Calculation/app/controller/profile_controller.js

'use strict';

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

const profileMenu = require('../../config/menu').profileMenu;
const smsTypeConst = require('../const/sms_type');
const qr = require('qr-image');

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.save(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);
            } 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;
                const rule = { mobile: { type: 'mobile', allowEmpty: false } };
                ctx.helper.validate(rule);

                // 查找是否有重复的认证手机
                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) {
                console.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.smsTypeSet(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,
            };
            await this.layout('profile/sign.ejs', renderData);
        }

        /**
         * 电子签名删除
         *
         * @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 });

                if (accountData.sign_path === '') {
                    throw '不存在签名';
                }

                const 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;

                const text = 'http://' + ctx.request.header.host + '/sign?user_id=' + sessionUser.accountId + '&app_token=' + sessionUser.sessionToken;

                // 大小默认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 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 renderData = {
                accountData,
                passwordJsValidator,
            };
            await this.layout('profile/safe.ejs', renderData);
        }
    }

    return ProfileController;
};