Spread Filters for Scalping: When Not to Enter

[PTScalper]

Architectural Mechanics

RegexOptions.Singleline: This is the keystone of the DOM replacement. By default, standard Regex stops reading when it hits a line break (\n). Because your HTML summary block spans roughly 15 lines of code, standard Regex would fail to find it. The Singleline modifier forces the Regex engine to treat the entire multi-line HTML document as one giant continuous string, allowing .*? to correctly consume everything between <!-- SUMMARY START --> and <!-- SUMMARY END -->.

Time-Synchronized Aggregation: Because the file rotates automatically at the start of a new month ($"DetailedStatement_{DateTime.Now:yyyy_MM}.html"), querying the Account.Balance directly would be misleading—it includes your lifetime account history. The LINQ query History.Where(t => t.ClosingTime.Month == DateTime.Now.Month) mathematically synchronizes the summary block's "Closed P/L" to perfectly match only the trades printed in that specific monthly HTML file.

Decoupled Float Calculations: Account.Equity - Account.Balance is dynamically calculated rather than relying on iterating through active positions. This ensures that the report captures the absolute, true-to-the-millisecond drawdown of the account at the exact moment the screenshot and Telegram dispatch are triggered.

[PTScalper]

To serve the HTML file over your local Wi-Fi network, you must embed a lightweight HTTP server directly into the cBot. C#'s System.Net.HttpListener is perfect for this, but it introduces two severe architectural risks if implemented incorrectly: Thread Blocking (the server loop freezing the trading engine) and File Contention (the server trying to read the HTML file at the exact millisecond the trading engine is updating it).

[PTScalper]

Here is the complete, thread-safe architecture to integrate a local web server into your cBot:

Code: Select all

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using cAlgo.API;

namespace cAlgo.Robots
{
    // AccessRights.FullAccess is MANDATORY to open network ports
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FullAccess)]
    public partial class InteractiveFiatHUD : Robot
    {
        [Parameter("Enable Web Server", Group = "Local Server", DefaultValue = true)]
        public bool EnableWebServer { get; set; }

        [Parameter("Server Port", Group = "Local Server", DefaultValue = 8080)]
        public int ServerPort { get; set; }

        // Server lifecycle management
        private HttpListener _httpServer;
        private CancellationTokenSource _serverCancellationToken;

        protected override void OnStart()
        {
            // ... (Your existing OnStart logic, like Timer.Start)

            if (EnableWebServer)
            {
                StartLocalWebServer();
            }
        }

        protected override void OnStop()
        {
            // CRITICAL: You must explicitly kill the server when the bot stops,
            // otherwise the port remains locked by the zombie thread in Windows.
            if (_httpServer != null && _httpServer.IsListening)
            {
                _serverCancellationToken.Cancel();
                _httpServer.Stop();
                _httpServer.Close();
                Print("[Web Server] Shut down successfully.");
            }
        }

        private void StartLocalWebServer()
        {
            try
            {
                _httpServer = new HttpListener();
                
                // The "+" binds to all network interfaces (Localhost, Ethernet, Wi-Fi)
                // Note: Windows requires cTrader to be run as Administrator for this prefix.
                _httpServer.Prefixes.Add($"http://+:{ServerPort}/");
                _httpServer.Start();

                _serverCancellationToken = new CancellationTokenSource();
                
                // Fire and forget the infinite listening loop onto a background thread
                Task.Run(() => ServerListenLoopAsync(_serverCancellationToken.Token));
                
                Print($"[Web Server] Active. Connect via Wi-Fi at http://[YOUR_PC_IP]:{ServerPort}/");
            }
            catch (HttpListenerException ex) when (ex.ErrorCode == 5) // Access Denied
            {
                Print("[Web Server Error] Access Denied. You MUST run cTrader as Administrator to open ports.");
            }
            catch (Exception ex)
            {
                Print($"[Web Server Error] {ex.Message}");
            }
        }

        private async Task ServerListenLoopAsync(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                try
                {
                    // Asynchronously wait for a phone/browser to connect
                    HttpListenerContext context = await _httpServer.GetContextAsync();

                    // Offload the specific request to ANOTHER background worker 
                    // so the server instantly goes back to listening for more connections.
                    _ = Task.Run(() => ProcessHttpRequestAsync(context));
                }
                catch (HttpListenerException)
                {
                    // This exception naturally fires when _httpServer.Stop() is called during teardown.
                    break;
                }
                catch (ObjectDisposedException)
                {
                    break; 
                }
            }
        }

        private async Task ProcessHttpRequestAsync(HttpListenerContext context)
        {
            HttpListenerResponse response = context.Response;

            try
            {
                string fileName = $"DetailedStatement_{DateTime.Now:yyyy_MM}.html";
                string fullPath = Path.Combine(HtmlDirectoryPath, fileName);

                if (!File.Exists(fullPath))
                {
                    byte[] errorBytes = Encoding.UTF8.GetBytes("<h2>Statement not generated yet.</h2>");
                    response.StatusCode = 404;
                    await response.OutputStream.WriteAsync(errorBytes, 0, errorBytes.Length);
                    return;
                }

                string htmlContent;

                // THREAD SYNCHRONIZATION: 
                // We use the EXACT same lock created for the HTML writer. 
                // If the bot is currently writing a basket closure, the web server waits milliseconds 
                // for it to finish before attempting to read, preventing an IOException crash.
                await _htmlFileLock.WaitAsync();
                try
                {
                    htmlContent = await File.ReadAllTextAsync(fullPath);
                }
                finally
                {
                    _htmlFileLock.Release();
                }

                // Construct and dispatch the HTTP OK Response
                byte[] responseBytes = Encoding.UTF8.GetBytes(htmlContent);
                response.ContentType = "text/html";
                response.ContentLength64 = responseBytes.Length;
                response.StatusCode = 200;

                await response.OutputStream.WriteAsync(responseBytes, 0, responseBytes.Length);
            }
            catch (Exception ex)
            {
                Print($"[Web Server Request Error] {ex.Message}");
                response.StatusCode = 500;
            }
            finally
            {
                // You MUST close the response, otherwise the browser on your phone hangs indefinitely
                response.Close();
            }
        }
    }
}

[PTScalper]

OS-Level Requirements (Crucial for Local Wi-Fi)

Because you are stepping into actual network infrastructure, your Windows environment enforces strict security barriers that code alone cannot bypass:

Administrative Privileges (HTTP.sys): Windows operates HttpListener on top of the kernel-mode HTTP.sys driver. Binding to the wildcard + IP address (which is required to serve files to external Wi-Fi devices rather than just localhost) strictly requires Administrative rights. You must right-click the cTrader shortcut and select "Run as Administrator", otherwise the cBot will instantly throw an Access Denied (Error 5) exception when you click start.

Windows Defender Firewall: By default, Windows blocks incoming connections from other devices on your LAN. You must open an inbound port rule:

Open Windows Defender Firewall -> Advanced Settings.

Inbound Rules -> New Rule -> Port -> TCP.

Specific local ports: 8080 (or whatever you set the parameter to).

Action: Allow the connection.

Apply to Domain, Private, and Public profiles.

[PTScalper]

Architectural Mechanics

Asynchronous Double-Offloading: Notice Task.Run(() => ServerListenLoopAsync) pushes the infinite while loop off the main execution thread. Then, inside the loop, _ = Task.Run(() => ProcessHttpRequestAsync(context)) pushes the actual file reading onto a third thread. If a request comes in and your hard drive takes 300ms to read the file, neither your trading engine nor your server's listening capabilities are delayed.

Contention Safety (_htmlFileLock): Reusing the SemaphoreSlim _htmlFileLock from your HTML generation logic ensures flawless integration. If your phone refreshes the page at the exact millisecond the bot executes a basket closure and tries to overwrite the DOM, the phone's request will silently queue up for a fraction of a second until the file is freed, rather than crashing the bot with a "File in Use" IOException.

Zombie Thread Prevention (CancellationToken): If you hit "Stop" on a cBot, cTrader abandons the bot's memory space but does not automatically kill background threads you manually spawned. If you don't call _serverCancellationToken.Cancel() and _httpServer.Stop() inside OnStop(), the port 8080 will remain permanently locked by your OS until you entirely restart cTrader.

[PTScalper]

To add an interactive equity curve without suffocating your cBot's CPU, you should utilize a Client-Side Rendering (CSR) architecture.

Instead of forcing your C# trading engine to continuously calculate chart coordinates and update massive JSON arrays via Regex, you inject a static block of JavaScript into the HTML file exactly once when the file is created.

Every time you open the page on your phone, the browser's JavaScript engine instantly reads the HTML table, calculates the cumulative running profit, and renders the Chart.js graph dynamically. This completely offloads the visual processing to your phone's processor.

[PTScalper]

Here is the updated HTML injection architecture:

Code: Select all

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using cAlgo.API;

namespace cAlgo.Robots
{
    public partial class InteractiveFiatHUD : Robot
    {
        private async Task AppendBatchedTradesToHtmlAsync(List<HistoricalTrade> batchedTrades)
        {
            await _htmlFileLock.WaitAsync();

            try
            {
                if (!Directory.Exists(HtmlDirectoryPath)) Directory.CreateDirectory(HtmlDirectoryPath);

                string fileName = $"DetailedStatement_{DateTime.Now:yyyy_MM}.html";
                string fullPath = Path.Combine(HtmlDirectoryPath, fileName);
                bool isNewFile = !File.Exists(fullPath);

                // 1. Build the new trade rows (Same as before)
                StringBuilder newRows = new StringBuilder();
                foreach (var t in batchedTrades)
                {
                    string typeColor = t.TradeType == TradeType.Buy ? "#0000ff" : "#ff0000";
                    double lotSize = t.VolumeInUnits / 100000.0; 

                    newRows.AppendLine($"<tr align=right>");
                    newRows.AppendLine($"<td>{t.PositionId}</td>");
                    newRows.AppendLine($"<td>{t.EntryTime:yyyy.MM.dd HH:mm:ss}</td>");
                    newRows.AppendLine($"<td style='color:{typeColor}'>{t.TradeType.ToString().ToLower()}</td>");
                    newRows.AppendLine($"<td>{lotSize:F2}</td>");
                    newRows.AppendLine($"<td align=left>{t.SymbolName}</td>");
                    newRows.AppendLine($"<td>{t.EntryPrice}</td>");
                    newRows.AppendLine($"<td>{t.ClosingTime:yyyy.MM.dd HH:mm:ss}</td>");
                    newRows.AppendLine($"<td>{t.ClosingPrice}</td>");
                    newRows.AppendLine($"<td class='profit-cell'>{t.NetProfit:F2}</td>"); // Added class for JS parsing
                    newRows.AppendLine($"</tr>");
                }

                string summaryBlock = BuildDynamicSummaryBlock();

                if (isNewFile)
                {
                    StringBuilder htmlDoc = new StringBuilder();
                    htmlDoc.AppendLine("<!DOCTYPE html><html><head><title>Statement</title>");
                    
                    // 2. INJECT CHART.JS CDN
                    htmlDoc.AppendLine("<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>");
                    
                    htmlDoc.AppendLine("<style>");
                    htmlDoc.AppendLine("body { font-family: Tahoma, sans-serif; font-size: 11px; margin: 20px; }");
                    htmlDoc.AppendLine("table { width: 100%; border-collapse: collapse; }");
                    htmlDoc.AppendLine("td, th { border: 1px solid #c0c0c0; padding: 3px; text-align: right; }");
                    htmlDoc.AppendLine("th { background-color: #e0e0e0; font-weight: bold; text-align: center; }");
                    htmlDoc.AppendLine(".header-table { width: 100%; border: none; margin-bottom: 20px; font-size: 16px; font-weight: bold; }");
                    htmlDoc.AppendLine(".header-table td { border: none; text-align: left; background-color: transparent; }");
                    htmlDoc.AppendLine(".chart-container { width: 100%; height: 250px; margin-bottom: 20px; }");
                    htmlDoc.AppendLine("</style></head><body>");

                    htmlDoc.AppendLine("<table class='header-table'><tr>");
                    htmlDoc.AppendLine($"<td>Account: {Account.Number}</td>");
                    htmlDoc.AppendLine($"<td style='text-align:right'>Currency: {Account.Asset.Name}</td>");
                    htmlDoc.AppendLine("</tr></table>");

                    // 3. INJECT THE CANVAS CONTAINER
                    htmlDoc.AppendLine("<div class='chart-container'><canvas id='equityChart'></canvas></div>");

                    htmlDoc.AppendLine("<table id='tradesTable'><thead><tr>");
                    htmlDoc.AppendLine("<th>Ticket</th><th>Open Time</th><th>Type</th><th>Size</th><th>Item</th>");
                    htmlDoc.AppendLine("<th>Price</th><th>Close Time</th><th>Price</th><th>Profit</th>");
                    htmlDoc.AppendLine("</tr></thead>");
                    
                    htmlDoc.AppendLine("<tbody>");
                    htmlDoc.Append(newRows.ToString());
                    htmlDoc.AppendLine("</tbody></table>");
                    
                    htmlDoc.AppendLine(summaryBlock);

                    // 4. INJECT THE CLIENT-SIDE RENDERING JAVASCRIPT
                    htmlDoc.AppendLine(BuildChartJavaScript());
                    
                    htmlDoc.AppendLine("</body></html>");

                    await File.WriteAllTextAsync(fullPath, htmlDoc.ToString());
                }
                else
                {
                    // Existing replacement logic
                    string existingHtml = await File.ReadAllTextAsync(fullPath);
                    if (existingHtml.Contains("</tbody>"))
                    {
                        existingHtml = existingHtml.Replace("</tbody>", newRows.ToString() + "\n</tbody>");
                    }
                    string regexPattern = @"<!-- SUMMARY START -->.*?<!-- SUMMARY END -->";
                    existingHtml = Regex.Replace(existingHtml, regexPattern, summaryBlock, RegexOptions.Singleline);
                    
                    await File.WriteAllTextAsync(fullPath, existingHtml);
                }
            }
            catch (Exception ex)
            {
                Print($"[HTML Logger Error] {ex.Message}");
            }
            finally
            {
                _htmlFileLock.Release();
            }
        }

        /// <summary>
        /// Generates the static JavaScript block that parses the table and renders the chart.
        /// </summary>
        private string BuildChartJavaScript()
        {
            StringBuilder js = new StringBuilder();
            js.AppendLine("<script>");
            js.AppendLine("document.addEventListener('DOMContentLoaded', function() {");
            js.AppendLine("    const cells = document.querySelectorAll('.profit-cell');");
            js.AppendLine("    let dataPoints = [0]; // Start curve at 0");
            js.AppendLine("    let labels = ['Start'];");
            js.AppendLine("    let cumulative = 0;");
            js.AppendLine("    let tradeCount = 0;");
            
            js.AppendLine("    cells.forEach(cell => {");
            js.AppendLine("        const profit = parseFloat(cell.innerText);");
            js.AppendLine("        if(!isNaN(profit)) {");
            js.AppendLine("            cumulative += profit;");
            js.AppendLine("            tradeCount++;");
            js.AppendLine("            dataPoints.push(cumulative);");
            js.AppendLine("            labels.push('Trade ' + tradeCount);");
            js.AppendLine("        }");
            js.AppendLine("    });");

            js.AppendLine("    const ctx = document.getElementById('equityChart').getContext('2d');");
            js.AppendLine("    const isProfitable = cumulative >= 0;");
            js.AppendLine("    const lineColor = isProfitable ? 'rgba(0, 122, 255, 1)' : 'rgba(255, 59, 48, 1)';");
            js.AppendLine("    const bgColor = isProfitable ? 'rgba(0, 122, 255, 0.1)' : 'rgba(255, 59, 48, 0.1)';");

            js.AppendLine("    new Chart(ctx, {");
            js.AppendLine("        type: 'line',");
            js.AppendLine("        data: {");
            js.AppendLine("            labels: labels,");
            js.AppendLine("            datasets: [{");
            js.AppendLine("                label: 'Cumulative P/L',");
            js.AppendLine("                data: dataPoints,");
            js.AppendLine("                borderColor: lineColor,");
            js.AppendLine("                backgroundColor: bgColor,");
            js.AppendLine("                borderWidth: 2,");
            js.AppendLine("                fill: true,");
            js.AppendLine("                tension: 0.1,");
            js.AppendLine("                pointRadius: 0,");
            js.AppendLine("                pointHitRadius: 10");
            js.AppendLine("            }]");
            js.AppendLine("        },");
            js.AppendLine("        options: {");
            js.AppendLine("            responsive: true,");
            js.AppendLine("            maintainAspectRatio: false,");
            js.AppendLine("            interaction: { mode: 'index', intersect: false },");
            js.AppendLine("            plugins: { legend: { display: false } },");
            js.AppendLine("            scales: { ");
            js.AppendLine("                x: { display: false },"); // Hides crowded X-axis labels
            js.AppendLine("                y: { grid: { color: '#e0e0e0' } }");
            js.AppendLine("            }");
            js.AppendLine("        }");
            js.AppendLine("    });");
            js.AppendLine("});");
            js.AppendLine("</script>");
            return js.ToString();
        }
    }
}

[PTScalper]

Architectural Mechanics

Zero-Overhead Maintenance: The C# code generates the <script> block only once, precisely when a new month begins and isNewFile == true. On subsequent batches throughout the month, C# only injects the raw <tr> table rows as it always did. The bot's execution speed remains absolutely unaffected by the addition of the chart.

Targeted DOM Parsing (.profit-cell): Notice the addition of class='profit-cell' to the final <td> in the row generation. This allows the JavaScript document.querySelectorAll('.profit-cell') to instantly extract an array of only the profit values. It prevents the JS from having to loop through and parse every single cell in the entire table, making the render nearly instantaneous on your phone.

Dynamic Color Switching: The JS logic const isProfitable = cumulative >= 0; dynamically changes the visual aesthetic of the entire chart. If your monthly aggregate is in profit, the line and fill are Apple-style blue. If the month drops into drawdown, the entire graph dynamically renders in hazard red, giving you an immediate visual cue when opening the page.

Responsive Canvas Constraints: The CSS .chart-container { width: 100%; height: 250px; } paired with Chart.js's maintainAspectRatio: false ensures the chart perfectly squashes to fit a mobile screen in portrait mode while stretching beautifully across a desktop monitor, without breaking the legacy MT4 table layout underneath it.

[PTScalper]

To implement a 5-second auto-refresh without ruining the mobile viewing experience, you must solve the Scroll Reset Problem. If you strictly use a standard HTML meta-refresh (<meta http-equiv="refresh" content="5">), the phone browser will snap back to the very top of the page every 5 seconds, making it impossible to scroll down and read older trades in your table.

You solve this by injecting a JavaScript snippet that writes your exact Y-axis scroll coordinates to the browser's sessionStorage milliseconds before the reload, and instantly scrolls you back to that exact pixel the moment the DOM re-renders.

[PTScalper]

Here is the isolated method and integration to inject into your cBot:

Code: Select all

using System;
using System.Text;
// ... (Your existing using statements)

namespace cAlgo.Robots
{
    public partial class InteractiveFiatHUD : Robot
    {
        // Add a parameter so you can adjust or disable the refresh rate from the cBot settings
        [Parameter("Auto-Refresh Interval (Seconds)", Group = "Local Server", DefaultValue = 5)]
        public int RefreshIntervalSeconds { get; set; }

        /// <summary>
        /// Generates the auto-refresh logic with scroll-state retention.
        /// </summary>
        private string BuildAutoRefreshJavaScript()
        {
            // If set to 0, disable the auto-refresh entirely
            if (RefreshIntervalSeconds <= 0) return string.Empty;

            int refreshMilliseconds = RefreshIntervalSeconds * 1000;

            StringBuilder js = new StringBuilder();
            js.AppendLine("<script>");
            js.AppendLine("document.addEventListener('DOMContentLoaded', function() {");
            
            // 1. Instantly restore the scroll position from the previous session
            js.AppendLine("    const savedScroll = sessionStorage.getItem('dashboardScrollY');");
            js.AppendLine("    if (savedScroll !== null) {");
            js.AppendLine("        window.scrollTo(0, parseInt(savedScroll, 10));");
            js.AppendLine("    }");

            // 2. Start the countdown to the next refresh
            js.AppendLine("    setTimeout(function() {");
            js.AppendLine("        // Save the current scroll position right before reloading");
            js.AppendLine("        sessionStorage.setItem('dashboardScrollY', window.scrollY);");
            js.AppendLine("        window.location.reload();");
            js.AppendLine($"    }, {refreshMilliseconds});");
            
            js.AppendLine("});");
            js.AppendLine("</script>");

            return js.ToString();
        }

        private async Task AppendBatchedTradesToHtmlAsync(List<HistoricalTrade> batchedTrades)
        {
            // ... (Your existing file locking, newRows generation, and summaryBlock logic)

            if (isNewFile)
            {
                StringBuilder htmlDoc = new StringBuilder();
                htmlDoc.AppendLine("<!DOCTYPE html><html><head><title>Statement</title>");
                
                // Existing Chart.js CDN and CSS styles go here...
                htmlDoc.AppendLine("<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>");
                // ... (Styles omitted for brevity) ...

                // ... (Existing Table and Canvas injection goes here) ...

                htmlDoc.AppendLine(summaryBlock);

                // Inject your existing Chart.js renderer
                htmlDoc.AppendLine(BuildChartJavaScript());
                
                // INJECT THE NEW AUTO-REFRESH SCRIPT AT THE VERY END
                htmlDoc.AppendLine(BuildAutoRefreshJavaScript());
                
                htmlDoc.AppendLine("</body></html>");

                await File.WriteAllTextAsync(fullPath, htmlDoc.ToString());
            }
            else
            {
                // ... (Your existing existingHtml.Replace DOM manipulation logic)
            }
        }
    }
}