@ohos-ports/zca-js 2.2.0-beta.1

package/dist/cjs/apis/deleteGroupInviteBox.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const deleteGroupInviteBoxFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/mdel-inv`);
+    /**
+     * Delete group invite box
+     *
+     * @param groupId - The group id
+     * @param blockFutureInvite - Whether to block future invites from this group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteGroupInviteBox(groupId, blockFutureInvite = false) {
+        const grids = Array.isArray(groupId) ? groupId : [groupId];
+        const params = {
+            invitations: JSON.stringify(grids.map((grid) => ({ grid }))),
+            block: blockFutureInvite ? 1 : 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.deleteGroupInviteBoxFactory = deleteGroupInviteBoxFactory;

package/dist/cjs/apis/deleteMessage.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+const deleteMessageFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/delete`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deletemsg`),
+    };
+    /**
+     * Delete a message
+     *
+     * @param dest Delete target
+     * @param onlyMe Delete message for only you
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteMessage(dest, onlyMe = false) {
+        const { threadId, type = Enum.ThreadType.User, data } = dest;
+        const isGroup = type === Enum.ThreadType.Group;
+        const isSelf = ctx.uid == data.uidFrom;
+        if (isSelf && onlyMe === false)
+            throw new ZaloApiError.ZaloApiError("To delete your message for everyone, use undo api instead");
+        if (!isGroup && onlyMe === false)
+            throw new ZaloApiError.ZaloApiError("Can't delete message for everyone in a private chat");
+        const params = {
+            [isGroup ? "grid" : "toid"]: threadId,
+            cliMsgId: Date.now(),
+            msgs: [
+                {
+                    cliMsgId: data.cliMsgId,
+                    globalMsgId: data.msgId,
+                    ownerId: data.uidFrom,
+                    destId: threadId,
+                },
+            ],
+            onlyMe: onlyMe ? 1 : 0,
+        };
+        if (!isGroup) {
+            params.imei = ctx.imei;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.deleteMessageFactory = deleteMessageFactory;

package/dist/cjs/apis/deleteProductCatalog.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const deleteProductCatalogFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/mdelete`);
+    /**
+     * Delete product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteProductCatalog(payload) {
+        if (!Array.isArray(payload.productIds))
+            payload.productIds = [payload.productIds];
+        const params = {
+            product_ids: payload.productIds,
+            catalog_id: payload.catalogId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.deleteProductCatalogFactory = deleteProductCatalogFactory;

package/dist/cjs/apis/disableGroupLink.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const disableGroupLinkFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/disable`);
+    /**
+     * Disable group link
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function disableGroupLink(groupId) {
+        const params = {
+            grid: groupId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.disableGroupLinkFactory = disableGroupLinkFactory;

package/dist/cjs/apis/disperseGroup.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const disperseGroupFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/disperse`);
+    /**
+     * Disperse Group
+     *
+     * @param groupId Group ID to disperse Group from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function disperseGroup(groupId) {
+        const params = {
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.disperseGroupFactory = disperseGroupFactory;

package/dist/cjs/apis/editNote.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const editNoteFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/updatev2`);
+    /**
+     * Edit an existing note in a group
+     *
+     * @param options Options for editing the note
+     * @param groupId Group ID to create note from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function editNote(options, groupId) {
+        const params = {
+            grid: groupId,
+            type: 0,
+            color: -16777216,
+            emoji: "",
+            startTime: -1,
+            duration: -1,
+            params: JSON.stringify({
+                title: options.title,
+            }),
+            topicId: options.topicId,
+            repeat: 0,
+            imei: ctx.imei,
+            pinAct: options.pinAct ? 1 : 2,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            if (typeof data.params == "string") {
+                data.params = JSON.parse(data.params);
+            }
+            return data;
+        });
+    };
+});
+
+exports.editNoteFactory = editNoteFactory;

package/dist/cjs/apis/editReminder.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+const editReminderFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/update`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/updatev2`),
+    };
+    /**
+     * Edit an existing reminder
+     *
+     * @param options Reminder parameters
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function editReminder(options, threadId, type = Enum.ThreadType.User) {
+        var _a, _b, _c, _d, _e, _f;
+        const requestParams = type === Enum.ThreadType.User
+            ? {
+                objectData: JSON.stringify({
+                    toUid: threadId,
+                    type: 0,
+                    color: -16777216,
+                    emoji: (_a = options.emoji) !== null && _a !== void 0 ? _a : "",
+                    startTime: (_b = options.startTime) !== null && _b !== void 0 ? _b : Date.now(),
+                    duration: -1,
+                    params: { title: options.title },
+                    needPin: false,
+                    reminderId: options.topicId,
+                    repeat: (_c = options.repeat) !== null && _c !== void 0 ? _c : 0,
+                }),
+            }
+            : {
+                grid: threadId,
+                type: 0,
+                color: -16777216,
+                emoji: (_d = options.emoji) !== null && _d !== void 0 ? _d : "",
+                startTime: (_e = options.startTime) !== null && _e !== void 0 ? _e : Date.now(),
+                duration: -1,
+                params: JSON.stringify({
+                    title: options.title,
+                }),
+                topicId: options.topicId,
+                repeat: (_f = options.repeat) !== null && _f !== void 0 ? _f : 0,
+                imei: ctx.imei,
+                pinAct: 2,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.editReminderFactory = editReminderFactory;

package/dist/cjs/apis/enableGroupLink.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const enableGroupLinkFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/new`);
+    /**
+     * Enable and create new group link
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function enableGroupLink(groupId) {
+        const params = {
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.enableGroupLinkFactory = enableGroupLinkFactory;

package/dist/cjs/apis/fetchAccountInfo.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('../utils.cjs');
+
+const fetchAccountInfoFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/me-v2`);
+    return async function fetchAccountInfo() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.fetchAccountInfoFactory = fetchAccountInfoFactory;

package/dist/cjs/apis/findUser.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const findUserFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/profile/get`);
+    /**
+     * Find user by phone number
+     *
+     * @param phoneNumber Phone number
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function findUser(phoneNumber, avatarSize = Enum.AvatarSize.Large) {
+        if (!phoneNumber)
+            throw new ZaloApiError.ZaloApiError("Missing phoneNumber");
+        if (phoneNumber.startsWith("0")) {
+            if (ctx.language == "vi")
+                phoneNumber = "84" + phoneNumber.slice(1);
+        }
+        const params = {
+            phone: phoneNumber,
+            avatar_size: avatarSize,
+            language: ctx.language,
+            imei: ctx.imei,
+            reqSrc: 40,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const finalServiceUrl = new URL(serviceURL);
+        finalServiceUrl.searchParams.append("params", encryptedParams);
+        const response = await utils.request(utils.makeURL(finalServiceUrl.toString(), {
+            params: encryptedParams,
+        }));
+        return utils.resolve(response, (result) => {
+            if (result.error && result.error.code != 216)
+                throw new ZaloApiError.ZaloApiError(result.error.message, result.error.code);
+            return result.data;
+        });
+    };
+});
+
+exports.findUserFactory = findUserFactory;

package/dist/cjs/apis/findUserByUsername.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const findUserByUsernameFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/search/by-user-name`);
+    /**
+     * Find user by username
+     *
+     * @param username username for find
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function findUserByUsername(username, avatarSize = Enum.AvatarSize.Large) {
+        const params = {
+            user_name: username,
+            avatar_size: avatarSize,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.findUserByUsernameFactory = findUserByUsernameFactory;

package/dist/cjs/apis/forwardMessage.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+const forwardMessageFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/mforward`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/mforward`),
+    };
+    /**
+     * Forward message to multiple threads
+     *
+     * @param payload Forward message payload
+     * @param threadId Thread ID(s)
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function forwardMessage(payload, threadIds, type = Enum.ThreadType.User) {
+        var _a, _b;
+        if (!payload.message)
+            throw new ZaloApiError.ZaloApiError("Missing message content");
+        if (!threadIds || threadIds.length === 0)
+            throw new ZaloApiError.ZaloApiError("Missing thread IDs");
+        const timestamp = Date.now();
+        const clientId = timestamp.toString();
+        const msgInfo = {
+            message: payload.message,
+            reference: payload.reference
+                ? JSON.stringify({
+                    type: 3,
+                    data: JSON.stringify(payload.reference),
+                })
+                : undefined,
+        };
+        const decorLog = payload.reference
+            ? {
+                fw: {
+                    pmsg: {
+                        st: 1,
+                        ts: payload.reference.ts,
+                        id: payload.reference.id,
+                    },
+                    rmsg: {
+                        st: 1,
+                        ts: payload.reference.ts,
+                        id: payload.reference.id,
+                    },
+                    fwLvl: payload.reference.fwLvl,
+                },
+            }
+            : null;
+        let params;
+        if (type === Enum.ThreadType.User) {
+            params = {
+                toIds: threadIds.map((threadId) => {
+                    var _a;
+                    return ({
+                        clientId,
+                        toUid: threadId,
+                        ttl: (_a = payload.ttl) !== null && _a !== void 0 ? _a : 0,
+                    });
+                }),
+                imei: ctx.imei,
+                ttl: (_a = payload.ttl) !== null && _a !== void 0 ? _a : 0,
+                msgType: "1",
+                totalIds: threadIds.length,
+                msgInfo: JSON.stringify(msgInfo),
+                decorLog: JSON.stringify(decorLog),
+            };
+        }
+        else {
+            params = {
+                grids: threadIds.map((threadId) => {
+                    var _a;
+                    return ({
+                        clientId,
+                        grid: threadId,
+                        ttl: (_a = payload.ttl) !== null && _a !== void 0 ? _a : 0,
+                    });
+                }),
+                ttl: (_b = payload.ttl) !== null && _b !== void 0 ? _b : 0,
+                msgType: "1",
+                totalIds: threadIds.length,
+                msgInfo: JSON.stringify(msgInfo),
+                decorLog: JSON.stringify(decorLog),
+            };
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.forwardMessageFactory = forwardMessageFactory;

package/dist/cjs/apis/getAliasList.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getAliasListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.alias[0]}/api/alias/list`);
+    /**
+     * Get alias list
+     *
+     * @param count Page size (default: 100)
+     * @param page Page number (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAliasList(count = 100, page = 1) {
+        const params = {
+            page,
+            count,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getAliasListFactory = getAliasListFactory;

package/dist/cjs/apis/getAllFriends.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const getAllFriendsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getfriends`);
+    /**
+     * Get all friends
+     *
+     * @param count Page size (default: 20000)
+     * @param page Page number (default: 1)
+     * @param avatarSize Avatar size (default: AvatarSize.Small)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAllFriends(count = 20000, page = 1, avatarSize = Enum.AvatarSize.Small) {
+        const params = {
+            incInvalid: 1,
+            page,
+            count,
+            avatar_size: avatarSize,
+            actiontime: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getAllFriendsFactory = getAllFriendsFactory;