Merge branch 'master' of ssh://gitlab.mytoken.org:10022/zhuangke/ts-api-demo

# Conflicts:
#	package-lock.json

cron/coinAndPairSetting.ts

+'use strict';
+
+
+const schedule = require('node-schedule');
+let { logger, datetimeUtils } = require('@madex/ex-js-public');
+
+import { spotPairs, ormDB, coinType } from "@madex/ex-ts-dao";
+import { getPairFromCore, getCoinFromCore } from '../src/utils/coreSystemUtils'
+
+
+let running = false;
+
+/**
+ *  每五分钟检查一次
+ */
+let job = schedule.scheduleJob('*/15 * * * * ?', async function () {
+    logger.info('setting sync start');
+
+    if (!running) {
+        try {
+            await syncPair();
+            await syncCoin();
+            running = true;
+            logger.info("coinAndPair sync job finish");
+        } catch (e) {
+            logger.info(e)
+        }
+        running = false;
+
+    }
+});
+const syncPair = async () => {
+    let now = new Date();
+    let res = await spotPairs.prototype.findAll({
+        where: {
+            status:1,
+            updatedAt:{[ormDB.Op.lt]:new Date(now.getTime()-10*1000)} // 10秒之前的
+        },
+        raw: true
+    })
+
+    for (const pair of res) {
+        const { symbol, id } = pair;
+        let cfg = await getPairFromCore(symbol);
+        if (cfg) {
+            await spotPairs.prototype.update({
+                status: 2,
+                product_id: cfg.id,
+                price_scale: cfg["price-scale"],
+                price_increment: cfg["price-increment"],
+                quantity_scale: cfg["quantity-scale"],
+                quantity_increment: cfg["quantity-increment"],
+
+            }, {
+                where: { id, status: 1 }
+            });
+            logger.info(symbol, "sync config success")
+        }
+    }
+}
+
+
+const syncCoin = async () => {
+    let now = new Date();
+    let res = await coinType.prototype.findAll({
+        where: {
+            is_main:1,
+            main_status:1,
+            updatedAt:{[ormDB.Op.lt]:new Date(now.getTime()-10*1000)} // 10秒之前的
+        },
+        raw: true
+    })
+
+    for (const coin of res) {
+        const { general_name:symbol, id } = coin;
+        let cfg = await getCoinFromCore(symbol);
+        if (cfg) {
+            await coinType.prototype.update({
+                main_status: 2,
+                asset_id: cfg["id"],
+            }, {
+                where: { id, main_status: 1 }
+            });
+            logger.info(symbol, "sync config success")
+        }
+    }
+}
+
+
+// job.invoke();

cron/index.ts

-// 计划任务
\ No newline at end of file
+// 计划任务
+
+require("./coinAndPairSetting.sync");
\ No newline at end of file

src/functional/mvc/control/coinType.control.ts

 import * as service from "../service/coinType.service";
 import { AddParam, ListParam } from "../service/coinType.service";
 
-let { logger, ResponseUtils, optionalUtils: Optional, apiAssertUtils: ApiAssert } = require('@madex/ex-js-public');
+let { logger, Res3Utils, optionalUtils: Optional, apiAssertUtils: ApiAssert } = require('@madex/ex-js-public');
 
 
 export const list = async (req: any, param: ListParam) => {
@@ -11,16 +11,16 @@ export const list = async (req: any, param: ListParam) => {
         param.page = Optional.opt(param, 'page', 1);
         param.size = Optional.opt(param, 'size', 50);
         let res = await service.list(param);
-        return ResponseUtils.success(cmd, res);
+        return Res3Utils.result(res);
     }
     catch (e) {
         logger.error(`${func_name} error:${e}`);
-        return ResponseUtils.error(func_name, cmd, e);
+        return Res3Utils.getErrorResult(e);
     }
 };
 
-export const add = async (req: any, param: AddParam) => {
-    let func_name = "coinTypeCtl.add";
+export const save = async (req: any, param: AddParam) => {
+    let func_name = "coinTypeCtl.save";
     let cmd = req.path;
     try {
         ApiAssert.notNull('3000', param.symbol);
@@ -33,11 +33,26 @@ export const add = async (req: any, param: AddParam) => {
         ApiAssert.isInt('3000', param.deposit_confirm_count);
         ApiAssert.isInt('3000', param.safe_confirm_count);
 
-        let res = await service.add(param);
-        return ResponseUtils.success(cmd, res);
+        let res = await service.save(param);
+        return Res3Utils.result(res);
     }
     catch (e) {
         logger.error(`${func_name} error:${e}`);
-        return ResponseUtils.error(func_name, cmd, e);
+        return Res3Utils.getErrorResult(e);
+    }
+};
+
+
+export const pushToCoreSystem = async (req: any, id: any) => {
+    let func_name = "coinTypeCtl.pushToCoreSystem";
+    let cmd = req.path;
+    try {
+        ApiAssert.notNull('3000', id);
+        let res = await service.pushToCoreSystem(id);
+        return Res3Utils.result(res);
+    }
+    catch (e) {
+        logger.error(`${func_name} error:${e}`);
+        return Res3Utils.getErrorResult(e);
     }
 };

src/functional/mvc/control/spotPair.control.ts

 import * as service from "../service/spotPair.service";
 import { AddParam, ListParam } from "../service/spotPair.service";
 
-let { logger, ResponseUtils, optionalUtils: Optional, apiAssertUtils: ApiAssert } = require('@madex/ex-js-public');
+let { logger, Res3Utils, optionalUtils: Optional, apiAssertUtils: ApiAssert } = require('@madex/ex-js-public');
 
 
 export const list = async (req: any, param: ListParam) => {
@@ -11,16 +11,16 @@ export const list = async (req: any, param: ListParam) => {
         param.page = Optional.opt(param, 'page', 1);
         param.size = Optional.opt(param, 'size', 50);
         let res = await service.list(param);
-        return ResponseUtils.success(cmd, res);
+        return Res3Utils.result(res);
     }
     catch (e) {
         logger.error(`${func_name} error:${e}`);
-        return ResponseUtils.error(func_name, cmd, e);
+        return Res3Utils.getErrorResult(e);
     }
 };
 
-export const add = async (req: any, param: AddParam) => {
-    let func_name = "spotPairCtl.add";
+export const save = async (req: any, param: AddParam) => {
+    let func_name = "spotPairCtl.save";
     let cmd = req.path;
     try {
         ApiAssert.notNull('3000', param.base);
@@ -31,11 +31,26 @@ export const add = async (req: any, param: AddParam) => {
         ApiAssert.notNull('3000', param.quantity_scale);
         ApiAssert.notNull('3000', param.maker_fee);
         ApiAssert.notNull('3000', param.taker_fee);
-        let res = await service.add(param);
-        return ResponseUtils.success(cmd, res);
+        let res = await service.save(param);
+        return Res3Utils.result(res);
     }
     catch (e) {
         logger.error(`${func_name} error:${e}`);
-        return ResponseUtils.error(func_name, cmd, e);
+        return Res3Utils.getErrorResult(e);
+    }
+};
+
+
+export const pushToCoreSystem = async (req: any, id: any) => {
+    let func_name = "spotPairCtl.pushToCoreSystem";
+    let cmd = req.path;
+    try {
+        ApiAssert.notNull('3000', id);
+        let res = await service.pushToCoreSystem(id);
+        return Res3Utils.result(res);
+    }
+    catch (e) {
+        logger.error(`${func_name} error:${e}`);
+        return Res3Utils.getErrorResult(e);
     }
 };

src/functional/mvc/service/coinType.service.ts

 // @madex/ex-ts-dao 是 ts 的 dao, 代码在 bitbucket/ex-js-dao 的 ts 分支上
-import { coinType, ormDB } from "@madex/ex-ts-dao";
+import { coinType, ormDB, spotPairs } from "@madex/ex-ts-dao";
+import { addCoin2Core, addPairToCore } from "../../../utils/coreSystemUtils";
 
 
 export interface ListParam {
@@ -11,6 +12,8 @@ export interface ListParam {
 }
 
 export interface AddParam {
+    id: any,
+
     symbol: string;
 
     is_active: number;
@@ -60,29 +63,29 @@ export interface AddParam {
     total_amount?: number;
 
 
-    supply_amount?: number ;
+    supply_amount?: number;
 
-    circulation_rate?: number ;
+    circulation_rate?: number;
 
     address_num?: number;
 
-    price?: string ;
+    price?: string;
 
-    supply_time?:string ;
+    supply_time?: string;
 
-    deflation_rate?:number ;
+    deflation_rate?: number;
 
-    comment?: string ;
+    comment?: string;
 
-    max_transfer_amount?: number ;
+    max_transfer_amount?: number;
 
     tag: string;
 
-    forbid_info_related?: number ;
+    forbid_info_related?: number;
 
-    is_hidden?: number ;
+    is_hidden?: number;
 
-    main_status?: number ;
+    main_status?: number;
 }
 
 
@@ -101,8 +104,39 @@ export async function list(param: ListParam) {
     return resList;
 }
 
-export const add = async (param: AddParam) => {
-    await coinType.prototype.create(param);
+export const save = async (param: AddParam) => {
+    let id = param.id;
+    if (id) {
+        delete param.id
+        await coinType.prototype.update(param, {
+            where: { id: id }
+        })
+    }
+    else {
+        await coinType.prototype.create(param);
+    }
+
+    return 'ok';
+};
+
+export const pushToCoreSystem = async (id: any) => {
+
+    let where = { id: id, main_status: 0, is_main: 1 };
+
+    let cfg = await coinType.prototype.find({
+        where: where, raw: true
+    });
+    if (cfg) {
+        let symbol = cfg.general_name;
+
+        let optResult = await addCoin2Core(symbol);
+        if (optResult) {
+            await coinType.prototype.update({ main_status: 1 }, {
+                where: where
+            })
+        }
+    }
     return 'ok';
+
 };
 

src/functional/mvc/service/spotPair.service.ts

 // @madex/ex-ts-dao 是 ts 的 dao, 代码在 bitbucket/ex-js-dao 的 ts 分支上
-import { spotPairs, ormDB } from "@madex/ex-ts-dao";
+import { spotPairs, ormDB, coinType } from "@madex/ex-ts-dao";
 import { NUMBER } from "sequelize";
+import { addPairToCore } from "../../../utils/coreSystemUtils";
 
 
 export interface ListParam {
     symbol: string | any;
+
     page: number;
+
     size: number;
 }
 
 export interface AddParam {
-    base:string;
-    quote:string;
-    symbol:string;
-    name:string;
-    price_scale:number;
-    quantity_scale:number;
-    maker_fee:string;
+    id: any;
+
+    base: string;
+
+    quote: string;
+
+    symbol: string;
+
+    name: string;
+
+    price_scale: number;
+
+    quantity_scale: number;
+
+    maker_fee: string;
+
     taker_fee: string;
 }
 
@@ -24,7 +36,7 @@ export interface AddParam {
 export async function list(param: ListParam) {
     let where = {};
     if (param.symbol) {
-        where["symbol"]=  { [ormDB.Op.like]: `%${param.symbol}%` };
+        where["symbol"] = { [ormDB.Op.like]: `%${param.symbol}%` };
     }
     let resList = await spotPairs.prototype.findAndCount({
         where: where,
@@ -36,8 +48,44 @@ export async function list(param: ListParam) {
     return resList;
 }
 
-export const add = async (param: AddParam) => {
-    await spotPairs.prototype.create(param);
+export const save = async (param: AddParam) => {
+    let id = param.id;
+    if (id) {
+        delete param.id
+        await spotPairs.prototype.update(param, {
+            where: { id: id }
+        })
+    }
+    else {
+        await spotPairs.prototype.create(param);
+    }
+    return 'ok';
+};
+
+export const pushToCoreSystem = async (id: any) => {
+    let where = { id: id, status: 0 };
+
+    let cfg = await spotPairs.prototype.find({
+        where: where, raw: true
+    });
+    if (cfg) {
+        let symbol = cfg.symbol;
+        let sps = symbol.split("_");
+        let base = sps[0];
+        let quote = sps[1]
+        let param = {
+            "base": base, "quote": quote, "symbol": symbol, "name": symbol,
+            "price-scale": cfg.price_scale, "quantity-scale": cfg.quantity_scale,
+            "maker-fee": cfg.maker_fee, "taker-fee": cfg.taker_fee
+        }
+        let optResult = await addPairToCore(param);
+        if (optResult) {
+            await spotPairs.prototype.update({ status: 1 }, {
+                where: where
+            });
+        }
+    }
+
     return 'ok';
 };
 

src/functional/router/v1/index.ts

@@ -36,10 +36,13 @@ const postFunc = {
     'i18n/info/log/list': i18nLogCtrl.list,
     'i18n/info/log/revert': i18nLogCtrl.revert,
 
-    'spotpair/add': spotPairCtrl.add,
-    'spotpair/list': spotPairCtrl.list,
-    'coinType/add': coinTypeCtrl.add,
+    'spotPair/add': spotPairCtrl.save,
+    'spotPair/list': spotPairCtrl.list,
+    'spotPair/spotPairCtl': spotPairCtrl.pushToCoreSystem,
+
+    'coinType/add': coinTypeCtrl.save,
     'coinType/list': coinTypeCtrl.list,
+    'coinType/spotPairCtl': coinTypeCtrl.pushToCoreSystem,
 
     //权限管理
     'acl/user/add': aclUserCtrl.add,

src/utils/coreSystemUtils.ts

+const axios = require("axios");
+
+import  configSetting  from "./../../config"
+const webadmin_endpoint = configSetting.webadmin_endpoint
+let { logger } = require('@madex/ex-js-public');
+
+// { id: 1, symbol: 'BTC' }
+export const getCoinFromCore = async(symbol)=> {
+    const url = `${webadmin_endpoint}/asset/by_symbol?symbol=${symbol}`
+    let { data } = await axios.get(url);
+    if (data.error) {
+        logger.error("getCoinFromCore",data);
+        return null
+    }
+    return data[0];
+}
+
+// {
+//     "id": 1,
+//      "symbol": 'BTC_USDT',
+//     'price-scale': 4,
+//     'price-increment': 1,
+//     'quantity-scale': 2,
+//     'quantity-increment': '0'
+// }
+export const getPairFromCore = async(symbol,market="spot")=> {
+    const url = `${webadmin_endpoint}/pair/by_symbol?symbol=${symbol}&market=${market}`
+    let { data } = await axios.get(url);
+    if (data.error) {
+        logger.error("getPairFromCore",data);
+        return null
+    }
+    return data[0]
+}
+
+export const addCoin2Core = async(symbol)=> {
+    const url = `${webadmin_endpoint}/asset/add`
+    let body =  {
+        "symbol":symbol,
+    }
+    let { data } = await axios.post(url,body);
+    if (data.error) {
+        logger.error(data);
+        return false;
+    }
+    return true;
+}
+
+export const addPairToCore = async(body)=> {
+    const url = `${webadmin_endpoint}/pair/add_product`
+    let { data } = await axios.post(url,body);
+    if (data.error) {
+        logger.error(data);
+        return false;
+    }
+    return true;
+}
+