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

package/lib/user.d.ts

@@ -1,30 +0,0 @@
-import { EffectiveConfig, UserInfo } from "./interface";
-interface getUsersParams {
-    page?: number;
-    pageSize?: number;
-    keyword?: string;
-}
-export declare const getUsers: (params?: getUsersParams) => Promise<{
-    list: UserInfo[];
-    hasMore: boolean;
-}>;
-interface getUserInfoParams {
-    userId: string;
-}
-export declare const getUserInfo: (params: getUserInfoParams) => Promise<UserInfo>;
-interface updateUserLimitTimeParams {
-    userId: string;
-    lockUserId: number;
-    permanent: boolean;
-    effective?: EffectiveConfig;
-    offlineUnlock?: boolean;
-}
-export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<true | undefined>;
-export declare const openAddFamilyUser: () => Promise<unknown>;
-export declare const openFamilyUserDetail: (userId: string) => Promise<undefined>;
-interface AddUserParams {
-    name: string;
-}
-export declare const addUser: (params: AddUserParams) => Promise<import("./api/user").AddNormalUserResponse>;
-export declare const removeUser: (userId: string) => Promise<void>;
-export {};

package/lib/user.js

@@ -1,298 +0,0 @@
-import { getUserDetailQuery, getUserList } from "./api/user";
-import config from "./config";
-import { update as updateMap, reportUpdate as reportUpdateMap, } from "./config/dp-map/unlock-method";
-import { update as updateMapBig, reportUpdate as reportUpdateMapBig, } 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";
-import { getError, handleCloudError } from "./utils/errors";
-import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "./api/user";
-import { validConfigDpMap } from "./config/dp-map/common";
-import { formatTimestampToMilliseconds, formatWeek, getPermanentSetting, isAdmin, isUseNearChannel, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
-import { getCurrentHomeInfo, isSupportShortLink } from "./utils/device";
-import { LoopTypes } from "./utils/constant";
-import { getCurrentUser } from "./state";
-import { deleteUser } from "./utils/user";
-import { UserType } from "./constant";
-const handleUserDetail = (user) => {
-    const { timeScheduleInfo, unlockDetail, ...rest } = user;
-    let scheduleInfo = {
-        permanent: true,
-    };
-    if (!timeScheduleInfo.permanent &&
-        timeScheduleInfo.scheduleDetails &&
-        timeScheduleInfo.scheduleDetails.length > 0) {
-        Object.assign(scheduleInfo, {
-            permanent: false,
-            effectiveTime: formatTimestampToMilliseconds(timeScheduleInfo.effectiveTime || 0),
-            expiredTime: formatTimestampToMilliseconds(timeScheduleInfo.expiredTime || 0),
-            scheduleDetails: {
-                repeat: !timeScheduleInfo.scheduleDetails[0].allDay,
-                effectiveTime: timeScheduleInfo.scheduleDetails[0].effectiveTime,
-                invalidTime: timeScheduleInfo.scheduleDetails[0].invalidTime,
-                timeZoneId: timeScheduleInfo.scheduleDetails[0].timeZoneId,
-                weeks: parseWeek(timeScheduleInfo.scheduleDetails[0].workingDay),
-            },
-        });
-    }
-    let unlockDetails = unlockDetail.map((detail) => {
-        const unlockList = detail.unlockList.map((unlockItem) => {
-            return {
-                unlockId: +unlockItem.unlockId.split("-")[1],
-                unlockName: unlockItem.unlockName,
-                id: unlockItem.opModeId,
-                isBound: unlockItem.allocateFlag === 1,
-                photoUnlock: unlockItem.photoUnlock,
-                isSpecial: unlockItem.unlockAttr === 1,
-            };
-        });
-        const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
-        return {
-            count: unlockList.length,
-            dpCode: detail.dpCode,
-            dpId: detail.dpId,
-            type: unlockMethodConfig.type,
-            unlockList,
-        };
-    });
-    return {
-        ...rest,
-        timeScheduleInfo: scheduleInfo,
-        unlockDetails,
-        isAccountUser: user.userListType === "group_user",
-    };
-};
-const concactUserList = (list, result) => {
-    return list.reduce((acc, item) => {
-        acc.push(handleUserDetail(item));
-        return acc;
-    }, result);
-};
-const getUserDpCodes = async () => {
-    const currentUser = await getCurrentUser();
-    const dps = [];
-    if (currentUser.allOpenDps) {
-        currentUser.allOpenDps.split(",").reduce((acc, cur) => {
-            const code = config.codesById[cur];
-            if (code) {
-                acc.push(code);
-            }
-            return acc;
-        }, dps);
-    }
-    return dps;
-};
-export const getUsers = async (params) => {
-    const { page = 1, pageSize = 10, keyword = "" } = params || {};
-    const dps = await getUserDpCodes();
-    const res = await getUserList({
-        dpCodes: dps.join(","),
-        devId: config.devInfo.devId,
-        offset: (page - 1) * pageSize,
-        limit: pageSize,
-        keyword,
-    });
-    let list = [];
-    if (res.admin && res.admin.length > 0) {
-        concactUserList(res.admin, list);
-    }
-    if (res.user && res.user.length > 0) {
-        concactUserList(res.user, list);
-    }
-    return {
-        list,
-        hasMore: res.hasNext,
-    };
-};
-export const getUserInfo = async (params) => {
-    const currentUser = await getCurrentUser();
-    const res = await getUserDetailQuery({
-        devId: config.devInfo.devId,
-        userId: params.userId,
-        dpIds: currentUser.allOpenDps,
-    });
-    return handleUserDetail(res);
-};
-export const updateUserLimitTime = async (params) => {
-    const { userId, lockUserId, permanent, effective } = params;
-    if (!permanent) {
-        validateEffectiveConfig(effective);
-    }
-    const currentUser = await getCurrentUser();
-    if (!isAdmin(currentUser.userType)) {
-        throw getError(1069);
-    }
-    const { userType } = await getUserInfo({
-        userId,
-    });
-    if (isAdmin(userType)) {
-        throw getError(1049);
-    }
-    const { repeat, effectiveTime = 0, expiredTime = 1439 } = effective || {};
-    const loopType = repeat
-        ?
-            LoopTypes[repeat.toUpperCase()]
-        : LoopTypes.NONE;
-    const dpValue = {
-        type: 0,
-        stage: 0,
-        admin: false,
-        memberId: lockUserId,
-        unlockId: 255,
-        validNum: 0,
-        pwdLength: 0,
-        pwd: [],
-        validConfig: permanent
-            ? getPermanentSetting()
-            : {
-                startTime: effective.effectiveDate,
-                endTime: effective.expiredDate,
-                loop: loopType,
-                loopConfig: 0,
-                weeks: effective?.repeat !== "week" || effective?.weeks === undefined
-                    ? [0, 0, 0, 0, 0, 0, 0]
-                    : effective.weeks,
-                days: [],
-                startHour: Math.floor(effectiveTime / 60),
-                startMinute: effectiveTime % 60,
-                endHour: Math.floor(expiredTime / 60),
-                endMinute: expiredTime % 60,
-            },
-    };
-    const dpCode = config.supportBigData
-        ? dpCodes.unlockMethodEditW
-        : dpCodes.unlockMethodEdit;
-    const res = (await publishDps({
-        [dpCode]: DpUtils.format(dpValue, (config.supportBigData ? updateMapBig : updateMap)),
-    }, {
-        checkReport: (dps) => {
-            if (typeof dps[dpCode] !== "undefined") {
-                const result = DpUtils.parse(dps[dpCode], (config.supportBigData
-                    ? reportUpdateMapBig
-                    : reportUpdateMap));
-                if (result.type === 0) {
-                    if (result.memberId === lockUserId) {
-                        return result;
-                    }
-                    else {
-                        console.warn("An incorrect member id was returned");
-                    }
-                }
-            }
-            return false;
-        },
-    }));
-    if (res.status !== 255) {
-        throw getError(1011);
-    }
-    try {
-        await updateUserTimeSchedule({
-            devId: config.devInfo.devId,
-            userId: userId,
-            timeScheduleInfo: {
-                permanent,
-                userTimeSet: DpUtils.format(dpValue.validConfig, validConfigDpMap.childMap),
-                effectiveTime: dpValue.validConfig.startTime,
-                expiredTime: dpValue.validConfig.endTime,
-                scheduleDetails: [
-                    {
-                        allDay: loopType === LoopTypes.NONE,
-                        effectiveTime: permanent ? 0 : effectiveTime,
-                        invalidTime: permanent ? 0 : expiredTime,
-                        workingDay: permanent ? 0 : formatWeek(dpValue.validConfig.weeks),
-                    },
-                ],
-            },
-        });
-        return true;
-    }
-    catch (e) {
-        handleCloudError(e, 1012);
-    }
-};
-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,
-            fail: (e) => {
-                console.error("openFamilyUserDetail fail", e);
-            },
-        });
-        return;
-    }
-    return Promise.reject(getError(1013));
-};
-export const addUser = async (params) => {
-    if (!config.supportBigData) {
-        throw getError(1060);
-    }
-    if (!params.name) {
-        throw getError(1009, "name");
-    }
-    try {
-        return await addNormalUser({
-            devId: config.devInfo.devId,
-            name: params.name,
-        });
-    }
-    catch (e) {
-        if (e?.innerError?.errorCode === "DEFINITION_PARAM_NAME_REPEAT") {
-            throw getError(1068);
-        }
-        throw e;
-    }
-};
-export const removeUser = async (userId) => {
-    if (!config.supportBigData) {
-        throw getError(1060);
-    }
-    const res = await getUserInfo({
-        userId,
-    });
-    if (isUseNearChannel()) {
-        return deleteUser({
-            userId,
-            lockUserId: res.lockUserId,
-            admin: res.userType === UserType.ADMIN || res.userType === UserType.OWNER,
-        });
-    }
-    return removeNormalUser({
-        devId: config.devInfo.devId,
-        userId,
-        shouldDeleteUnlockInfo: true,
-        issueDp: true,
-    });
-};

package/lib/utils/publishDps.d.ts

@@ -1,6 +0,0 @@
-import { DpValue } from "../interface";
-export declare const publishDpsOnly: (dpData: Record<string, string | number | boolean>) => Promise<void>;
-export declare const publishDps: (dpData: Record<string, DpValue>, option?: {
-    timeout?: number;
-    checkReport?: (dps: Record<string, any>) => boolean | Record<string, any>;
-}) => Promise<Record<string, DpValue>>;

package/lib/utils/publishDps.js

@@ -1,78 +0,0 @@
-import config from "../config";
-import { isOnlineByType } from ".";
-import { publishDeviceDps } from "./device";
-import emitter from "./event";
-import { DPCHANGE } from "./constant";
-import { getError } from "./errors";
-export const publishDpsOnly = async (dpData) => {
-    const { devInfo, idsByCode, deviceStatus } = config;
-    const option = {};
-    if (config.deviceStatus.type === "offline") {
-        throw getError(1001);
-    }
-    console.log("onlineType", config.onlineType);
-    if (deviceStatus.isWifiMatter && deviceStatus.onlineTypes.includes("cloud")) {
-        option.pipelines = [1];
-    }
-    if (isOnlineByType(config.onlineType, 2)) {
-        option.pipelines = [3];
-    }
-    const dps = Object.keys(dpData).reduce((acc, key) => {
-        const id = idsByCode[key];
-        if (id) {
-            acc[id] = dpData[key];
-        }
-        return acc;
-    }, {});
-    console.log("--------publishDeviceDps----", option, dps);
-    if (Object.keys(dps).length > 0) {
-        await publishDeviceDps({
-            deviceId: devInfo.devId,
-            dps,
-            ...option,
-        });
-    }
-};
-export const publishDps = async (dpData, option) => {
-    const { timeout = 15000, checkReport } = option || {};
-    return new Promise((resolve, reject) => {
-        const codes = Object.keys(dpData);
-        const result = {};
-        let timer;
-        const cleanup = () => {
-            emitter.off(DPCHANGE, handleChangeDp);
-            clearTimeout(timer);
-        };
-        const handleChangeDp = (dpCodes) => {
-            if (checkReport) {
-                const pass = checkReport(dpCodes);
-                if (pass) {
-                    cleanup();
-                    resolve(typeof pass !== "boolean" ? pass : dpCodes);
-                }
-            }
-            else {
-                Object.keys(dpCodes).forEach((code) => {
-                    const eixst = codes.indexOf(code);
-                    if (eixst > -1) {
-                        codes.splice(eixst, 1)[0];
-                        result[code] = dpCodes[code];
-                    }
-                });
-                if (codes.length === 0) {
-                    cleanup();
-                    resolve(result);
-                }
-            }
-        };
-        timer = setTimeout(() => {
-            cleanup();
-            reject(getError(1002));
-        }, timeout);
-        emitter.on(DPCHANGE, handleChangeDp);
-        publishDpsOnly(dpData).catch((error) => {
-            cleanup();
-            reject(error);
-        });
-    });
-};

package/lib/utils/user.d.ts

@@ -1,2 +0,0 @@
-import { RemovedUserData } from "../api/user";
-export declare const deleteUser: (data: RemovedUserData) => Promise<void>;