mtl-js-sdk/lib/platforms/all-platform/ucg/index.js

"use strict";

// eslint-disable-next-line no-undef
define(["./config.js"], function (config) {
  var readUCGConfig = config.readUCGConfig;

  function getUrl(object, suffix) {
    var appCode = object.appCode;
    var UCGConfig = appCode ? readUCGConfig({
      appcode: appCode
    }) || {} : {};

    var _object$isHttps = object.isHttps,
        isHttps = _object$isHttps === void 0 ? UCGConfig.isHttps || false : _object$isHttps,
        _object$port = object.port,
        port = _object$port === void 0 ? UCGConfig.port || "" : _object$port,
        _object$host = object.host,
        host = _object$host === void 0 ? UCGConfig.host || "" : _object$host,
        _object$url = object.url,
        url = _object$url === void 0 ? "" : _object$url,
        _object$_suffix = object._suffix,
        _suffix = _object$_suffix === void 0 ? suffix : _object$_suffix;

    if (url.indexOf("http") != -1) {
      var _url = "".concat(url).concat(_suffix);

      return _url;
    } else {
      var http = isHttps ? "https://" : "http://";

      var _port = port ? ":" + port : "";

      var _url2 = host ? "".concat(http).concat(host).concat(_port).concat(url).concat(_suffix) : "".concat(url).concat(_suffix);

      return _url2;
    }
  }

  function getTerminalType() {
    var terminalType = "";
    var platform = mtl.platform;

    switch (platform) {
      case "android":
        terminalType = "Android";
        break;

      case "ios":
        terminalType = "IOS";
        break;

      case "wx":
        terminalType = "WX";
        break;

      case "dd":
        terminalType = "DD";
        break;

      case "h5":
        terminalType = "h5";
        break;

      case "upesn":
        terminalType = "upesn";
        break;

      default:
        break;
    }

    return terminalType;
  }

  function onCommon(func, object) {
    var promise = new Promise(func);
    promise.then(function (res) {
      object.success && object.success(res.data);
      object.complete && object.complete(res);
    })["catch"](function (err) {
      object.fail && object.fail(err);
      object.complete && object.complete(err);
    });
  }

  function _loginByUser(object, resolve, reject) {
    var terminalType = object.terminalType || getTerminalType();
    var appCode = object.appCode,
        userName = object.userName,
        password = object.password;

    var _url = getUrl(object, "/mtl/login");

    console.log(_url); // 调用网络请求，请求登录接口

    var target = {
      url: _url,
      method: "POST",
      // 默认值
      data: {
        userName: userName,
        password: password,
        appCode: appCode,
        terminalType: terminalType
      },
      header: {
        "content-type": "application/json" // 默认值

      },
      complete: function complete(res) {
        resolve && resolve(res);
      },
      fail: function fail(err) {
        reject && reject(err);
      }
    };
    mtl.request(target);
  }

  function _loginByCode(object, resolve, reject) {
    var terminalType = object.terminalType || getTerminalType();
    var appCode = object.appCode,
        code = object.code;

    var _url = getUrl(object, "/mtl/loginThird");

    if (typeof code == "undefined" || !!!code) {
      mtl.getAuthCode({
        success: function success(res) {
          var code = res.authCode;
          console.log('authCode', code); // 调用网络请求，请求登录接口

          if (terminalType == 'WX') {
            mtl.getUserInfo({
              complete: function complete(res) {
                var userInfo = res.data ? res.data.userInfo : "";
                var data = {
                  appCode: appCode,
                  userInfo: userInfo || null,
                  code: code,
                  terminalType: terminalType
                };

                _loginRequest(_url, data, resolve, reject);
              }
            });
          } else {
            var data = {
              appCode: appCode,
              code: code,
              terminalType: terminalType
            };

            _loginRequest(_url, data, resolve, reject);
          }
        }
      });
    } else {
      // 调用网络请求，请求登录接口
      var data = {
        appCode: appCode,
        code: code,
        terminalType: terminalType
      };

      _loginRequest(_url, data, resolve, reject);
    }
  }

  function _loginRequest(_url, data, resolve, reject) {
    console.log('_loginRequest', JSON.stringify(data));
    mtl.request({
      url: _url,
      method: "POST",
      data: data,
      header: {
        "content-type": "application/json" // 默认值

      },
      complete: function complete(res) {
        resolve && resolve(res);
      },
      fail: function fail(err) {
        reject && reject(err);
      }
    });
  }

  function _bindUser(object, resolve, reject) {
    var terminalType = object.terminalType || getTerminalType();
    var appCode = object.appCode,
        tenantCode = object.tenantCode,
        userName = object.userName,
        password = object.password,
        type = object.type,
        code = object.code,
        deviceId = object.deviceId,
        langCode = object.langCode,
        yhtId = object.yhtId;

    var _url = getUrl(object, "/mtl/bind");

    console.log(_url); // 调用网络请求，请求登录接口

    mtl.request({
      url: _url,
      method: "POST",
      // 默认值
      data: {
        tenantCode: tenantCode,
        userName: userName,
        password: password,
        appCode: appCode,
        type: type,
        code: code,
        deviceId: deviceId,
        langCode: langCode,
        yhtId: yhtId,
        terminalType: terminalType
      },
      header: {
        "content-type": "application/json" // 默认值

      },
      complete: function complete(res) {
        resolve && resolve(res);
      },
      fail: function fail(err) {
        reject && reject(err);
      }
    });
  }

  function _getToken(object, resolve, reject) {
    var appCode = object.appCode,
        tenantCode = object.tenantCode,
        code = object.code,
        deviceId = object.deviceId,
        langCode = object.langCode,
        yhtId = object.yhtId;
    var terminalType = object.terminalType || getTerminalType();

    var _url = getUrl(object, "/mtl/getToken");

    console.log(_url); // 调用网络请求，请求登录接口

    mtl.request({
      url: _url,
      method: "POST",
      // 默认值
      data: {
        tenantCode: tenantCode,
        appCode: appCode,
        code: code,
        deviceId: deviceId,
        langCode: langCode,
        yhtId: yhtId,
        terminalType: terminalType
      },
      header: {
        "content-type": "application/json" // 默认值

      },
      fail: function fail(err) {
        reject(err);
      },
      complete: function complete(res) {
        resolve(res);
      }
    });
  }

  function login(object) {
    var platform = mtl.platform;
    object.terminalType = object.terminalType || getTerminalType();

    switch (platform) {
      case "android":
      case "ios":
        mtl.ucg.loginByUser(object);
        break;

      case "wx":
      case "dd":
        mtl.ucg.loginByCode(object);
        break;

      case "upesn":
      case "h5":
        if (object.code) {
          mtl.ucg.loginByCode(object);
        }

        break;

      default:
        break;
    }
  }

  function loginByUser(object) {
    var appCode = object.appCode;
    onCommon(function (resolve, reject) {
      if (typeof appCode == "undefined" || !!!appCode) {
        mtl.getAppCode({
          success: function success(res) {
            var appCode = res.appCode;
            object.appCode = appCode;

            _loginByUser(object, resolve, reject);
          }
        });
      } else {
        _loginByUser(object, resolve, reject);
      }
    }, object);
  }

  function loginByCode(object) {
    // code
    onCommon(function (resolve, reject) {
      var appCode = object.appCode;

      if (typeof appCode == "undefined" || !!!appCode) {
        mtl.getAppCode({
          success: function success(res) {
            var appCode = res.appCode;
            console.log('appCode', appCode);
            object.appCode = appCode;

            _loginByCode(object, resolve, reject);
          }
        });
      } else {
        _loginByCode(object, resolve, reject);
      }
    }, object);
  }

  function bindUser(object) {
    // code
    var terminalType = object.terminalType || getTerminalType();
    onCommon(function (resolve, reject) {
      _bindUser(object, resolve, reject);
    }, object);
  }

  function getToken(object) {
    // code
    onCommon(function (resolve, reject) {
      if (typeof object.appCode == "undefined" || !!!object.appCode) {
        mtl.getAppCode({
          success: function success(res) {
            var appCode = res.appCode;
            object.appCode = appCode;

            _getToken(object, resolve, reject);
          },
          fail: function fail(res) {
            object.fail && object.fail(res);
          }
        });
      } else {
        _getToken(object, resolve, reject);
      }
    }, object);
  }

  function callAction(object) {
    // let {appCode,token} = object;
    // token || config.getToken(appCode);
    // if(token){
    //   let resErr = {
    //     code:-1,
    //     message:`appCode :${appCode},未登录,当前未取到token`
    //   }
    //   object.fail && object.fail(resErr);
    //   object.complete && object.complete(resErr);
    //   return;
    // }
    // code
    onCommon(function (resolve, reject) {
      var headers = object.headers || {};
      var data = object.data || {};
      var params = object.params || {}; // headers.token = token;

      var _url = getUrl(object, "");

      console.log(_url); // 调用网络请求，请求登录接口

      mtl.request({
        url: _url,
        method: "POST",
        // 默认值
        data: data,
        params: params,
        headers: headers,
        complete: function complete(res) {
          resolve(res);
        },
        fail: function fail(err) {
          reject(err);
        }
      });
    }, object);
  }

  function uploadFile(object) {
    onCommon(function (resolve, reject) {
      var headers = object.headers || {};
      var formData = object.formData || {};
      var filePath = object.filePath || {};

      var _url = getUrl(object, "");

      console.log(_url); // 调用网络请求，请求登录接口

      mtl.uploadFile({
        url: _url,
        header: headers,
        formData: formData,
        filePath: filePath,
        complete: function complete(res) {
          resolve(res);
        },
        fail: function fail(err) {
          reject(err);
        }
      });
    }, object);
  }
  /**
   * 推送消息的监听，当钉钉端接收到消息时会通过object的回调方法传送
   * @param {*} object
   */


  function addPushListener(object) {
    var platform = mtl.platform;

    if ("dd" == platform) {
      mtl.addPushListener(object);
    } else {
      object.complete && object.complete({
        code: 200,
        message: "",
        data: {}
      });
      return;
    }
  }

  return {
    config: config,
    getUrl: getUrl,
    getTerminalType: getTerminalType,
    login: login,
    uploadFile: uploadFile,
    loginByUser: loginByUser,
    loginByCode: loginByCode,
    bindUser: bindUser,
    getToken: getToken,
    callAction: callAction,
    writeUCGConfig: config.writeUCGConfig,
    readUCGConfig: config.readUCGConfig,
    addPushListener: addPushListener
  };
});