ng-yunzai-mobile
Version:
1. 适配yunzai_uni_app_x
484 lines • 39.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: devices/wechat.mp.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { BaseDevice } from "./base.device";
import { Injectable, Inject } from "@angular/core";
import { HttpClient } from "@angular/common/http";
import { BASE_CLIENT } from "../client/base.client";
import { preloaderFinished } from "../auth/preloader";
import { from } from "rxjs";
import { Title } from "@angular/platform-browser";
import { TokenService } from "../token/token.service";
import { UserService } from "../user/user.service";
import { map } from "rxjs/operators";
import * as i0 from "@angular/core";
import * as i1 from "../token/token.service";
import * as i2 from "@angular/common/http";
import * as i3 from "../user/user.service";
import * as i4 from "@angular/platform-browser";
import * as i5 from "../client/base.client";
/** @type {?} */
const apis = [
"updateAppMessageShareData",
"updateTimelineShareData",
"onMenuShareTimeline",
"onMenuShareAppMessage",
"onMenuShareQQ",
"onMenuShareWeibo",
"onMenuShareQZone",
"startRecord",
"stopRecord",
"onVoiceRecordEnd",
"playVoice",
"pauseVoice",
"stopVoice",
"onVoicePlayEnd",
"uploadVoice",
"downloadVoice",
"chooseImage",
"previewImage",
"uploadImage",
"downloadImage",
"translateVoice",
"getNetworkType",
"openLocation",
"getLocation",
"hideOptionMenu",
"showOptionMenu",
"hideMenuItems",
"showMenuItems",
"hideAllNonBaseMenuItem",
"showAllNonBaseMenuItem",
"closeWindow",
"scanQRCode",
"chooseWXPay",
"openProductSpecificView",
"addCard",
"chooseCard",
"openCard",
];
/** @type {?} */
const openTags = [
'wx-open-launch-weapp',
'wx-open-launch-app',
'wx-open-subscribe',
'wx-open-audio'
];
export class WechatMp extends BaseDevice {
/**
* @param {?} tokenService
* @param {?} http
* @param {?} user
* @param {?} title
* @param {?} baseclient
*/
constructor(tokenService, http, user, title, baseclient) {
super();
this.tokenService = tokenService;
this.http = http;
this.user = user;
this.title = title;
this.baseclient = baseclient;
}
/**
* @return {?}
*/
auth() {
if (this.baseclient.wechat && this.baseclient.wechat.auth === false) {
return new Promise((/**
* @param {?} resolve
* @param {?} reject
* @return {?}
*/
(resolve, reject) => {
preloaderFinished();
resolve(true);
}));
}
// 如果是本地开发配置了账号密码
if (this.baseclient.dev && this.baseclient.dev.username && this.baseclient.dev.password) {
return new Promise((/**
* @param {?} resolve
* @param {?} reject
* @return {?}
*/
(resolve, reject) => {
this.authByConfiguredUserPass().then((/**
* @return {?}
*/
() => {
this.http
.get(`${this.baseclient.gateway}/auth/user`)
.subscribe((/**
* @param {?} response
* @return {?}
*/
(response) => {
this.user.set(Object.assign({}, response.principal, { tenantId: response.tenantId }));
preloaderFinished();
resolve(true);
}));
}));
}));
}
// 走微信端的认证流程
return new Promise((/**
* @param {?} reject
* @param {?} resolve
* @return {?}
*/
(reject, resolve) => {
/** @type {?} */
const url = encodeURIComponent(window.location.href);
this.http
.get(`${this.baseclient.gateway}/wechat/mp/token?url=` + url)
.subscribe((/**
* @param {?} token
* @return {?}
*/
(token) => {
if (token.error_code === 200) {
this.tokenService.set((/** @type {?} */ ({
accessToken: token.message,
tokenType: "bearer",
})));
this.http
.get(`${this.baseclient.gateway}/auth/user`)
.subscribe((/**
* @param {?} response
* @return {?}
*/
(response) => {
this.user.set(Object.assign({}, response.principal, { tenantId: response.tenantId }));
// 暂不对微信jssdk进行对接
this.generateWechatConfig();
preloaderFinished();
reject(null);
}));
}
else if (token.error_code === 500) {
// 没有token，则重定向到认证页面，认证完成后会跳回本页面
window.location.href = token.path;
}
}));
}));
}
/**
* @private
* @return {?}
*/
authByConfiguredUserPass() {
/** @type {?} */
const form = new FormData();
form.set('username', this.baseclient.dev.username);
form.set('password', this.baseclient.dev.password);
form.set('grant_type', 'password');
form.set('client_id', 'webapp');
form.set('scope', 'webapp');
form.set('client_secret', '123456');
return this.http
.post(`${this.baseclient.gateway}/auth/oauth/token`, form)
.pipe(map((/**
* @param {?} response
* @return {?}
*/
(response) => {
/** @type {?} */
const token = {};
token.tokenType = response.token_type;
token.accessToken = response.access_token;
token.scope = response.scope;
token.tokenDateLine = response.expires_in;
this.tokenService.set(token);
})))
.toPromise();
}
/**
* @param {?} iwindow
* @return {?}
*/
openWindow(iwindow) {
window.location.href = iwindow.url;
}
/**
* @param {?} ititle
* @return {?}
*/
setTitle(ititle) {
this.title.setTitle(ititle.title);
}
/**
* @param {?} navigationBar
* @return {?}
*/
setNavigationBar(navigationBar) {
alert("微信端暂不支持放置按钮,请在APP中使用此功能!");
return;
}
/**
* @param {?} ishare
* @return {?}
*/
share(ishare) {
alert("微信端暂不支持分享,请在APP中使用此功能!");
}
/**
* @return {?}
*/
getToken() {
/** @type {?} */
const itoken = {
accessToken: this.tokenService.get().accessToken,
tokenType: null,
tokenDataLine: null,
scope: null,
};
return itoken;
}
/**
* @return {?}
*/
scanCode() {
/** @type {?} */
const p = new Promise((/**
* @param {?} resolve
* @param {?} reject
* @return {?}
*/
(resolve, reject) => {
wx.scanQRCode({
needResult: 1,
scanType: ['qrCode', 'barCode'],
success: (/**
* @param {?} res
* @return {?}
*/
(res) => {
resolve(res.resultStr);
}),
});
}));
return from(p);
}
/**
* @return {?}
*/
userLocation() {
/** @type {?} */
const p = new Promise((/**
* @param {?} resolve
* @param {?} reject
* @return {?}
*/
(resolve, reject) => {
wx.getLocation({
type: 'wgs84',
// 默认为wgs84的gps坐标，如果要返回直接给openLocation用的火星坐标，可传入'gcj02'
success: (/**
* @param {?} res
* @return {?}
*/
(res) => {
if (res.errMsg === 'getLocation:ok') {
/** @type {?} */
const latitude = res.latitude;
// 纬度，浮点数，范围为90 ~ -90
/** @type {?} */
const longitude = res.longitude;
// 经度，浮点数，范围为180 ~ -180。
/** @type {?} */
const address = '微信无address';
resolve({ latitude, longitude, address });
}
}),
});
}));
return from(p);
}
/**
* @param {?} bssids
* @return {?}
*/
validateInWifi(bssids) {
alert("微信端暂不支持WIFI验证,请在APP中使用此功能!");
return undefined;
}
/**
* @return {?}
*/
getWifiMac() {
alert("微信端暂不支持获取MAC地址,请在APP中使用此功能!");
return undefined;
}
/**
* @return {?}
*/
generateWechatConfig() {
this.http
.get(`${this.baseclient.gateway}/wechat/mp/jssdk?url=${encodeURIComponent(window.location.href)}`)
.subscribe((/**
* @param {?} response
* @return {?}
*/
(response) => {
wx.config({
debug: false,
// 开启调试模式,调用的所有api的返回值会在客户端alert出来，若要查看传入的参数，可以在pc端打开，参数信息会通过log打出，仅在pc端时才会打印。
appId: response.appId,
// 必填，公众号的唯一标识
timestamp: response.timestamp,
// 必填，生成签名的时间戳
nonceStr: response.nonceStr,
// 必填，生成签名的随机串
signature: response.signature,
// 必填，签名
jsApiList: apis,
// 必填，需要使用的JS接口列表
openTagList: openTags // 可选，需要使用的开放标签列表，例如['wx-open-launch-app']
});
}));
wx.ready((/**
* @return {?}
*/
() => {
// config信息验证后会执行ready方法，所有接口调用都必须在config接口获得结果之后，config是一个客户端的异步操作，
// 所以如果需要在页面加载时就调用相关接口，则须把相关接口放在ready函数中调用来确保正确执行。对于用户触发时才调用的接口，则可以直接调用，不需要放在ready函数中。
console.log('微信jssdk初始化完成.');
}));
wx.error((/**
* @param {?} res
* @return {?}
*/
(res) => {
// config信息验证失败会执行error函数，如签名过期导致验证失败，具体错误信息可以打开config的debug模式查看，也可以在返回的res参数中查看，对于SPA可以在这里更新签名。
console.log('微信jssdk初始化失败:', res);
}));
}
/**
* @param {?} count
* @return {?}
*/
chooseContacts(count) {
alert("微信端暂不支持获取联系人,请在APP中使用此功能!");
return undefined;
}
/**
* @param {?} targetUserId
* @return {?}
*/
contactDetails(targetUserId) {
alert("微信端暂不支持查询联系人详细信息,请在APP中使用此功能!");
return undefined;
}
/**
* @param {?} count
* @param {?} sourceType
* @return {?}
*/
uploadImage(count, sourceType) {
alert("微信端暂不支持图片上传,请在APP中使用此功能!");
return undefined;
}
/**
* @param {?} url
* @param {?} openType
* @param {?} title
* @param {?} id
* @param {?} type
* @return {?}
*/
openReadWithTimer(url, openType, title, id, type) {
alert("微信端暂不支持读物时间统计,请在APP中使用此功能!");
return undefined;
}
/**
* @param {?} limitMinute
* @return {?}
*/
uploadMovie(limitMinute) {
alert("微信端暂不支持视频上传,请在APP中使用此功能!");
return undefined;
}
/**
* @param {?} url
* @param {?} title
* @return {?}
*/
fileBrowser(url, title) {
alert("微信端暂不支持此功能,请在APP中使用此功能!");
return undefined;
}
/**
* @param {?} ticket
* @param {?} callback
* @return {?}
*/
startSearchBeacons(ticket, callback) {
wx.startSearchBeacons({
ticket: ticket,
complete: callback,
});
}
/**
* @param {?} callback
* @return {?}
*/
stopSearchBeacons(callback) {
wx.stopSearchBeacons({
complete: callback,
});
}
/**
* @param {?} callback
* @return {?}
*/
onSearchBeacons(callback) {
wx.onSearchBeacons({
complete: callback,
});
}
}
WechatMp.decorators = [
{ type: Injectable, args: [{
providedIn: "root",
},] }
];
/** @nocollapse */
WechatMp.ctorParameters = () => [
{ type: TokenService },
{ type: HttpClient },
{ type: UserService },
{ type: Title },
{ type: undefined, decorators: [{ type: Inject, args: [BASE_CLIENT,] }] }
];
/** @nocollapse */ WechatMp.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function WechatMp_Factory() { return new WechatMp(i0.ɵɵinject(i1.TokenService), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.UserService), i0.ɵɵinject(i4.Title), i0.ɵɵinject(i5.BASE_CLIENT)); }, token: WechatMp, providedIn: "root" });
if (false) {
/**
* @type {?}
* @private
*/
WechatMp.prototype.tokenService;
/**
* @type {?}
* @private
*/
WechatMp.prototype.http;
/**
* @type {?}
* @private
*/
WechatMp.prototype.user;
/**
* @type {?}
* @private
*/
WechatMp.prototype.title;
/**
* @type {?}
* @private
*/
WechatMp.prototype.baseclient;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wechat.mp.js","sourceRoot":"ng://ng-yunzai-mobile/","sources":["devices/wechat.mp.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseDevice } from \"./base.device\";\r\nimport { Injectable, Inject } from \"@angular/core\";\r\nimport { HttpClient } from \"@angular/common/http\";\r\nimport { BASE_CLIENT, BaseClient } from \"../client/base.client\";\r\nimport { MyWechatMpToken } from \"./model/wechat.mp\";\r\nimport { preloaderFinished } from \"../auth/preloader\";\r\nimport { IWindow } from \"./model/window\";\r\nimport { ITitle } from \"./model/title\";\r\nimport { NavigationBar } from \"./model/navigationbar\";\r\nimport { IShare } from \"./model/share\";\r\nimport { Itoken } from \"../auth/itoken\";\r\nimport { from, Observable } from \"rxjs\";\r\nimport { UserLocation } from \"./model/location\";\r\nimport { Title } from \"@angular/platform-browser\";\r\nimport { TokenService } from \"../token/token.service\";\r\nimport { UserService } from \"../user/user.service\";\r\nimport {map} from \"rxjs/operators\";\r\n\r\nconst apis = [\r\n  \"updateAppMessageShareData\",\r\n  \"updateTimelineShareData\",\r\n  \"onMenuShareTimeline\",\r\n  \"onMenuShareAppMessage\",\r\n  \"onMenuShareQQ\",\r\n  \"onMenuShareWeibo\",\r\n  \"onMenuShareQZone\",\r\n  \"startRecord\",\r\n  \"stopRecord\",\r\n  \"onVoiceRecordEnd\",\r\n  \"playVoice\",\r\n  \"pauseVoice\",\r\n  \"stopVoice\",\r\n  \"onVoicePlayEnd\",\r\n  \"uploadVoice\",\r\n  \"downloadVoice\",\r\n  \"chooseImage\",\r\n  \"previewImage\",\r\n  \"uploadImage\",\r\n  \"downloadImage\",\r\n  \"translateVoice\",\r\n  \"getNetworkType\",\r\n  \"openLocation\",\r\n  \"getLocation\",\r\n  \"hideOptionMenu\",\r\n  \"showOptionMenu\",\r\n  \"hideMenuItems\",\r\n  \"showMenuItems\",\r\n  \"hideAllNonBaseMenuItem\",\r\n  \"showAllNonBaseMenuItem\",\r\n  \"closeWindow\",\r\n  \"scanQRCode\",\r\n  \"chooseWXPay\",\r\n  \"openProductSpecificView\",\r\n  \"addCard\",\r\n  \"chooseCard\",\r\n  \"openCard\",\r\n];\r\n\r\nconst openTags = [\r\n  'wx-open-launch-weapp',\r\n  'wx-open-launch-app',\r\n  'wx-open-subscribe',\r\n  'wx-open-audio'\r\n];\r\n\r\ndeclare let wx;\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class WechatMp extends BaseDevice {\r\n  constructor(\r\n    private tokenService: TokenService,\r\n    private http: HttpClient,\r\n    private user: UserService,\r\n    private title: Title,\r\n    @Inject(BASE_CLIENT) private baseclient: BaseClient\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  auth(): Promise<any> {\r\n    if (this.baseclient.wechat && this.baseclient.wechat.auth === false) {\r\n      return new Promise<any>((resolve, reject) => {\r\n        preloaderFinished();\r\n        resolve(true);\r\n      });\r\n    }\r\n    // 如果是本地开发配置了账号密码\r\n    if (this.baseclient.dev && this.baseclient.dev.username && this.baseclient.dev.password) {\r\n      return new Promise<any>((resolve, reject) => {\r\n        this.authByConfiguredUserPass().then(() => {\r\n          this.http\r\n            .get(`${this.baseclient.gateway}/auth/user`)\r\n            .subscribe((response: any) => {\r\n              this.user.set({...response.principal, tenantId: response.tenantId});\r\n              preloaderFinished();\r\n              resolve(true);\r\n            });\r\n        });\r\n      });\r\n    }\r\n\r\n    // 走微信端的认证流程\r\n    return new Promise<any>((reject, resolve) => {\r\n      const url = encodeURIComponent(window.location.href);\r\n      this.http\r\n        .get(`${this.baseclient.gateway}/wechat/mp/token?url=` + url)\r\n        .subscribe((token: MyWechatMpToken) => {\r\n          if (token.error_code === 200) {\r\n            this.tokenService.set({\r\n              accessToken: token.message,\r\n              tokenType: \"bearer\",\r\n            } as any);\r\n            this.http\r\n              .get(`${this.baseclient.gateway}/auth/user`)\r\n              .subscribe((response: any) => {\r\n                this.user.set({ ...response.principal, tenantId: response.tenantId });\r\n                // 暂不对微信jssdk进行对接\r\n                this.generateWechatConfig();\r\n                preloaderFinished();\r\n                reject(null);\r\n              });\r\n          } else if (token.error_code === 500) {\r\n            // 没有token，则重定向到认证页面，认证完成后会跳回本页面\r\n            window.location.href = token.path;\r\n          }\r\n        });\r\n    });\r\n  }\r\n\r\n  private authByConfiguredUserPass(): Promise<void> {\r\n    const form: FormData = new FormData();\r\n    form.set('username', this.baseclient.dev.username);\r\n    form.set('password', this.baseclient.dev.password);\r\n    form.set('grant_type', 'password');\r\n    form.set('client_id', 'webapp');\r\n    form.set('scope', 'webapp');\r\n    form.set('client_secret', '123456');\r\n\r\n    return this.http\r\n      .post(`${this.baseclient.gateway}/auth/oauth/token`, form)\r\n      .pipe(\r\n        map((response: any) => {\r\n          const token: any = {};\r\n          token.tokenType = response.token_type;\r\n          token.accessToken = response.access_token;\r\n          token.scope = response.scope;\r\n          token.tokenDateLine = response.expires_in;\r\n          this.tokenService.set(token);\r\n        })\r\n      )\r\n      .toPromise();\r\n  }\r\n\r\n  openWindow(iwindow: IWindow): void {\r\n    window.location.href = iwindow.url;\r\n  }\r\n\r\n  setTitle(ititle: ITitle): void {\r\n    this.title.setTitle(ititle.title);\r\n  }\r\n\r\n  setNavigationBar(navigationBar: NavigationBar): void {\r\n    alert(\"微信端暂不支持放置按钮,请在APP中使用此功能!\");\r\n    return;\r\n  }\r\n\r\n  share(ishare: IShare): void {\r\n    alert(\"微信端暂不支持分享,请在APP中使用此功能!\");\r\n  }\r\n\r\n  getToken(): Itoken {\r\n    const itoken: Itoken = {\r\n      accessToken: this.tokenService.get().accessToken,\r\n      tokenType: null,\r\n      tokenDataLine: null,\r\n      scope: null,\r\n    };\r\n    return itoken;\r\n  }\r\n\r\n  scanCode(): Observable<string> {\r\n    const p = new Promise<string>((resolve, reject) => {\r\n      wx.scanQRCode({\r\n        needResult: 1,\r\n        scanType: ['qrCode', 'barCode'],\r\n        success: (res: any) => {\r\n          resolve(res.resultStr);\r\n        },\r\n      });\r\n    });\r\n    return from(p);\r\n  }\r\n\r\n  userLocation(): Observable<UserLocation> {\r\n    const p = new Promise<UserLocation>((resolve, reject) => {\r\n      wx.getLocation({\r\n        type: 'wgs84', // 默认为wgs84的gps坐标，如果要返回直接给openLocation用的火星坐标，可传入'gcj02'\r\n        success: (res: any) => {\r\n          if (res.errMsg === 'getLocation:ok') {\r\n            const latitude = res.latitude; // 纬度，浮点数，范围为90 ~ -90\r\n            const longitude = res.longitude; // 经度，浮点数，范围为180 ~ -180。\r\n            const address = '微信无address';\r\n            resolve({latitude, longitude, address});\r\n          }\r\n        },\r\n      });\r\n    });\r\n    return from(p);\r\n  }\r\n\r\n  validateInWifi(bssids: string[]): Observable<boolean> {\r\n    alert(\"微信端暂不支持WIFI验证,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  getWifiMac(): Observable<string> {\r\n    alert(\"微信端暂不支持获取MAC地址,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  generateWechatConfig(): void {\r\n    this.http\r\n      .get(`${this.baseclient.gateway}/wechat/mp/jssdk?url=${encodeURIComponent(window.location.href)}`)\r\n      .subscribe((response: any) => {\r\n        wx.config({\r\n          debug: false, // 开启调试模式,调用的所有api的返回值会在客户端alert出来，若要查看传入的参数，可以在pc端打开，参数信息会通过log打出，仅在pc端时才会打印。\r\n          appId: response.appId, // 必填，公众号的唯一标识\r\n          timestamp: response.timestamp, // 必填，生成签名的时间戳\r\n          nonceStr: response.nonceStr, // 必填，生成签名的随机串\r\n          signature: response.signature, // 必填，签名\r\n          jsApiList: apis, // 必填，需要使用的JS接口列表\r\n          openTagList: openTags // 可选，需要使用的开放标签列表，例如['wx-open-launch-app']\r\n        });\r\n      });\r\n    wx.ready(() => {\r\n      // config信息验证后会执行ready方法，所有接口调用都必须在config接口获得结果之后，config是一个客户端的异步操作，\r\n      // 所以如果需要在页面加载时就调用相关接口，则须把相关接口放在ready函数中调用来确保正确执行。对于用户触发时才调用的接口，则可以直接调用，不需要放在ready函数中。\r\n      console.log('微信jssdk初始化完成.');\r\n    });\r\n\r\n    wx.error((res) => {\r\n      // config信息验证失败会执行error函数，如签名过期导致验证失败，具体错误信息可以打开config的debug模式查看，也可以在返回的res参数中查看，对于SPA可以在这里更新签名。\r\n      console.log('微信jssdk初始化失败:', res);\r\n    });\r\n  }\r\n\r\n  chooseContacts(count: number): Observable<any> {\r\n    alert(\"微信端暂不支持获取联系人,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  contactDetails(targetUserId: string): Observable<any> {\r\n    alert(\"微信端暂不支持查询联系人详细信息,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  uploadImage(count: number, sourceType: any): Observable<any> {\r\n    alert(\"微信端暂不支持图片上传,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  openReadWithTimer(\r\n    url: any,\r\n    openType: any,\r\n    title: any,\r\n    id: any,\r\n    type: any\r\n  ): Observable<any> {\r\n    alert(\"微信端暂不支持读物时间统计,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  uploadMovie(limitMinute: number): Observable<any> {\r\n    alert(\"微信端暂不支持视频上传,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n  fileBrowser(url: string, title: string): Observable<any> {\r\n    alert(\"微信端暂不支持此功能,请在APP中使用此功能!\");\r\n    return undefined;\r\n  }\r\n\r\n  startSearchBeacons(ticket: string, callback: (argv: any) => void): void {\r\n    wx.startSearchBeacons({\r\n      ticket: ticket,\r\n      complete: callback,\r\n    });\r\n  }\r\n  stopSearchBeacons(callback: (argv: any) => void): void {\r\n    wx.stopSearchBeacons({\r\n      complete: callback,\r\n    });\r\n  }\r\n  onSearchBeacons(callback: (argv: any) => void): void {\r\n    wx.onSearchBeacons({\r\n      complete: callback,\r\n    });\r\n  }\r\n}\r\n"]}