alicezetion 1.9.6 → 1.9.8

package/index.js

@@ -1,16 +1,20 @@
 "use strict";
 
 const utils = require("./utils");
+const cheerio = require("cheerio");
 const log = require("npmlog");
 
-const checkVerified = null;
+let checkVerified = null;
 
 const defaultLogRecordSize = 100;
 log.maxRecordSize = defaultLogRecordSize;
 
 function setOptions(globalOptions, options) {
-  Object.keys(options).map(function (key) {
+  Object.keys(options).map(function(key) {
     switch (key) {
+      case 'pauseLog':
+        if (options.pauseLog) log.pause();
+        break;
       case 'online':
         globalOptions.online = Boolean(options.online);
         break;
@@ -25,9 +29,6 @@ function setOptions(globalOptions, options) {
       case 'selfListen':
         globalOptions.selfListen = Boolean(options.selfListen);
         break;
-      case 'selfListenEvent':
-        globalOptions.selfListenEvent = options.selfListenEvent;
-        break;
       case 'listenEvents':
         globalOptions.listenEvents = Boolean(options.listenEvents);
         break;
@@ -75,27 +76,23 @@ function setOptions(globalOptions, options) {
 }
 
 function buildAPI(globalOptions, html, jar) {
-  const maybeCookie = jar.getCookies("https://www.facebook.com").filter(function (val) {
+  const maybeCookie = jar.getCookies("https://www.facebook.com").filter(function(val) {
     return val.cookieString().split("=")[0] === "c_user";
   });
 
-  const objCookie = jar.getCookies("https://www.facebook.com").reduce(function (obj, val) {
+  const objCookie = jar.getCookies("https://www.facebook.com").reduce(function(obj, val) {
     obj[val.cookieString().split("=")[0]] = val.cookieString().split("=")[1];
     return obj;
   }, {});
 
   if (maybeCookie.length === 0) {
-    throw { error: "Error retrieving userID. This can be caused by a lot of things, including getting blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify." };
+    throw { error: "please check your facebook account and get new alicestate" };
   }
-
   if (html.indexOf("/checkpoint/block/?next") > -1) {
-    log.warn("login", "Checkpoint detected. Please log in with a browser to verify.");
+    throw { error: "your facebook account has been ended please check it and get new alicestate"}
   }
-
   const userID = maybeCookie[0].cookieString().split("=")[1].toString();
   const i_userID = objCookie.i_user || null;
-  log.info("login", `Logged in as ${userID}`);
-
   try {
     clearInterval(checkVerified);
   } catch (_) { }
@@ -113,24 +110,18 @@ function buildAPI(globalOptions, html, jar) {
     irisSeqID = oldFBMQTTMatch[1];
     mqttEndpoint = oldFBMQTTMatch[2];
     region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
-    log.info("login", `Got this account's message region: ${region}`);
   } else {
     const newFBMQTTMatch = html.match(/{"app_id":"219994525426954","endpoint":"(.+?)","iris_seq_id":"(.+?)"}/);
     if (newFBMQTTMatch) {
       irisSeqID = newFBMQTTMatch[2];
       mqttEndpoint = newFBMQTTMatch[1].replace(/\\\//g, "/");
       region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
-      log.info("login", `Got this account's message region: ${region}`);
     } else {
       const legacyFBMQTTMatch = html.match(/(\["MqttWebConfig",\[\],{fbid:")(.+?)(",appID:219994525426954,endpoint:")(.+?)(",pollingEndpoint:")(.+?)(3790])/);
       if (legacyFBMQTTMatch) {
         mqttEndpoint = legacyFBMQTTMatch[4];
         region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
-        log.warn("login", `Cannot get sequence ID with new RegExp. Fallback to old RegExp (without seqID)...`);
-        log.info("login", `Got this account's message region: ${region}`);
-        log.info("login", `[Unused] Polling endpoint: ${legacyFBMQTTMatch[6]}`);
       } else {
-        log.warn("login", "Cannot get MQTT region & sequence ID.");
         noMqttData = html;
       }
     }
@@ -149,8 +140,6 @@ function buildAPI(globalOptions, html, jar) {
     mqttClient: undefined,
     lastSeqId: irisSeqID,
     syncToken: undefined,
-    wsReqNumber: 0,
-    wsTaskNumber: 0,
     mqttEndpoint,
     region,
     firstListen: true
@@ -161,7 +150,7 @@ function buildAPI(globalOptions, html, jar) {
     getAppState: function getAppState() {
       const appState = utils.getAppState(jar);
       // filter duplicate
-      return appState.filter((item, index, self) => self.findIndex((t) => { return t.key === item.key; }) === index);
+      return appState.filter((item, index, self) => self.findIndex((t) => { return t.key === item.key }) === index);
     }
   };
 
@@ -181,10 +170,12 @@ function buildAPI(globalOptions, html, jar) {
     'changeNickname',
     'changeThreadColor',
     'changeThreadEmoji',
+    'chat',
     'createNewGroup',
     'createPoll',
     'deleteMessage',
     'deleteThread',
+    'editMessage',
     'forwardAttachment',
     'getCurrentUserID',
     'getEmojiUrl',
@@ -204,22 +195,22 @@ function buildAPI(globalOptions, html, jar) {
     'markAsReadAll',
     'markAsSeen',
     'muteThread',
+    'pinMessage',
+    'react',
     'refreshFb_dtsg',
     'removeUserFromGroup',
     'resolvePhotoUrl',
     'searchForThread',
+    'seen',
     'sendMessage',
     'sendTypingIndicator',
     'setMessageReaction',
     'setPostReaction',
     'setTitle',
     'threadColors',
+    'token',
     'unsendMessage',
     'unfriend',
-    'edit',
-    'seen',
-    'chat',
-    'react',
 
     // HTTP
     'httpGet',
@@ -232,8 +223,8 @@ function buildAPI(globalOptions, html, jar) {
   const defaultFuncs = utils.makeDefaults(html, i_userID || userID, ctx);
 
   // Load all api functions in a loop
-  apiFuncNames.map(function (v) {
-    api[v] = require('./src/' + v)(defaultFuncs, api, ctx);
+  apiFuncNames.map(function(v) {
+    api[v] = require('./leiamnash/' + v)(defaultFuncs, api, ctx);
   });
 
   //Removing original `listen` that uses pull.
@@ -243,6 +234,255 @@ function buildAPI(globalOptions, html, jar) {
   return [ctx, defaultFuncs, api];
 }
 
+function makeLogin(jar, email, password, loginOptions, callback, prCallback) {
+  return function(res) {
+    const html = res.body;
+    const $ = cheerio.load(html);
+    let arr = [];
+
+    // This will be empty, but just to be sure we leave it
+    $("#login_form input").map(function(i, v) {
+      arr.push({ val: $(v).val(), name: $(v).attr("name") });
+    });
+
+    arr = arr.filter(function(v) {
+      return v.val && v.val.length;
+    });
+
+    const form = utils.arrToForm(arr);
+    form.lsd = utils.getFrom(html, "[\"LSD\",[],{\"token\":\"", "\"}");
+    form.lgndim = Buffer.from("{\"w\":1440,\"h\":900,\"aw\":1440,\"ah\":834,\"c\":24}").toString('base64');
+    form.email = email;
+    form.pass = password;
+    form.default_persistent = '0';
+    form.lgnrnd = utils.getFrom(html, "name=\"lgnrnd\" value=\"", "\"");
+    form.locale = 'en_US';
+    form.timezone = '240';
+    form.lgnjs = ~~(Date.now() / 1000);
+
+
+    // Getting cookies from the HTML page... (kill me now plz)
+    // we used to get a bunch of cookies in the headers of the response of the
+    // request, but FB changed and they now send those cookies inside the JS.
+    // They run the JS which then injects the cookies in the page.
+    // The "solution" is to parse through the html and find those cookies
+    // which happen to be conveniently indicated with a _js_ in front of their
+    // variable name.
+    //
+    // ---------- Very Hacky Part Starts -----------------
+    const willBeCookies = html.split("\"_js_");
+    willBeCookies.slice(1).map(function(val) {
+      const cookieData = JSON.parse("[\"" + utils.getFrom(val, "", "]") + "]");
+      jar.setCookie(utils.formatCookie(cookieData, "facebook"), "https://www.facebook.com");
+    });
+    // ---------- Very Hacky Part Ends -----------------
+ 
+    return utils
+      .post("https://www.facebook.com/login/device-based/regular/login/?login_attempt=1&lwv=110", jar, form, loginOptions)
+      .then(utils.saveCookies(jar))
+      .then(function(res) {
+        const headers = res.headers;
+        if (!headers.location) {
+          throw { error: "Wrong username/password." };
+        }
+
+        // This means the account has login approvals turned on.
+        if (headers.location.indexOf('https://www.facebook.com/checkpoint/') > -1) {
+          log.info("login", "You have login approvals turned on.");
+          const nextURL = 'https://www.facebook.com/checkpoint/?next=https%3A%2F%2Fwww.facebook.com%2Fhome.php';
+
+          return utils
+            .get(headers.location, jar, null, loginOptions)
+            .then(utils.saveCookies(jar))
+            .then(function(res) {
+              const html = res.body;
+              // Make the form in advance which will contain the fb_dtsg and nh
+              const $ = cheerio.load(html);
+              let arr = [];
+              $("form input").map(function(i, v) {
+                arr.push({ val: $(v).val(), name: $(v).attr("name") });
+              });
+
+              arr = arr.filter(function(v) {
+                return v.val && v.val.length;
+              });
+
+              const form = utils.arrToForm(arr);
+              if (html.indexOf("checkpoint/?next") > -1) {
+                setTimeout(() => {
+                  checkVerified = setInterval((_form) => {
+                    /* utils
+                      .post("https://www.facebook.com/login/approvals/approved_machine_check/", jar, form, loginOptions, null, {
+                        "Referer": "https://www.facebook.com/checkpoint/?next"
+                      })
+                      .then(utils.saveCookies(jar))
+                      .then(res => {
+                        try {
+                          JSON.parse(res.body.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*()/, ""));
+                        } catch (ex) {
+                          clearInterval(checkVerified);
+                          log.info("login", "Verified from browser. Logging in...");
+                          return loginHelper(utils.getAppState(jar), email, password, loginOptions, callback);
+                        }
+                      })
+                      .catch(ex => {
+                        log.error("login", ex);
+                      }); */
+                  }, 5000, {
+                    fb_dtsg: form.fb_dtsg,
+                    jazoest: form.jazoest,
+                    dpr: 1
+                  });
+                }, 2500);
+                throw {
+                  error: 'login-approval',
+                  continue: function submit2FA(code) {
+                    form.approvals_code = code;
+                    form['submit[Continue]'] = $("#checkpointSubmitButton").html(); //'Continue';
+                    let prResolve = null;
+                    let prReject = null;
+                    const rtPromise = new Promise(function(resolve, reject) {
+                      prResolve = resolve;
+                      prReject = reject;
+                    });
+                    if (typeof code == "string") {
+                      utils
+                        .post(nextURL, jar, form, loginOptions)
+                        .then(utils.saveCookies(jar))
+                        .then(function(res) {
+                          const $ = cheerio.load(res.body);
+                          const error = $("#approvals_code").parent().attr("data-xui-error");
+                          if (error) {
+                            throw {
+                              error: 'login-approval',
+                              errordesc: "Invalid 2FA code.",
+                              lerror: error,
+                              continue: submit2FA
+                            };
+                          }
+                        })
+                        .then(function() {
+                          // Use the same form (safe I hope)
+                          delete form.no_fido;
+                          delete form.approvals_code;
+                          form.name_action_selected = 'dont_save'; //'save_device';
+
+                          return utils
+                            .post(nextURL, jar, form, loginOptions)
+                            .then(utils.saveCookies(jar));
+                        })
+                        .then(function(res) {
+                          const headers = res.headers;
+                          if (!headers.location && res.body.indexOf('Review Recent Login') > -1) {
+                            throw { error: "Something went wrong with login approvals." };
+                          }
+
+                          const appState = utils.getAppState(jar);
+
+                          if (callback === prCallback) {
+                            callback = function(err, api) {
+                              if (err) {
+                                return prReject(err);
+                              }
+                              return prResolve(api);
+                            };
+                          }
+
+                          // Simply call loginHelper because all it needs is the jar
+                          // and will then complete the login process
+                          return loginHelper(appState, email, password, loginOptions, callback);
+                        })
+                        .catch(function(err) {
+                          // Check if using Promise instead of callback
+                          if (callback === prCallback) {
+                            prReject(err);
+                          } else {
+                            callback(err);
+                          }
+                        });
+                    } else {
+                      utils
+                        .post("https://www.facebook.com/checkpoint/?next=https%3A%2F%2Fwww.facebook.com%2Fhome.php", jar, form, loginOptions, null, {
+                          "Referer": "https://www.facebook.com/checkpoint/?next"
+                        })
+                        .then(utils.saveCookies(jar))
+                        .then(res => {
+                          try {
+                            JSON.parse(res.body.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*/, ""));
+                          } catch (ex) {
+                            clearInterval(checkVerified);
+                          
+                            if (callback === prCallback) {
+                              callback = function(err, api) {
+                                if (err) {
+                                  return prReject(err);
+                                }
+                                return prResolve(api);
+                              };
+                            }
+                            return loginHelper(utils.getAppState(jar), email, password, loginOptions, callback);
+                          }
+                        })
+                        .catch(ex => {
+                          log.error("login", ex);
+                          if (callback === prCallback) {
+                            prReject(ex);
+                          } else {
+                            callback(ex);
+                          }
+                        });
+                    }
+                    return rtPromise;
+                  }
+                };
+              } else {
+                if (!loginOptions.forceLogin) {
+                  throw { error: "Couldn't login. Facebook might have blocked this account. Please login with a browser or enable the option 'forceLogin' and try again." };
+                }
+                if (html.indexOf("Suspicious Login Attempt") > -1) {
+                  form['submit[This was me]'] = "This was me";
+                } else {
+                  form['submit[This Is Okay]'] = "This Is Okay";
+                }
+
+                return utils
+                  .post(nextURL, jar, form, loginOptions)
+                  .then(utils.saveCookies(jar))
+                  .then(function() {
+                    // Use the same form (safe I hope)
+                    form.name_action_selected = 'save_device';
+
+                    return utils
+                      .post(nextURL, jar, form, loginOptions)
+                      .then(utils.saveCookies(jar));
+                  })
+                  .then(function(res) {
+                    const headers = res.headers;
+
+                    if (!headers.location && res.body.indexOf('Review Recent Login') > -1) {
+                      throw { error: "Something went wrong with review recent login." };
+                    }
+
+                    const appState = utils.getAppState(jar);
+
+                    // Simply call loginHelper because all it needs is the jar
+                    // and will then complete the login process
+                    return loginHelper(appState, email, password, loginOptions, callback);
+                  })
+                  .catch(function(e) {
+                    callback(e);
+                  });
+              }
+            });
+        }
+
+        return utils
+          .get('https://www.facebook.com/', jar, null, loginOptions)
+          .then(utils.saveCookies(jar));
+      });
+  };
+}
+
 // Helps the login
 function loginHelper(appState, email, password, globalOptions, callback, prCallback) {
   let mainPromise = null;
@@ -251,31 +491,7 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
   // If we're given an appState we loop through it and save each cookie
   // back into the jar.
   if (appState) {
-    // check and convert cookie to appState
-    if (utils.getType(appState) === 'Array' && appState.some(c => c.name)) {
-      appState = appState.map(c => {
-        c.key = c.name;
-        delete c.name;
-        return c;
-      });
-    }
-    else if (utils.getType(appState) === 'String') {
-      const arrayAppState = [];
-      appState.split(';').forEach(c => {
-        const [key, value] = c.split('=');
-
-        arrayAppState.push({
-          key: (key || "").trim(),
-          value: (value || "").trim(),
-          domain: "facebook.com",
-          path: "/",
-          expires: new Date().getTime() + 1000 * 60 * 60 * 24 * 365
-        });
-      });
-      appState = arrayAppState;
-    }
-
-    appState.map(function (c) {
+    appState.map(function(c) {
       const str = c.key + "=" + c.value + "; expires=" + c.expires + "; domain=" + c.domain + "; path=" + c.path + ";";
       jar.setCookie(str, "http://" + c.domain);
     });
@@ -285,12 +501,17 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
       .get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true })
       .then(utils.saveCookies(jar));
   } else {
-    if (email) {
-      throw { error: "Currently, the login method by email and password is no longer supported, please use the login method by appState" };
-    }
-    else {
-      throw { error: "No appState given." };
-    }
+    // Open the main page, then we login with the given credentials and finally
+    // load the main page again (it'll give us some IDs that we need)
+    mainPromise = utils
+      .get("https://www.facebook.com/", null, null, globalOptions, { noRef: true })
+      .then(utils.saveCookies(jar))
+      .then(makeLogin(jar, email, password, globalOptions, callback, prCallback))
+      .then(function() {
+        return utils
+          .get('https://www.facebook.com/', jar, null, globalOptions)
+          .then(utils.saveCookies(jar));
+      });
   }
 
   let ctx = null;
@@ -298,7 +519,7 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
   let api = null;
 
   mainPromise = mainPromise
-    .then(function (res) {
+    .then(function(res) {
       // Hacky check for the redirection that happens on some ISPs, which doesn't return statusCode 3xx
       const reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
       const redirect = reg.exec(res.body);
@@ -309,7 +530,7 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
       }
       return res;
     })
-    .then(function (res) {
+    .then(function(res) {
       const html = res.body;
       const stuff = buildAPI(globalOptions, html, jar);
       ctx = stuff[0];
@@ -321,11 +542,11 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
   // given a pageID we log in as a page
   if (globalOptions.pageID) {
     mainPromise = mainPromise
-      .then(function () {
+      .then(function() {
         return utils
           .get('https://www.facebook.com/' + ctx.globalOptions.pageID + '/messages/?section=messages&subsection=inbox', ctx.jar, null, globalOptions);
       })
-      .then(function (resData) {
+      .then(function(resData) {
         let url = utils.getFrom(resData.body, 'window.location.replace("https:\\/\\/www.facebook.com\\', '");').split('\\').join('');
         url = url.substring(0, url.length - 1);
 
@@ -336,17 +557,16 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
 
   // At the end we call the callback or catch an exception
   mainPromise
-    .then(function () {
-      log.info("login", 'Done logging in.');
+    .then(function() {
       return callback(null, api);
     })
-    .catch(function (e) {
+    .catch(function(e) {
       log.error("login", e.error || e);
       callback(e);
     });
 }
 
-function alice(loginData, options, callback) {
+function login(loginData, options, callback) {
   if (utils.getType(options) === 'Function' || utils.getType(options) === 'AsyncFunction') {
     callback = options;
     options = {};
@@ -374,11 +594,11 @@ function alice(loginData, options, callback) {
   if (utils.getType(callback) !== "Function" && utils.getType(callback) !== "AsyncFunction") {
     let rejectFunc = null;
     let resolveFunc = null;
-    var returnPromise = new Promise(function (resolve, reject) {
+    var returnPromise = new Promise(function(resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
-    prCallback = function (error, api) {
+    prCallback = function(error, api) {
       if (error) {
         return rejectFunc(error);
       }
@@ -390,4 +610,4 @@ function alice(loginData, options, callback) {
   return returnPromise;
 }
 
-module.exports = alice;
+module.exports = login;

package/leiamnash/addExternalModule.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function addExternalModule(moduleObj) {
+    if (utils.getType(moduleObj) == "Object") {
+      for (let apiName in moduleObj) {
+        if (utils.getType(moduleObj[apiName]) == "Function") api[apiName] = moduleObj[apiName](defaultFuncs, api, ctx);
+        else throw new Error(`Item "${apiName}" in moduleObj must be a function, not ${utils.getType(moduleObj[apiName])}!`);
+      }
+    }
+    else throw new Error(`moduleObj must be an object, not ${utils.getType(moduleObj)}!`);
+  };
+};

package/leiamnash/addUserToGroup.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function addUserToGroup(userID, threadID, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback && (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction")) throw { error: "please pass a threadID as a second argument." };
+
+    if (!callback) {
+      callback = function (err) {
+        if (err) return rejectFunc(err);
+        resolveFunc();
+      };
+    }
+
+    if (utils.getType(threadID) !== "Number" && utils.getType(threadID) !== "String") throw { error: "ThreadID should be of type Number or String and not " + utils.getType(threadID) + "." };
+
+    if (utils.getType(userID) !== "Array") userID = [userID];
+
+    var messageAndOTID = utils.generateOfflineThreadingID();
+    var form = {
+      client: "mercury",
+      action_type: "ma-type:log-message",
+      author: "fbid:" + ctx.userID,
+      thread_id: "",
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_filtered_content_bh: false,
+      is_filtered_content_account: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      log_message_type: "log:subscribe",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      manual_retry_cnt: "0",
+      thread_fbid: threadID
+    };
+
+    for (var i = 0; i < userID.length; i++) {
+      if (utils.getType(userID[i]) !== "Number" && utils.getType(userID[i]) !== "String") throw { error: "Elements of userID should be of type Number or String and not " + utils.getType(userID[i]) + "." };
+      form["log_message_data[added_participants][" + i + "]"] = "fbid:" + userID[i];
+    }
+
+    defaultFuncs
+      .post("https://www.facebook.com/messaging/send/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (!resData) throw { error: "Add to group failed." };
+        if (resData.error) throw resData;
+
+        return callback();
+      })
+      .catch(function (err) {
+        log.error("addUserToGroup", "» Cannot add user to the voice chat. Please try again after");
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/leiamnash/changeAdminStatus.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function changeAdminStatus(threadID, adminID, adminStatus) {
+    if (utils.getType(threadID) !== "String") throw { error: "changeAdminStatus: threadID must be a string" };
+    if (utils.getType(adminID) !== "String" && utils.getType(adminID) !== "Array") throw { error: "changeAdminStatus: adminID must be a string or an array" };
+    if (utils.getType(adminStatus) !== "Boolean") throw { error: "changeAdminStatus: adminStatus must be true or false" };
+
+    let wsContent = {
+      request_id: 1,
+      type: 3,
+      payload: {
+        version_id: '3816854585040595',
+        tasks: [],
+        epoch_id: 6763184801413415579,
+        data_trace_id: null
+      },
+      app_id: '772021112871879'
+    }
+
+    if (utils.getType(adminID) === "Array") {
+      for (let i = 0; i < adminID.length; i++) {
+        wsContent.payload.tasks.push({
+          label: '25',
+          payload: JSON.stringify({ thread_key: threadID, contact_id: adminID[i], is_admin: adminStatus }),
+          queue_name: 'admin_status',
+          task_id: i + 1,
+          failure_count: null
+        });
+      }
+    }
+    else {
+      wsContent.payload.tasks.push({
+        label: '25',
+        payload: JSON.stringify({ thread_key: threadID, contact_id: adminID, is_admin: adminStatus }),
+        queue_name: 'admin_status',
+        task_id: 1,
+        failure_count: null
+      });
+    }
+
+    wsContent.payload = JSON.stringify(wsContent.payload);
+    return new Promise((resolve, reject) => ctx.mqttClient && ctx.mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => err ? reject(err) : resolve()));
+  };
+};