AI_auto_traders_JBS/Adaptive_MultiMarket_EA_v1.mq5

//+------------------------------------------------------------------+
//| Adaptive MultiMarket EA v1.00                                   |
//| Prototype based on the first five user-defined feature groups.  |
//| AI is optional and OFF by default; configure a compatible local  |
//| HTTP service to enable it.                                       |
//+------------------------------------------------------------------+
#property strict
#property version   "1.00"
#property description "Multi-symbol configurable EA: technical/momentum confirmation, ATR exits, recovery sizing, profit lock, CSV log."
#include <Trade/Trade.mqh>
CTrade trade;

//--- General
input ulong  InpMagicNumber=2026110201;
input bool   InpAllowBuy=true;
input bool   InpAllowSell=true;
input int    InpMaxSlippagePoints=30;
input bool   InpOnePositionPerSymbol=true;
input bool   InpUseGlobalRecoveryLock=true;
input int    InpLossesBeforeGlobalLock=3; // lock other new entries after 3 consecutive losses, starting with recovery trade #4

//--- Confirmation switches (any selected filters must pass)
input bool   InpUseTechnicalConfirmation=true;
input bool   InpUseMomentumConfirmation=true;
input bool   InpUseAIConfirmation=false; // OFF until a compatible local/API endpoint is configured
input double InpAIMinProbability=51.0;
input string InpAIEndpoint="";           // HTTP endpoint; response should contain buy_probability and sell_probability numbers
input int    InpAIRequestTimeoutMs=2500;
input int    InpAIHorizonMinutes=15;       // 15, 30 or 60
input int    InpSignalCheckSeconds=5;    // evaluate a fresh signal every five minutes

//--- Indicators / technical filters
input ENUM_TIMEFRAMES InpTrendTF1=PERIOD_H1;
input ENUM_TIMEFRAMES InpTrendTF2=PERIOD_M15;
input ENUM_TIMEFRAMES InpFastTF=PERIOD_M5;
input int    InpSMAFast=14;
input int    InpSMASlow=21;
input int    InpADXPeriod=14;
input double InpADXMinimum=18.0;
input int    InpRSIPeriod=14;
input double InpRSIBuyMinimum=52.0;
input double InpRSISellMaximum=48.0;
input int    InpMACDFast=12;
input int    InpMACDSlow=26;
input int    InpMACDSignal=9;
input int    InpATRPeriod=14;

//--- Momentum: Points mode or ADR/ratio mode
input bool   InpUseAutomaticADRMovement=true;
input int    InpADRDays=30;
input double InpADRDivisor=200.0;
input double InpManualMovementPoints=15.0;
input int    InpMomentumWindowSeconds=60; // 30 or 60
input double InpMomentumMultiplier=1.0;

//--- ATR exits / manual exits
input bool   InpUseATRStops=true;
input double InpSL_ATR_Multiplier=1.5;
input double InpTP_ATR_Multiplier=2.0;
input double InpManualSLPoints=300.0;
input double InpManualTPPoints=400.0;

//--- Lot sizing and loss recovery
input bool   InpAutoRiskLot=true;
input bool   InpRiskUseEquity=false;
input double InpRiskPercent=1.0;
input double InpManualLot=0.01;
input double InpLossLotMultiplier=2.0;
input double InpMinimumLot=0.01;
input double InpMaximumLot=5.0;

//--- Position management
input bool   InpEnableProfitLock=true;
input double InpLockStartPercent=60.0;
input double InpLockStartSLPercent=30.0;
input double InpLockStepPercent=10.0;
input double InpLockStepSLStart=30.0;
input double InpLockAt95Percent=85.0;
input double InpPost95TrailKeepPercent=32.0;
input bool   InpExtendTPAfter95=true;
input double InpExtendedTP_ATR_Multiplier=3.0;

//--- Reporting
input bool   InpEnableCSVReport=true;
input bool   InpSeparateReportByDate=true;
input string InpReportFolder="AdaptiveEA";

int hFast1=INVALID_HANDLE,hSlow1=INVALID_HANDLE,hFast2=INVALID_HANDLE,hSlow2=INVALID_HANDLE;
int hADX=INVALID_HANDLE,hRSI=INVALID_HANDLE,hMACD=INVALID_HANDLE,hATR=INVALID_HANDLE;
datetime g_lastSignalCheck=0;
double g_recentBid=0.0;
datetime g_recentTickTime=0;
double g_momentumStartBid=0.0;
datetime g_momentumStartTime=0;
string g_symbol;

string Key(const string suffix){ return "AM_EA_"+(string)InpMagicNumber+"_"+g_symbol+"_"+suffix; }
string GlobalLockKey(){ return "AM_EA_"+(string)InpMagicNumber+"_GLOBAL_LOCK"; }
string GlobalOwnerKey(){ return "AM_EA_"+(string)InpMagicNumber+"_GLOBAL_OWNER"; }
 double SymbolCode(){ double h=0.0; for(int i=0;i<StringLen(g_symbol);i++) h=h*31.0+(double)StringGetCharacter(g_symbol,i); return h; }

bool ReadBuffer(const int handle,const int buffer,const int shift,double &value)
{
   if(handle==INVALID_HANDLE) return false;
   double a[]; ArraySetAsSeries(a,true);
   if(CopyBuffer(handle,buffer,shift,1,a)!=1) return false;
   if(!MathIsValidNumber(a[0])) return false;
   value=a[0]; return true;
}

double NormalizeVolume(double lots)
{
   double step=SymbolInfoDouble(g_symbol,SYMBOL_VOLUME_STEP);
   double minv=SymbolInfoDouble(g_symbol,SYMBOL_VOLUME_MIN);
   double maxv=SymbolInfoDouble(g_symbol,SYMBOL_VOLUME_MAX);
   if(step<=0) step=0.01;
   minv=MathMax(minv,InpMinimumLot); maxv=MathMin(maxv,InpMaximumLot);
   lots=MathMax(minv,MathMin(maxv,lots));
   lots=MathFloor(lots/step+1e-8)*step;
   int digits=2; if(step<0.01) digits=3; if(step<0.001) digits=4;
   return NormalizeDouble(lots,digits);
}

int ConsecutiveLosses()
{
   if(!HistorySelect(0,TimeCurrent())) return 0;
   int losses=0; ulong lastSeen=0;
   for(int i=HistoryDealsTotal()-1;i>=0;i--)
   {
      ulong d=HistoryDealGetTicket(i); if(d==0) continue;
      if(HistoryDealGetString(d,DEAL_SYMBOL)!=g_symbol) continue;
      if((ulong)HistoryDealGetInteger(d,DEAL_MAGIC)!=InpMagicNumber) continue;
      ENUM_DEAL_ENTRY e=(ENUM_DEAL_ENTRY)HistoryDealGetInteger(d,DEAL_ENTRY);
      if(e!=DEAL_ENTRY_OUT && e!=DEAL_ENTRY_OUT_BY) continue;
      if(d==lastSeen) continue; lastSeen=d;
      double net=HistoryDealGetDouble(d,DEAL_PROFIT)+HistoryDealGetDouble(d,DEAL_SWAP)+HistoryDealGetDouble(d,DEAL_COMMISSION);
      if(net<0.0) losses++; else if(net>0.0) break;
   }
   return losses;
}

bool HasOurPosition()
{
   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket=PositionGetTicket(i); if(ticket==0) continue;
      if(PositionGetString(POSITION_SYMBOL)==g_symbol && (ulong)PositionGetInteger(POSITION_MAGIC)==InpMagicNumber) return true;
   }
   return false;
}

bool GlobalLockActive()
{
   if(!InpUseGlobalRecoveryLock) return false;
   if(!GlobalVariableCheck(GlobalLockKey())) return false;
   return GlobalVariableGet(GlobalLockKey())>0.5;
}

void SetGlobalLock(const bool on){ if(InpUseGlobalRecoveryLock){ GlobalVariableSet(GlobalLockKey(),on?1.0:0.0); if(on) GlobalVariableSet(GlobalOwnerKey(),SymbolCode()); } }

bool GetATR(double &atr){ return ReadBuffer(hATR,0,1,atr) && atr>0.0; }

double AverageDailyRange()
{
   int n=MathMax(1,InpADRDays); MqlRates rates[]; ArraySetAsSeries(rates,true);
   int got=CopyRates(g_symbol,PERIOD_D1,1,n,rates);
   if(got<=0) return 0.0;
   double sum=0.0; int count=0;
   for(int i=0;i<got;i++){ double r=rates[i].high-rates[i].low; if(r>0){sum+=r;count++;} }
   if(count==0) return 0.0;
   return sum/(double)count;
}

double RequiredMovementPrice()
{
   if(InpUseAutomaticADRMovement)
   {
      double adr=AverageDailyRange();
      if(adr>0.0 && InpADRDivisor>0.0) return (adr/InpADRDivisor)*InpMomentumMultiplier;
   }
   return InpManualMovementPoints*_Point*InpMomentumMultiplier;
}

bool TechnicalSignal(int &direction,double &atr,double &rsi,double &adx,double &macdMain,double &macdSignal)
{
   direction=0;
   double f1,s1,f2,s2;
   if(!ReadBuffer(hFast1,0,1,f1)||!ReadBuffer(hSlow1,0,1,s1)||!ReadBuffer(hFast2,0,1,f2)||!ReadBuffer(hSlow2,0,1,s2)) return false;
   if(!ReadBuffer(hADX,0,1,adx)||!ReadBuffer(hRSI,0,1,rsi)||!ReadBuffer(hMACD,0,1,macdMain)||!ReadBuffer(hMACD,1,1,macdSignal)||!GetATR(atr)) return false;
   double close1=iClose(g_symbol,InpTrendTF2,1); if(close1<=0) return false;
   bool buy=(f1>s1 && f2>s2 && close1>f2 && adx>=InpADXMinimum && rsi>=InpRSIBuyMinimum && macdMain>macdSignal);
   bool sell=(f1<s1 && f2<s2 && close1<f2 && adx>=InpADXMinimum && rsi<=InpRSISellMaximum && macdMain<macdSignal);
   if(buy) direction=1; else if(sell) direction=-1;
   return true;
}

bool MomentumPass(const int direction,double &moved)
{
   moved=0.0; if(!InpUseMomentumConfirmation) return true;
   MqlTick tick; if(!SymbolInfoTick(g_symbol,tick)) return false;
   datetime now=TimeCurrent();
   if(g_momentumStartTime==0 || (now-g_momentumStartTime)>MathMax(1,InpMomentumWindowSeconds))
   { g_momentumStartTime=now; g_momentumStartBid=tick.bid; return false; }
   moved=MathAbs(tick.bid-g_momentumStartBid);
   double need=RequiredMovementPrice(); if(need<=0) return false;
   if(direction>0) return (tick.bid-g_momentumStartBid)>=need;
   if(direction<0) return (g_momentumStartBid-tick.bid)>=need;
   return false;
}

// Optional HTTP JSON service. Add endpoint to MT5: Tools > Options > Expert Advisors > Allow WebRequest.
bool AIConfirm(const int direction,double &probability)
{
   probability=0.0;
   if(!InpUseAIConfirmation) return true;
   if(StringLen(InpAIEndpoint)==0) return false;
   string payload="{\"symbol\":\""+g_symbol+"\",\"horizon_minutes\":"+(string)InpAIHorizonMinutes+",\"direction\":\""+(direction>0?"BUY":"SELL")+"\"}";
   char data[],result[]; StringToCharArray(payload,data,0,WHOLE_ARRAY,CP_UTF8);
   string headers="Content-Type: application/json\r\n"; string response_headers;
   ResetLastError(); int code=WebRequest("POST",InpAIEndpoint,headers,InpAIRequestTimeoutMs,data,result,response_headers);
   if(code<200 || code>=300) return false;
   string body=CharArrayToString(result,0,WHOLE_ARRAY,CP_UTF8);
   string key=(direction>0?"buy_probability":"sell_probability"); int pos=StringFind(body,key);
   if(pos<0) return false; pos=StringFind(body,":",pos); if(pos<0) return false;
   string tail=StringSubstr(body,pos+1); StringReplace(tail," ",""); StringReplace(tail,"\"","");
   int end=StringFind(tail,","); if(end<0) end=StringFind(tail,"}"); if(end<0) return false;
   probability=StringToDouble(StringSubstr(tail,0,end));
   return probability>=InpAIMinProbability;
}

bool CalculateStops(const int direction,const double atr,double &sl,double &tp)
{
   MqlTick t; if(!SymbolInfoTick(g_symbol,t)) return false;
   double slDist,tpDist;
   if(InpUseATRStops){ slDist=atr*InpSL_ATR_Multiplier; tpDist=atr*InpTP_ATR_Multiplier; }
   else { slDist=InpManualSLPoints*_Point; tpDist=InpManualTPPoints*_Point; }
   if(slDist<=0||tpDist<=0) return false;
   int digits=(int)SymbolInfoInteger(g_symbol,SYMBOL_DIGITS);
   if(direction>0){ sl=NormalizeDouble(t.ask-slDist,digits); tp=NormalizeDouble(t.ask+tpDist,digits); }
   else { sl=NormalizeDouble(t.bid+slDist,digits); tp=NormalizeDouble(t.bid-tpDist,digits); }
   long stops=SymbolInfoInteger(g_symbol,SYMBOL_TRADE_STOPS_LEVEL); double minDist=stops*_Point;
   if(direction>0 && (t.ask-sl<minDist || tp-t.ask<minDist)) return false;
   if(direction<0 && (sl-t.bid<minDist || t.bid-tp<minDist)) return false;
   return true;
}

double CalculateLots(const double slDistance)
{
   int losses=ConsecutiveLosses();
   double base=InpManualLot;
   if(InpAutoRiskLot)
   {
      double capital=InpRiskUseEquity?AccountInfoDouble(ACCOUNT_EQUITY):AccountInfoDouble(ACCOUNT_BALANCE);
      double riskMoney=capital*InpRiskPercent/100.0;
      double tickVal=SymbolInfoDouble(g_symbol,SYMBOL_TRADE_TICK_VALUE);
      double tickSize=SymbolInfoDouble(g_symbol,SYMBOL_TRADE_TICK_SIZE);
      if(tickVal>0 && tickSize>0 && slDistance>0) base=riskMoney/(slDistance/tickSize*tickVal);
   }
   double lots=base*MathPow(MathMax(1.0,InpLossLotMultiplier),losses);
   return NormalizeVolume(lots);
}

void WriteReport(const string event,const int direction,const double probability,const double rsi,const double adx,const double macd,const double atr,const double moved,const double lots,const double price,const double sl,const double tp,const double pnl=0.0)
{
   if(!InpEnableCSVReport) return;
   string day=TimeToString(TimeCurrent(),TIME_DATE); StringReplace(day,".","");
   string filename=InpReportFolder+"/"+g_symbol+"_"+day+".csv";
   int flags=FILE_READ|FILE_WRITE|FILE_CSV|FILE_ANSI|FILE_SHARE_READ|FILE_SHARE_WRITE;
   int f=FileOpen(filename,flags,';'); if(f==INVALID_HANDLE) return;
   if(FileSize(f)==0) FileWrite(f,"Time","Event","Symbol","Direction","AI_Probability","RSI","ADX","MACD_Main","ATR","Momentum_PriceMove","Lots","Price","SL","TP","NetPnL");
   FileSeek(f,0,SEEK_END);
   FileWrite(f,TimeToString(TimeCurrent(),TIME_DATE|TIME_SECONDS),event,g_symbol,(direction>0?"BUY":(direction<0?"SELL":"NA")),DoubleToString(probability,2),DoubleToString(rsi,2),DoubleToString(adx,2),DoubleToString(macd,6),DoubleToString(atr,_Digits),DoubleToString(moved,_Digits),DoubleToString(lots,2),DoubleToString(price,_Digits),DoubleToString(sl,_Digits),DoubleToString(tp,_Digits),DoubleToString(pnl,2));
   FileClose(f);
}

void ManagePosition()
{
   if(!InpEnableProfitLock) return;
   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket=PositionGetTicket(i); if(ticket==0) continue;
      if(PositionGetString(POSITION_SYMBOL)!=g_symbol || (ulong)PositionGetInteger(POSITION_MAGIC)!=InpMagicNumber) continue;
      long type=PositionGetInteger(POSITION_TYPE); bool buy=(type==POSITION_TYPE_BUY);
      double entry=PositionGetDouble(POSITION_PRICE_OPEN),sl=PositionGetDouble(POSITION_SL),tp=PositionGetDouble(POSITION_TP);
      double current=buy?SymbolInfoDouble(g_symbol,SYMBOL_BID):SymbolInfoDouble(g_symbol,SYMBOL_ASK);
      double initialTP=GlobalVariableCheck(Key("INITIAL_TP"))?GlobalVariableGet(Key("INITIAL_TP")):tp;
      double initialSL=GlobalVariableCheck(Key("INITIAL_SL"))?GlobalVariableGet(Key("INITIAL_SL")):sl;
      double full=MathAbs(initialTP-entry); if(full<=0) continue;
      double progress=(buy?(current-entry):(entry-current))/full*100.0;
      double desiredSL=sl;
      if(progress>=InpLockAt95Percent)
      {
         double locked=full*(InpLockAt95Percent/100.0);
         double extra=MathMax(0.0,(buy?(current-entry):(entry-current))-locked);
         double lockDist=locked+extra*InpPost95TrailKeepPercent/100.0;
         desiredSL=buy?entry+lockDist:entry-lockDist;
         if(InpExtendTPAfter95)
         {
            double atr; if(GetATR(atr))
            {
               double ext=atr*InpExtendedTP_ATR_Multiplier;
               double newTP=buy?current+ext:current-ext;
               if(buy && newTP>tp) tp=newTP; if(!buy && newTP<tp) tp=newTP;
            }
         }
      }
      else if(progress>=InpLockStartPercent)
      {
         double step=InpLockStepPercent; if(step<=0) step=10;
         double stage=MathFloor((progress-InpLockStartPercent)/step);
         double lockPct=InpLockStepSLStart+stage*step;
         if(progress>=InpLockAt95Percent) lockPct=InpLockAt95Percent;
         lockPct=MathMin(lockPct,InpLockAt95Percent);
         if(lockPct<InpLockStartSLPercent) lockPct=InpLockStartSLPercent;
         desiredSL=buy?entry+full*lockPct/100.0:entry-full*lockPct/100.0;
      }
      int digits=(int)SymbolInfoInteger(g_symbol,SYMBOL_DIGITS); desiredSL=NormalizeDouble(desiredSL,digits);
      bool improve=(buy?(desiredSL>sl && desiredSL<current):(sl==0.0 || (desiredSL<sl && desiredSL>current)));
      if(improve || (tp!=PositionGetDouble(POSITION_TP))) trade.PositionModify(ticket,improve?desiredSL:sl,tp);
   }
}

void TryOpenTrade()
{
   if(InpOnePositionPerSymbol && HasOurPosition()) return;
   if(GlobalLockActive()) return;
   int dir=0; double atr=0,rsi=0,adx=0,macd=0,macds=0;
   if(InpUseTechnicalConfirmation)
   {
      if(!TechnicalSignal(dir,atr,rsi,adx,macd,macds) || dir==0) return;
   }
   else
   {
      if(!GetATR(atr)) atr=SymbolInfoDouble(g_symbol,SYMBOL_POINT)*100.0;
      // Without technical filter, direction is inferred from short-term SMA on M5.
      double a=iClose(g_symbol,InpFastTF,1),b=iClose(g_symbol,InpFastTF,2); if(a==0||b==0||a==b) return; dir=(a>b?1:-1);
   }
   if((dir>0&&!InpAllowBuy)||(dir<0&&!InpAllowSell)) return;
   double prob=0.0;
   if(InpUseAIConfirmation && !AIConfirm(dir,prob)) return;
   double moved=0.0;
   if(InpUseMomentumConfirmation && !MomentumPass(dir,moved)) return;
   double sl,tp; if(!CalculateStops(dir,atr,sl,tp)) return;
   double price=(dir>0?SymbolInfoDouble(g_symbol,SYMBOL_ASK):SymbolInfoDouble(g_symbol,SYMBOL_BID));
   double lots=CalculateLots(MathAbs(price-sl)); if(lots<=0) return;
   trade.SetExpertMagicNumber(InpMagicNumber); trade.SetDeviationInPoints(InpMaxSlippagePoints);
   bool ok=(dir>0?trade.Buy(lots,g_symbol,0.0,sl,tp,"AdaptiveEA BUY"):trade.Sell(lots,g_symbol,0.0,sl,tp,"AdaptiveEA SELL"));
   if(ok)
   {
      GlobalVariableSet(Key("INITIAL_TP"),tp); GlobalVariableSet(Key("INITIAL_SL"),sl);
      if(ConsecutiveLosses()>=InpLossesBeforeGlobalLock) SetGlobalLock(true);
      WriteReport("OPEN",dir,prob,rsi,adx,macd,atr,moved,lots,price,sl,tp,0.0);
   }
}

int OnInit()
{
   g_symbol=_Symbol;
   hFast1=iMA(g_symbol,InpTrendTF1,InpSMAFast,0,MODE_SMA,PRICE_CLOSE);
   hSlow1=iMA(g_symbol,InpTrendTF1,InpSMASlow,0,MODE_SMA,PRICE_CLOSE);
   hFast2=iMA(g_symbol,InpTrendTF2,InpSMAFast,0,MODE_SMA,PRICE_CLOSE);
   hSlow2=iMA(g_symbol,InpTrendTF2,InpSMASlow,0,MODE_SMA,PRICE_CLOSE);
   hADX=iADX(g_symbol,InpFastTF,InpADXPeriod); hRSI=iRSI(g_symbol,InpFastTF,InpRSIPeriod,PRICE_CLOSE);
   hMACD=iMACD(g_symbol,InpFastTF,InpMACDFast,InpMACDSlow,InpMACDSignal,PRICE_CLOSE);
   hATR=iATR(g_symbol,InpFastTF,InpATRPeriod);
   trade.SetExpertMagicNumber(InpMagicNumber); trade.SetDeviationInPoints(InpMaxSlippagePoints);
   if(InpEnableCSVReport) FolderCreate(InpReportFolder);
   EventSetTimer(1);
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
   if(hFast1!=INVALID_HANDLE) IndicatorRelease(hFast1); if(hSlow1!=INVALID_HANDLE) IndicatorRelease(hSlow1);
   if(hFast2!=INVALID_HANDLE) IndicatorRelease(hFast2); if(hSlow2!=INVALID_HANDLE) IndicatorRelease(hSlow2);
   if(hADX!=INVALID_HANDLE) IndicatorRelease(hADX); if(hRSI!=INVALID_HANDLE) IndicatorRelease(hRSI);
   if(hMACD!=INVALID_HANDLE) IndicatorRelease(hMACD); if(hATR!=INVALID_HANDLE) IndicatorRelease(hATR);
}

void OnTick()
{
   ManagePosition();

   int checkInterval=MathMax(1,InpSignalCheckSeconds);

   if(InpUseMomentumConfirmation)
   {
      int maxInterval=MathMax(1,InpMomentumWindowSeconds/6);
      checkInterval=MathMin(checkInterval,maxInterval);
   }

   datetime now=TimeCurrent();

   if(g_lastSignalCheck==0 ||
      (now-g_lastSignalCheck)>=checkInterval)
   {
      g_lastSignalCheck=now;
      TryOpenTrade();
   }
}

void OnTimer()
{
   ManagePosition();
   // Global lock is released by the recovery-owner chart after its profitable recovery close.
}

void OnTradeTransaction(const MqlTradeTransaction &trans,const MqlTradeRequest &request,const MqlTradeResult &result)
{
   if(trans.type!=TRADE_TRANSACTION_DEAL_ADD || trans.deal==0) return;
   if(!HistoryDealSelect(trans.deal)) return;
   if(HistoryDealGetString(trans.deal,DEAL_SYMBOL)!=g_symbol) return;
   if((ulong)HistoryDealGetInteger(trans.deal,DEAL_MAGIC)!=InpMagicNumber) return;
   ENUM_DEAL_ENTRY e=(ENUM_DEAL_ENTRY)HistoryDealGetInteger(trans.deal,DEAL_ENTRY);
   if(e!=DEAL_ENTRY_OUT && e!=DEAL_ENTRY_OUT_BY) return;
   double pnl=HistoryDealGetDouble(trans.deal,DEAL_PROFIT)+HistoryDealGetDouble(trans.deal,DEAL_SWAP)+HistoryDealGetDouble(trans.deal,DEAL_COMMISSION);
   if(pnl>0.0 && ConsecutiveLosses()==0 && GlobalLockActive() && GlobalVariableCheck(GlobalOwnerKey()) && GlobalVariableGet(GlobalOwnerKey())==SymbolCode()) SetGlobalLock(false);
   WriteReport("CLOSE",0,0,0,0,0,0,0,HistoryDealGetDouble(trans.deal,DEAL_VOLUME),HistoryDealGetDouble(trans.deal,DEAL_PRICE),0,0,pnl);
}
//+------------------------------------------------------------------+