@ray-js/lock-sdk 1.1.3-beta.9 → 1.2.0-beta.1

package/lib/temporary.js

@@ -1,698 +0,0 @@
-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";
-import { encrypt } from "./utils/device";
-import { getError, handleCloudError } from "./utils/errors";
-import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "./config/dp-map/unlock-method";
-import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, removeTempPwd as removeTempPwdBigDpMap, reportRemoveTempPwd as reportRemoveTempPwdBigDpMap, } from "./config/dp-map/unlock-method-big";
-import { publishDps } from "./utils/publishDps";
-import dpCodes from "./config/dp-code";
-import dpUtils from "@ray-js/tuya-dp-transform";
-const PASSWORD_REGEX = /^[0-9]+$/;
-const isValidPassword = async (params) => {
-    const validateResult = await validateTempPwd(params);
-    if (!validateResult.valid) {
-        handleCloudError({
-            innerError: {
-                errorCode: validateResult.errorCode,
-            },
-        });
-    }
-    return true;
-};
-export const createTempCustom = parallelOnly(async (params) => {
-    const { password, name, effective } = 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 useNear = isUseNearChannel();
-    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]),
-        },
-    ];
-    const baseData = {
-        devId: config.devInfo.devId,
-        effectiveTime: effective.effectiveDate,
-        invalidTime: effective.expiredDate,
-        name: name,
-        password: aesPwd,
-        schedule,
-    };
-    try {
-        if (useNear) {
-            await isValidPassword(baseData);
-            const { tyNum, name } = await createTemporaryPassword({
-                ...baseData,
-                sn: 0,
-                availTime: 0,
-                symbolic: false,
-                dpTunnel: 2,
-            });
-            if (!tyNum) {
-                throw getError(1043);
-            }
-            const dpData = {
-                cloudNo: tyNum,
-                valid: true,
-                validConfig: {
-                    startTime: effective.effectiveDate,
-                    endTime: effective.expiredDate,
-                    loop: loopType,
-                    loopConfig: 0,
-                    weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
-                    days: [],
-                    startHour: Math.floor(effectiveTime / 60),
-                    startMinute: effectiveTime % 60,
-                    endHour: Math.floor(expiredTime / 60),
-                    endMinute: expiredTime % 60,
-                },
-                validNum: 0,
-                pwdLength: params.password.length,
-                pwd: params.password.split("").map(Number),
-            };
-            const targetDpCode = config.supportBigData
-                ? dpCodes.tempPwdCreateW
-                : dpCodes.tempPwdCreate;
-            const result = await publishDps({
-                [targetDpCode]: dpUtils.format(dpData, (config.supportBigData
-                    ? addTempPwdBigDpMap
-                    : addTempPwdDpMap)),
-            }, {
-                checkReport: (dpData) => {
-                    const reportData = dpData[targetDpCode];
-                    if (reportData) {
-                        const data = dpUtils.parse(dpData[targetDpCode], (config.supportBigData
-                            ? reportAddTempPwdDBigpMap
-                            : reportAddTempPwdDpMap));
-                        if (data.cloudNo === tyNum) {
-                            return data;
-                        }
-                    }
-                    return false;
-                },
-            });
-            if (result.status === 0) {
-                return {
-                    type: "custom",
-                    name: name,
-                    password: password,
-                    unlockBindingId: result.unlockBindingId,
-                    effectiveConfig: effective,
-                };
-            }
-            throw getError(result.status === 2 ? 1041 : 1042);
-        }
-        else {
-            const res = await createTemporaryPassword({
-                ...baseData,
-                sn: 0,
-                availTime: 0,
-                symbolic: false,
-                dpTunnel: 2,
-            });
-            return {
-                type: "custom",
-                name: res.name,
-                password: password,
-                unlockBindingId: res.unlockBindingId,
-                effectiveConfig: effective,
-            };
-        }
-    }
-    catch (error) {
-        throw handleCloudError(error);
-    }
-});
-export const removeTempCustom = async (params) => {
-    try {
-        await deleteTempPassword({
-            devId: config.devInfo.devId,
-            unlockBindingId: params.unlockBindingId,
-            symbolic: false,
-            dpTunnel: 2,
-        });
-        if (isUseNearChannel()) {
-            const dpCode = config.supportBigData
-                ? dpCodes.tempPwdDelW
-                : dpCodes.tempPwdDel;
-            const dpData = {
-                unlockId: params.sn,
-            };
-            const result = await publishDps({
-                [dpCode]: dpUtils.format(dpData, (config.supportBigData
-                    ? removeTempPwdBigDpMap
-                    : removeTempPwdDpMap)),
-            }, {
-                checkReport: (dpData) => {
-                    const reportData = dpData[dpCode];
-                    if (reportData) {
-                        const data = dpUtils.parse(reportData, (config.supportBigData
-                            ? reportRemoveTempPwdBigDpMap
-                            : reportRemoveTempPwdDpMap));
-                        return data;
-                    }
-                    return false;
-                },
-            });
-            if (result.status === 0) {
-                return true;
-            }
-            throw getError(1065);
-        }
-    }
-    catch (e) {
-        handleCloudError(e);
-    }
-};
-export const updateTempCustom = async (params) => {
-    const { unlockBindingId, name, effective } = params;
-    if (name && name.length > 20) {
-        throw getError(1031);
-    }
-    validateEffectiveConfig(effective);
-    const loopType = effective?.repeat
-        ?
-            LoopTypes[effective?.repeat?.toUpperCase()]
-        : LoopTypes.NONE;
-    const schedule = [
-        {
-            allDay: loopType === LoopTypes.NONE,
-            effectiveTime: effective?.effectiveTime ?? 0,
-            invalidTime: effective?.expiredTime ?? 0,
-            workingDay: formatWeek(effective?.weeks ?? [0]),
-        },
-    ];
-    try {
-        return updateTemporaryPassword({
-            devId: config.devInfo.devId,
-            effectiveTime: effective.effectiveDate,
-            invalidTime: effective.expiredDate,
-            name: name,
-            schedule,
-            unlockBindingId,
-            symbolic: false,
-            dpTunnel: 2,
-        });
-    }
-    catch (error) {
-        handleCloudError(error);
-    }
-};
-const getOfflinePassword = async (params) => {
-    try {
-        return await createOfflinePassword(params);
-    }
-    catch (error) {
-        throw handleCloudError(error);
-    }
-};
-export const createTempLimit = async (params) => {
-    const { name, effectiveTime, invalidTime } = params;
-    if (name && name.length > 20) {
-        throw getError(1031);
-    }
-    if (effectiveTime >= invalidTime) {
-        throw getError(1010);
-    }
-    const res = await getOfflinePassword({
-        devId: config.devInfo.devId,
-        pwdType: "0",
-        pwdName: name,
-        gmtStart: effectiveTime,
-        gmtExpired: invalidTime,
-    });
-    return {
-        type: "limit",
-        name: res.pwdName,
-        password: parseOfflinePassword(res.pwd),
-        unlockBindingId: res.unlockBindingId,
-        effectiveConfig: {
-            effectiveDate: res.gmtStart,
-            expiredDate: res.gmtExpired,
-        },
-    };
-};
-export const createTempOnce = async (params) => {
-    const { name } = params;
-    if (name && name.length > 20) {
-        throw getError(1031);
-    }
-    const res = await getOfflinePassword({
-        devId: config.devInfo.devId,
-        pwdType: "1",
-        pwdName: name,
-        gmtStart: 0,
-        gmtExpired: 0,
-    });
-    return {
-        type: "once",
-        name: res.pwdName,
-        password: parseOfflinePassword(res.pwd),
-        unlockBindingId: res.unlockBindingId,
-        effectiveConfig: {
-            effectiveDate: res.gmtStart,
-            expiredDate: res.gmtExpired,
-        },
-    };
-};
-export const createTempDynamic = async () => {
-    const { dynamicPassword } = await getDynamicPassword({
-        devId: config.devInfo.devId,
-    });
-    const now = Math.floor(Date.now() / 1000);
-    return {
-        type: "dynamic",
-        name: "",
-        password: parseOfflinePassword(dynamicPassword),
-        unlockBindingId: "",
-        effectiveConfig: {
-            effectiveDate: now,
-            expiredDate: now + 5 * 60,
-        },
-    };
-};
-export const createTempClear = async (params) => {
-    const { name, unlockBindingId, clearAll } = params;
-    if (name && name.length > 20) {
-        throw getError(1031);
-    }
-    if (!clearAll && !unlockBindingId) {
-        throw getError(1044);
-    }
-    let res;
-    if (clearAll) {
-        res = await getOfflinePassword({
-            devId: config.devInfo.devId,
-            pwdType: "9",
-            pwdName: name,
-            gmtStart: 0,
-            gmtExpired: 0,
-        });
-    }
-    else {
-        res = await revokeOfflinePassword({
-            devId: config.devInfo.devId,
-            name,
-            unlockBindingId: unlockBindingId,
-        });
-    }
-    return {
-        type: clearAll ? "clear" : "clearOne",
-        name: res.pwdName,
-        password: parseOfflinePassword(res.pwd),
-        unlockBindingId: res.unlockBindingId,
-        effectiveConfig: {
-            effectiveDate: res.gmtStart,
-            expiredDate: res.gmtExpired,
-        },
-    };
-};
-const passwordTypeMap = {
-    "1-0": "custom",
-    "3-1": "once",
-    "3-0": "limit",
-    "3-8": "clearOne",
-    "3-9": "clear",
-};
-export const getTempEffectiveList = async () => {
-    const res = await fetchEffectiveList({
-        devId: config.devInfo.devId,
-        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
-    });
-    return res.map((item) => {
-        const type = passwordTypeMap[`${item.opModeType}-${item.opModeSubType}`] || "custom";
-        let status = "synchronizing";
-        switch (item.phase) {
-            case 1:
-                status = "effective";
-                if (item.effective === 1) {
-                    status = "toBeEffective";
-                }
-                break;
-            case 2:
-                status = "synchronizing";
-                break;
-            case 3:
-                status = "frozen";
-                break;
-            case 4:
-                status = "freezing";
-                break;
-            case 9:
-                status = "toBeDeleted";
-                break;
-            case 10:
-                status = "synchronizing";
-                break;
-        }
-        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;
-            }
-        }
-        const data = {
-            unlockBindingId: item.unlockBindingId,
-            name: item.name,
-            status,
-            type,
-            sn: item.sn,
-            hasClearPwd: item.opModeInfo?.hasClearPwd === true,
-            effectiveConfig,
-        };
-        if (data.type === "clearOne") {
-            data.clearInfo = {
-                name: item.opModeInfo?.revokedPwdName || "",
-                effectiveConfig: {
-                    effectiveDate: item.opModeInfo?.revokedPwdEffectiveTime || 0,
-                    expiredDate: item.opModeInfo?.revokedPwdInvalidTime || 0,
-                },
-            };
-        }
-        return data;
-    });
-};
-export const getTempInvalidList = async (params) => {
-    const res = await fetchInvalidList({
-        devId: config.devInfo.devId,
-        offset: (params?.page || 1) - 1,
-        limit: params?.pageSize || 200,
-    });
-    const list = res.datas.map((item) => {
-        const type = passwordTypeMap[`${item.opModeType}-${item.opModeSubType}`] || "custom";
-        let status = "expired";
-        let invalidReason = "synchronizationFailed";
-        if (item.phase === 8) {
-            invalidReason = "deleted";
-        }
-        if (item.failReason) {
-            switch (item.phase) {
-                case 1:
-                    invalidReason = "synchronizationFailed";
-                    break;
-                case 2:
-                    invalidReason = "passwordFull";
-                    break;
-            }
-        }
-        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;
-            }
-        }
-        const data = {
-            unlockBindingId: item.unlockBindingId,
-            name: item.name,
-            invalidReason,
-            status,
-            type,
-            sn: item.sn,
-            hasClearPwd: item.opModeInfo?.hasClearPwd === true,
-            effectiveConfig,
-        };
-        if (data.type === "clearOne") {
-            data.clearInfo = {
-                name: item.opModeInfo?.revokedPwdName || "",
-                effectiveConfig: {
-                    effectiveDate: item.opModeInfo?.revokedPwdEffectiveTime || 0,
-                    expiredDate: item.opModeInfo?.revokedPwdInvalidTime || 0,
-                },
-            };
-        }
-        return data;
-    });
-    return {
-        list,
-        hasMore: res.hasNext,
-        total: res.totalCount,
-    };
-};
-export const clearTempInvalidList = async () => {
-    return clearInvalidTempList({
-        devId: config.devInfo.devId,
-    });
-};
-const changePasswordPhase = async (unlockBindingId, phase) => {
-    const list = await fetchEffectiveList({
-        devId: config.devInfo.devId,
-        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
-    });
-    const password = list.find((item) => item.unlockBindingId === unlockBindingId);
-    if (!password) {
-        throw getError(1051);
-    }
-    try {
-        await updateTemporaryPassword({
-            unlockBindingId: unlockBindingId,
-            schedule: password.scheduleDetails,
-            effectiveTime: password.effectiveTime,
-            invalidTime: password.invalidTime,
-            name: password.name,
-            phase,
-            symbolic: false,
-            dpTunnel: 2,
-            devId: config.devInfo.devId,
-        });
-    }
-    catch (e) {
-        handleCloudError(e);
-    }
-    return true;
-};
-export const freezeTemp = async (params) => {
-    return changePasswordPhase(params.unlockBindingId, 4);
-};
-export const unfreezeTemp = async (params) => {
-    return changePasswordPhase(params.unlockBindingId, 2);
-};
-export const renameTemp = async (params) => {
-    const list = await fetchEffectiveList({
-        devId: config.devInfo.devId,
-        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
-    });
-    const password = list.find((item) => item.unlockBindingId === params.unlockBindingId);
-    if (!password) {
-        throw getError(1051);
-    }
-    try {
-        if (password.opModeType === 1) {
-            await reNameTemporary({
-                devId: config.devInfo.devId,
-                unlockBindingId: params.unlockBindingId,
-                name: params.name,
-            });
-        }
-        else {
-            await reNameOffline({
-                devId: config.devInfo.devId,
-                unlockBindingId: params.unlockBindingId,
-                pwdName: params.name,
-            });
-        }
-    }
-    catch (e) {
-        handleCloudError(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 handleCloudError(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 handleCloudError(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 handleCloudError(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 handleCloudError(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 handleCloudError(error);
-    }
-};