初版1.0

.gitignore

@@ -0,0 +1,26 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+stats.html
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+!.vscode/settings.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

app.js

@@ -1,36 +1,44 @@
-const express = require('express');
-const bodyparser = require('body-parser'); //body中间件
-const cors = require('cors'); //解决跨域的中间件
-const utils = require("./utils/index.js");
-const {errLog}= require("./utils/err");
-const server = express();
-server.listen(3000);
-server.use(cors({origin: "*",}));
-server.use(express.static('./public')); //用户的静态资源
-server.use(bodyparser.json());
+const express = require('express')
+const bodyparser = require('body-parser') //body中间件
+const cors = require('cors') //解决跨域的中间件
+const utils = require('./utils/index.js')
+const { errLog } = require('./utils/err')
+const server = express()
+server.listen(8899)
+server.use(cors({ origin: '*' }))
+server.use(express.static('./public')) //用户的静态资源
+server.use(bodyparser.json())
 // server.use(bodyparser.urlencoded({//body中间件
 // 	extended:false
 // }));
-server.use(async function (req, res, next)  {
-	if(req.headers.token){
-		let user=await utils.getUserInfo({req,res});
-		if(user.status===0) return res.send(utils.returnData({code: 203, msg: "你账号已被禁用，请联系管理员！！",req}));
-	}
-	next();
+server.use(async function (req, res, next) {
+  if (req.headers.token) {
+    let user = await utils.getUserInfo({ req, res })
+    if (user.status === 0) return res.send(utils.returnData({ code: 203, msg: '你账号已被禁用，请联系管理员！！', req }))
+  }
+  next()
 })
-process.on('unhandledRejection', (err, test) => {
-	errLog({err,code:500,msg:"后端系统错误！",funName:"fatal"});
-	}).on('uncaughtException', err => {
-	errLog({err,code:500,msg:"后端系统错误！！",funName:"fatal"});
-	});
-const adminRouter = require('./router/system/admin.js'); //管理菜单等路由
-const fileRouter = require('./router/system/file.js'); //文件等路由
-const testsRouter=require("./router/tests.js");//测试信息路由
-const componentsRouter=require("./router/components.js");//测试信息路由
-const annotationRouter=require("./router/annotation/bigEntity.js");//测试信息路由
-server.use('/admin', adminRouter);
-server.use('/file', fileRouter);
-server.use("/tests",testsRouter);
-server.use("/components",componentsRouter);
-server.use("/annotation",annotationRouter);
-console.log('后端接口启动成功');
+process
+  .on('unhandledRejection', (err, test) => {
+    errLog({ err, code: 500, msg: '后端系统错误！', funName: 'fatal' })
+  })
+  .on('uncaughtException', (err) => {
+    errLog({ err, code: 500, msg: '后端系统错误！！', funName: 'fatal' })
+  })
+const adminRouter = require('./router/system/admin.js') //管理菜单等路由
+const fileRouter = require('./router/system/file.js') //文件等路由
+const testsRouter = require('./router/tests.js') //测试信息路由
+const componentsRouter = require('./router/components.js')
+const entityRouter = require('./router/dataMark/entity.js')
+const relationshipRouter = require('./router/dataMark/relationship.js')
+const datasetRouter = require('./router/dataMark/dataset.js')
+const dataMarkRouter = require('./router/dataMark/dataMark.js')
+server.use('/admin', adminRouter)
+server.use('/file', fileRouter)
+server.use('/tests', testsRouter)
+server.use('/components', componentsRouter)
+server.use('/entity', entityRouter)
+server.use('/relationship', relationshipRouter)
+server.use('/dataset', datasetRouter)
+server.use('/dataMark', dataMarkRouter)
+console.log('后端接口启动成功')

logs/error.2024-03-28.log

@@ -1,68 +0,0 @@
-{"date":"2024-03-28 15:32:08","type":"ERROR","data":"{
-  err: Error: ER_PARSE_ERROR: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'describe,is_show FROM entity_big WHERE 1=1 ORDER BY id DESC LIMIT 0,10' at line 1
-      at Query.Sequence._packetToError (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\sequences\Sequence.js:47:14)
-      at Query.ErrorPacket (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\sequences\Query.js:79:18)
-      at Protocol._parsePacket (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Protocol.js:291:23)
-      at Parser._parsePacket (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Parser.js:433:10)
-      at Parser.write (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Parser.js:43:10)
-      at Protocol.write (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Protocol.js:38:16)
-      at Socket.<anonymous> (F:\workspace\annotations\APP\node_modules\mysql\lib\Connection.js:88:28)
-      at Socket.<anonymous> (F:\workspace\annotations\APP\node_modules\mysql\lib\Connection.js:526:10)
-      at Socket.emit (node:events:513:28)
-      at addChunk (node:internal/streams/readable:315:12)
-      --------------------
-      at Pool.query (F:\workspace\annotations\APP\node_modules\mysql\lib\Pool.js:199:23)
-      at F:\workspace\annotations\APP\utils\pools.js:13:14
-      at new Promise (<anonymous>)
-      at pools (F:\workspace\annotations\APP\utils\pools.js:12:12)
-      at F:\workspace\annotations\APP\router\annotation\bigEntity.js:28:26
-      at processTicksAndRejections (node:internal/process/task_queues:96:5) {
-    code: 'ER_PARSE_ERROR',
-    errno: 1064,
-    sqlMessage: "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'describe,is_show FROM entity_big WHERE 1=1 ORDER BY id DESC LIMIT 0,10' at line 1",
-    sqlState: '42000',
-    index: 0,
-    sql: 'SELECT name,describe,is_show FROM entity_big WHERE 1=1 ORDER BY id DESC LIMIT 0,10'
-  },
-  code: -1,
-  msg: '服务器异常！',
-  portName: '/annotation/getBigEntityList',
-  body: { page: 1, size: 10 },
-  query: {},
-  method: 'POST'
-}"} 
-
-{"date":"2024-03-28 15:32:12","type":"ERROR","data":"{
-  err: Error: ER_PARSE_ERROR: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'describe,is_show FROM entity_big WHERE 1=1 ORDER BY id DESC LIMIT 0,10' at line 1
-      at Query.Sequence._packetToError (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\sequences\Sequence.js:47:14)
-      at Query.ErrorPacket (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\sequences\Query.js:79:18)
-      at Protocol._parsePacket (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Protocol.js:291:23)
-      at Parser._parsePacket (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Parser.js:433:10)
-      at Parser.write (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Parser.js:43:10)
-      at Protocol.write (F:\workspace\annotations\APP\node_modules\mysql\lib\protocol\Protocol.js:38:16)
-      at Socket.<anonymous> (F:\workspace\annotations\APP\node_modules\mysql\lib\Connection.js:88:28)
-      at Socket.<anonymous> (F:\workspace\annotations\APP\node_modules\mysql\lib\Connection.js:526:10)
-      at Socket.emit (node:events:513:28)
-      at addChunk (node:internal/streams/readable:315:12)
-      --------------------
-      at Pool.query (F:\workspace\annotations\APP\node_modules\mysql\lib\Pool.js:199:23)
-      at F:\workspace\annotations\APP\utils\pools.js:13:14
-      at new Promise (<anonymous>)
-      at pools (F:\workspace\annotations\APP\utils\pools.js:12:12)
-      at F:\workspace\annotations\APP\router\annotation\bigEntity.js:28:26
-      at processTicksAndRejections (node:internal/process/task_queues:96:5) {
-    code: 'ER_PARSE_ERROR',
-    errno: 1064,
-    sqlMessage: "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'describe,is_show FROM entity_big WHERE 1=1 ORDER BY id DESC LIMIT 0,10' at line 1",
-    sqlState: '42000',
-    index: 0,
-    sql: 'SELECT name,describe,is_show FROM entity_big WHERE 1=1 ORDER BY id DESC LIMIT 0,10'
-  },
-  code: -1,
-  msg: '服务器异常！',
-  portName: '/annotation/getBigEntityList',
-  body: { page: 1, size: 10 },
-  query: {},
-  method: 'POST'
-}"} 
-

logs/error.2024-03-29.log

@@ -1,10 +0,0 @@
-{"date":"2024-03-29 15:05:10","type":"ERROR","data":"{
-  err: undefined,
-  code: 203,
-  msg: '登陆失效，请重新登陆！',
-  portName: '/admin/getUserInfo',
-  body: {},
-  query: {},
-  method: 'POST'
-}"} 
-

logs/fatal.2024-02-21.log

@@ -1,40 +0,0 @@
-{"date":"2024-02-21 17:30:14","type":"FATAL","data":"{
-  err: false,
-  code: 500,
-  msg: '后端系统错误！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-02-21 17:51:55","type":"FATAL","data":"{
-  err: false,
-  code: 500,
-  msg: '后端系统错误！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-02-21 18:17:25","type":"FATAL","data":"{
-  err: ReferenceError: user is not defined
-      at F:\workspace\annotations\APP\router\annotation\bigEntity.js:12:20
-      at Layer.handle [as handle_request] (F:\workspace\annotations\APP\node_modules\express\lib\router\layer.js:95:5)
-      at next (F:\workspace\annotations\APP\node_modules\express\lib\router\route.js:144:13)
-      at Route.dispatch (F:\workspace\annotations\APP\node_modules\express\lib\router\route.js:114:3)
-      at Layer.handle [as handle_request] (F:\workspace\annotations\APP\node_modules\express\lib\router\layer.js:95:5)
-      at F:\workspace\annotations\APP\node_modules\express\lib\router\index.js:284:15
-      at Function.process_params (F:\workspace\annotations\APP\node_modules\express\lib\router\index.js:346:12)
-      at next (F:\workspace\annotations\APP\node_modules\express\lib\router\index.js:280:10)
-      at Function.handle (F:\workspace\annotations\APP\node_modules\express\lib\router\index.js:175:3)
-      at router (F:\workspace\annotations\APP\node_modules\express\lib\router\index.js:47:12),
-  code: 500,
-  msg: '后端系统错误！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-

logs/fatal.2024-03-28.log

@@ -1,78 +0,0 @@
-{"date":"2024-03-28 14:23:30","type":"FATAL","data":"{
-  err: Error: listen EADDRINUSE: address already in use :::3000
-      at Server.setupListenHandle [as _listen2] (node:net:1872:16)
-      at listenInCluster (node:net:1920:12)
-      at Server.listen (node:net:2008:7)
-      at Function.listen (F:\workspace\annotations\APP\node_modules\express\lib\application.js:635:24)
-      at Object.<anonymous> (F:\workspace\annotations\APP\app.js:7:8)
-      at Module._compile (node:internal/modules/cjs/loader:1233:14)
-      at Module._extensions..js (node:internal/modules/cjs/loader:1287:10)
-      at Module.load (node:internal/modules/cjs/loader:1091:32)
-      at Module._load (node:internal/modules/cjs/loader:938:12)
-      at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:83:12) {
-    code: 'EADDRINUSE',
-    errno: -4091,
-    syscall: 'listen',
-    address: '::',
-    port: 3000
-  },
-  code: 500,
-  msg: '后端系统错误！！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-03-28 14:34:22","type":"FATAL","data":"{
-  err: Error: listen EADDRINUSE: address already in use :::3000
-      at Server.setupListenHandle [as _listen2] (node:net:1463:16)
-      at listenInCluster (node:net:1511:12)
-      at Server.listen (node:net:1599:7)
-      at Function.listen (F:\workspace\annotations\APP\node_modules\express\lib\application.js:635:24)
-      at Object.<anonymous> (F:\workspace\annotations\APP\app.js:7:8)
-      at Module._compile (node:internal/modules/cjs/loader:1196:14)
-      at Object.Module._extensions..js (node:internal/modules/cjs/loader:1250:10)
-      at Module.load (node:internal/modules/cjs/loader:1074:32)
-      at Function.Module._load (node:internal/modules/cjs/loader:909:12)
-      at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12) {
-    code: 'EADDRINUSE',
-    errno: -4091,
-    syscall: 'listen',
-    address: '::',
-    port: 3000
-  },
-  code: 500,
-  msg: '后端系统错误！！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-03-28 14:42:12","type":"FATAL","data":"{
-  err: Error: listen EADDRINUSE: address already in use :::3000
-      at Server.setupListenHandle [as _listen2] (node:net:1463:16)
-      at listenInCluster (node:net:1511:12)
-      at Server.listen (node:net:1599:7)
-      at Function.listen (F:\workspace\annotations\APP\node_modules\express\lib\application.js:635:24)
-      at Object.<anonymous> (F:\workspace\annotations\APP\app.js:7:8)
-      at Module._compile (node:internal/modules/cjs/loader:1196:14)
-      at Object.Module._extensions..js (node:internal/modules/cjs/loader:1250:10)
-      at Module.load (node:internal/modules/cjs/loader:1074:32)
-      at Function.Module._load (node:internal/modules/cjs/loader:909:12)
-      at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12) {
-    code: 'EADDRINUSE',
-    errno: -4091,
-    syscall: 'listen',
-    address: '::',
-    port: 3000
-  },
-  code: 500,
-  msg: '后端系统错误！！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-

logs/fatal.2024-03-29.log

@@ -1,72 +0,0 @@
-{"date":"2024-03-29 15:11:18","type":"FATAL","data":"{
-  err: ReferenceError: Cannot access 'name' before initialization
-      at F:\workspace\annotations\APP\router\system\admin.js:93:49
-      at Array.map (<anonymous>)
-      at filterAsyncRoutes (F:\workspace\annotations\APP\router\system\admin.js:82:13)
-      at F:\workspace\annotations\APP\router\system\admin.js:102:23
-      at Array.map (<anonymous>)
-      at filterAsyncRoutes (F:\workspace\annotations\APP\router\system\admin.js:82:13)
-      at F:\workspace\annotations\APP\router\system\admin.js:124:22
-      at processTicksAndRejections (node:internal/process/task_queues:96:5),
-  code: 500,
-  msg: '后端系统错误！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-03-29 15:14:51","type":"FATAL","data":"{
-  err: F:\workspace\annotations\APP\router\system\admin.js:103
-              children: {...sss, objs.name + 1}
-                                     ^
-  
-  SyntaxError: Unexpected token '.'
-      at Object.compileFunction (node:vm:360:18)
-      at wrapSafe (node:internal/modules/cjs/loader:1124:15)
-      at Module._compile (node:internal/modules/cjs/loader:1160:27)
-      at Object.Module._extensions..js (node:internal/modules/cjs/loader:1250:10)
-      at Module.load (node:internal/modules/cjs/loader:1074:32)
-      at Function.Module._load (node:internal/modules/cjs/loader:909:12)
-      at Module.require (node:internal/modules/cjs/loader:1098:19)
-      at require (node:internal/modules/cjs/helpers:108:18)
-      at Object.<anonymous> (F:\workspace\annotations\APP\app.js:26:21)
-      at Module._compile (node:internal/modules/cjs/loader:1196:14),
-  code: 500,
-  msg: '后端系统错误！！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-03-29 15:14:58","type":"FATAL","data":"{
-  err: TypeError: Found non-callable @@iterator
-      at F:\workspace\annotations\APP\router\system\admin.js:111:23
-      at Array.map (<anonymous>)
-      at filterAsyncRoutes (F:\workspace\annotations\APP\router\system\admin.js:82:13)
-      at F:\workspace\annotations\APP\router\system\admin.js:125:22
-      at processTicksAndRejections (node:internal/process/task_queues:96:5),
-  code: 500,
-  msg: '后端系统错误！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-
-{"date":"2024-03-29 15:21:23","type":"FATAL","data":"{
-  err: ReferenceError: Cannot access 'objs' before initialization
-      at F:\workspace\annotations\APP\router\system\admin.js:85:15
-      at Array.map (<anonymous>)
-      at filterAsyncRoutes (F:\workspace\annotations\APP\router\system\admin.js:82:13)
-      at F:\workspace\annotations\APP\router\system\admin.js:131:22
-      at processTicksAndRejections (node:internal/process/task_queues:96:5),
-  code: 500,
-  msg: '后端系统错误！',
-  portName: undefined,
-  body: undefined,
-  query: undefined,
-  method: undefined
-}"} 
-

pool.js

@@ -1,11 +1,13 @@
-const mysql=require("mysql");
-const pool=mysql.createPool({
-	host:"127.0.0.1",
-	port:3306,
-	user:"root",
-	password:"123456zxc",
-	database:"annotations",
-	connectionLimit:15,
-	dateStrings:true
-});
-module.exports=pool;
+const mysql = require('mysql')
+const pool = mysql.createPool({
+  // host: '127.0.0.1',
+  host: 'localhost',
+  port: 3306,
+  user: 'root',
+  // password: '123456zxc',
+  password: '010203zx',
+  database: 'data_mark',
+  connectionLimit: 15,
+  dateStrings: true
+})
+module.exports = pool

public/uploadFile/1737555127172009622597674842548-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/173755531385807796971039481964-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/17375554044250046972020041044615-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/1737555590626034250071013769934-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/173755581664406703068091808397-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/1737555887426019067397959453936-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/173755667319003976376697455599-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/173755679925206271054479920255-标注数据.txt

@@ -0,0 +1,10 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头

public/uploadFile/173886756868703616209111963975-标注数据.txt

@@ -0,0 +1,12 @@
+套管渗油、油位异常现象：套管表面渗漏有油渍。套管油位异常下降或者升高。处理原则：套管严重渗漏或者外绝缘破裂，需要更换时，向值班调控人员申请停运处理。套管油位异常时，应利用红外测温装置等方法检测油位，确认套管发生内漏需要处理时，向值班调控人员申请停运处理。
+211号汽车故障报告综合情况:故障现象:开暖风鼓风机运转时有异常响声。故障原因简要分析:该故障是鼓风机运转时有异响由此可以判断可能原因：1鼓风机故障 2鼓风机内有杂物
+365号汽车故障报告故障现象关车门时左车门会发出“崩崩”的响声。故障原因简要分析根据发出的声音推断应该是车门铁皮颤抖发出的声音.拆下左内护板及玻璃支架发现左前门防撞梁开胶；打胶加固防撞梁后关门声音正常；维修方案打胶加固防撞梁故障排除。
+故障现象：转向时有“咯噔”声原因分析：转向机与转向轴处缺油解决措施：向此处重新覆盖一层润滑脂后，故障消失
+地面分注井井口套管注水正常，而油管注不进去水是什么原因?如何处理?答：原因分析：①生产闸门或油管控制水量闸门没有打开或者闸板脱。②油管水表有堵塞现象。③油压高过泵压，使油管不能正常注水。处理方法：①检查流程是否正确，判断闸板脱的进行更换。②冲洗水表把调水闸门关闭后，再开大，重复几次，进行判断，如还不能恢复正常，需要进行更换水表。③关闭控制水量闸门，防止因单流阀不严，造成水表倒转。
+故障现象抽油杆偏磨，井口盘根漏油。故障原因(1)抽油机安装质量不合格，使驴头与井口不对中。(2)抽油机井生产过程中发生断连杆、曲柄销脱出等，导致游梁扭偏。(3)抽油机基础倾斜或修井过程中将采油树拉歪等。处理方法(1)调整抽油底盘或基础。(2)调整游梁顶丝使驴头与井口达到对中标准。
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。故障分析遥控器失效，首先应检查遥控器电池，电压正常。为保险起见，还是更换新的电池，但仍然不能开启车门。故障排除处理舒适系统天线搭铁故障，遥控器功能恢复，故障排除。
+"463号汽车故障报告故障现象发动机启动后怠速不稳，抖动厉害，排气管口有连续的突突声故障原因点火线圈插接头接触不良造成。诊断排除1、用断火法检查各缸工作情况，发现一、四缸不工作，无高压火；2、再检查火点线圈，发现一、四缸的低压点火线圈插接头输入接头松动。3、重新调整后，上述故障现象消失。
+发动机动力不足，高速行驶无力，由于油管上端固定不良导致油管下沉塑性变形，油管截面变小，影响供油量。原地怠速时，测量发动机油压数据正常。在车辆中低速行驶时，发动机燃油消耗量不大，车辆可以正常行驶。在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+737号汽车故障报告故障现象整车及动力电池故障灯亮故障分析1、整车及动力电池故障灯亮，报单体电压过低；2、经拆包检查发现从控采集电压插头接触不良；3、对从控采集插头重新拔插后车辆信息正常，故障排除。故障点从控采集电压插头
+在车辆中高速行驶时，发动机燃油消耗量增大，此时供油跟不上发动机消耗，导致动力不足
+899号汽车故障报告故障现象一辆PASSAT-1.8L舒适型轿车，行驶里程92000km。该车中控正常，用遥控器不能打开车门，只能用钥匙开车门。

router/annotation/bigEntity.js

@@ -1,36 +0,0 @@
-const express = require('express')
-const router = express.Router()
-const utils = require('../../utils/index.js')
-const pools = require('../../utils/pools.js')
-
-// 增加实体大类
-router.post('/addBigEntity', async (req, res) => {
-  let sql = 'INSERT INTO entity_big(`name`,`introduce`,is_show) VALUES (?,?,?)',
-    obj = req.body
-  await pools({
-    sql,
-    val: [obj.name, obj.introduce, obj.is_show],
-    run: false,
-    res,
-    req
-  })
-})
-//查询大类
-router.post('/getBigEntityList', async (req, res) => {
-  let user = await utils.getUserInfo({ req, res }),
-    obj = req.body
-  let sql = `SELECT id AS Id,name,introduce,is_show,parent_id AS parentId,has_children AS hasChildren FROM entity_big WHERE 1=1` // WHERE 1=1是一个始终为真的条件，后续动态添加查询条件的起点
-  sql = utils.setLike(sql, 'name', obj.name) // 添加一个基于name字段的模糊匹配条件，匹配的值来自obj.name
-  sql = utils.setMoreId(sql, user)
-  let { total } = await utils.getSum({ sql, name: 'entity_big', res, req }) // 执行SQL查询并获取结果中的总数
-  sql += ` ORDER BY id DESC` // 在SQL查询语句的末尾添加了一个ORDER BY子句，用于根据id字段降序排序结果
-  sql = utils.pageSize(sql, obj.page, obj.size) // 函数来修改SQL语句，添加分页功能。它使用obj.page和obj.size来确定返回结果的范围。
-  let { result } = await pools({ sql, res, req })
-  //   result = result.map((item) => ({
-  //     ...item,
-  //     hasChildren: item.hasChildren === 1 // 或者使用 Boolean(item.hasChildren) 如果hasChildren是数字类型
-  //   }))
-  res.send(utils.returnData({ data: result, total }))
-})
-
-module.exports = router

router/dataMark/dataMark.js

@@ -0,0 +1,14 @@
+const express = require('express')
+const router = express.Router()
+const utils = require('../../utils/index.js')
+const pools = require('../../utils/pools.js')
+
+// 修改标注结果数据
+router.post('/updataMarkInfo', async (req, res) => {
+  console.log("req.body",req);
+  
+  let sql = 'UPDATE mark_data_t SET markInfo=?,state=? WHERE id=?' ,obj = req.body
+  await pools({ sql, val: [JSON.stringify(obj.markInfo),obj.state, obj.id], run: false, res, req })
+})
+
+module.exports = router

router/dataMark/dataset.js

@@ -0,0 +1,259 @@
+const express = require('express')
+const router = express.Router()
+const utils = require('../../utils/index.js')
+const pools = require('../../utils/pools.js')
+const xlsx = require('node-xlsx')
+const fs = require('fs')
+const path = require('path')
+const fileEvent = require('../../utils/file')
+const execTransection = require('../../utils/dbHelper.js')
+const datetimeToTime = require('../../utils/tool.js')
+const uuid = require('uuid')
+// 增加数据集
+router.post('/addDataset', async (req, res) => {
+  let sql = 'INSERT INTO dataset_t(`name`,creator_id) VALUES (?,?)',
+    obj = req.body
+  await utils.existName({
+    sql: 'SELECT name FROM dataset_t WHERE name=?',
+    name: obj.name,
+    res,
+    msg: '该数据集名称已存在！',
+    req
+  })
+  await pools({
+    sql,
+    val: [obj.name, obj.creatorId],
+    run: false,
+    res,
+    req
+  })
+})
+
+//查询
+router.post('/getDatasetList', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res }),
+    obj = req.body
+  let sql = `SELECT 
+    d.id,
+    d.name,
+    d.creator_id AS creatorId,
+    u.name as creatorName,
+    (SELECT count(*) from mark_data_t m where m.dataset_id = d.id AND m.state=1) as marked,
+    (SELECT count(*) from mark_data_t m where m.dataset_id = d.id) as totalNumber
+  FROM 
+    dataset_t d JOIN user u ON d.creator_id = u.id WHERE 1=1` // WHERE 1=1是一个始终为真的条件，后续动态添加查询条件的起点 JOIN mark_data_t m ON d.id = m.dataset_id
+  sql = utils.setLike(sql, 'd.name', obj.name) // 添加一个基于name字段的模糊匹配条件，匹配的值来自obj.name
+  sql = utils.setMoreId(sql, user)
+  let { total } = await utils.getSum({ sql, name: 'dataset_t d', res, req }) // 执行SQL查询并获取结果中的总数
+  sql = utils.pageSize(sql, obj.page, obj.size) // 函数来修改SQL语句，添加分页功能。它使用obj.page和obj.size来确定返回结果的范围。
+  let { result } = await pools({ sql, res, req })
+  res.send(utils.returnData({ data: result, total }))
+})
+
+// 编辑
+router.post('/updataDataset', async (req, res) => {
+  let sql = 'UPDATE dataset_t SET name=? WHERE id=?',
+    obj = req.body
+  await pools({ sql, val: [obj.name, obj.id], run: false, res, req })
+})
+
+//删除
+router.post('/delDataset', async (req, res) => {
+  obj = req.body
+  let placeholders = obj.map(() => '?').join(',')
+  let sql = `DELETE FROM dataset_t WHERE id in (${placeholders})`
+  await pools({ sql, val: obj, run: false, res, req }) // 注意这里直接传递obj数组作为参数
+})
+
+// 查询导入记录
+router.post('/getImportRecord', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res })
+  obj = req.body
+  console.log('req.body', req.body)
+  let sql = `SELECT 
+    f.id,
+    f.name,
+    (SELECT name from user u where f.importer_id = u.id) as importerName,
+    f.time,
+    f.data_volume
+  FROM 
+  file_import_t f WHERE f.dataset_id = ?`
+  sql = utils.setLike(sql, 'name', obj.name)
+  sql = utils.setMoreId(sql, user)
+  let { total } = await utils.getSumWhere({ sql: '', val: [obj.dataset_id], name: 'file_import_t f', res, req })
+  sql = utils.pageSize(sql, obj.page, obj.size)
+  let { result } = await pools({ sql, val: [obj.dataset_id], req })
+  res.send(utils.returnData({ data: result, total }))
+})
+
+// 查询数据集数据
+router.post('/getDataList', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res })
+  obj = req.body
+  let sql = `SELECT * FROM mark_data_t WHERE dataset_id=?`
+  sql = utils.setLike(sql, 'text', obj.text)
+  sql = utils.setMoreId(sql, user)
+  let { total } = await utils.getSumWhere({ sql, val: [obj.dataset_id], name: 'mark_data_t', res, req })
+  sql = utils.pageSize(sql, obj.page, obj.size)
+  let { result } = await pools({ sql, val: [obj.dataset_id], req })
+  res.send(utils.returnData({ data: result, total }))
+})
+
+// 查看单条数据
+router.post('/getData', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res })
+  obj = req.body
+  let sql = `SELECT * FROM mark_data_t WHERE dataset_id=? AND id=?`
+  sql = utils.setMoreId(sql, user)
+  let { result } = await pools({ sql, val: [obj.dataset_id, obj.id], req })
+  res.send(utils.returnData({ data: result }))
+})
+
+// 导入数据
+router.post('/importData', async (req, res) => {
+  let fileArr = await fileEvent(req, res)
+  let filename = fileArr[0].filename
+  const fileType = req.files[0].mimetype
+  let list
+  //配置获取文件路径
+  if (fileType.includes('text')) {
+    const path = `public/uploadFile/${filename}`
+    fs.readFile(path, 'utf-8', (err, data) => {
+      if (err) {
+        res.send(utils.returnData({ code: -1, msg: '文件解析失败' }))
+      }
+      const data1 = data.split(/\r?\n/)
+      list = data1.map((line) => [line])
+      writeToDatabase(fileArr, list, req, res)
+    })
+  } else {
+    let xlsxRes = xlsx.parse(`${path.join(__dirname, '../../', 'public/uploadFile/')}${filename}`, { cellDates: true })
+    list = xlsxRes[0].data
+    list.splice(0, 1)
+    writeToDatabase(fileArr, list, req, res)
+  }
+})
+// 写入数据库
+const writeToDatabase = (fileArr, list, req, res) => {
+  let sqlParamsEntity = []
+  let fileImportSql = 'INSERT INTO file_import_t(`id`,`name`,`importer_id`,`time`,`data_volume`,`dataset_id`) VALUES (?,?,?,?,?,?)'
+  let params = JSON.parse(fileArr[0].params.listType)
+  const uniqueId = uuid.v4()
+  let name = fileArr[0].originalname
+  let { importer_id: importerId, dataset_id: datasetId } = params
+  let currentTime = datetimeToTime()
+  let dataVolume = list.length
+  var fileImportParam = [uniqueId, name, importerId, currentTime, dataVolume, datasetId]
+  sqlParamsEntity.push({
+    sql: fileImportSql,
+    values: fileImportParam
+  })
+  let markDataSql = 'INSERT INTO mark_data_t(text,`file_id`,`dataset_id`,is_mark,state) VALUES (?,?,?,?,?)'
+  console.log('list.length', list.length)
+  for (let i = 0; i < list.length; i++) {
+    let item = list[i]
+    var markDataParams = [item[0], uniqueId, datasetId, true, false]
+    sqlParamsEntity.push({
+      sql: markDataSql,
+      values: markDataParams
+    })
+  }
+  execTransection(sqlParamsEntity)
+    .then((resp) => {
+      res.send(utils.returnData({ code: 1, msg: '导入成功', data: [] }))
+    })
+    .catch((err) => {
+      res.send(utils.returnData({ code: -1, msg:'导入失败', err, req }))
+    })
+}
+
+// 修改text数据
+router.post('/updataData', async (req, res) => {
+  let sql = 'UPDATE mark_data_t SET text=? WHERE id=?',obj = req.body
+  await pools({ sql, val: [obj.text, obj.id], run: false, res, req })
+})
+
+//删除
+router.post('/delData', async (req, res) => {
+  let sqlParams = []
+  obj = req.body
+  let placeholders = obj.map(() => '?').join(',')
+  let sql = `DELETE FROM mark_data_t WHERE id in (${placeholders})`
+  let sqlUpdata = `UPDATE file_import_t SET data_volume = data_volume - ${obj.length}`
+  sqlParams.push(
+    {
+      sql: sql,
+      values: obj
+    },
+    {
+      sql: sqlUpdata,
+      values: []
+    }
+  )
+  execTransection(sqlParams)
+    .then((resp) => {
+      res.send(utils.returnData({ code: 1, msg: '删除成功', data: [] }))
+    })
+    .catch((err) => {
+      res.send(utils.returnData({ code: -1, msg, err, req }))
+    })
+  // await pools({ sql, val: obj, run: false, res, req }) // 注意这里直接传递obj数组作为参数
+})
+
+// 上一条、下一条数据
+router.post('/PNData', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res })
+  obj = req.body
+  let sql = ``
+  if (obj.type === 'previous') {
+    sql = ` SELECT * FROM mark_data_t m WHERE m.id < ? AND m.dataset_id=? ORDER BY m.id DESC LIMIT 0,1;`
+  } else {
+    sql = ` SELECT * FROM mark_data_t m WHERE m.id > ? AND m.dataset_id=? ORDER BY m.id LIMIT 0,1;`
+  }
+  sql = utils.setLike(sql, 'text', obj.text)
+  sql = utils.setMoreId(sql, user)
+  let { result } = await pools({ sql, val: [obj.id, obj.dataset_id], req })
+  console.log('result', result)
+  if (result.length === 0 && obj.type === 'previous') {
+    res.send(utils.returnData({ data: result, code: 2, msg: '已第一条数据' }))
+  } else if (result.length === 0 && obj.type === 'next') {
+    res.send(utils.returnData({ data: result, code: 2, msg: '已是最后一条数据' }))
+  } else {
+    res.send(utils.returnData({ data: result }))
+  }
+})
+
+//导出数据
+router.post("/exportDataset",async (req,res)=>{
+  let user = await utils.getUserInfo({req, res}),obj=req.body;
+  let sql = `SELECT id,text,markInfo FROM mark_data_t m WHERE m.dataset_id=?`;
+  sql+=` ORDER BY id ASC`;
+  let { result }=await pools({ sql, val: [obj.dataset_id], res, req });
+  
+  // 查询数据集名称
+  let datasetSql = `SELECT name FROM dataset_t d WHERE d.id=?`;
+  let { datasetName }=await pools({ sql:datasetSql, val: [obj.dataset_id], res, req });
+  console.log("datasetName",datasetName);
+  
+  let data =[ ['id','文本','标注信息']];
+  result.map(t=>{
+    data.push(Object.values(t))
+  })
+  let buffer = xlsx.build([{name:'sheet1',data}]);
+  const filename = `标注数据.xlsx`;
+  const encodedFilename = encodeURI(filename);
+  res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;filename='+encodedFilename);
+  res.send(buffer);
+});
+
+//下载模板
+router.post("/downloadTemplate",async (req,res)=>{
+  let data =[ ['文本']];
+  let buffer = xlsx.build([{name:'sheet1',data}]);
+  const filename = '标注数据模板.xlsx';
+  const encodedFilename = encodeURI(filename);
+  res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;filename='+encodedFilename);
+  res.send(buffer);
+});
+
+module.exports = router

router/dataMark/entity.js

@@ -0,0 +1,139 @@
+const express = require('express')
+const router = express.Router()
+const utils = require('../../utils/index.js')
+const pool = require('../../pool.js')
+const pools = require('../../utils/pools.js')
+const xlsx = require('node-xlsx')
+const path = require('path')
+const fileEvent = require('../../utils/file')
+const getNewSqlParamEntity = require('../../utils/tool.js')
+const execTrans = require('../../utils/dbHelper.js')
+
+// 增加实体
+router.post('/addEntity', async (req, res) => {
+  let sql = 'INSERT INTO entity_t(`name`,`introduce`,is_show,parent_id,color) VALUES (?,?,?,?,?)',
+    obj = req.body
+  await pools({
+    sql,
+    val: [obj.name, obj.introduce, obj.is_show, obj.parentId, obj.color],
+    run: false,
+    res,
+    req
+  })
+})
+
+//查询
+router.post('/getEntityList', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res }),
+    obj = req.body
+  let sql = `SELECT id AS entityId,name,introduce,is_show,parent_id AS parentId,color FROM entity_t WHERE 1=1` // WHERE 1=1是一个始终为真的条件，后续动态添加查询条件的起点
+  sql = utils.setLike(sql, 'name', obj.name) // 添加一个基于name字段的模糊匹配条件，匹配的值来自obj.name
+  sql = utils.setMoreId(sql, user)
+  sql = utils.setOr(sql, 'name', obj.name)
+  let { total } = await utils.getSum({ sql, name: 'entity_t', res, req }) // 执行SQL查询并获取结果中的总数
+  sql += ` ORDER BY id ASC` // 在SQL查询语句的末尾添加了一个ORDER BY子句，用于根据id字段排序结果 ASC升序、DESC降序
+  // sql = utils.pageSize(sql, obj.page, obj.size) // 函数来修改SQL语句，添加分页功能。它使用obj.page和obj.size来确定返回结果的范围。
+  let { result } = await pools({ sql, res, req })
+  result = result.map((item) => ({
+    ...item,
+    is_show: item.is_show === 1
+    // color: item.color.substring(1)
+  }))
+  res.send(utils.returnData({ data: result, total }))
+})
+
+// 查询子标签
+router.post('/getChildList', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res }),
+    obj = req.body
+  let sql = `SELECT id AS entityId,name,introduce,is_show,parent_id AS parentId,color FROM entity_t WHERE parent_id=?`
+  let { total } = await utils.getSumWhere({ sql:'',val: [obj.parentId], name: 'entity_t', res, req }) // 执行SQL查询并获取结果中的总数
+  sql += ` ORDER BY id ASC` // 在SQL查询语句的末尾添加了一个ORDER BY子句，用于根据id字段排序结果 ASC升序、DESC降序
+  // sql = utils.pageSize(sql, obj.page, obj.size) // 函数来修改SQL语句，添加分页功能。它使用obj.page和obj.size来确定返回结果的范围。
+  let { result } = await pools({ sql, val: [obj.parentId], req })
+  result = result.map((item) => ({
+    ...item,
+    is_show: item.is_show === 1
+    // color: item.color.substring(1)
+  }))
+  res.send(utils.returnData({ data: result, total }))
+})
+
+//修改
+router.post('/updataEntity', async (req, res) => {
+  let sql = 'UPDATE entity_t SET name=?,introduce=?,is_show=?,parent_id=?,color=? WHERE id=?',
+    obj = req.body
+  await pools({ sql, val: [obj.name, obj.introduce, obj.is_show, obj.parentId, obj.color, obj.entityId], run: false, res, req })
+})
+
+//删除
+router.post('/delEntity', async (req, res) => {
+  // await utils.checkPermi({ req, res, role: [systemSettings.menus.menuDelte] })  //检查是否有删除权限
+  let obj = req.body // 假设这是一个包含所有要删除的entityId的数组
+  let hasChildren = false
+  let selectSql = 'SELECT id FROM entity_t WHERE parent_id=?'
+  // 检查是否有子项
+  for (let id of obj) {
+    let { result } = await pools({ sql: selectSql, val: [id], res, req })
+    if (result.length !== 0) {
+      hasChildren = true
+      break
+    }
+  }
+  if (hasChildren) {
+    return res.send(utils.returnData({ code: -1, msg: '删除失败，请先删除子级', req }))
+  } else {
+    // 构建参数化查询的参数
+    let placeholders = obj.map(() => '?').join(',')
+    let sql = `DELETE FROM entity_t WHERE id in (${placeholders})`
+    await pools({ sql, val: obj, run: false, res, req }) // 注意这里直接传递obj数组作为参数
+  }
+})
+
+// 导入
+router.post('/importEntity', async (req, res) => {
+  let sql = 'INSERT INTO entity_t(`name`,`introduce`,is_show,parent_id,color) VALUES ?'
+  let fileArr = await fileEvent(req, res)
+  let filename = fileArr[0].filename
+  //配置获取文件路径
+  let xlsxRes = xlsx.parse(`${path.join(__dirname, '../../', 'public/uploadFile/')}${filename}`, { cellDates: true })
+  let list = xlsxRes[0].data
+  list.splice(0, 1)
+  console.log('list', list)
+  for (let i = 0; i < list.length; i++) {
+    let item = list[i]
+    if (item[item.length - 1] === 0) {
+      let res1 = await pools({ sql, val: [[item]], run: true, res, req, msg: '请确认导入的一级节点的值没有问题！！！' })
+      console.log('res1', res1)
+    } else {
+      let parentName = item[item.length - 1]
+      let parentSql = 'SELECT id FROM entity_t WHERE `name` = ?'
+      let parentId
+      try {
+        let result = await pools({ sql: parentSql, val: [parentName], run: true, res, req })
+        console.log('result', result)
+        parentId = result.result[0].id
+        console.log('parentId', parentId)
+      } catch (error) {
+        console.log('获取父节点id失败', error)
+        res.status(500).send('获取父节点id失败')
+        return
+      }
+      // 将父节点id添加到item中替换父节点名称
+      item[item.length - 1] = parentId
+      // 插入数据库
+      try {
+        if (i === list.length - 1) {
+          await pools({ sql, val: [[item]], run: false, res, req, msg: '请确认导入的节点的值没有问题！！！' })
+        } else {
+          await pools({ sql, val: [[item]], run: true, res, req, msg: '请确认导入的节点的值没有问题！！！' })
+        }
+      } catch (error) {
+        console.log('插入数据失败', error)
+        res.status(500).send('插入数据失败')
+        return
+      }
+    }
+  }
+})
+module.exports = router

router/dataMark/relationship.js

@@ -0,0 +1,108 @@
+const express = require('express')
+const router = express.Router()
+const utils = require('../../utils/index.js')
+const pools = require('../../utils/pools.js')
+// 增加实体
+router.post('/addRelationship', async (req, res) => {
+  let sql = 'INSERT INTO relationship_t(`name`) VALUES (?)',
+    obj = req.body
+  await utils.existName({
+    sql: 'SELECT name FROM relationship_t WHERE name=?',
+    name: obj.name,
+    res,
+    msg: '该实体关系已存在！',
+    req
+  })
+  await pools({
+    sql,
+    val: [obj.name],
+    run: false,
+    res,
+    req
+  })
+})
+
+//查询测试账号
+router.post('/getRelationshipList', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res }),
+    obj = req.body
+  let sql = `SELECT id AS relationshipId,name FROM relationship_t WHERE 1=1`
+  sql = utils.setLike(sql, 'name', obj.name)
+  sql = utils.setMoreId(sql, user)
+  let { total } = await utils.getSum({ sql, name: 'relationship_t', res, req })
+  sql += ` ORDER BY id ASC`
+  sql = utils.pageSize(sql, obj.page, obj.size)
+  let { result } = await pools({ sql, res, req })
+  res.send(utils.returnData({ data: result, total }))
+})
+
+//删除
+router.post('/delRelationship', async (req, res) => {
+  obj = req.body
+  let placeholders = obj.map(() => '?').join(',')
+  let sql = `DELETE FROM relationship_t WHERE id in (${placeholders})`
+  await pools({ sql, val: obj, run: false, res, req }) // 注意这里直接传递obj数组作为参数
+})
+
+//修改
+router.post('/updataRelationship', async (req, res) => {
+  let sql = 'UPDATE relationship_t SET name=? WHERE id=?',
+    obj = req.body
+  await pools({ sql, val: [obj.name, obj.relationshipId], run: false, res, req })
+})
+
+// 获取ERList
+router.post('/getERList', async (req, res) => {
+  let user = await utils.getUserInfo({ req, res }),
+    obj = req.body
+  // let sql = `SELECT relationship_id AS relationshipId,name FROM relationship WHERE 1=1`
+  let sql = `(SELECT
+      r.NAME AS relationshipName,
+      r.id AS relationshipId,
+      t.object_id AS objectId,
+      t.is_show,
+      t.id AS ERId,
+      (SELECT name from entity_t e where e.id = t.object_id) as objectName,
+      t.subject_id AS subjectId,
+      (SELECT name from entity_t e where e.id = t.subject_id) as subjectName
+    FROM
+      entity_relationship_t t JOIN relationship_t r ON r.id = t.relationship_id 
+    WHERE r.id = ? )`
+  let sqlCount = 'select count(1) from ' + sql + ' z'
+  if (obj.entityName) {
+    sql = `select z.* from ${sql} z where z.objectName like '%${obj.entityName}%' OR z.subjectName like '%${obj.entityName}%'`
+    sqlCount = 'select count(1) from (' + sql + ') z'
+  }
+  let sss = await pools({ sql: sqlCount, val: [obj.relationshipId], req })
+  let total = sss.result[0]['count(1)']
+  let { result } = await pools({ sql, val: [obj.relationshipId], req })
+  result = result.map((item) => ({
+    ...item,
+    isShow: item.is_show === 1
+  }))
+  res.send(utils.returnData({ data: result, total }))
+})
+
+//删除ER
+router.post('/delER', async (req, res) => {
+  obj = req.body
+  let placeholders = obj.map(() => '?').join(',')
+  let sql = `DELETE FROM entity_relationship_t WHERE id in (${placeholders})`
+  await pools({ sql, val: obj, run: false, res, req }) // 注意这里直接传递obj数组作为参数
+})
+
+// 增加ER
+router.post('/addER', async (req, res) => {
+  let sql = 'INSERT INTO entity_relationship_t(subject_id,object_id,relationship_id,is_show) VALUES (?,?,?,?)',
+    obj = req.body
+
+  let { result } = await pools({
+    sql,
+    val: [obj.subjectId, obj.objectId, obj.relationshipId, obj.isShow],
+    run: false,
+    res,
+    req
+  })
+  console.log('result', result)
+})
+module.exports = router

utils/config.js

@@ -1,9 +1,8 @@
-
-module.exports={
-    //上传文件位置
-    fileSite:"public",
-    //上传name
-    fileName:"file",
-    //文件host
-    fileHost:"http://127.0.0.1:3000"
+module.exports = {
+  //上传文件位置
+  fileSite: 'public/uploadFile',
+  //上传name
+  fileName: 'file',
+  //文件host
+  fileHost: 'http://127.0.0.1:8899'
 }

utils/dbHelper.js

@@ -0,0 +1,44 @@
+// const pool = require('../db/mysql') // 导入pool对象
+const pool = require('../pool.js')
+
+module.exports = function execTransection(sqlArr) {
+  return new Promise((resolve, reject) => {
+    var promiseArr = []
+    pool.getConnection(function (err, connection) {
+      if (err) {
+        return reject(err)
+      }
+      connection.beginTransaction((err) => {
+        if (err) {
+          return reject('开启事务失败')
+        }
+        // 将所有需要执行的sql封装为数组
+        promiseArr = sqlArr.map(({ sql, values }) => {
+          return new Promise((resolve, reject) => {
+            connection.query(sql, values, (e, rows, fields) => {
+              e ? reject(e) : resolve({ rows, success: true })
+            })
+          })
+        })
+        // Promise调用所有sql，一旦出错，回滚，否则，提交事务并释放链接
+        Promise.all(promiseArr)
+          .then((res) => {
+            connection.commit((error) => {
+              if (error) {
+                console.log('事务提交失败' + error)
+                reject(error)
+              }
+            })
+            connection.release() // 释放链接
+            resolve({ res })
+          })
+          .catch((err) => {
+            connection.rollback(() => {
+              console.log('数据操作回滚' + err)
+            })
+            reject(err)
+          })
+      })
+    })
+  })
+}

utils/file.js

@@ -1,45 +1,45 @@
-const multer = require('multer');
-const config = require("./config.js");
-const utils = require("./index");
+const multer = require('multer')
+const config = require('./config.js')
+const utils = require('./index')
 //上传的文件保存在 upload
 const storage = multer.diskStorage({
-    //存储的位置
-    destination(req, file, cb){
-        cb(null, config.fileSite);
-    },
-    //文件名字的确定 multer默认帮我们取一个没有扩展名的文件名，因此需要我们自己定义
-    filename(req, file, cb){
-        let math=Math.random();
-        math=math.toString().replace(".","");//随机字符串
-        cb(null, `${Date.now()}${math}-${file.originalname}`)
-    }
-});
+  //存储的位置
+  destination(req, file, cb) {
+    cb(null, config.fileSite)
+  },
+  //文件名字的确定 multer默认帮我们取一个没有扩展名的文件名，因此需要我们自己定义
+  filename(req, file, cb) {
+    let math = Math.random()
+    math = math.toString().replace('.', '') //随机字符串
+    cb(null, `${Date.now()}${math}-${file.originalname}`)
+  }
+})
 //传入storage 除了这个参数我们还可以传入dest等参数
 let upload = multer({
-    storage
-}).array(config.fileName);
+  storage
+}).array(config.fileName)
 //上传总函数
-let fileEvent=(req,res)=>{
-    return new Promise((resolve,reject)=>{
-        upload(req, res, function (err) {
-            if (err) return res.send(utils.returnData({code:-1,msg:"上传文件错误~",req,err}));
-            try{
-                //循环处理
-                let imgPath=[];
-                req.files.forEach(function (i) {
-                    const regex = /^(.+)\.[^.]+$/;
-                    const regexRes = i.originalname.match(regex);
-                    let name="";
-                    if (regexRes) name=regexRes[1];
-                    //获取临时文件的存储路径
-                    imgPath.push({url:`${config.fileHost}/${i.filename}`,name,originalname:i.originalname,filename:i.filename});
-                    // console.log("i.path:",i.path)
-                });
-                resolve(imgPath)
-            }catch(err){
-                res.send(utils.returnData({code:-1,msg:"上传文件错误~",req,err}));
-            }
-        });
-    });
-};
-module.exports=fileEvent;
+let fileEvent = (req, res) => {
+  return new Promise((resolve, reject) => {
+    upload(req, res, function (err) {
+      if (err) return res.send(utils.returnData({ code: -1, msg: '上传文件错误~', req, err }))
+      try {
+        //循环处理
+        let imgPath = []
+        req.files.forEach(function (i) {
+          const regex = /^(.+)\.[^.]+$/
+          const regexRes = i.originalname.match(regex)
+          let name = ''
+          if (regexRes) name = regexRes[1]
+          //获取临时文件的存储路径
+          imgPath.push({ url: `${config.fileHost}/${i.filename}`, name, originalname: i.originalname, filename: i.filename, params: req.body })
+          // console.log("i.path:",i.path)
+        })
+        resolve(imgPath)
+      } catch (err) {
+        res.send(utils.returnData({ code: -1, msg: '上传文件错误~', req, err }))
+      }
+    })
+  })
+}
+module.exports = fileEvent

utils/index.js

@@ -1,286 +1,311 @@
-const jwt = require("jsonwebtoken");
-const pool = require("../pool.js");
-const {errLog}=require("../utils/err");
+const jwt = require('jsonwebtoken')
+const pool = require('../pool.js')
+const { errLog } = require('../utils/err')
 //日志记录
 module.exports = {
-    poolsEvent(){
-        const pools = require("./pools");
-        return pools
-    },
-    setToken({uid,captcha,name="user"}) {
-        let token = jwt.sign({uid,captcha}, name, {
-            expiresIn: "86400s", // 授权时间
-        });
-        return token;
-    },
-    verToken({token,name="user"}) {
-        try {
-            return jwt.verify(token, name);
-        } catch (err) {
-            return false;
-        }
-    },
-    /**
-     * 判断名称是否重复
-     * @param sql  sql语句
-     * @param name  sql查询参数name
-     * @param msg  提示语
-     * @param req  请求主体
-     * @param res  响应主体
-     * */
-    async existName({sql, name,msg="名称已存在！",req,res}) {
-        if(!name) return true;
-        let {result}=await this.poolsEvent()({sql,res,req,val:[name]});
-        if (result.length > 0){
-            res.send(this.returnData({code:-1,msg,req}))
-            return Promise.reject(false);
-        }
-        return true;
-    },
-    /**
-     * 判断修改的名称是否和修改前的一样
-     * @param sql  sql语句
-     * @param sqlName  修改前的属性名
-     * @param name  修改后的值
-     * @param id  sql条件参数
-     * @param req  请求主体
-     * @param res  响应主体
-     * */
-    async judgeUserName({sql,sqlName="name", name,id,req,res}) {
-        let {result}=await this.poolsEvent()({sql,val:[id],res,req});
-        if (result[0][sqlName] == name) return -1;
-        return 1;
-    },
-    /**
-     * 响应总函数
-     * @param code  状态码
-     * @param msg  提示文字
-     * @param total  查询总数量
-     * @param data  数据
-     * @param err  错误信息
-     * @param req  错误信息
-     * @param funName  错误信息记录名称
-     * */
-    returnData({code = 1, msg, total=undefined,data = {},err,req={},funName} = {}) {
-        if (code == 1 && !msg) msg = "请求成功！";
-        if (code == -1 && !msg) msg = "服务器异常！";
-        if (code == 203 && !msg) msg = "登陆失效，请重新登陆！";
-        let res={code, msg, data};
-        if(total!==undefined) res.total=total;
-        if(err) res.err=err;
-        //记录错误日志
-        if(code!=1) errLog({err,code,msg,req,funName});
-        return res;
-    },
-    /**
-     * 获取用户信息
-     * @param req  请求主体
-     * @param res  响应主体
-     * @param addMore  是否拒绝管理员添加多账户信息
-     * */
-    async getUserInfo({req, res,addMore=false}={}) {
-        let token = req.headers.token;
-        if (!token) {
-            res.send(this.returnData({code: 203,req}));
-            return Promise.reject(false);
-        }
-        let user = this.verToken({token});
-        if (!user) {
-            res.send(this.returnData({code: 203,req}));
-            return Promise.reject(false);
-        }
-        let sql = "SELECT id,name,status,roles_id AS rolesId,admin,more_id AS moreId,url FROM user WHERE id=?";
-        let {result}=await this.poolsEvent()({sql,val:[user.uid],res,req});
-        if (result.length === 0) {
-            res.send(this.returnData({code: -1, msg: "用户不存在！",req}));
-            return Promise.reject(false);
-        }
-        if(addMore&&result[0].admin===1) {
-            res.send(this.returnData({code: -1, msg: "终极管理员无权 增加多账号数据~",req}));
-            return Promise.reject(false);
-        }
-        return result[0];
-    },
-
-    /**
-     * 获取用户权限
-     * @param req  请求主体
-     * @param res  响应主体
-     * */
-    async getUserRole(req, res) {
-        let user = await this.getUserInfo({req, res});
-        let userSql = "SELECT roles,role_key FROM roles WHERE FIND_IN_SET(id,?)";
-        let {result}=await this.poolsEvent()({sql:userSql,val:[user.rolesId],res,req});
-        if (result.length == 0) {
-            res.send(this.returnData({code:-1,msg:"获取权限失败！",req}));
-            return Promise.reject(false);
-        }
-        let roles = result.map(t => t.roles);
-        //权限字符
-        let roleKey=result.map(t=>t.role_key);
-        //角色权限
-        let roleAdmin=roleKey.some(t=>t==="admin");
-        return {userRole: roles.join(","),roleKey,user,roleAdmin};
-    },
-    /**
-     * 菜单字符权限拦截
-     * @param req  主体
-     * @param res  主体
-     * @param role  接口权限字符数组
-     * @param admin  是否管理员也要遵守（默认否）
-     * @param run  是否不拦截，返回结果
-     * */
-    async checkPermi({req,res,role=[],admin=false,run=false}){
-        let userRole=await this.getUserRole(req,res);
-        if((userRole.roleAdmin|| userRole.user.admin===1)&&!admin) return true;
-        let sql = "SELECT role_key AS roleKey FROM router_menu WHERE FIND_IN_SET(id,?)";
-        let {result}=await this.poolsEvent()({sql,val:[userRole.userRole],res,req});
-        try {
-            let roleKeyArr=result.map(t=>t.roleKey).filter(t=>t);
-            const hasPermission = role.some(permission => {
-                return roleKeyArr.includes(permission)
-            });
-            if(hasPermission||run) return hasPermission;
-            res.send(this.returnData({code:-1,msg:"暂无此功能请求权限！",req}));
-            return Promise.reject(false);
-        }catch (e) {
-            res.send(this.returnData({code:-1,msg:"菜单权限判断错误！！",req}));
-            return Promise.reject(false);
-        }
-    },
-    /**
-     * 角色权限拦截
-     * @param req  主体
-     * @param res  主体
-     * @param role  角色权限数组
-     * @param admin  是否管理员也要遵守（默认否）
-     * @param run  是否不拦截，返回结果
-     * */
-    async checkRole({req,res,role=[],admin=false,run=false}){
-        try {
-            let userRole=await this.getUserRole(req,res);
-            if((userRole.roleAdmin|| userRole.user.admin===1)&&!admin) return true;
-            let roleKeyArr=userRole.roleKey;
-            const hasPermission = role.some(permission => {
-                return roleKeyArr.includes(permission)
-            });
-            if(hasPermission||run) return hasPermission;
-            res.send(this.returnData({code:-1,msg:"暂无对应角色请求权限！",req}))
-            return Promise.reject(false);
-        }catch (e) {
-            res.send(this.returnData({code:-1,msg:"角色权限判断错误！",err:e,req}))
-            return Promise.reject(false);
-        }
-
-    },
-    /**
-     * 是否操作的是用户总管理员
-     * @param req  请求主体
-     * @param res  响应主体
-     * @param id  查询条件id
-     * */
-    async upAdmin({req,res,id}){
-        let sql = "SELECT admin FROM user WHERE id=?";
-        let {result}=await this.poolsEvent()({sql,val:[id],res,req});
-        if(result.length===0){
-            res.send(this.returnData({code:-1,msg:"管理信息判断错误！",req}));
-            return Promise.reject(false);
-        }
-        if(result[0].admin===1) {
-            res.send(this.returnData({code:-1,msg:"无法对《总管理》执行此操作！",req}));
-            return Promise.reject(false);
-        }
-        return result;
-    },
-    /**
-     * 是否操作的是角色总管理员
-     * @param req  请求主体
-     * @param res  响应主体
-     * @param id  查询条件id
-     * */
-    async upAdminRole({req,res,id}){
-        let sql = "SELECT role_key FROM roles WHERE id=?";
-        let {result}=await this.poolsEvent()({sql,val:[id],res,req});
-        if(result.length===0) {
-            res.send(this.returnData({code:-1,msg:"管理信息判断错误！！",req}));
-            return Promise.reject(false);
-        }
-        if(result[0].role_key==="admin") {
-            res.send(this.returnData({code:-1,msg:"无法对《角色总管理》执行此操作！",req}));
-            return Promise.reject(false);
-        }
-        return result;
+  poolsEvent() {
+    const pools = require('./pools')
+    return pools
+  },
+  setToken({ uid, captcha, name = 'user' }) {
+    let token = jwt.sign({ uid, captcha }, name, {
+      expiresIn: '86400s' // 授权时间
+    })
+    return token
+  },
+  verToken({ token, name = 'user' }) {
+    try {
+      return jwt.verify(token, name)
+    } catch (err) {
+      return false
+    }
+  },
+  /**
+   * 判断名称是否重复
+   * @param sql  sql语句
+   * @param name  sql查询参数name
+   * @param msg  提示语
+   * @param req  请求主体
+   * @param res  响应主体
+   * */
+  async existName({ sql, name, msg = '名称已存在！', req, res }) {
+    if (!name) return true
+    let { result } = await this.poolsEvent()({ sql, res, req, val: [name] })
+    if (result.length > 0) {
+      res.send(this.returnData({ code: -1, msg, req }))
+      return Promise.reject(false)
+    }
+    return true
+  },
+  /**
+   * 判断修改的名称是否和修改前的一样
+   * @param sql  sql语句
+   * @param sqlName  修改前的属性名
+   * @param name  修改后的值
+   * @param id  sql条件参数
+   * @param req  请求主体
+   * @param res  响应主体
+   * */
+  async judgeUserName({ sql, sqlName = 'name', name, id, req, res }) {
+    let { result } = await this.poolsEvent()({ sql, val: [id], res, req })
+    if (result[0][sqlName] == name) return -1
+    return 1
+  },
+  /**
+   * 响应总函数
+   * @param code  状态码
+   * @param msg  提示文字
+   * @param total  查询总数量
+   * @param data  数据
+   * @param err  错误信息
+   * @param req  错误信息
+   * @param funName  错误信息记录名称
+   * */
+  returnData({ code = 1, msg, total = undefined, data = {}, err, req = {}, funName } = {}) {
+    if (code == 1 && !msg) msg = '请求成功！'
+    if (code == -1 && err.code == 'ER_DUP_ENTRY' && !msg) msg = '新增数据重复，请检查输入的数据'
+    if (code == -1 && !msg) msg = '服务器异常！'
+    if (code == 203 && !msg) msg = '登陆失效，请重新登陆！'
+    let res = { code, msg, data }
+    if (total !== undefined) res.total = total
+    if (err) res.err = err
+    //记录错误日志
+    if (code != 1) errLog({ err, code, msg, req, funName })
+    return res
+  },
+  /**
+   * 获取用户信息
+   * @param req  请求主体
+   * @param res  响应主体
+   * @param addMore  是否拒绝管理员添加多账户信息
+   * */
+  async getUserInfo({ req, res, addMore = false } = {}) {
+    let token = req.headers.token
+    if (!token) {
+      res.send(this.returnData({ code: 203, req }))
+      return Promise.reject(false)
+    }
+    let user = this.verToken({ token })
+    if (!user) {
+      res.send(this.returnData({ code: 203, req }))
+      return Promise.reject(false)
+    }
+    let sql = 'SELECT id,name,status,roles_id AS rolesId,admin,more_id AS moreId,url FROM user WHERE id=?'
+    let { result } = await this.poolsEvent()({ sql, val: [user.uid], res, req })
+    if (result.length === 0) {
+      res.send(this.returnData({ code: -1, msg: '用户不存在！', req }))
+      return Promise.reject(false)
+    }
+    if (addMore && result[0].admin === 1) {
+      res.send(this.returnData({ code: -1, msg: '终极管理员无权 增加多账号数据~', req }))
+      return Promise.reject(false)
+    }
+    return result[0]
+  },
 
-    },
-    /**
-     * 通过id获取用户信息
-     * @param req  请求主体
-     * @param res  响应主体
-     * @param id  查询条件id
-     * */
-    async getUserId({req,res,id}){
-        let sql = "SELECT admin FROM user WHERE id=?";
-        let {result}=await this.poolsEvent()({sql,val:[id],res,req});
-        if(result.length===0) {
-            res.send(this.returnData({code:-1,msg:"用户信息错误！！",req}));
-            return Promise.reject(false);
-        }
-        return result[0];
-    },
-    /**
-     * 分页页码处理
-     * @param sql  sql语句
-     * @param page  页码
-     * @param size  最大数量
-     * */
-    pageSize(sql,page,size){
-        if(!page){page=1};
-        if(!size){size=10};
-        page = (page-1)*size;
-        size = parseInt(size);
-        return sql+=` LIMIT ${page},${size}`;
-    },
-    /**
-     * 查询总数
-     * @param sql  sql语句
-     * @param name  表名
-     * @param res  响应主体
-     * @param req  请求主体
-     * */
-    async getSum({sql="",name,res,req}) {
-        const regex = /WHERE(.+)/;
-        const result = sql.match(regex);
-        let where="1=1";
-        if (result && result[1])  where = result[1].trim();
-        let sqlRes = `SELECT count(1) FROM ${name} WHERE ${where}`;
-        let {result:resultRes}=await this.poolsEvent()({sql:sqlRes,res,req});
-        return { total: resultRes[0]["count(1)"] };
-    },
-    /**
-     * 将多账户id加入sql判断
-     * @param sql  sql语句
-     * @param user  用户信息
-     * @param name  字段名
-     * */
-    setMoreId(sql,user,name='more_id'){
-        if (user.admin !== 1) return sql += ` AND ${name} = ${user.moreId}`;
-        return sql;
-    },
-    /**
-     * 模糊查询
-     * @param sql sql语句
-     * @param name 字段名
-     * @param val 值
-     * */
-    setLike(sql,name="",val=""){
-        if(this.exist(val)) sql+=` AND ${name} LIKE "%${val}%"`;
-        return sql
-    },
-    /**
-     * 判断是否为空
-     * @param str any
-     * */
-    exist(str){
-        return str !== undefined && str !== "" && str !== null;
+  /**
+   * 获取用户权限
+   * @param req  请求主体
+   * @param res  响应主体
+   * */
+  async getUserRole(req, res) {
+    let user = await this.getUserInfo({ req, res })
+    let userSql = 'SELECT roles,role_key FROM roles WHERE FIND_IN_SET(id,?)'
+    let { result } = await this.poolsEvent()({ sql: userSql, val: [user.rolesId], res, req })
+    if (result.length == 0) {
+      res.send(this.returnData({ code: -1, msg: '获取权限失败！', req }))
+      return Promise.reject(false)
+    }
+    let roles = result.map((t) => t.roles)
+    //权限字符
+    let roleKey = result.map((t) => t.role_key)
+    //角色权限
+    let roleAdmin = roleKey.some((t) => t === 'admin')
+    return { userRole: roles.join(','), roleKey, user, roleAdmin }
+  },
+  /**
+   * 菜单字符权限拦截
+   * @param req  主体
+   * @param res  主体
+   * @param role  接口权限字符数组
+   * @param admin  是否管理员也要遵守（默认否）
+   * @param run  是否不拦截，返回结果
+   * */
+  async checkPermi({ req, res, role = [], admin = false, run = false }) {
+    let userRole = await this.getUserRole(req, res)
+    if ((userRole.roleAdmin || userRole.user.admin === 1) && !admin) return true
+    let sql = 'SELECT role_key AS roleKey FROM router_menu WHERE FIND_IN_SET(id,?)'
+    let { result } = await this.poolsEvent()({ sql, val: [userRole.userRole], res, req })
+    try {
+      let roleKeyArr = result.map((t) => t.roleKey).filter((t) => t)
+      const hasPermission = role.some((permission) => {
+        return roleKeyArr.includes(permission)
+      })
+      if (hasPermission || run) return hasPermission
+      res.send(this.returnData({ code: -1, msg: '暂无此功能请求权限！', req }))
+      return Promise.reject(false)
+    } catch (e) {
+      res.send(this.returnData({ code: -1, msg: '菜单权限判断错误！！', req }))
+      return Promise.reject(false)
     }
-};
+  },
+  /**
+   * 角色权限拦截
+   * @param req  主体
+   * @param res  主体
+   * @param role  角色权限数组
+   * @param admin  是否管理员也要遵守（默认否）
+   * @param run  是否不拦截，返回结果
+   * */
+  async checkRole({ req, res, role = [], admin = false, run = false }) {
+    try {
+      let userRole = await this.getUserRole(req, res)
+      if ((userRole.roleAdmin || userRole.user.admin === 1) && !admin) return true
+      let roleKeyArr = userRole.roleKey
+      const hasPermission = role.some((permission) => {
+        return roleKeyArr.includes(permission)
+      })
+      if (hasPermission || run) return hasPermission
+      res.send(this.returnData({ code: -1, msg: '暂无对应角色请求权限！', req }))
+      return Promise.reject(false)
+    } catch (e) {
+      res.send(this.returnData({ code: -1, msg: '角色权限判断错误！', err: e, req }))
+      return Promise.reject(false)
+    }
+  },
+  /**
+   * 是否操作的是用户总管理员
+   * @param req  请求主体
+   * @param res  响应主体
+   * @param id  查询条件id
+   * */
+  async upAdmin({ req, res, id }) {
+    let sql = 'SELECT admin FROM user WHERE id=?'
+    let { result } = await this.poolsEvent()({ sql, val: [id], res, req })
+    if (result.length === 0) {
+      res.send(this.returnData({ code: -1, msg: '管理信息判断错误！', req }))
+      return Promise.reject(false)
+    }
+    if (result[0].admin === 1) {
+      res.send(this.returnData({ code: -1, msg: '无法对《总管理》执行此操作！', req }))
+      return Promise.reject(false)
+    }
+    return result
+  },
+  /**
+   * 是否操作的是角色总管理员
+   * @param req  请求主体
+   * @param res  响应主体
+   * @param id  查询条件id
+   * */
+  async upAdminRole({ req, res, id }) {
+    let sql = 'SELECT role_key FROM roles WHERE id=?'
+    let { result } = await this.poolsEvent()({ sql, val: [id], res, req })
+    if (result.length === 0) {
+      res.send(this.returnData({ code: -1, msg: '管理信息判断错误！！', req }))
+      return Promise.reject(false)
+    }
+    if (result[0].role_key === 'admin') {
+      res.send(this.returnData({ code: -1, msg: '无法对《角色总管理》执行此操作！', req }))
+      return Promise.reject(false)
+    }
+    return result
+  },
+  /**
+   * 通过id获取用户信息
+   * @param req  请求主体
+   * @param res  响应主体
+   * @param id  查询条件id
+   * */
+  async getUserId({ req, res, id }) {
+    let sql = 'SELECT admin FROM user WHERE id=?'
+    let { result } = await this.poolsEvent()({ sql, val: [id], res, req })
+    if (result.length === 0) {
+      res.send(this.returnData({ code: -1, msg: '用户信息错误！！', req }))
+      return Promise.reject(false)
+    }
+    return result[0]
+  },
+  /**
+   * 分页页码处理
+   * @param sql  sql语句
+   * @param page  页码
+   * @param size  最大数量
+   * */
+  pageSize(sql, page, size) {
+    if (!page) {
+      page = 1
+    }
+    if (!size) {
+      size = 10
+    }
+    page = (page - 1) * size
+    size = parseInt(size)
+    return (sql += ` LIMIT ${page},${size}`)
+  },
+  /**
+   * 查询总数
+   * @param sql  sql语句
+   * @param name  表名
+   * @param res  响应主体
+   * @param req  请求主体
+   * */
+  async getSum({ sql = '', name, res, req }) {
+    const regex = /WHERE(.+)/
+    const result = sql.match(regex)
+    let where = '1=1'
+    if (result && result[1]) where = result[1].trim()
+    let sqlRes = `SELECT count(1) FROM ${name} WHERE ${where}`
+    let { result: resultRes } = await this.poolsEvent()({ sql: sqlRes, res, req })
+    return { total: resultRes[0]['count(1)'] }
+  },
+
+  /**
+   * 查询总数
+   * @param sql  sql语句
+   * @param val ？另加值
+   * @param name  表名
+   * @param res  响应主体
+   * @param req  请求主体
+   * */
+  async getSumWhere({ sql = '', val = [], name, res, req }) {
+    const regex = /WHERE(.+)/
+    const result = sql.match(regex)
+    let where = '1=1'
+    if (result && result[1]) where = result[1].trim()
+    let sqlRes = `SELECT count(1) FROM ${name} WHERE ${where}`
+    let { result: resultRes } = await this.poolsEvent()({ sql: sqlRes, val, res, req })
+    return { total: resultRes[0]['count(1)'] }
+  },
+  /**
+   * 将多账户id加入sql判断
+   * @param sql  sql语句
+   * @param user  用户信息
+   * @param name  字段名
+   * */
+  setMoreId(sql, user, name = 'more_id') {
+    if (user.admin !== 1) return (sql += ` AND ${name} = ${user.moreId}`)
+    return sql
+  },
+  /**
+   * 模糊查询
+   * @param sql sql语句
+   * @param name 字段名
+   * @param val 值
+   * */
+  setLike(sql, name = '', val = '') {
+    if (this.exist(val)) sql += ` AND ${name} LIKE "%${val}%"`
+    return sql
+  },
+  setOr(sql, name = '', val = '') {
+    if (this.exist(val)) sql += ` or id in (SELECT parent_id FROM entity_t where name LIKE '%${val}%')`
+    return sql
+  },
+  /**
+   * 判断是否为空
+   * @param str any
+   * */
+  exist(str) {
+    return str !== undefined && str !== '' && str !== null
+  }
+}

utils/pools.js

@@ -1,5 +1,5 @@
-const pool = require('../pool.js');
-const utils = require("./index.js");
+const pool = require('../pool.js')
+const utils = require('./index.js')
 /**
  * @param sql sql语句
  * @param val ？另加值
@@ -8,12 +8,12 @@ const utils = require("./index.js");
  * @param res 响应主体
  * @param req 请求主体
  * */
-module.exports=function pools({sql,val=[],msg,run=true,res,req}={}){
-    return new Promise((resolve)=>{
-        pool.query(sql, val,(err, result) => {
-            if (err) return res.send(utils.returnData({code: -1, msg,err,req}));
-            if(run) return resolve({result});
-            return res.send(utils.returnData({ data: result }));
-        });
+module.exports = function pools({ sql, val = [], msg, run = true, res, req } = {}) {
+  return new Promise((resolve) => {
+    pool.query(sql, val, (err, result) => {
+      if (err) return res.send(utils.returnData({ code: -1, msg, err, req }))
+      if (run) return resolve({ result })
+      return res.send(utils.returnData({ data: result }))
     })
-}
+  })
+}

utils/tool.js

@@ -0,0 +1,16 @@
+module.exports = function datetimeToTime() {
+  var date = new Date()
+  return (
+    date.getFullYear() +
+    '-' +
+    ('0' + (date.getMonth() + 1)).slice(-2) +
+    '-' +
+    ('0' + date.getDate()).slice(-2) +
+    ' ' +
+    ('0' + date.getHours()).slice(-2) +
+    ':' +
+    ('0' + date.getMinutes()).slice(-2) +
+    ':' +
+    ('0' + date.getSeconds()).slice(-2)
+  )
+}