mtl-js-sdk/lib/plugins/coop/platforms/web/methods.js

"use strict";

define(["./mtc/index"], function (MTCManager) {
  var SUCCESS_CODE = 200;
  var FAIL_CODE = 1;
  var LISTENER_TYPE_APPLY_PERMISSION = "MTL_APPLY_PERMISSION";
  var manager = null;
  var settings = null;
  var _permissionListenerId = null;
  var _commandListenerId = null;

  function callSuccess(_ref) {
    var data = _ref.data,
        object = _ref.object,
        _ref$caller = _ref.caller,
        caller = _ref$caller === void 0 ? "" : _ref$caller;
    var result = {
      code: SUCCESS_CODE,
      data: data,
      message: caller + ":ok!"
    };

    var _ref2 = object || {},
        success = _ref2.success,
        complete = _ref2.complete;

    success && success(data);
    complete && complete(result);
  }

  function callFail(_ref3) {
    var _ref3$code = _ref3.code,
        code = _ref3$code === void 0 ? FAIL_CODE : _ref3$code,
        message = _ref3.message,
        object = _ref3.object,
        _ref3$caller = _ref3.caller,
        caller = _ref3$caller === void 0 ? "" : _ref3$caller;
    var result = {
      code: code,
      data: null,
      message: message || caller + ":fail!"
    };

    var _ref4 = object || {},
        fail = _ref4.fail,
        complete = _ref4.complete;

    fail && fail(result);
    complete && complete(result);
  }

  function checkAndCallbackIfError(object) {
    if (!manager) {
      callFail({
        message: "未登录",
        object: object
      });
      return false;
    }

    return true;
  }

  function initialize(object) {
    settings = object;
    callSuccess({
      object: object,
      data: null,
      caller: "coop.initialize"
    });
  }

  function login(object) {
    if (!settings) {
      callFail({
        message: "还未初始化",
        object: object,
        caller: "coop.login"
      });
      return;
    }

    if (manager) {
      callFail({
        message: "已登录",
        object: object,
        code: 1001
      });
      return;
    }

    var _settings = settings,
        server = _settings.server,
        restServer = _settings.restServer,
        wssPort = _settings.wssPort,
        app = _settings.appId,
        etp = _settings.etpId,
        appSecret = _settings.appSecret,
        isHttps = _settings.serverHttps;
    var user = object.userId,
        password = object.password;
    var instance = new MTCManager({
      server: server,
      restServer: restServer,
      wssPort: wssPort,
      isHttps: isHttps,
      etp: etp,
      app: app,
      appSecret: appSecret
    });
    instance.login({
      user: user,
      password: password
    }).then(function () {
      manager = instance;
      callSuccess({
        object: object,
        data: null,
        caller: "coop.login"
      });
    })["catch"](function (error) {
      callFail({
        object: object,
        message: error && error.toString()
      });
    });
  }

  function getUserInfo() {
    return manager && manager.userinfo;
  }

  function logout(object) {
    manager && manager.logout();
    manager = null;
    callSuccess({
      object: object,
      data: null,
      caller: "coop.logout"
    });
  }

  function getOpenId(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.getOpenId().then(function (openId) {
      callSuccess({
        object: object,
        data: {
          openId: openId
        },
        caller: "coop.getOpenId"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function getDeviceInfo(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    var openId = object.openId;
    manager.getDeviceInfo(openId).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.getDeviceInfo"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function getMyDevices(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.getDevices({
      type: 3
    }).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.getMyDevices"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function getAuthorizedDevices(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.getDevices({
      type: 0
    }).then(function (_ref5) {
      var data = _ref5.binding;
      callSuccess({
        object: object,
        data: data,
        caller: "coop.getAuthorizedDevices"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function getAccessibleDevices(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.getDevices({
      type: 1
    }).then(function (_ref6) {
      var data = _ref6.byBinding;
      callSuccess({
        object: object,
        data: data,
        caller: "coop.getAccessibleDevices"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function getAllDevices(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.getDevices({
      type: 2
    }).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.getAllDevices"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function removeAuthorizedDevice(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.deleteDevice(0, object).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.removeAuthorizedDevice"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function removeAccessibleDevice(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.deleteDevice(1, object).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.removeAccessibleDevice"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function removeMyDevice(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    manager.deleteDevice(3, object).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.removeMyDevice"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function sendCommand(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    var commandType = object.commandType,
        to = object.to,
        commandParams = object.commandParams,
        onResponse = object.onResponse;
    manager.sendCommand({
      cmd: {
        to: to,
        commandType: commandType,
        commandParams: commandParams,
        response: 0
      },
      listener: onResponse
    }).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.sendCommand"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function receiveCommand(listener) {
    if (!checkAndCallbackIfError()) {
      console.log("coop.receiveCommand:fail", "reason:未登录");
      return;
    }

    if (_commandListenerId) {
      manager.removeListener(_commandListenerId);
    }

    _commandListenerId = manager.addListener("message", null, listener);
  }

  function replyCommand(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    var to = object.to,
        commandParams = object.commandParams,
        commandId = object.commandId;
    manager.sendCommand({
      cmd: {
        to: to,
        sourceCommandId: commandId,
        commandParams: commandParams,
        commandType: "MTL_CMD_MESSAGE",
        response: 1
      }
    }).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.replyCommand"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function requestAccessTo(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    var appId = object.appId,
        clientIdentify = object.clientIdentify,
        userId = object.userId,
        permissions = object.permissions,
        allPermissions = object.allPermissions,
        onResponse = object.onResponse;
    manager.requestAccess({
      to: {
        appId: appId,
        clientIdentify: clientIdentify,
        userId: userId
      },
      permissions: permissions,
      allPermissions: allPermissions,
      onResponse: onResponse
    }).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.requestAccessTo"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function receiveAccessRequest(listener) {
    if (!checkAndCallbackIfError()) {
      console.log("coop.receiveAccessRequest:fail", "reason:未登录");
      return;
    }

    if (_permissionListenerId) {
      manager.removeListener(_permissionListenerId);
    }

    _permissionListenerId = manager.addListener(LISTENER_TYPE_APPLY_PERMISSION, null, listener);
  }

  function agreeAccessRequest(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    var commandId = object.commandId,
        _object$commandParams = object.commandParams,
        permissions = _object$commandParams.permissions,
        allPermissions = _object$commandParams.allPermissions,
        to = object.to;
    manager.processAccessRequest({
      to: to,
      permissions: permissions,
      allPermissions: allPermissions,
      sourceCommandId: commandId
    }, true).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.agreeAccessRequest"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  function rejectAccessRequest(object) {
    if (!checkAndCallbackIfError(object)) {
      return;
    }

    var commandId = object.commandId,
        _object$commandParams2 = object.commandParams,
        permissions = _object$commandParams2.permissions,
        allPermissions = _object$commandParams2.allPermissions,
        to = object.to;
    manager.processAccessRequest({
      to: to,
      permissions: permissions,
      allPermissions: allPermissions,
      sourceCommandId: commandId
    }, false).then(function (data) {
      callSuccess({
        object: object,
        data: data,
        caller: "coop.rejectAccessRequest"
      });
    })["catch"](function (err) {
      callFail({
        object: object,
        message: err.toString()
      });
    });
  }

  return {
    initialize: initialize,
    login: login,
    getUserInfo: getUserInfo,
    logout: logout,
    getOpenId: getOpenId,
    getDeviceInfo: getDeviceInfo,
    getMyDevices: getMyDevices,
    getAuthorizedDevices: getAuthorizedDevices,
    getAccessibleDevices: getAccessibleDevices,
    getAllDevices: getAllDevices,
    removeAuthorizedDevice: removeAuthorizedDevice,
    removeAccessibleDevice: removeAccessibleDevice,
    removeMyDevice: removeMyDevice,
    sendCommand: sendCommand,
    receiveCommand: receiveCommand,
    replyCommand: replyCommand,
    requestAccessTo: requestAccessTo,
    receiveAccessRequest: receiveAccessRequest,
    agreeAccessRequest: agreeAccessRequest,
    rejectAccessRequest: rejectAccessRequest
  };
});