@dodi-smart/ttlock-graphql-api/dist/schema/smartlock.js

TTLock GraphQL API

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const builder_1 = require("../builder");
const logger_1 = require("../logger");
const session_1 = require("../session");
const utils_1 = require("../utils");
const ttlock_api_1 = require("@dodi-smart/ttlock-api");
builder_1.builder.objectType('TTLockSmartlock', {
    fields: (t) => ({
        lockId: t.exposeInt('lockId', {
            description: 'Lock id',
            nullable: true
        }),
        lockName: t.exposeString('lockName', {
            description: 'Lock name',
            nullable: true
        }),
        lockAlias: t.exposeString('lockAlias', {
            description: 'Lock alias name',
            nullable: true
        }),
        lockMac: t.exposeString('lockMac', {
            description: 'Lock MAC address',
            nullable: true
        }),
        lockData: t.exposeString('lockData', {
            description: 'Lock data, used to operate the lock',
            nullable: true
        }),
        electricQuantity: t.exposeInt('electricQuantity', {
            description: 'Lock battery',
            nullable: true
        }),
        featureValue: t.exposeString('featureValue', {
            description: 'characteristic value. it is used to indicate what kinds of feature do a lock support.',
            nullable: true
        }),
        hasGateway: t.exposeInt('hasGateway', {
            description: 'Is the lock binded to gateway:1-yes, 0-no',
            nullable: true
        }),
        groupId: t.exposeInt('groupId', {
            description: 'Group id',
            nullable: true
        }),
        groupName: t.exposeString('groupName', {
            description: 'Group name',
            nullable: true
        }),
        date: t.exposeInt('date', {
            description: 'Lock init time (timestamp in millisecond)',
            nullable: true
        }),
        details: t.field({
            type: 'TTLockSmartlockDetails',
            nullable: true,
            description: "Only lock's administrator is allowed to get lock details.",
            resolve: (lock) => __awaiter(void 0, void 0, void 0, function* () {
                const { clientId } = session_1.authHolder;
                const { accessToken } = session_1.authHolder.auth;
                if (!accessToken) {
                    logger_1.logger.error("Failed executing 'details': Missing accessToken");
                    return null;
                }
                const lockClient = new ttlock_api_1.LockApi();
                const lockDetails = yield lockClient.getLock({
                    clientId,
                    accessToken,
                    lockId: lock.lockId,
                    date: new Date().getTime()
                });
                if (lockDetails.errcode) {
                    logger_1.logger.error(`Failed executing 'details': Err(${lockDetails.errcode}): ${lockDetails.errmsg}`);
                    return null;
                }
                return lockDetails;
            })
        }),
        passcodes: t.field({
            type: 'TTLockSmartlockPasscodes',
            nullable: false,
            args: {
                limit: t.arg.int({
                    description: 'A limit on the number of objects to be returned. Limit can range between 20 and 10_000, and the default is 20.',
                    required: false,
                    defaultValue: 20
                }),
                offset: t.arg.int({
                    description: 'Page offset starting from 1',
                    required: false,
                    defaultValue: 1
                })
            },
            resolve: (_parent, { limit, offset }) => __awaiter(void 0, void 0, void 0, function* () {
                const { clientId } = session_1.authHolder;
                const { accessToken } = session_1.authHolder.auth;
                const emptyResponse = {
                    list: [],
                    pageNo: 0,
                    pageSize: 0,
                    total: 0
                };
                if (!accessToken) {
                    logger_1.logger.error("Failed executing 'passcodes': Missing accessToken");
                    return emptyResponse;
                }
                if (!_parent.lockId) {
                    logger_1.logger.error("Failed executing 'passcodes': Getting the lock failed");
                    return emptyResponse;
                }
                const passcodeClient = new ttlock_api_1.PasscodeApi();
                const passcodes = yield passcodeClient.getPasscodes({
                    clientId,
                    accessToken,
                    lockId: _parent.lockId,
                    date: new Date().getTime(),
                    pageNo: (0, utils_1.fixNumberNullable)(offset),
                    pageSize: (0, utils_1.fixNumberNullable)(limit)
                });
                if (passcodes.errcode) {
                    logger_1.logger.error(`Failed executing 'passcodes': Err(${passcodes.errcode}): ${passcodes.errmsg}`);
                    return emptyResponse;
                }
                const { list, pageNo, pageSize, total } = passcodes;
                return {
                    list,
                    pageNo,
                    pageSize,
                    total
                };
            })
        }),
        wirelessKeypads: t.field({
            type: 'TTLockSmartlockWirelessKeypads',
            nullable: false,
            resolve: (_parent, {}) => __awaiter(void 0, void 0, void 0, function* () {
                const { clientId } = session_1.authHolder;
                const { accessToken } = session_1.authHolder.auth;
                const emptyResponse = {
                    list: []
                };
                if (!accessToken) {
                    logger_1.logger.error("Failed executing 'wirelessKeypads': Missing accessToken");
                    return emptyResponse;
                }
                if (!_parent.lockId) {
                    logger_1.logger.error("Failed executing 'wirelessKeypads': Getting the lock failed");
                    return emptyResponse;
                }
                const client = new ttlock_api_1.WirelessKeypadApi();
                const passcodes = yield client.getLockWirelessKeypads({
                    clientId,
                    accessToken,
                    lockId: _parent.lockId,
                    date: new Date().getTime()
                });
                if (passcodes.errcode) {
                    logger_1.logger.error(`Failed executing 'wirelessKeypads': Err(${passcodes.errcode}): ${passcodes.errmsg}`);
                    return emptyResponse;
                }
                const { list } = passcodes;
                return {
                    list
                };
            })
        })
    })
});
//# sourceMappingURL=smartlock.js.map