Calculation/app/controller/profile_controller.js

'use strict';

/**
 * 账号相关控制器
 *
 * @author CaiAoLin
 * @date 2018/1/26
 * @version
 */

const moment = require('moment');
const profileMenu = require('../../config/menu').profileMenu;
const smsTypeConst = require('../const/sms_type');
const qr = require('qr-image');
const path = require('path');
const sendToWormhole = require('stream-wormhole');
const loginWay = require('../const/setting').loginWay;

module.exports = app => {

    class ProfileController extends app.BaseController {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局context
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            ctx.subMenu = profileMenu;
        }
        /**
         * 账号资料页面
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async info(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });

            // 获取基础数据的字段规则
            const baseRule = ctx.service.projectAccount.rule('profileBase');
            const baseJsValidator = await this.jsValidator.convert(baseRule).setSelector('#base-form').build();

            const renderData = {
                accountData,
                baseJsValidator,
            };
            await this.layout('profile/info.ejs', renderData);
        }

        /**
         * 保存基本信息
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async saveBase(ctx) {
            try {
                // 获取当前用户数据
                const sessionUser = ctx.session.sessionUser;

                // 获取基础数据的字段规则
                const baseRule = ctx.service.projectAccount.rule('profileBase');
                ctx.helper.validate(baseRule);

                const result = await ctx.service.projectAccount.saveInfo(ctx.request.body, sessionUser.accountId);
                if (!result) {
                    throw '保存信息失败';
                }

                this.setMessage('修改成功', this.messageType.SUCCESS);
            } catch (error) {
                this.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
            }

            ctx.redirect(ctx.request.header.referer);
        }

        /**
         * 修改密码操作
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async modifyPassword(ctx) {
            const password = ctx.request.body.password;
            const newPassword = ctx.request.body.new_password;

            try {
                const sessionUser = ctx.session.sessionUser;
                let accountId = sessionUser.accountId;
                accountId = parseInt(accountId);
                if (isNaN(accountId) || accountId <= 0) {
                    throw '参数错误';
                }
                // 验证数据
                const passwordRule = ctx.service.projectAccount.rule('modifyPassword');
                ctx.helper.validate(passwordRule);

                const result = await ctx.service.projectAccount.modifyPassword(accountId, password, newPassword);
                if (!result) {
                    throw '修改密码失败';
                }
                this.setMessage('修改密码成功', this.messageType.SUCCESS);
                ctx.redirect('/logout');
            } catch (error) {
                this.setMessage(error.toString(), this.messageType.ERROR);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 设置短信验证码
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async getCode(ctx) {
            const response = {
                err: 0,
                msg: '',
            };
            try {
                const sessionUser = ctx.session.sessionUser;
                const mobile = ctx.request.body.mobile;
                let type = null;
                if (ctx.request.body.type) {
                    type = ctx.request.body.type;
                    delete ctx.request.body.type;
                }
                const rule = { mobile: { type: 'mobile', allowEmpty: false } };
                ctx.helper.validate(rule);

                if (type === null || type !== 'shenpi') {
                    // 查找是否有重复的认证手机
                    const accountData = await ctx.service.projectAccount.getDataByCondition({ project_id: ctx.session.sessionProject.id, auth_mobile: mobile });
                    if (accountData !== null) {
                        throw '此手机号码已被使用，请重新输入！';
                    }
                }
                const result = await ctx.service.projectAccount.setSMSCode(sessionUser.accountId, mobile);
                if (!result) {
                    throw '获取验证码失败';
                }
            } catch (error) {
                response.err = 1;
                response.msg = error.toString();
            }

            ctx.body = response;
        }

        /**
         * 绑定认证手机
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async bindMobile(ctx) {
            const response = {
                err: 0,
                msg: '',
            };
            try {
                const rule = ctx.service.projectAccount.rule('bindMobile');
                ctx.helper.validate(rule);

                const sessionUser = ctx.session.sessionUser;

                const result = await ctx.service.projectAccount.bindMobile(sessionUser.accountId, ctx.request.body, ctx.session.sessionProject.id);

                if (!result) {
                    throw '绑定手机失败!';
                }
                // this.setMessage('绑定成功', this.messageType.SUCCESS);
                response.msg = '绑定成功';
                response.url = ctx.request.header.referer;
            } catch (error) {
                this.ctx.helper.log(error);
                response.err = 1;
                response.msg = error.toString();
            }
            ctx.body = response;
        }

        /**
         * 短信通知
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async sms(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });

            const renderData = {
                accountData,
                smsType: smsTypeConst.type,
            };
            await this.layout('profile/sms.ejs', renderData, 'profile/modal.ejs');
        }

        /**
         * 短信通知类型设置
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async smsType(ctx) {
            try {
                const sessionUser = ctx.session.sessionUser;
                const result = await ctx.service.projectAccount.noticeTypeSet(sessionUser.accountId, ctx.request.body);

                if (!result) {
                    throw '修改通知类型失败!';
                }
                this.setMessage('通知类型绑定成功', this.messageType.SUCCESS);
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
            }
            ctx.redirect(ctx.request.header.referer);
        }

        /**
         * 电子签名
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async sign(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });

            const renderData = {
                accountData,
                fujianOssPath: ctx.app.config.fujianOssPath,
            };
            await this.layout('profile/sign.ejs', renderData);
        }

        /**
         * 网证通电子签名页
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async netcasign(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });
            const signData = await ctx.service.netcasign.getDataByCondition({ uid: sessionUser.accountId });

            const renderData = {
                accountData,
                signData,
            };
            await this.layout('profile/netcasign.ejs', renderData, 'profile/sign_modal.ejs');
        }

        /**
         * 网证通电子签名页面操作
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async signSave(ctx) {
            const response = {
                err: 0,
                msg: '',
            };
            try {
                const sessionUser = ctx.session.sessionUser;
                const data = JSON.parse(ctx.request.body.data);
                let signData;
                switch (data.type) {
                    case 'bind':
                        signData = await ctx.service.netcasign.getDataByCondition({ pid: ctx.session.sessionProject.id, keyId: data.updateData.keyId });
                        if (signData) {
                            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: signData.uid });
                            throw '该Ukey已绑定于 ' + accountData.name + ', 不可重复绑定';
                        }

                        const result = await ctx.service.netcasign.add(data.updateData, sessionUser.accountId);
                        if (!result) {
                            throw '绑定Ukey失败';
                        }
                        response.data = await ctx.service.netcasign.getDataByCondition({ uid: sessionUser.accountId });
                        break;
                    case 'unbind':
                        signData = await ctx.service.netcasign.getDataByCondition({ pid: ctx.session.sessionProject.id, uid: sessionUser.accountId });
                        if (!signData) {
                            throw '当前用户不存在绑定证书，解除绑定失败';
                        }
                        await ctx.service.netcasign.del(signData.id);
                        break;
                    case 'savesign':
                        signData = await ctx.service.netcasign.getDataByCondition({ pid: ctx.session.sessionProject.id, uid: sessionUser.accountId });
                        if (!signData) {
                            throw '当前用户不存在绑定证书';
                        }
                        await ctx.service.netcasign.save({ sign_base64: data.sign_base64 }, signData.id);
                        break;
                    case 'delsign':
                        signData = await ctx.service.netcasign.getDataByCondition({ pid: ctx.session.sessionProject.id, uid: sessionUser.accountId });
                        if (!signData) {
                            throw '当前用户不存在绑定证书';
                        }
                        if (signData && !signData.sign_base64) {
                            throw '当前用户不存在签名，移除签名失败';
                        }
                        await ctx.service.netcasign.save({ sign_base64: null }, signData.id);
                        break;
                    default:throw '参数有误';
                }
            } catch (error) {
                response.err = 1;
                response.msg = error.toString();
            }

            ctx.body = response;
        }

        /**
         * 电子签名删除
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async signDelete(ctx) {
            const response = {
                err: 0,
                msg: '',
            };
            try {
                const sessionUser = ctx.session.sessionUser;

                // 获取账号数据
                const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });
                const data = JSON.parse(ctx.request.body.data);
                let result = false;
                if (data.type && data.type === 'stamp') {
                    if (!accountData.stamp_path) {
                        throw '不存在签章';
                    }
                    // 删除oss文件
                    await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + accountData.stamp_path);
                    // 删除库
                    result = await ctx.service.projectAccount.update({ stamp_path: null }, { id: sessionUser.accountId });
                } else {
                    if (accountData.sign_path === '') {
                        throw '不存在签名';
                    }
                    result = await ctx.service.projectAccount.update({ sign_path: '' }, { id: sessionUser.accountId });
                }
                if (!result) {
                    throw '移除签名失败';
                }
            } catch (error) {
                response.err = 1;
                response.msg = error.toString();
            }

            ctx.body = response;
        }

        /**
         * 生成二维码
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async qrCode(ctx) {
            const size = 5;
            const margin = 1;
            try {
                // 获取当前用户数据
                const sessionUser = ctx.session.sessionUser;

                let text = ctx.protocol + '://' + ctx.host + '/sign?user_id=' + sessionUser.accountId + '&app_token=' + sessionUser.sessionToken;
                if (ctx.query.from === 'netcasign') {
                    text += '&from=netcasign';
                }

                // 大小默认5，二维码周围间距默认1
                const img = qr.image(text || '', { type: 'png', size: size || 5, margin: margin || 1 });
                ctx.status = 200;
                ctx.type = 'image/png';
                ctx.body = img;
            } catch (e) {
                ctx.status = 414;
                ctx.set('Content-Type', 'text/html');
                ctx.body = '<h1>414 Request-URI Too Large</h1>';
            }
        }

        /**
         * 上传签名图
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async signUpload(ctx) {
            const responseData = {
                err: 0, msg: '', data: null,
            };
            try {
                const stream = await ctx.getFileStream();
                const create_time = Date.parse(new Date()) / 1000;
                const fileInfo = path.parse(stream.filename);
                if (stream.fields && stream.fields.type && stream.fields.type === 'stamp') {
                    // const dirName = 'app/public/upload/sign/profile';
                    // const fileName = moment().format('YYYYMMDD') + '_sign_' + create_time + fileInfo.ext;
                    const filepath = `app/public/upload/sign/profile/qianzhang_${create_time + fileInfo.ext}`;
                    await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                    await sendToWormhole(stream);
                    const result = await ctx.service.projectAccount.update({ stamp_path: filepath }, { id: ctx.session.sessionUser.accountId });
                    if (result) {
                        responseData.data = { stamp_path: filepath };
                    } else {
                        throw '添加数据库失败';
                    }
                } else {
                    const dirName = 'public/upload/sign';
                    const fileName = moment().format('YYYYMMDD') + '_sign_' + create_time + fileInfo.ext;
                    await ctx.helper.saveStreamFile(stream, path.join(this.app.baseDir, 'app', dirName, fileName));
                    await sendToWormhole(stream);
                    const result = await ctx.service.projectAccount.update({ sign_path: fileName }, { id: ctx.session.sessionUser.accountId });
                    if (result) {
                        responseData.data = { sign_path: fileName };
                    } else {
                        throw '添加数据库失败';
                    }
                }
            } catch (err) {
                this.log(err);
                responseData.err = 1;
                responseData.msg = err;
            }
            ctx.body = responseData;
        }

        /**
         * 账号安全
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async safe(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });

            // 获取修改密码的字段规则
            const passwordRule = ctx.service.projectAccount.rule('modifyPassword');
            const passwordJsValidator = await this.jsValidator.convert(passwordRule).setSelector('#password-form').build();

            // 获取登录日志
            const loginLogging = await ctx.service.loginLogging.getLoginLogs(ctx.session.sessionProject.id, ctx.session.sessionUser.accountId);
            const renderData = {
                accountData,
                passwordJsValidator,
                loginLogging,
                loginWay,
            };
            await this.layout('profile/safe.ejs', renderData);
        }

        /**
         * 微信通知
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async wechat(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });

            const renderData = {
                accountData,
                smsType: smsTypeConst.type,
            };
            await this.layout('profile/wechat.ejs', renderData, 'profile/wechat_modal.ejs');
        }

        /**
         * 微信解绑
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async removeWechat(ctx) {
            try {
                const sessionUser = ctx.session.sessionUser;
                // 获取账号数据
                const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });
                const result = await ctx.service.projectAccount.bindWx(sessionUser.accountId, null, null);

                if (!result) {
                    throw '解绑微信失败!';
                }
                // 解绑成功通知
                const templateId = '0w0Yp65X4PHccTLeAyE5aQhS-blS-bylwxAPYEGy3CI';
                const url = '';
                const msgData = {
                    first: {
                        value: '您好，纵横云计量与微信解绑成功。',
                    },
                    keyword1: {
                        value: ctx.session.sessionProject.code,
                    },
                    keyword2: {
                        value: sessionUser.account,
                    },
                    keyword3: {
                        value: moment(new Date()).format('YYYY-MM-DD'),
                    },
                    remark: {
                        value: '感谢您的使用，要接收通知请重新绑定。',
                    },
                };
                await app.wechat.api.sendTemplate(accountData.wx_openid, templateId, url, '', msgData);

                this.setMessage('微信解绑成功', this.messageType.SUCCESS);
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
            }
            ctx.redirect(ctx.request.header.referer);
        }
    }

    return ProfileController;
};