Skip to content

S
sb_h5
Commit 3a98abdf authored by 高诸锋's avatar 高诸锋
Browse files
Options

fix config

parent 4c7c2b83
Pipeline #3879 passed with stage
    in 9 minutes 56 seconds
    Show whitespace changes
    Inline Side-by-side
    Showing with 2107 additions and 0 deletions
    .autod.conf.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = {
    write: true,
    prefix: '^',
    plugin: 'autod-egg',
    test: [
    'test',
    'benchmark',
    ],
    dep: [
    'egg',
    'egg-scripts',
    ],
    devdep: [
    'egg-ci',
    'egg-bin',
    'egg-mock',
    'autod',
    'autod-egg',
    'eslint',
    'eslint-config-egg',
    'webstorm-disable-index',
    ],
    exclude: [
    './test/fixtures',
    './dist',
    ],
    };
    .eslintrc 0 → 100644
    View file @ 3a98abdf
    {
    "extends": [
    "eslint-config-egg"
    ],
    "parserOptions": {
    "ecmaFeatures": {
    "experimentalObjectRestSpread": true
    }
    },
    "rules": {
    "indent": ["error", 2],
    "array-bracket-spacing": ["error", "never"],
    "linebreak-style": "off"
    }
    }
    \ No newline at end of file
    .gitignore 0 → 100644
    View file @ 3a98abdf
    logs/
    npm-debug.log
    yarn-error.log
    node_modules/
    package-lock.json
    yarn.lock
    coverage/
    .idea/
    run/
    .DS_Store
    *.sw*
    *.un~
    .gitlab-ci.yml 0 → 100644
    View file @ 3a98abdf
    variables:
    DOCKER_REGISTRY: 't-docker.51gjj.com'
    before_script:
    - docker login -u pengtianzi -p 4dc8b3a4d91fa7fa $DOCKER_REGISTRY
    stages:
    - pre_deploy
    build_docker_image:
    stage: pre_deploy
    script:
    - export IMAGE_TAG=${CI_COMMIT_TAG:-latest}
    - docker build -t $DOCKER_REGISTRY/$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME:$IMAGE_TAG .
    - docker push $DOCKER_REGISTRY/$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME:$IMAGE_TAG
    tags:
    - docker-image-builder
    .travis.yml 0 → 100644
    View file @ 3a98abdf
    sudo: false
    language: node_js
    node_js:
    - '8'
    install:
    - npm i npminstall && npminstall
    script:
    - npm run ci
    after_script:
    - npminstall codecov && codecov
    .vscode/launch.json 0 → 100644
    View file @ 3a98abdf
    {
    // 使用 IntelliSense 了解相关属性。
    // 悬停以查看现有属性的描述。
    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
    {
    "type": "node",
    "request": "launch",
    "name": "Egg Debug",
    "runtimeExecutable": "npm",
    "runtimeArgs": [
    "run",
    "debug",
    "--",
    "--inspect-brk"
    ],
    "console": "integratedTerminal",
    "restart": true,
    "protocol": "auto",
    "port": 9229,
    "autoAttachChildProcesses": true
    },
    {
    "type": "node",
    "request": "launch",
    "name": "Egg Test",
    "runtimeExecutable": "npm",
    "runtimeArgs": [
    "run",
    "test-local",
    "--",
    "--inspect-brk"
    ],
    "protocol": "auto",
    "port": 9229,
    "autoAttachChildProcesses": true
    },
    {
    "type": "node",
    "request": "attach",
    "name": "Egg Attach to remote",
    "localRoot": "${workspaceRoot}",
    "remoteRoot": "/usr/src/app",
    "address": "localhost",
    "protocol": "auto",
    "port": 9999
    }
    ]
    }
    \ No newline at end of file
    Dockerfile 0 → 100644
    View file @ 3a98abdf
    FROM t-docker.51gjj.com/tools/node:8.12.0
    ENV LANG C.UTF-8
    ENV NODE_ENV production
    ENV PATH $PATH:/usr/local/node/bin/
    RUN mkdir -p /usr/src/app
    WORKDIR /usr/src/app
    COPY package.json /usr/src/app/
    RUN yarn config set registry "https://registry.npm.taobao.org/"
    RUN yarn install
    COPY . /usr/src/app
    EXPOSE 7001
    CMD [ "yarn", "docker" ]
    README.md 0 → 100644
    View file @ 3a98abdf
    # hf_h5_server
    公积金H5认证服务
    ## QuickStart
    <!-- add docs here for user -->
    see [egg docs][egg] for more detail.
    ### Development
    ```bash
    $ npm i
    $ npm run dev
    $ open http://localhost:7001/
    ```
    ### Deploy
    ```bash
    $ npm start
    $ npm stop
    ```
    ### npm scripts
    - Use `npm run lint` to check code style.
    - Use `npm test` to run unit test.
    - Use `npm run autod` to auto detect dependencies upgrade, see [autod](https://www.npmjs.com/package/autod) for more detail.
    [egg]: https://eggjs.org
    \ No newline at end of file
    README.zh-CN.md 0 → 100644
    View file @ 3a98abdf
    # hf_h5_server
    公积金H5认证服务
    ## 快速入门
    <!-- 在此次添加使用文档 -->
    如需进一步了解，参见 [egg 文档][egg]。
    ### 本地开发
    ```bash
    $ npm i
    $ npm run dev
    $ open http://localhost:7001/
    ```
    ### 部署
    ```bash
    $ npm start
    $ npm stop
    ```
    ### 单元测试
    - [egg-bin] 内置了 [mocha], [thunk-mocha], [power-assert], [istanbul] 等框架，让你可以专注于写单元测试，无需理会配套工具。
    - 断言库非常推荐使用 [power-assert]。
    - 具体参见 [egg 文档 - 单元测试](https://eggjs.org/zh-cn/core/unittest)。
    ### 内置指令
    - 使用 `npm run lint` 来做代码风格检查。
    - 使用 `npm test` 来执行单元测试。
    - 使用 `npm run autod` 来自动检测依赖更新，详细参见 [autod](https://www.npmjs.com/package/autod) 。
    [egg]: https://eggjs.org
    app/controller/order.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Controller = require('egg').Controller;
    class OrderController extends Controller {
    constructor(ctx) {
    super(ctx);
    this.createRule = {
    appKey: { type: 'string', required: true },
    userId: { type: 'string', required: true },
    notifyUrl: { type: 'string', required: false },
    };
    this.showRule = {
    sign: 'string',
    params: {
    type: 'object',
    rule: {
    token: 'string',
    orderSn: 'string',
    appKey: 'string',
    timestamp: 'string',
    },
    },
    };
    }
    async create() {
    const { ctx, service } = this;
    ctx.validate(this.createRule);
    // const { appKey } = ctx.request.body.params;
    const { appKey, userId, notifyUrl } = ctx.request.body;
    // const orderId = await service.signature.createOrderId(ctx.request.body);
    const orderId = await ctx.helper.getUuid();
    await service.order.create({
    orderId,
    taskId: '',
    userId,
    cityId: '',
    appkey: appKey,
    status: 'init',
    callbackUrl: notifyUrl,
    });
    ctx.success({ orderId });
    }
    async show() {
    const { ctx, service } = this;
    ctx.validate(this.showRule);
    const { orderId } = ctx.params;
    await service.signature.signatureCheck(ctx.request.body);
    const data = await service.order.getOneByOrderId(orderId);
    if (data) {
    if (data.status === 'success') {
    const result = await service.storage.read(orderId);
    ctx.success(result);
    return;
    }
    ctx.success({
    status: data.status,
    });
    return;
    }
    ctx.fail('无此订单号');
    }
    async fetchOrderId() {
    const { ctx, service } = this;
    const token = await service.signature.getToken();
    const signParams = ctx.helper.buildRequestBody({ token });
    const { appKey } = signParams.params;
    const orderId = await service.signature.createOrderId(signParams);
    await service.order.create({
    orderId,
    taskId: '',
    userId: '',
    cityId: '',
    appkey: appKey,
    status: 'init',
    });
    ctx.success({ orderId });
    }
    }
    module.exports = OrderController;
    app/controller/partner.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Controller = require('egg').Controller;
    class PartnerController extends Controller {
    // constructor(ctx) {
    // super(ctx);
    // }
    async show() {
    const { ctx, service } = this;
    const { appKey } = ctx.params;
    const ret = await service.partner.fetchTheme(appKey);
    if (ret && ret.id === appKey) {
    ctx.success(ret);
    return;
    }
    ctx.fail('尚未配置主题');
    }
    }
    module.exports = PartnerController;
    app/controller/script.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Controller = require('egg').Controller;
    class ScriptController extends Controller {
    async fetchScripts() {
    const { ctx, service } = this;
    const { appKey } = ctx.query;
    let limitScriptsList = false;
    if (appKey) {
    const ret = await service.partner.fetchScripts(appKey);
    limitScriptsList = ret.scripts;
    }
    let data = await service.scripts.fetchScripts();
    if (limitScriptsList) {
    data = data.filter(item => {
    return limitScriptsList.includes(item.id);
    });
    }
    ctx.success(data);
    }
    async fetchOneScripts() {
    const { ctx, service } = this;
    let { scriptId } = ctx.params;
    if (scriptId === 'auto') {
    const ret = await service.scripts.fetchScriptIdByIp();
    scriptId = ret.scriptId;
    }
    const data = await service.scripts.fetchOneScripts(scriptId);
    ctx.success(data);
    }
    async fetchParamsInfo() {
    const { ctx, service } = this;
    const { refresh = false } = ctx.query;
    const data = await service.scripts.fetchParams(refresh);
    ctx.success(data);
    }
    async fetchHelpInfo() {
    const { ctx, service } = this;
    const { scriptId } = ctx.params;
    const data = await service.scripts.fetchHelp(scriptId);
    ctx.success(data);
    }
    async fetchQueryButtonInfo() {
    const { ctx, service } = this;
    const { scriptId } = ctx.params;
    const data = await service.scripts.fetchQueryButton(scriptId);
    ctx.success(data);
    }
    async fetchNoticeInfo() {
    const { ctx, service } = this;
    const { scriptId } = ctx.params;
    const data = await service.scripts.fetchNotice(scriptId);
    ctx.success(data);
    }
    async fetchHubSeripts() {
    const { ctx, service } = this;
    let { hubId } = ctx.params;
    if (hubId === 'auto') {
    const ret = await service.scripts.fetchScriptIdByIp();
    hubId = ret.hubId;
    }
    const data = await service.scripts.fetchHubSeripts(hubId);
    ctx.success(data);
    }
    }
    module.exports = ScriptController;
    app/controller/task.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Controller = require('egg').Controller;
    class TaskController extends Controller {
    constructor(ctx) {
    super(ctx);
    this.createRule = {
    scriptId: { type: 'number', required: true },
    orderId: { type: 'string', required: true },
    };
    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+/ },
    };
    }
    async create() {
    const { ctx, service } = this;
    ctx.validate(this.createRule);
    const { scriptId, orderId } = ctx.request.body;
    const taskId = await service.task.create(scriptId);
    await service.order.update({ orderId, cityId: scriptId, taskId });
    await service.cache.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.task.submit({
    taskId,
    data: ctx.request.body,
    callbackUrl: config.callbackUrl,
    });
    await service.cache.set({
    key: taskId,
    value: { status: 'init', note: { message: 'init' } },
    });
    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.task.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.cache.get({ key: taskId });
    ctx.success(data);
    }
    async handleCallback() {
    const { ctx, service } = this;
    const { taskId } = ctx.request.body;
    const result = await service.task.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:
    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 insertData = await service.washData.wash(result);
    const order = await service.order.getOneByTaskId(taskId);
    if (!order) {
    throw new Error('任务已经结束了');
    }
    const { orderId, appkey } = order;
    insertData.orderId = orderId;
    insertData.cityName = insertData.location;
    insertData.taskId = taskId;
    insertData.appKey = appkey;
    delete insertData.code;
    await service.storage.write(insertData);
    } catch (err) {
    ctx.logger.error('handleCallback', err, result);
    taskNote = {
    status: 'failure',
    note: { message: err.message },
    };
    }
    break;
    default:
    ctx.logger.warn('handleCallback', result);
    break;
    }
    await service.cache.set({
    key: taskId,
    value: taskNote,
    });
    }
    }
    module.exports = TaskController;
    app/controller/token.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Controller = require('egg').Controller;
    class TokenController extends Controller {
    constructor(ctx) {
    super(ctx);
    this.createRule = {
    sign: 'string',
    params: {
    type: 'object',
    rule: {
    appKey: 'string',
    timestamp: 'string',
    },
    },
    };
    }
    async create() {
    const { ctx, service } = this;
    ctx.validate(this.createRule);
    const token = await service.signature.createToken(ctx.request.body);
    ctx.success({ data: token });
    }
    // 处理响应状态码的问题
    async createForPartner() {
    const { ctx, service } = this;
    try {
    ctx.validate(this.createRule);
    } catch (e) {
    ctx.body = { code: 101, msg: e.errors };
    return;
    }
    const token = await service.signature.createTokenForPartner(ctx.request.body);
    ctx.body = { code: 0, data: token };
    }
    }
    module.exports = TokenController;
    app/extend/application.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const REDIS_CACHE = Symbol('Context#RedisCache');
    const NODE_CACHE = Symbol('Context#NodeCache');
    const NodeCache = require('node-cache');
    const INCR_SCRIPT = 'return redis.call("INCR", ARGV[1])';
    class Cache {
    constructor(app) {
    this.app = app;
    this.name = 'unknown-cache';
    this.app.redis.defineCommand('INCR', {
    numberOfKeys: 0,
    lua: INCR_SCRIPT,
    });
    }
    async val(key, next, ttl) {
    let data = await this.get(key);
    if (data) {
    return data;
    }
    data = await next(key);
    await this.set(key, data, ttl);
    return data;
    }
    async get(key) {
    const startTime = +new Date();
    const ret = await this._get(key);
    let jsonText = JSON.stringify(ret);
    if (jsonText === undefined) {
    jsonText = 'undefined';
    } else if (jsonText.length >= 128) {
    if (/^\{/.test(jsonText)) {
    jsonText = '{...}';
    } else if (/^\[/.test(jsonText)) {
    jsonText = '[...]';
    } else {
    jsonText = jsonText.substr(0, 125) + '...';
    }
    }
    this.app.logger.info(`【Cache Get:】(${+new Date() - startTime}ms) ${this.name}.${key}: ${jsonText}`);
    return ret;
    }
    async set(key, value, ttl = 60) {
    const startTime = +new Date();
    await this._set(key, value, ttl);
    this.app.logger.info(`【Cache Set】(${+new Date() - startTime}ms) Key: ${key} value: ${JSON.stringify(value)}`);
    return;
    }
    }
    class RedisCacheWrap extends Cache {
    constructor(app, redis) {
    super(app);
    this.redis = redis;
    this.name = 'redis-cache';
    }
    async _get(key) {
    const { redis } = this;
    let value = await redis.get(key);
    if (value === null) {
    value = undefined;
    }
    if (value) {
    value = JSON.parse(value);
    }
    return value;
    }
    async _set(key, value, ttl) {
    const { redis } = this;
    value = JSON.stringify(value);
    if (ttl > 0) {
    await redis.set(key, value, 'EX', ttl);
    } else {
    await redis.set(key, value);
    }
    }
    }
    class NodeCacheWrap extends Cache {
    constructor(app) {
    super(app);
    this.cache = new NodeCache();
    this.name = 'node-cache';
    }
    async _get(key) {
    return this.cache.get(key);
    }
    async _set(key, value, ttl) {
    const { cache } = this;
    value = JSON.parse(JSON.stringify(value));
    if (ttl > 0) {
    cache.set(key, value, ttl);
    } else {
    cache.set(key, value);
    }
    }
    }
    module.exports = {
    get memcache() {
    if (!this[REDIS_CACHE]) {
    this[REDIS_CACHE] = new RedisCacheWrap(this, this.redis);
    }
    return this[REDIS_CACHE];
    },
    get cache() {
    if (!this[NODE_CACHE]) {
    this[NODE_CACHE] = new NodeCacheWrap(this);
    }
    return this[NODE_CACHE];
    },
    };
    app/extend/context.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = {
    success(data = false) {
    const method = this.request.method.toLowerCase();
    if (method === 'get') {
    this.status = 200;
    this.body = data || {};
    } else if (method === 'post') {
    this.status = 201;
    this.body = data || {};
    } else if (method === 'put' || method === 'delete') {
    this.status = data ? 200 : 204;
    this.body = data ? data : '';
    } else {
    this.status = 204;
    this.body = '';
    }
    },
    fail(error = '') {
    this.status = 400;
    this.body = {
    error,
    };
    },
    };
    app/extend/helper.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const querystring = require('querystring');
    const crypto = require('crypto');
    const uuid = require('uuid/v4');
    function process(params) {
    const keys = Object.keys(params)
    .filter(key => {
    return (
    params[key] !== undefined &&
    params[key] !== '' &&
    ['appSecret', 'partner_key', 'sign', 'key'].indexOf(key) < 0
    );
    })
    .sort();
    const result = {};
    for (const key of keys) {
    result[key] = params[key];
    }
    return result;
    }
    module.exports.buildRequestBody = function(params, needNonceStr = false) {
    const { app } = this;
    const { appKey, appSecret } = app.config.GJJ_OpenAPI;
    params = params || {};
    params.appKey = appKey;
    params.timestamp = Date.now();
    if (needNonceStr) {
    params.nonce_str = this.genRandomStr(16);
    }
    const signStr = this.paramSign(appSecret, params);
    return { sign: signStr, params };
    };
    module.exports.genRandomStr = function(length) {
    return crypto.randomBytes(length).toString('hex');
    };
    module.exports.paramSign = function(appSecret, params) {
    if (!params) {
    const err = new Error('parameter params missing');
    err.name = 'ParameterSignError';
    throw err;
    }
    if (!appSecret) {
    const err = new Error('parameter appSecret missing');
    err.name = 'ParamSignError';
    throw err;
    }
    const newParams = process(params);
    let query = querystring.stringify(newParams);
    query += '&appSecret=' + appSecret;
    const signStr = crypto
    .createHash('md5')
    .update(query)
    .digest('hex')
    .toUpperCase();
    return signStr;
    };
    module.exports.getUuid = function() {
    return uuid();
    };
    app/middleware/errorHandler.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = () => {
    return async function errorHandler(ctx, next) {
    try {
    await next();
    } catch (err) {
    // 所有的异常都在 app 上触发一个 error 事件，框架会记录一条错误日志
    ctx.app.emit('error', err, ctx);
    const status = err.status || 500;
    // 生产环境时 500 错误的详细错误内容不返回给客户端，因为可能包含敏感信息
    const error = status === 500 && ctx.app.config.env === 'prod'
    ? 'Internal Server Error'
    : err.message;
    // 从 error 对象上读出各个属性，设置到响应中
    ctx.fail(error);
    if (status === 422) {
    ctx.body.detail = err.errors;
    }
    ctx.status = status;
    }
    };
    };
    app/middleware/requestLog.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = (options, app) => {
    return async function(ctx, next) {
    const { request } = ctx;
    const { header } = request;
    const ipStr = header['x-real-ip'] || header['x-forwarded-for'];
    if (ipStr) {
    request.ip = ipStr;
    }
    const start = new Date();
    let ms = 0;
    await next();
    ms = new Date() - start;
    app.logger.info(
    `[middleware-response-time](${ms}ms) ${request.method} ${request.protocol}://${request.ip}${
    request.originalUrl}, request.query:${JSON.stringify(request.query)}, request.body:
    ${JSON.stringify(request.body)}, response.status: ${ctx.response.status}, response.body: ${JSON.stringify(ctx.response.body)}`
    );
    };
    };
    app/middleware/verifyAppKey.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = (options, app) => {
    return async function(ctx, next) {
    const { appKey } = ctx.request.body;
    // 可以在这里增加验签的功能;
    if (appKey && ctx.app.appKeyArr.includes(appKey)) {
    await next();
    } else {
    ctx.throw(400, '无效的appKey');
    }
    };
    };
    app/model/taskStatus.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const moment = require('moment');
    module.exports = app => {
    const { DataTypes } = app.Sequelize;
    const taskStatus = app.model.define('taskStatus', {
    id: {
    type: DataTypes.INTEGER(20),
    allowNull: false,
    primaryKey: true,
    autoIncrement: true,
    field: 'id',
    },
    orderId: {
    type: DataTypes.STRING(255),
    allowNull: false,
    defaultValue: '',
    primaryKey: false,
    field: 'orderId',
    },
    taskId: {
    type: DataTypes.STRING(50),
    allowNull: false,
    defaultValue: '',
    field: 'taskId',
    },
    userId: {
    type: DataTypes.STRING(255),
    allowNull: true,
    defaultValue: '',
    field: 'userId',
    },
    cityId: {
    type: DataTypes.STRING(10),
    allowNull: true,
    defaultValue: '',
    field: 'cityId',
    },
    appkey: {
    type: DataTypes.STRING(100),
    allowNull: false,
    field: 'appkey',
    },
    callbackUrl: {
    type: DataTypes.STRING(255),
    allowNull: false,
    defaultValue: '',
    field: 'callbackUrl',
    },
    status: {
    type: DataTypes.STRING(50),
    allowNull: false,
    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));
    },
    },
    createDate: {
    type: DataTypes.DATE,
    get() {
    const date = this.getDataValue('createDate');
    return date ? moment(date).format('YYYY-MM-DD HH:mm:ss') : undefined;
    },
    },
    updateDate: {
    type: DataTypes.DATE,
    get() {
    const date = this.getDataValue('updateDate');
    return date ? moment(date).format('YYYY-MM-DD HH:mm:ss') : undefined;
    },
    },
    type: {
    type: DataTypes.STRING(1),
    allowNull: true,
    defaultValue: '',
    field: 'type',
    },
    }, {
    tableName: 'sbH5_status',
    timestamps: false,
    });
    return taskStatus;
    };
    app/router.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    /**
    * @param {Egg.Application} app - egg application
    */
    module.exports = app => {
    const { controller } = app;
    const sbRouter = app.router.namespace(app.config.projectRootPath);
    sbRouter.post('/tasks', controller.task.create); // 创建任务
    sbRouter.get('/tasks/:taskId', controller.task.show); // 获取任务状态
    sbRouter.post('/tasks/:taskId/submit', controller.task.submit); // 提交任务参数
    sbRouter.post('/tasks/:taskId/capture', controller.task.fetchCapture); // 获取验证码
    sbRouter.post('/callback', controller.task.handleCallback); // 处理回调结果，不对外
    sbRouter.get('/scripts', controller.script.fetchScripts); // 获取所有脚本信息
    sbRouter.get('/scripts/:scriptId', controller.script.fetchOneScripts); // 获取单一脚本信息
    sbRouter.get('/help/:scriptId', controller.script.fetchHelpInfo); // 获取帮助信息
    sbRouter.get('/notice/:scriptId', controller.script.fetchNoticeInfo);// 获取提示信息
    sbRouter.get('/query_button/:scriptId', controller.script.fetchQueryButtonInfo); // 获取查询按钮信息
    sbRouter.get('/params', controller.script.fetchParamsInfo); // 获取登录参数字典
    sbRouter.post('/tokens', controller.token.create); // 创建token
    sbRouter.post('/orders', controller.order.create); // 创建订单号
    sbRouter.post('/orders/:orderId', controller.order.show); // 获取订单号详情
    sbRouter.get('/hubs/:hubId/scripts', controller.script.fetchHubSeripts);// 根据hubId 获取脚本数据（数组）
    sbRouter.get('/theme/:appKey', controller.partner.show);// 根据hubId 获取脚本数据（数组）
    // 这个接口之后会移除掉
    sbRouter.get('/orders', controller.order.fetchOrderId);
    sbRouter.post('/getToken', controller.token.createForPartner);
    };
    app/schedule/flash_cus_pro.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = {
    schedule: {
    interval: '5m', // 4个小时间隔
    type: 'all', // 所有woker
    immediate: true,
    },
    async task(ctx) {
    try {
    const dbRes = await ctx.cusPro.query('SELECT app_key FROM customer_product WHERE goods_sn = 108 AND state = 1', {
    type: 'SELECT',
    });
    const arr = [];
    for (const item of dbRes) {
    arr.push(item.app_key);
    }
    ctx.app.appKeyArr = arr;
    } catch (e) {
    ctx.logger.error('【schedule/flash_cus_pro】catch error:', e);
    }
    },
    };
    app/service/cache.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    class CacheService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config } = this;
    const { taskPrefix } = config.lockKeys;
    this.taskPrefix = taskPrefix;
    }
    /**
    * 将taskId状态缓存到redis和数据库
    * @param {Object} key taskId
    * - value: 状态 提示信息 status 、note={}
    * - exprie: 过期时间(单位/s)
    */
    async set({ key, value = {}, expire = 300 }) {
    const { ctx, app, taskPrefix } = this;
    const data = await app.cache.get(taskPrefix + key);
    if (!data || (data && data.status !== 'success')) {
    await app.cache.set(taskPrefix + key, value, expire);
    }
    const order = await ctx.model.TaskStatus.findOne({
    where: { taskId: key },
    });
    if (order && order.status !== 'success') {
    await order.update({ ...value });
    } else {
    ctx.logger.error('【Cache】set no order or already success', key);
    }
    }
    /**
    * 获取task状态 优先redis
    * @param {Object} key taskId
    * @return {Object} status note
    */
    async get({ key }) {
    const { ctx, app, taskPrefix } = this;
    const data = await app.cache.get(taskPrefix + key);
    if (data) {
    ctx.logger.info(`【Cache】get From node-cache ${key} data:`, data);
    return data;
    }
    const order = await ctx.model.TaskStatus.findOne({
    where: { taskId: key },
    });
    if (order) {
    ctx.logger.info(`【Cache】get From Model ${key} order:`, { status: order.status, note: order.note });
    return { status: order.status, note: order.note };
    }
    ctx.logger.error(`【Cache】get No Result ${key}`);
    ctx.throw.error(400, { message: 'no taskId' });
    }
    }
    module.exports = CacheService;
    app/service/order.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    class OrderService extends Service {
    async getOneByOrderId(orderId) {
    const { ctx } = this;
    const order = await ctx.model.TaskStatus.findOne({
    where: { orderId },
    });
    return order;
    }
    async getOneByTaskId(taskId) {
    const { ctx } = this;
    const order = await ctx.model.TaskStatus.findOne({
    where: { taskId },
    });
    return order;
    }
    async create(params) {
    const { ctx } = this;
    const order = await ctx.model.TaskStatus.findOne({
    where: { orderId: params.orderId },
    });
    if (order) {
    ctx.throw(400, { message: 'already have order' });
    }
    await ctx.model.TaskStatus.create(params);
    return order;
    }
    async update(params) {
    const { ctx } = this;
    const order = await ctx.model.TaskStatus.findOne({
    where: { orderId: params.orderId },
    });
    if (!order) {
    ctx.throw(400, { message: 'no order' });
    }
    await order.update(params);
    return order;
    }
    }
    module.exports = OrderService;
    app/service/partner.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    class PartnerService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config: { partnerAPI } } = this;
    this.partnerAPI = partnerAPI;
    }
    async fetchTheme(appKey) {
    const { ctx, partnerAPI: { fetchTheme, host, redisThemePrefix } } = this;
    if (appKey) {
    const data = await this.app.redis.get(redisThemePrefix + appKey);
    if (data) {
    try {
    return JSON.parse(data);
    } catch (err) {
    ctx.logger.error('【Scripts】fetchParams', redisThemePrefix + appKey, 'result:', data, err);
    await this.app.redis.del(redisThemePrefix + appKey);
    }
    }
    }
    const ret = await ctx.curl(`${host + fetchTheme}/${appKey}`, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    method: 'GET',
    });
    ctx.logger.info(`【Partner】 fetchTheme ${host + fetchTheme}/${appKey}`, ret.data);
    if (ret.status === 200 && ret.data && ret.data.id === appKey) {
    await this.app.redis.set(redisThemePrefix + appKey, JSON.stringify(ret.data), 'EX', 7200);
    }
    return ret.data;
    }
    async fetchScripts(appKey) {
    const { ctx, partnerAPI: { fetchScripts, host, redisScriptsPrefix } } = this;
    if (appKey) {
    const data = await this.app.redis.get(redisScriptsPrefix + appKey);
    if (data) {
    try {
    return JSON.parse(data);
    } catch (err) {
    ctx.logger.error('【Partner】 fetchScripts', redisScriptsPrefix + appKey, 'result:', data, err);
    await this.app.redis.del(redisScriptsPrefix + appKey);
    }
    }
    }
    const url = `${host + fetchScripts}/${appKey}`;
    const ret = await ctx.curl(url, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    method: 'GET',
    });
    ctx.logger.info(`【Partner】 fetchTheme ${url}`, ret.data);
    if (ret.status === 200 && ret.data && ret.data.id === appKey) {
    await this.app.redis.set(redisScriptsPrefix + appKey, JSON.stringify(ret.data), 'EX', 7200);
    }
    return ret.data;
    }
    }
    module.exports = PartnerService;
    app/service/scripts.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    class ScriptsService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config } = this;
    const { scriptsAPI } = config;
    this.scriptsAPI = scriptsAPI;
    this.baseURL = scriptsAPI.host;
    this.fetchScriptsUrl = scriptsAPI.fetchScriptsUrl;
    this.fetchOneScriptUrl = scriptsAPI.fetchOneScriptUrl;
    this.fetchParamsInfoUrl = scriptsAPI.fetchParamsInfoUrl;
    this.fetchHelpUrl = scriptsAPI.fetchHelpUrl;
    this.redisScriptsKey = scriptsAPI.redisScriptsKey;
    this.redisParamsKey = scriptsAPI.redisParamsKey;
    }
    async fetchScripts() {
    const { baseURL, fetchScriptsUrl, redisScriptsKey, ctx } = this;
    const data = await this.app.redis.get(redisScriptsKey);
    if (data) {
    try {
    return JSON.parse(data);
    } catch (err) {
    ctx.logger.error('【Scripts】fetchScriptsFromRedis', 'result:', data, err);
    await this.app.redis.del(redisScriptsKey);
    }
    }
    const result = await ctx.curl(baseURL + fetchScriptsUrl, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    ctx.logger.info(`【Scripts】fetchScripts,${baseURL + fetchScriptsUrl}`, 'result:', result.data);
    if (result.data && result.data.length > 0) {
    await this.app.redis.set(redisScriptsKey, JSON.stringify(result.data), 'EX', 300);
    }
    return result.data;
    }
    async fetchOneScripts(scriptId) {
    const { baseURL, fetchOneScriptUrl, ctx } = this;
    const result = await ctx.curl(baseURL + fetchOneScriptUrl + '/' + scriptId, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    return result.data;
    }
    async fetchParams(refresh = false) {
    const { baseURL, fetchParamsInfoUrl, redisParamsKey, ctx } = this;
    if (!refresh) {
    const data = await this.app.redis.get(redisParamsKey);
    if (data) {
    try {
    return JSON.parse(data);
    } catch (err) {
    ctx.logger.error('【Scripts】fetchParams', 'result:', data, err);
    await this.app.redis.del(redisParamsKey);
    }
    }
    }
    const result = await ctx.curl(baseURL + fetchParamsInfoUrl, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    ctx.logger.info(`【Scripts】fetchParams,${baseURL + fetchParamsInfoUrl}`, 'result:', result.data);
    if (result.data && result.data.length > 0) {
    await this.app.redis.set(redisParamsKey, JSON.stringify(result.data), 'EX', 3000);
    }
    return result.data;
    }
    async fetchHelp(scriptId) {
    const { baseURL, scriptsAPI: { fetchHelpUrl }, ctx } = this;
    const result = await ctx.curl(baseURL + fetchHelpUrl + '/' + scriptId, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    return result.data;
    }
    async fetchQueryButton(scriptId) {
    const { baseURL, scriptsAPI: { fetchQueryButtonUrl }, ctx } = this;
    const result = await ctx.curl(baseURL + fetchQueryButtonUrl + '/' + scriptId, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    return result.data;
    }
    async fetchNotice(scriptId) {
    const { baseURL, scriptsAPI: { fetchNoticeUrl }, ctx } = this;
    const result = await ctx.curl(baseURL + fetchNoticeUrl + '/' + scriptId, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    return result.data;
    }
    async fetchHubSeripts(hubId) {
    const { baseURL, scriptsAPI: { fetchHubSeriptsUrl }, ctx } = this;
    const result = await ctx.curl(baseURL + fetchHubSeriptsUrl + '/' + hubId + '/scripts', {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    return result.data;
    }
    async fetchCityFormIp() {
    const { ctx } = this;
    const { ip } = ctx.request;
    ctx.logger.info(ctx.request);
    const url = `https://api.map.baidu.com/location/ip?ak=3TBenWOhPygtFFazaR5kSibU&ip=${ip}`;
    const result = await ctx.curl(url, {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    if (result.data.status === 0) {
    return result.data.content.address_detail.city;
    }
    ctx.logger.error('fetchCityFormIp', url, result.data);
    return '北京市';
    }
    async fetchScriptByCityName(name) {
    const { baseURL, scriptsAPI: { fetchScriptByCityNameUrl }, ctx } = this;
    const result = await ctx.curl(baseURL + fetchScriptByCityNameUrl + '?name=' + encodeURIComponent(name) + '&type=query', {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    contentType: 'json',
    });
    ctx.logger.info(`fetchScriptByCityName,${baseURL + fetchScriptByCityNameUrl + '?name=' + name}`, 'result:', result.data);
    return result.data;
    }
    async fetchScriptIdByIp() {
    const city = await this.fetchCityFormIp();
    const scriptList = await this.fetchScriptByCityName(city);
    return scriptList;
    }
    }
    module.exports = ScriptsService;
    app/service/signature.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    const LOCK_SCRIPT = 'return redis.call("set", KEYS[1], ARGV[1], "NX", "EX", ARGV[2])';
    const UNLOCK_SCRIPT =
    'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end';
    class SignatureService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config } = this;
    const { signatureAPI, lockKeys } = config;
    this.baseURL = signatureAPI.host;
    this.fetchTokenUrl = signatureAPI.fetchTokenUrl;
    this.fetchOrderIdUrl = signatureAPI.fetchOrderIdUrl;
    this.signatureUrl = signatureAPI.signatureUrl;
    this.signatureType = signatureAPI.signatureType;
    this.LOCK_KEY = lockKeys.fecteToken;
    this.SCRIPTS_KEY = lockKeys.token;
    ctx.app.redis.defineCommand('lock', {
    numberOfKeys: 1,
    lua: LOCK_SCRIPT,
    });
    ctx.app.redis.defineCommand('unlock', {
    numberOfKeys: 1,
    lua: UNLOCK_SCRIPT,
    });
    }
    _request(url, opts) {
    const { ctx, baseURL } = this;
    url = `${baseURL}${url}`;
    opts = {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    ...opts,
    };
    ctx.logger.info('signnature', url, opts);
    return ctx.curl(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 createToken(params) {
    const { fetchTokenUrl, ctx } = this;
    const result = await this._request(fetchTokenUrl, {
    method: 'post',
    data: params,
    contentType: 'json',
    });
    ctx.logger.info('【Signature】createToken params', params, 'result:', result.data);
    this._checkSuccess(result);
    return result.data.data.token;
    }
    async createOrderId(params) {
    const { fetchOrderIdUrl, ctx } = this;
    const result = await this._request(fetchOrderIdUrl, {
    method: 'post',
    data: params,
    contentType: 'json',
    });
    ctx.logger.info('【Signature】createOrderId params', params, 'result:', result.data);
    this._checkSuccess(result);
    return result.data.data.orderSn;
    }
    async signatureCheck(params) {
    const { signatureUrl, signatureType, ctx } = this;
    const result = await this._request(signatureUrl, {
    method: 'post',
    data: { ...params, type: signatureType },
    contentType: 'json',
    });
    ctx.logger.info('【Signature】signatureCheck params', params, 'result:', result.data);
    this._checkSuccess(result);
    return result.data.data;
    }
    // 临时文件
    async getToken() {
    const { app, ctx, LOCK_KEY, SCRIPTS_KEY } = this;
    const { redis } = app;
    const result = await redis.get(SCRIPTS_KEY);
    if (result) {
    return result;
    }
    const lockVal = ctx.helper.genRandomStr(16);
    const locked = await redis.lock(LOCK_KEY, lockVal, 60);
    if (locked) {
    const signParams = ctx.helper.buildRequestBody();
    const token = await this.createToken(signParams);
    await redis.set(SCRIPTS_KEY, token, 'EX', 7150);
    await redis.unlock(LOCK_KEY, lockVal);
    return token;
    }
    this.getToken();
    }
    async _checkSuccessForPartner(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(200, { message: result.data.msg, code: result.data.code });
    }
    }
    // 给合作方创建token
    async createTokenForPartner(params) {
    const { fetchTokenUrl, ctx } = this;
    const result = await this._request(fetchTokenUrl, {
    method: 'post',
    data: params,
    contentType: 'json',
    });
    ctx.logger.info('【Signature】createToken params', params, 'result:', result.data);
    this._checkSuccessForPartner(result);
    return result.data.data.token;
    }
    }
    module.exports = SignatureService;
    app/service/storage.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    class StorageService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config } = this;
    const { storageAPI } = config;
    this.baseURL = storageAPI.host;
    this.writeUrl = storageAPI.writeUrl;
    this.readUrl = storageAPI.readUrl;
    this.writeType = storageAPI.writeType;
    this.readDataKey = storageAPI.readDataKey;
    }
    _request(url, opts) {
    const { ctx, baseURL } = this;
    url = `${baseURL}${url}`;
    opts = {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    ...opts,
    };
    return ctx.curl(url, opts);
    }
    async write(data) {
    const { writeUrl, writeType, ctx } = this;
    const result = await this._request(writeUrl, {
    method: 'post',
    data: { ...data, serviceType: writeType },
    contentType: 'json',
    });
    ctx.logger.info(`【Storage】write url:${writeUrl} params`, { ...data, serviceType: writeType }, 'result:', result.data);
    if (result.data.code !== '0') {
    throw new Error('存储数据出错');
    }
    return;
    }
    async read(orderId) {
    const { readUrl, readDataKey, ctx } = this;
    const result = await this._request(`${readUrl}/${orderId}`, {
    method: 'get',
    contentType: 'json',
    });
    ctx.logger.info(`【Storage】read url:${readUrl}/${orderId} write result:`, result.data);
    if (result && result.data && result.data.code !== 0) {
    ctx.logger.error(`storageAPI read ${readUrl}/${orderId}`, result.data);
    ctx.throw(400, { message: result.data.msg });
    }
    return result.data.data[readDataKey];
    }
    }
    module.exports = StorageService;
    app/service/task.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    const LOCK_SCRIPT = 'return redis.call("set", KEYS[1], ARGV[1], "NX", "EX", ARGV[2])';
    const UNLOCK_SCRIPT =
    'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end';
    class TaskService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config: { taskAPI, LOCK_KEY } } = this;
    this.taskAPI = taskAPI;
    this.baseURL = taskAPI.host;
    this.LOCK_KEY = LOCK_KEY;
    ctx.app.redis.defineCommand('lock', {
    numberOfKeys: 1,
    lua: LOCK_SCRIPT,
    });
    ctx.app.redis.defineCommand('unlock', {
    numberOfKeys: 1,
    lua: UNLOCK_SCRIPT,
    });
    }
    _request(url, opts) {
    const { ctx, baseURL } = this;
    url = `${baseURL}${url}`;
    opts = {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    ...opts,
    };
    return ctx.curl(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 create(data) {
    const { ctx, taskAPI } = this;
    const { createTaskUrl } = taskAPI;
    const result = await this._request(createTaskUrl, {
    method: 'post',
    data: { cityId: data },
    contentType: 'json',
    });
    ctx.logger.info(`【Task】create ${createTaskUrl} cityId: ${data} result:`, result.data);
    this._checkSuccess(result);
    return result.data.data.taskId;
    }
    async fetchCapture({ taskId, type }) {
    const { taskAPI, ctx } = this;
    const { fetchCodeUrl } = taskAPI;
    const result = await this._request(fetchCodeUrl, {
    method: 'post',
    data: {
    taskId,
    type,
    },
    contentType: 'json',
    });
    ctx.logger.info(`【Task】fetchCapture ${fetchCodeUrl} params`, {
    taskId,
    type,
    }, result.data);
    this._checkSuccess(result);
    return result.data.data;
    }
    async submit(data) {
    const { taskAPI, ctx } = this;
    const { submitTaskUrl } = taskAPI;
    const result = await this._request(submitTaskUrl, {
    method: 'post',
    data,
    contentType: 'json',
    });
    ctx.logger.info(`【Task】submit ${submitTaskUrl} params`, data, result.data);
    this._checkSuccess(result);
    return result;
    }
    async fetchTask(data) {
    const { taskAPI, ctx } = this;
    const { fetchTaskUrl } = taskAPI;
    const result = await this._request(fetchTaskUrl, {
    method: 'post',
    data,
    contentType: 'json',
    });
    ctx.logger.info(`【Task】fetchTask ${fetchTaskUrl} params`, data, result.data);
    return result.data;
    }
    // async _fetchScripts() {
    // const { taskAPI } = this;
    // const { fecthHubsUrl } = taskAPI;
    // const result = await this._request(fecthHubsUrl, {
    // method: 'get',
    // contentType: 'json',
    // });
    // return result;
    // }
    // async fetchScripts() {
    // const { app, ctx, LOCK_KEY, SCRIPTS_KEY } = this;
    // const { redis } = app;
    // const result = await redis.get(SCRIPTS_KEY);
    // if (result) {
    // return JSON.parse(result);
    // }
    // const lockVal = ctx.helper.genRandomStr(16);
    // const locked = await redis.lock(LOCK_KEY, lockVal, 60);
    // if (locked) {
    // const scripts = await this._fetchScripts();
    // await redis.set(SCRIPTS_KEY, JSON.stringify(scripts), 'EX', 300);
    // await redis.unlock(LOCK_KEY, lockVal);
    // return scripts;
    // }
    // this.fetchScripts();
    // }
    }
    module.exports = TaskService;
    app/service/washData.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const Service = require('egg').Service;
    class WashDataService extends Service {
    constructor(ctx) {
    super(ctx);
    const { config } = this;
    this.washUrl = config.washAPI.host + config.washAPI.washUrl;
    }
    async wash(data) {
    const { app, washUrl, ctx } = this;
    const rawdata = this._switchData(data);
    const washData = await app.curl(washUrl,
    {
    charset: 'utf-8',
    timeout: ['30s', '30s'],
    dataType: 'json',
    data: rawdata,
    method: 'post',
    contentType: 'json',
    });
    if (washData.status !== 200) {
    ctx.logger.error(`【washData】url${washUrl} ,params`, rawdata, washData);
    throw new Error('清洗数据出错');
    }
    if (washData.data.code !== 0) {
    ctx.logger.error(`【washData】url${washUrl} ,params`, rawdata, washData.data);
    throw new Error('清洗数据出错');
    }
    return washData.data;
    }
    _switchData(data) {
    const tmp = data.data;
    const bar = {};
    bar.taskId = tmp.taskId;
    bar.cityId = tmp.cityId;
    bar.data = JSON.parse(tmp.data);
    bar.orderID = 'ttt';
    bar.appKey = '';
    return bar;
    }
    }
    module.exports = WashDataService;
    appveyor.yml 0 → 100644
    View file @ 3a98abdf
    environment:
    matrix:
    - nodejs_version: '8'
    install:
    - ps: Install-Product node $env:nodejs_version
    - npm i npminstall && node_modules\.bin\npminstall
    test_script:
    - node --version
    - npm --version
    - npm run test
    build: off
    config/config.default.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = appInfo => {
    const config = exports = {};
    // use for cookie sign key, should change to your own and keep security
    config.keys = appInfo.name + '_1542452126322_5140';
    config.projectRootPath = '/shebao_server';
    // add your config here
    config.middleware = ['requestLog', 'errorHandler', 'verifyAppKey'];
    config.verifyAppKey = {
    match: '/orders',
    };
    // 是否启用csrf安全
    config.security = {
    csrf: {
    enable: false,
    },
    domainWhiteList: [],
    };
    config.cors = {
    origin: '*',
    allowMethods: 'GET,HEAD,PUT,POST,DELETE,PATCH,OPTIONS',
    credentials: true,
    };
    return config;
    };
    config/config.local.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = () => {
    const config = exports = {};
    config.debug = true;
    config.redis = {
    client: {
    port: 6379,
    host: '127.0.0.1',
    password: 'DEV8redis',
    db: 0,
    },
    };
    config.taskAPI = {
    host: 'http://tm.51gjj.com:4831',
    fetchHubsUrl: '',
    createTaskUrl: '/shebao/createSbTask',
    fetchCodeUrl: '/shebao/getSbCode',
    submitTaskUrl: '/shebao/loginSbWeb',
    fetchTaskUrl: '/shebao/getSbData', // 获取该task状态
    };
    config.partnerAPI = {
    host: 'https://dev-nginx.jianbing.com/zeus-api/v1',
    fetchTheme: '/chaos/partners/theme',
    fetchScripts: '/chaos/partners/scripts',
    redisThemePrefix: 'URANUS.HF.PARNTERS.THEME',
    redisScriptsPrefix: 'URANUS.HF.PARNTERS.SCRIPTS',
    };
    config.scriptsAPI = {
    host: 'https://dev-nginx.jianbing.com/zeus-api/v1',
    fetchScriptsUrl: '/chaos/hf/two_dimension_array/queries',
    fetchOneScriptUrl: '/chaos/hf/two_dimension_array/info',
    fetchParamsInfoUrl: '/chaos/hf/login_param_map',
    fetchQueryButtonUrl: '/chaos/hf/query_button',
    fetchHelpUrl: '/chaos/hf/help',
    fetchNoticeUrl: '/chaos/hf/notice',
    fetchHubSeriptsUrl: '/chaos/hf/hubs',
    fetchScriptByCityNameUrl: '/chaos/hf/city_scripts',
    redisScriptsKey: 'URANUS.HF.SCRIPTS',
    redisParamsKey: 'URANUS.HF.PARAMS',
    };
    config.storageAPI = {
    host: 'http://tv.51gjj.com:11252',
    writeUrl: '/data',
    readUrl: '/shebao',
    writeType: 'shebao',
    readDataKey: 'shebaoData',
    };
    config.washAPI = {
    host: 'http://tt.51gjj.com:11101',
    washUrl: '/si/analyzeSI',
    };
    config.signatureAPI = {
    host: 'http://tj3.51gjj.com:5118',
    fetchTokenUrl: '/Access/GetToken',
    fetchOrderIdUrl: '/Order/GetOrderSn',
    signatureUrl: '/Access/SignValidityCheck',
    fetchParnterUrl: '',
    signatureType: 'shebao',
    };
    config.lockKeys = {
    fecthHub: 'NEWSB.HF.HUBS.LOCK',
    fecteToken: 'NEWSB.HF.TOKEN.LOCK',
    token: 'NEWSB.HF.TOKEN',
    fecthParnters: 'NEWSB.PARNTERS.LOCK',
    taskPrefix: 'NEWSB.TASK',
    };
    config.sequelize = {
    datasources: [{
    // 东八时区
    timezone: '+08:00',
    delegate: 'model',
    baseDir: 'model',
    dialect: 'mysql',
    host: 'rm-bp1272001633qc0x9o.mysql.rds.aliyuncs.com',
    database: 'data_service_dev',
    username: 'hexin',
    password: 'gYUHszn9#q',
    port: 3306,
    }, {
    // 东八时区
    timezone: '+08:00',
    delegate: 'cusPro',
    baseDir: 'model',
    dialect: 'mysql',
    host: 'rm-bp1272001633qc0x9o.mysql.rds.aliyuncs.com',
    database: 'java_open_platform',
    username: 'hexin',
    password: 'gYUHszn9#q',
    port: 3306,
    }],
    };
    config.SB_OpenAPI = {
    appKey: '60670203E411FD62BA9E953CFB73F881',
    appSecret: '0BDD1ECC147503C477563E5C1438C366D70E4F80',
    };
    config.callbackUrl = 'https://dev-nginx.jianbing.com/shebao_server/callback';
    return config;
    };
    config/config.prod.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    module.exports = () => {
    const config = exports = {};
    config.debug = true;
    config.redis = {
    client: {
    port: 6379,
    host: process.env.REDIS_HOST,
    password: 'DEV8redis',
    db: 0,
    },
    };
    config.taskAPI = {
    host: 'http://tm.51gjj.com:4831',
    fetchHubsUrl: '',
    createTaskUrl: '/gjjServices/createGjjTask',
    fetchCodeUrl: '/gjjServices/queryGjjCode',
    submitTaskUrl: '/gjjServices/queryGjj',
    fetchTaskUrl: '/gjjServices/getGjjData',
    };
    config.scriptsAPI = {
    host: 'https://dev-nginx.jianbing.com/zeus-api/v1',
    fetchScriptsUrl: '/chaos/hf/two_dimension_array/queries',
    fetchOneScriptUrl: '/chaos/hf/two_dimension_array/info',
    fetchParamsInfoUrl: '/chaos/hf/login_param_map',
    fetchQueryButtonUrl: '/chaos/hf/query_button',
    fetchHelpUrl: '/chaos/hf/help',
    fetchNoticeUrl: '/chaos/hf/notice',
    fetchHubSeriptsUrl: '/chaos/hf/hubs',
    fetchScriptByCityNameUrl: '/chaos/hf/city_scripts',
    redisScriptsKey: 'URANUS.HF.SCRIPTS',
    redisParamsKey: 'URANUS.HF.PARAMS',
    };
    config.storageAPI = {
    host: 'http://tv.51gjj.com:11252',
    writeUrl: '/data',
    readUrl: '/gjj',
    writeType: 'gjj',
    readDataKey: 'gjjData',
    };
    config.washAPI = {
    host: 'http://tt.51gjj.com:11101',
    washUrl: '/gjj/analyzeGjj',
    };
    config.signatureAPI = {
    host: 'http://tj3.51gjj.com:5118',
    fetchTokenUrl: '/Access/GetToken',
    fetchOrderIdUrl: '/Order/GetOrderSn',
    signatureUrl: '/Access/SignValidityCheck',
    fetchParnterUrl: '',
    signatureType: 'gjj',
    };
    config.partnerAPI = {
    host: 'https://dev-nginx.jianbing.com/zeus-api/v1',
    fetchTheme: '/chaos/partners/theme',
    fetchScripts: '/chaos/partners/scripts',
    redisThemePrefix: 'URANUS.HF.PARNTERS.THEME',
    redisScriptsPrefix: 'URANUS.HF.PARNTERS.SCRIPTS',
    };
    config.lockKeys = {
    fecthHub: 'URANUS.HF.HUBS.LOCK',
    fecteToken: 'URANUS.HF.TOKEN.LOCK',
    token: 'URANUS.HF.TOKEN',
    fecthParnters: 'URANUS.PARNTERS.LOCK',
    taskPrefix: 'URANUS.HFH5.TASK',
    };
    config.projectRootPath = '';
    config.sequelize = {
    datasources: [{
    // 东八时区
    timezone: '+08:00',
    delegate: 'model',
    baseDir: 'model',
    dialect: 'mysql',
    host: 'rm-bp1272001633qc0x9.mysql.rds.aliyuncs.com',
    database: 'nodetest',
    username: 'hexin',
    password: 'gYUHszn9#q',
    port: 3306,
    }],
    };
    config.GJJ_OpenAPI = {
    appKey: '9FBBA75BBFC24401AA6A76AEFC277346',
    appSecret: 'D7FEA664E0CD4336BEAA1B3569393A301DBB6995',
    };
    config.callbackUrl = 'https://dev-nginx.jianbing.com/hf_h5_server/callback';
    return config;
    };
    config/plugin.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    // had enabled by egg
    // exports.static = true;
    exports.mysql = {
    enable: false,
    package: 'egg-mysql',
    };
    exports.sequelize = {
    enable: true,
    package: 'egg-sequelize',
    };
    exports.redis = {
    enable: true,
    package: 'egg-redis',
    };
    exports.cors = {
    enable: true,
    package: 'egg-cors',
    };
    exports.validate = {
    enable: true,
    package: 'egg-validate',
    };
    exports.routerPlus = {
    enable: true,
    package: 'egg-router-plus',
    };
    package.json 0 → 100644
    View file @ 3a98abdf
    {
    "name": "hf_h5_server",
    "version": "1.0.0",
    "description": "公积金H5认证服务",
    "private": true,
    "dependencies": {
    "egg": "^2.2.1",
    "egg-cors": "^2.1.1",
    "egg-mysql": "^3.0.0",
    "egg-redis": "^2.0.0",
    "egg-router-plus": "^1.3.0",
    "egg-scripts": "^2.5.0",
    "egg-sequelize": "^4.2.0",
    "egg-validate": "^2.0.2",
    "mysql2": "^1.6.4",
    "node-cache": "^4.2.0"
    },
    "devDependencies": {
    "autod": "^3.0.1",
    "autod-egg": "^1.0.0",
    "egg-bin": "^4.3.5",
    "egg-ci": "^1.8.0",
    "egg-mock": "^3.14.0",
    "eslint": "^4.11.0",
    "eslint-config-egg": "^6.0.0",
    "webstorm-disable-index": "^1.2.0"
    },
    "engines": {
    "node": ">=8.9.0"
    },
    "scripts": {
    "start": "egg-scripts start --daemon --title=egg-server-hf_h5_server",
    "stop": "egg-scripts stop --title=egg-server-hf_h5_server",
    "docker": "eggctl start --title=egg-server-hf_h5_serverr",
    "dev": "egg-bin dev",
    "debug": "egg-bin debug",
    "test": "npm run lint -- --fix && npm run test-local",
    "test-local": "egg-bin test",
    "cov": "egg-bin cov",
    "lint": "eslint .",
    "ci": "npm run lint && npm run cov",
    "autod": "autod"
    },
    "ci": {
    "version": "8"
    },
    "repository": {
    "type": "git",
    "url": ""
    },
    "author": "HAYWAEL",
    "license": "MIT"
    }
    test/app/controller/home.test.js 0 → 100644
    View file @ 3a98abdf
    'use strict';
    const { app, assert } = require('egg-mock/bootstrap');
    describe('test/app/controller/home.test.js', () => {
    it('should assert', function* () {
    const pkg = require('../../../package.json');
    assert(app.config.keys.startsWith(pkg.name));
    // const ctx = app.mockContext({});
    // yield ctx.service.xx();
    });
    it('should GET /', () => {
    return app.httpRequest()
    .get('/')
    .expect('hi, egg')
    .expect(200);
    });
    });
    Markdown is supported
    0% or
    You are about to add 0 people to the discussion. Proceed with caution.
    Finish editing this message first!
    Please register or to comment