no message

.gitignore

+.idea
+/out
+/node_modules
+/test
+/public
+/logs
+/video
+*test*
+*.logs
+*.zip
\ No newline at end of file

.vscode/launch.json

+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "启动程序",
+            "program": "${workspaceFolder}/src/main.ts",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        }
+    ]
+}
\ No newline at end of file

package.json

+{
+  "name": "screen",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.ts",
+  "dependencies": {
+    "@alicloud/sms-sdk": "^1.1.6",
+    "@types/node": "^10.12.18",
+    "compression": "^1.7.4",
+    "express": "^4.17.1",
+    "express-async-handler": "^1.1.4",
+    "express-history-api-fallback": "^2.2.1",
+    "formidable": "^1.2.1",
+    "log4js": "^6.6.1",
+    "lru-cache": "^4.1.5",
+    "md5": "^2.2.1",
+    "moment": "^2.24.0",
+    "mongoose": "^5.4.0",
+    "mysql": "^2.18.1",
+    "mysql2": "^3.1.2",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "qs": "^6.11.0",
+    "request": "^2.88.0",
+    "sequelize": "^6.29.0",
+    "svg-captcha": "^1.3.12",
+    "ws": "^5.2.2",
+    "xml2js": "^0.4.23"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "cjj",
+  "license": "ISC",
+  "bin": "./out/main.js",
+  "pkg": {
+    "scripts": "out/**/*.js",
+    "assets": [
+      "public/**/*",
+      "res/**/*",
+      "images/**/*",
+      "video/**/*"
+    ],
+    "outputPath": "dist"
+  }
+}

serverConfig.xml

+<config>
+    <port>7088</port>
+    <dbConfig>
+        <mysqlHost>192.168.0.105</mysqlHost>
+        <mysqlPort>3306</mysqlPort>
+        <mysqlUser>root</mysqlUser>
+        <mysqlPwd>123456</mysqlPwd>
+        <dataBase>oadb</dataBase>
+    </dbConfig>
+</config>
+ 
\ No newline at end of file

src/biz/askForLeave.ts

+/**
+ * 请假逻辑
+ * 作者:lxm
+ * 包括工时填报
+ */
+
+import moment = require("moment");
+import { ASKFORLEAVETYPE } from "../config/enum";
+import { addData, selectData } from "../data/admin/askForLeave";
+import { changeEnumValue } from "../util/tools";
+
+
+
+/**
+ * 请假
+ * @param des 描述 
+ * @param startTime 开始时间 
+ * @param endTime 结束时间
+ * @param long 时长
+ * @param type 请假类型
+ */
+export async function askForLeave(userId:string, des:string, startTime:number, endTime:number, type:number, time:number, day:number) {
+    
+    let st = new Date(startTime);
+    let et = new Date(endTime);
+
+    await addData(des, st, et, userId, time, type, day);
+
+    return {isSuccess:true, message:"添加成功"}
+}
+
+
+export async function myAskForLeaveList(userId:string) {
+    let dataList = await selectData(userId);
+
+    let result = [];
+    dataList.forEach(info => {
+        let { id, des, startTime, endTime, time, type, day } = info;
+        let changeType = changeEnumValue(ASKFORLEAVETYPE, type);
+        let changeStartTime = moment(startTime).format("YYYY/MM/DD HH:mm");
+        let changeEndTimee = moment(endTime).format("YYYY/MM/DD HH:mm");
+        let timeStr = `${day}日${time}小时`;
+        result.push({id, des, startTime:changeStartTime, endTime:changeEndTimee, time:timeStr, type:changeType});
+    });
+
+    return {dataList:result}
+}

src/biz/project.ts

+import { findAllProjectIdAndName } from "../data/admin/project"
+
+
+
+export async function projectListForSelect() {
+    
+    let projectList = await findAllProjectIdAndName();
+
+    return {dataList:projectList}
+}
\ No newline at end of file

src/biz/user.ts

+/**
+ * 用户管理
+ * 作者:lxm
+ * 包括 登录 改密码 获取权限密码
+ */
+
+import { ERRORENUM } from "../config/errorEnum";
+import { LIMITSLIST } from "../config/systemConfig";
+import * as userData from "../data/admin/user";
+import { BizError } from "../util/bizError";
+import { getToken } from "../util/tools";
+
+
+export async function login(loginId:string, pwd:number) {
+    let userInfo = await userData.findUserByLoginId(loginId);
+    if (!userInfo) throw new BizError(ERRORENUM.登录失败, '用户不存在');
+
+    if (userInfo.pwd != pwd) throw new BizError(ERRORENUM.密码错误, `密码错误 ${pwd}`);
+
+    let token = getToken(userInfo.loginId);
+
+    await userData.updateData({token}, {loginId});
+
+    let limitsList = [LIMITSLIST.工时填报];
+
+    if (userInfo.departmentId == 7 || userInfo.departmentId == 8 || userInfo.departmentId == 6  ) {
+        limitsList.push(LIMITSLIST.工时管理);
+    }
+    if (userInfo.userId == 4) {
+        for (let i = 2; i <=7; i++) {
+            limitsList.push(i);
+        }
+    }
+
+    let result = { token, 
+        userId:userInfo.userId, 
+        roleId:userInfo.roleId, 
+        departmentId:userInfo.departmentId, 
+        name:userInfo.name,
+        headSculpture:`http://192.168.0.105:7088/1.png`,
+        limitsList
+    };
+
+    
+
+    return result;
+}
+
+
+export async function changePwd() {
+    
+}

src/biz/workingLog.ts

+/**
+ * 工时逻辑
+ * 作者:lxm
+ * 包括工时填报
+ */
+
+import moment = require("moment");
+import { ERRORENUM } from "../config/errorEnum";
+import * as projectData from "../data/admin/project";
+import * as workinglogData from "../data/admin/workinglog";
+import { BizError } from "../util/bizError";
+import * as tools from "../util/tools";
+import { findDepartmentMap } from "../data/admin/department";
+import { count } from "console";
+
+
+/**
+ * 填报工时
+ * @param userId 
+ * @param dataList 
+ */
+export async function addWorking(userId:number, time:number, projectId:string, isOutside:boolean, date:string, workLog:string ) {
+
+    const DateKey = tools.getWorkingDateKey(date);
+    let selectKey = moment(date).format("YYYY-MM-DD")+ ' 18:00:00'
+    let timeCount = await workinglogData.findWorkingLogLengthByDateKey(userId, selectKey);
+    if (timeCount + time >= 24) throw new BizError(ERRORENUM.工时填报时长出错, `${timeCount + time } >= 24`);
+    // if (logCount>0) throw new BizError(ERRORENUM.重复提交, `${DateKey}工时填报重复提交`);
+
+    //查找项目编号
+    let projectInfo = await projectData.findOnceProjectById(projectId);
+    if ( !projectInfo ) throw new BizError(ERRORENUM.不存在该项目, `${userId} 填报 ${projectId}`);
+
+    let id = tools.getWorkingLogId(userId);
+
+    let outside = isOutside ? 1 : 0;
+    await workinglogData.addWorkingLog(id, projectId, userId, time, selectKey, outside, workLog);
+
+    return {isSuccess:true, message:"添加成功"};
+}
+
+
+/**
+ * 查看本周填报的工时
+ * 本周的规则是:周一到周日
+ * @param userId 
+ * @returns 
+ */
+export async function workinglogList(userId:number) {
+    //获取这周开始时间
+    // let s = moment(new Date()).weekday(0).format("YYYY-MM-DD") + ' 00:00:00';
+    // let e = moment(new Date()).weekday(6).format("YYYY-MM-DD") + ' 23:59:59';
+    let weekofday = parseInt(moment().format('d')) // 计算今天是这周第几天 周日为一周中的第一天
+    if (weekofday == 0) weekofday = 7;
+    let s = moment().subtract(weekofday,'days').format('YYYY-MM-DD') + ' 00:00:00';// 周-日期
+    let e = moment().add(7 - weekofday, 'days').format('YYYY-MM-DD') + ' 23:59:59';// 周日期
+
+    let thisWeekLog = await workinglogData.findThisWeekWorkingLog(userId, s, e);
+
+    let timeCount = 0;
+    thisWeekLog.forEach(info => {
+        info.dateKey = moment(info.dateKey).format("YYYY-MM-DD");
+        timeCount += info.time;
+        info.isOutside = info.isOutside == 1;
+    })
+    //获取这周结束时间
+    return { dataList:thisWeekLog, timeCount };
+}
+
+
+export async function updateWorkinglog(userId:number, id:string, time:number, projectId:string, isOutside:boolean, workLog:string) {
+    let s = moment().weekday(1).format("YYYY-MM-DD") + ' 00:00:00';
+    let e = moment().weekday(7).format("YYYY-MM-DD") + ' 23:59:59';
+    let thisWeekLog = await workinglogData.findThisWeekWorkingLog(userId, s, e);
+
+    let checkDateKey = 0;
+    thisWeekLog.forEach(info => {
+        if (info.id == id) {
+            checkDateKey = new Date(info.dateKey).getDate();
+        }
+    });
+    if (!checkDateKey) throw new BizError(ERRORENUM.未找到该数据, id);
+
+    let count = time;
+    thisWeekLog.forEach(info => {
+        if (new Date(info.dateKey).getDate() == checkDateKey && info.id != id ) {
+            count += info.time;
+        }
+    });
+    if (count >= 24) throw new BizError(ERRORENUM.工时填报时长出错, `${ count } >= 24`);
+
+    let outside = isOutside ? 1 : 0;
+    await workinglogData.updateWorkinglog(id, projectId, time, outside, workLog);
+
+    return { isSuccess:true, message:"修改成功" };
+}
+
+
+export async function delWorkinglog(userId:number, id:string,) {
+
+    let dataInfo = await workinglogData.findWorkingLogById(id);
+    if (!dataInfo) throw new BizError(ERRORENUM.未找到该数据, id);
+
+    await workinglogData.deleteWorkingLogById(id);
+
+    return { isSuccess:true, message:"删除成功" };
+}
+
+
+/**
+ * 工时管理列表 按时间分
+ * @param page 
+ * @param startMs
+ * @param endMs
+ * @returns 
+ */
+export async function adminWorkLogForTime(page:number, startMs:string, endMs:string) {
+    let s = null;
+    let e = null;
+    if (startMs && endMs) {
+        s = moment(startMs).format("YYYY-MM-DD") + ' 00:00:00';
+        e = moment(endMs).format("YYYY-MM-DD") + ' 23:59:59';
+    }
+    
+
+    let {dataList, count} = await workinglogData.findAllWorkingLogToPage((page-1 )*10, s, e);
+
+    const DepartmentMap = await findDepartmentMap();
+
+    let result = [];
+
+    dataList.forEach(info => {
+        let year = moment(info.dateKey).year();
+        let month = moment(info.dateKey).month()+1;
+        let day = moment(info.dateKey).date();
+        result.push({
+            year,
+            month,
+            day,
+            name:info.name,
+            departmentName : DepartmentMap[info.departmentId],
+            projectName:info.projectName,
+            projectId:info.projectId,
+            workLog:info.workLog,
+            time: info.time
+        });
+    });
+
+    return {dataList:result, total:count };
+}
+
+
+/**
+ * 工时管理列表 按项目分
+ * @param page 
+ * @param startMs 
+ * @param endMs 
+ * @returns 
+ */
+export async function adminWorkLogForProject(page:number, startMs:string, endMs:string) {
+    let s = null;
+    let e = null;
+    if (startMs && endMs) {
+        s = moment(startMs).format("YYYY-MM-DD") + ' 00:00:00';
+        e = moment(endMs).format("YYYY-MM-DD") + ' 23:59:59';
+    }
+    
+    let workingLog = await workinglogData.findAllWorkingLogToProject(s, e);
+
+    let distinctMap = {};// => {name:{id:"", count:0}}
+
+    workingLog.forEach(info => {
+        if (!distinctMap[info.projectName]) distinctMap[info.projectName] = {id:info.projectId, count:0 }
+        distinctMap[info.projectName].count += info.time;
+    });
+
+    let result = [];
+    for (let name in distinctMap) {
+        let {id, count} = distinctMap[name];
+        let dayCount = Math.ceil(count/8 * 100)/100
+        result.push({
+            name,
+            id,
+            hostCount:count,
+            dayCount
+        });
+    }
+
+    return {dataList:result.splice((page-1)*10, 10 ), total:result.length };
+}
+
+
+/**
+ * 导出按时间分的工时管理列表
+ * @param startMs 
+ * @param endMs 
+ * @returns 
+ */
+export async function outPutAdminWorkingLogListForTime(startMs:string, endMs:string) {
+    let s = null;
+    let e = null;
+    if (startMs && endMs) {
+        s = moment(startMs).format("YYYY-MM-DD") + ' 00:00:00';
+        e = moment(endMs).format("YYYY-MM-DD") + ' 23:59:59';
+    }
+    
+    let workingLog = await workinglogData.findAllWorkingLog(s, e);
+
+    const DepartmentMap = await findDepartmentMap();
+
+    let result = [
+        ["日期年","日期月","日期日","部门","姓名","项目名称","项目编号","时长/小时","工作内容"]
+    ];
+
+    workingLog.forEach(info => {
+        let year = moment(info.dateKey).year();
+        let month = moment(info.dateKey).month()+1;
+        let day = moment(info.dateKey).date();
+        let departmentName = DepartmentMap[info.departmentId];
+        let subList = [
+            year,
+            month,
+            day,
+            departmentName,
+            info.name,
+            info.projectName,
+            info.projectId,
+            info.time,
+            info.workLog
+        ]
+        result.push(subList);
+    });
+
+
+    return {dataList:result, name:`【按时间分工时】.xlsx`};
+}
+
+
+/**
+ * 导出按项目分的工时管理列表
+ * @param startMs 
+ * @param endMs 
+ * @returns 
+ */
+export async function outPutAdminWorkingLogListForProject(startMs:string, endMs:string) {
+    let s = null;
+    let e = null;
+    if (startMs && endMs) {
+        s = moment(startMs).format("YYYY-MM-DD") + ' 00:00:00';
+        e = moment(endMs).format("YYYY-MM-DD") + ' 23:59:59';
+    }
+    let workingLog = await workinglogData.findAllWorkingLogToProject(s, e);
+
+    let distinctMap = {};// => {name:{id:"", count:0}}
+
+    workingLog.forEach(info => {
+        if (!distinctMap[info.projectName]) distinctMap[info.projectName] = {id:info.projectId, count:0 }
+        distinctMap[info.projectName].count += info.time;
+    });
+
+    let result = [
+        ["项目名称","项目编号","时长/小时","时长/人天"]
+    ];
+    for (let name in distinctMap) {
+        let {id, count} = distinctMap[name];
+        let dayCount = Math.ceil(count/8 * 100)/100;
+        
+        result.push([name, id, count, dayCount]);
+    }
+    
+    return {dataList:result, name:`【按项目分工时】.xlsx`};
+}
\ No newline at end of file

src/config/enum.ts

+
+export enum ASKFORLEAVETYPE {
+    调休 =1,
+    年假,
+    病假,
+    事假
+}
+
+
+export enum WORKLOGADMINTYPE {
+    按项目分 = 1,
+    按时间分
+}
\ No newline at end of file

src/config/errorEnum.ts

+
+export enum ERRORENUM {
+    登录失败 = 1,
+    密码错误,
+    重复提交,
+    身份验证失败,
+    非法登录,
+    身份验证过期,
+    参数错误,
+    未找到该数据,
+    表单校验失败,
+    工时填报时长出错,
+    不存在该项目,
+
+}
+
+export enum ERRORCODEENUM {
+    身份验证失败 = 401,
+    非法登录 = 402,
+    身份验证过期 = 403
+}
+
+let bizErrorMsgMap = {};
+for (let key in ERRORENUM) {
+    bizErrorMsgMap[ERRORENUM[key]] = key;
+}
+
+export function getBizMsg(param) {
+    return bizErrorMsgMap[param];
+}
\ No newline at end of file

src/config/serverConfig.ts

+const path = require('path');
+import * as fs from "fs";
+import { BizError } from "../util/bizError";
+import { analysisXml } from "../util/myXML";
+import { ServerConfig } from "../config/systemClass";
+const os = require('os');
+
+export let systemConfig =  new ServerConfig;
+
+const ConfigName = "serverConfig.xml";
+export async function initConfig() {
+    try {
+        let buff = fs.readFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), ConfigName));
+        let configStr = buff.toString();
+        let configInfo:any = await analysisXml(configStr);
+		if (!configInfo || !configInfo.config) throw new BizError('xml中无配置');
+		else {
+            
+            let {port, dbConfig } = configInfo.config;
+            systemConfig.port = parseInt(port[0]);
+
+            if (dbConfig) {
+                let dbConfigInfo = dbConfig[0];
+                if (dbConfigInfo.mysqlHost && dbConfigInfo.mysqlPort && dbConfigInfo.mysqlUser && dbConfigInfo.dataBase) {
+                    systemConfig.mysqlHost=dbConfigInfo.mysqlHost[0];
+                    systemConfig.mysqlPort=parseInt(dbConfigInfo.mysqlPort[0]);
+                    systemConfig.mysqlUser=dbConfigInfo.mysqlUser[0];
+                    systemConfig.mysqlPwd=dbConfigInfo.mysqlPwd[0] || "";
+                    systemConfig.dataBase=dbConfigInfo.dataBase[0];
+                }
+            }
+		}
+        
+        console.log("config init success");
+
+    } catch(err) {
+        throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确");
+    }
+}
+
+function analysisMongoConnectStr(path, port, dataBase, w, timeOutMs) {
+    return `mongodb://${path}:${port}/${dataBase}?w=${w}&wtimeoutMS=${timeOutMs}`
+}
+ 
+export function getEnum() {
+    
+}
\ No newline at end of file

src/config/systemClass.ts

+export class ServerConfig {
+    port:number;
+    mysqlHost:string;
+    mysqlPort:number;
+    mysqlUser:string;
+    mysqlPwd:string;
+    dataBase:string;
+}
\ No newline at end of file

src/config/systemConfig.ts

+
+
+export enum LIMITSLIST {
+    工时填报 = 1,
+    加班申请,
+    请假申请,
+    报销申请,
+    会议纪要,
+    工时管理,
+    我的任务
+} 
\ No newline at end of file

src/data/admin/askForLeave.ts

+/**
+ * 请假表
+ */
+
+import { mySqlTableClass } from "../../db/mysqlClass";
+
+const Sequelize =require('sequelize')
+const MySequesize = require('../../db/mysqlInit');  //导入创建的sequelize对象
+//创建StudentModel模型，该模型对应的表名是student
+
+let askforleaveModel;
+export async function initModel() {
+    var model = MySequesize.mysqlDB.define('askforleave',{
+        id:{
+            type:Sequelize.INTEGER, 
+            primaryKey:true,  //表示主键
+            allowNull:false,   //表示当前列是否允许为空，false表示该列不能为空
+            unique:true    //表示该列的值必须唯一
+        },
+        des:{ type:Sequelize.STRING(100) }, 
+        startTime:{ type:Sequelize.DATE, allowNull:false },
+        endTime:{ type:Sequelize.DATE, allowNull:false },
+        userId:{ type:Sequelize.INTEGER, allowNull: false },//填报人
+        approval:{ type:Sequelize.INTEGER, allowNull: false },//填报人
+        time:{ type:Sequelize.INTEGER, allowNull: false },//填报人
+        day:{ type:Sequelize.INTEGER, allowNull: false },//填报人
+        type:{ type:Sequelize.INTEGER, allowNull: false },//填报人
+
+        contractId:{ type:Sequelize.STRING(200),  },//合同号
+       
+        dateKey:{ type:Sequelize.DATE, allowNull:false },//填报时间
+    },{
+        freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
+        timestamps:false  //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
+    });
+    // //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
+    askforleaveModel = await model.sync({});
+
+}
+
+
+export async function addData(des:string, startTime:Date, endTime:Date, userId:string, time:number, type:number, day:number) {
+    await askforleaveModel.create({des, startTime, endTime, userId, time, type, day});
+}
+
+export async function selectData(userId:string) {
+    let dataList = await askforleaveModel.findAll({
+        where:{userId}
+    });
+    return dataList;
+}
\ No newline at end of file

src/data/admin/department.ts

+/**
+ * 部门表
+ */
+
+import { mySqlTableClass } from "../../db/mysqlClass";
+
+
+const Sequelize =require('sequelize')
+const MySequesize = require('../../db/mysqlInit');  //导入创建的sequelize对象
+//创建StudentModel模型，该模型对应的表名是student
+
+let departmentModel;
+export async function initModel() {
+    var model = MySequesize.mysqlDB.define('department',{
+        id:{//项目号
+            type:Sequelize.INTEGER, 
+            primaryKey:true,  //表示主键
+            allowNull:false,   //表示当前列是否允许为空，false表示该列不能为空
+            unique:true    //表示该列的值必须唯一
+        },
+        name:{ type:Sequelize.STRING(100), allowNull:false }, 
+    },{
+        freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
+        timestamps:false  //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
+    });
+    // //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
+    departmentModel = await model.sync({});
+
+}
+
+
+
+export async function findDepartmentMap() {
+    let dataList = await departmentModel.findAll({ });
+
+    let map = {};
+    dataList.forEach(info => {
+        map[info.id] = info.name;
+    });
+    
+    return map;
+}

src/data/admin/overtime.ts

+/**
+ * 加班
+ */
+
+import { mySqlTableClass } from "../../db/mysqlClass";
+
+
+/**表结构 */
+const TableConfig = {
+    id:"string",//
+    projectId:"string",//项目id
+    userId:"number",//用户id
+    dateKey:"date",//日期缩写
+    time:"number",//时长
+    isPassed:"number",//是否通过
+    approver:"number"//审核id
+
+}
+
+/**sql */
+enum SQLENUM {
+
+}
+/**多表sql */
+enum MORETABLESQLENUM {
+
+}
+
+let departmentModel;
+
+export function initModel() {
+    departmentModel = new mySqlTableClass("overtime", TableConfig, SQLENUM, MORETABLESQLENUM);
+}

src/data/admin/project.ts

+/**
+ * 项目表
+ */
+
+import { mySqlTableClass } from "../../db/mysqlClass";
+
+const Sequelize =require('sequelize')
+const MySequesize = require('../../db/mysqlInit');  //导入创建的sequelize对象
+//创建StudentModel模型，该模型对应的表名是student
+
+let projectModel;
+export async function initModel() {
+    var model = MySequesize.mysqlDB.define('project',{
+        id:{//项目号
+            type:Sequelize.STRING(200), 
+            primaryKey:true,  //表示主键
+            allowNull:false,   //表示当前列是否允许为空，false表示该列不能为空
+            unique:true    //表示该列的值必须唯一
+        },
+        name:{ type:Sequelize.STRING(100), allowNull:false }, 
+        contractId:{ type:Sequelize.STRING(200),  },//合同号
+    },{
+        freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
+        timestamps:false  //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
+    });
+    // //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
+    projectModel = await model.sync({});
+
+}
+
+export async function findAllProjectMap() {
+    let projectList = await projectModel.find({});
+
+    let result = {};
+    projectList.forEach(info => {
+        result[info.id] = info.name;
+    });
+
+    return result;
+}
+
+
+export async function findOnceProjectById(projectId:string) {
+    let dataList = await projectModel.findAll({
+        where:{id:projectId}
+    });
+    return dataList[0] || {};
+}
+
+export async function findAllProjectIdAndName() {
+    let dataList = await projectModel.findAll({
+        where:{}
+    });
+    return dataList;
+}
\ No newline at end of file

src/data/admin/role.ts

+/**
+ * 角色表
+ */
+
+import { mySqlTableClass } from "../../db/mysqlClass";
+
+
+/**表结构 */
+const TableConfig = {
+    id:"number",//
+    nameName:"string",//角色名称
+}
+
+/**sql */
+enum SQLENUM {
+
+}
+/**多表sql */
+enum MORETABLESQLENUM {
+
+}
+
+let roleModel;
+
+export function initModel() {
+    roleModel = new mySqlTableClass("role", TableConfig, SQLENUM, MORETABLESQLENUM);
+}

src/data/admin/user.ts

+/**
+ * 用户表
+ */
+
+import { mySqlTableClass } from "../../db/mysqlClass";
+const Sequelize =require('sequelize')
+const MySequesize = require('../../db/mysqlInit');  //导入创建的sequelize对象
+
+let userModel;
+export async function initModel() {
+    var model = MySequesize.mysqlDB.define('users',{
+        userId:{//用户id
+            type:Sequelize.INTEGER, 
+            primaryKey:true,  //表示主键
+            allowNull:false,   //表示当前列是否允许为空，false表示该列不能为空
+            unique:true    //表示该列的值必须唯一
+        },
+        name:{ type:Sequelize.STRING(100), allowNull:false }, //名称
+        loginId:{ type:Sequelize.STRING(200)},//登录id
+        pwd:{ type:Sequelize.STRING(200)},//密码
+        roleId:{ type:Sequelize.INTEGER},//角色id 外键角色表id
+        exchangeTime:{ type:Sequelize.INTEGER},//调休余额
+        annualLeave:{ type:Sequelize.INTEGER},//年假余额
+        departmentId:{ type:Sequelize.INTEGER },//部门id 外键部门表id
+        token:{ type:Sequelize.Sequelize.STRING(200) }
+    },{
+        freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
+        timestamps:false  //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
+    });
+    // //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
+    userModel = await model.sync({});
+
+}
+
+
+/**
+ * 登录账号查询用户
+ * @param loginId 
+ */
+export async function findUserByLoginId(loginId:string) {
+    let dataList = await userModel.findAll({ where:{loginId}});
+    return dataList[0] || {};
+}
+
+
+/**
+ * 登录账号查询用户
+ * @param loginId 
+ */
+export async function findUserByUserId(userId:string) {
+    let dataList = await userModel.findAll({ where:{userId:parseInt(userId)}});
+    return dataList[0] || {};
+}
+
+/**
+ * 修改数据
+ * @param param 修改内容
+ * @param select 修改条件
+ * @returns 
+ */
+export async function updateData(param:object, select:object) {
+    let res = await userModel.update(param, {where:select});
+    console.log();
+}

src/data/admin/workinglog.ts

+/**
+ * 工时表
+ */
+
+import { mysqlDB } from "../../db/mysqlInit";
+const Sequelize =require('sequelize')
+//创建StudentModel模型，该模型对应的表名是student
+
+let workinglogModel;
+export async function initModel() {
+    var model = mysqlDB.define('workinglog',{
+        id:{
+            type:Sequelize.STRING(100), //表示属性的数据类型
+            primaryKey:true,  //表示主键
+            allowNull:false,   //表示当前列是否允许为空，false表示该列不能为空
+            unique:true    //表示该列的值必须唯一
+        },
+        projectId:{ type:Sequelize.STRING(100), allowNull:false }, //项目号
+        userId:{ type:Sequelize.INTEGER, allowNull: false },//填报人
+        time:{ type:Sequelize.INTEGER, allowNull:false },//工时
+        dateKey:{ type:Sequelize.DATE, allowNull:false },//填报时间
+        isOutside:{ type:Sequelize.INTEGER },//是否外出 0=否 1=是
+        workLog:{ type:Sequelize.STRING(200)}, //工作内容
+    },{
+        freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
+        timestamps:false  //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
+    });
+    // //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
+    workinglogModel = await model.sync({});
+}
+
+//获取今日时长
+export async function findWorkingLogLengthByDateKey(userId:number, dateKey:string) {
+    
+    let count = 0;
+    let dataList = await workinglogModel.findAll({
+        where:{userId:userId, dateKey:dateKey}
+    });
+    dataList.forEach(info => {
+        count += info.time;
+    });
+    return count;
+}
+
+
+//获取本周工时记录
+export async function findThisWeekWorkingLog(userId:number, startTime:string, endTime:string) {
+    let sql = `select workinglog.workLog, workinglog.id as id,workinglog.projectId as projectId, project.name as projectName, workinglog.time, workinglog.dateKey, `;
+    sql += `workinglog.isOutside from workinglog INNER JOIN project on project.id = workinglog.projectId where userId = ${userId} and dateKey > "${startTime}" and dateKey < "${endTime}" `
+    let res = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
+    let dataList = [];
+    res.forEach(info => {
+        dataList.push(info);
+    });
+    return dataList;
+}
+
+
+
+
+/**
+ * 获取所有工时记录  按时间分
+ * 带分页
+ * @param startIndex 
+ * @param startTime 
+ * @param endTime 
+ * @returns 
+ */
+export async function findAllWorkingLogToPage(startIndex:number, startTime:string, endTime:string) {
+    let sql = `SELECT workinglog.workLog, workinglog.projectId AS projectId, project.NAME AS projectName, workinglog.time, workinglog.dateKey, workinglog.isOutside, users.name, users.departmentId `;
+    sql += `FROM workinglog INNER JOIN project ON project.id = workinglog.projectId inner JOIN users on users.userId = workinglog.userId `;
+    if (startTime && endTime) {
+        sql += ` where workinglog.dateKey > "${startTime}" and workinglog.dateKey < "${endTime}"`;
+    }
+    sql += `LIMIT ${startIndex},10`;
+    let res = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
+    let dataList = [];
+    res.forEach(info => {
+        dataList.push(info);
+    });
+    let countSql = `SELECT workinglog.workLog, workinglog.projectId AS projectId, project.NAME AS projectName, workinglog.time, workinglog.dateKey, workinglog.isOutside, users.name, users.departmentId `;
+    countSql += `FROM workinglog INNER JOIN project ON project.id = workinglog.projectId inner JOIN users on users.userId = workinglog.userId`
+    if (startTime && endTime) {
+        countSql += ` where dateKey > "${startTime}" and dateKey < "${endTime}"`;
+    }
+    let countRes = await mysqlDB.query(countSql, { type: mysqlDB.QueryTypes.SELECT } );
+    return {dataList, count:countRes.length};
+}
+
+
+/**
+ * 获取所有工时记录  按时间分
+ * 不带分页
+ * @param startTime 
+ * @param endTime 
+ * @returns 
+ */
+export async function findAllWorkingLog( startTime:string, endTime:string) {
+    let sql = `SELECT workinglog.workLog, workinglog.projectId AS projectId, project.NAME AS projectName, workinglog.time, workinglog.dateKey, workinglog.isOutside, users.name, users.departmentId `;
+    sql += `FROM workinglog INNER JOIN project ON project.id = workinglog.projectId inner JOIN users on users.userId = workinglog.userId `
+    if (startTime && endTime) {
+        sql += ` where workinglog.dateKey > "${startTime}" and workinglog.dateKey < "${endTime}"`;
+    }
+    let res = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
+    return res;
+}
+
+/**
+ * 获取所有工时记录 按项目分
+ * @param startTime 
+ * @param endTime 
+ * @returns 
+ */
+export async function findAllWorkingLogToProject(startTime:string, endTime:string) {
+    let sql = `SELECT workinglog.projectId AS projectId, project.NAME AS projectName, workinglog.time `;
+    sql += `FROM workinglog INNER JOIN project ON project.id = workinglog.projectId `;
+    if (startTime && endTime) {
+        sql += ` where workinglog.dateKey > "${startTime}" and workinglog.dateKey < "${endTime}"`;
+    }
+    return await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
+}
+
+//添加工时
+export async function addWorkingLog(id:string, projectId:string, userId:number, time:number, dateKey:string, isOutside:number, workLog:string) {
+    await workinglogModel.create({id, projectId, userId, time, dateKey, isOutside, workLog});
+}
+
+//修改工时信息
+export async function updateWorkinglog(id:string, projectId:string, time:number, isOutside:number, workLog:string) {
+    await workinglogModel.update({projectId, time, isOutside, workLog}, {where:{id}});
+}
+
+
+export async function findWorkingLogById(id:string) {
+    let dataList = await workinglogModel.findAll({
+        where:{id}
+    });
+    return dataList[0] || {};
+}
+
+
+export async function deleteWorkingLogById(id:string) {
+    return await workinglogModel.destroy({where:{id}});
+}
\ No newline at end of file

src/db/initTable.ts

+import * as workinglogData from "../data/admin/workinglog";
+import * as projectData from "../data/admin/project";
+import * as userData from "../data/admin/user";
+import * as departmentData from "../data/admin/department";
+
+
+export async function initTable() {
+    await workinglogData.initModel();
+    await projectData.initModel();
+    await userData.initModel();
+    await departmentData.initModel();
+}
\ No newline at end of file

src/db/mysqlClass.ts

+import { mysqlDB } from "./mysqlInit";
+
+
+/**
+ * mysql数据表实体类
+ */
+export class mySqlTableClass {
+    file;//字段对象
+    tableName;//表名
+    sql;//sql
+    moreTableSql;//多表sql
+
+    constructor(tableName:string, file?, sqlEnum?, moreSqlEnum?) {
+        this.tableName = tableName;
+        this.file = file || {};
+        this.sql = sqlEnum || {};
+        this.moreTableSql = moreSqlEnum || {};
+    }
+
+    /**
+     * 查询单表
+     * @param param 条件参数
+     * @param res 指定返回
+     */
+    async find(param, res?) {
+        let sqlStr = 'select ';
+        if (!res) sqlStr += '* ';
+        else {
+            res.forEach((itemStr, index) => {
+                sqlStr += itemStr;
+                if (index == res.length - 1) sqlStr += ' ';
+                else sqlStr += ', ';
+            });
+        }
+        sqlStr += `from ${this.tableName} `;
+
+        const KeyLength = Object.keys(param).length;
+        
+        let valueList = [];
+        if ( KeyLength > 0) {
+            sqlStr += 'where ';
+            let index = 0;
+            for (let key in param) {
+                sqlStr += `${key} = ?`;
+                valueList.push(param[key]);
+                if (index < KeyLength - 1) sqlStr += 'and ';
+                else sqlStr += ' ';
+                index += 1;
+            }
+        }
+
+        return await mysqlDB.selectData(sqlStr, valueList);
+    }
+
+    /**
+     * 查询单个
+     * @param param 
+     * @param res 
+     * @returns 
+     */
+    async findOne(param, res?) {
+        let sqlStr = 'select ';
+        if (!res) sqlStr += '* ';
+        else {
+            res.forEach((itemStr, index) => {
+                sqlStr += itemStr;
+                if (index == res.length - 1) sqlStr += ' ';
+                else sqlStr += ', ';
+            });
+        }
+        sqlStr += `from ${this.tableName} `;
+
+        const KeyLength = Object.keys(param).length;
+        
+        let valueList = [];
+        if ( KeyLength > 0) {
+            sqlStr += 'where ';
+            let index = 0;
+            for (let key in param) {
+                sqlStr += `${key} = ?`;
+                valueList.push(param[key]);
+                if (index < KeyLength - 1) sqlStr += 'and ';
+                else sqlStr += ' ';
+                index += 1;
+            }
+        }
+
+        return await mysqlDB.findOne(sqlStr, valueList);
+    } 
+
+    /**
+     * 修改
+     * @param table 
+     * @param param 修改信息
+     * @param contition 条件
+     * @returns 
+     */
+    async update(param:object, contition:object) {
+        return await mysqlDB.updateData(this.tableName, param, contition);
+    }
+
+    /**
+     * 删除
+     * @param paramater 
+     * @returns 
+     */
+    async delete(paramater:object) {
+        return await mysqlDB.deleteData(this.tableName, paramater);
+    }
+
+    /**
+     * 创建
+     * @param param 
+     * @returns 
+     */
+    async install(param:object) {
+        return await mysqlDB.createData(this.tableName, param);
+    }
+
+    /**
+     * 执行sql
+     * @param sql 
+     */
+    async query(sql:string, param) {
+        return await mysqlDB.queryData(sql, param);
+    }
+}
\ No newline at end of file

src/db/mysqlInit.ts

+import { systemConfig } from "../config/serverConfig";
+import { initTable } from "./initTable";
+
+const mysql = require('mysql2');
+//导入sequelize模块
+const Sequelize = require('sequelize');
+
+var mysqlDB;
+export async function initMysqlDB() {
+    mysqlDB = new Sequelize(systemConfig.dataBase,systemConfig.mysqlUser,systemConfig.mysqlPwd,{
+        host:systemConfig.mysqlHost,
+        port:systemConfig.mysqlPort,
+        dialect:'mysql',   //数据库类型
+        pool:{  //数据库连接池
+            max:20,  //最大连接对象的个数
+            min:5,  //最小连接对象的个数
+            idle:1000  //最长等待时间，单位为毫秒
+        }
+    });
+    //
+    await initTable();
+}
+
+export { mysqlDB };
\ No newline at end of file

src/main.ts

+import { initConfig, systemConfig} from "./config/serverConfig";
+import { initMysqlDB } from "./db/mysqlInit";
+import { httpServer } from "./net/http_server";
+
+async function lanuch() {
+    await initConfig();//初始化配置解析
+    await initMysqlDB();
+    httpServer.createServer(systemConfig.port);
+    console.log('This indicates that the server is started successfully.');
+}
+
+lanuch();
\ No newline at end of file

src/middleware/fromParam.ts

+var formidable = require("formidable");
+const path = require('path');
+
+export async function parseFormParam(req, res, next) {
+    var form = new formidable.IncomingForm();
+    form.uploadDir = path.join(__dirname.substring(0,__dirname.indexOf("out")), 'files');
+    form.parse(req, (err, fields, files)=>{
+        if (err) {
+            next(err)
+        }
+        else {
+            req.fields = fields;
+            req.files = files;
+            next();
+        }
+    })
+}
\ No newline at end of file

src/middleware/httpErrorHandler.ts

+import { ERRORCODEENUM } from "../config/errorEnum";
+
+/**
+ * 中间件 错误返回
+ * @param err 
+ * @param req 
+ * @param res 
+ * @param next 
+ */
+export function httpErrorHandler(err, req, res, next) {
+    console.log("in httpErrorHandler");
+    console.log(err);
+    //todo 自定义错误编码
+    if (err) {
+        if ( ERRORCODEENUM[err.message] ) {
+            res.success({success:false, msg:err.message, code:ERRORCODEENUM[err.message]});
+            next();
+        }
+        else  {
+            res.success({success:false, msg:err.message, code:500});
+            next();
+        }
+    }
+} 
\ No newline at end of file

src/middleware/user.ts

+import { ERRORENUM } from "../config/errorEnum";
+import { findUserByUserId } from "../data/admin/user";
+import { BizError } from "../util/bizError";
+
+/**
+ * 中间件 校验token
+ * @param req 
+ * @param res 
+ * @param next 
+ * @returns 
+ */
+export async function checkFuHuaQiToken(req, res, next) {
+    if (!req.headers) req.headers = {};
+
+    const reqToken = req.headers.token;
+    const userId = req.headers.userid || "";
+
+    if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
+
+    let userInfo = await findUserByUserId(userId);
+    if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`));
+    
+    
+    if (userInfo.token != reqToken ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${userId} token:${reqToken}`));
+
+    req.headers.userid = userInfo.userId;
+
+    next();
+}
+

src/middleware/watch.ts

+export function watch(req, res, next) {
+    res.success = success.bind({res:res, req:req});
+    
+    return next();
+}
+
+/**
+ * 中间件正确返回方法
+ * @param data 
+ */
+function success(data) {
+    let resultPack;
+    if (data ) {
+        if ( data.success === undefined || data.success === true ) {
+            resultPack = {data, success:true, code:200};
+        }
+        else {
+            resultPack = data;
+        }
+    }else {
+        resultPack = {code:500, success:false, msg:'result is null'};
+    }
+    this.res.send(resultPack);
+}
+

src/net/http_server.ts

+import express = require('express');
+import bodyParser = require('body-parser');
+import routers = require('../routers/router');
+import compression = require('compression');
+import { watch } from '../middleware/watch';
+import { httpErrorHandler } from '../middleware/httpErrorHandler';
+import * as path from "path";
+import * as fallback from 'express-history-api-fallback';
+
+export class httpServer {
+    static createServer(port:number) {
+        var httpServer = express();
+
+        httpServer.all('*', (req, res, next) => {
+            res.header('Access-Control-Allow-Origin', req.headers.origin);
+            res.header("Access-Control-Allow-Headers", "X-Requested-With");
+            res.header('Access-Control-Allow-Headers', 'Content-Type,request-origin,userid,token');
+            res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
+            res.header('Access-Control-Allow-Credentials', true);
+            res.header("X-Powered-By", ' 3.2.1');
+            next();
+            // if(req.method === 'OPTIONS'){
+            //     res.statusCode = 200;
+            //     res.end();
+            //   }else{
+            //       next();
+            //   }
+        });
+
+        httpServer.use(express.static("./images") );
+        const root = path.join(__dirname, "../../public");
+        httpServer.use(express.static(root));
+        httpServer.use(fallback('index.html', { root }));
+        httpServer.use(bodyParser.json({limit:"1000kb"}));
+        httpServer.use(compression());
+        httpServer.use(watch);
+        routers.setRouter(httpServer);
+        httpServer.use(httpErrorHandler);
+        httpServer.listen(port);
+        console.log('server listen on port:'+port);
+    }
+}
\ No newline at end of file

src/routers/askForLeave.ts

+/**
+ * 请假
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import * as askForLeaveBiz from '../biz/askForLeave';
+import { checkFuHuaQiToken } from '../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/askforleave/add', checkFuHuaQiToken, asyncHandler(add));
+    httpServer.post('/askforleave/list', checkFuHuaQiToken, asyncHandler(list));
+}
+
+async function add(req, res) {
+    let userId = req.headers.userid;
+    let { day, time, des, startTime, endTime, type} = req.body;
+    let result = await askForLeaveBiz.askForLeave(userId, des, startTime, endTime, type, time, day);
+    res.success(result);
+}
+
+
+async function list(req, res) {
+    let userId = req.headers.userid;
+   
+    let result = await askForLeaveBiz.myAskForLeaveList(userId);
+    res.success(result);
+}
\ No newline at end of file

src/routers/public.ts

+/**
+ * 公共资源路由
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import { ASKFORLEAVETYPE, WORKLOGADMINTYPE } from '../config/enum';
+import { projectListForSelect } from '../biz/project';
+
+export function setRouter(httpServer) {
+    httpServer.post('/public/askforleavetype', asyncHandler(askForLeave));
+    httpServer.post('/public/projectlist', asyncHandler(projectList));
+    httpServer.post('/public/adminworkingtype', asyncHandler(adminWorkingType));
+}
+
+
+async function adminWorkingType(req, res) {
+    let dataList = [];
+    for (let key in WORKLOGADMINTYPE) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            dataList.push({key, value:WORKLOGADMINTYPE[key]});
+        }
+    }
+    res.success({dataList});
+}
+
+/**
+ * @param req 
+ * @param res 
+ */
+async function askForLeave(req, res) {
+    let dataList = [];
+    for (let key in ASKFORLEAVETYPE) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            dataList.push({key, value:ASKFORLEAVETYPE[key]});
+        }
+    }
+    res.success({dataList});
+}
+
+
+/**
+ * @param req 
+ * @param res 
+ */
+async function projectList(req, res) {
+    let result = await projectListForSelect();
+    res.success(result);
+}
+

src/routers/router.ts

+/**
+ * 总路由入口
+ */
+
+import * as userRouters from './user'
+import * as publicRouters from './public'
+import * as askForLeaveRouters from './askForLeave'
+import * as workingLogRouters from './workingLog'
+
+
+export function setRouter(httpServer){
+    userRouters.setRouter(httpServer);
+    publicRouters.setRouter(httpServer);
+    askForLeaveRouters.setRouter(httpServer);
+    workingLogRouters.setRouter(httpServer);
+}
\ No newline at end of file

src/routers/user.ts

+/**
+ * 用户路由
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import * as tools from '../util/tools';
+import * as userBiz from '../biz/user';
+import { checkFuHuaQiToken } from '../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/user/login', asyncHandler(login));
+}
+
+
+async function login(req, res) {
+    let reqConf = {loginId:'String', pwd:'String'};
+    let {loginId, pwd} = tools.checkReqParam(reqConf, req.body);
+
+    let userInfo = await userBiz.login(loginId, pwd);
+
+    res.success(userInfo);
+}

src/routers/workingLog.ts

+/**
+ * 工时路由
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import * as workingLogBiz from '../biz/workingLog';
+import { checkFuHuaQiToken } from '../middleware/user';
+import { eccReqParamater } from '../tools/eccParam';
+import { eccEnumValue } from '../tools/eccEnum';
+import { WORKLOGADMINTYPE } from '../config/enum';
+
+export function setRouter(httpServer) {
+    httpServer.post('/workinglog/find', checkFuHuaQiToken, asyncHandler(find));
+    httpServer.post('/workinglog/add', checkFuHuaQiToken, asyncHandler(add));
+    httpServer.post('/workinglog/del', checkFuHuaQiToken, asyncHandler(del));
+    httpServer.post('/workinglog/update', checkFuHuaQiToken, asyncHandler(update));
+    /**工时管理 */
+    httpServer.post('/workinglog/admin/list', checkFuHuaQiToken, asyncHandler(workginLogAdminList));
+    httpServer.post('/workinglog/admin/outputlist', checkFuHuaQiToken, asyncHandler(outPutList));
+}
+
+/**
+ * 工时管理列表
+ * @param req 
+ * @param res 
+ */
+async function workginLogAdminList(req, res) {
+    let  reqConf = {page: 'Number', type:'Number', startMs:'String', endMs:"String"};
+    let { page, type, startMs, endMs } = eccReqParamater(reqConf, req.body, ['startMs', 'endMs'] );
+
+    eccEnumValue("工时管理列表", type, WORKLOGADMINTYPE, type);
+    
+    let result:any = {};
+    if (type == WORKLOGADMINTYPE.按时间分) result = await workingLogBiz.adminWorkLogForTime(page, startMs, endMs);
+    else result = await workingLogBiz.adminWorkLogForProject(page, startMs, endMs);
+    result.type = type;
+
+    res.success(result);
+}
+
+
+/**
+ * 导出 工时管理列表 
+ * @param req 
+ * @param res 
+ */
+async function outPutList(req, res) {
+    let  reqConf = {type:'Number', startMs:'String', endMs:"String"};
+    let { type, startMs, endMs } = eccReqParamater(reqConf, req.body, ['startMs', 'endMs'] );
+    eccEnumValue("工时管理列表", type, WORKLOGADMINTYPE, type);
+
+    let result:any = {};
+    if (type == WORKLOGADMINTYPE.按时间分) result = await workingLogBiz.outPutAdminWorkingLogListForTime(startMs, endMs);
+    else result = await workingLogBiz.outPutAdminWorkingLogListForProject(startMs, endMs);
+
+    res.success(result);
+}
+
+
+
+async function find(req, res) {
+    let userId = req.headers.userid;
+    let result = await workingLogBiz.workinglogList(userId);
+    res.success(result);
+}
+async function add(req, res) {
+    let userId = req.headers.userid;
+    let  reqConf = {time: 'Number', projectId: 'String', isOutside: 'Boolean', date:'String', workLog:"String"};
+    let { time, projectId, isOutside, date, workLog} = eccReqParamater(reqConf, req.body, ['workLog']);
+    // let { time, projectId, isOutside, date} = req.body;
+
+    let result = await workingLogBiz.addWorking(userId, time, projectId, isOutside, date, workLog);
+    res.success(result);
+}
+
+async function del(req, res) {
+    let userId = req.headers.userid;
+    let { id } = req.body;
+    let result = await workingLogBiz.delWorkinglog(userId, id);
+    res.success(result);
+}
+
+async function update(req, res) {
+    let userId = req.headers.userid;
+    let  reqConf = {id:"String", time: 'Number', projectId: 'String', isOutside: 'Boolean', workLog:"String"};
+    let {id, time, projectId, isOutside, workLog} = eccReqParamater(reqConf, req.body, ['workLog']);
+
+    let result = await workingLogBiz.updateWorkinglog(userId, id, time, projectId, isOutside, workLog);
+    res.success(result);
+}
\ No newline at end of file

src/tools/eccEnum.ts

+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "../util/bizError";
+
+/**
+ * 校验value是否符合传入的枚举
+ * @param name 被掉用名称 用于输出异常日志
+ * @param key 目标字段  用于输出异常日志
+ * @param enumConf 目标枚举
+ * @param value 目标值
+ * 无返回 有异常直接报错
+ */
+export function eccEnumValue(name:string, key:string, enumConf, value:any) {
+    let eccSuccess = true;
+    if ( typeof value == 'number' ) {
+        if (!enumConf[value] ) eccSuccess = false;
+    } else if (Array.isArray(value)) {
+        value.forEach(item => {
+            if ( !enumConf[item] ) eccSuccess = false;
+        });
+    }
+    
+    if (!eccSuccess) throw new BizError(ERRORENUM.表单校验失败, `${name} 下的 ${key} 字段值为 ${value} 不满足枚举范围`);
+}

src/tools/eccParam.ts

+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "../util/bizError";
+
+/**
+ * 根据conf配置校验请求参数
+ * @param conf 配置
+ * @param param 表单
+ * @param skipKeys []不必填的字段
+ */
+export function eccReqParamater(conf:object, param, skipKeys?) {
+    skipKeys = skipKeys || [];
+    for (let key in conf) {
+        let type = conf[key];
+        let value = param[key];
+
+        let isError = false; //校验是否异常
+        let errorStr = "";//异常说明
+
+        if ( (typeof value != 'boolean') && !value ) {
+            if (skipKeys.indexOf(key) < 0 ) {
+                isError = true;
+                errorStr = `缺少 ${key} 字段`;
+            }
+        } else if(param[key]) {
+            let paramType = typeof param[key];
+            switch(conf[key]) {
+                case 'Number':
+                    if ( paramType != 'number' )  isError = true;
+                break;
+                case 'String':
+                    if ( paramType != 'string' ) isError = true;
+                break;
+                case 'Boolean':
+                    if ( paramType != 'boolean' ) isError = true;
+                break;
+                case '[Number]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'number' ) {
+                            isError = true;
+                            errorStr = `${key}应是number型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
+                case '[Object]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'object' ) {
+                            isError = true;
+                            errorStr = `${key}应是object型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
+            }
+            errorStr = isError && errorStr == "" ? `${key}应该是${type}型 而不是${paramType}`: errorStr;
+        }
+
+        if (isError) throw new BizError(ERRORENUM.参数错误, errorStr);
+        
+    }
+    for (let key in param) {
+        if (!conf[key]) throw new BizError(ERRORENUM.参数错误, `多余${key}字段`);
+    }
+    return param;
+}

src/util/bizError.ts

+import { getBizMsg } from "../config/errorEnum";
+import { logError } from "./log";
+
+export class BizError extends Error {
+    constructor(...msgs) {
+        let reqErrorMsg = '';
+        let logErrorMsg = '';
+        for (let i = 0; i <msgs.length; i++) {
+            if (!i) {
+                let msg = getBizMsg(msgs[i]);
+                reqErrorMsg = msg;
+                logErrorMsg = msg;
+            } else {
+                logErrorMsg += ` | ${msgs[i]} `;
+            }
+        }
+
+        logError(logErrorMsg);
+        super(reqErrorMsg);
+    }
+}

src/util/log.ts

+let log4js = require('log4js');
+let path = require('path');
+
+//log路径
+export const systemLogPath = {
+    errorLogFile:"error",
+    errorLogDir:"error",
+    handleLogFile:"handle",
+    handleLogDir:"handle"
+}
+
+//日志根目录
+// let baseLogPath = path.resolve(__dirname.substring(0, __dirname.indexOf("out")), 'logs');
+let baseLogPath = path.resolve('./', 'logs');
+let errFile = path.resolve(baseLogPath, systemLogPath.errorLogDir, systemLogPath.errorLogFile);
+let handFile =path.resolve(baseLogPath, systemLogPath.handleLogDir, systemLogPath.handleLogFile);
+let config = {
+    appenders:
+        {
+            "rule-console": {"type": "console"},
+            "errorLogger": {
+                "type": "dateFile", // 日志类型
+                "filename": errFile, // 输出文件名
+                "pattern": "-yyyy-MM-dd.log", // 后缀
+                "alwaysIncludePattern": true, // 上面两个参数是否合并
+                "encoding": "utf-8", // 编码格式
+                "maxLogSize": 1000, // 最大存储内容
+                "numBackups": 3, // 当文件内容超过文件存储空间时，备份文件的数量
+                "path": `/${systemLogPath.errorLogDir}`
+            },
+            "handleLogger": {
+                "type": "dateFile",
+                "filename":  handFile,
+                "pattern": "-yyyy-MM-dd.log",
+                "alwaysIncludePattern": true,
+                "encoding": "utf-8",
+                "maxLogSize": 1000,
+                "numBackups": 3,
+                "path": `/${systemLogPath.handleLogDir}`
+            }
+          
+        },
+    categories: {
+        "default": {"appenders": ["rule-console"], "level": "all"}, //这个配置一定要有
+        "errorLogger": {"appenders": ["errorLogger"], "level": "error"},
+        "handleLogger": {"appenders": ["handleLogger"], "level": "all"}
+    },
+    "baseLogPath": path.resolve(baseLogPath, systemLogPath.handleLogDir, systemLogPath.handleLogFile)
+};
+
+log4js.configure(config);  //加载配置文件
+
+//调用预先定义的日志名称
+let errorLogger = log4js.getLogger("errorLogger");
+let handleLogger = log4js.getLogger("handleLogger");
+let consoleLogger = log4js.getLogger("rule-console");
+
+//错误日志
+export function logError(...errStrs) {
+    let str = "";
+    errStrs.forEach(item => {
+        str += item + " |  ";
+    });
+    errorLogger.error(`errorInfo =>   ${str}`);
+}
+
+//普通日志
+export function logHandle(msgStr:string) {
+    handleLogger.info(`logInfo =>    ${msgStr}`);
+}
+
+//输出日志
+export function logConsole(logStr:string) {
+    consoleLogger.info(`logInfo =>   ${logStr}`);
+}

src/util/myXML.ts

+var xml2js = require("xml2js");
+
+
+/**
+ * 
+ * @param str 需要解析的xml文本
+ * @returns 解析好的对象
+ */
+export function analysisXml(str) {
+    return new Promise( (resolve, reject) => {
+        xml2js.parseString(str, (err, result) => {
+            if (err) return reject(err);
+            return resolve(result);
+        });
+    });
+   
+}
\ No newline at end of file

src/util/request.ts

+import * as request from 'request';
+import { BizError } from './bizError';
+
+export function get(url:string, query?, headers?) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        let paramater:any = { url, json:true };
+        if (query) paramater.qs = query;
+        if (headers) paramater.headers = headers;
+        request.get(paramater, function (err, r, body) {
+            if (err) return reject(err);
+            if (r && r.statusCode != 200) return reject(new Error('httpError:'+r.statusCode));
+            resolve(body);
+        });
+    })
+}
+
+
+export function post(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    let header = {"content-type": "application/json"};  
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            headers: Object.assign(header, headers),
+            body: body
+        }, function(error, response, body) {
+            if (!error && response.statusCode == 200) {
+                resolve(body);
+            }
+            else {
+                reject(error)
+            }
+        });
+    })
+}
+
+export function postForm(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            form:body
+        }, function(error, response, res) {
+            if (!error) {
+                resolve(res);
+            }
+            else {
+                reject(error)
+            }
+        });
+    })
+}

tsconfig.json

+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2017",
+    "sourceMap": true,
+    "rootDir":"./src",
+    "outDir":"./out"
+  },
+  "exclude": [
+    "node_modules"
+  ]
+} 
\ No newline at end of file