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

package/lib/unlock-method.js

@@ -1,701 +0,0 @@
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { bindUnlockMethodToUser, bindUnlockMethodToUserByRecord, checkFreeUnlockMethods, createUnlockMethod, removeUnlockMethod, editUnlockMethod, fetchCreatePasswordSN, fetchFreeUnlockMethods, getUnlockMethodInfo, unbindMemberUnlockMethod, } from "./api/lock";
-import config from "./config";
-import dpCodes from "./config/dp-code";
-import { add as addMap, reportAdd as reportAddMap, remove as removeMap, reportRemove as reportRemoveMap, } from "./config/dp-map/unlock-method";
-import { add as addBigMap, reportAdd as reportAddBigMap, remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "./config/dp-map/unlock-method-big";
-import { getPermanentSetting, getUnlockMethodTypeByDpCode, getUnlockMethodTypeByType, isAdmin, parallelOnly, sleep, } from "./utils";
-import { getError } from "./utils/errors";
-import { publishDps } from "./utils/publishDps";
-import { encrypt } from "./utils/device";
-import emitter from "./utils/event";
-import { DPCHANGE, LoopTypes, UNLOCK_METHOD_EVENT } from "./utils/constant";
-import { getFileRemoteUrl, sendPhoneVerifyCode } from "./api";
-import { getUserInfo } from "./user";
-import { getDeviceAdvancedAbilities } from "./capability";
-const getAddUnlockError = (status) => {
-    if (status >= 0 && status <= 10) {
-        return getError(1015 + status);
-    }
-    if (status === 0xfe) {
-        return getError(1026);
-    }
-    return {
-        ...getError(1016),
-        devCode: status,
-    };
-};
-export const getUnlockMethodDetail = async (id) => {
-    const cloudData = await getUnlockMethodInfo({
-        devId: config.devInfo.devId,
-        opModeId: id,
-    });
-    const detail = {
-        isBound: cloudData.allocateFlag === 1,
-        type: getUnlockMethodTypeByDpCode(config.codesById[Number(cloudData.opmode)])?.type,
-        phase: cloudData.phase,
-        dpId: Number(cloudData.opmode),
-        isSpecial: cloudData.unlockAttr === 1,
-        unlockName: cloudData.unlockName,
-        userId: cloudData.userId,
-        unlockId: Number(cloudData.opmodeValue),
-        lockUserId: cloudData.lockUserId,
-        id: cloudData.opmodeId,
-        userType: cloudData.userType,
-        notifyInfo: {
-            appSend: !!cloudData.notifyInfo?.appSend,
-            msgSend: !!cloudData.notifyInfo?.msgPhone,
-            msgPhone: cloudData.notifyInfo?.msgPhone,
-            countryCode: cloudData.notifyInfo?.countryCode,
-        },
-    };
-    return detail;
-};
-const getUnlockMethodBase = async (type, userId) => {
-    const { idsByCode, devInfo: { devId }, supportBigData, } = config;
-    const unlockMethodConfig = getUnlockMethodTypeByType(type);
-    const addDpCode = supportBigData
-        ? dpCodes.unlockMethodCreateW
-        : dpCodes.unlockMethodCreate;
-    const dpId = idsByCode[unlockMethodConfig.code];
-    const [user, sn] = await Promise.all([
-        getUserInfo({
-            userId: userId,
-        }),
-        fetchCreatePasswordSN({
-            devId: devId,
-            dpId,
-        }),
-    ]);
-    const { userType, lockUserId, timeScheduleInfo } = user;
-    let validConfig;
-    if (timeScheduleInfo) {
-        const { permanent, effectiveTime, expiredTime, scheduleDetails } = timeScheduleInfo;
-        if (permanent) {
-            validConfig = {
-                startTime: effectiveTime
-                    ? Math.floor(effectiveTime / 1000)
-                    : 0x386cd300,
-                endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
-                loop: LoopTypes.NONE,
-                loopConfig: 0,
-                weeks: [0, 0, 0, 0, 0, 0, 0],
-                days: [],
-                startHour: 0,
-                startMinute: 0,
-                endHour: 0,
-                endMinute: 0,
-            };
-        }
-        else {
-            validConfig = {
-                startTime: Math.floor((effectiveTime || +new Date()) / 1000),
-                endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
-                loop: scheduleDetails?.repeat ? LoopTypes.WEEK : LoopTypes.NONE,
-                loopConfig: 0,
-                weeks: scheduleDetails?.repeat
-                    ? scheduleDetails?.weeks
-                    : [0, 0, 0, 0, 0, 0, 0],
-                days: [],
-                startHour: Math.floor((scheduleDetails?.effectiveTime ?? 0) / 60),
-                startMinute: (scheduleDetails?.effectiveTime ?? 0) % 60,
-                endHour: Math.floor((scheduleDetails?.invalidTime ?? 0) / 60),
-                endMinute: (scheduleDetails?.invalidTime ?? 0) % 60,
-            };
-        }
-    }
-    else {
-        validConfig = getPermanentSetting();
-    }
-    const dpData = {
-        type: unlockMethodConfig.id,
-        stage: 0,
-        admin: isAdmin(userType),
-        memberId: lockUserId,
-        unlockId: supportBigData ? 0xffff : 0xff,
-        validConfig,
-        validNum: 0,
-        pwdLength: 0,
-        pwd: [],
-        sn,
-    };
-    return {
-        unlockMethodConfig,
-        devId,
-        userType,
-        lockUserId,
-        sn,
-        dpId,
-        addDpCode,
-        addDpMap: (supportBigData ? addBigMap : addMap),
-        addDpReportMap: (supportBigData ? reportAddBigMap : reportAddMap),
-        dpData,
-    };
-};
-const checkSpecial = (isSpecial, params, oldSetting) => {
-    const supportedPhone = checkSpecialSupportPhone();
-    if (isSpecial) {
-        if (!params?.appSend) {
-            if (!supportedPhone) {
-                throw getError(1057);
-            }
-            else if (!params?.msgSend) {
-                throw getError(1058);
-            }
-        }
-        if (supportedPhone && params?.msgSend) {
-            if (!params.msgPhone) {
-                throw getError(1066);
-            }
-            if (!params.countryCode) {
-                throw getError(1056);
-            }
-            if (params.msgPhone !== oldSetting?.msgPhone && !params.verifyCode) {
-                throw getError(1055);
-            }
-        }
-    }
-    return {
-        unlockAttr: isSpecial ? 1 : 0,
-        notifyInfo: {
-            appSend: !!params?.appSend,
-            msgPhone: supportedPhone && params?.msgSend ? params?.msgPhone : undefined,
-            countryCode: supportedPhone && params?.msgSend ? params?.countryCode : undefined,
-            msgPhoneVerifyCode: supportedPhone && params?.msgSend ? params?.verifyCode : undefined,
-        },
-    };
-};
-export const checkSpecialSupportPhone = () => {
-    return !!config.dpSchema[dpCodes.message];
-};
-export const addPassword = async (params) => {
-    if (!params.password) {
-        throw getError(1054);
-    }
-    const specialInfo = checkSpecial(!!params.isSpecial, params.specialInfo);
-    const { lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, devId, dpId, unlockMethodConfig, } = await getUnlockMethodBase("password", params.userId);
-    dpData.pwdLength = params.password.length;
-    dpData.pwd = params.password.split("").map(Number);
-    const res = await publishDps({
-        [addDpCode]: dpUtils.format(dpData, addDpMap),
-    }, {
-        checkReport: (dpData) => {
-            if (typeof dpData[addDpCode] !== "undefined") {
-                const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
-                let hasReport = result.type === unlockMethodConfig.id &&
-                    [0xff, 0xfd].includes(result.stage);
-                if (config.strictMode) {
-                    hasReport =
-                        hasReport && result.memberId === lockUserId && result.sn === sn;
-                }
-                if (hasReport) {
-                    if (result.memberId !== lockUserId) {
-                        console.warn(`AddPassword: lockUserId mismatch, expected ${lockUserId}, got ${result.memberId}`);
-                    }
-                    return result;
-                }
-                return false;
-            }
-            console.warn("AddPassword: An invalid value may have been reported");
-            return false;
-        },
-    });
-    if (res.stage === 0xfd) {
-        throw getAddUnlockError(res.status);
-    }
-    const aesPwd = await encrypt(devId, params.password);
-    await sleep(300);
-    return await createUnlockMethod({
-        devId: devId,
-        userId: params.userId,
-        unlockId: `${dpId}-${res.unlockId}`,
-        unlockName: params.name,
-        unlockDetail: aesPwd,
-        ...specialInfo,
-    });
-};
-const addUnlockMethodData = {
-    unlockMethodConfig: {},
-    total: 0,
-    dpCode: "",
-    dpMap: {},
-    sn: 0,
-    lockUserId: 0,
-    timeoutId: 0,
-    userId: "",
-    unlockDpId: 0,
-    timeout: 15000,
-    canEmitEvents: true,
-    pendingEvents: [],
-    releaseEmitTimer: 0,
-    eventSessionId: 0,
-};
-const ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY = 16;
-const dispatchAddUnlockMethodEvent = (eventData) => {
-    if (emitter.hasListener(UNLOCK_METHOD_EVENT)) {
-        emitter.emit(UNLOCK_METHOD_EVENT, eventData);
-    }
-    else {
-        emitter.cache(UNLOCK_METHOD_EVENT, eventData);
-    }
-};
-const emitAddUnlockMethodEvent = (eventData) => {
-    if (!addUnlockMethodData.canEmitEvents) {
-        addUnlockMethodData.pendingEvents.push(eventData);
-        return;
-    }
-    dispatchAddUnlockMethodEvent(eventData);
-};
-const releaseAddUnlockMethodEventsAfterStart = (eventSessionId) => {
-    clearTimeout(addUnlockMethodData.releaseEmitTimer);
-    addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
-        if (addUnlockMethodData.eventSessionId !== eventSessionId) {
-            return;
-        }
-        addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
-            if (addUnlockMethodData.eventSessionId !== eventSessionId) {
-                return;
-            }
-            addUnlockMethodData.canEmitEvents = true;
-            const pendingEvents = addUnlockMethodData.pendingEvents.splice(0);
-            pendingEvents.forEach((eventData) => {
-                dispatchAddUnlockMethodEvent(eventData);
-            });
-        }, ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY);
-    }, 0);
-};
-const handleAddTimeout = (timeout = 15000) => {
-    clearTimeout(addUnlockMethodData.timeoutId);
-    addUnlockMethodData.timeoutId = setTimeout(() => {
-        emitter.off(DPCHANGE, handleAddReport);
-        emitAddUnlockMethodEvent({
-            type: addUnlockMethodData.unlockMethodConfig.type,
-            stage: "fail",
-            lockUserId: addUnlockMethodData.lockUserId,
-            error: getError(1002),
-        });
-    }, timeout);
-};
-const handleAddReport = async (dps) => {
-    if (dps[addUnlockMethodData.dpCode]) {
-        const result = dpUtils.parse(dps[addUnlockMethodData.dpCode], addUnlockMethodData.dpMap);
-        let eventData = null;
-        if (result.type !== addUnlockMethodData.unlockMethodConfig.id) {
-            return;
-        }
-        if (config.strictMode) {
-            if (result.sn !== addUnlockMethodData.sn ||
-                result.memberId !== addUnlockMethodData.lockUserId) {
-                return;
-            }
-        }
-        else {
-            if (result.sn !== addUnlockMethodData.sn) {
-                console.warn(`AddUnlockMethod: sn mismatch, expected ${addUnlockMethodData.sn}, got ${result.sn}`);
-            }
-            if (result.memberId !== addUnlockMethodData.lockUserId) {
-                console.warn(`AddUnlockMethod: lockUserId mismatch, expected ${addUnlockMethodData.lockUserId}, got ${result.memberId}`);
-            }
-        }
-        const type = addUnlockMethodData.unlockMethodConfig.type;
-        switch (result.stage) {
-            case 0xfc: {
-                handleAddTimeout(addUnlockMethodData.timeout);
-                eventData = {
-                    type,
-                    stage: "step",
-                    lockUserId: result.memberId,
-                    step: result.step,
-                    total: addUnlockMethodData.total,
-                };
-                break;
-            }
-            case 0xfd: {
-                clearMonitoringAddReport();
-                eventData = {
-                    stage: "fail",
-                    type,
-                    lockUserId: result.memberId,
-                    error: getAddUnlockError(result.status),
-                };
-                break;
-            }
-            case 0xfe: {
-                clearMonitoringAddReport();
-                if (isCancelAddUnlockMethod) {
-                    isCancelAddUnlockMethod = false;
-                    return;
-                }
-                eventData = {
-                    stage: "fail",
-                    type,
-                    lockUserId: result.memberId,
-                    error: getAddUnlockError(result.status),
-                };
-                break;
-            }
-            case 0xff: {
-                clearMonitoringAddReport();
-                try {
-                    await sleep(300);
-                    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 (err) {
-                    console.warn("AddUnlockMethod failed", err);
-                    eventData = {
-                        stage: "fail",
-                        type,
-                        lockUserId: result.memberId,
-                        error: getError(1053),
-                    };
-                }
-                break;
-            }
-            default:
-        }
-        if (eventData) {
-            emitAddUnlockMethodEvent(eventData);
-        }
-    }
-};
-const clearMonitoringAddReport = () => {
-    clearTimeout(addUnlockMethodData.timeoutId);
-    emitter.off(DPCHANGE, handleAddReport);
-};
-const monitoringAddReport = (option) => {
-    Object.assign(addUnlockMethodData, option);
-    clearTimeout(addUnlockMethodData.releaseEmitTimer);
-    addUnlockMethodData.canEmitEvents = false;
-    addUnlockMethodData.pendingEvents = [];
-    addUnlockMethodData.eventSessionId += 1;
-    emitter.clearCache(UNLOCK_METHOD_EVENT);
-    emitter.off(DPCHANGE, handleAddReport);
-    emitter.on(DPCHANGE, handleAddReport);
-    handleAddTimeout(option.timeout);
-    return addUnlockMethodData.eventSessionId;
-};
-export const startAddUnlockMethod = async (params) => {
-    const { unlockMethodConfig, lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, dpId, } = await getUnlockMethodBase(params.type, params.userId);
-    isCancelAddUnlockMethod = false;
-    let addReportMonitoringStarted = false;
-    let addReportMonitoringSessionId = 0;
-    const startAddReportMonitoring = (total) => {
-        if (addReportMonitoringStarted) {
-            return addReportMonitoringSessionId;
-        }
-        addReportMonitoringStarted = true;
-        addReportMonitoringSessionId = monitoringAddReport({
-            timeout: params.timeout,
-            unlockMethodConfig,
-            total,
-            dpCode: addDpCode,
-            dpMap: addDpReportMap,
-            sn,
-            lockUserId,
-            userId: params.userId,
-            unlockDpId: dpId,
-        });
-        return addReportMonitoringSessionId;
-    };
-    const res = await publishDps({
-        [addDpCode]: dpUtils.format(dpData, addDpMap),
-    }, {
-        timeout: params.timeout,
-        checkReport: (dpData) => {
-            if (typeof dpData[addDpCode] !== "undefined") {
-                const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
-                let hasReport = result.type === unlockMethodConfig.id;
-                if (config.strictMode) {
-                    hasReport =
-                        hasReport && result.memberId === lockUserId && result.sn === sn;
-                }
-                if (hasReport) {
-                    if (result.memberId !== lockUserId) {
-                        console.warn(`StartAddUnlockMethod: lockUserId mismatch, expected ${lockUserId}, got ${result.memberId}`);
-                    }
-                    if (result.sn !== sn) {
-                        console.warn("AddPassword: An invalid sn may have been reported");
-                    }
-                    if (result.stage === 0) {
-                        startAddReportMonitoring(result.total);
-                    }
-                    return result;
-                }
-                return false;
-            }
-            console.warn("AddPassword: An invalid value may have been reported");
-            return false;
-        },
-    });
-    if (res.stage === 0) {
-        const eventSessionId = startAddReportMonitoring(res.total);
-        releaseAddUnlockMethodEventsAfterStart(eventSessionId);
-        return { total: res.total };
-    }
-    if (res.stage === 0xfd) {
-        throw getAddUnlockError(res.status);
-    }
-    throw getError(1027);
-};
-export const updateUnlockMethod = async (params) => {
-    const detail = await getUnlockMethodDetail(params.id);
-    const specialInfo = checkSpecial(!!params.isSpecial, params.specialInfo, detail.notifyInfo);
-    return await editUnlockMethod({
-        devId: config.devInfo.devId,
-        opModeId: params.id,
-        unlockName: params.name,
-        ...specialInfo,
-    });
-};
-let isCancelAddUnlockMethod = false;
-export const cancelAddUnlockMethod = parallelOnly(async (params) => {
-    const { dpData, addDpCode, addDpMap, addDpReportMap, unlockMethodConfig, lockUserId, sn, } = await getUnlockMethodBase(params.type, params.userId);
-    dpData.stage = 0xfe;
-    isCancelAddUnlockMethod = true;
-    await publishDps({
-        [addDpCode]: dpUtils.format(dpData, addDpMap),
-    }, {
-        checkReport: (dpData) => {
-            if (typeof dpData[addDpCode] !== "undefined") {
-                const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
-                let hasReport = result.type === unlockMethodConfig.id;
-                if (config.strictMode) {
-                    hasReport =
-                        hasReport &&
-                            result.stage === 0xfe &&
-                            result.memberId === lockUserId &&
-                            result.sn === sn;
-                }
-                if (hasReport) {
-                    return result;
-                }
-                console.warn("CancelAddUnlockMethod: An invalid value may have been reported");
-            }
-            return false;
-        },
-    });
-    return true;
-});
-export const deleteUnlockMethod = parallelOnly(async (id) => {
-    const { lockUserId, unlockId, userType, dpId } = await getUnlockMethodDetail(id);
-    const dpCode = config.codesById[dpId];
-    const unlockMethodConfig = getUnlockMethodTypeByDpCode(dpCode);
-    const removeDPCode = config.supportBigData
-        ? dpCodes.unlockMethodDelW
-        : dpCodes.unlockMethodDel;
-    if (!config.dpSchema[removeDPCode]) {
-        throw getError(1014);
-    }
-    const dpData = {
-        type: unlockMethodConfig.id,
-        stage: 0,
-        admin: isAdmin(userType),
-        memberId: lockUserId,
-        unlockId,
-        operation: 1,
-    };
-    const res = await publishDps({
-        [removeDPCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
-    }, {
-        checkReport: (dpData) => {
-            if (typeof dpData[removeDPCode] !== "undefined") {
-                const result = dpUtils.parse(dpData[removeDPCode], (config.supportBigData
-                    ? reportRemoveBigMap
-                    : reportRemoveMap));
-                let hasReport = result.type === unlockMethodConfig.id;
-                if (config.strictMode) {
-                    hasReport =
-                        hasReport &&
-                            result.stage === 0 &&
-                            result.memberId === lockUserId &&
-                            result.unlockId === unlockId;
-                }
-                if (hasReport) {
-                    if (result.unlockId !== unlockId) {
-                        console.warn(`RemoveUnlockMethod: unlockId mismatch, expected ${unlockId}, got ${result.unlockId}`);
-                    }
-                    return result;
-                }
-                console.warn("RemoveUnlockMethod: An invalid value may have been reported");
-            }
-            return false;
-        },
-    });
-    if (res.status !== 255 && res.status !== 1) {
-        switch (res.status) {
-            case 2:
-                throw getError(1029);
-            case 0:
-            default:
-                throw getError(1028);
-        }
-    }
-    await removeUnlockMethod({
-        devId: config.devInfo.devId,
-        opmodeId: id,
-    });
-});
-export const checkUnBindUnlockMethods = async () => {
-    const data = await checkFreeUnlockMethods({
-        devId: config.devInfo.devId,
-    });
-    return data === true || data === 1;
-};
-export const getUnbindUnlockMethods = async () => {
-    const cloudData = await fetchFreeUnlockMethods({
-        devId: config.devInfo.devId,
-    });
-    const list = cloudData.map((item) => {
-        const unlockMethodConfig = getUnlockMethodTypeByDpCode(item.standardDp);
-        return {
-            type: unlockMethodConfig.type,
-            list: item.unlockInfo.map((unlock) => {
-                return {
-                    unlockId: Number(unlock.unlockId.split("-")[1]),
-                    unlockName: unlock.unlockName,
-                    id: unlock.opmodeId,
-                    unlockSn: unlock.unlockSn,
-                    type: unlockMethodConfig.type,
-                    dpId: Number(item.opmode),
-                    dpCode: item.standardDp,
-                };
-            }),
-        };
-    });
-    return list;
-};
-export const bindUnlockMethod = (params) => {
-    const unlockIds = params.unlockList.map((item) => {
-        const unlockMethodConfig = getUnlockMethodTypeByType(item.type);
-        const dpId = config.idsByCode[unlockMethodConfig.code];
-        return `${dpId}-${item.unlockId}`;
-    });
-    return bindUnlockMethodToUser({
-        devId: config.devInfo.devId,
-        userId: params.userId,
-        unlockIds: unlockIds,
-    });
-};
-export const unbindUnlockMethod = async (id) => {
-    const detail = await getUnlockMethodDetail(id);
-    if (!detail.isBound) {
-        throw getError(1050);
-    }
-    return unbindMemberUnlockMethod({
-        devId: config.devInfo.devId,
-        userId: detail.userId,
-        unlockIds: [`${detail.dpId}-${detail.unlockId}`],
-    });
-};
-export const bindUnlockMethodFromLog = (params) => {
-    const { idsByCode } = config;
-    const unlockIds = params.unlockList.map((item) => {
-        const unlockMethodConfig = getUnlockMethodTypeByType(item.type);
-        const dpId = idsByCode[unlockMethodConfig.code];
-        return `${dpId}-${item.unlockId}`;
-    });
-    return bindUnlockMethodToUserByRecord({
-        devId: config.devInfo.devId,
-        userId: params.userId,
-        unlockIds: unlockIds,
-    });
-};
-export const sendVerifyCode = (params) => {
-    return sendPhoneVerifyCode({
-        ...params,
-        devId: config.devInfo.devId,
-    });
-};
-export const onAddUnlockMethod = (listener) => {
-    emitter.on(UNLOCK_METHOD_EVENT, listener);
-};
-export const offAddUnlockMethod = (listener) => {
-    emitter.off(UNLOCK_METHOD_EVENT, listener);
-};
-const guileTypeMap = {
-    card: ["addCard", "addCardPic"],
-    finger: ["addFingerprint", "addFingerprintPic"],
-    face: ["addFace", "addFacePic"],
-    fingerVein: ["addFingervein", "addFingerveinPic"],
-    hand: ["addPalmvein", "addPalmveinPic"],
-    eye: ["addIris", "addIrisPic"],
-};
-export const getUnlockGuide = async (type) => {
-    if (type === "password") {
-        return null;
-    }
-    const { unlockGuide } = await getDeviceAdvancedAbilities();
-    if (unlockGuide.support) {
-        const [videoKey, picKey] = guileTypeMap[type] || ["", ""];
-        const resources = [];
-        let videoUrlPath = "";
-        let picUrlPath = "";
-        if (unlockGuide.config[picKey]) {
-            picUrlPath = unlockGuide.config[picKey].url;
-            resources.push({
-                objectKey: picUrlPath,
-            });
-        }
-        if (unlockGuide.config[videoKey]) {
-            videoUrlPath = unlockGuide.config[videoKey].url;
-            resources.push({
-                objectKey: videoUrlPath,
-            });
-        }
-        if (resources.length === 0) {
-            return null;
-        }
-        const { signedUrls } = await getFileRemoteUrl({
-            biz: "hulk_video_tutorial_video",
-            resources,
-        });
-        const expireTime = Date.now() + 30 * 60 * 1000;
-        return {
-            videoUrl: signedUrls[videoUrlPath],
-            picUrl: signedUrls[picUrlPath],
-            expireTime,
-        };
-    }
-    return null;
-};