Auto refreshing plotters

Conditions.js

@@ -363,18 +363,7 @@
             let lowerEnd = leftDate.valueOf();
             let upperEnd = rightDate.valueOf();
 
-            if (conditions.length > 0) {
-
-                if (conditions[0].begin > lowerEnd || conditions[conditions.length - 1].end < upperEnd) {
-
-                    setTimeout(recalculate, 2000);
-
-                    //console.log("File missing while calculating conditions, scheduling a recalculation in 2 seconds.");
-
-                }
-            }
-
-            //console.log("Olivia > recalculateUsingDailyFiles > total conditions generated : " + conditions.length);
+            setTimeout(recalculate, 2000);
 
         } catch (err) {
 

FinalResults.js

@@ -0,0 +1,348 @@
+function newAAMastersPlottersTradingSimulationFinalResults() {
+
+    const MODULE_NAME = "Final Results Plotter";
+    const ERROR_LOG = true;
+    const INTENSIVE_LOG = false;
+    const logger = newWebDebugLog();
+    logger.fileName = MODULE_NAME;
+
+    let thisObject = {
+
+        // Main functions and properties.
+
+        initialize: initialize,
+        finalize: finalize,
+        container: undefined,
+        getContainer: getContainer,
+        setTimePeriod: setTimePeriod,
+        setDatetime: setDatetime,
+        draw: draw,
+        recalculateScale: recalculateScale,
+        currentRecord: undefined
+    };
+
+    /* this is part of the module template */
+
+    let container = newContainer();     // Do not touch this 3 lines, they are just needed.
+    container.initialize();
+    thisObject.container = container;
+
+    let timeLineCoordinateSystem = newTimeLineCoordinateSystem();       // Needed to be able to plot on the timeline, otherwise not.
+
+    let timePeriod;                     // This will hold the current Time Period the user is at.
+    let datetime;                       // This will hold the current Datetime the user is at.
+
+    let dataFile;                     // This is the current Market File being plotted.
+    let fileCursor;                     // This is the current File Cursor being used to retrieve Daily Files.
+
+    let singleFile;                      // This object will provide the different Market Files at different Time Periods.
+
+    /* these are module specific variables: */
+
+    let records = [];                   // Here we keep the records to be ploted every time the Draw() function is called by the AAWebPlatform.
+
+    let imageStopLossPhase;
+    let imageTakeProfitPhase;
+    let imageRecord;
+
+    let zoomChangedEventSubscriptionId
+    let offsetChangedEventSubscriptionId
+    let filesUpdatedEventSubscriptionId
+    let dragFinishedEventSubscriptionId
+    let dimmensionsChangedEventSubscriptionId
+
+    return thisObject;
+
+    function finalize() {
+        try {
+
+            /* Stop listening to the necesary events. */
+
+            viewPort.eventHandler.stopListening(zoomChangedEventSubscriptionId);
+            viewPort.eventHandler.stopListening(offsetChangedEventSubscriptionId);
+            singleFile.eventHandler.stopListening(filesUpdatedEventSubscriptionId);
+            canvas.eventHandler.stopListening(dragFinishedEventSubscriptionId);
+            thisObject.container.eventHandler.stopListening(dimmensionsChangedEventSubscriptionId)
+
+            /* icons */
+
+            imageStopLossPhase = undefined;
+            imageTakeProfitPhase = undefined;
+            imageRecord = undefined;
+
+            /* Destroy References */
+
+            singleFile = undefined;
+
+            datetime = undefined;
+            timePeriod = undefined;
+
+            dataFile = undefined;
+            fileCursor = undefined;
+
+        } catch (err) {
+
+            if (ERROR_LOG === true) { logger.write("[ERROR] finalize -> err = " + err.stack); }
+        }
+    }
+
+    function initialize(pStorage, pExchange, pMarket, pDatetime, pTimePeriod, callBackFunction) {
+
+        try {
+
+            /* Store the information received. */
+
+            singleFile = pStorage.singleFile;
+
+            datetime = pDatetime;
+            timePeriod = pTimePeriod;
+
+            dataFile = singleFile.getFile(timePeriod);
+
+            /* Listen to the necesary events. */
+
+            zoomChangedEventSubscriptionId = viewPort.eventHandler.listenToEvent("Zoom Changed", onZoomChanged);
+            offsetChangedEventSubscriptionId = viewPort.eventHandler.listenToEvent("Offset Changed", onOffsetChanged);
+            filesUpdatedEventSubscriptionId = singleFile.eventHandler.listenToEvent("Files Updated", onFilesUpdated);
+            dragFinishedEventSubscriptionId = canvas.eventHandler.listenToEvent("Drag Finished", onDragFinished);
+
+            /* Get ready for plotting. */
+
+            recalculate();
+
+            /* Ready for when dimmension changes. */
+
+            dimmensionsChangedEventSubscriptionId = thisObject.container.eventHandler.listenToEvent('Dimmensions Changed', function () {
+                recalculate();
+            })
+
+            callBackFunction();
+
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err = " + err.stack); }
+        }
+    }
+
+    function getContainer(point) {
+        let container;
+        /* First we check if this point is inside this space. */
+        if (this.container.frame.isThisPointHere(point) === true) {
+            return this.container;
+        } else {
+            /* This point does not belong to this space. */
+            return undefined;
+        }
+    }
+
+    function onFilesUpdated() {
+        try {
+            dataFile = singleFile.getFile(timePeriod);
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] onFilesUpdated -> err = " + err.stack); }
+        }
+    }
+
+    function setTimePeriod(pTimePeriod) {
+        try {
+            if (timePeriod !== pTimePeriod) {
+                timePeriod = pTimePeriod;
+                dataFile = singleFile.getFile(timePeriod);
+                recalculate();
+            }
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] setTimePeriod -> err = " + err.stack); }
+        }
+    }
+
+    function setDatetime(pDatetime) {
+        datetime = pDatetime;
+    }
+
+    function draw() {
+        try {
+            // Nothing to draw for now
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] draw -> err = " + err.stack); }
+        }
+    }
+
+    function recalculate() {
+
+        try {
+
+            records = []
+
+            if (timePeriod >= _1_HOUR_IN_MILISECONDS) {
+
+                recalculateUsingMarketFiles();
+
+            } else {
+
+                recalculateUsingDailyFiles();
+
+            }
+
+            thisObject.container.eventHandler.raiseEvent("Records Changed", records);
+
+        } catch (err) {
+
+            if (ERROR_LOG === true) { logger.write("[ERROR] recalculate -> err = " + err.stack); }
+        }
+    }
+
+    function recalculate() {
+
+        try {
+
+            if (dataFile === undefined) { return; } // Initialization not complete yet.
+
+            records = [];
+
+            for (let i = 0; i < dataFile.length; i++) {
+
+                let record = {};
+
+                record.begin = dataFile[i][0];
+                record.end = dataFile[i][1];
+                record.type = dataFile[i][2];
+                record.rate = dataFile[i][3];
+                record.amount = dataFile[i][4];
+                record.balanceA = dataFile[i][5];
+                record.balanceB = dataFile[i][6];
+                record.profit = dataFile[i][7];
+                record.lastTradeProfitLoss = dataFile[i][8];
+                record.stopLoss = dataFile[i][9];
+                record.roundtrips = dataFile[i][10];
+                record.hits = dataFile[i][11];
+                record.fails = dataFile[i][12];
+                record.hitRatio = dataFile[i][13];
+                record.ROI = dataFile[i][14];
+                record.periods = dataFile[i][15];
+                record.days = dataFile[i][16];
+                record.anualizedRateOfReturn = dataFile[i][17];
+                record.sellRate = dataFile[i][18];
+                record.lastTradeROI = dataFile[i][19];
+                record.strategy = dataFile[i][20];
+                record.strategyPhase = dataFile[i][21];
+                record.takeProfit = dataFile[i][22];
+                record.stopLossPhase = dataFile[i][23];
+                record.takeProfitPhase = dataFile[i][24];
+                record.positionSize = dataFile[i][26]; // 25 is the message for the executor
+                record.initialBalanceA = dataFile[i][27];
+                record.minimunBalanceA = dataFile[i][28];
+                record.maximunBalanceA = dataFile[i][29];
+                record.initialBalanceB = dataFile[i][30];
+                record.minimunBalanceB = dataFile[i][31];
+                record.maximunBalanceB = dataFile[i][32];
+                record.baseAsset = dataFile[i][33];
+                record.positionPeriods = dataFile[i][34];
+                record.positionDays = dataFile[i][35];
+
+                thisObject.currentRecord = record;
+                thisObject.container.eventHandler.raiseEvent("Current Record Changed", thisObject.currentRecord);
+            }
+
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] recalculate -> err = " + err.stack); }
+        }
+    }
+
+    function recalculateScale() {
+        try {
+            // No scale needed
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] recalculateScale -> err = " + err.stack); }
+        }
+    }
+
+    function plotChart() {
+        try {
+            let userPosition = getUserPosition()
+            let userPositionDate = userPosition.point.x
+
+            let record;
+
+            /* Now we calculate and plot the records */
+            for (let i = 0; i < records.length; i++) { // We do not start in 0 so as to be able to read the previous record i - 1
+
+                record = records[i];
+
+                /* Send the current record to the panel */
+
+                if (userPositionDate >= record.begin && userPositionDate <= record.end) {
+
+                    let eventRecords = {
+                        currentRecord: record,
+                        lastRecord: records[records.length - 1]
+                    };
+                    thisObject.container.eventHandler.raiseEvent("Current Record Changed", eventRecords);
+                }
+            }
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] plotChart -> err = " + err.stack); }
+        }
+    }
+
+    function onZoomChanged(event) {
+        try {
+            recalculate();
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] onZoomChanged -> err = " + err.stack); }
+        }
+    }
+
+    function onOffsetChanged() {
+        try {
+            if (Math.random() * 100 > 95) {
+                recalculate()
+            };
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] onOffsetChanged -> err = " + err.stack); }
+        }
+    }
+
+    function onDragFinished() {
+        try {
+            recalculate();
+        } catch (err) {
+            if (ERROR_LOG === true) { logger.write("[ERROR] onDragFinished -> err = " + err.stack); }
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

FinalResultsPanel.js

@@ -0,0 +1,360 @@
+
+function newAAMastersPlottersTradingSimulationTradingSimulationFinalResultsPanel() {
+
+    let thisObject = {
+        fitFunction: undefined,
+        onEventRaised: onEventRaised,
+        container: undefined,
+        draw: draw,
+        getContainer: getContainer,
+        initialize: initialize,
+        finalize: finalize
+    };
+
+    let container = newContainer();
+    container.initialize();
+    thisObject.container = container;
+
+    container.displacement.containerName = "Final Results";
+    container.frame.containerName = "Final Results";
+
+    let currentRecord;
+    let lastRecord;
+    let panelTabButton
+
+
+    return thisObject;
+
+    function initialize() {
+
+        thisObject.container.frame.width = UI_PANEL.WIDTH.NORMAL * 2;
+        thisObject.container.frame.height = UI_PANEL.HEIGHT.NORMAL * 2.5;
+
+        thisObject.container.frame.position.x = viewPort.visibleArea.topLeft.x + thisObject.container.frame.width * 1;
+        thisObject.container.frame.position.y = viewPort.visibleArea.topRight.y;
+
+        panelTabButton = newPanelTabButton()
+        panelTabButton.parentContainer = thisObject.container
+        panelTabButton.container.frame.parentFrame = thisObject.container.frame
+        panelTabButton.fitFunction = thisObject.fitFunction
+        panelTabButton.initialize()
+
+    }
+
+    function finalize() {
+
+    }
+
+    function getContainer(point) {
+
+        let container;
+
+        container = panelTabButton.getContainer(point)
+        if (container !== undefined) { return container }
+
+        if (thisObject.container.frame.isThisPointHere(point, true) === true) {
+
+            let checkPoint = {
+                x: point.x,
+                y: point.y
+            }
+
+            checkPoint = thisObject.fitFunction(checkPoint)
+
+            if (point.x === checkPoint.x && point.y === checkPoint.y) {
+                return thisObject.container;
+            }
+        }
+    }
+
+
+    function onEventRaised(records) {
+
+        currentRecord = records.currentRecord;
+        lastRecord = records.lastRecord
+
+    }
+
+
+    function draw() {
+
+        thisObject.container.frame.draw(false, false, true, thisObject.fitFunction);
+
+        plotCurrentRecordInfo();
+
+        panelTabButton.draw()
+    }
+
+
+    function plotCurrentRecordInfo() {
+
+        if (currentRecord === undefined) { return; }
+        if (lastRecord === undefined) { return; }
+
+        const frameBodyHeight = thisObject.container.frame.getBodyHeight();
+        const frameTitleHeight = thisObject.container.frame.height - frameBodyHeight;
+
+        const X_AXIS = thisObject.container.frame.width / 2;
+        const Y_AXIS = frameTitleHeight + frameBodyHeight / 2;
+
+
+        /* put the labels with the records values */
+
+        browserCanvasContext.beginPath();
+
+        let y = 0;
+        let increment = 0.024;
+
+        y = y + increment;
+        y = y + increment;
+        printLabel('Current Position', X_AXIS, frameTitleHeight + frameBodyHeight * y, '1', 14);
+
+        y = y + increment;
+        printLabel('Size', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.positionSize, X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Rate', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.sellRate, X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Stop', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.stopLoss, X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Take Profit', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.takeProfit, X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Periods', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.positionPeriods), X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Days', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.positionDays).toFixed(2), X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        y = y + increment;
+        printLabel('Latest Position', X_AXIS, frameTitleHeight + frameBodyHeight * y, '1', 14);
+
+        y = y + increment;
+        printLabel('Profit / Loss', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.lastTradeProfitLoss), X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('ROI', X_AXIS, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.lastTradeROI).toFixed(2) + ' % ', X_AXIS, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+
+
+        let bifurcationLevel = y
+        y = y + increment;
+        y = y + increment;
+        printLabel('Partial Results', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1', 14);
+
+        y = y + increment;
+        printLabel('Profit / Loss', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.profit, X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Trades', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.roundtrips, X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Hits', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.hits, X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Fails', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.fails, X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Hit Ratio', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.hitRatio * 100).toFixed(2) + ' %', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('ROI', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.ROI * 100).toFixed(2) + ' %', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Periods', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.periods, X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Days', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(currentRecord.days, X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Anualized Rate of Return', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((currentRecord.anualizedRateOfReturn * 100).toFixed(2) + ' %', X_AXIS - thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+
+        y = bifurcationLevel
+
+        y = y + increment;
+        y = y + increment;
+        printLabel('Final Results', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1', 14);
+
+        y = y + increment;
+        printLabel('Profit / Loss', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(lastRecord.profit, X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Trades', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(lastRecord.roundtrips, X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Hits', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(lastRecord.hits, X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Fails', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(lastRecord.fails, X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Hit Ratio', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((lastRecord.hitRatio * 100).toFixed(2) + ' %', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('ROI', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((lastRecord.ROI * 100).toFixed(2) + ' %', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Periods', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(lastRecord.periods, X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Days', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel(lastRecord.days, X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+        y = y + increment;
+        printLabel('Anualized Rate of Return', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '0.60');
+        y = y + increment;
+        printLabel((lastRecord.anualizedRateOfReturn * 100).toFixed(2) + ' %', X_AXIS + thisObject.container.frame.width / 4, frameTitleHeight + frameBodyHeight * y, '1.00', 14);
+
+
+
+        function printLabel(labelToPrint, x, y, opacity, fontSize) {
+
+            let labelPoint;
+            if (fontSize === undefined) { fontSize = 10 };
+
+            browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY;
+
+            let label = '' + labelToPrint;
+            if (isNaN(label) === false) {
+                label = Number(label).toLocaleString();
+                if ((label === "-0" || label === "0") && (labelToPrint !== 0) && (labelToPrint !== "0.00")) {
+                    label = Number(labelToPrint).toFixed(6);
+                }
+            }
+            let xOffset = label.length / 2 * fontSize * FONT_ASPECT_RATIO;
+
+            labelPoint = {
+                x: x - xOffset,
+                y: y
+            };
+
+            labelPoint = thisObject.container.frame.frameThisPoint(labelPoint);
+            labelPoint = thisObject.fitFunction(labelPoint)
+
+            browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.DARK + ', ' + opacity + ')';
+            browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y);
+
+        }
+
+        browserCanvasContext.closePath();
+        browserCanvasContext.fill();
+
+        /* Parameters */
+        let params
+        let paramsArray = []
+        let positionTaken = false
+
+        if (currentRecord.positionSize > 0) {
+            positionTaken = true
+        }
+
+        params = {}
+        params.VALUE = currentRecord.balanceA;
+        params.INIT_VALUE = currentRecord.initialBalanceA
+        params.MIN_VALUE = currentRecord.minimunBalanceA
+        params.MAX_VALUE = currentRecord.maximunBalanceA
+        params.ASSET_LABEL = 'Asset A'
+        params.ASSET_NAME = DEFAULT_MARKET.assetB
+        params.LEFT_OFFSET = 100
+        params.POSITION_TAKEN = positionTaken
+        params.BASE_ASSET = currentRecord.baseAsset
+        params.DECIMALS = 4
+
+        paramsArray.push(params)
+
+        params = {}
+        params.VALUE = currentRecord.balanceB;
+        params.MIN_VALUE = currentRecord.minimunBalanceB
+        params.INIT_VALUE = currentRecord.initialBalanceB
+        params.MAX_VALUE = currentRecord.maximunBalanceB
+        params.ASSET_LABEL = 'Asset B'
+        params.ASSET_NAME = DEFAULT_MARKET.assetA
+        params.LEFT_OFFSET = 220
+        params.POSITION_TAKEN = positionTaken
+        params.BASE_ASSET = currentRecord.baseAsset
+        params.DECIMALS = 2
+
+        paramsArray.push(params)
+
+        canvas.cockpitSpace.assetBalances.setParamsArray(paramsArray)
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Strategies.js

@@ -367,18 +367,7 @@
             let lowerEnd = leftDate.valueOf();
             let upperEnd = rightDate.valueOf();
 
-            if (strategies.length > 0) {
-
-                if (strategies[0].begin > lowerEnd || strategies[strategies.length - 1].end < upperEnd) {
-
-                    setTimeout(recalculate, 2000);
-
-                    //console.log("File missing while calculating strategies, scheduling a recalculation in 2 seconds.");
-
-                }
-            }
-
-            //console.log("Olivia > recalculateUsingDailyFiles > total strategies generated : " + strategies.length);
+            setTimeout(recalculate, 2000);
 
         } catch (err) {
 

Trades.js

@@ -354,18 +354,7 @@
             let lowerEnd = leftDate.valueOf();
             let upperEnd = rightDate.valueOf();
 
-            if (trades.length > 0) {
-
-                if (trades[0].begin > lowerEnd || trades[trades.length - 1].end < upperEnd) {
-
-                    setTimeout(recalculate, 2000);
-
-                    //console.log("File missing while calculating trades, scheduling a recalculation in 2 seconds.");
-
-                }
-            }
-
-            //console.log("Olivia > recalculateUsingDailyFiles > total trades generated : " + trades.length);
+            setTimeout(recalculate, 2000);
 
         } catch (err) {
 

TradingSimulation.js

@@ -371,18 +371,7 @@
             let lowerEnd = leftDate.valueOf();
             let upperEnd = rightDate.valueOf();
 
-            if (records.length > 0) {
-
-                if (records[0].begin > lowerEnd || records[records.length - 1].end < upperEnd) {
-
-                    setTimeout(recalculate, 2000);
-
-                    //console.log("File missing while calculating records, scheduling a recalculation in 2 seconds.");
-
-                }
-            }
-
-            //console.log("Olivia > recalculateUsingDailyFiles > total records generated : " + records.length);
+            setTimeout(recalculate, 2000);
 
         } catch (err) {