fmode-ng 0.0.39 → 0.0.41

package/esm2022/lib/user/login/auth.service.mjs

@@ -1,10 +1,375 @@
-
+import { Injectable } from '@angular/core';
+import Parse from "parse";
+import { Router } from '@angular/router';
+// import { AccountService } from '../account/account.service';
+import { NovaCloudService } from '../../nova-cloud';
+import { HttpClient } from '@angular/common/http';
+import { ToastController } from '@ionic/angular/standalone';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@ionic/angular/standalone";
+import * as i3 from "../../nova-cloud";
+import * as i4 from "@angular/common/http";
+if (!Parse.applicationId) {
+    Parse.initialize("ncloudmaster");
+    Parse.serverURL = (Parse.serverURL?.split("parse")?.[0] || "https://server.fmode.cn/") + "parse";
+}
+export class AuthService {
+    // set isModalShow(v){
+    //   this._isModalShow = v
+    //   this.setAc
+    // }
+    // get isModalShow(){
+    //   return this._isModalShow
+    // }
+    isGuardLock(url) {
+        let lock = true;
+        let user = Parse.User.current();
+        if (user?.id) { // 用户已登录不锁定
+            lock = false;
+        }
+        else { // 用户未登录且该页面需要守卫，则锁定
+            lock = this.guardMap[url];
+        }
+        // console.log(this.guardMap)
+        // console.log(lock)
+        return lock;
+    }
+    get loginTypeCount() {
+        return Object.values(this.loginOptions)?.filter(item => item)?.length;
+    }
+    get logoUrl() {
+        return localStorage.getItem("LOGO_URL") || this._logoUrl || "https://file.yuban.co/img/logo-feima.png";
+    }
+    set logoUrl(v) {
+        localStorage.setItem("LOGO_URL", v);
+        this._logoUrl = this._logoUrl;
+    }
+    getCompanyId() {
+        let company = localStorage.getItem("company");
+        company = this.company || company;
+        return company;
+    }
+    constructor(router, 
+    // private accServ:AccountService,
+    toastCtrl, novaCloud, http) {
+        this.router = router;
+        this.toastCtrl = toastCtrl;
+        this.novaCloud = novaCloud;
+        this.http = http;
+        this.guardMap = {};
+        this.isModalShow = false;
+        this.showBackHome = true;
+        //点击按钮切换对应表单
+        this.activeButton = "账号密码"; // 默认为短信验证按钮选中
+        this.loginOptions = {
+            userpwd: true, // 帐号+密码
+            mobilepwd: true, // 手机号+密码
+            mobilecode: true, // 手机+验证码
+            wechat: true // 微信扫码登录
+        };
+        /**
+         * 企业账套：登录用户校验所在的账套
+         */
+        this._logoUrl = "https://file.yuban.co/img/logo-feima.png";
+        this.wechatUrl = "https://file-cloud.fmode.cn/E4KpGvTEto/20230822/hv1tsm115258608.jpg";
+        /**
+         * 登录状态：默认false，登陆后为true
+         * @description
+         * 用于守卫弹窗锁定模块校验
+         */
+        this.isLoggedIn = false;
+        this.LoginPage = '/pcuser/login';
+        // 根据手机号获得帐套内用户名
+        this.mobileUserMap = {};
+        this.enabledLocalCode = false; // 开启验证码
+    }
+    async toast(options) {
+        options.position = options?.position || "top";
+        options.duration = options?.duration || 1500;
+        options.color = options?.color || "primary";
+        let toast = await this.toastCtrl.create(options);
+        toast.present();
+    }
+    init(options) {
+        this.company = options.company;
+        this.guardType = options.guardType;
+        this.saveParamsInvite();
+    }
+    checkLoginLock() {
+        let user = Parse.User.current();
+        if (user?.id) {
+            return true;
+        }
+        else {
+            this.isModalShow = true;
+            this.isLoggedIn = false;
+            return false;
+        }
+    }
+    checkLogin(url) {
+        // 将url记录在被守卫页列表中，便于后续检测弹窗锁定
+        this.guardMap[url] = true;
+        // 如果已登录，验证为true无需锁定 跳出该函数
+        let currentUser = Parse.User.current();
+        console.log("currentUser", currentUser);
+        if (currentUser && currentUser.id) {
+            // this.setCurrentUserLocalStorage(currentUser)
+            this.setAccount(currentUser);
+            this.isLoggedIn = true;
+            return true;
+        }
+        // 如果未登录，判断进行两种守卫方式
+        if (!this.guardType || this.guardType == "page") { // 守卫方式1：页面跳转
+            // 否则重定向到login页面
+            // console.log(this.authService.isLoggedIn)
+            this.redirectUrl = url;
+            // console.log("请登录：",this.LoginPage)
+            this.router.navigate([this.LoginPage]);
+            return false;
+        }
+        if (this.guardType == "modal") { // 守卫方式2：弹窗锁定
+            // console.log("触发 守卫方式2：弹窗锁定")
+            this.isModalShow = true;
+            this.isLoggedIn = false;
+            return true;
+        }
+    }
+    async setAccount(user) {
+        if (this.account?.id)
+            return;
+        let Account = Parse.Object.extend("Account");
+        // this.account = await this.accServ.getUserAccount(user);
+        let company = user?.get("company") || { __type: "Pointer", className: "Company", objectId: this.getCompanyId() } || null;
+        let query = new Parse.Query("Account");
+        query.equalTo("user", user.toPointer());
+        let account = await query.first();
+        if (!account?.id) {
+            account = new Account();
+            account.set({
+                user: user.toPointer(),
+                company: company,
+            });
+            account = await account.save();
+        }
+        this.account = account;
+        return account;
+    }
+    login(username, password) {
+        return new Promise((resolve, reject) => {
+            Parse.User.logIn(username, password).then(async (data) => {
+                // 检测邀请逻辑
+                this.bindInvite(data);
+                // 根据当前用户，设置帐套信息
+                this.setCurrentUserLocalStorage(data);
+                // 如果是modal弹窗登录则刷新当前页
+                if (this.guardType == "modal") {
+                    await this.refreshPage();
+                    resolve(true);
+                    return;
+                }
+                // 如果直接进login页面，redirectUrl为undefined 导航至首页
+                let queryCom = new Parse.Query('Company');
+                queryCom.select('rootPage');
+                queryCom.equalTo('objectId', data?.get('company')?.id);
+                let com = await queryCom.first();
+                let rootPage = com?.get("rootPage");
+                this.redirectUrl = this.redirectUrl || rootPage || "/project/dashboard";
+                let url = this.redirectUrl;
+                url = decodeURIComponent(url);
+                this.router.navigate([url]);
+            }).catch(err => {
+                console.error(err);
+                reject({ message: "无此用户信息，请先在小程序登录" });
+            });
+        });
+    }
+    refreshPage() {
+        return new Promise(resolve => {
+            let currentUrl = this.router.url;
+            // location.reload(); // 页面强制刷新
+            // resolve(true)
+            if (Parse.User.current()?.id) {
+                this.isModalShow = false;
+            }
+            ;
+            // NG路由重载
+            this.router.navigateByUrl('/', { skipLocationChange: true }).then(() => {
+                this.router.navigateByUrl(currentUrl).then(() => {
+                    resolve(true);
+                });
+            });
+        });
+    }
+    // 用户登录后，更新帐套信息至本地存储
+    setCurrentUserLocalStorage(user) {
+        if (user.get("company")?.id) {
+            localStorage.setItem("company", user.get("company")?.id);
+        }
+    }
+    logout(type, url) {
+        let company = localStorage.getItem("company");
+        let WECHAT_APP_ID = localStorage.getItem("WECHAT_APP_ID");
+        let LOGO_URL = localStorage.getItem("LOGO_URL");
+        let NOVA_APIG_SERVER = localStorage.getItem("NOVA_APIG_SERVER");
+        localStorage.clear();
+        localStorage.setItem('company', company);
+        localStorage.setItem('WECHAT_APP_ID', WECHAT_APP_ID);
+        localStorage.setItem('LOGO_URL', LOGO_URL);
+        localStorage.setItem('NOVA_APIG_SERVER', NOVA_APIG_SERVER);
+        Parse.User.logOut().then(user => {
+        });
+        this.router.navigate([url || "/pcuser/login"]);
+    }
     /**
-     * @copyright © 未来飞马 © 未来全栈 www.fmode.cn 
-     * 版权所有 © 未来飞马 © 江西脑控科技有限公司 Copyright © Fmode Technology Co., Ltd.
-     * 保留所有权利 All Rights Reserved.
-     * /home/ryan/workspace/nova/nova-admin/dist/fmode-ng/esm2022/lib/user/login/auth.service.mjs
+     * 根据帐套内mobile字段登录逻辑
      */
-    import{Injectable}from"@angular/core";import Parse from"parse";import{Router}from"@angular/router";import{NovaCloudService}from"../../nova-cloud";import{HttpClient}from"@angular/common/http";import{catchError}from"rxjs/operators";import*as i0 from"@angular/core";import*as i1 from"@angular/router";import*as i2 from"../../nova-cloud";import*as i3 from"@angular/common/http";Parse.applicationId||(Parse.initialize("ncloudmaster"),Parse.serverURL=(Parse.serverURL?.split("parse")?.[0]||"https://server.fmode.cn/")+"parse");export class AuthService{isGuardLock(e){let t=!0,r=Parse.User.current();return t=!r?.id&&this.guardMap[e],t}get logoUrl(){return localStorage.getItem("LOGO_URL")||this._logoUrl||"https://file.yuban.co/img/logo-feima.png"}set logoUrl(e){localStorage.setItem("LOGO_URL",e),this._logoUrl=this._logoUrl}getCompanyId(){let e=localStorage.getItem("company");return e=this.company||e,e}constructor(e,t,r){this.router=e,this.novaCloud=t,this.http=r,this.guardMap={},this.isModalShow=!1,this._logoUrl="https://file.yuban.co/img/logo-feima.png",this.wechatUrl="https://file-cloud.fmode.cn/E4KpGvTEto/20230822/hv1tsm115258608.jpg",this.isLoggedIn=!1,this.LoginPage="/pcuser/login",this.mobileUserMap={}}init(e){this.company=e.company,this.guardType=e.guardType,this.saveParamsInvite()}checkLoginLock(){let e=Parse.User.current();return!!e?.id||(this.isModalShow=!0,this.isLoggedIn=!1,!1)}checkLogin(e){this.guardMap[e]=!0;let t=Parse.User.current();return console.log("currentUser",t),t&&t.id?(this.setAccount(t),this.isLoggedIn=!0,!0):this.guardType&&"page"!=this.guardType?"modal"==this.guardType?(this.isModalShow=!0,this.isLoggedIn=!1,!0):void 0:(this.redirectUrl=e,this.router.navigate([this.LoginPage]),!1)}async setAccount(e){if(this.account?.id)return;let t=Parse.Object.extend("Account"),r=e?.get("company")||{__type:"Pointer",className:"Company",objectId:this.getCompanyId()}||null,o=new Parse.Query("Account");o.equalTo("user",e.toPointer());let i=await o.first();return i?.id||(i=new t,i.set({user:e.toPointer(),company:r}),i=await i.save()),this.account=i,i}login(e,t){return new Promise(((r,o)=>{Parse.User.logIn(e,t).then((async e=>{if(this.bindInvite(e),this.setCurrentUserLocalStorage(e),"modal"==this.guardType)return await this.refreshPage(),void r(!0);let t=new Parse.Query("Company");t.select("rootPage"),t.equalTo("objectId",e?.get("company")?.id);let o=await t.first(),i=o?.get("rootPage");this.redirectUrl=this.redirectUrl||i||"/project/dashboard";let a=this.redirectUrl;a=decodeURIComponent(a),this.router.navigate([a])})).catch((e=>{console.error(e),o({message:"无此用户信息，请先在小程序登录"})}))}))}refreshPage(){return new Promise((e=>{let t=this.router.url;Parse.User.current()?.id&&(this.isModalShow=!1),this.router.navigateByUrl("/",{skipLocationChange:!0}).then((()=>{this.router.navigateByUrl(t).then((()=>{e(!0)}))}))}))}setCurrentUserLocalStorage(e){e.get("company")?.id&&localStorage.setItem("company",e.get("company")?.id)}logout(e,t){let r=localStorage.getItem("company");localStorage.clear(),localStorage.setItem("company",r),Parse.User.logOut().then((e=>{this.router.navigate([t||"/pcuser/login"])}))}async loginMobilePassword(e,t,r){let o=await this.getMobileUser(e);o?this.login(o,t).then((async e=>{this.isModalShow=!1})).catch((e=>{console.log(e),r.create("error","错误的用户名或密码")})):r.create("error","用户不存在，请尝试其他登录方式")}signMobilePassword(e,t){return new Promise(((r,o)=>{Parse.User.signUp(this.getCompanyId()+"-"+e,t,"").then((async t=>{t.id&&(console.log(t),t.set("company",{__type:"Pointer",className:"Company",objectId:this.getCompanyId()}),t.set("mobile",e),t.set("type","user"),this.bindInvite(t),t=await t.save(),r(t))})).catch((e=>{o(e)}))}))}async getMobileUser(e){let t=this.getCompanyId(),r=t+e;if(this.mobileUserMap[r])return this.mobileUserMap[r];let o=await this.novaCloud.api("/auth/getusername",{company:t,mobile:e});return o?.username&&(this.mobileUserMap[r]=o?.username),this.mobileUserMap[r]}async loginCode(e,t,r){return new Promise(((o,i)=>{if(!t)return r?.create("error","请填写有效验证码"),void i();let a=Parse.serverURL?.split("parse")?.[0]||"https://server.fmode.cn/";this.http.get(a+`api/auth/mobile?company=${this.company}&mobile=${e}&code=${t}`,{}).pipe(catchError((async e=>{console.log(e),r?.create("error","登录失败："+e.error.mess),i()}))).subscribe((e=>{200==e.code?Parse.User.become(e.data.token).then((async e=>{if(console.log(e),e.id)return this.bindInvite(e),void o(!0);r?.create("error","登录失败"),i()})):(r?.create("error","登录失败"),i())}))}))}saveParamsInvite(){let e=this.novaCloud.searchParse();console.log("saveParamsInvite",e);let t=e?.invite;console.log(t),t&&localStorage.setItem("invite",e?.invite)}bindInvite(e){if(!(e=e||Parse.User.current()))return;if(e?.get("invite")?.id)return;let t=localStorage.getItem("invite");t&&this.novaCloud.api("/auth/invite",{current:e?.id,invite:t,type:"code"})}static{this.ɵfac=i0.ɵɵngDeclareFactory({minVersion:"12.0.0",version:"17.3.12",ngImport:i0,type:AuthService,deps:[{token:i1.Router},{token:i2.NovaCloudService},{token:i3.HttpClient}],target:i0.ɵɵFactoryTarget.Injectable})}static{this.ɵprov=i0.ɵɵngDeclareInjectable({minVersion:"12.0.0",version:"17.3.12",ngImport:i0,type:AuthService,providedIn:"root"})}}i0.ɵɵngDeclareClassMetadata({minVersion:"12.0.0",version:"17.3.12",ngImport:i0,type:AuthService,decorators:[{type:Injectable,args:[{providedIn:"root"}]}],ctorParameters:()=>[{type:i1.Router},{type:i2.NovaCloudService},{type:i3.HttpClient}]});
-var MODULE_PATH_NEED = `6K+l5paH5Lu25piv5pys6aG555uu55qE5LiA6YOo5YiGIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBDb21wb25lbnRzIGluIEZtb2RlIEluYy4KICAgIOeJiOadg+aJgOaciSDCqSDmnKrmnaXpo57pqawgwqkg5rGf6KW/6ISR5o6n56eR5oqA5pyJ6ZmQ5YWs5Y+4IENvcHlyaWdodCDCqSBGbW9kZSBUZWNobm9sb2d5IENvLiwgTHRkLgogICAg5L+d55WZ5omA5pyJ5p2D5YipIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgICDkuKXnpoHlnKjmnKrnu4/mjojmnYPnmoTmg4XlhrXkuIvvvIzpgJrov4fku7vkvZXlqpLku4vlpI3liLbmraTmlofku7YgVW5hdXRob3JpemVkIGNvcHlpbmcgb2YgdGhpcyBmaWxlLCB2aWEgYW55IG1lZGl1bSBpcyBzdHJpY3RseSBwcm9oaWJpdGVkCiAgICDor6Xmlofku7bmmK/kuJPmnInnmoTmnLrlr4bmlofku7YgUHJvcHJpZXRhcnkgYW5kIGNvbmZpZGVudGlhbAogICAKICAgIENvcHlyaWdodCAyMDIxLW5vdyBGbW9kZSBJbmMuIHN1cHBvcnRAZm1vZGUuY24uIDE4NjA3MDA3MDczLgogICAg5L+d55WZ5omA5pyJ5p2D5YipIEFsbCByaWdodHMgcmVzZXJ2ZWQuCgogICAgUEFUSDovaG9tZS9yeWFuL3dvcmtzcGFjZS9ub3ZhL25vdmEtYWRtaW4vZGlzdC9mbW9kZS1uZy9lc20yMDIyL2xpYi91c2VyL2xvZ2luL2F1dGguc2VydmljZS5tanM=`
-    
+    // 手机号+密码登录
+    async loginMobilePassword(mobile, password, msgServ) {
+        let username = await this.getMobileUser(mobile);
+        if (!username) {
+            msgServ.create("error", "用户不存在，请尝试其他登录方式");
+            return;
+        }
+        this.login(username, password)
+            .then(async (data) => {
+            this.isModalShow = false;
+        }).catch(err => {
+            console.log(err);
+            msgServ.create("error", "错误的用户名或密码");
+        });
+    }
+    signMobilePassword(mobile, password) {
+        return new Promise(async (resolve, reject) => {
+            let signedUser = await this.signUpAndUpdate(mobile, password);
+            resolve(signedUser);
+        });
+    }
+    async getMobileUser(mobile) {
+        let company = this.getCompanyId();
+        let userMID = company + mobile;
+        if (this.mobileUserMap[userMID])
+            return this.mobileUserMap[userMID];
+        let result = await this.novaCloud.api("/auth/getusername", {
+            company: company,
+            mobile: mobile
+        });
+        if (result?.username) {
+            this.mobileUserMap[userMID] = result?.username;
+        }
+        return this.mobileUserMap[userMID];
+    }
+    signUpAndUpdate(mobile, password) {
+        password = password || mobile + "pwd666";
+        return new Promise(resolve => {
+            Parse.User.signUp(this.getCompanyId() + "-" + mobile, password, "").then(async (signedUser) => {
+                if (signedUser.id) {
+                    console.log(signedUser);
+                    signedUser.set("company", {
+                        __type: "Pointer",
+                        className: "Company",
+                        objectId: this.getCompanyId()
+                    });
+                    signedUser.set("mobile", mobile);
+                    signedUser.set("type", "user");
+                    this.bindInvite(signedUser);
+                    signedUser = await signedUser.save();
+                    resolve(signedUser);
+                }
+            }).catch(error => {
+                resolve(undefined);
+            });
+        });
+    }
+    async getMobileCodeToken(mobile, code) {
+        return new Promise((resolve, reject) => {
+            let host = Parse.serverURL?.split("parse")?.[0] || "https://server.fmode.cn/";
+            this.http.get(host + `api/auth/mobile?company=${this.company}&mobile=${mobile}&code=${code}`).toPromise().then(res => {
+                resolve(res);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+    /* 验证码登录 */
+    async loginCode(mobile, code, msgServ, closeCallBack) {
+        if (!code) {
+            this.toast({ color: "primary", message: "请填写有效验证码" });
+            return;
+        }
+        try {
+            let res = await this.getMobileCodeToken(mobile, code);
+            if (res?.code == 200) {
+                console.log(200, res);
+                let logUser = await Parse.User.become(res.data.token);
+                console.log(logUser, logUser?.id);
+                if (logUser?.id) {
+                    console.log(logUser, logUser?.id);
+                    // 检测邀请逻辑
+                    try {
+                        await this.bindInvite(logUser);
+                    }
+                    catch (errb) {
+                        console.error("bind err b", errb);
+                    }
+                    return true;
+                }
+            }
+        }
+        catch (e) {
+            console.log("error1", e);
+            if (e?.error?.mess?.indexOf("用户不存在") > -1) { // 自动注册
+                let signedUser = await this.signUpAndUpdate(mobile);
+                if (signedUser?.id) {
+                    return await this.loginCode(mobile, code);
+                }
+            }
+            else {
+                this.toast({ message: e?.error?.mess });
+                return;
+            }
+        }
+    }
+    saveParamsInvite() {
+        let searchParams = this.novaCloud.searchParse();
+        console.log("saveParamsInvite", searchParams);
+        let invite = searchParams?.invite;
+        console.log(invite);
+        if (invite)
+            localStorage.setItem("invite", searchParams?.invite);
+    }
+    async bindInvite(current) {
+        current = current || Parse.User.current();
+        if (!current)
+            return; // 当前用户必须存在
+        if (current?.get("invite")?.id)
+            return; // 当前用户无邀请关系
+        let invite = localStorage.getItem("invite");
+        if (!invite)
+            return; // 本地存储邀请码必须存在
+        if (current?.id == invite)
+            return; // 不能邀请自己
+        let res;
+        try {
+            res = await this.novaCloud.api("/auth/invite", {
+                current: current?.id,
+                invite: invite,
+                type: "code"
+            });
+            console.log("bind", res);
+        }
+        catch (err) {
+            console.error("bind err", err);
+        }
+        return;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [{ token: i1.Router }, { token: i2.ToastController }, { token: i3.NovaCloudService }, { token: i4.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.ToastController }, { type: i3.NovaCloudService }, { type: i4.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../projects/fmode-ng/src/lib/user/login/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport Parse from \"parse\";\nif(!Parse.applicationId){\n  Parse.initialize(\"ncloudmaster\");\n  (Parse as any).serverURL = ((Parse as any).serverURL?.split(\"parse\")?.[0] || \"https://server.fmode.cn/\") + \"parse\";\n}\n\nimport { Router } from '@angular/router';\n// import { AccountService } from '../account/account.service';\nimport { NovaCloudService } from '../../nova-cloud';\nimport { HttpClient } from '@angular/common/http';\nimport { catchError } from \"rxjs/operators\";\nimport { ToastController } from '@ionic/angular/standalone';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AuthService {\n\n  /**\n   * 守卫方式：权限验证锁定方式\n   * @type \"page\"|\"modal\" page页面跳转 modal弹窗锁定\n   */\n  guardType:\"page\"|\"modal\"\n  guardMap:any = {}\n\n  isModalShow:boolean = false\n  // set isModalShow(v){\n  //   this._isModalShow = v\n  //   this.setAc\n  // }\n  // get isModalShow(){\n  //   return this._isModalShow\n  // }\n  isGuardLock(url){\n    let lock = true\n    let user = Parse.User.current();\n    if(user?.id){ // 用户已登录不锁定\n      lock = false\n    }else{ // 用户未登录且该页面需要守卫，则锁定\n      lock = this.guardMap[url]\n    }\n    // console.log(this.guardMap)\n    // console.log(lock)\n    return lock\n  }\n\n  showBackHome:boolean = true;\n  //点击按钮切换对应表单\n  activeButton: string = \"账号密码\"; // 默认为短信验证按钮选中\n  loginOptions:{\n    userpwd?:boolean,\n    mobilepwd?:boolean,\n    mobilecode?:boolean,\n    wechat?:boolean,\n  } = {\n    userpwd:true, // 帐号+密码\n    mobilepwd:true, // 手机号+密码\n    mobilecode:true, // 手机+验证码\n    wechat:true // 微信扫码登录\n  }\n  get loginTypeCount(){\n    return Object.values(this.loginOptions)?.filter(item=>item)?.length\n  }\n\n  /**\n   * 企业账套：登录用户校验所在的账套\n   */\n  _logoUrl = \"https://file.yuban.co/img/logo-feima.png\"\n  get logoUrl(){\n    return localStorage.getItem(\"LOGO_URL\") || this._logoUrl || \"https://file.yuban.co/img/logo-feima.png\"\n  }\n  set logoUrl(v){\n    localStorage.setItem(\"LOGO_URL\",v)\n    this._logoUrl = this._logoUrl\n  }\n  company:string\n  getCompanyId(){\n    let company = localStorage.getItem(\"company\");\n    company = this.company || company\n    return company\n  }\n  \n  wechatUrl:string = \"https://file-cloud.fmode.cn/E4KpGvTEto/20230822/hv1tsm115258608.jpg\"\n\n  /**\n   * 资金账户：user自动创建唯一资金账户\n   */\n  account:Parse.Object\n\n  /**\n   * 登录状态：默认false，登陆后为true\n   * @description\n   * 用于守卫弹窗锁定模块校验\n   */\n  isLoggedIn = false;\n\n  // store the URL so we can redirect after logging in\n  redirectUrl: string;\n  constructor(public router: Router,\n    // private accServ:AccountService,\n    private toastCtrl:ToastController,\n    private novaCloud:NovaCloudService,private http: HttpClient,) {\n  }\n  async toast(options:any){\n    options.position = options?.position || \"top\"\n    options.duration = options?.duration || 1500\n    options.color = options?.color || \"primary\"\n    let toast = await this.toastCtrl.create(options)\n    toast.present()\n  }\n  init(options:{\n    company?:string\n    guardType?:\"page\"|\"modal\"\n    LoginPage?:string\n  }){\n    this.company = options.company;\n    this.guardType = options.guardType\n    this.saveParamsInvite()\n  }\n  checkLoginLock(){\n    let user = Parse.User.current();\n    if(user?.id){\n      return true\n    }else{\n      this.isModalShow = true;\n      this.isLoggedIn = false;\n      return false\n    }\n  }\n  LoginPage = '/pcuser/login'\n  checkLogin(url: string): boolean {\n\n    // 将url记录在被守卫页列表中，便于后续检测弹窗锁定\n    this.guardMap[url] = true;\n\n    // 如果已登录，验证为true无需锁定 跳出该函数\n    let currentUser = Parse.User.current();\n    \n    console.log(\"currentUser\",currentUser)\n    if (currentUser&&currentUser.id) { \n      // this.setCurrentUserLocalStorage(currentUser)\n      this.setAccount(currentUser);\n      this.isLoggedIn = true\n      return true; \n    }\n\n    // 如果未登录，判断进行两种守卫方式\n    if(!this.guardType || this.guardType==\"page\"){ // 守卫方式1：页面跳转\n      // 否则重定向到login页面\n      // console.log(this.authService.isLoggedIn)\n      this.redirectUrl = url;\n      // console.log(\"请登录：\",this.LoginPage)\n      this.router.navigate([this.LoginPage]);\n      return false\n    }\n    if(this.guardType==\"modal\"){ // 守卫方式2：弹窗锁定\n      // console.log(\"触发 守卫方式2：弹窗锁定\")\n      this.isModalShow = true;\n      this.isLoggedIn = false;\n      return true\n    }\n  }\n  async setAccount(user){\n    if(this.account?.id) return;\n    let Account = Parse.Object.extend(\"Account\")\n    // this.account = await this.accServ.getUserAccount(user);\n    let company = user?.get(\"company\") || {__type:\"Pointer\",className:\"Company\",objectId:this.getCompanyId()} || null\n    let query = new Parse.Query(\"Account\");\n    query.equalTo(\"user\",user.toPointer())\n    let account = await query.first();\n    if(!account?.id){\n      account = new Account();\n      account.set({\n        user:user.toPointer(),\n        company:company,\n      })\n      account = await account.save();\n    }\n    this.account = account\n    return account\n  }\n\n  login(username, password) {\n    return new Promise((resolve,reject)=>{\n      Parse.User.logIn(username, password).then( async data => {\n\n      // 检测邀请逻辑\n      this.bindInvite(data);\n\n      // 根据当前用户，设置帐套信息\n      this.setCurrentUserLocalStorage(data);\n      \n      // 如果是modal弹窗登录则刷新当前页\n      if(this.guardType==\"modal\"){\n        await this.refreshPage();\n        resolve(true)\n        return\n      }\n\n      // 如果直接进login页面，redirectUrl为undefined 导航至首页\n      let queryCom = new Parse.Query('Company')\n      queryCom.select('rootPage')\n      queryCom.equalTo('objectId',data?.get('company')?.id)\n      let com = await queryCom.first()\n        let rootPage = com?.get(\"rootPage\")\n         this.redirectUrl =  this.redirectUrl || rootPage || \"/project/dashboard\"\n       let url = this.redirectUrl;\n       url = decodeURIComponent(url);\n       this.router.navigate([url]);\n     }).catch(err => {\n       console.error(err)\n       reject({ message: \"无此用户信息，请先在小程序登录\" })\n    })\n   })\n }\n refreshPage() {\n  return new Promise(resolve=>{\n    let currentUrl = this.router.url;\n\n    // location.reload(); // 页面强制刷新\n    // resolve(true)\n    if(Parse.User.current()?.id){this.isModalShow=false};\n\n    // NG路由重载\n    this.router.navigateByUrl('/', { skipLocationChange: true }).then(() => {\n      this.router.navigateByUrl(currentUrl).then(()=>{\n        resolve(true)\n      })\n    });\n  })\n}\n\n // 用户登录后，更新帐套信息至本地存储\n setCurrentUserLocalStorage(user:Parse.User){\n  if(user.get(\"company\")?.id){\n    localStorage.setItem(\"company\",user.get(\"company\")?.id)\n  }\n }\n\n logout(type,url): void {\n    let company = localStorage.getItem(\"company\");\n    let WECHAT_APP_ID = localStorage.getItem(\"WECHAT_APP_ID\");\n    let LOGO_URL = localStorage.getItem(\"LOGO_URL\");\n    let NOVA_APIG_SERVER = localStorage.getItem(\"NOVA_APIG_SERVER\");\n    localStorage.clear();\n    localStorage.setItem('company',company);\n    localStorage.setItem('WECHAT_APP_ID',WECHAT_APP_ID);\n    localStorage.setItem('LOGO_URL',LOGO_URL);\n    localStorage.setItem('NOVA_APIG_SERVER',NOVA_APIG_SERVER);\n    \n    Parse.User.logOut().then(user=>{\n    });\n    this.router.navigate([url||\"/pcuser/login\"]);\n  }\n\n  /** \n   * 根据帐套内mobile字段登录逻辑\n   */\n  // 手机号+密码登录\n  async loginMobilePassword(mobile:string,password:string,msgServ){\n    let username = await this.getMobileUser(mobile)\n    if(!username){\n      msgServ.create(\"error\", \"用户不存在，请尝试其他登录方式\");\n      return\n    }\n    this.login(username, password)\n      .then(async data => {\n        this.isModalShow = false;\n      }).catch(err => {\n        console.log(err)\n        msgServ.create(\"error\", \"错误的用户名或密码\");\n      });\n  }\n  signMobilePassword(mobile:string,password:string):Promise<any>{\n    return new Promise(async (resolve,reject)=>{\n      let signedUser = await this.signUpAndUpdate(mobile,password);\n      resolve(signedUser)\n    })\n\n  }\n  // 根据手机号获得帐套内用户名\n  mobileUserMap = {}\n  async getMobileUser(mobile:string){\n    let company = this.getCompanyId()\n    let userMID = company+mobile\n    if(this.mobileUserMap[userMID]) return this.mobileUserMap[userMID]\n    let result:any = await this.novaCloud.api(\"/auth/getusername\",{\n      company:company,\n      mobile:mobile\n    })\n    if(result?.username){\n      this.mobileUserMap[userMID] = result?.username\n    }\n    return this.mobileUserMap[userMID]\n  }\n  enabledLocalCode:boolean = false; // 开启验证码\n\n  signUpAndUpdate(mobile,password?:string):Promise<Parse.Object|undefined>{\n    password = password || mobile+\"pwd666\"\n    return new Promise(resolve=>{\n      Parse.User.signUp(\n        this.getCompanyId()+\"-\" + mobile,\n          password,\n          \"\"\n        ).then(async signedUser=>{\n          if (signedUser.id) {\n            console.log(signedUser)\n            signedUser.set(\"company\", {\n              __type: \"Pointer\",\n              className: \"Company\",\n              objectId: this.getCompanyId()\n            });\n            signedUser.set(\"mobile\", mobile);\n            signedUser.set(\"type\",\"user\");\n            this.bindInvite(signedUser);\n            signedUser = await signedUser.save();\n            resolve(signedUser)\n          }\n        }).catch(error=>{\n          resolve(undefined)\n        })\n    })\n  }\n\n  async getMobileCodeToken(mobile,code):Promise<any>{\n    return new Promise((resolve,reject)=>{\n      let host = (Parse as any).serverURL?.split(\"parse\")?.[0] || \"https://server.fmode.cn/\"\n      this.http.get(host+`api/auth/mobile?company=${this.company}&mobile=${mobile}&code=${code}`).toPromise().then(res=>{\n        resolve(res);\n      }).catch(error=>{\n        reject(error);\n      })\n    })\n      \n  }\n\n  /* 验证码登录 */\n  async loginCode(mobile:string, code:string, msgServ?,closeCallBack?:any): Promise<Boolean> {\n      if (!code) {\n        this.toast({color:\"primary\",message:\"请填写有效验证码\"})\n        return;\n      }\n\n      try{\n        let res = await this.getMobileCodeToken(mobile,code);\n        if (res?.code == 200) {\n          console.log(200,res)\n\n          let logUser = await Parse.User.become(res.data.token);\n          console.log(logUser,logUser?.id)\n          if (logUser?.id) {\n            console.log(logUser,logUser?.id)\n            // 检测邀请逻辑\n            try{\n              await this.bindInvite(logUser);\n            }catch(errb){\n              console.error(\"bind err b\",errb)\n            }\n            return true;\n          }\n        }\n      }catch(e){\n        console.log(\"error1\",e);\n        if(e?.error?.mess?.indexOf(\"用户不存在\")>-1){ // 自动注册\n          let signedUser = await this.signUpAndUpdate(mobile);\n          if(signedUser?.id){\n            return await this.loginCode(mobile,code);\n          }\n        }else{\n          this.toast({message:e?.error?.mess})\n          return\n        }\n      }\n  }\n  saveParamsInvite(){\n    let searchParams = this.novaCloud.searchParse()\n    console.log(\"saveParamsInvite\",searchParams)\n    let invite = searchParams?.invite;\n    console.log(invite)\n    if(invite) localStorage.setItem(\"invite\",searchParams?.invite)\n  }\n  async bindInvite(current?:any){\n    current = current || Parse.User.current();\n    if(!current) return // 当前用户必须存在\n    if(current?.get(\"invite\")?.id) return // 当前用户无邀请关系\n    \n    let invite = localStorage.getItem(\"invite\") \n    if(!invite) return // 本地存储邀请码必须存在\n    if(current?.id == invite ) return // 不能邀请自己\n    let res \n    \n    try{\n      res = await this.novaCloud.api(\"/auth/invite\",{\n        current:current?.id,\n        invite:invite,\n        type:\"code\"\n      })\n      console.log(\"bind\",res)\n    }catch(err){\n      console.error(\"bind err\",err)\n    }\n    return\n\n  }\n}"]}