dev to beta

.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/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';

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,11 @@ export default class View {
         });
 
         const startBot = limitations => {
-            $('#stopButton, #summaryStopButton').show();
-            $('#runButton, #summaryRunButton').hide();
-            $('#runButton, #summaryRunButton').prop('disabled', true);
+            const $runButtons = $('#runButton, #summaryRunButton');
+            const $stopButtons = $('#stopButton, #summaryStopButton');
+            $stopButtons.show();
+            $runButtons.hide();
+            $runButtons.prop('disabled', true);
             globalObserver.emit('summary.disable_clear');
             showSummary();
             this.blockly.run(limitations);
@@ -641,7 +643,15 @@ export default class View {
         });
 
         globalObserver.register('bot.stop', () => {
-            $('#runButton, #summaryRunButton').prop('disabled', false);
+            const $runButtons = $('#runButton, #summaryRunButton');
+            const $stopButtons = $('#stopButton, #summaryStopButton');
+            if ($runButtons.is(':visible') || $stopButtons.is(':visible')) {
+                $runButtons.show();
+                $stopButtons.hide();
+
+                $stopButtons.prop('disabled', false);
+                $runButtons.prop('disabled', false);
+            }
         });
 
         globalObserver.register('bot.info', info => {

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

@@ -409,3 +409,7 @@ export const getPredictionForContracts = (contracts, selectedContractType) => {
     }
     return predictionRange;
 };
+
+export const disableRunButton = isDisabled => {
+    $('#runButton, #summaryRunButton').attr('disabled', isDisabled);
+};

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];
+};

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

@@ -0,0 +1,30 @@
+import { translate } from '../../../../../../common/i18n';
+
+Blockly.Blocks.totimestamp = {
+    init: function init() {
+        this.appendDummyInput();
+        this.appendValueInput('DATETIME').appendField(translate('To Timestamp'));
+        this.setInputsInline(true);
+        this.setOutput(true, 'Number');
+        this.setColour('#dedede');
+        this.setTooltip(
+            translate(
+                'Converts a string representing a date/time string into seconds since Epoch. Example: 2019-01-01 21:03:45 GMT+0800 will be converted to 1546347825. Time and time zone offset are optional.'
+            )
+        );
+    },
+};
+
+Blockly.JavaScript.totimestamp = block => {
+    const dateString = Blockly.JavaScript.valueToCode(block, 'DATETIME', Blockly.JavaScript.ORDER_ATOMIC);
+    // eslint-disable-next-line no-underscore-dangle
+    const functionName = Blockly.JavaScript.provideFunction_('dateTimeStringToTimestamp', [
+        // eslint-disable-next-line no-underscore-dangle
+        `function ${Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_}(dateTimeString) {
+            return Bot.toTimestamp(dateTimeString);
+        }`,
+    ]);
+
+    const code = `${functionName}(${dateString})`;
+    return [code, Blockly.JavaScript.ORDER_FUNCTION_CALL];
+};

src/botPage/view/blockly/blocks/trade/tradeOptions.js

@@ -5,6 +5,7 @@ import {
     getDurationsForContracts,
     getBarriersForContracts,
     getPredictionForContracts,
+    disableRunButton,
 } from '../shared';
 import { insideTrade } from '../../relationChecker';
 import { findTopParentBlock, hideInteractionsFromBlockly, getBlocksByType } from '../../utils';
@@ -102,33 +103,40 @@ export default () => {
             }
         },
         pollForContracts(symbol) {
+            disableRunButton(true);
             return new Promise(resolve => {
                 const contractsForSymbol = haveContractsForSymbol(symbol);
+
+                const resolveContracts = resolveObj => {
+                    disableRunButton(false);
+                    resolve(resolveObj);
+                };
+
                 if (!contractsForSymbol) {
                     // Register an event and use as a lock to avoid spamming API
                     const event = `contractsLoaded.${symbol}`;
                     if (!globalObserver.isRegistered(event)) {
                         globalObserver.register(event, () => {});
                         getContractsAvailableForSymbol(symbol).then(contracts => {
                             globalObserver.unregisterAll(event); // Release the lock
-                            resolve(contracts);
+                            resolveContracts(contracts);
                         });
                     } else {
                         // Request in progress, start polling localStorage until contracts are available.
                         const pollingFn = setInterval(() => {
                             const contracts = haveContractsForSymbol(symbol);
                             if (contracts) {
                                 clearInterval(pollingFn);
-                                resolve(contracts.available);
+                                resolveContracts(contracts.available);
                             }
                         }, 100);
                         setTimeout(() => {
                             clearInterval(pollingFn);
-                            resolve([]);
+                            resolveContracts([]);
                         }, 10000);
                     }
                 } else {
-                    resolve(contractsForSymbol.available);
+                    resolveContracts(contractsForSymbol.available);
                 }
             });
         },