whatsapp-web-sj.js 1.26.0

package/src/structures/Chat.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const Base = require('./Base');
+const Message = require('./Message');
+
+/**
+ * Represents a Chat on WhatsApp
+ * @extends {Base}
+ */
+class Chat extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if (data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * ID that represents the chat
+         * @type {object}
+         */
+        this.id = data.id;
+
+        /**
+         * Title of the chat
+         * @type {string}
+         */
+        this.name = data.formattedTitle;
+
+        /**
+         * Indicates if the Chat is a Group Chat
+         * @type {boolean}
+         */
+        this.isGroup = data.isGroup;
+
+        /**
+         * Indicates if the Chat is readonly
+         * @type {boolean}
+         */
+        this.isReadOnly = data.isReadOnly;
+
+        /**
+         * Amount of messages unread
+         * @type {number}
+         */
+        this.unreadCount = data.unreadCount;
+
+        /**
+         * Unix timestamp for when the last activity occurred
+         * @type {number}
+         */
+        this.timestamp = data.t;
+
+        /**
+         * Indicates if the Chat is archived
+         * @type {boolean}
+         */
+        this.archived = data.archive;
+
+        /**
+         * Indicates if the Chat is pinned
+         * @type {boolean}
+         */
+        this.pinned = !!data.pin;
+
+        /**
+         * Indicates if the chat is muted or not
+         * @type {boolean}
+         */
+        this.isMuted = data.isMuted;
+
+        /**
+         * Unix timestamp for when the mute expires
+         * @type {number}
+         */
+        this.muteExpiration = data.muteExpiration;
+
+        /**
+         * Last message fo chat
+         * @type {Message}
+         */
+        this.lastMessage = data.lastMessage ? new Message(super.client, data.lastMessage) : undefined;
+        
+        return super._patch(data);
+    }
+
+    /**
+     * Send a message to this chat
+     * @param {string|MessageMedia|Location} content
+     * @param {MessageSendOptions} [options] 
+     * @returns {Promise<Message>} Message that was just sent
+     */
+    async sendMessage(content, options) {
+        return this.client.sendMessage(this.id._serialized, content, options);
+    }
+
+    /**
+     * Set the message as seen
+     * @returns {Promise<Boolean>} result
+     */
+    async sendSeen() {
+        return this.client.sendSeen(this.id._serialized);
+    }
+
+    /**
+     * Clears all messages from the chat
+     * @returns {Promise<Boolean>} result
+     */
+    async clearMessages() {
+        return this.client.pupPage.evaluate(chatId => {
+            return window.WWebJS.sendClearChat(chatId);
+        }, this.id._serialized);
+    }
+
+    /**
+     * Deletes the chat
+     * @returns {Promise<Boolean>} result
+     */
+    async delete() {
+        return this.client.pupPage.evaluate(chatId => {
+            return window.WWebJS.sendDeleteChat(chatId);
+        }, this.id._serialized);
+    }
+
+    /**
+     * Archives this chat
+     */
+    async archive() {
+        return this.client.archiveChat(this.id._serialized);
+    }
+
+    /**
+     * un-archives this chat
+     */
+    async unarchive() {
+        return this.client.unarchiveChat(this.id._serialized);
+    }
+
+    /**
+     * Pins this chat
+     * @returns {Promise<boolean>} New pin state. Could be false if the max number of pinned chats was reached.
+     */
+    async pin() {
+        return this.client.pinChat(this.id._serialized);
+    }
+
+    /**
+     * Unpins this chat
+     * @returns {Promise<boolean>} New pin state
+     */
+    async unpin() {
+        return this.client.unpinChat(this.id._serialized);
+    }
+
+    /**
+     * Mutes this chat forever, unless a date is specified
+     * @param {?Date} unmuteDate Date at which the Chat will be unmuted, leave as is to mute forever
+     */
+    async mute(unmuteDate) {
+        return this.client.muteChat(this.id._serialized, unmuteDate);
+    }
+
+    /**
+     * Unmutes this chat
+     */
+    async unmute() {
+        return this.client.unmuteChat(this.id._serialized);
+    }
+
+    /**
+     * Mark this chat as unread
+     */
+    async markUnread(){
+        return this.client.markChatUnread(this.id._serialized);
+    }
+
+    /**
+     * Loads chat messages, sorted from earliest to latest.
+     * @param {Object} searchOptions Options for searching messages. Right now only limit and fromMe is supported.
+     * @param {Number} [searchOptions.limit] The amount of messages to return. If no limit is specified, the available messages will be returned. Note that the actual number of returned messages may be smaller if there aren't enough messages in the conversation. Set this to Infinity to load all messages.
+     * @param {Boolean} [searchOptions.fromMe] Return only messages from the bot number or vise versa. To get all messages, leave the option undefined.
+     * @returns {Promise<Array<Message>>}
+     */
+    async fetchMessages(searchOptions) {
+        let messages = await this.client.pupPage.evaluate(async (chatId, searchOptions) => {
+            const msgFilter = (m) => {
+                if (m.isNotification) {
+                    return false; // dont include notification messages
+                }
+                if (searchOptions && searchOptions.fromMe !== undefined && m.id.fromMe !== searchOptions.fromMe) {
+                    return false;
+                }
+                return true;
+            };
+
+            const chat = window.Store.Chat.get(chatId);
+            let msgs = chat.msgs.getModelsArray().filter(msgFilter);
+
+            if (searchOptions && searchOptions.limit > 0) {
+                while (msgs.length < searchOptions.limit) {
+                    const loadedMessages = await window.Store.ConversationMsgs.loadEarlierMsgs(chat);
+                    if (!loadedMessages || !loadedMessages.length) break;
+                    msgs = [...loadedMessages.filter(msgFilter), ...msgs];
+                }
+                
+                if (msgs.length > searchOptions.limit) {
+                    msgs.sort((a, b) => (a.t > b.t) ? 1 : -1);
+                    msgs = msgs.splice(msgs.length - searchOptions.limit);
+                }
+            }
+
+            return msgs.map(m => window.WWebJS.getMessageModel(m));
+
+        }, this.id._serialized, searchOptions);
+
+        return messages.map(m => new Message(this.client, m));
+    }
+
+    /**
+     * Simulate typing in chat. This will last for 25 seconds.
+     */
+    async sendStateTyping() {
+        return this.client.pupPage.evaluate(chatId => {
+            window.WWebJS.sendChatstate('typing', chatId);
+            return true;
+        }, this.id._serialized);
+    }
+
+    /**
+     * Simulate recording audio in chat. This will last for 25 seconds.
+     */
+    async sendStateRecording() {
+        return this.client.pupPage.evaluate(chatId => {
+            window.WWebJS.sendChatstate('recording', chatId);
+            return true;
+        }, this.id._serialized);
+    }
+
+    /**
+     * Stops typing or recording in chat immediately.
+     */
+    async clearState() {
+        return this.client.pupPage.evaluate(chatId => {
+            window.WWebJS.sendChatstate('stop', chatId);
+            return true;
+        }, this.id._serialized);
+    }
+
+    /**
+     * Returns the Contact that corresponds to this Chat.
+     * @returns {Promise<Contact>}
+     */
+    async getContact() {
+        return await this.client.getContactById(this.id._serialized);
+    }
+
+    /**
+     * Returns array of all Labels assigned to this Chat
+     * @returns {Promise<Array<Label>>}
+     */
+    async getLabels() {
+        return this.client.getChatLabels(this.id._serialized);
+    }
+
+    /**
+     * Add or remove labels to this Chat
+     * @param {Array<number|string>} labelIds
+     * @returns {Promise<void>}
+     */
+    async changeLabels(labelIds) {
+        return this.client.addOrRemoveLabels(labelIds, [this.id._serialized]);
+    }
+}
+
+module.exports = Chat;

package/src/structures/ClientInfo.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Current connection information
+ * @extends {Base}
+ */
+class ClientInfo extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if (data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * Name configured to be shown in push notifications
+         * @type {string}
+         */
+        this.pushname = data.pushname;
+
+        /**
+         * Current user ID
+         * @type {object}
+         */
+        this.wid = data.wid;
+
+        /**
+         * @type {object}
+         * @deprecated Use .wid instead
+         */
+        this.me = data.wid;
+
+        /**
+         * Information about the phone this client is connected to. Not available in multi-device.
+         * @type {object}
+         * @property {string} wa_version WhatsApp Version running on the phone
+         * @property {string} os_version OS Version running on the phone (iOS or Android version)
+         * @property {string} device_manufacturer Device manufacturer
+         * @property {string} device_model Device model
+         * @property {string} os_build_number OS build number
+         * @deprecated
+         */
+        this.phone = data.phone;
+
+        /**
+         * Platform WhatsApp is running on
+         * @type {string}
+         */
+        this.platform = data.platform;
+
+        return super._patch(data);
+    }
+
+    /**
+     * Get current battery percentage and charging status for the attached device
+     * @returns {object} batteryStatus
+     * @returns {number} batteryStatus.battery - The current battery percentage
+     * @returns {boolean} batteryStatus.plugged - Indicates if the phone is plugged in (true) or not (false)
+     * @deprecated
+     */
+    async getBatteryStatus() {
+        return await this.client.pupPage.evaluate(() => {
+            const { battery, plugged } = window.Store.Conn;
+            return { battery, plugged };
+        });
+    }
+}
+
+module.exports = ClientInfo;

package/src/structures/Contact.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * ID that represents a contact
+ * @typedef {Object} ContactId
+ * @property {string} server
+ * @property {string} user
+ * @property {string} _serialized
+ */
+
+/**
+ * Represents a Contact on WhatsApp
+ * @extends {Base}
+ */
+class Contact extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if(data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * ID that represents the contact
+         * @type {ContactId}
+         */
+        this.id = data.id;
+
+        /**
+         * Contact's phone number
+         * @type {string}
+         */
+        this.number = data.userid;
+
+        /**
+         * Indicates if the contact is a business contact
+         * @type {boolean}
+         */
+        this.isBusiness = data.isBusiness;
+
+        /**
+         * Indicates if the contact is an enterprise contact
+         * @type {boolean}
+         */
+        this.isEnterprise = data.isEnterprise;
+
+        this.labels = data.labels;
+
+        /**
+         * The contact's name, as saved by the current user
+         * @type {?string}
+         */
+        this.name = data.name;
+
+        /**
+         * The name that the contact has configured to be shown publically
+         * @type {string}
+         */
+        this.pushname = data.pushname;
+
+        this.sectionHeader = data.sectionHeader;
+
+        /**
+         * A shortened version of name
+         * @type {?string}
+         */
+        this.shortName = data.shortName;
+
+        this.statusMute = data.statusMute;
+        this.type = data.type;
+        this.verifiedLevel = data.verifiedLevel;
+        this.verifiedName = data.verifiedName;
+
+        /**
+         * Indicates if the contact is the current user's contact
+         * @type {boolean}
+         */
+        this.isMe = data.isMe;
+
+        /**
+         * Indicates if the contact is a user contact
+         * @type {boolean}
+         */
+        this.isUser = data.isUser;
+
+        /**
+         * Indicates if the contact is a group contact
+         * @type {boolean}
+         */
+        this.isGroup = data.isGroup;
+
+        /**
+         * Indicates if the number is registered on WhatsApp
+         * @type {boolean}
+         */
+        this.isWAContact = data.isWAContact;
+
+        /**
+         * Indicates if the number is saved in the current phone's contacts
+         * @type {boolean}
+         */
+        this.isMyContact = data.isMyContact;
+
+        /**
+         * Indicates if you have blocked this contact
+         * @type {boolean}
+         */
+        this.isBlocked = data.isBlocked;
+        
+        return super._patch(data);
+    }
+
+    /**
+     * Returns the contact's profile picture URL, if privacy settings allow it
+     * @returns {Promise<string>}
+     */
+    async getProfilePicUrl() {
+        return await this.client.getProfilePicUrl(this.id._serialized);
+    }
+
+    /**
+     * Returns the contact's formatted phone number, (12345678901@c.us) => (+1 (234) 5678-901)
+     * @returns {Promise<string>}
+     */
+    async getFormattedNumber() {
+        return await this.client.getFormattedNumber(this.id._serialized);
+    }
+    
+    /**
+     * Returns the contact's countrycode, (1541859685@c.us) => (1)
+     * @returns {Promise<string>}
+     */
+    async getCountryCode() {
+        return await this.client.getCountryCode(this.id._serialized);
+    }
+    
+    /**
+     * Returns the Chat that corresponds to this Contact. 
+     * Will return null when getting chat for currently logged in user.
+     * @returns {Promise<Chat>}
+     */
+    async getChat() {
+        if(this.isMe) return null;
+
+        return await this.client.getChatById(this.id._serialized);
+    }
+
+    /**
+     * Blocks this contact from WhatsApp
+     * @returns {Promise<boolean>}
+     */
+    async block() {
+        if(this.isGroup) return false;
+
+        await this.client.pupPage.evaluate(async (contactId) => {
+            const contact = window.Store.Contact.get(contactId);
+            await window.Store.BlockContact.blockContact({contact});
+        }, this.id._serialized);
+
+        this.isBlocked = true;
+        return true;
+    }
+
+    /**
+     * Unblocks this contact from WhatsApp
+     * @returns {Promise<boolean>}
+     */
+    async unblock() {
+        if(this.isGroup) return false;
+
+        await this.client.pupPage.evaluate(async (contactId) => {
+            const contact = window.Store.Contact.get(contactId);
+            await window.Store.BlockContact.unblockContact(contact);
+        }, this.id._serialized);
+
+        this.isBlocked = false;
+        return true;
+    }
+
+    /**
+     * Gets the Contact's current "about" info. Returns null if you don't have permission to read their status.
+     * @returns {Promise<?string>}
+     */
+    async getAbout() {
+        const about = await this.client.pupPage.evaluate(async (contactId) => {
+            const wid = window.Store.WidFactory.createWid(contactId);
+            return window.Store.StatusUtils.getStatus(wid);
+        }, this.id._serialized);
+
+        if (typeof about.status !== 'string')
+            return null;
+
+        return about.status;
+    }
+
+    /**
+     * Gets the Contact's common groups with you. Returns empty array if you don't have any common group.
+     * @returns {Promise<WAWebJS.ChatId[]>}
+     */
+    async getCommonGroups() {
+        return await this.client.getCommonGroups(this.id._serialized);
+    }
+    
+}
+
+module.exports = Contact;