@mathieuc/tradingview 2.0.1 → 2.0.7

package/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: Mathieu2301

package/README.md

@@ -56,9 +56,9 @@ const marketAPI = require('tradingview');
 
 const marketAPI = require('tradingview');
 
-const market = marketAPI();
+(async () => {
+  const market = marketAPI(false);
 
-market.on('logged', async () => {
   const searchBTC = (await market.search('bitcoin euro', 'crypto'))[0];
   console.log('Found Bitcoin / Euro:', searchBTC);
 
@@ -66,7 +66,7 @@ market.on('logged', async () => {
   console.log('Full technical analysis for Bitcoin:', TA);
 
   // You can also use this way: await market.getTA('crypto', 'BINANCE:BTCEUR');
-});
+})();
 ```
 
 ```javascript

package/main.js

@@ -1,6 +1,7 @@
 const WebSocket = require('ws');
 const {
   search, getScreener, getTA, getIndicator,
+  getUser, getChartToken, getDrawings,
 } = require('./miscRequests');
 
 let onPacket = () => null;
@@ -88,6 +89,9 @@ module.exports = (autoInit = true) => {
   /** List of subscribed symbols */
   let subscribed = [];
 
+  /** Websockets status calls */
+  let isEnded = false;
+
   /**
    * Send a custom packet
    * @param {string} t Packet type
@@ -166,33 +170,56 @@ module.exports = (autoInit = true) => {
   };
 
   return {
-    /**
-     * @param {'connected' | 'disconnected' | 'logged'
-     * | 'subscribed' | 'price' | 'data' | 'error' | 'ping' } ev
-     * @param {(...data: object) => null} cb
+    /** Event listener
+     * @param { 'connected' | 'disconnected' | 'logged'
+     * | 'subscribed' | 'price' | 'data' | 'error' | 'ping' } event Event
+     * @param {(...data: object) => null} cb Callback
      */
-    on(ev, cb) {
-      if (!callbacks[ev]) {
-        console.log('Wrong event:', ev);
+    on(event, cb) {
+      if (!callbacks[event]) {
+        console.log('Wrong event:', event);
         console.log('Available events:', Object.keys(callbacks));
         return;
       }
 
-      callbacks[ev].push(cb);
+      callbacks[event].push(cb);
+    },
+
+    /**
+     * Close the websocket connection
+     * @return {Promise<void>} When websocket is closed
+     */
+    end() {
+      return new Promise((cb) => {
+        isEnded = true;
+        ws.close();
+        cb();
+      });
     },
 
+    getUser,
+    getChartToken,
+    getDrawings,
     search,
     getScreener,
     getTA,
     subscribed,
 
-    subscribe(symbol = '') {
+    /**
+     * Unsubscribe to a market
+     * @param {string} symbol Market symbol (Example: BTCEUR or COINBASE:BTCEUR)
+     */
+    subscribe(symbol) {
       if (subscribed.includes(symbol)) return;
       send('quote_add_symbols', [sessionId, symbol]);
       subscribed.push(symbol);
     },
 
-    unsubscribe(symbol = '') {
+    /**
+     * Unsubscribe from a market
+     * @param {string} symbol Market symbol (Example: BTCEUR or COINBASE:BTCEUR)
+     */
+    unsubscribe(symbol) {
       if (!subscribed.includes(symbol)) return;
       send('quote_remove_symbols', [sessionId, symbol]);
       subscribed = subscribed.filter((s) => s !== symbol);
@@ -205,6 +232,7 @@ module.exports = (autoInit = true) => {
      * @property {(string | number | boolean | null)[]} [settings] Indicator settings value
      *
      * @typedef {Object} ChartInfos
+     * @property {string} [session] User 'sessionid' cookie
      * @property {string} symbol Market symbol (Example: BTCEUR or COINBASE:BTCEUR)
      * @property { '1' | '3' | '5' | '15' | '30' | '45'
      *  | '60' | '120' | '180' | '240'
@@ -271,6 +299,8 @@ module.exports = (autoInit = true) => {
       }
 
       chartCBs[chartSession] = (packet) => {
+        if (isEnded) return;
+
         if (['timescale_update', 'du'].includes(packet.type)) {
           updatePeriods(packet);
           onUpdate([...periods].reverse());
@@ -282,6 +312,7 @@ module.exports = (autoInit = true) => {
         }
       };
 
+      if (chart.session) send('set_auth_token', [(await getUser(chart.session)).authToken]);
       send('chart_create_session', [chartSession, '']);
       if (chart.timezone) send('switch_timezone', [chartSession, chart.timezone]);
       send('resolve_symbol', [chartSession, 'sds_sym_1', `={"symbol":"${chart.symbol || 'BTCEUR'}","adjustment":"splits"}`]);

package/miscRequests.js

@@ -1,258 +1,420 @@
-const https = require('https');
-
-const indicators = ['Recommend.Other', 'Recommend.All', 'Recommend.MA'];
-
-function fetchScanData(tickers = [], type = '', columns = []) {
-  return new Promise((cb, err) => {
-    const req = https.request({
-      method: 'POST',
-      hostname: 'scanner.tradingview.com',
-      path: `/${type}/scan`,
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    }, (res) => {
-      let data = '';
-      res.on('data', (c) => { data += c; });
-      res.on('end', () => {
-        if (!data.startsWith('{')) {
-          err(new Error('Wrong screener or symbol'));
-          return;
-        }
-        try {
-          cb(JSON.parse(data));
-        } catch (error) {
-          err(new Error('Can\'t parse server response'));
-        }
-      });
-    });
-
-    req.on('error', err);
-    req.end(JSON.stringify({ symbols: { tickers }, columns }));
-  });
-}
-
-/**
- * @typedef {number} advice
- *
- * @typedef {{ Other: advice, All: advice, MA: advice }} Period
- *
- * @typedef {{
- *  '1': Period,
- *  '5': Period,
- *  '15': Period,
- *  '60': Period,
- *  '240': Period,
- *  '1D': Period,
- *  '1W': Period,
- *  '1M': Period,
- * }} Periods
- *
- * @typedef {string | 'forex' | 'crypto'
- * | 'america' | 'australia' | 'canada' | 'egypt'
- * | 'germany' | 'india' | 'israel' | 'italy'
- * | 'luxembourg' | 'poland' | 'sweden' | 'turkey'
- * | 'uk' | 'vietnam'} screener
- * You can use `getScreener(exchange)` function for non-forex and non-crypto markets.
- */
-
-module.exports = {
-  /**
-   * @param {string} exchange Example: BINANCE, EURONEXT, NASDAQ
-   * @returns {screener}
-  */
-  getScreener(exchange) {
-    const e = exchange.toUpperCase();
-    if (['NASDAQ', 'NYSE', 'NYSE ARCA', 'OTC'].includes(e)) return 'america';
-    if (['ASX'].includes(e)) return 'australia';
-    if (['TSX', 'TSXV', 'CSE', 'NEO'].includes(e)) return 'canada';
-    if (['EGX'].includes(e)) return 'egypt';
-    if (['FWB', 'SWB', 'XETR'].includes(e)) return 'germany';
-    if (['BSE', 'NSE'].includes(e)) return 'india';
-    if (['TASE'].includes(e)) return 'israel';
-    if (['MIL', 'MILSEDEX'].includes(e)) return 'italy';
-    if (['LUXSE'].includes(e)) return 'luxembourg';
-    if (['NEWCONNECT'].includes(e)) return 'poland';
-    if (['NGM'].includes(e)) return 'sweden';
-    if (['BIST'].includes(e)) return 'turkey';
-    if (['LSE', 'LSIN'].includes(e)) return 'uk';
-    if (['HNX'].includes(e)) return 'vietnam';
-    return exchange.toLowerCase();
-  },
-
-  /** Get technical analysis
-   * @param {screener} screener
-   * @param {string} id Full market id (Example: COINBASE:BTCEUR)
-   * @returns {Promise<Periods>} results
-   */
-  async getTA(screener, id) {
-    const advice = {};
-
-    const cols = ['1', '5', '15', '60', '240', '1D', '1W', '1M']
-      .map((t) => indicators.map((i) => (t !== '1D' ? `${i}|${t}` : i)))
-      .flat();
-
-    const rs = await fetchScanData([id], screener, cols);
-    if (!rs.data || !rs.data[0]) return false;
-
-    rs.data[0].d.forEach((val, i) => {
-      const [name, period] = cols[i].split('|');
-      const pName = period || '1D';
-      if (!advice[pName]) advice[pName] = {};
-      advice[pName][name.split('.').pop()] = Math.round(val * 1000) / 500;
-    });
-
-    return advice;
-  },
-
-  /**
-   * @typedef {Object} SearchResult
-   * @property {string} id
-   * @property {string} exchange
-   * @property {string} fullExchange
-   * @property {string} screener
-   * @property {string} symbol
-   * @property {string} description
-   * @property {string} type
-   * @property {() => Promise<Periods>} getTA
-   */
-
-  /**
-   * @param {string} search Search a symbol
-   * @param {'stock' | 'futures' | 'forex' | 'cfd' | 'crypto' | 'index' | 'economic'} filter
-   * @returns {Promise<SearchResult[]>} Search results
-   */
-  async search(search, filter = '') {
-    return new Promise((cb, err) => {
-      https.get({
-        host: 'symbol-search.tradingview.com',
-        path: `/symbol_search/?text=${search.replace(/ /g, '%20')}&type=${filter}`,
-        origin: 'https://www.tradingview.com',
-      }, (res) => {
-        let rs = '';
-        res.on('data', (d) => { rs += d; });
-        res.on('end', () => {
-          try {
-            rs = JSON.parse(rs);
-          } catch (e) {
-            err(new Error('Can\'t parse server response'));
-            return;
-          }
-
-          cb(rs.map((s) => {
-            const exchange = s.exchange.split(' ')[0];
-            const id = `${exchange}:${s.symbol}`;
-
-            const screener = (['forex', 'crypto'].includes(s.type)
-              ? s.type
-              : this.getScreener(exchange)
-            );
-
-            return {
-              id,
-              exchange,
-              fullExchange: s.exchange,
-              screener,
-              symbol: s.symbol,
-              description: s.description,
-              type: s.type,
-              getTA: () => this.getTA(screener, id),
-            };
-          }));
-        });
-
-        res.on('error', err);
-      });
-    });
-  },
-
-  /**
-   * @typedef {Object} indicatorInput
-   * @property {string} name
-   * @property {string} inline Inline name
-   * @property { 'text' | 'source' | 'integer' | 'float' | 'resolution' | 'bool' } type
-   * @property {string | number | boolean} value
-   * @property {string | number | boolean} defVal
-   * @property {boolean} hidden
-   * @property {boolean} isFake
-   * @property {string[]} [options]
-   */
-
-  /**
-   * @typedef {Object} Indicator
-   * @property {string} pineId Indicator ID
-   * @property {string} pineVersion Indicator version
-   * @property {string} description Indicator description
-   * @property {string} shortDescription Indicator short description
-   * @property {Object<string, indicatorInput>} inputs Indicator inputs
-   * @property {Object<string, string>} plots Indicator plots
-   * @property {string} script Indicator script
-   */
-
-  /**
-   * Get an indicator
-   * @param {string} id Indicator ID (Like: PUB;XXXXXXXXXXXXXXXXXXXXX)
-   * @param {string} version Wanted version of the indicator
-   * @returns {Promise<Indicator>} Indicator
-   */
-  async getIndicator(id, version, settings = []) {
-    return new Promise((cb, err) => {
-      https.get(`https://pine-facade.tradingview.com/pine-facade/translate/${id}/${version}`, (res) => {
-        let rs = '';
-        res.on('data', (d) => { rs += d; });
-        res.on('end', () => {
-          try {
-            rs = JSON.parse(rs);
-          } catch (e) {
-            err(new Error('Inexistent or unsupported indicator'));
-            return;
-          }
-
-          if (!rs.success || !rs.result.metaInfo || !rs.result.metaInfo.inputs) {
-            err(new Error('Inexistent or unsupported indicator'));
-            return;
-          }
-
-          const inputs = {};
-
-          rs.result.metaInfo.inputs.forEach((input) => {
-            if (['text', 'pineId', 'pineVersion'].includes(input.id)) return;
-            const inline = input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9]/g, '');
-
-            const i = parseInt(input.id.replace(/[^0-9]/g, ''), 10);
-
-            inputs[input.id] = {
-              name: input.name,
-              type: input.type,
-              value: settings[i] ?? input.defval,
-              defVal: input.defval,
-              hidden: !!input.isHidden,
-              isFake: !!input.isFake,
-              inline,
-            };
-
-            if (input.options) inputs[input.id].options = input.options;
-          });
-
-          const plots = {};
-
-          Object.keys(rs.result.metaInfo.styles).forEach((plotId) => {
-            plots[plotId] = rs.result.metaInfo.styles[plotId].title.replace(/ /g, '_').replace(/[^a-zA-Z0-9]/g, '');
-          });
-
-          cb({
-            pineId: id,
-            pineVersion: version,
-            description: rs.result.metaInfo.description,
-            shortDescription: rs.result.metaInfo.shortDescription,
-            inputs,
-            plots,
-            script: rs.result.ilTemplate,
-          });
-        });
-
-        res.on('error', err);
-      });
-    });
-  },
-};
+const https = require('https');
+
+const indicators = ['Recommend.Other', 'Recommend.All', 'Recommend.MA'];
+
+function fetchScanData(tickers = [], type = '', columns = []) {
+  return new Promise((cb, err) => {
+    const req = https.request({
+      method: 'POST',
+      hostname: 'scanner.tradingview.com',
+      path: `/${type}/scan`,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (c) => { data += c; });
+      res.on('end', () => {
+        if (!data.startsWith('{')) {
+          err(new Error('Wrong screener or symbol'));
+          return;
+        }
+        try {
+          cb(JSON.parse(data));
+        } catch (error) {
+          err(new Error('Can\'t parse server response'));
+        }
+      });
+    });
+
+    req.on('error', err);
+    req.end(JSON.stringify({ symbols: { tickers }, columns }));
+  });
+}
+
+/**
+ * @typedef {number} advice
+ *
+ * @typedef {{ Other: advice, All: advice, MA: advice }} Period
+ *
+ * @typedef {{
+ *  '1': Period,
+ *  '5': Period,
+ *  '15': Period,
+ *  '60': Period,
+ *  '240': Period,
+ *  '1D': Period,
+ *  '1W': Period,
+ *  '1M': Period,
+ * }} Periods
+ *
+ * @typedef {string | 'forex' | 'crypto'
+ * | 'america' | 'australia' | 'canada' | 'egypt'
+ * | 'germany' | 'india' | 'israel' | 'italy'
+ * | 'luxembourg' | 'poland' | 'sweden' | 'turkey'
+ * | 'uk' | 'vietnam'} screener
+ * You can use `getScreener(exchange)` function for non-forex and non-crypto markets.
+ */
+
+module.exports = {
+  /**
+   * @param {string} exchange Example: BINANCE, EURONEXT, NASDAQ
+   * @returns {screener}
+  */
+  getScreener(exchange) {
+    const e = exchange.toUpperCase();
+    if (['NASDAQ', 'NYSE', 'NYSE ARCA', 'OTC'].includes(e)) return 'america';
+    if (['ASX'].includes(e)) return 'australia';
+    if (['TSX', 'TSXV', 'CSE', 'NEO'].includes(e)) return 'canada';
+    if (['EGX'].includes(e)) return 'egypt';
+    if (['FWB', 'SWB', 'XETR'].includes(e)) return 'germany';
+    if (['BSE', 'NSE'].includes(e)) return 'india';
+    if (['TASE'].includes(e)) return 'israel';
+    if (['MIL', 'MILSEDEX'].includes(e)) return 'italy';
+    if (['LUXSE'].includes(e)) return 'luxembourg';
+    if (['NEWCONNECT'].includes(e)) return 'poland';
+    if (['NGM'].includes(e)) return 'sweden';
+    if (['BIST'].includes(e)) return 'turkey';
+    if (['LSE', 'LSIN'].includes(e)) return 'uk';
+    if (['HNX'].includes(e)) return 'vietnam';
+    return exchange.toLowerCase();
+  },
+
+  /**
+   * Get technical analysis
+   * @param {screener} screener
+   * @param {string} id Full market id (Example: COINBASE:BTCEUR)
+   * @returns {Promise<Periods>} results
+   */
+  async getTA(screener, id) {
+    const advice = {};
+
+    const cols = ['1', '5', '15', '60', '240', '1D', '1W', '1M']
+      .map((t) => indicators.map((i) => (t !== '1D' ? `${i}|${t}` : i)))
+      .flat();
+
+    const rs = await fetchScanData([id], screener, cols);
+    if (!rs.data || !rs.data[0]) return false;
+
+    rs.data[0].d.forEach((val, i) => {
+      const [name, period] = cols[i].split('|');
+      const pName = period || '1D';
+      if (!advice[pName]) advice[pName] = {};
+      advice[pName][name.split('.').pop()] = Math.round(val * 1000) / 500;
+    });
+
+    return advice;
+  },
+
+  /**
+   * @typedef {Object} SearchResult
+   * @property {string} id
+   * @property {string} exchange
+   * @property {string} fullExchange
+   * @property {string} screener
+   * @property {string} symbol
+   * @property {string} description
+   * @property {string} type
+   * @property {() => Promise<Periods>} getTA
+   */
+
+  /**
+   * Find a symbol
+   * @param {string} search Keywords
+   * @param {'stock' | 'futures' | 'forex' | 'cfd' | 'crypto' | 'index' | 'economic'} [filter]
+   * @returns {Promise<SearchResult[]>} Search results
+   */
+  async search(search, filter = '') {
+    return new Promise((cb, err) => {
+      https.get({
+        host: 'symbol-search.tradingview.com',
+        path: `/symbol_search/?text=${search.replace(/ /g, '%20')}&type=${filter}`,
+        origin: 'https://www.tradingview.com',
+      }, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', () => {
+          try {
+            rs = JSON.parse(rs);
+          } catch (e) {
+            err(new Error('Can\'t parse server response'));
+            return;
+          }
+
+          cb(rs.map((s) => {
+            const exchange = s.exchange.split(' ')[0];
+            const id = `${exchange}:${s.symbol}`;
+
+            const screener = (['forex', 'crypto'].includes(s.type)
+              ? s.type
+              : this.getScreener(exchange)
+            );
+
+            return {
+              id,
+              exchange,
+              fullExchange: s.exchange,
+              screener,
+              symbol: s.symbol,
+              description: s.description,
+              type: s.type,
+              getTA: () => this.getTA(screener, id),
+            };
+          }));
+        });
+
+        res.on('error', err);
+      });
+    });
+  },
+
+  /**
+   * @typedef {Object} indicatorInput
+   * @property {string} name
+   * @property {string} inline Inline name
+   * @property { 'text' | 'source' | 'integer' | 'float' | 'resolution' | 'bool' } type
+   * @property {string | number | boolean} value
+   * @property {string | number | boolean} defVal
+   * @property {boolean} hidden
+   * @property {boolean} isFake
+   * @property {string[]} [options]
+   */
+
+  /**
+   * @typedef {Object} Indicator
+   * @property {string} pineId Indicator ID
+   * @property {string} pineVersion Indicator version
+   * @property {string} description Indicator description
+   * @property {string} shortDescription Indicator short description
+   * @property {Object<string, indicatorInput>} inputs Indicator inputs
+   * @property {Object<string, string>} plots Indicator plots
+   * @property {string} script Indicator script
+   */
+
+  /**
+   * Get an indicator
+   * @param {string} id Indicator ID (Like: PUB;XXXXXXXXXXXXXXXXXXXXX)
+   * @param {string} version Wanted version of the indicator
+   * @returns {Promise<Indicator>} Indicator
+   */
+  async getIndicator(id, version, settings = []) {
+    return new Promise((cb, err) => {
+      https.get(`https://pine-facade.tradingview.com/pine-facade/translate/${id}/${version}`, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', () => {
+          try {
+            rs = JSON.parse(rs);
+          } catch (e) {
+            err(new Error('Inexistent or unsupported indicator'));
+            return;
+          }
+
+          if (!rs.success || !rs.result.metaInfo || !rs.result.metaInfo.inputs) {
+            err(new Error('Inexistent or unsupported indicator'));
+            return;
+          }
+
+          const inputs = {};
+
+          rs.result.metaInfo.inputs.forEach((input) => {
+            if (['text', 'pineId', 'pineVersion'].includes(input.id)) return;
+            const inline = input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9]/g, '');
+
+            const i = parseInt(input.id.replace(/[^0-9]/g, ''), 10);
+
+            inputs[input.id] = {
+              name: input.name,
+              type: input.type,
+              value: settings[i] ?? input.defval,
+              defVal: input.defval,
+              hidden: !!input.isHidden,
+              isFake: !!input.isFake,
+              inline,
+            };
+
+            if (input.options) inputs[input.id].options = input.options;
+          });
+
+          const plots = {};
+
+          Object.keys(rs.result.metaInfo.styles).forEach((plotId) => {
+            plots[plotId] = rs.result.metaInfo.styles[plotId].title.replace(/ /g, '_').replace(/[^a-zA-Z0-9]/g, '');
+          });
+
+          cb({
+            pineId: id,
+            pineVersion: version,
+            description: rs.result.metaInfo.description,
+            shortDescription: rs.result.metaInfo.shortDescription,
+            inputs,
+            plots,
+            script: rs.result.ilTemplate,
+          });
+        });
+
+        res.on('error', err);
+      });
+    });
+  },
+
+  /**
+   * @typedef {Object} User Instance of User
+   * @property {number} id User ID
+   * @property {string} username User username
+   * @property {string} firstName User first name
+   * @property {string} lastName User last name
+   * @property {number} reputation User reputation
+   * @property {number} following Number of following accounts
+   * @property {number} followers Number of followers
+   * @property {Object} notifications User's notifications
+   * @property {number} notifications.user User notifications
+   * @property {number} notifications.following Notification from following accounts
+   * @property {string} session User session
+   * @property {string} sessionHash User session hash
+   * @property {string} privateChannel User private channel
+   * @property {string} authToken User auth token
+   * @property {Date} joinDate Account creation date
+   */
+
+  /**
+   * Get a token for an user from a 'sessionid' cookie
+   * @param {string} session User 'sessionid' cookie
+   * @param {string} [location] Auth page location (For france: https://fr.tradingview.com/)
+   * @returns {Promise<User>} Token
+   */
+  async getUser(session, location = 'https://www.tradingview.com/') {
+    return new Promise((cb, err) => {
+      https.get(location, {
+        headers: { cookie: `sessionid=${session}` },
+      }, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', async () => {
+          if (res.headers.location && location !== res.headers.location) {
+            cb(await module.exports.getUser(session, res.headers.location));
+            return;
+          }
+          if (rs.includes('auth_token')) {
+            cb({
+              id: /"id":([0-9]{1,10}),/.exec(rs)[1],
+              username: /"username":"(.*?)"/.exec(rs)[1],
+              firstName: /"first_name":"(.*?)"/.exec(rs)[1],
+              lastName: /"last_name":"(.*?)"/.exec(rs)[1],
+              reputation: parseFloat(/"reputation":(.*?),/.exec(rs)[1] || 0),
+              following: parseFloat(/,"following":([0-9]*?),/.exec(rs)[1] || 0),
+              followers: parseFloat(/,"followers":([0-9]*?),/.exec(rs)[1] || 0),
+              notifications: {
+                following: parseFloat(/"notification_count":\{"following":([0-9]*),/.exec(rs)[1] || 0),
+                user: parseFloat(/"notification_count":\{"following":[0-9]*,"user":([0-9]*)/.exec(rs)[1] || 0),
+              },
+              session,
+              sessionHash: /"session_hash":"(.*?)"/.exec(rs)[1],
+              privateChannel: /"private_channel":"(.*?)"/.exec(rs)[1],
+              authToken: /"auth_token":"(.*?)"/.exec(rs)[1],
+              joinDate: new Date(/"date_joined":"(.*?)"/.exec(rs)[1] || 0),
+            });
+          } else err(new Error('Wrong or expired sessionid'));
+        });
+
+        res.on('error', err);
+      }).end();
+    });
+  },
+
+  /**
+   * User credentials
+   * @typedef {Object} UserCredentials
+   * @property {number} id User ID
+   * @property {string} session User session ('sessionid' cookie)
+   */
+
+  /**
+   * Get a chart token from a layout ID and the user credentials if the layout is not public
+   * @param {string} layout The layout ID found in the layout URL (Like: 'XXXXXXXX')
+   * @param {UserCredentials} [credentials] User credentials (id + session)
+   * @returns {Promise<string>} Token
+   */
+  async getChartToken(layout, credentials = {}) {
+    return new Promise((cb, err) => {
+      const creds = credentials.id && credentials.session;
+      const userID = creds ? credentials.id : -1;
+      const session = creds ? credentials.session : null;
+
+      https.get(`https://www.tradingview.com/chart-token/?image_url=${layout}&user_id=${userID}`, {
+        headers: { cookie: session ? `sessionid=${session}` : '' },
+      }, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', async () => {
+          rs = JSON.parse(rs);
+
+          if (rs.token) cb(rs.token);
+          else err(new Error('Wrong layout or credentials'));
+        });
+
+        res.on('error', err);
+      }).end();
+    });
+  },
+
+  /**
+   * @typedef {Object} DrawingPoint
+   * @property {number} time_t Point X time position
+   * @property {number} price Point Y price position
+   * @property {number} offset Point offset
+   */
+
+  /**
+   * @typedef {Object} Drawing
+   * @property {string} id Drawing ID (Like: 'XXXXXX')
+   * @property {string} symbol Layout market symbol (Like: 'BINANCE:BUCEUR')
+   * @property {string} ownerSource Owner user ID (Like: 'XXXXXX')
+   * @property {string} serverUpdateTime Drawing last update timestamp
+   * @property {string} currencyId Currency ID (Like: 'EUR')
+   * @property {any} unitId Unit ID
+   * @property {string} type Drawing type
+   * @property {DrawingPoint[]} points List of drawing points
+   * @property {number} zorder Drawing Z order
+   * @property {string} linkKey Drawing link key
+   * @property {Object} state Drawing state
+   */
+
+  /**
+   * Get a chart token from a layout ID and the user credentials if the layout is not public
+   * @param {string} layout The layout ID found in the layout URL (Like: 'XXXXXXXX')
+   * @param {string | ''} [symbol] Market filter (Like: 'BINANCE:BTCEUR')
+   * @param {UserCredentials} [credentials] User credentials (id + session)
+   * @param {number} [chartID = 1] Chart ID
+   * @returns {Promise<Drawing[]>} Drawings
+   */
+  async getDrawings(layout, symbol = '', credentials = {}, chartID = 1) {
+    const chartToken = await module.exports.getChartToken(layout, credentials);
+
+    return new Promise((cb, err) => {
+      const creds = credentials.id && credentials.session;
+      const session = creds ? credentials.session : null;
+
+      const url = `https://charts-storage.tradingview.com/charts-storage/layout/${
+        layout}/sources?chart_id=${chartID}&jwt=${chartToken}${symbol ? `&symbol=${symbol}` : ''}`;
+
+      https.get(url, {
+        headers: { cookie: session ? `sessionid=${session}` : '' },
+      }, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', async () => {
+          rs = JSON.parse(rs);
+
+          if (rs.payload) {
+            cb(Object.values(rs.payload.sources || {}).map((drawing) => ({
+              ...drawing, ...drawing.state,
+            })));
+          } else err(new Error('Wrong layout, user credentials, or chart id.'));
+        });
+
+        res.on('error', err);
+      }).end();
+    });
+  },
+};

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@mathieuc/tradingview",
-  "version": "2.0.1",
-  "description": "Tradingview instant stocks API",
+  "version": "2.0.7",
+  "description": "Tradingview instant stocks API, indicator alerts, trading bot, and more !",
   "main": "main.js",
   "scripts": {
     "test-prices": "node ./tests/prices.js",
     "test-analysis": "node ./tests/analysis.js",
     "test-indicator": "node ./tests/indicator.js",
-    "test-alerts": "node ./tests/alerts/alerts.js",
-    "start-prices": "npm test"
+    "test-manual-alerts": "node ./tests/alerts/manualAlert.js",
+    "test-strat-alerts": "node ./tests/alerts/strategyAlert.js",
+    "test": "npm run test-prices"
   },
   "keywords": [
     "tradingwiew",

package/tests/alerts/drawings.js

@@ -0,0 +1,41 @@
+require('./envLoader');
+const marketAPI = require('../../main');
+
+if (!process.env.LAYOUT_ID) console.error('You need to set a layout id');
+
+const market = marketAPI(false);
+
+console.log('Connecting...');
+
+(async () => {
+  /*
+  * Important ! If you want to get a layout without login, you have to
+  * set it in public mode. If you get an error, please wait few minutes.
+  * Try getting to https://www.tradingview.com/chart/LAYOUT_ID/ in incognito mode.
+  */
+  const user = (process.env.SESSION_ID) ? await market.getUser(process.env.SESSION_ID) : {};
+  console.log('Connected as', user.firstName || user.username || 'anonymous', '!');
+
+  console.log(`Gettings drawings of '${process.env.LAYOUT_ID}' layout...`);
+
+  const drawings = await market.getDrawings(process.env.LAYOUT_ID, '', {
+    id: user.id,
+    session: user.session,
+  });
+
+  const lines = drawings.filter((d) => (
+    ['LineToolHorzLine', 'LineToolRay', 'LineToolTrendLine', 'LineToolHorzRay'].includes(d.type)
+    && d.state.linestyle === 0
+    && d.state.linewidth === 4
+  ));
+
+  console.log(
+    `Found ${drawings.length} result(s) including ${lines.length} thick line(s):`,
+    lines.map((l) => ({
+      market: l.symbol,
+      type: l.type,
+      points: l.points,
+      text: l.state.text,
+    })),
+  );
+})();

package/tests/alerts/{alerts.js → manualAlert.js}

@@ -1,4 +1,5 @@
 require('./envLoader');
+const { getSentNotifs, addSentNotifs } = require('./sentNotifs');
 const marketAPI = require('../../main');
 const discordWH = require('./discordWH')(process.env.DISCORD_TOKEN);
 
@@ -7,8 +8,6 @@ if (!process.env.PERIOD) process.env.PERIOD = '240';
 
 const market = marketAPI(false);
 
-const sentNotifs = [];
-
 market.on('logged', () => {
   process.env.SYMBOLS.split(',').forEach((symbol) => {
     console.log('Listen', symbol);
@@ -39,20 +38,6 @@ market.on('logged', () => {
     }, (periods) => {
       if (!periods[0].CIPHER_B) return;
 
-      // periods.forEach((p, i) => {
-      //   if (p.CIPHER_B.WTWave1 > 0 || p.CIPHER_B.WTWave1 < -35) return;
-
-      //   const pBefore = periods[i + 1];
-      //   if (!pBefore) return;
-
-      //   const gapBefore = pBefore.CIPHER_B.VWAP;
-      //   const gap = p.CIPHER_B.VWAP;
-      //   if (
-      //     gapBefore < 0 && gapBefore < gap
-      //     && pBefore.CIPHER_B.WTWave1 < p.CIPHER_B.WTWave1
-      //   ) console.log(symbol, 'TRIG', new Date(p.$time * 1000).toLocaleString());
-      // });
-
       const pBefore = periods[1];
       const p = periods[0];
 
@@ -62,12 +47,12 @@ market.on('logged', () => {
       const notifID = `${symbol}@${p.$time}@BULL_TRIGGER`;
 
       if (
-        !sentNotifs.includes(notifID)
-        && p.CIPHER_B.WTWave1 <= 0 && p.CIPHER_B.WTWave1 > -35
+        p.CIPHER_B.WTWave1 <= 0 && p.CIPHER_B.WTWave1 > -35
         && gapBefore < 0 && gapBefore < gap
         && pBefore.CIPHER_B.WTWave1 < p.CIPHER_B.WTWave1
+        && !getSentNotifs().includes(notifID)
       ) {
-        sentNotifs.push(notifID);
+        addSentNotifs(notifID);
         console.log(symbol, 'TRIG NOW', new Date(p.$time * 1000).toLocaleString());
 
         discordWH({

package/tests/alerts/sentNotifs.js

@@ -0,0 +1,16 @@
+const fs = require('fs');
+
+const sentNotifsFile = './sentNotifs.txt';
+
+exports.getSentNotifs = () => {
+  if (!fs.existsSync(sentNotifsFile)) fs.writeFileSync(sentNotifsFile, '');
+  return (fs.readFileSync(sentNotifsFile, 'utf8') || '').split(';').filter((n) => n);
+};
+
+exports.addSentNotifs = (notif = '') => {
+  if (!fs.existsSync(sentNotifsFile)) fs.writeFileSync(sentNotifsFile, '');
+  fs.writeFileSync(
+    sentNotifsFile,
+    `${fs.readFileSync(sentNotifsFile, 'utf8') || ''}${notif};`,
+  );
+};

package/tests/alerts/strategyAlert.js

@@ -0,0 +1,94 @@
+require('./envLoader');
+const { getSentNotifs, addSentNotifs } = require('./sentNotifs');
+const marketAPI = require('../../main');
+const discordWH = require('./discordWH')(process.env.DISCORD_TOKEN);
+
+const markets = [
+  {
+    symbol: 'EURUSD',
+    period: '1D',
+    settings: {
+      1: 21, // HMA 1 Length
+      3: 89, // HMA 2 Length
+      5: 7, // RSI Length
+      8: 2, // Stop Loss (%)
+      9: 1, // Take Profit (%)
+    },
+  },
+  {
+    symbol: 'GBPUSD',
+    period: '1D',
+    settings: {
+      1: 220, // HMA 1 Length
+      3: 150, // HMA 2 Length
+      5: 1, // RSI Length
+      8: 2, // Stop Loss (%)
+      9: 1, // Take Profit (%)
+    },
+  },
+  {
+    symbol: 'USDCAD',
+    period: '1D',
+    settings: {
+      1: 21, // HMA 1 Length
+      3: 89, // HMA 2 Length
+      5: 10, // RSI Length
+      8: 3, // Stop Loss (%)
+      9: 2, // Take Profit (%)
+    },
+  },
+];
+
+const market = marketAPI(false);
+
+market.on('logged', () => {
+  markets.forEach((mrk) => {
+    console.log('Listen', mrk.symbol);
+
+    market.initChart({
+      symbol: mrk.symbol,
+      period: mrk.period || '1D',
+      range: mrk.range || 30,
+      timezone: mrk.timezone || 'Europe/Paris',
+      indicators: [
+        // My Magimix Indicator
+        {
+          name: 'MAGIMIX',
+          id: 'USER;d90a5e852ddc439b994db6beff14d702',
+          version: mrk.version || 'last',
+          settings: mrk.settings || [],
+        },
+      ],
+    }, ({ 0: p }) => {
+      if (!p.MAGIMIX) return;
+
+      const signalType = p.MAGIMIX.Longsignal ? 'LONG' : 'SHORT';
+      const notifID = `${mrk.symbol}@MAGIMIX@${p.$time}@${signalType}`;
+
+      if (
+        (p.MAGIMIX.Longsignal || p.MAGIMIX.Shortsignal)
+        && !getSentNotifs().includes(notifID)
+      ) {
+        addSentNotifs(notifID);
+        console.log(mrk.symbol, 'SIGNAL', new Date(p.$time * 1000).toLocaleString());
+
+        discordWH({
+          content: process.env.DISCORD_MENTION,
+          embeds: [
+            {
+              title: `Magimix ${signalType} signal for ${mrk.symbol} !`,
+              color: p.MAGIMIX.Longsignal ? 3066993 : 15158332,
+              description: `Magimix ${signalType} signal for ${mrk.symbol} at ${p.$prices.close} !`,
+              url: `https://fr.tradingview.com/chart/?symbol=${mrk.symbol}`,
+              timestamp: new Date(p.$time * 1000),
+              footer: {
+                text: 'TradingView',
+                icon_url: 'https://tradingview.com/favicon.ico',
+              },
+            },
+          ],
+        });
+      }
+    });
+  });
+});

package/tests/analysis.js

@@ -1,13 +1,13 @@
-const marketAPI = require('../main');
-
-const market = marketAPI();
-
-market.on('logged', async () => {
-  const searchBTC = (await market.search('bitcoin euro', 'crypto'))[0];
-  console.log('Found Bitcoin / Euro:', searchBTC);
-
-  const TA = await searchBTC.getTA();
-  console.log('Full technical analysis for Bitcoin:', TA);
-
-  // You can also use this way: await market.getTA('crypto', 'BINANCE:BTCEUR');
-});
+const marketAPI = require('../main');
+
+(async () => {
+  const market = marketAPI(false);
+
+  const searchBTC = (await market.search('bitcoin euro', 'crypto'))[0];
+  console.log('Found Bitcoin / Euro:', searchBTC);
+
+  const TA = await searchBTC.getTA();
+  console.log('Full technical analysis for Bitcoin:', TA);
+
+  // You can also use this way: await market.getTA('crypto', 'BINANCE:BTCEUR');
+})();

package/tests/alerts/.env

@@ -1,4 +0,0 @@
-DISCORD_TOKEN=880092944634347550/EAH07CPb-FgNcXbhXZECIFaIJHBXAF55GUks-q2I6UR-A0VbekxtiJ4ZszeZ1xo-h8-0
-DISCORD_MENTION=<@&880092218692612197>
-SYMBOLS=BTCUSD,ETHUSD,EURUSD,EURAUD,GBPUSD
-PERIOD=60