@ray-js/lock-sdk 1.0.3 → 1.1.0-beta.1

package/lib/sync/offline-dps.js

@@ -0,0 +1,34 @@
+import { clearOfflineDpData } from "../api";
+import { getOfflineDps } from "../offline-dps";
+import config from "../config";
+import { isUseNearChannel } from "../utils";
+import { publishDpsOnly } from "../utils/publishDps";
+export const syncOfflineDps = async () => {
+    if (config.supportOfflineDps) {
+        const useNear = isUseNearChannel();
+        if (useNear) {
+            const offlineDps = await getOfflineDps();
+            try {
+                if (Object.keys(offlineDps).length) {
+                    const hasTask = Object.keys(offlineDps).some((code) => offlineDps[code].pushStatus === false);
+                    if (hasTask) {
+                        try {
+                            await clearOfflineDpData(config.devInfo.devId);
+                        }
+                        catch (error) {
+                            return;
+                        }
+                        const dpData = Object.keys(offlineDps).reduce((acc, code) => {
+                            acc[code] = offlineDps[code].value;
+                            return acc;
+                        }, {});
+                        publishDpsOnly(dpData);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(error);
+            }
+        }
+    }
+};

package/lib/sync/remote-serect-key.js

@@ -8,36 +8,32 @@ import { decrypt } from "../utils/device";
 import { publishDpsOnly } from "../utils/publishDps";
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../config/dp-map/open";
-import { ProductCommunicationType } from "../constant";
 const syncRemoteSerectKey = async (force) => {
     const useNear = isUseNearChannel();
     if (useNear) {
         try {
-            const isSupportBle = config.communication.includes(ProductCommunicationType.BLUETOOTH);
-            if (config.communication.length > 1 && isSupportBle) {
-                if (!force) {
-                    const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
-                    if (keyValue) {
-                        const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
-                        if (keyData.status === 0) {
-                            return;
-                        }
+            if (!force) {
+                const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
+                if (keyValue) {
+                    const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
+                    if (keyData.status === 0) {
+                        return;
                     }
                 }
-                const { lockUserId, userId } = await getCurrentUser();
-                const { password, invalidTime, effectiveTime } = await checkRemoteKey(config.devInfo.devId);
-                const pw = await decrypt(config.devInfo.devId, password);
-                publishDpsOnly({
-                    [dpCodes.remoteNoPdSetkey]: dpUtils.format({
-                        valid: true,
-                        memberId: lockUserId !== 0 ? lockUserId : userId,
-                        startTime: effectiveTime,
-                        endTime: invalidTime,
-                        validNum: 100,
-                        key: stringToBytes(pw),
-                    }, setKeyMap),
-                });
             }
+            const { lockUserId, userId } = await getCurrentUser();
+            const { password, invalidTime, effectiveTime } = await checkRemoteKey(config.devInfo.devId);
+            const pw = await decrypt(config.devInfo.devId, password);
+            publishDpsOnly({
+                [dpCodes.remoteNoPdSetkey]: dpUtils.format({
+                    valid: true,
+                    memberId: lockUserId !== 0 ? lockUserId : userId,
+                    startTime: effectiveTime,
+                    endTime: invalidTime,
+                    validNum: 100,
+                    key: stringToBytes(pw),
+                }, setKeyMap),
+            });
         }
         catch (e) {
             console.warn(e);

package/lib/sync/t0.js

@@ -1,5 +1,5 @@
 import { getActiveTime } from "../api";
-import config from "../config";
+import config, { hasCapability } from "../config";
 import dpCodes from "../config/dp-code";
 import { ProductCommunicationType } from "../constant";
 import { isUseNearChannel } from "../utils";
@@ -9,7 +9,7 @@ const isNeedSync = () => {
     const near = isUseNearChannel();
     return (near ||
         (config.devInfo.isOnline &&
-            config.communication.includes(ProductCommunicationType.THREAD)));
+            hasCapability(ProductCommunicationType.THREAD)));
 };
 const syncT0 = async () => {
     if (hasSysncT0) {

package/lib/sync/unlock-method.d.ts

@@ -0,0 +1,2 @@
+export declare const syncUnlockMethod: () => Promise<void>;
+export declare const autoSyncUnlockMethod: () => Promise<void>;

package/lib/sync/unlock-method.js

@@ -0,0 +1,42 @@
+import { fetchSyncUnlockMethodInfo } from "../api/lock";
+import config from "../config";
+import dpCodes from "../config/dp-code";
+import { getCurrentUser } from "../state";
+import { publishDps } from "../utils/publishDps";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { reportSync as reportSyncMap } from "../config/dp-map/unlock-method";
+import { reportSync as reportSyncBigMap } from "../config/dp-map/unlock-method-big";
+let syncUnlockMethodFirst = true;
+export const syncUnlockMethod = async () => {
+    syncUnlockMethodFirst = false;
+    const { allOpenDps = "" } = await getCurrentUser();
+    const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
+        devId: config.devInfo.devId,
+        dpIds: allOpenDps.split(","),
+    });
+    if (ins && distributed) {
+        const dpCode = config.supportBigData
+            ? dpCodes.synchMethodW
+            : dpCodes.synchMethod;
+        await publishDps({ [dpCode]: ins }, {
+            checkReport: (dpData) => {
+                if (typeof dpData[dpCode] !== "undefined") {
+                    const result = dpUtils.parse(dpData[dpCode], config.supportBigData ? reportSyncBigMap : reportSyncMap);
+                    if (result.stage === 1) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+        });
+    }
+};
+export const autoSyncUnlockMethod = async () => {
+    try {
+        if (syncUnlockMethodFirst) {
+            await syncUnlockMethod();
+        }
+    }
+    catch (e) {
+    }
+};

package/lib/sync/user.d.ts

@@ -0,0 +1,2 @@
+declare const syncDeleteUsers: () => Promise<void>;
+export default syncDeleteUsers;

package/lib/sync/user.js

@@ -0,0 +1,76 @@
+import { getDeviceStatus } from "../state";
+import { ProductCommunicationType } from "../constant";
+import config, { hasCapability } from "../config";
+import { getUsersSyncLockData, removeUser } from "../api/user";
+import dpCodes from "../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../config/dp-map/unlock-method-big";
+import { remove as removeMap, reportRemove as reportRemoveMap, } from "../config/dp-map/unlock-method";
+import { publishDps } from "../utils/publishDps";
+const deleteUser = async (data) => {
+    const { admin, lockUserId, userId } = data;
+    const dpCode = config.supportBigData
+        ? dpCodes.unlockMethodDelW
+        : dpCodes.unlockMethodDel;
+    const dpData = {
+        type: 0,
+        stage: 0,
+        admin: !!admin,
+        memberId: lockUserId,
+        unlockId: config.supportBigData ? 0xffff : 0xff,
+        category: 0,
+    };
+    await publishDps({
+        [dpCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
+    }, {
+        checkReport: (dps) => {
+            if (dps[dpCode]) {
+                const dpValue = dpUtils.parse(dps[dpCode], (config.supportBigData
+                    ? reportRemoveBigMap
+                    : reportRemoveMap));
+                if (dpValue.type === 0 &&
+                    dpValue.status == 255 &&
+                    dpValue.memberId === lockUserId) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    });
+    await removeUser(config.devInfo.devId, userId);
+};
+let isSyncDone = false;
+const syncDeleteUsers = async () => {
+    const deviceStatus = getDeviceStatus();
+    if (deviceStatus.isWifiActive) {
+        return;
+    }
+    const hasThread = hasCapability(ProductCommunicationType.THREAD);
+    if (hasThread &&
+        (deviceStatus.onlineType === "local" || deviceStatus.onlineType === "cloud")) {
+        return;
+    }
+    if (isSyncDone)
+        return;
+    if (deviceStatus.type === "online" && deviceStatus.onlineType === "ble") {
+        isSyncDone = true;
+        let count = 0;
+        const handleSync = async () => {
+            try {
+                const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
+                await Promise.all(removedUser.map((item) => deleteUser(item).catch(() => { })));
+                isSyncDone = false;
+            }
+            catch (e) {
+                if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+                    count++;
+                    setTimeout(async () => {
+                        await handleSync();
+                    }, 2000);
+                }
+            }
+        };
+        handleSync();
+    }
+};
+export default syncDeleteUsers;

package/lib/temporary.d.ts

@@ -74,4 +74,97 @@ interface RenameParams {
     name: string;
 }
 export declare const renameTemp: (params: RenameParams) => Promise<void>;
+interface CreateOnlineUnlimitedParams {
+    password: string;
+    name: string;
+    effective: EffectiveConfig;
+    phone?: string;
+    countryCode?: string;
+}
+export declare const saveTempOnlineUnlimited: (params: CreateOnlineUnlimitedParams) => Promise<{
+    type: string;
+    name: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}>;
+interface CreateOfflineParams {
+    name: string;
+    effective: EffectiveConfig;
+    isOnce: boolean;
+}
+export type OfflineTempType = "once" | "multiple";
+export interface OfflineTempResult {
+    type: OfflineTempType;
+    name: string;
+    password: string;
+    unlockBindingId: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}
+export declare const createTempOffline: (params: CreateOfflineParams) => Promise<{
+    type: string;
+    name: string;
+    password: string;
+    unlockBindingId: string;
+    pwdId: string;
+    effectiveConfig: {
+        effectiveDate: number;
+        expiredDate: number;
+    };
+}>;
+export declare const removeTempOnlineUnlimited: (id: string) => Promise<void>;
+export interface OnlinePasswordItem {
+    effective: number;
+    unlockBindingId: string;
+    effectiveTime: number;
+    invalidTime: number;
+    name: string;
+    phase: number;
+    scheduleDetails: EffectiveConfig;
+    status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";
+}
+export declare const getTempOnlineUnlimitedList: () => Promise<{
+    status: string;
+    effectiveConfig: EffectiveConfig;
+    effective: number;
+    unlockBindingId: string;
+    effectiveTime: number;
+    failReason: number;
+    invalidTime: number;
+    name: string;
+    phase: number;
+    scheduleDetails: {
+        allDay: boolean;
+        effectiveTime: number;
+        invalidTime: number;
+        timeZoneId: string;
+        workingDay: number;
+    }[];
+    opModeType: number;
+    opModeSubType: number;
+    sn: number;
+    opModeInfo?: {
+        hasClearPwd?: boolean;
+        revokedPwdName?: string;
+        revokedPwdEffectiveTime?: number;
+        revokedPwdInvalidTime?: number;
+    };
+}[]>;
+export interface OfflinePasswordItem {
+    email: string;
+    gmtExpired: number;
+    gmtStart: number;
+    hasClearPwd: boolean;
+    mobile: string;
+    pwd: string;
+    pwdId: string;
+    pwdName: string;
+    pwdTypeCode: "once" | "multiple" | "clear_one" | "clear_all";
+    revokedPwdName: string;
+    status: number;
+    timeZoneId: string;
+}
+export type OfflinePasswordType = "once" | "multiple" | "clear_one" | "clear_all";
+export declare const getTempOfflineEffectiveList: (pwdTypeCode: OfflinePasswordType) => Promise<import("./api/temp").EffectivePasswrodItem[]>;
+export declare const getTempOfflineInvalidList: (pwdTypeCode: OfflinePasswordType) => Promise<import("./api/temp").EffectivePasswrodItem[]>;
 export {};

package/lib/temporary.js

@@ -1,4 +1,4 @@
-import { clearInvalidTempList, createOfflinePassword, createTemporaryPassword, deleteTempPassword, fetchEffectiveList, fetchInvalidList, getDynamicPassword, reNameOffline, reNameTemporary, revokeOfflinePassword, updateTemporaryPassword, validateTempPwd, } from "./api/temp";
+import { clearInvalidTempList, createOfflinePassword, createTemporaryPassword, deleteTempPassword, fetchEffectiveList, fetchInvalidList, getDynamicPassword, reNameOffline, reNameTemporary, revokeOfflinePassword, updateTemporaryPassword, validateTempPwd, createOnlineUnlimited, removeTempOnlineUnlimitedAPI, getTempOnlineUnlimitedListAPI, getTempOfflineListAPI, createOfflineOnceAPI, } from "./api/temp";
 import config from "./config";
 import { formatWeek, isUseNearChannel, parallelOnly, parseOfflinePassword, parseWeek, validateEffectiveConfig, } from "./utils";
 import { LoopTypes } from "./utils/constant";
@@ -511,3 +511,173 @@ export const renameTemp = async (params) => {
         handleError(e);
     }
 };
+export const saveTempOnlineUnlimited = async (params) => {
+    const { password, name, effective, phone, countryCode } = params;
+    if (!PASSWORD_REGEX.test(password)) {
+        throw getError(1030);
+    }
+    if (name && name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(effective);
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const aesPwd = await encrypt(config.devInfo.devId, password);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime,
+            invalidTime: expiredTime,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    try {
+        const res = await createOnlineUnlimited({
+            devId: config.devInfo.devId,
+            effectiveTime: effective.effectiveDate,
+            invalidTime: effective.expiredDate,
+            name: name,
+            password: aesPwd,
+            schedule,
+            availTime: 0,
+            phone,
+            countryCode,
+        });
+        return {
+            type: "custom",
+            name: res.name,
+            pwdId: res.pwdId,
+            effectiveConfig: effective,
+        };
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+export const createTempOffline = async (params) => {
+    const { name, effective, isOnce } = params;
+    if (isOnce) {
+        const res = await createOfflineOnceAPI({
+            devId: config.devInfo.devId,
+            pwdType: "1",
+            gmtStart: "0",
+            gmtExpired: "0",
+        });
+        return {
+            type: "once",
+            name: res.pwdName,
+            password: parseOfflinePassword(res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            pwdId: res.pwdId,
+            effectiveConfig: {
+                effectiveDate: Number(res.gmtStart),
+                expiredDate: Number(res.gmtExpired),
+            },
+        };
+    }
+    else {
+        if (name && name.length > 20) {
+            throw getError(1031);
+        }
+        if (effective.effectiveDate >= effective.expiredDate) {
+            throw getError(1010);
+        }
+        const res = await createOfflineOnceAPI({
+            devId: config.devInfo.devId,
+            pwdType: "0",
+            gmtStart: effective.effectiveDate.toString(),
+            gmtExpired: effective.expiredDate.toString(),
+        });
+        return {
+            type: "multiple",
+            name: res.pwdName,
+            password: parseOfflinePassword(res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            pwdId: res.pwdId,
+            effectiveConfig: {
+                effectiveDate: Number(res.gmtStart),
+                expiredDate: Number(res.gmtExpired),
+            },
+        };
+    }
+};
+export const removeTempOnlineUnlimited = async (id) => {
+    try {
+        await removeTempOnlineUnlimitedAPI({
+            devId: config.devInfo.devId,
+            id,
+        });
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+const onLinePasswordStatusMap = {
+    1: "effective",
+    2: "synchronizing",
+    3: "expired",
+    4: "disabled",
+    5: "invalid",
+};
+export const getTempOnlineUnlimitedList = async () => {
+    try {
+        const pswList = await getTempOnlineUnlimitedListAPI(config.devInfo.devId);
+        const newPswList = pswList?.map((item) => {
+            const status = onLinePasswordStatusMap[item.effective];
+            const effectiveConfig = {
+                effectiveDate: item.effectiveTime,
+                expiredDate: item.invalidTime,
+            };
+            if (item.scheduleDetails?.length) {
+                const scheduleDetail = item.scheduleDetails[0];
+                effectiveConfig.repeat =
+                    scheduleDetail.allDay === false ? "week" : "none";
+                if (effectiveConfig.repeat === "week") {
+                    effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                    effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                    effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+                }
+            }
+            return { ...item, status, effectiveConfig };
+        });
+        return newPswList;
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+const offlinePasswordTypeMap = {
+    once: "1",
+    multiple: "0",
+    clear_one: "8",
+    clear_all: "9",
+};
+export const getTempOfflineEffectiveList = async (pwdTypeCode) => {
+    try {
+        const offLineValidPswList = await getTempOfflineListAPI({
+            devId: config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "1",
+        });
+        return offLineValidPswList;
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+export const getTempOfflineInvalidList = async (pwdTypeCode) => {
+    try {
+        const offLineFailurePswList = await getTempOfflineListAPI({
+            devId: config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "0",
+        });
+        return offLineFailurePswList;
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};

package/lib/unlock-method.js

@@ -13,6 +13,7 @@ import { encrypt } from "./utils/device";
 import emitter from "./utils/event";
 import { DPCHANGE, UNLOCK_METHOD_EVENT } from "./utils/constant";
 import { sendPhoneVerifyCode } from "./api";
+import { getUserInfo } from "./user";
 const getAddUnlockError = (status) => {
     if (status >= 0 && status <= 10) {
         return getError(1015 + status);
@@ -261,19 +262,48 @@ const handleAddReport = async (dps) => {
                 clearMonitoringAddReport();
                 try {
                     await sleep(300);
-                    const res = await createUnlockMethod({
-                        devId: config.devInfo.devId,
-                        userId: addUnlockMethodData.userId,
-                        unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
-                        unlockName: "",
-                        unlockAttr: 0,
-                    });
-                    eventData = {
-                        stage: "success",
-                        type,
-                        id: res.opModeId,
-                        name: res.unlockName,
-                    };
+                    let isAddEnabled = true;
+                    if (!config.supportMultipleFace && type === "face") {
+                        const user = await getUserInfo({
+                            userId: addUnlockMethodData.userId,
+                        });
+                        const faceData = user.unlockDetails.find((item) => item.type === "face" && item.unlockList.length > 0);
+                        if (faceData) {
+                            const originUnlockId = faceData.unlockList[0].unlockId;
+                            if (originUnlockId !== result.unlockId) {
+                                eventData = {
+                                    stage: "fail",
+                                    type,
+                                    lockUserId: result.memberId,
+                                    error: getError(1061),
+                                };
+                            }
+                            else {
+                                eventData = {
+                                    stage: "success",
+                                    type,
+                                    id: faceData.unlockList[0].id,
+                                    name: faceData.unlockList[0].unlockName,
+                                };
+                            }
+                            isAddEnabled = false;
+                        }
+                    }
+                    if (isAddEnabled) {
+                        const res = await createUnlockMethod({
+                            devId: config.devInfo.devId,
+                            userId: addUnlockMethodData.userId,
+                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockName: "",
+                            unlockAttr: 0,
+                        });
+                        eventData = {
+                            stage: "success",
+                            type,
+                            id: res.opModeId,
+                            name: res.unlockName,
+                        };
+                    }
                 }
                 catch {
                     eventData = {

package/lib/user.d.ts

@@ -10,7 +10,6 @@ export declare const getUsers: (params?: getUsersParams) => Promise<{
 }>;
 interface getUserInfoParams {
     userId: string;
-    nickName: string;
 }
 export declare const getUserInfo: (params: getUserInfoParams) => Promise<UserInfo>;
 interface updateUserLimitTimeParams {
@@ -21,6 +20,8 @@ interface updateUserLimitTimeParams {
     offlineUnlock?: boolean;
 }
 export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<boolean>;
+export declare const openAddFamilyUser: () => Promise<unknown>;
+export declare const openFamilyUserDetail: (userId: string) => Promise<undefined>;
 interface AddUserParams {
     name: string;
 }

package/lib/user.js

@@ -9,6 +9,7 @@ import { getError } from "./utils/errors";
 import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "./api/user";
 import { validConfigDpMap } from "./config/dp-map/common";
 import { formatTimestampToMilliseconds, formatWeek, isAdmin, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
+import { getCurrentHomeInfo, isSupportShortLink } from "./utils/device";
 import { LoopTypes } from "./utils/constant";
 import { getCurrentUser } from "./state";
 const concactUserList = (list, result) => {
@@ -94,8 +95,12 @@ export const getUsers = async (params) => {
     };
 };
 export const getUserInfo = async (params) => {
+    const user = await getUserDetail({
+        devId: config.devInfo.devId,
+        userId: params.userId,
+    });
     const data = await getUsers({
-        keyword: params.nickName,
+        keyword: user.nickName,
     });
     const res = data.list.find((item) => item.userId === params.userId);
     if (res) {
@@ -199,6 +204,54 @@ export const updateUserLimitTime = async (params) => {
     }
     return true;
 };
+export const openAddFamilyUser = async () => {
+    const homeInfo = await getCurrentHomeInfo();
+    let link = await isSupportShortLink("tysh_family_add_member_rn");
+    if (!link) {
+        link = await isSupportShortLink("thingsh_family_add_member_rn");
+    }
+    if (link) {
+        const url = `tuyaSmart://${link}?homeId=${homeInfo.homeId}`;
+        return new Promise((resolve, reject) => {
+            ty.router({
+                url: url,
+                success: (d) => {
+                    resolve(true);
+                },
+                fail: (e) => {
+                    reject(e);
+                },
+            });
+        });
+    }
+    return Promise.reject(getError(1013));
+};
+const userTypeMap = {
+    "10": 1,
+    "20": 0,
+    "40": -1,
+    "50": 2,
+};
+export const openFamilyUserDetail = async (userId) => {
+    const { homeId } = await getCurrentHomeInfo();
+    const { userType: currentUserType } = await getCurrentUser();
+    const role = userTypeMap[currentUserType];
+    let link = await isSupportShortLink("member_info");
+    if (link) {
+        const url = `tuyaSmart://member_info?homeId=${homeId}&memberId=${userId}&role=${role}`;
+        ty.router({
+            url: url,
+            success: (d) => {
+                console.log("openFamilyUserDetail success");
+            },
+            fail: (e) => {
+                console.log("openFamilyUserDetail fail", e);
+            },
+        });
+        return;
+    }
+    return Promise.reject(getError(1013));
+};
 export const addUser = async (params) => {
     if (!config.supportBigData) {
         throw getError(1060);