学信H5 增加注册和找回密码

app/controller/findpwd.js

+'use strict';
+
+const Controller = require('egg').Controller;
+
+class TaskController extends Controller {
+    constructor(ctx) {
+        super(ctx);
+        this.createRule = {
+            orderId: 'string',
+        };
+
+        this.submitRule = {
+            phone: {type: 'string', format: /^1\d{10}$/, required: false},
+            ID: {type: 'string', format: /^\d{14}(\d{3})?[\dXx]$/, required: false},
+            email: {type: 'email', required: false},
+        };
+
+        this.fetchCaptureRule = {
+            type: {type: 'enum', values: ['code', 'phone_code']},
+        };
+
+        this.taskIdRule = {
+            taskId: {type: 'string', format: /\d+/},
+        };
+
+        this.cityConfigRule = {
+            sign: 'string',
+            params: {
+                type: 'object',
+                rule: {
+                    appKey: 'string',
+                    timestamp: 'string',
+                    token: 'string',
+                }
+            }
+        }
+    }
+
+    async getSetting() {
+        const {ctx, service} = this;
+        const loginParam = await service.findpwd.fetchLoginParam();
+        ctx.success({
+            loginParam
+        });
+    }
+
+    async create() {
+        const {ctx, service} = this;
+        ctx.validate(this.createRule);
+        const {orderId} = ctx.request.body;
+        const taskId = await service.findpwd.create();
+        await service.findpwdOrder.update({orderId, taskId});
+        await service.findpwdCache.set({
+            key: taskId,
+            value: {status: 'init', note: {message: 'init'}},
+        });
+        ctx.success({taskId});
+    }
+
+    async submit() {
+        const {ctx, service, config} = this;
+        ctx.validate(this.submitRule);
+        const {taskId} = ctx.params;
+        await service.findpwdCache.set({
+            key: taskId,
+            value: {status: 'init', note: {message: 'init'}},
+        });
+        await service.findpwd.submit({
+            taskId,
+            data: ctx.request.body,
+            callbackUrl: config.callbackUrl,
+        });
+        ctx.success({taskId});
+    }
+
+    async fetchCapture() {
+        const {ctx, service} = this;
+        ctx.validate(this.fetchCaptureRule);
+        const {taskId} = ctx.params;
+        const {type} = ctx.request.body;
+        const result = await service.findpwd.fetchCapture({
+            taskId,
+            type,
+        });
+        ctx.success(result);
+    }
+
+    async show() {
+        const {ctx, service} = this;
+        ctx.validate(this.taskIdRule, ctx.params);
+        const {taskId} = ctx.params;
+        const data = await service.findpwdCache.get({key: taskId});
+        ctx.success(data);
+    }
+
+    async handleCallback() {
+        const {ctx, service} = this;
+        const {taskId} = ctx.request.body;
+        const result = await service.findpwd.fetchTask({taskId});
+        ctx.success();
+        let taskNote = {
+            status: 'init',
+            note: {message: 'init'},
+        };
+        switch (result.code) {
+            case -1:
+            case 106:
+            case 102:
+            case 204:
+                taskNote = {
+                    status: 'failure',
+                    note: {message: result.msg},
+                };
+                break;
+            case 1:
+                if (result.data.data) {
+                    result.data = {
+                        data: JSON.parse(JSON.parse(result.data.data).post_data.strForNextStep),
+                        loginParam: result.data.loginParam
+                    }
+                }
+                taskNote = {
+                    status: 'next',
+                    note: {message: 'waiting', nextStep: result.data.loginParam},
+                };
+                break;
+            case 110:
+                taskNote = {
+                    status: 'query',
+                    note: {message: 'login success'},
+                };
+                break;
+            case 0:
+                taskNote = {
+                    status: 'success',
+                    note: {message: 'task success'},
+                };
+                try {
+                    const order = await service.findpwdOrder.getOneByTaskId(taskId);
+                    if (!order) {
+                        throw new Error('任务已经结束了');
+                    }
+                    const {orderId} = order;
+                    result.data = JSON.parse(result.data.data);
+                    result.orderId = orderId;
+                    delete result.code;
+                    delete result.msg;
+                    await service.storage.write(result);
+                    await service.partner.notice(order);
+                } catch (err) {
+                    ctx.logger.error('handleCallback', err, JSON.stringify(result));
+                    taskNote = {
+                        status: 'failure',
+                        note: {message: err.message},
+                    };
+                }
+                break;
+            default:
+                ctx.logger.warn('handleCallback', JSON.stringify(result));
+                break;
+        }
+        await service.findpwdCache.set({
+            key: taskId,
+            value: taskNote,
+        });
+    }
+}
+
+module.exports = TaskController;

app/controller/register.js

+'use strict';
+
+const Controller = require('egg').Controller;
+
+class TaskController extends Controller {
+    constructor(ctx) {
+        super(ctx);
+        this.createRule = {
+            orderId: 'string',
+        };
+
+        this.submitRule = {
+            phone: {type: 'string', format: /^1\d{10}$/, required: false},
+            ID: {type: 'string', format: /^\d{14}(\d{3})?[\dXx]$/, required: false},
+            email: {type: 'email', required: false},
+        };
+
+        this.fetchCaptureRule = {
+            type: {type: 'enum', values: ['code', 'phone_code']},
+        };
+
+        this.taskIdRule = {
+            taskId: {type: 'string', format: /\d+/},
+        };
+
+        this.cityConfigRule = {
+            sign: 'string',
+            params: {
+                type: 'object',
+                rule: {
+                    appKey: 'string',
+                    timestamp: 'string',
+                    token: 'string',
+                }
+            }
+        }
+    }
+
+    async getSetting() {
+        const {ctx, service} = this;
+        const loginParam = await service.register.fetchLoginParam();
+        ctx.success({
+            loginParam
+        });
+    }
+
+    async create() {
+        const {ctx, service} = this;
+        ctx.validate(this.createRule);
+        const {orderId} = ctx.request.body;
+        const taskId = await service.register.create();
+        await service.registerOrder.update({orderId, taskId});
+        await service.registerCache.set({
+            key: taskId,
+            value: {status: 'init', note: {message: 'init'}},
+        });
+        ctx.success({taskId});
+    }
+
+    async submit() {
+        const {ctx, service, config} = this;
+        ctx.validate(this.submitRule);
+        const {taskId} = ctx.params;
+        await service.registerCache.set({
+            key: taskId,
+            value: {status: 'init', note: {message: 'init'}},
+        });
+        await service.register.submit({
+            taskId,
+            data: ctx.request.body,
+            callbackUrl: config.callbackUrl,
+        });
+        ctx.success({taskId});
+    }
+
+    async fetchCapture() {
+        const {ctx, service} = this;
+        ctx.validate(this.fetchCaptureRule);
+        const {taskId} = ctx.params;
+        const {type} = ctx.request.body;
+        const result = await service.register.fetchCapture({
+            taskId,
+            type,
+        });
+        ctx.success(result);
+    }
+
+    async show() {
+        const {ctx, service} = this;
+        ctx.validate(this.taskIdRule, ctx.params);
+        const {taskId} = ctx.params;
+        const data = await service.registerCache.get({key: taskId});
+        ctx.success(data);
+    }
+
+    async handleCallback() {
+        const {ctx, service} = this;
+        const {taskId} = ctx.request.body;
+        const result = await service.register.fetchTask({taskId});
+        ctx.success();
+        let taskNote = {
+            status: 'init',
+            note: {message: 'init'},
+        };
+        switch (result.code) {
+            case -1:
+            case 106:
+            case 102:
+            case 204:
+                taskNote = {
+                    status: 'failure',
+                    note: {message: result.msg},
+                };
+                break;
+            case 1:
+                if (result.data.data) {
+                    result.data = {
+                        data: JSON.parse(JSON.parse(result.data.data).post_data.strForNextStep),
+                        loginParam: result.data.loginParam
+                    }
+                }
+                taskNote = {
+                    status: 'next',
+                    note: {message: 'waiting', nextStep: result.data.loginParam},
+                };
+                break;
+            case 110:
+                taskNote = {
+                    status: 'query',
+                    note: {message: 'login success'},
+                };
+                break;
+            case 0:
+                taskNote = {
+                    status: 'success',
+                    note: {message: 'task success'},
+                };
+                try {
+                    const order = await service.registerOrder.getOneByTaskId(taskId);
+                    if (!order) {
+                        throw new Error('任务已经结束了');
+                    }
+                    const {orderId} = order;
+                    result.data = JSON.parse(result.data.data);
+                    result.orderId = orderId;
+                    delete result.code;
+                    delete result.msg;
+                    await service.storage.write(result);
+                    await service.partner.notice(order);
+                } catch (err) {
+                    ctx.logger.error('handleCallback', err, JSON.stringify(result));
+                    taskNote = {
+                        status: 'failure',
+                        note: {message: err.message},
+                    };
+                }
+                break;
+            default:
+                ctx.logger.warn('handleCallback', JSON.stringify(result));
+                break;
+        }
+        await service.registerCache.set({
+            key: taskId,
+            value: taskNote,
+        });
+    }
+}
+
+module.exports = TaskController;

app/controller/task.js

@@ -36,6 +36,14 @@ class TaskController extends Controller {
         }
     }
 
+    async getSetting() {
+        const {ctx, service} = this;
+        const loginParam = await service.task.fetchLoginParam();
+        ctx.success({
+            loginParam
+        });
+    }
+
     async create() {
         const {ctx, service} = this;
         ctx.validate(this.createRule);

app/model/findpwd.js

+'use strict';
+
+module.exports = app => {
+  const { DataTypes } = app.Sequelize;
+
+  const Findpwd = app.model.define('findpwd', {
+    id: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      autoIncrement: true,
+      primaryKey: true,
+      field: 'id',
+    },
+    orderId: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      defaultValue: '',
+      primaryKey: true,
+      field: 'orderId',
+    },
+    taskId: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      defaultValue: '',
+      field: 'taskId',
+    },
+    appkey: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'appKey',
+    },
+    status: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      defaultValue: '',
+      field: 'status',
+    },
+    note: {
+      type: DataTypes.STRING(8000),
+      allowNull: true,
+      defaultValue: '',
+      field: 'note',
+      get() {
+        const note = this.getDataValue('note');
+        if (note) {
+          try {
+            return JSON.parse(note);
+          } catch (error) {
+            return {};
+          }
+        }
+        return {};
+      },
+      set(val) {
+        this.setDataValue('note', JSON.stringify(val));
+      },
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: app.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'createDate',
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: app.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updateDate',
+    },
+    text1: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      defaultValue: '',
+      field: 'text1',
+    },
+    text2: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      defaultValue: '',
+      field: 'text2',
+    },
+    text3: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      defaultValue: '',
+      field: 'text3',
+    },
+  }, {
+    tableName: 'xuexin_findpwd_status',
+    // timestamps: false,
+  });
+
+  return Findpwd;
+};

app/router.js

@@ -6,24 +6,37 @@
 module.exports = app => {
   const { router, controller } = app;
 
-  const itRouter = router.namespace(app.config.projectRootPath);
-  itRouter.post('/tasks', controller.task.create); // 创建任务
-  itRouter.get('/tasks/:taskId', controller.task.show); // 获取任务状态
-  itRouter.post('/tasks/:taskId/submit', controller.task.submit); // 提交任务参数
-  // itRouter.post('/tasks/:taskId/capture', controller.task.fetchCapture); // 获取验证码
-
-  itRouter.post('/callback', controller.task.handleCallback); // 处理回调结果，不对外
-
-  itRouter.get('/theme/:appKey', controller.partner.show);// 配置主题
-  itRouter.get('/agreements/:id', controller.partner.fetchAgreements);//查询协议
-
-  itRouter.post('/tokens', controller.token.create); // 创建token
-  itRouter.post('/orders', controller.order.create); // 创建订单号
-
-  itRouter.post('/getToken', controller.token.partnerToken);     // 合作方获取token
-  itRouter.post('/getorderSn', controller.order.partnerOrder);   // 合作方获取orderSn
-
-  itRouter.post('/getData', controller.order.partnerData);       // 合作方拉数据
-
-  itRouter.get('/orderData/:appKey/:orderId', controller.order.orderShow);//获取展示页面数据
+  const chsiRouter = router.namespace(app.config.projectRootPath);
+  chsiRouter.get('/loginScripts', controller.task.getSetting); // 获取学信登录参数
+  chsiRouter.post('/tasks', controller.task.create); // 创建任务
+  chsiRouter.get('/tasks/:taskId', controller.task.show); // 获取任务状态
+  chsiRouter.post('/tasks/:taskId/submit', controller.task.submit); // 提交任务参数
+  // chsiRouter.post('/tasks/:taskId/capture', controller.task.fetchCapture); // 获取验证码
+  
+  chsiRouter.post('/callback', controller.task.handleCallback); // 处理回调结果，不对外
+
+  chsiRouter.get('/registerScripts', controller.register.getSetting); // 获取注册登录参数
+  chsiRouter.post('/registerTasks', controller.register.create); // 注册-创建任务
+  chsiRouter.get('/registerTasks/:taskId', controller.register.show); // 注册-获取任务状态
+  chsiRouter.post('/registerTasks/:taskId/submit', controller.register.submit); // 注册-提交任务参数
+// chsiRouter.post('/registerTasks/:taskId/capture', controller.register.fetchCapture); // 注册-获取验证码
+
+  chsiRouter.get('/findPwdScripts', controller.findpwd.getSetting); // 找回密码-获取登录参数
+  chsiRouter.post('/findPwdTasks', controller.findpwd.create); // 找回密码-创建任务
+  chsiRouter.get('/findPwdTasks/:taskId', controller.findpwd.show); // 找回密码-获取任务状态
+  chsiRouter.post('/findPwdTasks/:taskId/submit', controller.findpwd.submit); // 找回密码-提交任务参数
+// chsiRouter.post('/findPwdTasks/:taskId/capture', controller.findpwd.fetchCapture); // 找回密码-获取验证码
+
+  chsiRouter.get('/theme/:appKey', controller.partner.show);// 配置主题
+  chsiRouter.get('/agreements/:id', controller.partner.fetchAgreements);//查询协议
+
+  chsiRouter.post('/tokens', controller.token.create); // 创建token
+  chsiRouter.post('/orders', controller.order.create); // 创建订单号
+
+  chsiRouter.post('/getToken', controller.token.partnerToken);     // 合作方获取token
+  chsiRouter.post('/getorderSn', controller.order.partnerOrder);   // 合作方获取orderSn
+
+  chsiRouter.post('/getData', controller.order.partnerData);       // 合作方拉数据
+
+  chsiRouter.get('/orderData/:appKey/:orderId', controller.order.orderShow);//获取展示页面数据
 };
\ No newline at end of file

app/service/findpwd.js

+'use strict';
+
+const Service = require('egg').Service;
+
+class TaskService extends Service {
+    constructor(ctx) {
+        super(ctx);
+        const {config} = this;
+        const {findpwdAPI, LOCK_KEY} = config;
+        this.baseURL = findpwdAPI.host;
+        this.loginParamUrl = findpwdAPI.loginParamUrl;
+        this.createTaskUrl = findpwdAPI.createTaskUrl;
+        this.submitTaskUrl = findpwdAPI.submitTaskUrl;
+        this.fetchCodeUrl = findpwdAPI.fetchCodeUrl;
+        this.fetchTaskUrl = findpwdAPI.fetchTaskUrl;
+        this.cityConfigUrl = findpwdAPI.cityConfigUrl;
+        this.LOCK_KEY = LOCK_KEY;
+    }
+
+
+    _request(url, opts) {
+        const {ctx, baseURL} = this;
+        opts = {
+            charset: 'utf-8',
+            timeout: ['30s', '30s'],
+            dataType: 'json',
+            contentType: 'json',
+            ...opts,
+        };
+        ctx.logger.info('_request', `${baseURL}${url}`);
+        return ctx.curl(`${baseURL}${url}`, opts);
+    }
+
+    _checkSuccess(result) {
+        if (result.status !== 200) {
+            const errorMsg = result.data && result.data.error_msg ? result.data.error_msg : 'unknown error';
+            this.ctx.throw(result.status, errorMsg);
+        }
+        if (result.data.code !== 0) {
+            this.ctx.throw(400, {message: result.data.msg, code: result.data.code});
+        }
+    }
+
+    async fetchLoginParam() {
+        const {loginParamUrl, ctx} = this;
+        const result = await this._request(loginParamUrl);
+        ctx.logger.info(`【Task】create ${loginParamUrl} result:`, JSON.stringify(result.data));
+        this._checkSuccess(result);
+        return result.data.data[0].citys[0].queryParam[0].loginParam;
+    }
+
+    async create() {
+        const {createTaskUrl, ctx} = this;
+        const result = await this._request(createTaskUrl, {
+            method: 'post',
+            data: { cityId: '1' },
+        });
+        ctx.logger.info(`【Task】create ${createTaskUrl} result:`, JSON.stringify(result.data));
+        this._checkSuccess(result);
+        return result.data.data.taskId;
+    }
+
+    async fetchCapture({taskId, type}) {
+        const {fetchCodeUrl, ctx} = this;
+        const result = await this._request(fetchCodeUrl, {
+            method: 'post',
+            data: {
+                taskId,
+                type,
+            },
+        });
+        ctx.logger.info(`【Task】fetchCapture ${fetchCodeUrl} params`, JSON.stringify({
+            taskId,
+            type,
+        }), result.data.code);
+        this._checkSuccess(result);
+        return result.data.data;
+    }
+
+    async submit(data) {
+        const {submitTaskUrl, ctx} = this;
+        const result = await this._request(submitTaskUrl, {
+            method: 'post',
+            data,
+        });
+        ctx.logger.info(`【Task】submit ${submitTaskUrl} params`, JSON.stringify(data), JSON.stringify(result.data));
+        this._checkSuccess(result);
+        return result;
+    }
+
+    async fetchTask(data) {
+        const {fetchTaskUrl, ctx} = this;
+        const result = await this._request(fetchTaskUrl, {
+            method: 'post',
+            data,
+        });
+        ctx.logger.info(`【Task】fetchTask ${fetchTaskUrl} params`, JSON.stringify(data), JSON.stringify(result.data.code));
+        return result.data;
+    }
+}
+
+module.exports = TaskService;

app/service/findpwdCache.js

+'use strict';
+
+const Service = require('egg').Service;
+
+
+class CacheService extends Service {
+  constructor(ctx) {
+    super(ctx);
+    const { config } = this;
+    const { registerTaskPrefix } = config.lockKeys;
+    this.registerTaskPrefix = registerTaskPrefix;
+  }
+
+  /**
+   * 将taskId状态缓存到redis和数据库
+   * @param {Object} key taskId
+   *   - value: 状态 提示信息 status 、note={}
+   *   - exprie: 过期时间
+   */
+  async set({ key, value = {}, exprie = 300 }) {
+    const { ctx, app, registerTaskPrefix } = this;
+
+    const data = await app.redis.get(registerTaskPrefix + key);
+    if (!data || (data && data.status !== 'success')) {
+      await app.redis.set(registerTaskPrefix + key, JSON.stringify(value), 'EX', exprie);
+    }
+
+    const order = await ctx.model.Findpwd.findOne({
+      where: { taskId: key },
+    });
+    if (order && order.status !== 'success') {
+      await order.update({ ...value });
+    } else {
+      ctx.logger.error('【findpwdCache】set no order or already success', key);
+    }
+    ctx.logger.info(`【findpwdCache】set ${key} value:`, JSON.stringify(value));
+  }
+
+  /**
+   * 获取task状态 优先redis
+   * @param {Object} key taskId
+   * @return {Object} status note
+   */
+
+  async get({ key }) {
+    const { ctx, app, registerTaskPrefix } = this;
+    const data = await app.redis.get(registerTaskPrefix + key);
+    if (data) {
+      ctx.logger.info(`【findpwdCache】get From redis ${key} data:`, data);
+      return JSON.parse(data);
+    }
+    const order = await ctx.model.Findpwd.findOne({
+      where: { taskId: key },
+    });
+    if (order) {
+      ctx.logger.info(`【findpwdCache】get From Model ${key} order:`, JSON.stringify({ status: order.status, note: order.note }));
+      return { status: order.status, note: order.note };
+    }
+    ctx.logger.error(`【findpwdCache】get No Result ${key} `);
+    this.ctx.throw(400, { message: 'no taskId' });
+  }
+}
+
+module.exports = CacheService;
\ No newline at end of file

app/service/findpwdOrder.js

+'use strict';
+
+const Service = require('egg').Service;
+
+class OrderService extends Service {
+  async getOneByOrderId(orderId) {
+    const { ctx } = this;
+    const order = await ctx.model.Findpwd.findOne({
+      where: { orderId },
+    });
+    return order;
+  }
+
+  async getOneByTaskId(taskId) {
+    const { ctx } = this;
+    const order = await ctx.model.Findpwd.findOne({
+      where: { taskId },
+    });
+    return order;
+  }
+
+  async create(params) {
+    const { ctx } = this;
+    const order = await ctx.model.Findpwd.findOne({
+      where: { orderId: params.orderId },
+    });
+    if (order) {
+      ctx.throw(400, { message: 'already have order' });
+    }
+    await ctx.model.Findpwd.create(params);
+    return order;
+  }
+
+  async update(params) {
+    const { ctx } = this;
+    const order = await ctx.model.Findpwd.findAll({
+      where: { orderId: params.orderId },
+      order: [['createDate', 'DESC']],
+    });
+    if (order.length === 0) {
+      ctx.throw(400, { message: 'no order' });
+      return;
+    }
+    for (const item of order) {
+      if (item.status === 'success') {
+        ctx.throw(400, { message: 'orderId success' });
+        return;
+      }
+    }
+    const { appKey, taskId, notifyUrl, backUrl, userId } = order[0];
+    if (taskId) {
+      await ctx.model.Findpwd.create({ appKey, status: 'init', notifyUrl, backUrl, userId, ...params })
+    } else {
+      await order[0].update(params);
+    }
+    return order[0];
+  }
+}
+
+module.exports = OrderService;

app/service/register.js

+'use strict';
+
+const Service = require('egg').Service;
+
+class TaskService extends Service {
+    constructor(ctx) {
+        super(ctx);
+        const {config} = this;
+        const {registerAPI, LOCK_KEY} = config;
+        this.baseURL = registerAPI.host;
+        this.loginParamUrl = registerAPI.loginParamUrl;
+        this.createTaskUrl = registerAPI.createTaskUrl;
+        this.submitTaskUrl = registerAPI.submitTaskUrl;
+        this.fetchCodeUrl = registerAPI.fetchCodeUrl;
+        this.fetchTaskUrl = registerAPI.fetchTaskUrl;
+        this.cityConfigUrl = registerAPI.cityConfigUrl;
+        this.LOCK_KEY = LOCK_KEY;
+    }
+
+
+    _request(url, opts) {
+        const {ctx, baseURL} = this;
+        opts = {
+            charset: 'utf-8',
+            timeout: ['30s', '30s'],
+            dataType: 'json',
+            contentType: 'json',
+            ...opts,
+        };
+        ctx.logger.info('_request', `${baseURL}${url}`);
+        return ctx.curl(`${baseURL}${url}`, opts);
+    }
+
+    _checkSuccess(result) {
+        if (result.status !== 200) {
+            const errorMsg = result.data && result.data.error_msg ? result.data.error_msg : 'unknown error';
+            this.ctx.throw(result.status, errorMsg);
+        }
+        if (result.data.code !== 0) {
+            this.ctx.throw(400, {message: result.data.msg, code: result.data.code});
+        }
+    }
+
+    async fetchLoginParam() {
+        const {loginParamUrl, ctx} = this;
+        const result = await this._request(loginParamUrl);
+        ctx.logger.info(`【Task】create ${loginParamUrl} result:`, JSON.stringify(result.data));
+        this._checkSuccess(result);
+        return result.data.data[0].citys[0].queryParam;
+    }
+
+    async create() {
+        const {createTaskUrl, ctx} = this;
+        const result = await this._request(createTaskUrl, {
+            method: 'post',
+            data: { cityId: '1' },
+        });
+        ctx.logger.info(`【Task】create ${createTaskUrl} result:`, JSON.stringify(result.data));
+        this._checkSuccess(result);
+        return result.data.data.taskId;
+    }
+
+    async fetchCapture({taskId, type}) {
+        const {fetchCodeUrl, ctx} = this;
+        const result = await this._request(fetchCodeUrl, {
+            method: 'post',
+            data: {
+                taskId,
+                type,
+            },
+        });
+        ctx.logger.info(`【Task】fetchCapture ${fetchCodeUrl} params`, JSON.stringify({
+            taskId,
+            type,
+        }), result.data.code);
+        this._checkSuccess(result);
+        return result.data.data;
+    }
+
+    async submit(data) {
+        const {submitTaskUrl, ctx} = this;
+        const result = await this._request(submitTaskUrl, {
+            method: 'post',
+            data,
+        });
+        ctx.logger.info(`【Task】submit ${submitTaskUrl} params`, JSON.stringify(data), JSON.stringify(result.data));
+        this._checkSuccess(result);
+        return result;
+    }
+
+    async fetchTask(data) {
+        const {fetchTaskUrl, ctx} = this;
+        const result = await this._request(fetchTaskUrl, {
+            method: 'post',
+            data,
+        });
+        ctx.logger.info(`【Task】fetchTask ${fetchTaskUrl} params`, JSON.stringify(data), JSON.stringify(result.data.code));
+        return result.data;
+    }
+}
+
+module.exports = TaskService;

app/service/registerCache.js

+'use strict';
+
+const Service = require('egg').Service;
+
+
+class CacheService extends Service {
+  constructor(ctx) {
+    super(ctx);
+    const { config } = this;
+    const { registerTaskPrefix } = config.lockKeys;
+    this.registerTaskPrefix = registerTaskPrefix;
+  }
+
+  /**
+   * 将taskId状态缓存到redis和数据库
+   * @param {Object} key taskId
+   *   - value: 状态 提示信息 status 、note={}
+   *   - exprie: 过期时间
+   */
+  async set({ key, value = {}, exprie = 300 }) {
+    const { ctx, app, registerTaskPrefix } = this;
+
+    const data = await app.redis.get(registerTaskPrefix + key);
+    if (!data || (data && data.status !== 'success')) {
+      await app.redis.set(registerTaskPrefix + key, JSON.stringify(value), 'EX', exprie);
+    }
+
+    const order = await ctx.model.Register.findOne({
+      where: { taskId: key },
+    });
+    if (order && order.status !== 'success') {
+      await order.update({ ...value });
+    } else {
+      ctx.logger.error('【registerCache】set no order or already success', key);
+    }
+    ctx.logger.info(`【registerCache】set ${key} value:`, JSON.stringify(value));
+  }
+
+  /**
+   * 获取task状态 优先redis
+   * @param {Object} key taskId
+   * @return {Object} status note
+   */
+
+  async get({ key }) {
+    const { ctx, app, registerTaskPrefix } = this;
+    const data = await app.redis.get(registerTaskPrefix + key);
+    if (data) {
+      ctx.logger.info(`【registerCache】get From redis ${key} data:`, data);
+      return JSON.parse(data);
+    }
+    const order = await ctx.model.Register.findOne({
+      where: { taskId: key },
+    });
+    if (order) {
+      ctx.logger.info(`【registerCache】get From Model ${key} order:`, JSON.stringify({ status: order.status, note: order.note }));
+      return { status: order.status, note: order.note };
+    }
+    ctx.logger.error(`【registerCache】get No Result ${key} `);
+    this.ctx.throw(400, { message: 'no taskId' });
+  }
+}
+
+module.exports = CacheService;
\ No newline at end of file

app/service/task.js

@@ -8,6 +8,7 @@ class TaskService extends Service {
         const {config} = this;
         const {taskAPI, LOCK_KEY} = config;
         this.baseURL = taskAPI.host;
+        this.loginParamUrl = taskAPI.loginParamUrl;
         this.createTaskUrl = taskAPI.createTaskUrl;
         this.submitTaskUrl = taskAPI.submitTaskUrl;
         this.fetchCodeUrl = taskAPI.fetchCodeUrl;
@@ -40,6 +41,20 @@ class TaskService extends Service {
         }
     }
 
+    async fetchLoginParam() {
+        const {loginParamUrl, ctx} = this;
+        const result = await this._request(loginParamUrl);
+        ctx.logger.info(`【Task】create ${loginParamUrl} result:`, JSON.stringify(result.data.code));
+        this._checkSuccess(result);
+        let loginParam;
+        for(let item of result.data.bankList){
+            if(item.id === 10003){
+                loginParam = item.queryParam[0].loginParam;
+            }
+        }
+        return loginParam;
+    }
+
     async create() {
         const {createTaskUrl, ctx} = this;
         const result = await this._request(createTaskUrl, {

config/config.local.js

@@ -17,12 +17,31 @@ module.exports = () => {
     
     config.taskAPI = {
         host: 'http://tm.51gjj.com:7815',
+        loginParamUrl: '/CreditCardServices/GetCcSetting',
         createTaskUrl: '/CreditCardServices/CreateCreditCardTask',
         fetchCodeUrl: '/CreditCardServices/QueryCreditCardCode',
         submitTaskUrl: '/CreditCardServices/QueryCreditCard',
         fetchTaskUrl: '/CreditCardServices/GetCcData'
     };
 
+    config.registerAPI = {
+        host: 'http://ts1.51gjj.com:18525',
+        loginParamUrl: '/xxregister/getSettings',
+        createTaskUrl: '/xxregister/createTask',
+        fetchCodeUrl: '/xxregister/getCode',
+        submitTaskUrl: '/xxregister/loginWeb',
+        fetchTaskUrl: '/xxregister/getData'
+    };
+
+    config.findpwdAPI = {
+        host: 'http://ts1.51gjj.com:18526',
+        loginParamUrl: '/xxfindpwd/getSettings',
+        createTaskUrl: '/xxfindpwd/createTask',
+        fetchCodeUrl: '/xxfindpwd/getCode',
+        submitTaskUrl: '/xxfindpwd/loginWeb',
+        fetchTaskUrl: '/xxfindpwd/getData'
+    };
+
     config.partnerAPI = {
         host: 'https://uat-nginx.jianbing.com/zeus-api/v1',
         fetchTheme: '/chaos/theme',
@@ -77,8 +96,10 @@ module.exports = () => {
         fecthHub: 'URANUS.XX.HUBS.LOCK',
         fecteToken: 'URANUS.XX.TOKEN.LOCK',
         token: 'URANUS.XX.TOKEN',
-        fecthParnters: 'URANUS.PARNTERS.LOCK',
-        taskPrefix: 'URANUS.TASK',
+        fecthParnters: 'URANUS.XX.PARNTERS.LOCK',
+        taskPrefix: 'URANUS.XX.TASK',
+        findpwdTaskPrefix: 'URANUS.XX.FINDPWD.TASK',
+        registerTaskPrefix: 'URANUS.XX.REGISTER.TASK'
     };
 
     config.sequelize = {
@@ -89,14 +110,14 @@ module.exports = () => {
             baseDir: 'model',
             dialect: 'mysql',
             host: 'rm-bp1272001633qc0x9o.mysql.rds.aliyuncs.com',
-            database: 'data_service_dev',
+            database: 'data_service_uat',
             username: 'hexin',
             password: 'gYUHszn9#q',
             port: 3306,
         }],
     };
 
-    config.callbackUrl = 'https://dev-nginx.jianbing.com/xuexin_h5/callback';
+    config.callbackUrl = 'https://uat-nginx.jianbing.com/xuexin_h5/callback';
 
     return config;
 };

config/config.prod.js

@@ -20,12 +20,31 @@ module.exports = () => {
   
   config.taskAPI = {
     host: process.env.TASKAPI_HOST,
+    loginParamUrl: '/CreditCardServices/GetCcSetting',
     createTaskUrl: '/CreditCardServices/CreateCreditCardTask',
     fetchCodeUrl: '/CreditCardServices/QueryCreditCardCode',
     submitTaskUrl: '/CreditCardServices/QueryCreditCard',
     fetchTaskUrl: '/CreditCardServices/GetCcData'
 };
 
+config.registerAPI = {
+  host: 'http://ts1.51gjj.com:18525',
+  loginParamUrl: '/xxregister/getSettings',
+  createTaskUrl: '/xxregister/createTask',
+  fetchCodeUrl: '/xxregister/getCode',
+  submitTaskUrl: '/xxregister/loginWeb',
+  fetchTaskUrl: '/xxregister/getData'
+};
+
+config.findpwdAPI = {
+  host: 'http://ts1.51gjj.com:18526',
+  loginParamUrl: '/xxfindpwd/getSettings',
+  createTaskUrl: '/xxfindpwd/createTask',
+  fetchCodeUrl: '/xxfindpwd/getCode',
+  submitTaskUrl: '/xxfindpwd/loginWeb',
+  fetchTaskUrl: '/xxfindpwd/getData'
+};
+
   config.partnerAPI = {
     host: process.env.PARTNERAPI_HOST,
     fetchTheme: '/chaos/theme',
@@ -81,8 +100,8 @@ module.exports = () => {
     fecthHub: 'URANUS.XX.HUBS.LOCK',
     fecteToken: 'URANUS.XX.TOKEN.LOCK',
     token: 'URANUS.XX.TOKEN',
-    fecthParnters: 'URANUS.PARNTERS.LOCK',
-    taskPrefix: 'URANUS.TASK',
+    fecthParnters: 'URANUS.XX.PARNTERS.LOCK',
+    taskPrefix: 'URANUS.XX.TASK',
   };
 
   config.sequelize = {