V20190718_0

.github/stale.yml

@@ -0,0 +1,24 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+# Limit to only `issues`
+only: issues
+
+# Number of days of inactivity before an Issue or Pull Request is closed.
+# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
+daysUntilClose: 14
+
+# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
+exemptLabels:
+  - bug
+  - "technical issues"
+
+# Comment to post when marking as stale. Set to `false` to disable
+markComment: false
+
+# Comment to post when closing a stale Issue or Pull Request.
+closeComment: >
+  This issue has been automatically closed since there has not been
+  any recent activity. Please open a new issue for related bugs.
+
+# Limit the number of actions per hour, from 1-30. Default is 30
+limitPerRun: 30

src/botPage/bot/Interface/ToolsInterface.js

@@ -1,13 +1,78 @@
 import CandleInterface from './CandleInterface';
 import MiscInterface from './MiscInterface';
 import IndicatorsInterface from './IndicatorsInterface';
+import { translate } from '../../../common/i18n';
 
 // prettier-ignore
 export default Interface => class extends IndicatorsInterface(
     MiscInterface(CandleInterface(Interface))) {
     getToolsInterface() {
         return {
-            getTime: () => parseInt(new Date().getTime() / 1000),
+            getTime   : () => parseInt(new Date().getTime() / 1000),
+            toDateTime: (timestamp) => {
+                const getTwoDigitValue = input => {
+                    if (input < 10) {
+                        return `0${input}`;
+                    }
+                    return `${input}`;
+                }
+                const invalidTimestamp = () => `${translate('Invalid timestamp')}: ${timestamp}`;
+                if (typeof timestamp === 'number') {
+                    const dateTime = new Date(timestamp * 1000);
+                    if (dateTime.getTime()) {
+                        const year = dateTime.getFullYear();
+                        const month = getTwoDigitValue(dateTime.getMonth() + 1);
+                        const day = getTwoDigitValue(dateTime.getDate());
+                        const hours = getTwoDigitValue(dateTime.getHours());
+                        const minutes = getTwoDigitValue(dateTime.getMinutes());
+                        const seconds = getTwoDigitValue(dateTime.getSeconds());
+                        const formatGTMoffset = () => {
+                            const GMToffsetRaw = dateTime.getTimezoneOffset();
+                            const sign = GMToffsetRaw > 0 ? '-' : '+';
+                            const GMToffset = Math.abs(GMToffsetRaw);
+                            const h = Math.floor(GMToffset / 60);
+                            const m = GMToffset - h * 60;
+                            return `GMT${sign}${getTwoDigitValue(h)}${getTwoDigitValue(m)}`;
+                        }
+                        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds} ${formatGTMoffset()}`;
+                    }
+                    return invalidTimestamp();
+                }
+                return invalidTimestamp();
+            },
+            toTimestamp: (dateTimeString) => {
+                const invalidDatetime = () => `${translate('Invalid date/time')}: ${dateTimeString}`;
+                if (typeof dateTimeString === 'string') {
+                    const dateTime = dateTimeString
+                        .replace(/[^0-9.:-\s]/g, '')
+                        .replace(/\s+/g,' ')
+                        .trim()
+                        .split(' ');        
+
+                    const d = /^[12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+                    const t = /^(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9])(:([0-5][0-9])?)?$/;
+
+                    let validatedDateTime;
+
+                    if(dateTime.length >= 2) {
+                        validatedDateTime = d.test(dateTime[0]) && t.test(dateTime[1]) ? `${dateTime[0]}T${dateTime[1]}` : null;
+                    } else if(dateTime.length === 1) {
+                        validatedDateTime = d.test(dateTime[0]) ? dateTime[0] : null;
+                    } else {
+                        validatedDateTime = null;
+                    }
+
+                    if(validatedDateTime) {
+                        const dateObj = new Date(validatedDateTime);
+                        // eslint-disable-next-line no-restricted-globals
+                        if(dateObj instanceof Date && !isNaN(dateObj)) {
+                            return  dateObj.getTime() / 1000;
+                        }
+                    }
+                    return invalidDatetime();
+                }
+                return invalidDatetime();
+            },
             ...this.getCandleInterface(),
             ...this.getMiscInterface(),
             ...this.getIndicatorsInterface(),

src/botPage/bot/Interpreter.js

@@ -149,8 +149,10 @@ export default class Interpreter {
     }
     terminateSession() {
         this.$scope.api.disconnect();
-        globalObserver.emit('bot.stop');
         this.stopped = true;
+
+        globalObserver.emit('bot.stop');
+        globalObserver.setState({ isRunning: false });
     }
     stop() {
         if (this.bot.tradeEngine.isSold === false && !this.isErrorTriggered) {

src/botPage/bot/TradeEngine/OpenContract.js

@@ -17,8 +17,6 @@ export default Engine =>
 
                 this.setContractFlags(contract);
 
-                this.sellExpired();
-
                 this.data = this.data.set('contract', contract);
 
                 broadcastContract({ accountID: this.accountInfo.loginid, ...contract });
@@ -45,11 +43,7 @@ export default Engine =>
                     this.store.dispatch(openContractReceived());
                     if (!this.isExpired) {
                         this.resetSubscriptionTimeout();
-                        return;
-                    }
-                    if (!this.retriedUnsuccessfullSellExpired) {
-                        this.retriedUnsuccessfullSellExpired = true;
-                        this.resetSubscriptionTimeout(AFTER_FINISH_TIMEOUT);
+
                     }
                 }
             });
@@ -61,7 +55,6 @@ export default Engine =>
         }
         subscribeToOpenContract(contractId = this.contractId) {
             if (this.contractId !== contractId) {
-                this.retriedUnsuccessfullSellExpired = false;
                 this.resetSubscriptionTimeout();
             }
             this.contractId = contractId;

src/botPage/bot/TradeEngine/Sell.js

@@ -46,9 +46,4 @@ export default Engine =>
                 delayIndex++
             ).then(onSuccess);
         }
-        sellExpired() {
-            if (this.isSellAvailable && this.isExpired) {
-                doUntilDone(() => this.api.sellExpiredContracts());
-            }
-        }
     };

src/botPage/bot/TradeEngine/Total.js

@@ -1,7 +1,7 @@
 import { translate } from '../../../common/i18n';
 import { roundBalance } from '../../common/tools';
 import { info, notify } from '../broadcast';
-import createError from '../../common/error';
+import { createError } from '../../common/error';
 import { observer as globalObserver } from '../../../common/utils/observer';
 
 const skeleton = {

src/botPage/bot/TradeEngine/index.js

@@ -3,7 +3,7 @@ import { createStore, applyMiddleware } from 'redux';
 import thunk from 'redux-thunk';
 import { durationToSecond } from '../../../common/utils/tools';
 import { translate } from '../../..//common/i18n';
-import createError from '../../common/error';
+import { createError } from '../../common/error';
 import { doUntilDone } from '../tools';
 import { expectInitArg, expectTradeOptions } from '../sanitize';
 import Proposal from './Proposal';
@@ -92,6 +92,7 @@ export default class TradeEngine extends Balance(Purchase(Sell(OpenContract(Prop
         }
 
         globalObserver.emit('bot.running');
+        globalObserver.setState({ isRunning: true });
 
         this.tradeOptions = expectTradeOptions(tradeOptions);
 

src/botPage/bot/__tests__/block-tests/After.js

@@ -21,7 +21,7 @@ describe('After Purchase Blocks', () => {
     it('After purchase api', () => {
         expectResultTypes(result, [
             'boolean', // is result win
-            'string', // statement
+            'number', // statement
         ]);
     });
 });

src/botPage/bot/__tests__/block-tests/tools-test/Time.js

@@ -27,3 +27,17 @@ describe('Time in tools', () => {
         expect(time2 - time1).most(3);
     });
 });
+
+describe('Convert timestamp to date/time and back', () => {
+    const timestamp = Math.ceil(new Date().getTime() / 1000);
+    let result;
+    beforeAll(done => {
+        run(`(function() {return Bot.toTimestamp(Bot.toDateTime(${timestamp}));})()`).then(v => {
+            result = v;
+            done();
+        });
+    });
+    it('converts timestamp to date/time string', () => {
+        expect(result).satisfy(dt => dt === timestamp);
+    });
+});

src/botPage/bot/sanitize.js

@@ -1,5 +1,5 @@
 import { translate } from '../../common/i18n';
-import createError from '../common/error';
+import { createError } from '../common/error';
 
 const isPositiveNumber = num => Number.isFinite(num) && num > 0;
 

src/botPage/common/error.js

@@ -1,7 +1,13 @@
-const createError = (name, message) => {
+import { observer as globalObserver } from '../../common/utils/observer';
+import { translate } from '../../common/i18n';
+
+export const createError = (name, message) => {
     const e = new Error(message);
     e.name = name;
     return e;
 };
 
-export default createError;
+export const createErrorAndEmit = (name, message) => {
+    globalObserver.emit('ui.log.warn', `${translate(message)}`);
+    return createError(name, message);
+};

src/botPage/view/View.js

@@ -511,9 +511,19 @@ export default class View {
         });
 
         const startBot = limitations => {
-            $('#stopButton, #summaryStopButton').show();
-            $('#runButton, #summaryRunButton').hide();
-            $('#runButton, #summaryRunButton').prop('disabled', true);
+            const elRunButtons = document.querySelectorAll('#runButton, #summaryRunButton');
+            const elStopButtons = document.querySelectorAll('#stopButton, #summaryStopButton');
+
+            elRunButtons.forEach(el => {
+                const elRunButton = el;
+                elRunButton.style.display = 'none';
+                elRunButton.setAttributeNode(document.createAttribute('disabled'));
+            });
+            elStopButtons.forEach(el => {
+                const elStopButton = el;
+                elStopButton.style.display = 'inline-block';
+            });
+
             globalObserver.emit('summary.disable_clear');
             showSummary();
             this.blockly.run(limitations);
@@ -625,23 +635,54 @@ export default class View {
         this.blockly.stop();
     }
     addEventHandlers() {
+        const getRunButtonElements = () => document.querySelectorAll('#runButton, #summaryRunButton');
+        const getStopButtonElements = () => document.querySelectorAll('#stopButton, #summaryStopButton');
+
         window.addEventListener('storage', e => {
             window.onbeforeunload = null;
             if (e.key === 'activeToken' && !e.newValue) window.location.reload();
             if (e.key === 'realityCheckTime') hideRealityCheck();
         });
 
         globalObserver.register('Error', error => {
-            $('#runButton, #summaryRunButton').prop('disabled', false);
+            getRunButtonElements().forEach(el => {
+                const elRunButton = el;
+                elRunButton.removeAttribute('disabled');
+            });
+
             if (error.error && error.error.error.code === 'InvalidToken') {
                 removeAllTokens();
                 updateTokenList();
                 this.stop();
             }
         });
 
+        globalObserver.register('bot.running', () => {
+            getRunButtonElements().forEach(el => {
+                const elRunButton = el;
+                elRunButton.style.display = 'none';
+                elRunButton.setAttributeNode(document.createAttribute('disabled'));
+            });
+            getStopButtonElements().forEach(el => {
+                const elStopButton = el;
+                elStopButton.style.display = 'inline-block';
+                elStopButton.removeAttribute('disabled');
+            });
+        });
+
         globalObserver.register('bot.stop', () => {
-            $('#runButton, #summaryRunButton').prop('disabled', false);
+            // Enable run button, this event is emitted after the interpreter
+            // killed the API connection.
+            getStopButtonElements().forEach(el => {
+                const elStopButton = el;
+                elStopButton.style.display = null;
+                elStopButton.removeAttribute('disabled');
+            });
+            getRunButtonElements().forEach(el => {
+                const elRunButton = el;
+                elRunButton.style.display = null;
+                elRunButton.removeAttribute('disabled');
+            });
         });
 
         globalObserver.register('bot.info', info => {

src/botPage/view/blockly/blocks/shared.js

@@ -409,3 +409,22 @@ export const getPredictionForContracts = (contracts, selectedContractType) => {
     }
     return predictionRange;
 };
+
+export const disableRunButton = shouldDisable => {
+    const elRunButtons = document.querySelectorAll('#runButton, #summaryRunButton');
+    const isRunning = globalObserver.getState('isRunning');
+
+    elRunButtons.forEach(elRunButton => {
+        if (isRunning) {
+            if (shouldDisable) {
+                elRunButton.setAttributeNode(document.createAttribute('disabled'));
+            } else {
+                // Do not enable. The bot is running.
+            }
+        } else if (shouldDisable) {
+            elRunButton.setAttributeNode(document.createAttribute('disabled'));
+        } else {
+            elRunButton.removeAttribute('disabled');
+        }
+    });
+};

src/botPage/view/blockly/blocks/tools/time/index.js

@@ -1,3 +1,5 @@
 import './epoch';
 import './timeout';
 import './interval';
+import './todatetime';
+import './totimestamp';

src/botPage/view/blockly/blocks/tools/time/todatetime.js

@@ -0,0 +1,30 @@
+import { translate } from '../../../../../../common/i18n';
+
+Blockly.Blocks.todatetime = {
+    init: function init() {
+        this.appendDummyInput();
+        this.appendValueInput('TIMESTAMP').appendField(translate('To Date/Time'));
+        this.setInputsInline(true);
+        this.setOutput(true, 'String');
+        this.setColour('#dedede');
+        this.setTooltip(
+            translate(
+                'Converts a number of seconds since Epoch into a string representing date and time. Example: 1546347825 will be converted to 2019-01-01 21:03:45.'
+            )
+        );
+    },
+};
+
+Blockly.JavaScript.todatetime = block => {
+    const timestamp = Blockly.JavaScript.valueToCode(block, 'TIMESTAMP', Blockly.JavaScript.ORDER_ATOMIC);
+    // eslint-disable-next-line no-underscore-dangle
+    const functionName = Blockly.JavaScript.provideFunction_('timestampToDateString', [
+        // eslint-disable-next-line no-underscore-dangle
+        `function ${Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_}(timestamp) {
+            return Bot.toDateTime(timestamp);
+        }`,
+    ]);
+
+    const code = `${functionName}(${timestamp})`;
+    return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};