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;
const wxWork = require('../lib/wx_work');
const profileConst = require('../const/profile');

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 cert(ctx) {
            // 获取当前用户数据
            const sessionUser = ctx.session.sessionUser;

            // 获取账号数据
            const accountData = await ctx.service.projectAccount.getDataByCondition({ id: sessionUser.accountId });
            const certList = await ctx.service.accountCert.getAllDataByCondition({ where: { uid: sessionUser.accountId }, orders: [['create_time', 'desc']] });
            // json转换
            certList.forEach(item => {
                item.edu_json = item.edu_json ? JSON.parse(item.edu_json) : [];
            });
            const renderData = {
                accountData,
                certList,
                fujianOssPath: ctx.app.config.fujianOssPath,
                certRegConst: profileConst.cert.certReg,
                certQualConst: profileConst.cert.certQual,
                jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.profile.cert),
            };
            await this.layout('profile/cert.ejs', renderData, 'profile/cert_modal.ejs');
        }

        async certSave(ctx) {
            const response = {
                err: 0,
                msg: '',
                data: {},
            };
            try {
                const sessionUser = ctx.session.sessionUser;
                const data = JSON.parse(ctx.request.body.data);
                switch (data.type) {
                    case 'add_cert':
                        response.data = await ctx.service.accountCert.addCert(sessionUser.accountId);
                        break;
                    case 'update_cert':
                        response.data = await ctx.service.accountCert.updateCert(data.update_data);
                        break;
                    case 'add_jx':
                        response.data = await ctx.service.accountCert.addEduJson(data.id);
                        break;
                    case 'update_jx':
                        response.data = await ctx.service.accountCert.updateEduJson(data.update_data);
                        break;
                    case 'del_cert': // 包括删除附件
                        response.data = await ctx.service.accountCert.delCert(data.delete_data);
                        break;
                    default:throw '参数有误';
                }
            } catch (error) {
                response.err = 1;
                response.msg = error.toString();
            }
            ctx.body = response;
        }
        /**
         * 上传证书（单选）
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async certUpload(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);
                const id = stream.fields && stream.fields.id ? stream.fields.id : 0;
                if (!id) throw '参数有误';
                let jxid = '';
                let type = '';
                if (stream.fields && stream.fields.type === 'upload_jx') {
                    jxid = stream.fields.jxid ? stream.fields.jxid : '';
                    if (!jxid) throw '参数有误';
                    type = 'jx';
                } else if (stream.fields && stream.fields.type === 'upload_cert') {
                    type = 'cert';
                }
                if (!type) throw '参数有误';
                // 判断用户是否选择上传文件
                if (!stream.filename) {
                    throw '请选择上传的文件!';
                }
                const filename = stream.filename;
                const filepath = `app/public/upload/profile/${ctx.session.sessionUser.accountId}/cert/zhengshu_${create_time + fileInfo.ext}`;
                // await ctx.helper.saveStreamFile(stream, path.resolve(this.app.baseDir, filepath));
                await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                await sendToWormhole(stream);
                if (type === 'jx') {
                    const info = await ctx.service.accountCert.getDataById(id);
                    if (!info) throw '数据有误';
                    const edu_json = info.edu_json ? JSON.parse(info.edu_json) : [];
                    const jxInfo = edu_json.find(item => item.id === jxid);
                    if (!jxInfo) throw '数据有误';
                    jxInfo.file_path = filepath;
                    jxInfo.file_name = filename;
                    await ctx.service.accountCert.update({ edu_json: JSON.stringify(edu_json) }, { id });
                } else {
                    await ctx.service.accountCert.update({ file_path: filepath, file_name: filename }, { id });
                }
                responseData.data = { file_path: filepath, file_name: filename };
            } catch (err) {
                console.log(err);
                responseData.err = 1;
                responseData.msg = err;
            }
            ctx.body = responseData;
        }


        /**
         * 修改密码操作
         *
         * @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 reg = /^(?![0-9]+$)(?![a-zA-Z]+$).{6,16}$/;
                if (!reg.test(newPassword)) {
                    throw '请设置至少包含数字和字母的新密码';
                }

                const result = await ctx.service.projectAccount.modifyPassword(accountId, password, newPassword);
                if (!result) {
                    throw '修改密码失败';
                }
                this.setMessage('修改密码成功', this.messageType.SUCCESS);
                ctx.redirect('/logout');
            } catch (error) {
                ctx.session.postError = error.toString();
                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 '不存在签章';
                    }
                    const stamp_path_list = accountData.stamp_path.split('!;!');
                    const spIndex = ctx.helper._.indexOf(stamp_path_list, data.src);
                    if (spIndex === -1) {
                        throw '不存在此签章';
                    }
                    // 不删除地址，只删除数据库数据，防止已签章的报表丢失
                    // await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + stamp_path_list[spIndex]);
                    stamp_path_list.splice(spIndex, 1);
                    // 删除库
                    result = await ctx.service.projectAccount.update({ stamp_path: stamp_path_list.length === 0 ? null : stamp_path_list.join('!;!') }, { 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 stampUpload(ctx) {
            const responseData = {
                err: 0, msg: '', data: null,
            };
            let stream;
            try {
                const parts = ctx.multipart({ autoFields: true });
                const paths = [];
                let index = 0;
                stream = await parts();
                while (stream !== undefined) {
                    // 判断用户是否选择上传文件
                    if (!stream.filename) {
                        throw '请选择上传的文件!';
                    }
                    const fileInfo = path.parse(stream.filename);
                    const create_time = Date.parse(new Date()) / 1000;
                    const filepath = `app/public/upload/sign/profile/qianzhang_${create_time + index.toString() + fileInfo.ext}`;
                    // await ctx.helper.saveStreamFile(stream, path.resolve(this.app.baseDir, filepath));
                    await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                    if (stream) {
                        await sendToWormhole(stream);
                    }
                    paths.push(filepath);
                    ++index;
                    if (Array.isArray(parts.field.size) && index < parts.field.size.length) {
                        stream = await parts();
                    } else {
                        stream = undefined;
                    }
                }
                // 获取账号数据
                const accountData = await ctx.service.projectAccount.getDataByCondition({ id: ctx.session.sessionUser.accountId });
                const stamp_path = accountData.stamp_path ? accountData.stamp_path.split('!;!') : [];
                const stamp_path_list = ctx.helper._.concat(stamp_path, paths);
                const result = await ctx.service.projectAccount.update({ stamp_path: stamp_path_list.join('!;!') }, { id: ctx.session.sessionUser.accountId });
                if (result) {
                    responseData.data = { stamp_path: stamp_path_list };
                } else {
                    throw '添加数据库失败';
                }
            } catch (err) {
                this.log(err);
                // 失败需要消耗掉stream 以防卡死
                if (stream) {
                    await sendToWormhole(stream);
                }
                responseData.err = 1;
                responseData.msg = err.toString();
            }
            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();

            // console.log(passwordJsValidator);

            // 获取登录日志
            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 });
            if (accountData.qywx_user_info !== null) {
                accountData.qywx_user_info = JSON.parse(accountData.qywx_user_info);
            }

            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 });
                // 判断解绑类型
                if (ctx.request.body.data_type === 'wxWork') {
                    const result = await ctx.service.projectAccount.bindWx4Work(sessionUser.accountId, null, null, null);
                    if (!result) {
                        throw '解绑企业微信失败!';
                    }
                    // 解绑成功通知
                    const qywx = new wxWork(ctx);
                    const desc = '您好，纵横云计量与企业微信解绑成功。';
                    const content = [
                        {
                            keyname: '项目编号',
                            value: ctx.session.sessionProject.code,
                        },
                        {
                            keyname: '账号',
                            value: sessionUser.account,
                        },
                        {
                            keyname: '绑定时间',
                            value: moment(new Date()).format('YYYY-MM-DD'),
                        },
                        {
                            keyname: '备注',
                            value: '感谢您的使用，要接收通知请重新绑定。',
                        },
                    ];
                    const url = ctx.protocol + '://' + ctx.host + '/wx/tips?msg=解绑成功，感谢您的使用。';
                    await qywx.sendTemplateCard([accountData.qywx_userid], accountData.qywx_corpid, '账号解绑成功通知', desc, content, url);

                    this.setMessage('企业微信解绑成功', this.messageType.SUCCESS);
                } else {
                    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;
};