ming_node 2.2.5 → 2.4.0

package/module/BaseMapper.js

@@ -163,6 +163,23 @@ class BaseMapper {
         return dataList;
     }
 
+
+    /**
+     * 分页查
+     * @param page
+     * @param num
+     * @param queryCase
+     * @param columns
+     * @param order
+     */
+    async selectPurePageList({page=1,num=10,queryCase="1=1", columns="*",order="id desc"}){
+        let start = (page - 1) * num;
+        let whereCase=queryCase;
+        let queryColumn=BaseMapper.getColumn(columns);
+        let dataList=await Db.doSql(`SELECT ${queryColumn} FROM ${this.tableName} where ${whereCase} order by ${order}  LIMIT ${start},${num}`)
+        return dataList;
+    }
+
     /**
      * 查后代
      * @param parent_id
@@ -222,7 +239,7 @@ class BaseMapper {
     async getTableSchema(){
         if(this.tableSchema==null){
             let dataBaseName=Db.dbConfig.database;
-            let sql=`select COLUMN_NAME,COLUMN_TYPE,COLUMN_COMMENT from information_schema.columns where table_schema ='${dataBaseName}'  and table_name = '${this.tableName}';`
+            let sql=`select column_name,column_type,column_comment from information_schema.columns where table_schema ='${dataBaseName}'  and table_name = '${this.tableName}';`
             let tableSchema=await Db.doSql(sql);
             return tableSchema;
         }
@@ -303,7 +320,44 @@ class BaseMapper {
         return sql;
     }
 
-
+    /**
+     * 给 list 加name
+     * @param tableName 表名
+     * @param list      列表
+     * @param list_idkey     列表中的idkey
+     * @param list_namekey   列表中的namekey
+     * @param db_idkey      库中的namekey
+     * @param db_namekey    库中的namekey
+     * @returns {Promise<void>}
+     */
+    static async appendListName(
+        {
+            tableName="t_user",
+            list,
+            list_idkey="create_user",
+            list_namekey="name",
+            db_idkey="create_user",
+            db_namekey="create_user_name",
+        }
+    ){
+        if(list==null || list.length==0){
+            return
+        }
+        const idKeyList=list.map(u=>u[list_idkey]);
+        let sql=`select ${db_idkey}, ${db_namekey} from ${tableName} where ${db_idkey} in (?)`
+        let dbDataList=await Db.doSql(sql,[idKeyList]);
+        const userMap = {};
+        for (let i = 0; i < dbDataList.length; i++) {
+            const idkeyV = dbDataList[i][db_idkey];
+            userMap[idkeyV] = dbDataList[i];
+        }
+        for (let i=0;i<list.length;i++){
+            if(userMap[list[i][list_idkey]]){
+                list[i][list_namekey]= userMap[list[i][list_idkey]][db_namekey];
+            }
+        }
+        return;
+    }
 
 }
 

package/package.json

@@ -46,5 +46,5 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "2.2.5"
+  "version": "2.4.0"
 }

package/plugins/BaseGraphqlApi/getGraphqlSchema.js

@@ -6,56 +6,128 @@ const{
     GraphQLInt,
     GraphQLSchema,
     GraphQLList,
-    GraphQLNonNull
+    GraphQLNonNull,
+    GraphQLFloat,
+    GraphQLBoolean,
 } = require('graphql');
 
 
+function getGraphTypeBySqlType(sqlType) {
+    sqlType = sqlType.toLowerCase();
+    if (sqlType.indexOf("string") >= 0 || sqlType.indexOf("varchar") >= 0 || sqlType.indexOf("text") >= 0) {
+        return GraphQLString;
+    } else if (sqlType.indexOf("int") >= 0) {
+        return GraphQLInt;
+    } else if (sqlType.indexOf("date") >= 0 || sqlType.indexOf("time") >= 0) {
+        return GraphQLString;
+    } else if (sqlType.indexOf("double") >= 0) {
+        return GraphQLFloat;
+    } else if (sqlType.indexOf("float") >= 0) {
+        return GraphQLFloat;
+    } else if (sqlType.indexOf("decimal") >= 0) {
+        return GraphQLFloat;
+    }
+    return GraphQLString;
+}
 
 
-function getGraphqlSchema({dbBaseMapper}){
-    const ResponseType =  new GraphQLObjectType({
-        name:'response',
-        fields:{
-            status:{type:GraphQLInt},
-            msg:{type:GraphQLString}
+function obj2QueryCase(obj){
+    let queryCase="1=1";
+    if(obj && Object.keys(obj).length>0){
+        for(var p in obj) {
+            queryCase=queryCase+` and ${p}='${obj[p]}' `
         }
-    })
+    }
+    return queryCase;
+
+}
 
-    const qlObjectType = new GraphQLObjectType({
-        name:'person',
+async function getGraphqlSchema({dbBaseMapper,generateTime}){
+    let tableName=dbBaseMapper.tableName;
+    let tableSchema=await dbBaseMapper.getTableSchema()
+    const ResponseType =  new GraphQLObjectType({
+        name:'response',
         fields:{
-            id:{type:GraphQLInt},
-            name:{type:GraphQLString}
+            code:{type:GraphQLInt},
+            msg:{type:GraphQLString},
+            data:{type:GraphQLString},
         }
     })
-
+    let qlObjectTypeParams={};
+    qlObjectTypeParams.name=tableName;
+    qlObjectTypeParams.fields={};
+       tableSchema.forEach(u=>{
+           qlObjectTypeParams.fields[u.column_name]={
+                type:getGraphTypeBySqlType(u.column_type),
+                description:u.column_comment};
+         })
+    const qlObjectType = new GraphQLObjectType(qlObjectTypeParams)
     const RootQuery = new GraphQLObjectType({
-        name:'personQuery',
+        name:tableName+'Query',
         fields:{
-            person:{
+            rows:{
                 type: new GraphQLList(qlObjectType),
-                args:{
-                    id:{type:GraphQLInt},
-                    name:{type:GraphQLString}
-                },
+                args:{...qlObjectTypeParams.fields,
+                        page:{type:GraphQLInt, description:"页码"},
+                        num:{type:GraphQLInt, description:"每页条数"},
+                        order:{type:GraphQLInt, description:"排序"}
+                     },
                 async resolve(parentValue,args){
-                    return Db.doSql(`select * from person`);
+                    const {page=1,num=10,order="id",...queryCase}=args;
+                    const queryCaseStr=  obj2QueryCase(queryCase);
+                    return dbBaseMapper.selectPurePageList({
+                        page,
+                        num,
+                        order,
+                        queryCase:queryCaseStr})
                 }
+            },
+            total:{
+                    type: GraphQLInt,
+                    args:qlObjectTypeParams.fields,
+                    async resolve(parentValue,args){
+                        const {page=1,num=10,order="id",...queryCase}=args;
+                        const queryCaseStr=  obj2QueryCase(queryCase);
+                        return dbBaseMapper.selectCount({queryCase:queryCaseStr})
+                    }
             }
         }
     })
 
     var mutation = new GraphQLObjectType({
-        name:"Mutation",
+        name:tableName+"Mutation",
         fields:{
-            addPerson:{
+            add:{
+                type:ResponseType,
+                args:qlObjectTypeParams.fields,
+                async resolve(parenValue,args){
+                    if(generateTime){
+                        args.gmt_create=new Date().format("yyyy-MM-dd hh:mm:ss");
+                    }
+                    await dbBaseMapper.insert(args);
+                    return {code:0,msg:"success"}
+                }
+            },
+            update:{
+                type:ResponseType,
+                args:qlObjectTypeParams.fields,
+                async resolve(parenValue,args){
+                     const   {id,...updateObj}=args;
+                    if(generateTime){
+                        updateObj.gmt_modified=new Date().format("yyyy-MM-dd hh:mm:ss");
+                    }
+                     await dbBaseMapper.update(updateObj,`id=${id}`)
+                     return {code:0,msg:"success"}
+                   }
+                }
+            ,
+            delete:{
                 type:ResponseType,
-                args:{
-                    name:{type:GraphQLString}
-                },
+                args:qlObjectTypeParams.fields,
                 async resolve(parenValue,args){
-                    //await personDao.insert(args.name)
-                    return {status:0,msg:"ok"}
+                    const queryCaseStr=  obj2QueryCase(args);
+                    await dbBaseMapper.delete(queryCaseStr);
+                    return {code:0,msg:"ok"}
                 }
             }
         }

package/plugins/BaseGraphqlApi/index.js

@@ -2,13 +2,18 @@ var getGraphqlSchema= require("./getGraphqlSchema")
 const { graphqlHTTP } = require('express-graphql')
 
 class BaseGraphqlApi{
-    constructor({dbBaseMapper,prefix}) {
+    constructor({dbBaseMapper,prefix,generateTime}) {
         this.dbBaseMapper=dbBaseMapper;
         this.tableName=dbBaseMapper.tableName;
         this.prefix=prefix?prefix:tableName;
+        this.generateTime=generateTime;
     }
-    install(app,args){
-        let schema= getGraphqlSchema( this.dbBaseMapper)
+    async install(app,args){
+        let schema=await getGraphqlSchema({
+            dbBaseMapper:this.dbBaseMapper,
+            generateTime:this.generateTime}
+        );
+
         app.mapping(`/${this.prefix}`,graphqlHTTP({
             schema:schema,
             graphiql:true

package/plugins/BaseRpcApi/ApiCloudBaseRpcApi.js

@@ -32,8 +32,9 @@ class ApiCloudBaseRpcApi extends AbstractBaseRpcApi{
         num=Number.parseInt(num);
         let limit=num;
         let skip= (page-1)*num
-        let r=await this.tableClient.list(queryCase,limit,skip,"createdAt ASC");
-        return r;
+        let rows=await this.tableClient.list(queryCase,limit,skip,"createdAt ASC");
+        let countResult=await this.tableClient.count(queryCase);
+        return {rows, total:countResult.count}
     }
 
     async listAll(obj){

package/utils/common/CollectionUtils.js

@@ -23,6 +23,117 @@ class CollectionUtils{
     }
 
 
+    static list2Csv({list,titlesKeys,titlesNames}){
+        if(list==null||list.length==0){
+            return;
+        }
+        if(!titlesKeys){
+            titlesKeys=Object.keys(list[0])
+        }
+        if(!titlesNames){
+            titlesNames=titlesKeys
+        }
+        let bodyStr="";
+        list.forEach((items, index) => {
+            for(let key of titlesKeys){
+                items[key]=items[key]+"";
+                bodyStr=bodyStr+`"${!items[key]?'null': ""+items[key].replace(/\s/g,"")}"`+","
+            }
+            // console.log(bodyStr)
+            bodyStr=bodyStr+"\n";
+        })
+        return `\ufeff`+titlesNames+'\n'+bodyStr;
+    }
+
+    static n(arr,key="unionId"){
+        function n1(r1,r2,key){
+            if(r1==null || r2==null ||r1==undefined||r2==undefined || r1.length==0 || r2.length==0){
+                return []
+            }
+            let  r2keyList=r2.map(u=>u[key])
+            let result=   r1.filter(u=>r2keyList.indexOf(u[key])!==-1)
+            return result;
+        }
+        let allResult=[]
+        try{
+            if(arr==null || arr==undefined || arr.length==0){
+                return []
+            }
+            for (let i=0;i<arr.length;i++){
+                if(arr[i]==null||arr[i]==undefined||arr[i].length==0){
+                    return []
+                }
+            }
+            allResult= arr.reduce((r1,r2)=>{
+                let ri= n1(r1,r2,key)
+                if(ri==null||ri==undefined||ri.length==0){
+                    throw []
+                }
+                return ri;
+            },arr[0])
+        }catch (e){
+            allResult=e;
+        }
+        return allResult;
+    }
+
+    static u(arr,key="unionId"){
+        function u1(r1,r2,key){
+            if(r1==null && r2==null){
+                return []
+            }
+            let r=[...r1,...r2];
+            return r;
+        }
+        let allResult=[]
+        try{
+            if(arr==null || arr==undefined || arr.length==0){
+                return []
+            }
+            for (let i=0;i<arr.length;i++){
+                if(arr[i]==null||arr[i]==undefined||arr[i].length==0){
+                    return []
+                }
+            }
+            allResult= arr.reduce((r1,r2)=>{
+                let ri= u1(r1,r2,key)
+                if(ri==null||ri==undefined||ri.length==0){
+                    return [];
+                }
+                return ri;
+            },arr[0])
+        }catch (e){
+            allResult=[];
+        }
+        let  allResultKeys=allResult.map(u=>u[key]);
+        let allResult1=[];
+        let allResult1KeyObj={};
+        for (let i=0;i<allResult.length;i++){
+            let allResultObj=allResult[i];
+            let k= allResultObj[key];
+            if(allResult1KeyObj[k]){
+                continue;
+            }else {
+                allResult1.push(allResultObj);
+                allResult1KeyObj[k]=true;
+            }
+        }
+        return allResult1;
+    }
+
+    static dif(arr1,arr2,key="unionId"){
+        if(arr1==null || arr1==null|| arr1.length==0 ){
+            return []
+        }
+        if(arr2==null || arr2==null|| arr2.length==0 ){
+            return arr1;
+        }
+        let  r2keyList=arr2.map(u=>u[key])
+        let result=  arr1.filter(u=>r2keyList.indexOf(u[key])==-1)
+        return result;
+
+    }
+
 }
 
 module.exports = CollectionUtils;

package/utils/common/DateUtils.js

@@ -0,0 +1,36 @@
+
+
+class DateUtils {
+     static difDate(startDate="2021-04-01",endDate="2022-02-10"){
+        let flag = [1, 3, 5, 7, 8, 10, 12, 4, 6, 9, 11, 2];
+        let start = new Date(startDate);
+        let end = new Date(endDate);
+        let year = end.getFullYear() - start.getFullYear();
+        let month = end.getMonth() - start.getMonth();
+        let day = end.getDate() - start.getDate();
+        if (month < 0) {
+            year--;
+            month = end.getMonth() + (12 - start.getMonth());
+        }
+        if (day < 0) {
+            month--;
+            let index = flag.findIndex((temp) => {
+                return temp === start.getMonth() + 1
+            });
+            let monthLength;
+            if (index <= 6) {
+                monthLength = 31;
+            } else if (index > 6 && index <= 10) {
+                monthLength = 30;
+            } else {
+                monthLength = 28;
+            }
+            day = end.getDate() + (monthLength - start.getDate());
+        }
+        return {year,month,day}
+    }
+
+}
+
+
+module.exports = DateUtils;