ap-dev 1.1.11 → 1.1.15

package/dev/ApiPanel/menus.js

@@ -66,9 +66,12 @@ const menus = [
             }, {
                 id: 'ApiIconList',
                 label: '4.3 Icon 图标'
+            }, {
+                id: 'ApiVueUtils',
+                label: '4.4 常用工具类'
             }, {
                 id: 'ApiOtherVue',
-                label: '4.4 其他'
+                label: '4.5 其他'
             }]
     }, {
         id: 'ApiDefault',

package/dev/ApiPanel/modules/ApiGrid.vue

@@ -271,7 +271,7 @@ toolbarBtn: ["add", "edit", "del", "cancel", "refresh", "save", "separator",
         default: '无',
         memo: '添加行时对象的默认值。<br>一对象：默认值。<br>二、方法：()方法返回默认值<br><span class="api-memo">注：和列的addDefaultValue效果相同，主要处理页面不需要显示的字段的默认值。</span>',
         code: '<span class="api-code">// 1、对象形式：添加行的fdDeleted默认为0 <br>addDefaultObj: {fdDeleted:0}' +
-                    '<br>// 2、方法形式：动态返回添加行的默认值 <br>addDefaultObj: () => {fdDeleted:0}</span>'
+                    '<br>// 2、方法形式：动态返回添加行的默认值 <br>addDefaultObj: () => { return {fdDeleted:0} }</span>'
       }
     ]
     const gridAttrData_col = [

package/dev/ApiPanel/modules/ApiJavaUtils.vue

@@ -21,6 +21,7 @@ import ApiListUtil from './../tabs/ApiListUtil'
 import ApiStringUtil from './../tabs/ApiStringUtil'
 import ApiQyWxUtil from './../tabs/ApiQyWxUtil'
 import ApiJavaCommonUtil from './../tabs/ApiJavaCommonUtil'
+import ApiWebSocketUtil from './../tabs/ApiWebSocketUtil'
 
 export default {
     name: "ApiJavaUtils",
@@ -37,6 +38,7 @@ export default {
         ApiStringUtil,
         ApiQyWxUtil,
         ApiJavaCommonUtil,
+        ApiWebSocketUtil
     },
     data() {
         let opts = [
@@ -76,6 +78,9 @@ export default {
             }, {
                 label: 'CacheUtil',
                 component: 'ApiCacheUtil',
+            },{
+                label: 'WebSocketUtil',
+                component: 'ApiWebSocketUtil',
             },
         ];
         return {

package/dev/ApiPanel/modules/ApiVueUtils.vue

@@ -0,0 +1,48 @@
+<template>
+    <el-tabs v-model="activeName" tabPosition="left" class="api-tabs">
+        <template v-for="(item,index) in opts">
+            <el-tab-pane :label="item.label" :name="'tab' + index" class="api-tab">
+                <component :is="item.component"></component>
+            </el-tab-pane>
+        </template>
+    </el-tabs>
+</template>
+
+<script>
+import ApiVueDateUtil from './../tabs/ApiVueDateUtil'
+import ApiVueWebSocketUtil from './../tabs/ApiVueWebSocketUtil'
+
+export default {
+    name: "ApiJavaUtils",
+    components: {
+        ApiVueDateUtil,
+        ApiVueWebSocketUtil,
+    },
+    data() {
+        let opts = [
+            {
+                label: "DateUtil",
+                component: "ApiVueDateUtil"
+            }, {
+                label: "WebSocketUtil",
+                component: "ApiVueWebSocketUtil"
+            }
+        ];
+        return {
+            activeName: 'tab0',
+            opts: opts
+        }
+    }
+}
+</script>
+
+<style scoped>
+.api-tabs {
+    display: flex;
+    height: 100%;
+}
+.api-tabs /deep/ .el-tabs__content {
+    flex: 1;
+    overflow: scroll;
+}
+</style>

package/dev/ApiPanel/tabs/ApiApSqlCommon.vue

@@ -8,24 +8,32 @@
             1、后端代码生成：***TF<br>
             <br>
             2、组装sql<br>
-            <div class="api-code">ApSql sql = new ApSql();<br>
-                sql.select(TDemoTF.fdName,TDemoTypeTF.fdName)<br>
-                .from(TDemoTF.TDemo)<br>
-                .leftJoin(TDemoTypeTF.TDemoType)<br>
-                .on(TDemoTF.fdTypeId.eq(TDemoTypeTF.fdId))<br>
-                .where(TDemoTF.fdName.like("张%"))<br>
-                .and(TDemoTF.fdDisabled.eq(1))<br>
-                .orderBy(TDemoTF.fdName);</div>
+            <div class="api-code">
+                TDemoTF t1 = new TDemoTF();<br>
+                TDemoTypeTF t2 = new TDemoTypeTF();<br><br>
+                ApSql sql = new ApSql();<br>
+                sql.select(t1.fdName,t2.fdName)<br>
+                .from(t1.TDemo)<br>
+                .leftJoin(t2.TDemoType)<br>
+                .on(t1.fdTypeId.eq(t2.fdId))<br>
+                .where(t1.fdName.like("张%"))<br>
+                .and(t1.fdDisabled.eq(1))<br>
+                .orderBy(t1.fdName);</div>
             <br>
             3、执行sql：可返回四种类型的结果<br>
             <div class="api-code">
                 // 1、返回 HashMap 类型的list<br>
                 List&lt;HashMap> list1 = sql.execute();<br><br>
-                // 2、返回指定对象类型的list<br>
+                // 2、返回 HashMap 类型的list；分页处理<br>
+                // 参数：PageParam pp<br>
+                List&lt;HashMap> list1 = sql.execute(pp);<br><br>
+                // 3、返回指定对象类型的list<br>
                 List&lt;TDemo> list2 = sql.execute(TDemo.class);<br><br>
-                // 3、返回 HashMap （只需返回一条数据）<br>
+                // 4、返回指定对象类型的list；分页<br>
+                List&lt;TDemo> list2 = sql.execute(pp, TDemo.class);<br><br>
+                // 5、返回 HashMap （只需返回一条数据）<br>
                 HashMap obj2 = sql.executeOne();<br><br>
-                // 4、返回 指定对象 （只需返回一条数据）<br>
+                // 6、返回 指定对象 （只需返回一条数据）<br>
                 TDemo obj1 = sql.executeOne(TDemo.class);<br></div>
             <br><br>
             复杂sql示例：<br>
@@ -40,12 +48,13 @@
         <api-content>
             1、默认别名：t1、t2、...。<br>
             默认添加bean属性名称。eg：t1.fd_name as fdName<br><br>
-            2、自定义别名：【.as("****")】<br>
+            2、自定义别名：new TxxxTF("别名")<br>
             <div class="api-code">// 例：同一个表，在SQL中多次使用时需要自定义别名。<br>
-                .from(TDemoTF.TDemo)<br>
-                .leftJoin(TDemoTF.TDemo.as("d"))<br></div>
+                TDemoTF t1 = new TDemoTF("a1");<br>
+                TDemoTF t2 = new TDemoTF("a2");<br>
+            </div>
             <br>
-            <span class="api-memo">注：通常使用默认别名即可。如果自定义别名，表相应字段都需要自定义表别名。</span>
+            <span class="api-memo">注：通常使用默认别名即可。如果自定义别名，不能使用t1、t2、...防止冲突。</span>
         </api-content>
         <api-tittle2>
             三、通用说明：字段别名（select时使用）
@@ -54,19 +63,19 @@
             1、默认bean属性名称："as 属性名"<br>
             <div class="api-code">
                 // select t1.fd_name as fdName<br>
-                .select(TDemoTF.fdName)
+                .select(t1.fdName)
             </div>
             <br>
             2、存在函数时，默认添加f*："as f*"<br>
             <div class="api-code">
                 // select count(t1.fd_name) as f1<br>
-                .select(count(TDemoTF.fdName))
+                .select(count(t1.fdName))
             </div>
             <br>
             3、自定义别名：.as("****")<br>
             <div class="api-code">
                 // select t1.fd_name as name<br>
-                .select(TDemoTF.fdName.as("name"))
+                .select(t1.fdName.as("name"))
             </div>
         </api-content>
         <api-tittle2>
@@ -76,13 +85,13 @@
             1、字段和字段：<br>
             <div class="api-code">
                 // t1.fd_name= t2.fd_name<br>
-                TDemo1TF.fdName.eq(TDemo2TF.fdName)
+                t1.fdName.eq(t2.fdName)
             </div>
             <br>
             2、字段和参数，默认添加f*："as f*"<br>
             <div class="api-code">
                 // t1.fd_name= '张三'<br>
-                TDemo1TF.fdName.eq("张三")
+                t1.fdName.eq("张三")
             </div>
             <br>
         </api-content>
@@ -95,9 +104,9 @@
                 // 例：select count(f1.fd_name)<br><br>
                 // 方式1（推荐）：顶部import 静态方法<br>
                 import static com.ap.sql.ASL.count;<br>
-                .select(count(TDemoTF.fdName))<br><br>
+                .select(count(t1.fdName))<br><br>
                 // 方式2：直接调用<br>
-                .select(ASL.count(TDemoTF.fdName))
+                .select(ASL.count(t1.fdName))
             </div>
             <br>
         </api-content>
@@ -130,19 +139,22 @@ order by
 
 
 // ApSql构造
+TDemoTF t1 = new TDemoTF();
+TDemoTypeTF t2 = new TDemoTypeTF();
+
 ApSql sql = new ApSql();
-sql.select(TDemoTF.fdName,
-    substring(TDemoTF.fdName, 1 ,2),
-    TDemoTypeTF.fdName,
+sql.select(t1.fdName,
+    substring(t1.fdName, 1 ,2),
+    t2.fdName,
     custom('lower(t1.fd_en_name) as fdEnName'))
-.from(TDemoTF.TDemo)
-.leftJoin(TDemoTypeTF.TDemoType)
-.on(TDemoTF.fdTypeId.eq(TDemoTypeTF.fdId))
-.where(TDemoTF.fdDate.lt(date_format('2021-11-08', 'Y-%m-%d')))
-.andPartStart(TDemoTF.fdName.like( "张%"))
-.and(TDemoTF.fdName.like( "李%"))
+.from(t1.TDemo)
+.leftJoin(t2.TDemoType)
+.on(t1.fdTypeId.eq(t2.fdId))
+.where(t1.fdDate.lt(date_format('2021-11-08', 'Y-%m-%d')))
+.andPartStart(t1.fdName.like( "张%"))
+.and(t1.fdName.like( "李%"))
 .partEnd()
-.orderBy(TDemoTF.fdName.desc());`
+.orderBy(t1.fdName.desc());`
         return {js1}
     },
     methods: {}

package/dev/ApiPanel/tabs/ApiApSqlFunction.vue

@@ -25,74 +25,74 @@ export default {
                 name: 'count',
                 memo: `格式：count(字段) <br>说明：计数`,
                 code: `<span class="api-code">// 例：select count(t1.fd_name) f1
-.select(count(TDemoTF.fdName))</span>`
+.select(count(t1.fdName))</span>`
             }, {
                 name: 'group_concat',
                 memo: `格式：group_concat(字段) <br>说明：聚合`,
                 code: `<span class="api-code">// 例：select group_concat(t1.fd_name) f1
-.select(group_concat(TDemoTF.fdName))</span>`
+.select(group_concat(t1.fdName))</span>`
             }, {
                 name: 'date_format',
                 memo: `格式：date_format(字段, "日期格式") <br>说明：日期格式化
 <br>常用日期格式：%Y-%m-%d %H:%i:%S<br>例：2021-11-18 11:20:30`,
                 code: `<span class="api-code">// 例：select date_format(t1.fd_date, '%Y-%m-%d %H:%i:%S') f1
-.select(date_format(TDemoTF.fdDate, "%Y-%m-%d %H:%i:%S"))</span>`
+.select(date_format(t1.fdDate, "%Y-%m-%d %H:%i:%S"))</span>`
             }, {
                 name: 'sum',
                 memo: `格式：sum(字段) <br>说明：求和`,
                 code: `<span class="api-code">// 例：select sum(t1.fd_type) f1
-.select(sum(TDemoTF.fdType))</span>`
+.select(sum(t1.fdType))</span>`
             }, {
                 name: 'avg',
                 memo: `格式：avg(字段) <br>说明：平均数`,
                 code: `<span class="api-code">// 例：select avg(t1.fd_type) f1
-.select(avg(TDemoTF.fdType))</span>`
+.select(avg(t1.fdType))</span>`
             }, {
                 name: 'substring',
                 memo: `格式：avg(字段, 开始位置, 截取长度) <br>说明：字符串切割`,
                 code: `<span class="api-code">// 例：select substring(t1.fd_name, 1, 2) f1
-.select(substring(TDemoTF.fdName, 1, 2))</span>`
+.select(substring(t1.fdName, 1, 2))</span>`
             }, {
                 name: 'ifnull',
                 memo: `格式：ifnull(字段, "参数") <br>说明：判断空`,
                 code: `<span class="api-code">// 例：select ifnull(t1.fd_name,t1.fd_comment) f1
-.select(ifnull(TTestTF.fdName, TTestTF.fdComment))
+.select(ifnull(t1.fdName, t1.fdComment))
 // 例：select ifnull(t1.fd_name, '空') f1
-.select(ifnull(TTestTF.fdName, "空"))</span>`
+.select(ifnull(t1.fdName, "空"))</span>`
             }, {
                 name: 'if_',
                 memo: `格式：if(表达式, "参数", "参数") <br>说明：if为java关键字所以末端加了下划线`,
                 code: `<span class="api-code">// 例：select if(t1.fd_name='张三', '是张三', '不是张三') f1
-.select(if(TTestTF.fdName.eq("张三"), "是张三", "不是张三"))
+.select(if(t1.fdName.eq("张三"), "是张三", "不是张三"))
 // 例：select if(t1.fd_name='张三', t1.fd_comment, 'xxx') f1
-.select(if(TTestTF.fdName.eq("张三"), TTestTF.fdCommont, "xxx"))</span>`
+.select(if(t1.fdName.eq("张三"), t1.fdCommont, "xxx"))</span>`
             }, {
                 name: 'round',
                 memo: `格式：ROUND(字段) <br>说明：最近的整数(四舍五入)`,
                 code: `<span class="api-code">// 例：select round(t1.fd_count) f1
-.select(round(TTestTF.fdCount))</span>`
+.select(round(t1.fdCount))</span>`
             }, {
                 name: 'truncate',
                 memo: `格式：truncate(xx, y) <br>说明：数值 xx 保留到小数点后 y 位的值（不会进行四舍五入）`,
                 code: `<span class="api-code">// 例：select truncate(t1.fd_count, 2) f1
-.select(truncate(TTestTF.fdCount, 2))</span>`
+.select(truncate(t1.fdCount, 2))</span>`
             }, {
                 name: 'max',
                 memo: `格式：max(字段) <br>说明：最大值`,
                 code: `<span class="api-code">// 例：select max(t1.fd_count) f1
-.select(max(TTestTF.fdCount))</span>`
+.select(max(t1.fdCount))</span>`
             }, {
                 name: 'min',
                 memo: `格式：min(字段) <br>说明：最小值`,
                 code: `<span class="api-code">// 例：select min(t1.fd_count) f1
-.select(min(TTestTF.fdCount))</span>`
+.select(min(t1.fdCount))</span>`
             }, {
                 name: 'concat',
                 memo: `格式：concat(xx,yy...) <br>说明：拼接`,
                 code: `<span class="api-code">// 例：select concat(t1.fd_name, "名字", "！") f1
-.select(concat(TTestTF.fdName , "名字", "！"))
+.select(concat(t1.fdName , "名字", "！"))
 // 例：select concat(t1.fd_name, t1.fd_type) f1
-.select(concat(TTestTF.fdName , TTestTF.fdType))</span>`
+.select(concat(t1.fdName , t1.fdType))</span>`
             }, {
                 name: 'custom',
                 memo: `格式：custom("参数") <br>说明：自定义任意字符串`,

package/dev/ApiPanel/tabs/ApiApSqlKeyword.vue

@@ -27,13 +27,16 @@ export default {
 2、表别名<br>
 3、函数<br>`,
                 code: `<span class="api-code">// select示例：
-.select(
-    TDemoTF.fdName,                                    // 默认 =>  t1.fd_name as fdName
-    TDemoTF.fdName.as("name"),                  // 字段别名 =>  t1.fd_name as name,
-    TDemoTF.fdName.tableAs("temp"),           // 表别名 =>  temp.fd_name as fdName,
-    substring(TDemoTF.fdName, 1, 2),            // 函数调用 =>  substring(t1.fd_name, 1, 2) as f1
-    substring(TDemoTF.fdName, 1, 2).tableAs("temp").as("name")) // 嵌套 =>  substring(temp.fd_name, 1, 2) as name
-    .from(TDemoTF.TDemo)</span>`
+TDemoTF t1 = new TDemoTF();
+
+ApSql sql = new ApSql();
+sql.select(
+    t1.fdName,                                    // 默认 =>  t1.fd_name as fdName
+    t1.fdName.as("name"),                  // 字段别名 =>  t1.fd_name as name,
+    t1.fdName.tableAs("temp"),           // 表别名 =>  temp.fd_name as fdName,
+    substring(t1.fdName, 1, 2),            // 函数调用 =>  substring(t1.fd_name, 1, 2) as f1
+    substring(t1.fdName, 1, 2).tableAs("temp").as("name")) // 嵌套 =>  substring(temp.fd_name, 1, 2) as name
+    .from(t1.TDemo)</span>`
             }, {
                 name: 'select distinct',
                 memo: `同select`,
@@ -43,85 +46,86 @@ export default {
                 name: 'from',
                 memo: `1、表别名`,
                 code: `<span class="api-code">// 1、默认别名：t_demo t1
-.from(TDemoTF.TDemo)
+.from(t1.TDemo)
 // 2、自定义别名转为：t_demo tt
-.from(TDemoTF.TDemo).as("tt")</span>`
+TDemoTF t1 = new TDemoTF("tt");
+.from(t1.TDemo)</span>`
             }, {
                 name: 'inner join ',
                 memo: `同from`,
                 code: `<span class="api-code">// 例：from t_demo1 t1 inner join t_demo2 t2：
-.from(TDemo1TF.TDemo).innerJoin(TDemo2TF.TDemo)</span>`
+.from(t1.TDemo).innerJoin(t2.TDemo)</span>`
             }, {
                 name: 'left join ',
                 memo: `同from`,
                 code: `<span class="api-code">// 例：from t_demo1 t1 left join t_demo2 t2
-.from(TDemo1TF.TDemo).leftJoin(TDemo2TF.TDemo)</span>`
+.from(t1.TDemo).leftJoin(t2.TDemo)</span>`
             }, {
                 name: 'right join ',
                 memo: `同from`,
                 code: `<span class="api-code">// 示例：from t_demo1 t1 right join t_demo2 t2
-.from(TDemo1TF.TDemo).rightJoin(TDemo2TF.TDemo)</span>`
+.from(t1.TDemo).rightJoin(t2.TDemo)</span>`
             }, {
                 name: 'on',
                 memo: `字段连接`,
                 code: `<span class="api-code">// 1、单个条件：....on t1.fd_name= t2.fd_name
-.on(TDemo1TF.fdName.eq(TDemo2TF.fdName))
+.on(t1.fdName.eq(t2.fdName))
 // 2、多条件拼接：....on t1.fd_name= t2.fd_name and t1.fd_type=1
-.on(TDemo1TF.fdName.eq(TDemo2TF.fdName)).and(TDemo1TF.fdType.eq(1))</span>`
+.on(t1.fdName.eq(t2.fdName)).and(t1.fdType.eq(1))</span>`
             }, {
                 name: 'where',
                 memo: `where条件`,
                 code: `<span class="api-code">// 例：where t1.fd_name= '张三'
-.where(TDemoTF.fdName.eq("张三"))
+.where(t1.fdName.eq("张三"))
 //  例：where t1.fd_name= t2.fd_name
-.where(TDemo1TF.fdName.eq(TDemo2TF.fdName))</span>`
+.where(t1.fdName.eq(t2.fdName))</span>`
             }, {
                 name: 'and',
                 memo: `and`,
                 code: `<span class="api-code">// 例：and t1.fd_name= '张三'
-.and(TDemoTF.fdName.eq("张三"))
+.and(t1.fdName.eq("张三"))
 // 例：and t1.fd_name= t2.fd_name
-.and(TDemo1TF.fdName.eq(TDemo2TF.fdName))</span>`
+.and(t1.fdName.eq(t2.fdName))</span>`
             }, {
                 name: 'or',
                 memo: `or`,
                 code: `<span class="api-code">// 例：or t1.fd_name= '张三'
-.or(TDemoTF.fdName.eq("张三"))
+.or(t1.fdName.eq("张三"))
  // 例：or t1.fd_name= t2.fd_name
-.or(TDemo1TF.fdName.eq(TDemo2TF.fdName))</span>`
+.or(t1.fdName.eq(t2.fdName))</span>`
             }, {
                 name: 'andPartStart',
                 memo: `带括号形式：and ()`,
                 code: `<span class="api-code">// 例：and ( t1.fd_name like '%张%' or t1.fd_name like '%李%')
-.andPartStart(TDemoTF.fdName.like("%张%")).or(TDemoTF.fdName.like("%李%")).partEnd()</span>`
+.andPartStart(t1.fdName.like("%张%")).or(t1.fdName.like("%李%")).partEnd()</span>`
             }, {
                 name: 'orPartStart',
                 memo: `带括号形式：or ()`,
                 code: `<span class="api-code">// 例：or ( t1.fd_name like '%张%' or t1.fd_name like '%李%')
-.orPartStart(TDemoTF.fdName.like("%张%")).or(TDemoTF.fdName.like("%李%")).partEnd()</span>`
+.orPartStart(t1.fdName.like("%张%")).or(t1.fdName.like("%李%")).partEnd()</span>`
             }, {
                 name: 'groupBy',
                 memo: `group by`,
                 code: `<span class="api-code">// 例：group by t1.fd_name
-.groupBy(TDemoTF.fdName)
+.groupBy(t1.fdName)
  // 例：group by t1.fd_name, t1.fd_type
-.groupBy(TDemoTF.fdName, TDemoTF.fdType)</span>`
+.groupBy(t1.fdName, t1.fdType)</span>`
             }, {
                 name: 'having',
                 memo: `having`,
                 code: `<span class="api-code">// 例：having t1.fd_name= '张三'
-.having(TDemoTF.fdName.eq("张三"))
+.having(t1.fdName.eq("张三"))
 // 例：having t1.fd_name= '张三' and t1.fd_type = 1
-.having(TDemoTF.fdName.eq("张三")).and(TDemoTF.fdType.eq(1))</span>`
+.having(t1.fdName.eq("张三")).and(t1.fdType.eq(1))</span>`
             }, {
                 name: 'orderBy',
                 memo: `order by<br> 默认升序：asc`,
                 code: `<span class="api-code">// 例：order by t1.fd_name
-.orderBy(TDemoTF.fdName)
+.orderBy(t1.fdName)
  // 例：order by t1.fd_name, t1.fd_type
-.orderBy(TDemoTF.fdName, TDemoTF.fdType)
+.orderBy(t1.fdName, t1.fdType)
  // 例：order by t1.fd_name asc, t1.fd_type desc
-.orderBy(TDemoTF.fdName.asc(), TDemoTF.fdType.desc())</span>`
+.orderBy(t1.fdName.asc(), t1.fdType.desc())</span>`
             }, {
                 name: 'limit',
                 memo: `limit`,

package/dev/ApiPanel/tabs/ApiApSqlOperate.vue

@@ -25,67 +25,67 @@ export default {
                 name: '=',
                 memo: `格式：字段.eq("参数") <br>说明：等于。参数可以是字段`,
                 code: `<span class="api-code">// 例：t1.fd_name = "张三"
-TDemoTF.fdName.eq("张三")
+t1.fdName.eq("张三")
 // 例：t1.fd_name = t2.fd_name
-TDemo1TF.fdName.eq(TDemo2TF.fdName)</span>`
+t1.fdName.eq(t2.fdName)</span>`
             }, {
                 name: '!=',
                 memo: `格式：字段.notEq("参数") <br>说明：不等于。参数可以是字段`,
                 code: `<span class="api-code">// 例：t1.fd_name != "张三"
-TDemoTF.fdName.notEq("张三")
+t1.fdName.notEq("张三")
 // 例：t1.fd_name != t2.fd_name
-TDemo1TF.fdName.notEq(TDemo2TF.fdName)</span>`
+t1.fdName.notEq(t2.fdName)</span>`
             }, {
                 name: '<',
                 memo: `格式：字段.lt("参数") <br>说明：小于。参数可以是字段`,
                 code: `<span class="api-code">// 例：t1.fd_count < 1
-TDemoTF.fdCount.lt(1)</span>`
+t1.fdCount.lt(1)</span>`
             }, {
                 name: '<=',
                 memo: `格式：字段.ltEq("参数") <br>说明：小于等于。参数可以是字段`,
                 code: `<span class="api-code">// 例：t1.fd_count <= 1
-TDemoTF.fdCount.ltEq(1)</span>`
+t1.fdCount.ltEq(1)</span>`
             }, {
                 name: '>',
                 memo: `格式：字段.gt("参数") <br>说明：大于。参数可以是字段`,
                 code: `<span class="api-code">// 例：t1.fd_count > 1
-TDemoTF.fdCount.gt(1)</span>`
+t1.fdCount.gt(1)</span>`
             }, {
                 name: '>=',
                 memo: `格式：字段.gtEq("参数") <br>说明：大于等于。参数可以是字段`,
                 code: `<span class="api-code">// 例：t1.fd_count >= 1
-TDemoTF.fdCount.gtEq(1)</span>`
+t1.fdCount.gtEq(1)</span>`
             }, {
                 name: 'like',
                 memo: `格式：字段.like("参数") <br>说明：like`,
                 code: `<span class="api-code">// 例：t1.fd_name like "张%"
-TDemoTF.fdCount.like("张%")</span>`
+t1.fdCount.like("张%")</span>`
             }, {
                 name: 'is null',
                 memo: `格式：字段.isNull() <br>说明：为空`,
                 code: `<span class="api-code">// 例：t1.fd_name is null
-TDemoTF.fdCount.isNull()</span>`
+t1.fdCount.isNull()</span>`
             }, {
                 name: 'is not null',
                 memo: `格式：字段.isNotNull() <br>说明：不为空`,
                 code: `<span class="api-code">// 例：t1.fd_name is not null
-TDemoTF.fdCount.isNotNull()</span>`
+t1.fdCount.isNotNull()</span>`
             }, {
                 name: 'in',
                 memo: `格式：字段.in("参数","参数"...) <br>说明：包含。<br>参数可以是多个。<br>参数可以是list`,
                 code: `<span class="api-code">// 例：t1.fd_type in (1, 2, 3)
-TDemoTF.fdType.in(1, 2, 2)
+t1.fdType.in(1, 2, 2)
 // 例：t1.fd_type in (1, 2, 3)
 List list = new ArrayList<Integer>();
 list.add(1);
 list.add(2);
 list.add(3);
-TDemoTF.fdType.in(list)</span>`
+t1.fdType.in(list)</span>`
             }, {
                 name: 'between and',
                 memo: `格式：字段.between() <br>说明：不为空`,
                 code: `<span class="api-code">// 例：t1.fd_type between 1 and 3
-TDemoTF.fdType.between(1, 3)</span>`
+t1.fdType.between(1, 3)</span>`
             }
         ]
 

package/dev/ApiPanel/tabs/ApiVueDateUtil.vue

@@ -0,0 +1,44 @@
+<template>
+    <div style="height: 100%">
+        <h3>日期工具类 - DateUtil</h3>
+        <api-table :data="methodData" :columns="methodCols"/>
+    </div>
+</template>
+
+<script>
+import {ApiCode, ApiContent, ApiTable, ApiTittle1, ApiTittle2} from './../components'
+
+export default {
+    name: 'ApiStringUtil',
+    components: {
+        ApiTable, ApiCode, ApiTittle1, ApiContent, ApiTittle2
+    },
+    data() {
+        const methodCols = [
+            {label: '方法名', prop: 'name', width: '220px'},
+            {label: '说明', prop: 'memo', width: '300px'},
+            {label: '示例代码', prop: 'code', minWidth: '100px'}]
+        const methodData = [
+            {
+                name: 'formatDate',
+                memo: `格式化日期<br><span class="api-memo">格式：yyyy-MM-dd hh:mm:ss。</span>`,
+                code: `<span class="api-code">// 1、导入方法
+import {formatDate} from 'ap-util/util/DateUtil';
+
+// 2、调用
+let str = formatDate(new Date(), 'yyyy-MM-dd hh:mm:ss');
+</span>`
+            }
+        ]
+
+        return {
+            methodData,
+            methodCols
+        }
+    },
+    methods: {}
+}
+</script>
+
+<style scoped>
+</style>