forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                                       Emergency_CHF_Flat.mq5     |
//+------------------------------------------------------------------+
#property copyright "Generated Script"
#property version   "1.00"
#property description "Panic script to close all CHF positions and delete pending CHF orders"
#property script_show_inputs

#include <Trade\Trade.mqh>

input int MaxSlippage = 50; // Maximum allowed slippage in points

void OnStart()
  {
   CTrade trade;
   trade.SetDeviationInPoints(MaxSlippage);
   
   int closedCount = 0;
   int deletedCount = 0;
   
   // 1. Close all open positions containing "CHF"
   // We loop backward so closing a position doesn't shift the remaining indices
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0)
        {
         string symbol = PositionGetString(POSITION_SYMBOL);
         
         if(StringFind(symbol, "CHF") >= 0)
           {
            if(trade.PositionClose(ticket))
              {
               Print("Closed CHF Position: ", symbol, " | Ticket: ", ticket);
               closedCount++;
              }
            else
              {
               Print("Failed to close position: ", symbol, " | Error: ", GetLastError());
              }
           }
        }
     }
     
   // 2. Delete all pending orders containing "CHF"
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(ticket > 0)
        {
         string symbol = OrderGetString(ORDER_SYMBOL);
         
         if(StringFind(symbol, "CHF") >= 0)
           {
            if(trade.OrderDelete(ticket))
              {
               Print("Deleted CHF Pending Order: ", symbol, " | Ticket: ", ticket);
               deletedCount++;
              }
            else
              {
               Print("Failed to delete order: ", symbol, " | Error: ", GetLastError());
              }
           }
        }
     }
     
   Print("Emergency flat complete. Positions closed: ", closedCount, " | Orders deleted: ", deletedCount);
  }
//+------------------------------------------------------------------+

Code: Select all

using System;
using System.Linq;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class EmergencyCHFFlat : Robot
    {
        protected override void OnStart()
        {
            int closedCount = 0;
            int canceledCount = 0;

            Print("Executing Emergency CHF Flat...");

            // 1. Find and close all open positions containing "CHF"
            // We use .ToUpper() to account for broker suffixes (e.g., eurchf)
            // .ToArray() creates a snapshot so we don't get collection modification errors during iteration
            var chfPositions = Positions.Where(p => p.SymbolName.ToUpper().Contains("CHF")).ToArray();
            
            foreach (var position in chfPositions)
            {
                TradeResult result = ClosePosition(position);
                
                if (result.IsSuccessful)
                {
                    Print("Closed CHF Position: {0} | ID: {1}", position.SymbolName, position.Id);
                    closedCount++;
                }
                else
                {
                    Print("Failed to close position: {0} | Error: {1}", position.SymbolName, result.Error);
                }
            }

            // 2. Find and cancel all pending orders containing "CHF"
            var chfOrders = PendingOrders.Where(o => o.SymbolName.ToUpper().Contains("CHF")).ToArray();
            
            foreach (var order in chfOrders)
            {
                TradeResult result = CancelPendingOrder(order);
                
                if (result.IsSuccessful)
                {
                    Print("Canceled CHF Pending Order: {0} | ID: {1}", order.SymbolName, order.Id);
                    canceledCount++;
                }
                else
                {
                    Print("Failed to cancel order: {0} | Error: {1}", order.SymbolName, result.Error);
                }
            }

            Print("Emergency flat complete. Positions closed: {0} | Orders canceled: {1}", closedCount, canceledCount);
            
            // Stop the cBot immediately so it acts exactly like a one-time execution script
            Stop();
        }
    }
}

Code: Select all

using System;
using System.Linq;
using System.Threading;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class EmergencyFlatPro : Robot
    {
        [Parameter("Target Asset (e.g. CHF, USD)", DefaultValue = "CHF", Group = "Filter")]
        public string TargetAsset { get; set; }

        [Parameter("Max Retries on Reject", DefaultValue = 3, MinValue = 0, Group = "Execution")]
        public int MaxRetries { get; set; }

        [Parameter("Play Sound on Completion", DefaultValue = true, Group = "Notifications")]
        public bool PlaySoundAlert { get; set; }

        // Tracks active async operations to prevent premature cBot termination
        private int _pendingOperations;

        protected override void OnStart()
        {
            if (string.IsNullOrWhiteSpace(TargetAsset))
            {
                Print("❌ ERROR: Target asset cannot be empty.");
                Stop();
                return;
            }

            string filter = TargetAsset.ToUpper();
            
            // Take immediate snapshots of the collections
            var targetPositions = Positions.Where(p => p.SymbolName.ToUpper().Contains(filter)).ToArray();
            var targetOrders = PendingOrders.Where(o => o.SymbolName.ToUpper().Contains(filter)).ToArray();

            if (targetPositions.Length == 0 && targetOrders.Length == 0)
            {
                Print("ℹ️ INFO: No open positions or pending orders found for {0}. Standing by.", filter);
                Stop();
                return;
            }

            Print("🚨 EMERGENCY PROTOCOL INITIATED: Flattening {0} exposure concurrently...", filter);
            _pendingOperations = targetPositions.Length + targetOrders.Length;

            // Fire all requests simultaneously. Do NOT await them.
            foreach (var position in targetPositions)
            {
                AttemptClosePosition(position, 0);
            }

            foreach (var order in targetOrders)
            {
                AttemptCancelOrder(order, 0);
            }
        }

        private void AttemptClosePosition(Position position, int attemptCount)
        {
            ClosePositionAsync(position, result => 
            {
                if (result.IsSuccessful)
                {
                    Print("✅ SUCCESS: Closed Position {0} (ID: {1})", position.SymbolName, position.Id);
                    CheckCompletion();
                }
                else
                {
                    if (attemptCount < MaxRetries)
                    {
                        Print("⚠️ WARNING: FAILED to close {0} (ID: {1}) [{2}]. Retrying {3}/{4}...", 
                            position.SymbolName, position.Id, result.Error, attemptCount + 1, MaxRetries);
                            
                        AttemptClosePosition(position, attemptCount + 1);
                    }
                    else
                    {
                        Print("❌ FATAL: Failed to close {0} (ID: {1}) after {2} attempts. Error: {3}", 
                            position.SymbolName, position.Id, MaxRetries, result.Error);
                        CheckCompletion();
                    }
                }
            });
        }

        private void AttemptCancelOrder(PendingOrder order, int attemptCount)
        {
            CancelPendingOrderAsync(order, result => 
            {
                if (result.IsSuccessful)
                {
                    Print("✅ SUCCESS: Canceled Order {0} (ID: {1})", order.SymbolName, order.Id);
                    CheckCompletion();
                }
                else
                {
                    if (attemptCount < MaxRetries)
                    {
                        Print("⚠️ WARNING: FAILED to cancel order {0} (ID: {1}) [{2}]. Retrying {3}/{4}...", 
                            order.SymbolName, order.Id, result.Error, attemptCount + 1, MaxRetries);
                            
                        AttemptCancelOrder(order, attemptCount + 1);
                    }
                    else
                    {
                        Print("❌ FATAL: Failed to cancel order {0} (ID: {1}) after {2} attempts. Error: {3}", 
                            order.SymbolName, order.Id, MaxRetries, result.Error);
                        CheckCompletion();
                    }
                }
            });
        }

        private void CheckCompletion()
        {
            // Thread-safe decrement just in case the broker implementation 
            // fires callbacks from a different thread pool worker
            int remaining = Interlocked.Decrement(ref _pendingOperations);
            
            if (remaining <= 0)
            {
                Print("🏁 EMERGENCY PROTOCOL COMPLETE. All requested operations have resolved.");
                
                if (PlaySoundAlert)
                {
                    // Triggers the standard platform alert sound
                    Notifications.PlaySound(SoundType.Alert); 
                }
                
                // Only turn off the cBot once all callbacks are finished
                Stop();
            }
        }
    }
}