fca-smart-shankar 10.9.1 → 13.0.0

package/src/getThreadHistoryDeprecated.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getThreadHistory(threadID, amount, timestamp, callback) {
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    if (!callback) {
+      throw { error: "getThreadHistory: need callback" };
+    }
+
+    var form = {
+      client: "mercury"
+    };
+
+    api.getUserInfo(threadID, function(err, res) {
+      if (err) {
+        return callback(err);
+      }
+      var key = Object.keys(res).length > 0 ? "user_ids" : "thread_fbids";
+      form["messages[" + key + "][" + threadID + "][offset]"] = 0;
+      form["messages[" + key + "][" + threadID + "][timestamp]"] = timestamp;
+      form["messages[" + key + "][" + threadID + "][limit]"] = amount;
+
+      if (ctx.globalOptions.pageID)
+        form.request_user_id = ctx.globalOptions.pageID;
+
+      defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/thread_info.php",
+          ctx.jar,
+          form
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function(resData) {
+          if (resData.error) {
+            throw resData;
+          } else if (!resData.payload) {
+            throw { error: "Could not retrieve thread history." };
+          }
+
+          // Asking for message history from a thread with no message history
+          // will return undefined for actions here
+          if (!resData.payload.actions) {
+            resData.payload.actions = [];
+          }
+
+          var userIDs = {};
+          resData.payload.actions.forEach(function(v) {
+            userIDs[v.author.split(":").pop()] = "";
+          });
+
+          api.getUserInfo(Object.keys(userIDs), function(err, data) {
+            if (err) return callback(err); //callback({error: "Could not retrieve user information in getThreadHistory."});
+
+            resData.payload.actions.forEach(function(v) {
+              var sender = data[v.author.split(":").pop()];
+              if (sender) v.sender_name = sender.name;
+              else v.sender_name = "Facebook User";
+              v.sender_fbid = v.author;
+              delete v.author;
+            });
+
+            callback(
+              null,
+              resData.payload.actions.map(utils.formatHistoryMessage)
+            );
+          });
+        })
+        .catch(function(err) {
+          log.error("getThreadHistory", err);
+          return callback(err);
+        });
+    });
+    return returnPromise;
+  };
+};

package/src/getThreadInfo.js

@@ -1,8 +1,8 @@
-/* eslint-disable linebreak-style */
 "use strict";
 
-var utils = require("../utils");
-// tương lai đi rồi fix ahahha
+const utils = require("../utils");
+const log = require("npmlog");
+
 function formatEventReminders(reminder) {
   return {
     reminderID: reminder.id,
@@ -10,7 +10,6 @@ function formatEventReminders(reminder) {
     time: reminder.time,
     eventType: reminder.lightweight_event_type.toLowerCase(),
     locationName: reminder.location_name,
-    // @TODO verify this
     locationCoordinates: reminder.location_coordinates,
     locationPage: reminder.location_page,
     eventStatus: reminder.lightweight_event_status.toLowerCase(),
@@ -21,29 +20,26 @@ function formatEventReminders(reminder) {
     secondsToNotifyBefore: reminder.seconds_to_notify_before,
     allowsRsvp: reminder.allows_rsvp,
     relatedEvent: reminder.related_event,
-    members: reminder.event_reminder_members.edges.map(function(member) {
+    members: reminder.event_reminder_members.edges.map(function (member) {
       return {
         memberID: member.node.id,
-        state: member.guest_list_state.toLowerCase()
+        state: member.guest_list_state.toLowerCase(),
       };
-    })
+    }),
   };
 }
 
 function formatThreadGraphQLResponse(data) {
-  try{
-    var messageThread = data.message_thread;
-  } catch (err){
-    console.error("GetThreadInfoGraphQL", "Can't get this thread info!");
-    return {err: err};
-  }
-  var threadID = messageThread.thread_key.thread_fbid
+  if (data.errors) return null; // Return null if there are errors
+  const messageThread = data.message_thread;
+  if (!messageThread) return null;
+
+  const threadID = messageThread.thread_key.thread_fbid
     ? messageThread.thread_key.thread_fbid
     : messageThread.thread_key.other_user_id;
 
-  // Remove me
-  var lastM = messageThread.last_message;
-  var snippetID =
+  const lastM = messageThread.last_message;
+  const snippetID =
     lastM &&
     lastM.nodes &&
     lastM.nodes[0] &&
@@ -51,10 +47,10 @@ function formatThreadGraphQLResponse(data) {
     lastM.nodes[0].message_sender.messaging_actor
       ? lastM.nodes[0].message_sender.messaging_actor.id
       : null;
-  var snippetText =
+  const snippetText =
     lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
-  var lastR = messageThread.last_read_receipt;
-  var lastReadTimestamp =
+  const lastR = messageThread.last_read_receipt;
+  const lastReadTimestamp =
     lastR && lastR.nodes && lastR.nodes[0] && lastR.nodes[0].timestamp_precise
       ? lastR.nodes[0].timestamp_precise
       : null;
@@ -62,18 +58,21 @@ function formatThreadGraphQLResponse(data) {
   return {
     threadID: threadID,
     threadName: messageThread.name,
-    participantIDs: messageThread.all_participants.edges.map(d => d.node.messaging_actor.id),
-    userInfo: messageThread.all_participants.edges.map(d => ({
+    participantIDs: messageThread.all_participants.edges.map(
+      (d) => d.node.messaging_actor.id,
+    ),
+    userInfo: messageThread.all_participants.edges.map((d) => ({
       id: d.node.messaging_actor.id,
       name: d.node.messaging_actor.name,
       firstName: d.node.messaging_actor.short_name,
       vanity: d.node.messaging_actor.username,
+      url: d.node.messaging_actor.url,
       thumbSrc: d.node.messaging_actor.big_image_src.uri,
       profileUrl: d.node.messaging_actor.big_image_src.uri,
       gender: d.node.messaging_actor.gender,
       type: d.node.messaging_actor.__typename,
       isFriend: d.node.messaging_actor.is_viewer_friend,
-      isBirthday: !!d.node.messaging_actor.is_birthday //not sure?
+      isBirthday: !!d.node.messaging_actor.is_birthday,
     })),
     unreadCount: messageThread.unread_count,
     messageCount: messageThread.messages_count,
@@ -95,33 +94,30 @@ function formatThreadGraphQLResponse(data) {
       messageThread.customization_info.outgoing_bubble_color
         ? messageThread.customization_info.outgoing_bubble_color.slice(2)
         : null,
+    threadTheme: messageThread.thread_theme,
     nicknames:
       messageThread.customization_info &&
       messageThread.customization_info.participant_customizations
         ? messageThread.customization_info.participant_customizations.reduce(
-            function(res, val) {
+            function (res, val) {
               if (val.nickname) res[val.participant_id] = val.nickname;
               return res;
             },
-            {}
+            {},
           )
         : {},
     adminIDs: messageThread.thread_admins,
     approvalMode: Boolean(messageThread.approval_mode),
-    approvalQueue: messageThread.group_approval_queue.nodes.map(a => ({
+    approvalQueue: messageThread.group_approval_queue.nodes.map((a) => ({
       inviterID: a.inviter.id,
       requesterID: a.requester.id,
       timestamp: a.request_timestamp,
-      request_source: a.request_source // @Undocumented
+      request_source: a.request_source,
     })),
-
-    // @Undocumented
     reactionsMuteMode: messageThread.reactions_mute_mode.toLowerCase(),
     mentionsMuteMode: messageThread.mentions_mute_mode.toLowerCase(),
     isPinProtected: messageThread.is_pin_protected,
     relatedPageThread: messageThread.related_page_thread,
-
-    // @Legacy
     name: messageThread.name,
     snippet: snippetText,
     snippetSender: snippetID,
@@ -140,51 +136,30 @@ function formatThreadGraphQLResponse(data) {
     lastMessageType: "message",
     lastReadTimestamp: lastReadTimestamp,
     threadType: messageThread.thread_type == "GROUP" ? 2 : 1,
-    TimeCreate: Date.now(),
-    TimeUpdate: Date.now()
+    inviteLink: {
+      enable: messageThread.joinable_mode
+        ? messageThread.joinable_mode.mode == 1
+        : false,
+      link: messageThread.joinable_mode
+        ? messageThread.joinable_mode.link
+        : null,
+    },
   };
 }
 
-const MAX_ARRAY_LENGTH = 6; //safe 
-var Request_Update_Time = 0;
-var updateInterval;
-var updateTimeout;
-let Queues = [];
-
-let onetimecook = false
-
-function addToQueues(num) {
-  const existingArray = Queues.some(subArr => subArr.some(obj => obj.threadID == num.threadID));
-
-  if (!existingArray) {
-    if (Queues.length > 0 && Queues[Queues.length - 1].length === MAX_ARRAY_LENGTH) {
-      Queues.push([num]);
-    } else {
-      const lastArray = Queues.length > 0 ? Queues[Queues.length - 1] : [];
-      lastArray.push(num);
-
-      if (Queues.length === 0) {
-        Queues.push(lastArray);
-      }
-    }
-  }
-}
-
-
-module.exports = function(defaultFuncs, api, ctx) {
-
-  var { createData,getData,hasData,updateData, getAll } = require('../Extra/ExtraGetThread');
-  var Database = require('../Extra/Database');
-  
-  return async function getThreadInfoGraphQL(threadID, callback) {
-    var resolveFunc = function(){};
-    var rejectFunc = function(){};
-    var returnPromise = new Promise(function (resolve, reject) {
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadInfoGraphQL(threadID, callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
 
-    if (utils.getType(callback) != "Function" && utils.getType(callback) != "AsyncFunction") {
+    if (
+      utils.getType(callback) != "Function" &&
+      utils.getType(callback) != "AsyncFunction"
+    ) {
       callback = function (err, data) {
         if (err) {
           return rejectFunc(err);
@@ -192,233 +167,61 @@ module.exports = function(defaultFuncs, api, ctx) {
         resolveFunc(data);
       };
     }
-    
-    if (utils.getType(threadID) !== "Array") threadID = [threadID];
 
+    if (utils.getType(threadID) !== "Array") {
+      threadID = [threadID];
+    }
 
-    if (utils.getType(global.Fca.Data.Userinfo) == "Array" || global.Fca.Data.Userinfo == undefined) global.Fca.Data.Userinfo = new Map();
+    let form = {};
+    threadID.map(function (t, i) {
+      form["o" + i] = {
+        doc_id: "3449967031715030",
+        query_params: {
+          id: t,
+          message_limit: 0,
+          load_messages: false,
+          load_read_receipts: false,
+          before: null,
+        },
+      };
+    });
 
-    const updateUserInfo = (threadInfo) => {
-      if (!global.Fca.Data.Userinfo) {
-        global.Fca.Data.Userinfo = new Map();
-      }
-    
-      threadInfo.forEach(thread => {
-        const userInfo = thread.userInfo;
-    
-        if (Array.isArray(userInfo)) {
-          const userInfoMap = new Map(userInfo.map(user => [user.id, user]));
-          for (const [id, user] of userInfoMap) {
-            global.Fca.Data.Userinfo.set(id, user);
-          }
-        }
-      });
+    form = {
+      queries: JSON.stringify(form),
+      batch_name: "MessengerGraphQLThreadFetcher",
     };
-  
-  const getMultiInfo = async function (threadIDs) {
-      let form = {};
-      let tempThreadInf = [];
-          threadIDs.forEach((x,y) => {
-              form["o" + y] = {
-                  doc_id: "3449967031715030",
-                  query_params: { id: x, message_limit: 0, load_messages: false, load_read_receipts: false, before: null }
-              }; 
-          });
-      let Submit = { queries: JSON.stringify(form), batch_name: "MessengerGraphQLThreadFetcher" };
-          
-      const promise = new Promise((resolve, reject) => {
-          defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, Submit)
-          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-          .then(resData => {
-              if (resData.error || resData[resData.length - 1].error_results !== 0) throw "Lỗi: getThreadInfoGraphQL Có Thể Do Bạn Spam Quá Nhiều";
-                  resData = resData.slice(0, -1).sort((a, b) => Object.keys(a)[0].localeCompare(Object.keys(b)[0]));
-                  resData.forEach((x, y) => tempThreadInf.push(formatThreadGraphQLResponse(x["o" + y].data)));
-                  return resolve({
-                      Success: true,
-                      Data: tempThreadInf
-                  });
-          })
-          .catch(() => { 
-              reject({ Success: false, Data: '' }) 
-          });
-      })
-  
-      return await promise;
-  }
-  
-  const formatAndUpdateData = (AllThreadInfo) => {
-      try {
-          AllThreadInfo.forEach(threadInf => { updateData(threadInf.threadID, threadInf); })
-          updateUserInfo(AllThreadInfo) // [ {}, {} ]
-  
-      } catch (e) {
-          console.log(e);
-      }
-  }
 
-  const formatAndCreateData = (AllThreadInfo) => {
-    try {
-        AllThreadInfo.forEach(threadInf => { createData(threadInf.threadID, threadInf); })
-        updateUserInfo(AllThreadInfo) // [ {}, {} ]
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) {
+          throw resData;
+        }
 
-    } catch (e) {
-        console.log(e);
-    }
-}
-  
-  const checkAverageStaticTimestamp = function (avgTimeStamp) {
-    const DEFAULT_UPDATE_TIME = 900 * 1000; //thời gian cập nhật tối đa + với thời gian trung bình của tổng request 1 mảng
-    //khi request phút thứ 3, 1 req ở phút thứ 7, 1 req ở phút thứ 10, vậy trung bình là (3+7+1) / time.length (3) + với 15p = tg trung bình để cập nhật 1 mảng
-    const MAXIMUM_ERROR_TIME = 10 * 1000;
-    return { //khi check = false thì cần cập nhật vì đã hơn thời gian tb + 15p
-        Check:  (parseInt(avgTimeStamp) + parseInt(DEFAULT_UPDATE_TIME)) + parseInt(MAXIMUM_ERROR_TIME) >= Date.now(), // ở đây avgTimeStamp là thời gian cố định của 1 mảng queue khi đầy 
-        timeLeft: (parseInt(avgTimeStamp) + parseInt(DEFAULT_UPDATE_TIME)) - Date.now() + parseInt(MAXIMUM_ERROR_TIME)
-    }
-  }
-  
-  const autoCheckAndUpdateRecallTime = () => {
-      let holdTime = [];
-      let oneTimeCall = false;
-      //lấy tất cả trung bình thời gian của tất cả mảng và tìm thời gian còn lại ngắn nhất, nếu có sẵn id cần cập nhật thì cập nhật ngày lập tức
-      Queues.forEach((i, index) => {
-          // [ { threadID, TimeCreate }, {} ]
-          const averageTimestamp = Math.round(i.reduce((acc, obj) => acc + obj.TimeCreate, 0) / i.length);
-          const DataAvg = checkAverageStaticTimestamp(averageTimestamp);
-          if (DataAvg.Check) {
-            //cần chờ
-             // holdTime.push(DataAvg.timeLeft);
-             //cho thi cho 10s sau check lai roi cho tiep nhe =))
+        const threadInfos = {};
+        for (let i = resData.length - 2; i >= 0; i--) {
+          const threadInfo = formatThreadGraphQLResponse(
+            resData[i][Object.keys(resData[i])[0]].data,
+          );
+          if (threadInfo) { // Only add valid threadInfo
+            threadInfos[
+              threadInfo.threadID || threadID[threadID.length - 1 - i]
+            ] = threadInfo;
           }
-          else {
-            oneTimeCall = true;
-          }
-      });
-
-      if (oneTimeCall) autoUpdateData(); // cập nhật ngay, nhin la biet tot hon hold roi =))
-
-      // if (holdTime.length >= 1) {
-      //     holdTime.sort((a,b) => a - b) //low to high time
-      //     if (holdTime[0] > Request_Update_Time) {
-      //         Request_Update_Time = holdTime[0];
-      //         clearInterval(updateInterval);
-      //         updateInterval = setInterval(() => { autoUpdateData(); }, holdTime[0])
-      //     }
-      // }
-
-      //hold lam cai cho gi khi ta co check lien tuc 10s 1 lan 😔
+        }
 
-      const MAXIMUM_RECALL_TIME = 30 * 1000;
-      clearTimeout(updateTimeout);
-      updateTimeout = setTimeout(() => { autoCheckAndUpdateRecallTime(); }, MAXIMUM_RECALL_TIME)
-  }
-  
-  const autoUpdateData = async function() {
-      //[ [ {}, {} ], [ {}, {}  ] ]
-      let doUpdate = [];
-      let holdTime = [];
-  
-      Queues.forEach((i, index) => {
-          // [ {}, {} ]
-          const averageTimestamp = Math.round(i.reduce((acc, obj) => acc + obj.TimeCreate, 0) / i.length);
-          // thời gian trung bình của 1 mảng từ lúc bắt đầu request lần đầu, cần + thêm thời gian cố định là 15p !
-  
-          const DataAvg = checkAverageStaticTimestamp(averageTimestamp)
-          if (DataAvg.Check) {
-              // chờ tiếp
-          }
-          else {
-            // đã hơn thời gian 15p
-              doUpdate.push(i) // [ {}, {} ]
-              Queues.splice(index, 1); //đạt điều kiện nên xoá để tý nó tự thêm 💀
-          }
-  
-      });
-  
-      if (doUpdate.length >= 1) {
-          // maybe [ [ {}, {} ] [ {}, {} ] ]
-          let ids = []; // [ id, id ]
-          doUpdate.forEach(i => {
-              //[ {} {} ]
-              const onlyThreadID = [...new Set(i.map(obj => obj.threadID))]; // [ id1, id2 ]
-              ids.push(onlyThreadID) //[ [ id1, id2 ] ]
-          })
-  
-          // [ [ id1, id2 ],[ id1, id2 ] ] 5 per arr
-  
-          ids.forEach(async function(i) {
-              const dataResp = await getMultiInfo(i);
-              if (dataResp.Success == true) {
-                  let MultiThread = dataResp.Data;
-                  formatAndUpdateData(MultiThread)
-              }
-              else {
-                  global.Fca.Require.logger.Warning('CANT NOT GET THREADINFO 💀 MAYBE U HAS BEEN BLOCKED FROM FACEBOOK');
-              }
-          })
-      }
-  }
-  
-  const createOrTakeDataFromDatabase = async (threadIDs) => {
-      let inDb = []; //NOTE: xử lý resp thành 1 mảng nếu có nhiều hơn 1 threadID và obj nếu 1 threadID
-      let inFastArr = [];
-      let createNow = [];
-      let cbThreadInfos = [];
-      // kiểm tra và phân ra 2 loại 1 là chưa  có 2 là có =))
-      // kiểm tra
-  
-      threadIDs.forEach(id => {
-          // id, id ,id
-          hasData(id) == true ? inDb.push(id) : createNow.push(id)
+        if (Object.values(threadInfos).length == 1) {
+          callback(null, Object.values(threadInfos)[0]);
+        } else {
+          callback(null, threadInfos);
+        }
+      })
+      .catch(function () {
+        // Do nothing on error
+        callback(null, null);
       });
 
-      if (inDb.length >= 1) {
-          let threadInfos = inDb.map(id => getData(id));
-          cbThreadInfos = cbThreadInfos.concat(threadInfos);
-          updateUserInfo(threadInfos);
-  
-          //request update queue
-          threadInfos.forEach(i => addToQueues({ threadID: i.threadID, TimeCreate: Date.now() }));
-      }
-      if (createNow.length >= 1) {
-          //5 data per chunk []
-          const chunkSize = 5;
-          const totalChunk = []; // [ [ id, id ], [ id,id ] ]
-          
-          for (let i = 0; i < createNow.length; i += chunkSize) {
-            const chunk = createNow.slice(i, i + chunkSize);
-            totalChunk.push(chunk);
-          }
-  
-          for (let i of totalChunk) {
-              //i = [ id,id ]
-              const newThreadInf = await getMultiInfo(i); // always [ {} ] or [ {}, {} ]
-              if (newThreadInf.Success == true) {
-                let MultiThread = newThreadInf.Data;  
-                formatAndCreateData(MultiThread)
-                cbThreadInfos = cbThreadInfos.concat(MultiThread)
-    
-                //request update queue
-                MultiThread.forEach(i => addToQueues({ threadID: i.threadID, TimeCreate: Date.now() }));
-            }
-            else {
-                global.Fca.Require.logger.Warning('CANT NOT GET THREADINFO 💀 MAYBE U HAS BEEN BLOCKED FROM FACEBOOK');
-            }
-          } 
-      }
-      return cbThreadInfos.length == 1 ? callback(null, cbThreadInfos[0]) : callback(null, cbThreadInfos)
-  }
-
-    if (global.Fca.Data.Already != true) {
-      global.Fca.Data.Already = true;
-      autoCheckAndUpdateRecallTime(); 
-      setInterval(function(){ 
-        const MapToArray = Array.from(global.Fca.Data.Userinfo, ([name, value]) => (value));
-        Database(true).set('UserInfo', MapToArray); 
-      }, 420 * 1000); 
-    } 
-
-    await createOrTakeDataFromDatabase(threadID);
-    
     return returnPromise;
   };
-};
+};

package/src/getThreadInfoDeprecated.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getThreadInfo(threadID, callback) {
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    var form = {
+      client: "mercury"
+    };
+
+    api.getUserInfo(threadID, function(err, userRes) {
+      if (err) {
+        return callback(err);
+      }
+      var key = Object.keys(userRes).length > 0 ? "user_ids" : "thread_fbids";
+      form["threads[" + key + "][0]"] = threadID;
+
+      if (ctx.globalOptions.pageId)
+        form.request_user_id = ctx.globalOptions.pageId;
+
+      defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/thread_info.php",
+          ctx.jar,
+          form
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function(resData) {
+          if (resData.error) {
+            throw resData;
+          } else if (!resData.payload) {
+            throw {
+              error: "Could not retrieve thread Info."
+            };
+          }
+          var threadData = resData.payload.threads[0];
+          var userData = userRes[threadID];
+
+          if (threadData == null) {
+            throw {
+              error: "ThreadData is null"
+            };
+          }
+
+          threadData.name =
+            userData != null && userData.name != null
+              ? userData.name
+              : threadData.name;
+          threadData.image_src =
+            userData != null && userData.thumbSrc != null
+              ? userData.thumbSrc
+              : threadData.image_src;
+
+          callback(null, utils.formatThread(threadData));
+        })
+        .catch(function(err) {
+          log.error("getThreadInfo", err);
+          return callback(err);
+        });
+    });
+    return returnPromise;
+  };
+};