fix git ignore

Author: yini-chen

.gitignore

@@ -19,7 +19,7 @@ lib/services/
 .mocks/
 .idea/
 test/services/
-lib/
+media/lib/
 scripts/dev/
 yarn-error.log
 out/

src/openApiService/lib/client.ts

@@ -0,0 +1,296 @@
+'use strict';
+
+const { default: OpenApiUtil } = require('@alicloud/openapi-util');
+const { default: Util } = require('@alicloud/tea-util');
+const $Credential = require('@alicloud/credentials');
+const $tea = require('@alicloud/tea-typescript');
+const { default: Credential } = require('@alicloud/credentials');
+
+export class OpenAPIClient {
+  private _credential: any;
+  private _endpoint: any;
+  private _endpointType: any;
+  private _protocol: any;
+  private _regionId: any;
+  private _userAgent: any;
+  private _readTimeout: any;
+  private _connectTimeout: any;
+  private _httpsProxy: any;
+  private _httpProxy: any;
+  private _noProxy: any;
+  private _socks5Proxy: any;
+  private _socks5NetWork: any;
+  private _maxIdleConns: any;
+  private _signatureAlgorithm: any;
+  constructor(config) {
+    if (Util.isUnset($tea.toMap(config))) {
+      throw $tea.newError({
+        code: 'ParameterMissing',
+        message: "'config' can not be unset",
+      });
+    }
+
+    if (!Util.isUnset(config.credential)) {
+      this._credential = config.credential;
+    } else if (!Util.empty(config.accessKeyId) && !Util.empty(config.accessKeySecret)) {
+      if (!Util.empty(config.securityToken)) {
+        config.type = 'sts';
+      } else {
+        config.type = 'access_key';
+      }
+
+      let credentialConfig = new $Credential.Config({
+        accessKeyId: config.accessKeyId,
+        type: config.type,
+        accessKeySecret: config.accessKeySecret,
+        securityToken: config.securityToken,
+      });
+      this._credential = new Credential(credentialConfig);
+    }
+
+    this._endpoint = config.endpoint;
+    this._endpointType = config.endpointType;
+    this._protocol = config.protocol;
+    this._regionId = config.regionId;
+    this._userAgent = config.userAgent;
+    this._readTimeout = config.readTimeout;
+    this._connectTimeout = config.connectTimeout;
+    this._httpProxy = config.httpProxy;
+    this._httpsProxy = config.httpsProxy;
+    this._noProxy = config.noProxy;
+    this._socks5Proxy = config.socks5Proxy;
+    this._socks5NetWork = config.socks5NetWork;
+    this._maxIdleConns = config.maxIdleConns;
+    this._signatureAlgorithm = config.signatureAlgorithm;
+  }
+
+  async getAccessKeyId() {
+    if (Util.isUnset(this._credential)) {
+      return '';
+    }
+
+    let accessKeyId = await this._credential.getAccessKeyId();
+    return accessKeyId;
+  }
+
+  /**
+   * Get accesskey secret by using credential
+   * @return accesskey secret
+   */
+  async getAccessKeySecret() {
+    if (Util.isUnset(this._credential)) {
+      return '';
+    }
+
+    let secret = await this._credential.getAccessKeySecret();
+    return secret;
+  }
+
+  async getSecurityToken() {
+    if (Util.isUnset(this._credential)) {
+      return '';
+    }
+
+    let token = await this._credential.getSecurityToken();
+    return token;
+  }
+
+  defaultAny(inputValue, defaultValue) {
+    if (Util.isUnset(inputValue)) {
+      return defaultValue;
+    }
+
+    return inputValue;
+  }
+
+  async doRequest(params, request, runtime) {
+    let _runtime = {
+      timeouted: 'retry',
+      readTimeout: Util.defaultNumber(runtime.readTimeout, this._readTimeout),
+      connectTimeout: Util.defaultNumber(runtime.connectTimeout, this._connectTimeout),
+      httpProxy: Util.defaultString(runtime.httpProxy, this._httpProxy),
+      httpsProxy: Util.defaultString(runtime.httpsProxy, this._httpsProxy),
+      noProxy: Util.defaultString(runtime.noProxy, this._noProxy),
+      maxIdleConns: Util.defaultNumber(runtime.maxIdleConns, this._maxIdleConns),
+      retry: {
+        retryable: runtime.autoretry,
+        maxAttempts: Util.defaultNumber(runtime.maxAttempts, 3),
+      },
+      backoff: {
+        policy: Util.defaultString(runtime.backoffPolicy, 'no'),
+        period: Util.defaultNumber(runtime.backoffPeriod, 1),
+      },
+      ignoreSSL: runtime.ignoreSSL,
+    };
+
+    let _lastRequest = null;
+    let _now = Date.now();
+    let _retryTimes = 0;
+    while ($tea.allowRetry(_runtime['retry'], _retryTimes, _now)) {
+      if (_retryTimes > 0) {
+        let _backoffTime = $tea.getBackoffTime(_runtime['backoff'], _retryTimes);
+        if (_backoffTime > 0) {
+          await $tea.sleep(_backoffTime);
+        }
+      }
+
+      _retryTimes = _retryTimes + 1;
+      let entry;
+      try {
+        let request_ = new $tea.Request();
+        request_.protocol = Util.defaultString(this._protocol, params.protocol);
+        request_.method = params.method;
+        request_.pathname = OpenApiUtil.getEncodePath(params.pathname);
+        request_.query = OpenApiUtil.query(request.query);
+        // endpoint is setted in product client
+        request_.headers = {
+          host: this._endpoint,
+          'x-acs-version': params.version,
+          'x-acs-action': params.action,
+          'user-agent': 'Alibaba Cloud API Toolkit',
+          'x-acs-date': OpenApiUtil.getTimestamp(),
+          'x-acs-signature-nonce': Util.getNonce(),
+          accept: 'application/json',
+          ...request.headers,
+        };
+        if (request.headers && request.headers['Host']) {
+          delete request_.headers['Host'];
+          request_.headers['host'] = request.headers['Host'];
+        }
+        let signatureAlgorithm = Util.defaultString(this._signatureAlgorithm, 'ACS3-HMAC-SHA256');
+        let hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(Util.toBytes(''), signatureAlgorithm));
+        if (!Util.isUnset(request.stream)) {
+          let tmp = await Util.readAsBytes(request.stream);
+          hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(tmp, signatureAlgorithm));
+          request_.body = new $tea.BytesReadable(tmp);
+          request_.headers['content-type'] = 'application/octet-stream';
+        }
+        else {
+          if (!Util.isUnset(request.body)) {
+            if (Util.equalString(params.reqBodyType, 'json')) {
+              let jsonObj = Util.toJSONString(request.body);
+              hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(Util.toBytes(jsonObj), signatureAlgorithm));
+              request_.body = new $tea.BytesReadable(jsonObj);
+              request_.headers['content-type'] = 'application/json; charset=utf-8';
+            }
+            else {
+              let m = Util.assertAsMap(request.body);
+              let formObj = OpenApiUtil.toForm(m);
+              hashedRequestPayload = OpenApiUtil.hexEncode(OpenApiUtil.hash(Util.toBytes(formObj), signatureAlgorithm));
+              request_.body = new $tea.BytesReadable(formObj);
+              request_.headers['content-type'] = 'application/x-www-form-urlencoded';
+            }
+          }
+        }
+
+        request_.headers['x-acs-content-sha256'] = hashedRequestPayload;
+        if (!Util.equalString(params.authType, 'Anonymous')) {
+          let accessKeyId = await this.getAccessKeyId();
+          let accessKeySecret = await this.getAccessKeySecret();
+          let securityToken = await this.getSecurityToken();
+          if (!Util.empty(securityToken)) {
+            request_.headers['x-acs-accesskey-id'] = accessKeyId;
+            request_.headers['x-acs-security-token'] = securityToken;
+          }
+
+
+          request_.headers['Authorization'] = OpenApiUtil.getAuthorization(request_, signatureAlgorithm, hashedRequestPayload, accessKeyId, accessKeySecret);
+        }
+        request_.headers['host'] = this._endpoint;
+        if (request.headers && request.headers['Host']) {
+          request_.headers['Host'] = request.headers['Host'];
+        }
+
+        _lastRequest = request_;
+        console.log("_lastRequest",_lastRequest)
+        
+        let response_ = await $tea.doAction(request_, _runtime);
+        entry =  {
+          request: {
+            headers: request_.headers
+          },
+          response: {
+            statusCode: response_.statusCode,
+            headers: response_.headers,
+          }
+        };
+
+        if (Util.is4xx(response_.statusCode) || Util.is5xx(response_.statusCode)) {
+          let _res = await Util.readAsJSON(response_.body);
+          let err = Util.assertAsMap(_res);
+          return {
+            format: 'json',
+            result: err,
+            entry
+          };
+        }
+
+        if (response_.statusCode === 204 && (Util.isUnset(response_.headers['content-type']) || Util.isUnset(response_.headers['content-length']))) {
+          let str = await Util.readAsString(response_.body);
+          return {
+            format: 'string',
+            result: str,
+            entry
+          };
+        }
+
+        if (Util.equalString(params.bodyType, 'binary')) {
+          return {
+            format: 'binary',
+            result: response_.body,
+            entry
+          };
+        } else if (Util.equalString(params.bodyType, 'byte')) {
+          let byt = await Util.readAsBytes(response_.body);
+          return {
+            format: 'byte',
+            result: byt,
+            entry
+          };
+        } else if (Util.equalString(params.bodyType, 'string')) {
+          let str = await Util.readAsString(response_.body);
+          return {
+            format: 'string',
+            result: str,
+            entry
+          };
+        } else if (Util.equalString(params.bodyType, 'json')) {
+          let obj = await Util.readAsJSON(response_.body);
+          let res = Util.assertAsMap(obj);
+          return {
+            format: 'json',
+            result: res,
+            entry
+          };
+        } else if (Util.equalString(params.bodyType, 'array')) {
+          let arr = await Util.readAsJSON(response_.body);
+          return {
+            format: 'json',
+            result: arr,
+            entry
+          };
+        } 
+        let str = await Util.readAsString(response_.body);
+        return {
+          format: 'string',
+          result: str,
+          entry
+        };
+        
+
+      } catch (ex) {
+        if ($tea.isRetryable(ex)) {
+          continue;
+        }
+        ex.entry = entry;
+        throw ex;
+      }
+    }
+
+    throw $tea.newUnretryableError(_lastRequest);
+  }
+}
+
+
+exports.Client = OpenAPIClient;
+export default OpenAPIClient;