Skip to content

O
oaServer
Commit 1491cd7f by lixinming
Options

2.0

parent d52a5312
Showing with 1560 additions and 966 deletions
serverConfig.xml
<config> <config>
<port>7088</port> <port>7088</port>
<dbConfig> <dbConfig>
<!-- 本地mysql配置 -->
<mysqlHost>192.168.0.105</mysqlHost> <mysqlHost>192.168.0.105</mysqlHost>
<mysqlPort>3306</mysqlPort> <mysqlPort>3306</mysqlPort>
<mysqlUser>root</mysqlUser> <mysqlUser>root</mysqlUser>
<mysqlPwd>123456</mysqlPwd> <mysqlPwd>123456</mysqlPwd>
<dataBase>oadb</dataBase> <dataBase>oadb</dataBase>.
<!-- 服务器mysql配置 -->
<!-- <mysqlHost>127.0.0.1</mysqlHost>
<mysqlPort>3306</mysqlPort>
<mysqlUser>root</mysqlUser>
<mysqlPwd>Yfs123456_</mysqlPwd>
<dataBase>yfs</dataBase> -->
</dbConfig> </dbConfig>
</config> </config>
\ No newline at end of file
src/biz/attendance.ts
/** /**
* 出勤表 逻辑 * 出勤
*/ */
import moment = require("moment"); import moment = require("moment");
import { getWorkLogListByTime } from "../data/admin/workinglog"; import { selectDataToTableAssociation } from "../model/findData";
import { ASKFORLEAVETYPE, STATED, TABLENAMEENUM } from "../config/enum";
import { changeEnumValue } from "../util/piecemeal";
/**
* 出勤列表
* @param year
* @param month
* @returns
*/
export async function getAttendanceData(year:number, month:number) { export async function getAttendanceData(year:number, month:number) {
let startTime = moment(`${year}-${month >=10 ? ''+month : '0'+month}-01 00:00:00`).format("YYYY-MM-DD") + ' 00:00:00';
let startTime = moment(`${year}-${month}-1 00:00:00`).format("YYYY-MM-DD HH:mm:SS"); let endTime = moment(`${year}-${month >=10 ? ''+month : '0'+month}-01 00:00:00`).add(1, 'months').format("YYYY-MM-DD") + ' 00:00:00';
let endTime = moment(`${year}-${month}-1 00:00:00`).add(1, 'months').format("YYYY-MM-DD HH:mm:SS");
let workLog = await getWorkLogListByTime(startTime, endTime); /**查询工时 */
let selectParam = {
dateKey:{"%between%":[startTime, endTime]}
};
let includeConf = {};
includeConf[TABLENAMEENUM.用户表] = ["name"];
let workLog = await selectDataToTableAssociation(TABLENAMEENUM.工时表, includeConf, selectParam, ["dateKey", "time"]);
//获取日历标题 //获取日历标题
let tileList = [{label:"姓名", prop:"name", index:0}]; let tileList = [{label:"姓名", prop:"name", index:0}];
let dataCount = moment(startTime).daysInMonth(); let dataCount = moment(startTime).daysInMonth();
for (let i = 1; i <= dataCount; i++) { for (let i = 1; i <= dataCount; i++) {
let dateKey = moment(`${year}-${month}-${i} 00:00:00`).format("MM-DD"); let dateKey = moment(`${year}-${month >=10 ? ''+month : '0'+month}-${i >=10 ? ''+i : '0'+i} 00:00:00`).format("MM-DD");
tileList.push({label:dateKey, prop:dateKey, index:i}); tileList.push({label:dateKey, prop:dateKey, index:i});
// let weekDays = moment(dateKey).day();
// if (weekDays == 0 || weekDays == 6) {
// jumpMap[dateKey] = "-";
// } else {
// }
} }
let dataMap = {}; let dataMap = {};
workLog.forEach(info => { workLog.forEach(info => {
let {dateKey, name, time} = info; let {dateKey, user, time} = info;
let name = user.name;
let key = moment(dateKey).format("MM-DD"); let key = moment(dateKey).format("MM-DD");
if (!dataMap[name]) dataMap[name] = {name}; if (!dataMap[name]) dataMap[name] = {name};
if (!dataMap[name][key] ) dataMap[name][key] = 0; if (!dataMap[name][key] ) dataMap[name][key] = 0;
dataMap[name][key] += time; dataMap[name][key] += time;
}) });
/**查询请假 */
let askSelectParam = {
endTime:{"%gt%":startTime},
state:STATED.是
};
let askIncludeConf = {};
askIncludeConf[TABLENAMEENUM.用户表] = ["name"];
let askLog = await selectDataToTableAssociation(TABLENAMEENUM.请假, askIncludeConf, askSelectParam, ["startTime", "endTime", "time", "type", "day"]);
askLog.forEach(info => {
let {user, time, startTime, endTime, type, day} = info;
if (!dataMap[user.name]) dataMap[user.name] = {name:user.name};
let askDay = moment(endTime).diff(moment(startTime), 'days');
if (askDay > 0) {
for (let i = 0; i < askDay; i++) {
let dayKey = moment(startTime).add(i, 'days').format("MM-DD");
if (!dataMap[user.name][dayKey]) dataMap[user.name][dayKey] = `${changeEnumValue(ASKFORLEAVETYPE, type)}`;
}
} else if (askDay == 0) {
let dayKey = moment(startTime).format("MM-DD");
dataMap[user.name][dayKey] = `${changeEnumValue(ASKFORLEAVETYPE, type)}${(day*8)+time}h`;
}
});
let dataList = Object.values(dataMap); let dataList = Object.values(dataMap);
......
src/biz/member.ts 0 → 100644
import { APPROVETYPE, ASKFORLEAVETYPE, DEPARTMENTENUM, TABLENAMEENUM } from "../config/enum";
import { selectDataListByParam, selectDataToTableAssociation, selectOneDataByParam } from "../model/findData";
import moment = require("moment");
import { updateManyData } from "../model/updateData";
import { getDBTime } from "../util/myTools";
/**
* 成员列表
* @returns
*/
export async function getMemberList() {
let includeConf = {};
includeConf[TABLENAMEENUM.部门表] = {colum:["name"], where:{departmentId:{"%in%":[DEPARTMENTENUM.开发, DEPARTMENTENUM.设计, DEPARTMENTENUM.项目经理, DEPARTMENTENUM.人事]}} };
includeConf[TABLENAMEENUM.角色表] = {colum:["roleName"], where:{} };
let column = ["userId", "name", "ed", "roleId", "departmentId", "annualLeave"];
let userList = await selectDataToTableAssociation(TABLENAMEENUM.用户表, includeConf, {state:1}, column);
let dataList = [];
for (let i = 0; i < userList.length; i++) {
let info = userList[i];
let {userId, name, ed, department, annualLeave} = info;
let monthDifference = 0;
let annualLeaveCount = 0;
let monthNum = new Date(ed).getMonth()
let longStr = ``;
if (ed) monthDifference = -1 * moment(ed).diff(moment(), 'months');
else {
ed = "-";
longStr = "-";
}
if (monthDifference >= 12) {
/**满一年 */
let year = Math.floor(monthDifference/12);
longStr = `${year}年`;
if (monthDifference%12) longStr += `${monthDifference%12}个月`;
annualLeaveCount = year + 5 > 10 ? 10 : year + 5;
} else {
/**未满一年 */
longStr = `${monthDifference}个月`;
annualLeaveCount = Math.round((12 - monthNum)/12*5);
}
let {cto, annual} = await findUserAskCount(userId);
dataList.push({
userId,
name,
departmentName:department.name,
ed,
longStr,
annualLeaveCount,
nowALeave:annual/8,
cto
});
}
return {dataList};
}
// /**
// * 校验年假 test
// */
// export async function eccMemberTime() {
// let includeConf = {};
// includeConf[TABLENAMEENUM.部门表] = {colum:["name"], where:{departmentId:{"%in%":[DEPARTMENTENUM.开发, DEPARTMENTENUM.设计, DEPARTMENTENUM.项目经理, DEPARTMENTENUM.人事]}} };
// includeConf[TABLENAMEENUM.角色表] = {colum:["roleName"], where:{} };
// let column = ["userId", "name", "ed", "roleId", "departmentId", "annualLeave"];
// let userList = await selectDataToTableAssociation(TABLENAMEENUM.用户表, includeConf, {state:1}, column);
// let annMap = {};
// for (let i = 0; i < userList.length; i++) {
// let info = userList[i];
// let {userId, name, ed, department} = info;
// let monthDifference = 0;
// let annualLeaveCount = 0;
// let monthNum = new Date(ed).getMonth()
// let longStr = ``;
// if (ed) monthDifference = -1 * moment(ed).diff(moment(), 'months');
// else {
// ed = "-";
// longStr = "-";
// }
// if (monthDifference >= 12) {
// /**满一年 */
// let year = Math.floor(monthDifference/12);
// longStr = `${year}年`;
// if (monthDifference%12) longStr += `${monthDifference%12}个月`;
// annualLeaveCount = year + 5 > 10 ? 10 : year + 5;
// } else {
// /**未满一年 */
// longStr = `${monthDifference}个月`;
// annualLeaveCount = Math.round((12 - monthNum)/12*5);
// }
// annMap[userId] = annualLeaveCount * 8;
// }
// let askList = await selectDataListByParam(TABLENAMEENUM.请假, {state:APPROVETYPE.通过, type:2}, [ "day", "userId", "time", "type"]);
// let nianjia = {};
// askList.forEach(info => {
// let {userId, time, day} = info;
// let itemCount = time + (day*8);
// if (!nianjia[userId]) nianjia[userId] = 0;
// nianjia[userId] += itemCount;
// });
// for (let key in annMap) {
// let dNum = annMap[key] - (nianjia[key] || 0);
// updateManyData(TABLENAMEENUM.用户表, {userId:key}, {annualLeave:dNum});
// }
// console.log("数据校验成功");
// }
export async function updateMemberData(userId:number, edTime:string) {
let ed = getDBTime(edTime);
await updateManyData(TABLENAMEENUM.用户表, {userId}, {ed});
return {isSuccess:true};
}
/**
* 用户下拉框
* @returns
*/
export async function memberSelectList() {
let result = await selectDataListByParam(TABLENAMEENUM.用户表, {}, ["userId", "name"]);
let dataList = [];
result.forEach(info => {
dataList.push({
value:info.userId,
label:info.name
});
});
return {dataList};
}
/**
* 部门用户下拉框
* @param departmentId
* @returns
*/
export async function getDepartmentUserList(departmentId:number) {
let userList = await selectDataListByParam(TABLENAMEENUM.用户表, {departmentId}, ["userId", "name"]);
let dataList = [];
userList.forEach(info => {
dataList.push({
value:info.userId,
label:info.name
});
});
return {dataList};
}
/**
* 获取用户剩余调休和剩余年假时长
* @param userId 目标用户
* @returns {result:{cto:调休, annual:年假}}
*/
export async function findUserAskCount(userId:number) {
let askList = await selectDataListByParam(TABLENAMEENUM.请假, {userId, state:APPROVETYPE.通过}, [ "day", "time", "type"]);
let tiaoXiu = 0;
askList.forEach(info => {
let {type, day, time} = info;
let itemLong = 0;
if (day != 0) itemLong += day*8;
if (time != 0) itemLong += time;
if (type == ASKFORLEAVETYPE.调休) {
tiaoXiu += itemLong;
}
});
let otList = await selectDataListByParam(TABLENAMEENUM.加班, {userId, state:APPROVETYPE.通过}, ["time"]);
let ovCount = 0;//加班时间
otList.forEach(info => {
ovCount += info.time || 0;
});
let cto = ovCount - tiaoXiu;
let thisUserInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {userId}, ["annualLeave"]);
let annual = thisUserInfo.annualLeave || 0;
return {cto, annual};
}
\ No newline at end of file
src/biz/overtime.ts
/**
* 加班
*/
import moment = require("moment"); import moment = require("moment");
import { addOvertime, delOvertime, findOvertime, findOvertimeApprove, findOvertimeByApprover, findOvertimeById, updateOvertime, updateOvertimeState } from "../data/admin/overtime"; import { APPROVETYPE, ROLEENUM, STATED, SYSTEMCONSTCONFIGENUM, TABLENAMEENUM } from "../config/enum";
import * as tools from "../util/tools"; import { selectDataListByParam, selectDataToTableAssociation, selectOneDataByParam } from "../model/findData";
import * as projectData from "../data/admin/project";
import { BizError } from "../util/bizError"; import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum"; import { ERRORENUM } from "../config/errorEnum";
import { findDepartmentRole, findUserByUserIdNum } from "../data/admin/user"; import { queue } from "./system";
import { findAskforleaveByUserIdAndType } from "../data/admin/askForLeave"; import { getOvertimeId } from "../util/myTools";
import { APPROVETYPE, ASKFORLEAVETYPE, STATED } from "../config/enum"; import { addData } from "../model/addData";
import { findUserAskCount } from "./member";
import { updateManyData } from "../model/updateData";
import { delData } from "../model/delData";
/** /**
...@@ -19,60 +24,65 @@ import { APPROVETYPE, ASKFORLEAVETYPE, STATED } from "../config/enum"; ...@@ -19,60 +24,65 @@ import { APPROVETYPE, ASKFORLEAVETYPE, STATED } from "../config/enum";
* @returns {isSuccess:true, message:"添加成功"} * @returns {isSuccess:true, message:"添加成功"}
*/ */
export async function addOvertimeLog(userId:number, time:number, projectId:string, date:string, workLog:string ) { export async function addOvertimeLog(userId:number, time:number, projectId:string, date:string, workLog:string ) {
let selectKey = moment(date).format("YYYY-MM-DD")+ ' 18:00:00' let dateKey = moment(date).format("YYYY-MM-DD")+ ' 18:00:00'
//查找项目编号 //查找项目编号
let projectInfo = await projectData.findOnceProjectById(projectId); let projectInfo = await selectOneDataByParam(TABLENAMEENUM.项目表, {projectId}, []);
if ( !projectInfo ) throw new BizError(ERRORENUM.不存在该项目, `${userId} 填报 ${projectId}`); if ( !projectInfo ) throw new BizError(ERRORENUM.不存在该项目, `${userId} 填报 ${projectId}`);
//获取个人信息 //获取个人信息
let userInfo = await findUserByUserIdNum(userId); let userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {userId}, []);
let approver = 0; let approver = 0;
if (userInfo.roleId == 6) { if (userInfo.roleId == ROLEENUM.员工) {
let approverInfo = await findDepartmentRole(5, userInfo.departmentId); approver = queue[SYSTEMCONSTCONFIGENUM.部门经理][userInfo.departmentId].userId;
approver = approverInfo.userId; } else if (userInfo.roleId == ROLEENUM.部门经理) {
} else { approver = queue[SYSTEMCONSTCONFIGENUM.加班默认].userId;
approver = 17;//默认给张老师审批
} }
let id = tools.getOvertimeId(userId); let id = getOvertimeId(userId);
await addOvertime(id, projectId, userId, time, selectKey, workLog, approver); let addInfo = {id, projectId, userId, time, state:STATED.否, dateKey, workLog, approver};
await addData(TABLENAMEENUM.加班, addInfo);
return {isSuccess:true, message:"添加成功"}; return {isSuccess:true, message:"添加成功"};
} }
/** /**
* 查看 * 加班列表
* @param userId 填报人 * @param userId 填报人
* @returns { 本周填报的工时信息, 本月工时统计 } * @returns { 本周填报的工时信息, 本月工时统计 }
*/ */
export async function overtimeList(userId:number) { export async function overtimeList(userId:number) {
let includeConf = {};
includeConf[TABLENAMEENUM.项目表] = ["name", "projectId"];
let column = ["id", "userId", "time", "dateKey", "workLog", "state", "projectId"];
let overtimeLog = await selectDataToTableAssociation(TABLENAMEENUM.加班, includeConf, {userId}, column);
let overtimeLog = await findOvertime(userId);
let projectMap = await projectData.findAllProjectMap();
overtimeLog.sort((a, b) => {return new Date(b.dateKey).valueOf() - new Date(a.dateKey).valueOf() }); overtimeLog.sort((a, b) => {return new Date(b.dateKey).valueOf() - new Date(a.dateKey).valueOf() });
let notApprove = 0; let notApprove = 0;
let dataList = []; let dataList = [];
let overtimeCount = 0; let overtimeCount = 0;
let approveCount = 0;
overtimeLog.forEach(info => { overtimeLog.forEach(info => {
let {id, projectId, userId, time, dateKey, isOutside, workLog, state } = info; let {id, projectId, userId, time, dateKey, workLog, state, project } = info;
notApprove += state == 0 ? time : 0; notApprove += state == 0 ? time : 0;
approveCount += state == APPROVETYPE.通过 ? time : 0;
overtimeCount += time; overtimeCount += time;
let stateStr = "未审批" let stateStr = "未审批"
if (state) stateStr = state == APPROVETYPE.通过 ? "通过" : "未通过"; if (state) stateStr = state == APPROVETYPE.通过 ? "通过" : "未通过";
dataList.push({ dataList.push({
dateKey:moment(dateKey).format("YYYY-MM-DD"), dateKey:moment(dateKey).format("YYYY-MM-DD"),
id, projectId, userId, time, isOutside, workLog, id, projectId, userId, time, workLog,
projectName:projectMap[projectId], projectName:project.name,
state: stateStr state: stateStr
}); });
}); });
let askforleaveCount = await findAskforleaveByUserIdAndType(userId, ASKFORLEAVETYPE.调休); let {cto} = await findUserAskCount(userId);
let approveCount = await findOvertimeApprove(userId);
return { dataList, notApprove, available:approveCount-askforleaveCount, overtimeCount }; return { dataList, notApprove, available:approveCount-cto, overtimeCount };
} }
...@@ -86,55 +96,80 @@ export async function overtimeList(userId:number) { ...@@ -86,55 +96,80 @@ export async function overtimeList(userId:number) {
* @param workLog 工作内容 * @param workLog 工作内容
* @returns {isSuccess:true, message:"添加成功"} * @returns {isSuccess:true, message:"添加成功"}
*/ */
export async function updateOvertimeLog(id:string, userId:number, time:number, projectId:string, workLog:string ) { export async function updateOvertimeLog(id:string, userId:number, time:number, projectId:string, workLog:string ) {
let overTimeInfo = await findOvertimeById(id); let overTimeInfo = await selectOneDataByParam(TABLENAMEENUM.加班, {id}, []);
if (!overTimeInfo[0]) throw new BizError(ERRORENUM.目标数据已不存在) if (!overTimeInfo || !overTimeInfo.id) throw new BizError(ERRORENUM.目标数据已不存在)
if (overTimeInfo[0].state == STATED.是) throw new BizError(ERRORENUM.已经通过审批的加班不能修改或删除); if (overTimeInfo.state == STATED.是) throw new BizError(ERRORENUM.已经通过审批的加班不能修改或删除);
await updateOvertime(id, projectId, time, workLog); await updateManyData(TABLENAMEENUM.加班, {id}, {projectId, time, workLog});
return {isSuccess:true, message:"添加成功"}; return {isSuccess:true, message:"修改成功"};
} }
/**
* 删除加班
* @param id
* @returns
*/
export async function deleteOvertimeLog(id:string ) { export async function deleteOvertimeLog(id:string ) {
let overTimeInfo = await findOvertimeById(id); let overTimeInfo = await selectOneDataByParam(TABLENAMEENUM.加班, {id}, []);
if (!overTimeInfo[0]) throw new BizError(ERRORENUM.目标数据已不存在)
if (overTimeInfo[0].state == STATED.是) throw new BizError(ERRORENUM.已经通过审批的加班不能修改或删除); if (!overTimeInfo || !overTimeInfo.id) throw new BizError(ERRORENUM.目标数据已不存在)
if (overTimeInfo.state == STATED.是) throw new BizError(ERRORENUM.已经通过审批的加班不能修改或删除);
await delOvertime(id); await delData(TABLENAMEENUM.加班, {id});
return {isSuccess:true, message:"删除成功"}; return {isSuccess:true, message:"删除成功"};
} }
/**
* 加班审批
* @param id
* @param type
* @param notPassingStr
* @returns
*/
export async function approveOverTime(id:string, type:number, notPassingStr:string) { export async function approveOverTime(id:string, type:number, notPassingStr:string) {
if (type == APPROVETYPE.不通过 && !notPassingStr) { if (type == APPROVETYPE.不通过 && !notPassingStr) {
throw new BizError(ERRORENUM.参数错误); throw new BizError(ERRORENUM.参数错误);
} }
if (type == APPROVETYPE.通过) notPassingStr = ""; if (type == APPROVETYPE.通过) notPassingStr = "";
let overTimeInfo = await findOvertimeById(id); let overTimeInfo = await selectOneDataByParam(TABLENAMEENUM.加班, {id}, []);
if (!overTimeInfo) throw new BizError(ERRORENUM.目标数据已不存在); if (!overTimeInfo || !overTimeInfo.id) throw new BizError(ERRORENUM.目标数据已不存在);
await updateOvertimeState(id, type, notPassingStr);
await updateManyData(TABLENAMEENUM.加班, {id}, {state:type, notPassingStr});
return {isSuccess:true, message:"操作成功"}; return {isSuccess:true, message:"操作成功"};
} }
export async function approveOverTimeList(userId:number) {
let overTimeList = await findOvertimeByApprover(userId); /**
* 审批列表
* @param userId
* @returns
*/
export async function approveOverTimeList(userId:number) {
let includeConf = {};
includeConf[TABLENAMEENUM.项目表] = ["name"];
includeConf[TABLENAMEENUM.用户表] = ["name"];
let column = ["projectId", "id", "time", "dateKey", "workLog"];
let overTimeList = await selectDataToTableAssociation(TABLENAMEENUM.加班, includeConf, {approver:userId, state:STATED.否}, column);
let dataList = []; let dataList = [];
let peopleMap = {}; let peopleMap = {};
overTimeList.forEach(info => { overTimeList.forEach(info => {
let {userName, projectName, id, time, dateKey, workLog} = info; let {user, id, time, dateKey, workLog, project} = info;
let userName = user.name;
dataList.push({ dataList.push({
dateKey:moment(dateKey).format("YYYY-MM-DD"), dateKey:moment(dateKey).format("YYYY-MM-DD"),
userName, projectName, id, time, workLog userName, projectName:project.name, id, time, workLog
}); });
peopleMap[userName] = 1; peopleMap[userName] = 1;
}); });
return {dataList, peopleCount:Object.keys(peopleMap).length }; return {dataList, peopleCount:Object.keys(peopleMap).length };
} }
\ No newline at end of file
src/biz/project.ts
import moment = require("moment"); /**
* 项目
*/
import { TABLENAMEENUM } from "../config/enum";
import { ERRORENUM } from "../config/errorEnum"; import { ERRORENUM } from "../config/errorEnum";
import { addProject, findAllProject, findOnceProjectById, updateProject } from "../data/admin/project" import { addData } from "../model/addData";
import { selectDataListByParam, selectOneDataByParam } from "../model/findData";
import { updateManyData } from "../model/updateData";
import { BizError } from "../util/bizError"; import { BizError } from "../util/bizError";
import { getDBTime } from "../util/myTools";
/**
* 项目下拉框
* @returns
*/
export async function projectListForSelect() { export async function projectListForSelect() {
let projectList = await selectDataListByParam(TABLENAMEENUM.项目表, {}, ["projectId", "name"]);
let projectList = await findAllProject(); let dataList = [];
projectList.forEach(info => {
let {projectId, name} = info;
dataList.push( {id:projectId, name});
});
return {dataList:projectList} return {dataList:dataList}
} }
/**
* 所有项目列表
* @returns
*/
export async function allProjectList() { export async function allProjectList() {
let projectList = await findAllProject(); let projectList = await await selectDataListByParam(TABLENAMEENUM.项目表, {}, ["projectId", "projectId", "name", "controller", "createTime"]);
let dataList = []; let dataList = [];
projectList.forEach(info => { projectList.forEach(info => {
dataList.push({ dataList.push({
id:info.id, id:info.projectId,
name:info.name, name:info.name,
controller:info.controller||"", controller:info.controller||"",
controllerStr:info.controller || "无", controllerStr:info.controller || "无",
...@@ -30,20 +51,36 @@ export async function allProjectList() { ...@@ -30,20 +51,36 @@ export async function allProjectList() {
return {dataList}; return {dataList};
} }
export async function addProjectData(id:string, name:string, controller:string) {
let projectInfo = await findOnceProjectById(id);
if (projectInfo.id) throw new BizError(ERRORENUM.项目ID已存在);
await addProject(id, name, controller, moment().format("YYYY-MM-DD HH:mm:ss") ); /**
* 创建新项目
* @param id
* @param name
* @param controller
* @returns
*/
export async function addProjectData(id:string, name:string, controller:string) {
let projectInfo = await selectOneDataByParam(TABLENAMEENUM.项目表, {projectId:id}, ["projectId", "name"]);
if (projectInfo.projectId) throw new BizError(ERRORENUM.项目ID已存在);
await addData(TABLENAMEENUM.项目表, {projectId:id, name, controller, createTime:getDBTime() } );
return {isSuccess:true, message:"添加成功"}; return {isSuccess:true, message:"添加成功"};
} }
/**
* 修改
* @param id
* @param name
* @param controller
* @returns
*/
export async function updateProjectData(id:string, name:string, controller:string) { export async function updateProjectData(id:string, name:string, controller:string) {
let projectInfo = await findOnceProjectById(id); let projectInfo = await selectOneDataByParam(TABLENAMEENUM.项目表, {projectId:id}, ["projectId", "name"]);
if (!projectInfo.id) throw new BizError(ERRORENUM.目标数据已不存在); if (!projectInfo.projectId) throw new BizError(ERRORENUM.目标数据已不存在);
await updateProject(id, name, controller ); await updateManyData(TABLENAMEENUM.项目表, {projectId:id}, {name, controller});
return {isSuccess:true, message:"修改成功"}; return {isSuccess:true, message:"修改成功"};
} }
\ No newline at end of file
src/biz/system.ts 0 → 100644
/**
* 放系系统基础数据
*/
import { DEPARTMENTENUM, ROLEENUM, SYSTEMCONSTCONFIGENUM, TABLENAMEENUM } from "../config/enum";
import { selectOneDataByParam } from "../model/findData";
export let queue = {
};
export async function initSystemConst() {
/**部门经理 */
queue[SYSTEMCONSTCONFIGENUM.部门经理] = {};
let userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {roleId:ROLEENUM.部门经理,departmentId:DEPARTMENTENUM.开发 }, ["userId", "name"]);
queue[SYSTEMCONSTCONFIGENUM.部门经理][DEPARTMENTENUM.开发] = {userId:userInfo.userId, name:userInfo.name};
userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {roleId:ROLEENUM.部门经理,departmentId:DEPARTMENTENUM.设计 }, ["userId", "name"])
queue[SYSTEMCONSTCONFIGENUM.部门经理][DEPARTMENTENUM.设计] = {userId:userInfo.userId, name:userInfo.name};
userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {roleId:ROLEENUM.部门经理,departmentId:DEPARTMENTENUM.项目经理 }, ["userId", "name"])
queue[SYSTEMCONSTCONFIGENUM.部门经理][DEPARTMENTENUM.项目经理] = {userId:userInfo.userId, name:userInfo.name};
queue[SYSTEMCONSTCONFIGENUM.加班默认] = {userId:17, name:"张谕"};
queue[SYSTEMCONSTCONFIGENUM.请假默认] = {userId:16, name:"万仪停"};
}
\ No newline at end of file
src/biz/user.ts
/** /**
* 用户管理 * 用户
* 作者:lxm
* 包括 登录 改密码 获取权限密码
*/ */
import { DEPARTMENT, ROLE } from "../config/enum"; import { DEPARTMENTENUM, FIRSTLVLIMIT, ROLEENUM, SECONDLVLIMIT, TABLENAMEENUM } from "../config/enum";
import { ERRORENUM } from "../config/errorEnum"; import { ERRORENUM } from "../config/errorEnum";
import { FIRSTLVLIMIT, SECONDLVLIMIT } from "../config/systemConfig"; import { selectOneDataByParam } from "../model/findData";
import * as userData from "../data/admin/user"; import { updateManyData } from "../model/updateData";
import { BizError } from "../util/bizError"; import { BizError } from "../util/bizError";
import { getToken } from "../util/tools"; import { getToken } from "../util/myTools";
/**
* 登陆
* @param loginId
* @param pwd
* @returns
*/
export async function login(loginId:string, pwd:number) { export async function login(loginId:string, pwd:number) {
let userInfo = await userData.findUserByLoginId(loginId); let userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {loginId}, [] );
if (!userInfo) throw new BizError(ERRORENUM.登录失败, '用户不存在'); if (!userInfo.userId) throw new BizError(ERRORENUM.登录失败, '用户不存在');
if (userInfo.pwd != pwd) throw new BizError(ERRORENUM.密码错误, `密码错误 ${pwd}`); if (userInfo.pwd != pwd) throw new BizError(ERRORENUM.密码错误, `密码错误 ${pwd}`);
let token = getToken(userInfo.loginId); let token = getToken(userInfo.loginId);
await userData.updateData({token}, {loginId}); await updateManyData(TABLENAMEENUM.用户表, {loginId}, {token});
let stagingList = []; let stagingList = [];
let approveList = []; let approveList = [];
let statsList = [];//统计 let statsList = [];//统计
if (userInfo.departmentId == DEPARTMENT.开发 || userInfo.departmentId == DEPARTMENT.设计 ||userInfo.departmentId == DEPARTMENT.项目经理) { if (userInfo.departmentId == DEPARTMENTENUM.开发 || userInfo.departmentId == DEPARTMENTENUM.设计 ||userInfo.departmentId == DEPARTMENTENUM.项目经理) {
stagingList = [FIRSTLVLIMIT.工时填报, FIRSTLVLIMIT.加班填报, FIRSTLVLIMIT.请假填报]; stagingList = [FIRSTLVLIMIT.工时填报, FIRSTLVLIMIT.加班填报, FIRSTLVLIMIT.请假填报];
if (userInfo.roleId == ROLE.部门经理) { if (userInfo.roleId == ROLEENUM.部门经理) {
stagingList.push(FIRSTLVLIMIT.数据导出); stagingList.push(FIRSTLVLIMIT.数据导出);
stagingList.push(FIRSTLVLIMIT.部门工时列表) stagingList.push(FIRSTLVLIMIT.部门工时列表)
statsList = [SECONDLVLIMIT.工时统计, SECONDLVLIMIT.部门统计]; statsList = [SECONDLVLIMIT.工时统计, SECONDLVLIMIT.部门统计];
if (userInfo.departmentId != DEPARTMENT.项目经理) approveList = [FIRSTLVLIMIT.加班审批, FIRSTLVLIMIT.请假审批]; if (userInfo.departmentId != DEPARTMENTENUM.项目经理) approveList = [FIRSTLVLIMIT.加班审批, FIRSTLVLIMIT.请假审批];
} }
} else if (userInfo.departmentId == DEPARTMENT.领导) { } else if (userInfo.departmentId == DEPARTMENTENUM.领导) {
stagingList = [FIRSTLVLIMIT.请假审批, FIRSTLVLIMIT.数据导出]; stagingList = [FIRSTLVLIMIT.请假审批, FIRSTLVLIMIT.数据导出];
statsList = [SECONDLVLIMIT.工时统计, SECONDLVLIMIT.部门统计]; statsList = [SECONDLVLIMIT.工时统计, SECONDLVLIMIT.部门统计];
} else if (userInfo.departmentId == DEPARTMENT.行政 ) { } else if (userInfo.departmentId == DEPARTMENTENUM.行政 ) {
stagingList = [FIRSTLVLIMIT.加班审批, FIRSTLVLIMIT.数据导出, FIRSTLVLIMIT.立项]; stagingList = [FIRSTLVLIMIT.加班审批, FIRSTLVLIMIT.数据导出, FIRSTLVLIMIT.立项];
} else if (userInfo.departmentId == DEPARTMENT.人事) { } else if (userInfo.departmentId == DEPARTMENTENUM.人事) {
stagingList = [FIRSTLVLIMIT.人事用请假情况, FIRSTLVLIMIT.请假审批, FIRSTLVLIMIT.出勤]; stagingList = [FIRSTLVLIMIT.人事用请假情况, FIRSTLVLIMIT.请假审批, FIRSTLVLIMIT.出勤, FIRSTLVLIMIT.成员列表];
} }
let result = { token, let result = { token,
...@@ -47,7 +50,7 @@ export async function login(loginId:string, pwd:number) { ...@@ -47,7 +50,7 @@ export async function login(loginId:string, pwd:number) {
roleId:userInfo.roleId, roleId:userInfo.roleId,
departmentId:userInfo.departmentId, departmentId:userInfo.departmentId,
name:userInfo.name, name:userInfo.name,
headSculpture:`http://192.168.0.105:7088/1.png`, headSculpture:`http://192.168.0.109:7088/1.png`,
stagingList, stagingList,
approveList, approveList,
statsList statsList
...@@ -56,10 +59,17 @@ export async function login(loginId:string, pwd:number) { ...@@ -56,10 +59,17 @@ export async function login(loginId:string, pwd:number) {
return result; return result;
} }
/**
* 退出登陆
* @param userId
* @returns
*/
export async function logout(userId:number) { export async function logout(userId:number) {
let userInfo = await userData.findUserByUserIdNum(userId); let userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {userId}, [] );
if ( !userInfo ) throw new BizError(ERRORENUM.身份验证失败); if ( !userInfo.userId ) throw new BizError(ERRORENUM.身份验证失败);
await userData.updateData({token:""}, {userId}); await updateManyData(TABLENAMEENUM.用户表, {userId}, {token:""});
return {isSuccess:true} return {isSuccess:true}
} }
......
src/config/enum.ts
export enum OPERATIONTYPEENUM {
增 = 1,
删,
改,
查
}
export enum ASKFORLEAVETYPE { export enum ASKFORLEAVETYPE {
调休 =1, 调休 =1,
年假, 年假,
...@@ -6,10 +14,44 @@ export enum ASKFORLEAVETYPE { ...@@ -6,10 +14,44 @@ export enum ASKFORLEAVETYPE {
事假 事假
} }
export enum APPROVETYPE {
通过 = 1,
不通过 = 2
}
export enum WORKLOGADMINTYPE {
按项目分 = 1, export enum TABLENAMEENUM {
按时间分 用户表 = 'users',
角色表 = 'role',
项目表 = 'project',
部门表 = 'department',
加班 = 'overtime',
请假 = 'askforleave',
工时表 = 'workinglog'
}
export enum ROLEENUM {
系统管理员 = 1,
老板 = 4,
部门经理 = 5,
员工 = 6
}
export enum DEPARTMENTENUM {
财务 = 1,
设计 = 2,
开发 = 3,
项目经理 = 4,
领导 = 5,
系统管理员 = 6,
行政 = 7,
人事 = 8
}
export enum SYSTEMCONSTCONFIGENUM {
部门经理 = 1,
请假默认,
加班默认
} }
export enum STATED{ export enum STATED{
...@@ -17,25 +59,29 @@ export enum STATED{ ...@@ -17,25 +59,29 @@ export enum STATED{
是 = 1, 是 = 1,
} }
export enum APPROVETYPE { export enum FIRSTLVLIMIT {
通过 = 1, 工时填报 = 1,
不通过 = 2 加班填报,
请假填报,
加班审批,
请假审批,
数据导出,
立项,
人事用请假情况,
出勤,
部门工时列表 = 10,
成员列表
} }
export enum DEPARTMENT { /**
财务 = 1, * 统计
设计, */
开发, export enum SECONDLVLIMIT {
项目经理, 工时统计 = 188,
领导, 部门统计,
系统管理员,
行政,
人事,
} }
export enum ROLE { export enum WORKLOGADMINTYPE {
系统管理员 = 1, 按项目分 = 1,
老板 = 4, 按时间分
部门经理 = 5, }
员工 = 6, \ No newline at end of file
}
src/config/errorEnum.ts
export enum ERRORENUM { export enum ERRORENUM {
登录失败 = 1, 不存在表 = 1,
密码错误, 身份验证失败,
重复提交, 非法登录,
身份验证失败, 身份验证过期,
非法登录, 数据表不存在,
身份验证过期, 参数错误,
参数错误, 添加时数据对象为空,
未找到该数据, 修改时数据对象为空,
表单校验失败, 年假剩余不足请重新分配请假时间,
一天只有8小时多余的时间请填加班, 年假限制为4小时的倍数,
不存在该项目, 调休剩余不足请重新分配请假时间,
已经通过审批的加班不能修改或删除, 已经通过审批的请假不能修改或删除,
已经通过审批的请假不能修改或删除, 目标数据已不存在,
目标数据已不存在, 已经通过审批的数据不能修改,
项目ID已存在, 该请假已通过审批,
年假剩余不足请重新分配请假时间, 年假剩余时间不足,
调休剩余不足请重新分配请假时间 调休时间不足,
不存在该项目,
已经通过审批的加班不能修改或删除,
项目ID已存在,
登录失败,
密码错误,
一天只有8小时多余的时间请填加班,
表单校验失败
} }
/**
* 只用做code码定义
*/
export enum ERRORCODEENUM { export enum ERRORCODEENUM {
身份验证失败 = 401, 身份验证失败 = 401,
非法登录 = 402, 非法登录 = 402,
......
src/config/mysqlTableConfig.ts 0 → 100644
const Sequelize = require('sequelize');
export const TablesConfig = [
{
tableNameCn:'角色表',
tableName:'role',
schema:{
roleId:{
type:Sequelize.INTEGER(20), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
roleName:{type:Sequelize.STRING(255), allowNull:false}, //登录账号
},
association: []
},
{
tableNameCn:'部门表',
tableName:'department',
schema:{
departmentId:{
type:Sequelize.INTEGER(20), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
name:{type:Sequelize.STRING(255), allowNull:false}, //部门名称
},
association: []
},
{
tableNameCn:'用户表',
tableName:'users',
schema:{
userId: {
type:Sequelize.INTEGER(20), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
name: {type:Sequelize.STRING(255), allowNull:false}, //名称
loginId: {type:Sequelize.STRING(255), allowNull:false}, //账号
pwd: {type:Sequelize.STRING(255), allowNull:false}, //密码
roleId: {type:Sequelize.INTEGER(20), allowNull:false, references:{
model:'role',
key:'roleId'
}}, //角色id
exchangeTime: {type:Sequelize.INTEGER(20), allowNull:false}, //调休剩余
annualLeave: {type:Sequelize.INTEGER(20), allowNull:false}, //年假剩余
departmentId: {type:Sequelize.INTEGER(20), allowNull:false, references:{
model:'department',
key:'departmentId'
}}, //部门id
token: {type:Sequelize.STRING(255)},
tokenDate: {type:Sequelize.DATE},
ed: {type:Sequelize.DATE}//入职时间
},
association: []
},
{
tableNameCn:'项目表',
tableName:'project',
schema:{
projectId:{
type:Sequelize.STRING(255), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
name:{type:Sequelize.STRING(255)}, //项目名称
contractId:{type:Sequelize.STRING(255)}, //合同编号
controller:{type:Sequelize.STRING(255)}, //项目经理
createTime:{type:Sequelize.DATE}, //创建时间
},
association: []
},
{
tableNameCn:'加班',
tableName:'overtime',
schema:{
id:{
type:Sequelize.STRING(244), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
projectId:{type:Sequelize.STRING(255), references:{
model:'project',
key:'projectId'
}}, //
userId:{type:Sequelize.INTEGER(20), references:{
model:'users',
key:'userId'
}}, //
dateKey:{type:Sequelize.DATE}, //
time:{type:Sequelize.INTEGER(20), allowNull:false}, //
state:{type:Sequelize.INTEGER(20), allowNull:false}, //
approver:{type:Sequelize.INTEGER(20), allowNull:false}, //
workLog:{type:Sequelize.STRING(255), allowNull:true},
notPassing:{type:Sequelize.STRING(255), allowNull:true}//不通过理由
},
association: []
},
{
tableNameCn:'请假',
tableName:'askforleave',
schema:{
id:{
type:Sequelize.STRING(255), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
des:{type:Sequelize.STRING(255)}, //描述
startTime:{type:Sequelize.DATE}, //
endTime:{type:Sequelize.DATE}, //
userId:{type:Sequelize.INTEGER(20), references:{
model:'users',
key:'userId'
}}, //
approval:{type:Sequelize.INTEGER(20), allowNull:false}, //
time:{type:Sequelize.INTEGER(20), allowNull:false}, //
type:{type:Sequelize.INTEGER(20), allowNull:false}, //
day:{type:Sequelize.INTEGER(20), allowNull:false}, //
state:{type:Sequelize.INTEGER(20), allowNull:false}, //
notPassing:{type:Sequelize.STRING(255), allowNull:true},//不通过理由
dateKey:{type:Sequelize.DATE} //
},
association: [
]
},
{
tableNameCn:'工时表',
tableName:'workinglog',
schema:{
id:{
type:Sequelize.STRING(255), //表示属性的数据类型
allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
primaryKey:true, //表示主键
unique:true //表示该列的值必须唯一
},
projectId:{type:Sequelize.STRING(255), references:{
model:'project',
key:'projectId'
}}, //
userId:{type:Sequelize.INTEGER(20), references:{
model:'users',
key:'userId'
}}, //
time:{type:Sequelize.INTEGER(20), allowNull:false}, //
dateKey:{type:Sequelize.DATE}, //
isOutside:{type:Sequelize.INTEGER(20)}, //
workLog:{type:Sequelize.STRING(255)}, //描述
},
association: [
]
}
];
\ No newline at end of file
src/config/serverConfig.ts
...@@ -3,8 +3,6 @@ import * as fs from "fs"; ...@@ -3,8 +3,6 @@ import * as fs from "fs";
import { BizError } from "../util/bizError"; import { BizError } from "../util/bizError";
import { analysisXml } from "../util/myXML"; import { analysisXml } from "../util/myXML";
import { ServerConfig } from "../config/systemClass"; import { ServerConfig } from "../config/systemClass";
const os = require('os');
export let systemConfig = new ServerConfig; export let systemConfig = new ServerConfig;
const ConfigName = "serverConfig.xml"; const ConfigName = "serverConfig.xml";
...@@ -19,21 +17,26 @@ export async function initConfig() { ...@@ -19,21 +17,26 @@ export async function initConfig() {
let {port, dbConfig } = configInfo.config; let {port, dbConfig } = configInfo.config;
systemConfig.port = parseInt(port[0]); systemConfig.port = parseInt(port[0]);
if (dbConfig) { if (dbConfig) {
let dbConfigInfo = dbConfig[0]; let dbConfigInfo = dbConfig[0];
systemConfig.mysqldb = {host:'', port:0, user:'', pwd:'', dataBase:''};
if (dbConfigInfo.mysqlHost && dbConfigInfo.mysqlPort && dbConfigInfo.mysqlUser && dbConfigInfo.dataBase) { if (dbConfigInfo.mysqlHost && dbConfigInfo.mysqlPort && dbConfigInfo.mysqlUser && dbConfigInfo.dataBase) {
systemConfig.mysqlHost=dbConfigInfo.mysqlHost[0]; systemConfig.mysqldb.host=dbConfigInfo.mysqlHost[0];
systemConfig.mysqlPort=parseInt(dbConfigInfo.mysqlPort[0]); systemConfig.mysqldb.port=parseInt(dbConfigInfo.mysqlPort[0]);
systemConfig.mysqlUser=dbConfigInfo.mysqlUser[0]; systemConfig.mysqldb.user=dbConfigInfo.mysqlUser[0];
systemConfig.mysqlPwd=dbConfigInfo.mysqlPwd[0] || ""; systemConfig.mysqldb.pwd=dbConfigInfo.mysqlPwd[0] || "";
systemConfig.dataBase=dbConfigInfo.dataBase[0]; systemConfig.mysqldb.dataBase=dbConfigInfo.dataBase[0];
} }
} }
} }
console.log("config init success"); console.log("config init success");
} catch(err) { } catch(err) {
console.log('ERROR => 服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确');
console.log(err);
throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确"); throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确");
} }
} }
...@@ -41,7 +44,3 @@ export async function initConfig() { ...@@ -41,7 +44,3 @@ export async function initConfig() {
function analysisMongoConnectStr(path, port, dataBase, w, timeOutMs) { function analysisMongoConnectStr(path, port, dataBase, w, timeOutMs) {
return `mongodb://${path}:${port}/${dataBase}?w=${w}&wtimeoutMS=${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 { export class ServerConfig {
/**系统配置 */
port:number; port:number;
mysqlHost:string;
mysqlPort:number; mysqldb:{
mysqlUser:string; host:string,
mysqlPwd:string; port:number,
dataBase:string; user:string,
pwd:string,
dataBase:string,
}
} }
\ No newline at end of file
src/config/systemConfig.ts deleted 100644 → 0
export enum FIRSTLVLIMIT {
工时填报 = 1,
加班填报,
请假填报,
加班审批,
请假审批,
数据导出,
立项,
人事用请假情况,
出勤,
部门工时列表 = 10
}
export enum SECONDLVLIMIT {
工时统计 = 188,
部门统计,
}
\ No newline at end of file
src/data/admin/askForLeave.ts deleted 100644 → 0
/**请假 */
import { APPROVETYPE } from "../../config/enum";
import { mysqlDB } from "../../db/mysqlInit";
const Sequelize =require('sequelize')
//创建StudentModel模型，该模型对应的表名是student
let askforleaveModel;
export async function initModel() {
var model = mysqlDB.define('askforleave',{
id:{
type:Sequelize.STRING(100), //表示属性的数据类型
primaryKey:true, //表示主键
allowNull:false, //表示当前列是否允许为空，false表示该列不能为空
unique:true //表示该列的值必须唯一
},
des:{ type:Sequelize.STRING(100), allowNull:false }, //事由
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},//类型
dateKey:{ type:Sequelize.DATE, allowNull:false },//填报日期
state:{ type:Sequelize.INTEGER, allowNull: false},//状态
notPassing:{ type:Sequelize.STRING(100), allowNull:false }, //不通过原因
},{
freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
timestamps:false //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
});
// //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
askforleaveModel = await model.sync({});
}
export async function initAskforleave(id:string, des:string, startTime:string, endTime:string, userId:number, approval:number, time:number, day:number, type:number, dateKey:string, state:number) {
await askforleaveModel.create({id, des, startTime, endTime, userId, approval, time, day, type, dateKey, notPassing:"", state});
}
/**
* 添加请假
*/
export async function addAskforleave(id:string, des:string, startTime:string, endTime:string, userId:number, approval:number, time:number, day:number, type:number, dateKey:string) {
await askforleaveModel.create({id, des, startTime, endTime, userId, approval, time, day, type, dateKey, notPassing:"", state:0});
}
export async function findAskforleaveByUserIdAndType(userId:number, type:number) {
let list = await askforleaveModel.findAll({
where:{ userId, type, state:APPROVETYPE.通过 }
});
let count = 0;
list.forEach(info => {
let {day, time} = info;
if (day!=0) count += day*8;
if (time != 0) count += time;
});
return count;
}
export async function findAskForLeaveListByUserId(userId:number) {
return await askforleaveModel.findAll({where:{userId}});
}
export async function findAskForLeaveListById(id:string) {
return await askforleaveModel.findAll({where:{id}});
}
export async function delAskForLeaveListById(id:string) {
await askforleaveModel.destroy({where:{id}});
}
export async function findAskForLeaveListByTimeToPage(param, startNum:number, endNum:number) {
let sql = `select users.name, askforleave.state, askforleave.startTime, askforleave.endTime, askforleave.day, askforleave.time, askforleave.type,askforleave.des, askforleave.approval from askforleave INNER JOIN users on users.userId = askforleave.userId `;
let paramList = Object.keys(param)
if (paramList.length) {
sql += ' where ';
for (let i= 0; i < paramList.length; i++) {
let key = paramList[i];
if (key == "startTime") {
sql += `askforleave.startTime > '${param.startTime}' `;
}
if (key == "endTime") {
sql += `askforleave.endTime < '${param.endTime}' `;
}
if (key == "userId") {
sql += `users.userId = ${param.userId}`;
}
if (i != paramList.length -1) {
sql += ' and '
}
}
}
sql += ` ORDER BY askforleave.dateKey DESC limit ${startNum}, ${endNum}`;
return await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
}
export async function findAskForLeaveListByTime(param) {
let sql = `select users.name, askforleave.state, askforleave.startTime, askforleave.endTime, askforleave.day, askforleave.time, askforleave.type,askforleave.des, askforleave.approval from askforleave INNER JOIN users on users.userId = askforleave.userId `;
let paramList = Object.keys(param)
if (paramList.length) {
sql += ' where ';
for (let i= 0; i < paramList.length; i++) {
let key = paramList[i];
if (key == "startTime") {
sql += `askforleave.startTime > '${param.startTime}' `;
}
if (key == "endTime") {
sql += `askforleave.endTime < '${param.endTime}' `;
}
if (key == "userId") {
sql += `users.userId = ${param.userId}`;
}
if (i != paramList.length -1) {
sql += ' and '
}
}
}
sql += ` ORDER BY askforleave.dateKey DESC`;
return await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
}
export async function findAskForLeaveCountByTime(param) {
let sql = `select count(*) as count from askforleave`;
let paramList = Object.keys(param)
if (paramList.length) {
sql += ' where ';
for (let i= 0; i < paramList.length; i++) {
let key = paramList[i];
if (key == "startTime") {
sql += `startTime > '${param.startTime}' `;
}
if (key == "endTime") {
sql += `endTime < '${param.endTime}' `;
}
if (key == "userId") {
sql += `userId = ${param.userId}`;
}
if (i != paramList.length -1) {
sql += ' and '
}
}
}
let countData = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
return countData[0].count;
}
export async function updateAskforleave(id:string, des:string, startTime:string, endTime:string, time:number, day:number, type:number) {
let updateInfo = {des, startTime, endTime, time, day, type};
await askforleaveModel.update(updateInfo, {where:{id}});
}
export async function findAskForLeaveListByApprover(userId:number) {
let sql = `select users.name as userName, askforleave.id, askforleave.startTime, askforleave.endTime, askforleave.day, askforleave.time, askforleave.type, askforleave.des from askforleave INNER JOIN users on `;
sql += `askforleave.userId = users.userId where askforleave.approval = ${userId} and askforleave.state = 0`
return await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
}
export async function updateAskForLeaveState(id:string, state:number, notPassing?) {
let updateInfo:any = {state};
if (notPassing) updateInfo.notPassing = notPassing;
await askforleaveModel.update(updateInfo, {where:{id}});
}
export async function findAskForLeaveByDepartmentId(departmentId:number, selectTime:string) {
let sql = `select users.name, sum(askforleave.time) as time, sum(askforleave.day) as day from users LEFT JOIN askforleave on askforleave.userId = users.userId WHERE users.departmentId = ${departmentId} and (askforleave.startTime > "${selectTime}" or askforleave.endTime > "${selectTime}") GROUP BY users.name `
let dataList = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
let map = {};
dataList.forEach(info => {
map[info.name] = parseInt(info.time) + (parseInt(info.day) * 8 );
});
return map;
}
\ No newline at end of file
src/data/admin/department.ts deleted 100644 → 0
/**
* 部门表
*/
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({});
}
/**
* 查询所有部门
* @returns
*/
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 deleted 100644 → 0
/**
* 加班表
*/
import { mysqlDB } from "../../db/mysqlInit";
const Sequelize =require('sequelize')
//创建StudentModel模型，该模型对应的表名是student
let overtimeModel;
export async function initModel() {
var model = mysqlDB.define('overtime',{
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 },//填报时间
state:{ type:Sequelize.INTEGER },//状态 0=否 1=通过 2=不通过
workLog:{ type:Sequelize.STRING(200)}, //工作内容
approver:{ type:Sequelize.INTEGER, allowNull: false },//审批人
notPassing:{type:Sequelize.STRING(200)},//不通过理由
},{
freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
timestamps:false //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
});
// //同步数据库，force的值为false，表若存在则先删除后创建，force的值为true表示表若存在则不创建
overtimeModel = await model.sync({});
}
/**
* 添加工时记录
* @param id 属性的数据类型
* @param projectId 项目号
* @param userId 填报人
* @param time 工时
* @param dateKey 填报时间
* @param isOutside 是否外出 0=否 1=是
* @param workLog 工作内容
*/
export async function addOvertime(id:string, projectId:string, userId:number, time:number, dateKey:string, workLog:string, approver:number) {
await overtimeModel.create({id, projectId, userId, time, dateKey, state:0, workLog, approver});
}
export async function findOvertimeById(id:string) {
return await overtimeModel.findAll({
where:{id}
});
}
export async function findOvertime(userId:number) {
return await overtimeModel.findAll({
where:{userId}
});
}
export async function findOvertimeApprove(userId:number) {
let list = await overtimeModel.findAll({
where:{userId, state:1}
});
let count = 0;
list.forEach(info => {
let {time} = info;
count += time;
});
return count;
}
export async function updateOvertime(id:string, projectId:string, time:number, workLog:string) {
await overtimeModel.update({projectId, time, workLog}, {where:{id}});
}
export async function delOvertime(id:string) {
await overtimeModel.destroy({where:{id}});
}
export async function updateOvertimeState(id:string, state:number, notPassing?) {
let updateInfo:any = {state};
if (notPassing) updateInfo.notPassing = notPassing;
await overtimeModel.update(updateInfo, {where:{id}});
}
export async function findOvertimeByApprover(userId:number) {
let sql = `select users.name as userName, project.name as projectName, overtime.id, overtime.time, overtime.dateKey, overtime.workLog from overtime INNER JOIN users on `;
sql += `overtime.userId = users.userId INNER JOIN project on project.id = overtime.projectId where overtime.approver = ${userId} and overtime.state = 0`
return await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
}
export async function initOvertime(id:string, projectId:string, userId:number, time:number, dateKey:string, workLog:string, approver:number, state:number) {
await overtimeModel.create({id, projectId, userId, time, dateKey, state, workLog, approver, notPassing:""});
}
export async function findOvertimeByDepartmentId(departmentId:number, startTime:string) {
let sql = `select users.name, sum(overtime.time) as time from users LEFT JOIN overtime on overtime.userId = users.userId WHERE users.departmentId = ${departmentId} and overtime.dateKey >"${startTime}" GROUP BY users.name`
let dataList = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
let map = {};
dataList.forEach(info => {
map[info.name] = info.time;
});
return map;
}
export async function findOvertimeByTime(startTime:string, endTime:string) {
let sql = `select users.name, project.name as projectName, overtime.time, overtime.dateKey from users LEFT JOIN overtime on overtime.userId = users.userId inner join project on project.id = overtime.projectId `
if (startTime && endTime) {
sql += ` where overtime.dateKey > "${startTime}" and overtime.dateKey < "${endTime}"`;
}
let dataList = await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
return dataList;
}
\ No newline at end of file
src/data/admin/project.ts deleted 100644 → 0
/**
* 项目表
*/
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), },//合同号
controller:{ type:Sequelize.STRING(200) }, //项目经理
createTime:{ type:Sequelize.DATE},// 创建时间
},{
freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
timestamps:false //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
});
projectModel = await model.sync({});
}
/**
* 查询所有项目
* @returns
*/
export async function findAllProjectMap() {
let projectList = await projectModel.findAll({});
let result = {};
projectList.forEach(info => {
result[info.id] = info.name;
});
return result;
}
/**
* 根据项目id查询项目
* @param projectId
* @returns
*/
export async function findOnceProjectById(projectId:string) {
let dataList = await projectModel.findAll({
where:{id:projectId}
});
return dataList[0] || {};
}
/**
* 查询所有项目的id和名称
* @returns
*/
export async function findAllProject() {
let dataList = await projectModel.findAll({
where:{}
});
return dataList;
}
/**
* 查询项目名称
* @returns
*/
export async function findProjectByName(projectName:string) {
let dataList = await projectModel.findAll({
where:{name:projectName}
});
return dataList;
}
export async function addProject(id:string, name:string, controller:string, createTime:string) {
await projectModel.create({id, name, controller, createTime });
}
export async function updateProject(id:string, name:string, controller:string) {
await projectModel.update({name, controller }, {where:{id}});
}
\ No newline at end of file
src/data/admin/user.ts deleted 100644 → 0
/**
* 用户表
*/
import { mysqlDB } from "../../db/mysqlInit";
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({});
// userModel = await instantiateModel('users', {
// userId:{type:String, mainKey:true},
// name:{type:String, allowNull:true},
// loginId:{ type:String},//登录id
// pwd:{ type:String},//密码
// roleId:{ type:Number},//角色id 外键角色表id
// exchangeTime:{ type:Number},//调休余额
// annualLeave:{ type:Number},//年假余额
// departmentId:{ type:Number },//部门id 外键部门表id
// token:{ type:String },
// });
}
/**
* 登录账号查询用户
* @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 loginId
*/
export async function findUserByUserIdNum(userId:number) {
let dataList = await userModel.findAll({ where:{userId}});
return dataList[0] || {};
}
/**
* 根据登录信息
* @param roleId
* @param departmentId
*/
export async function findDepartmentRole(roleId:number, departmentId:number) {
let dataList = await userModel.findAll({ where:{roleId, departmentId}});
return dataList[0] || {};
}
/**
* 修改数据
* @param param 修改内容
* @param select 修改条件
* @returns
*/
export async function updateData(param:object, select:object) {
await userModel.update(param, {where:select});
}
export async function selectUserByDepartmentId(departmentId:number) {
return await userModel.findAll({ where:{departmentId}});
}
export async function selectMemberUser() {
let sql = `select * from users where departmentId >= 2 and departmentId <=4`;
return await mysqlDB.query(sql, { type: mysqlDB.QueryTypes.SELECT } );
}
src/db/initTable.ts deleted 100644 → 0
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";
import * as overtimeData from "../data/admin/overtime";
import * as askForLeaveData from "../data/admin/askForLeave";
export async function initTable() {
await workinglogData.initModel();
await projectData.initModel();
await userData.initModel();
await departmentData.initModel();
await overtimeData.initModel();
await askForLeaveData.initModel();
}
\ No newline at end of file
src/db/mysqlClass.ts deleted 100644 → 0
const Sequelize = require('sequelize');
export async function instantiateModel(tableName:string, config) {
let tablesBase = {};
for ( let key in config) {
let info = config[key];
let keysValue:any = {type:null};
if (typeof config.type.isFinite == "function") {
keysValue.type = Sequelize.INTEGER;
} else if (typeof config.type.concat == "function") {
keysValue.type = Sequelize.STRING(200);
} else if (typeof config.type.getFullYear == "function") {
keysValue.type = Sequelize.DATE;
}
if (info.mainKey) {
keysValue.primaryKey = true; //表示主键
keysValue.allowNull = false; //表示当前列是否允许为空，false表示该列不能为空
keysValue.unique = true; //表示该列的值必须唯一
}
if (info.allowNull) {
keysValue.allowNull = info.allowNull;
}
tablesBase[key] = keysValue;
}
let defaultConfig = {
freezeTableName:true,
timestamps:false,
}
let model = Sequelize.mysqlDB.define(tableName, tablesBase, defaultConfig);
return await model.sysc({});
}
src/db/mysqlInit.ts
import { systemConfig } from "../config/serverConfig"; import { systemConfig } from "../config/serverConfig";
import { initTable } from "./initTable";
//导入sequelize模块 //导入sequelize模块
const Sequelize = require('sequelize'); const Sequelize = require('sequelize');
var mysqlDB; var mysqlDB;
export async function initMysqlDB() { export async function initMysqlDB() {
mysqlDB = new Sequelize(systemConfig.dataBase,systemConfig.mysqlUser,systemConfig.mysqlPwd,{ mysqlDB = new Sequelize(systemConfig.mysqldb.dataBase,systemConfig.mysqldb.user,systemConfig.mysqldb.pwd,{
host:systemConfig.mysqlHost, host:systemConfig.mysqldb.host,
port:systemConfig.mysqlPort, port:systemConfig.mysqldb.port,
dialect:'mysql', //数据库类型 dialect:'mysql', //数据库类型
pool:{ //数据库连接池 pool:{ //数据库连接池
max:20, //最大连接对象的个数 max:20, //最大连接对象的个数
min:5, //最小连接对象的个数 min:5, //最小连接对象的个数
idle:1000 //最长等待时间，单位为毫秒 idle:1000 //最长等待时间，单位为毫秒
} },
}); timezone: '+08:00', //东八时区
// dialectOptions: {
await initTable(); dateStrings: true,
typeCast: true
},
});
} }
export { mysqlDB }; export { mysqlDB };
\ No newline at end of file
src/main.ts
import { initSystemConst } from "./biz/system";
import { initConfig, systemConfig} from "./config/serverConfig"; import { initConfig, systemConfig} from "./config/serverConfig";
import { initMysqlDB } from "./db/mysqlInit"; import * as mysqlDB from "./db/mysqlInit";
import { initMysqlModel } from "./model/sqlModelBind";
import { httpServer } from "./net/http_server"; import { httpServer } from "./net/http_server";
async function lanuch() { async function lanuch() {
await initConfig();//初始化配置解析 /**初始化配置解析 */
await initMysqlDB(); await initConfig();
/**初始化数据库 */
// await mongoDB.initDB();
// await initModel();
/**初始化sql */
await mysqlDB.initMysqlDB();
await initMysqlModel();
/**创建http服务 */
httpServer.createServer(systemConfig.port); httpServer.createServer(systemConfig.port);
/**初始化系统常量 */
await initSystemConst();
// await smsTask();
console.log('This indicates that the server is started successfully.'); console.log('This indicates that the server is started successfully.');
// await initData();
} }
lanuch(); lanuch();
\ No newline at end of file
src/middleware/fromParam.ts deleted 100644 → 0
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 { bizlive } from "tencentcloud-sdk-nodejs";
import { ERRORCODEENUM } from "../config/errorEnum"; import { ERRORCODEENUM } from "../config/errorEnum";
/** /**
...@@ -16,7 +17,7 @@ export function httpErrorHandler(err, req, res, next) { ...@@ -16,7 +17,7 @@ export function httpErrorHandler(err, req, res, next) {
res.success({success:false, msg:err.message, code:ERRORCODEENUM[err.message]}); res.success({success:false, msg:err.message, code:ERRORCODEENUM[err.message]});
next(); next();
} }
else { else {
res.success({success:false, msg:err.message, code:500}); res.success({success:false, msg:err.message, code:500});
next(); next();
} }
......
src/middleware/user.ts
import { TABLENAMEENUM } from "../config/enum";
import { ERRORENUM } from "../config/errorEnum"; import { ERRORENUM } from "../config/errorEnum";
import { findUserByUserId } from "../data/admin/user"; import { selectOneDataByParam } from "../model/findData";
import { BizError } from "../util/bizError"; import { BizError } from "../util/bizError";
/** /**
...@@ -17,14 +18,19 @@ export async function checkFuHuaQiToken(req, res, next) { ...@@ -17,14 +18,19 @@ export async function checkFuHuaQiToken(req, res, next) {
if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`)); if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
let userInfo = await findUserByUserId(userId); let userInfo = await selectOneDataByParam(TABLENAMEENUM.用户表, {userId}, ["userId", "roleId", "name", "departmentId", "token"]);
if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`)); if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`));
if (userInfo.token != reqToken ) 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; req.headers.userid = userInfo.userId;
req.headers.userinfo = {
userId,
roleId:userInfo.roleId,
name:userInfo.name,
departmentId:userInfo.departmentId
}
next(); next();
} }
src/model/addData.ts 0 → 100644
import { mysqlModelMap } from "./sqlModelBind";
/**
* 添加数据
* @param tableName
* @param data
* @returns
*/
export async function addData(tableName:string, data:any) {
let dataArray = [];
if (!Array.isArray(data)) {
dataArray.push(data);
} else dataArray = data;
await mysqlModelMap[tableName].bulkCreate(dataArray);
return true;
}
\ No newline at end of file
src/model/delData.ts 0 → 100644
import { mysqlModelMap } from "./sqlModelBind";
export async function delData(tableName:string, param) {
await mysqlModelMap[tableName].destroy({where:param});
return true;
}
\ No newline at end of file
src/model/findData.ts 0 → 100644
import { Op, Sequelize } from "sequelize";
import { ERRORENUM } from "../config/errorEnum";
import { mysqlModelMap } from "./sqlModelBind";
import { BizError } from "../util/bizError";
/**
* where条件查询参数
* @param param
* %like%：模糊查询 {列名: {"%like%": }}
* %gt%：大于 {列名: {"%gt%": }}
* %gte%：大于等于 {列名: {"%gte%": }}
* %lt%：小于 {列名: {"%lt%": }}
* %lte%：小于等于 {列名: {"%lte%": }}
* %between%：查询范围内数据 {列名: {"%between%": ["开始参数", "结束参数"]}} ---BETWEEN 开始参数 AND 结束参数 列>开始参数 and 列<结束参数
* %notBetween%：查询不在范围内数据 {列名: {"%notBetween%": ["开始参数", "结束参数"]}} ---NOT BETWEEN 开始参数 AND 结束参数
* %orderDesc%: order by DESC {"%orderDesc%": "列名"}
* %limit%: {"%limit%": 数量}
* @param column
* @returns
*/
function analysisParamToWhere(param, column) {
let where = {};
let order = [];
let group = "";
let limit = 0;
for (let key in param) {
if (typeof param[key] == "object") {
where[key] = {};
for (let whereKey in param[key]){
switch(whereKey) {
case "%like%":
where[key][Op.like] = `%${param[key]["%like%"]}%`;
break;
case "%gt%":
where[key][Op.gt] = param[key]["%gt%"];
break;
case "%gte%":
where[key][Op.gte] = param[key]["%gte%"];
break;
case "%lt%":
where[key][Op.lt] = param[key]["%lt%"];
break;
case "%lte%":
where[key][Op.lte] = param[key]["%lte%"];
break;
case "%between%":
where[key][Op.between] = param[key]["%between%"];
break;
case "%notBetween%":
where[key][Op.notBetween] = param[key]["%notBetween%"];
break;
case "%in%":
where[key][Op.in] = param[key]["%in%"];
break;
case "%notIn%":
where[key][Op.notIn] = param[key]["%notIn%"];
break;
}
}
}else {
switch (key) {
case "%orderDesc%":
order = [[Sequelize.col(param[key]), "DESC"]];
break;
case "%orderAsc%":
order = [[Sequelize.col(param[key]), "ASC"]];
break;
case "%limit%":
limit = param[key];
break;
case "%group%":
group = param[key];
break;
default: where[key] = param[key];
}
}
}
let selectParam:any = {where};
if (column && column.length) selectParam.attributes = column;
if (order && order.length) selectParam.order = order;
if (limit) selectParam.limit = limit;
if (group) selectParam.group = group;
return selectParam;
}
/**
* 查询单个数据
* @param tableModel 表对象
* @param param
* @returns
*/
export async function selectOneDataByParam(tableName:string, param, column) {
let selectParam = analysisParamToWhere(param, column);
let data = await mysqlModelMap[tableName].findOne(selectParam);
data = data || {};
return data;
}
/**
* 查询多个数据
* @param tableName 表对象
* @param param
* @returns
*/
export async function selectDataListByParam(tableName:string, param, column) {
let selectParam = analysisParamToWhere(param, column);
let data = await mysqlModelMap[tableName].findAll(selectParam);
return data;
}
/**
* 分页查询
* @param
* @param param
* @param pageNumber
* @param pageSize
* @returns
*/
export async function selectDataListToPageByParam(tableName:string, param, column, pageNumber:number, pageSize:number) {
let selectParam:any = analysisParamToWhere(param, column);
selectParam.limit = pageSize || 10;
selectParam.offset = (pageNumber-1)*10;
let data = await mysqlModelMap[tableName].findAll(selectParam);
return data;
}
export async function selectDataCountByParam(tableName:string, param) {
let selectParam:any = analysisParamToWhere(param, []);
let data = await mysqlModelMap[tableName].count(selectParam);
return data;
}
export async function associationSelect(tableName:string, param) {
let model = mysqlModelMap[tableName];
if (!model) throw new BizError(ERRORENUM.不存在表);
let data = await model.aggragateData(param);
return data;
}
/**
* 多表联查 列表
* @param
* @param includeConf {"表名":["",""] }
* @param param
* @param column
* @returns
*/
export async function selectDataToTableAssociation(tableName:string, includeConf, param, column) {
let include = [];
for (let tableName in includeConf) {
if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
let item = includeConf[tableName];
let itemWhere= [];
let itemColumn = [];
if (Array.isArray(item)) {
itemColumn = item;
} else {
itemWhere = item.where;
itemColumn = item.column;
}
let includeInfomation = analysisParamToWhere(itemWhere, itemColumn);
includeInfomation.model = mysqlModelMap[tableName];
include.push(includeInfomation);
}
let selectParam:any = analysisParamToWhere(param, column);
selectParam.include = include;
let data = await mysqlModelMap[tableName].findAll(selectParam);
return data;
}
/**
* 多表联查 分页
* @param
* @param includeConf {"表名":["",""] }
* @param param
* @param column
* @returns
*/
export async function selectDataToTableAssociationToPage(tableName, includeConf, param, column, pageNumber:number, pageSize:number) {
let include = [];
for (let tableName in includeConf) {
if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
let item = includeConf[tableName];
let itemWhere= [];
let itemColumn = [];
if (Array.isArray(item)) {
itemColumn = item;
} else {
itemWhere = item.where || [];
itemColumn = item.column || [];
}
let includeInfomation = analysisParamToWhere(itemWhere, itemColumn);
includeInfomation.model = mysqlModelMap[tableName];
include.push(includeInfomation);
}
let selectParam:any = analysisParamToWhere(param, column);
selectParam.include = include;
selectParam.limit = pageSize || 10;
selectParam.offset = (pageNumber-1)*10;
let data = await mysqlModelMap[tableName].findAll(selectParam);
return data;
}
/**
* 多表查询单个
* @param
* @param includeConf
* @param param
* @param column
* @returns
*/
export async function selectOneDataToTableAssociation(tableName, includeConf, param, column) {
let include = [];
for (let tableName in includeConf) {
if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
let item = includeConf[tableName];
let itemWhere= [];
let itemColumn = [];
if (Array.isArray(item)) {
itemColumn = item;
} else {
itemWhere = item.where;
itemColumn = item.column;
}
let includeInfomation = analysisParamToWhere(itemWhere, itemColumn);
includeInfomation.model = mysqlModelMap[tableName];
include.push(includeInfomation);
}
let selectParam:any = analysisParamToWhere(param, column);
selectParam.include = include;
let data = await mysqlModelMap[tableName].findOne(selectParam);
data = data || {};
return data;
}
/**
* 多表获取总数
* @param tableName
* @param includeConf
* @param param
* @param column
*/
export async function selectDataCountToTableAssociation(tableName, includeConf, param) {
let include = [];
for (let tableName in includeConf) {
if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
let item = includeConf[tableName];
let itemWhere= [];
let itemColumn = [];
if (Array.isArray(item)) {
itemColumn = item;
} else {
itemWhere = item.where;
itemColumn = item.column;
}
let includeInfomation = analysisParamToWhere(itemWhere, itemColumn);
includeInfomation.model = mysqlModelMap[tableName];
include.push(includeInfomation);
}
let selectParam:any = analysisParamToWhere(param, []);
selectParam.include = include;
let count = await mysqlModelMap[tableName].count(selectParam);
return count;
}
\ No newline at end of file
src/model/sqlModelBind.ts 0 → 100644
/**
* mysql 数据层
*/
import { TablesConfig } from "../config/mysqlTableConfig";
import { mysqlDB } from "../db/mysqlInit";
let mysqlModelMap = {};
export async function initMysqlModel() {
/**初始化表 */
for (let i =0; i < TablesConfig.length; i++) {
let { tableName, schema } = TablesConfig[i];
let schemaConf = {
freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
timestamps:false //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
};
let assocsConfigList = [];
for (let key in schema) {
if (schema[key].references) {
let modelName = schema[key]["references"].model;
assocsConfigList.push({modelName, foreignKey:schema[key]["references"].key});
schema[key]["references"].model = mysqlModelMap[modelName];
}
}
let model = mysqlDB.define( tableName, schema, schemaConf);
mysqlModelMap[tableName] = await model.sync({}).then();
assocsConfigList.forEach(async (item) => {
let {modelName, foreignKey} = item;
mysqlModelMap[tableName].belongsTo(mysqlModelMap[modelName], {foreignKey});
});
}
console.log();
/**初始化表关联 */
// for (let i =0; i < TablesConfig.length; i++) {
// let { tableName, association } = TablesConfig[i];
// association.forEach( (item:any) => {
// if (item) {
// let {type, check, foreignKey} = item;
// if (type == "hasMany") {
// mysqlModelMap[check].hasOne(mysqlModelMap[tableName]);
// } else if (type == "hasMany") {
// mysqlModelMap[tableName].hasMany(mysqlModelMap[check], {foreignKey});
// }
// mysqlModelMap[check].belongsTo(mysqlModelMap[tableName], {foreignKey});
// console.log(check,"建立", tableName, "连接");
// }
// });
// }
}
export { mysqlModelMap };
\ No newline at end of file
src/model/updateData.ts 0 → 100644
import { Op, Sequelize } from "sequelize";
import { mysqlModelMap } from "./sqlModelBind";
/**
* where条件查询参数
* @param param
* %like%：模糊查询 {列名: {"%like%": }}
* %gt%：大于 {列名: {"%gt%": }}
* %gte%：大于等于 {列名: {"%gte%": }}
* %lt%：小于 {列名: {"%lt%": }}
* %lte%：小于等于 {列名: {"%lte%": }}
* %between%：查询范围内数据 {列名: {"%between%": ["开始参数", "结束参数"]}} ---BETWEEN 开始参数 AND 结束参数
* %notBetween%：查询不在范围内数据 {列名: {"%notBetween%": ["开始参数", "结束参数"]}} ---NOT BETWEEN 开始参数 AND 结束参数
* %orderDesc%: order by DESC {"%orderDesc%": "列名"}
* %limit%: {"%limit%": 数量}
* @returns
*/
function analysisParamToWhere(param) {
let where = {};
let order = [];
let limit = 0;
for (let key in param) {
if (typeof param[key] == "object") {
where[key] = {};
for (let whereKey in param[key]){
switch(whereKey) {
case "%like%":
where[key][Op.like] = `%${param[key]["%like%"]}%`;
break;
case "%gt%":
where[key][Op.gt] = param[key]["%gt%"];
break;
case "%gte%":
where[key][Op.gte] = param[key]["%gte%"];
break;
case "%lt%":
where[key][Op.lt] = param[key]["%lt%"];
break;
case "%lte%":
where[key][Op.lte] = param[key]["%lte%"];
break;
case "%between%":
where[key][Op.between] = param[key]["%between%"];
break;
case "%notBetween%":
where[key][Op.notBetween] = param[key]["%notBetween%"];
break;
case "%in%":
where[key][Op.in] = param[key]["%in%"];
break;
case "%notIn%":
where[key][Op.notIn] = param[key]["%notIn%"];
break;
}
}
}else {
switch (key) {
case "%orderDesc%":
order = [[Sequelize.col(param[key]), "DESC"]];
break;
case "%orderAsc%":
order = [[Sequelize.col(param[key]), "ASC"]];
break;
case "%limit%":
limit = param[key];
break;
default: where[key] = param[key];
}
}
}
let selectParam:any = {where};
if (order && order.length) selectParam.order = order;
if (limit) selectParam.limit = limit;
return selectParam;
}
export async function updateManyData(tableName, param:object, data:object) {
let where = analysisParamToWhere(param);
await mysqlModelMap[tableName].update(data, where);
return {isSuccess:true};
}
\ No newline at end of file
src/routers/askForLeave.ts
...@@ -6,6 +6,7 @@ import * as asyncHandler from 'express-async-handler'; ...@@ -6,6 +6,7 @@ import * as asyncHandler from 'express-async-handler';
import * as askForLeaveBiz from '../biz/askForLeave'; import * as askForLeaveBiz from '../biz/askForLeave';
import { checkFuHuaQiToken } from '../middleware/user'; import { checkFuHuaQiToken } from '../middleware/user';
import { eccReqParamater } from '../tools/eccParam'; import { eccReqParamater } from '../tools/eccParam';
import { memberSelectList } from '../biz/member';
export function setRouter(httpServer) { export function setRouter(httpServer) {
httpServer.post('/askforleave/add', checkFuHuaQiToken, asyncHandler(add)); httpServer.post('/askforleave/add', checkFuHuaQiToken, asyncHandler(add));
...@@ -25,10 +26,11 @@ export function setRouter(httpServer) { ...@@ -25,10 +26,11 @@ export function setRouter(httpServer) {
async function add(req, res) { async function add(req, res) {
let userId = req.headers.userid; let userId = req.headers.userid;
let userInfo = req.headers.userinfo;
let reqConf = {des: 'String', startTime: 'String', endTime: 'String', type:'Number', day:"Number", time:"Number"}; let reqConf = {des: 'String', startTime: 'String', endTime: 'String', type:'Number', day:"Number", time:"Number"};
let { des, startTime, endTime, type, day, time } = eccReqParamater(reqConf, req.body, ["day", "time"]); let { des, startTime, endTime, type, day, time } = eccReqParamater(reqConf, req.body, ["day", "time"]);
let result = await askForLeaveBiz.addAskForLeaveLog(userId, des, startTime, endTime, type, day, time); let result = await askForLeaveBiz.addAskForLeaveLog(userId, userInfo, des, startTime, endTime, type, day, time);
res.success(result); res.success(result);
} }
...@@ -98,7 +100,7 @@ async function personnelList(req, res) { ...@@ -98,7 +100,7 @@ async function personnelList(req, res) {
async function memberNameList(req, res) { async function memberNameList(req, res) {
let userId = req.headers.userid; let userId = req.headers.userid;
let result = await askForLeaveBiz.getMemberNameList(); let result = await memberSelectList();
res.success(result); res.success(result);
} }
...@@ -107,7 +109,7 @@ async function outPutData(req, res) { ...@@ -107,7 +109,7 @@ async function outPutData(req, res) {
let reqConf = { startTime:"String", endTime:"String", userId:"Number"}; let reqConf = { startTime:"String", endTime:"String", userId:"Number"};
let {userId, startTime, endTime} = eccReqParamater(reqConf, req.body, ["startTime", "endTime", "userId"]); let {userId, startTime, endTime} = eccReqParamater(reqConf, req.body, ["startTime", "endTime", "userId"]);
let result = await askForLeaveBiz.getOutPutPersonnelAFLList(userId, startTime, endTime); let result = await askForLeaveBiz.outPutPersonnelAFLList(userId, startTime, endTime);
res.success(result); res.success(result);
} }
src/routers/member.ts 0 → 100644
/**
* 成员
*/
import * as asyncHandler from 'express-async-handler';
import { checkFuHuaQiToken } from '../middleware/user';
import * as memberBiz from '../biz/member';
import { eccReqParamater } from '../tools/eccParam';
export function setRouter(httpServer) {
httpServer.post('/member/personnel/list', checkFuHuaQiToken, asyncHandler(memberList));
httpServer.post('/member/personnel/update', checkFuHuaQiToken, asyncHandler(updateInfo));
}
/**
* 成员列表
* @param req
* @param res
*/
async function memberList(req, res) {
let result = await memberBiz.getMemberList();
res.success(result);
}
/**
* 更新入职时间
* @param req
* @param res
*/
async function updateInfo(req, res) {
let reqConf = {userId: 'Number', ed: 'String'};
let { userId, ed} = eccReqParamater(reqConf, req.body, ["day", "time"]);
let result = await memberBiz.updateMemberData(userId, ed);
res.success(result);
}
\ No newline at end of file
src/routers/router.ts
...@@ -10,6 +10,7 @@ import * as overtimeRouters from './overtime' ...@@ -10,6 +10,7 @@ import * as overtimeRouters from './overtime'
import * as projectRouters from './project' import * as projectRouters from './project'
import * as statsRouters from './stats' import * as statsRouters from './stats'
import * as attendanceRouters from './attendance' import * as attendanceRouters from './attendance'
import * as memberRouters from './member'
export function setRouter(httpServer){ export function setRouter(httpServer){
...@@ -21,4 +22,5 @@ export function setRouter(httpServer){ ...@@ -21,4 +22,5 @@ export function setRouter(httpServer){
projectRouters.setRouter(httpServer); projectRouters.setRouter(httpServer);
statsRouters.setRouter(httpServer); statsRouters.setRouter(httpServer);
attendanceRouters.setRouter(httpServer); attendanceRouters.setRouter(httpServer);
memberRouters.setRouter(httpServer);
} }
\ No newline at end of file
src/routers/user.ts
...@@ -3,9 +3,9 @@ ...@@ -3,9 +3,9 @@
*/ */
import * as asyncHandler from 'express-async-handler'; import * as asyncHandler from 'express-async-handler';
import * as tools from '../util/tools';
import * as userBiz from '../biz/user'; import * as userBiz from '../biz/user';
import { checkFuHuaQiToken } from '../middleware/user'; import { checkFuHuaQiToken } from '../middleware/user';
import { eccReqParamater } from '../tools/eccParam';
export function setRouter(httpServer) { export function setRouter(httpServer) {
httpServer.post('/user/login', asyncHandler(login)); httpServer.post('/user/login', asyncHandler(login));
...@@ -15,7 +15,7 @@ export function setRouter(httpServer) { ...@@ -15,7 +15,7 @@ export function setRouter(httpServer) {
async function login(req, res) { async function login(req, res) {
let reqConf = {loginId:'String', pwd:'String'}; let reqConf = {loginId:'String', pwd:'String'};
let {loginId, pwd} = tools.checkReqParam(reqConf, req.body); let {loginId, pwd} = eccReqParamater(reqConf, req.body);
let userInfo = await userBiz.login(loginId, pwd); let userInfo = await userBiz.login(loginId, pwd);
......
src/routers/workingLog.ts
...@@ -5,9 +5,9 @@ ...@@ -5,9 +5,9 @@
import * as asyncHandler from 'express-async-handler'; import * as asyncHandler from 'express-async-handler';
import * as workingLogBiz from '../biz/workingLog'; import * as workingLogBiz from '../biz/workingLog';
import { checkFuHuaQiToken } from '../middleware/user'; import { checkFuHuaQiToken } from '../middleware/user';
import { eccReqParamater } from '../tools/eccParam'; import { eccEnumValue, eccReqParamater } from '../tools/eccParam';
import { eccEnumValue } from '../tools/eccEnum';
import { WORKLOGADMINTYPE } from '../config/enum'; import { WORKLOGADMINTYPE } from '../config/enum';
import { getDepartmentUserList } from '../biz/member';
export function setRouter(httpServer) { export function setRouter(httpServer) {
httpServer.post('/workinglog/find', checkFuHuaQiToken, asyncHandler(find)); httpServer.post('/workinglog/find', checkFuHuaQiToken, asyncHandler(find));
...@@ -128,7 +128,7 @@ async function departmentUserList(req, res) { ...@@ -128,7 +128,7 @@ async function departmentUserList(req, res) {
let reqConf = {departmentId:"Number"}; let reqConf = {departmentId:"Number"};
let {departmentId} = eccReqParamater(reqConf, req.body, []); let {departmentId} = eccReqParamater(reqConf, req.body, []);
let result = await workingLogBiz.getDepartmentUserList(departmentId); let result = await getDepartmentUserList(departmentId);
res.success(result); res.success(result);
} }
src/tools/eccEnum.ts deleted 100644 → 0
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
...@@ -3,35 +3,47 @@ import { BizError } from "../util/bizError"; ...@@ -3,35 +3,47 @@ import { BizError } from "../util/bizError";
/** /**
* 根据conf配置校验请求参数 * 根据conf配置校验请求参数
* @param conf 配置 * @param conf 配置
* @param param 表单 * @param param 表单
* @param skipKeys []不必填的字段 * @param skipKeys []不必填的字段
*/ */
export function eccReqParamater(conf:object, param, skipKeys?) { export function eccReqParamater(conf:object, param, skipKeys?) {
skipKeys = skipKeys || []; skipKeys = skipKeys || [];
for (let key in conf) {
let type = conf[key];
let value = param[key];
let isError = false; //校验是否异常 let skipMap = {};
let errorStr = "";//异常说明 skipKeys.forEach(keyName => {
skipMap[keyName] = 1;
});
if ( (typeof value != 'boolean') && !value ) { /**校验多余字段 */
if (skipKeys.indexOf(key) < 0 ) { for (let key in param) {
isError = true; if (!conf[key]) throw new BizError(ERRORENUM.参数错误, `多余${key}字段`);
errorStr = `缺少 ${key} 字段`; }
}
} else if(param[key]) { /**校验必填和缺失字段 */
let paramType = typeof param[key]; for (let key in conf) {
switch(conf[key]) { let confType = conf[key];
let value = param[key];
let valueType = typeof value;
if ( value == null || value == undefined ) {
if (!skipMap[key]) throw new BizError(ERRORENUM.参数错误, `缺失${key}字段`);
} else {
let isError = false;
let errorStr = "";
switch(confType) {
case 'Number': case 'Number':
if ( paramType != 'number' ) isError = true; if ( confType.toLowerCase() != valueType ) isError = true;
else {
if ((""+param[key]).indexOf('.') > -1) {
param[key] = parseInt(`${param[key] *100}`)/100;
}
}
break; break;
case 'String': case 'String':
if ( paramType != 'string' ) isError = true;
break;
case 'Boolean': case 'Boolean':
if ( paramType != 'boolean' ) isError = true; case 'Object':
if ( confType.toLowerCase() != valueType ) isError = true;
break; break;
case '[Number]': case '[Number]':
if ( !Array.isArray(param[key]) ) isError = true; if ( !Array.isArray(param[key]) ) isError = true;
...@@ -53,15 +65,76 @@ export function eccReqParamater(conf:object, param, skipKeys?) { ...@@ -53,15 +65,76 @@ export function eccReqParamater(conf:object, param, skipKeys?) {
} }
} }
break; break;
case '[String]':
if ( !Array.isArray(param[key]) ) isError = true;
for (let i =0; i < param[key].length; i++) {
let item = param[key][i];
if ( typeof item != 'string' ) {
isError = true;
errorStr = `${key}应是String型数组其中下标${i}是${typeof item}`;
}
}
break;
// case 'Address':
// /**地址类型 基本数据类型为数组字符串但是要判断层级关系 */
// if ( !Array.isArray(param[key]) ) {
// isError = true;
// errorStr = `${key}应是数组形`;
// }
// if ( param[key].length != 4) {
// isError = true;
// errorStr = `${key}超过特定长度4 目前长度 ${param[key].length}`;
// }
// for (let i =0; i < param[key].length; i++) {
// let item = param[key][i];
// if ( typeof item != 'string' ) {
// isError = true;
// errorStr = `${key}应是string型数组其中下标${i}是${typeof item}`;
// }
// }
// /** 不符合规则的 */
// let nullIndex = -1;
// for (let i = 0; i < param[key].length; i++) {
// if (nullIndex != -1) {//出现过空 第一次出现后的位置 都不能有值
// if (param[key]) {
// //做一个特化
// throw new BizError(ERRORENUM.地址数据不完整, `${key} 下标 ${nullIndex} 为空 `);
// }
// }
// if (nullIndex == -1 && !param[key][i]) {
// /**按顺序第一次赋值 */
// nullIndex = i;
// }
// }
// break;
} }
errorStr = isError && errorStr == "" ? `${key}应该是${type}型 而不是${paramType}`: errorStr; errorStr = isError && errorStr == "" ? `${key}应该是${confType}型 而不是${valueType}`: errorStr;
if (isError) throw new BizError(ERRORENUM.参数错误, errorStr);
} }
if (isError) throw new BizError(ERRORENUM.参数错误, errorStr);
}
for (let key in param) {
if (!conf[key]) throw new BizError(ERRORENUM.参数错误, `多余${key}字段`);
} }
return param; return param;
} }
/**
* 校验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/util/bizError.ts
/**
* 异常类
* 需要和log4js共同使用
*/
import { getBizMsg } from "../config/errorEnum"; import { getBizMsg } from "../config/errorEnum";
import { logError } from "./log"; import { logError } from "./log";
......
src/util/initData.ts deleted 100644 → 0
// /**
// * 初始化加班和调休数据
// */
// const xlsx = require('node-xlsx');
// const path = require('path');
// const md5 = require("md5");
// import moment = require("moment");
// import { onceSheetBecomeOfblockData } from "./analysisExcel";
// import { addWorkingLog } from "../data/admin/workinglog";
// import { addOvertime, initOvertime } from "../data/admin/overtime";
// import { ASKFORLEAVETYPE } from "../config/enum";
// import { initAskforleave } from "../data/admin/askForLeave";
// import { getAskForLeaveId, getOvertimeId } from "./tools";
// export async function initData() {
// // return
// let name = "李欣鸣";
// let userId = 12;
// let data = onceSheetBecomeOfblockData("初始化数据.xlsx", name);
// for(let i = 0; i < data.length; i++) {
// let {blockData, blockTitle} = data[i];
// if (blockTitle == "0_0") initAskForLeaveData(name, userId, blockData);
// if (blockTitle == "5_0") initOverTimeData(name, userId, blockData);
// }
// }
// async function initOverTimeData(name, userId, list) {
// if (!list) {
// console.log(name, "初始化加班", "=无数据");
// }
// let projectId = "SH-YY-GD";
// let utc = new Date();
// let count = 0;
// let addFloat = 0;
// for (let i = 0; i < list.length; i++) {
// if (!i) continue;
// let subList = list[i];
// let dataTime;
// if (typeof subList[0] == 'number') {
// dataTime =  new Date((subList[0] - 25569 ) * 86400 * 1000 + utc.getTimezoneOffset()*1000*60);
// } else dataTime = new Date(subList[0]);
// let id = `ot${userId}${new Date(dataTime).valueOf()}${Math.ceil(Math.random() *100)}`;
// let dateKey = moment(dataTime).format("YYYY-MM-DD")+ ' 18:00:00';
// let state = 1;
// let workLog = "归档";
// let time = subList[1];
// if (Math.floor(time) != time) addFloat += time - Math.floor(time);
// let approver = 3;//张老师
// if (Math.floor(time)) await initOvertime(id, projectId, userId, Math.floor(time), dateKey, workLog, approver, state);
// count+=1;
// }
// console.log(name+"初始化加班成功"+count+"条数据");
// let todayKey = '2023-01-22 18:00:00';
// if (addFloat) await initOvertime(getOvertimeId(userId), projectId, userId, Math.ceil(addFloat), todayKey, "补充小数位", 3, 1);
// console.log(name+"初始化加班 补录小数点一条数据"+addFloat+"小时");
// }
// async function initAskForLeaveData(name, userId, list) {
// if (!list) {
// console.log(name, "初始化请假", "=无数据");
// }
// let utc = new Date();
// let count = 0;
// let addFloat = 0;
// for (let i = 0; i < list.length; i++) {
// if (!i) continue;
// let subList = list[i];
// let dataTime;
// if (typeof subList[0] == 'number') {
// dataTime =  new Date((subList[0] - 25569 ) * 86400 * 1000 + utc.getTimezoneOffset()*1000*60);
// } else dataTime = new Date(subList[0]);
// let id = `al${userId}${new Date(dataTime).valueOf()}${Math.ceil(Math.random() *100)}`;
// let des = "调休";
// let startTime = moment(dataTime).format("YYYY-MM-DD")+ ' 09:00:00';
// let endTime = moment(dataTime).format("YYYY-MM-DD")+ ' 06:00:00';
// let dateKey = moment(dataTime).format("YYYY-MM-DD")+ ' 18:00:00';
// let state = 1;
// let day = 0;
// let time = subList[1];
// if (Math.floor(time) != time) addFloat += time - Math.floor(time);
// let type = ASKFORLEAVETYPE.调休;
// let approval = 3;//罗总
// if (Math.floor(time)) await initAskforleave(id, des, startTime, endTime, userId, approval, Math.floor(time), day, type, dateKey, state);
// count+=1;
// }
// console.log(name+"调休 初始化成功"+count+"条数据");
// let todayKey = '2023-01-22 18:00:00';
// let startTime = '2023-01-22 09:00:00';
// let endTime = '2023-01-22 18:00:00';
// if (Math.ceil(addFloat)) await initAskforleave(getAskForLeaveId(userId), "补充小数点", startTime, endTime, userId, 3, Math.ceil(addFloat), 0, ASKFORLEAVETYPE.调休, todayKey, 1);
// console.log(name+"初始化调休 补录小数点一条数据"+addFloat+"小时");
// }
\ No newline at end of file
src/util/log.ts
/**
* 日志类
* 包括错误日志 普通日志
* 日志存放在根目录的logs内
*/
let log4js = require('log4js'); let log4js = require('log4js');
let path = require('path'); let path = require('path');
...@@ -21,7 +27,7 @@ let config = { ...@@ -21,7 +27,7 @@ let config = {
"errorLogger": { "errorLogger": {
"type": "dateFile", // 日志类型 "type": "dateFile", // 日志类型
"filename": errFile, // 输出文件名 "filename": errFile, // 输出文件名
"pattern": "-yyyy-MM-dd.log", // 后缀 "pattern": "yyyy-MM-dd.log", // 后缀
"alwaysIncludePattern": true, // 上面两个参数是否合并 "alwaysIncludePattern": true, // 上面两个参数是否合并
"encoding": "utf-8", // 编码格式 "encoding": "utf-8", // 编码格式
"maxLogSize": 1000, // 最大存储内容 "maxLogSize": 1000, // 最大存储内容
...@@ -31,7 +37,7 @@ let config = { ...@@ -31,7 +37,7 @@ let config = {
"handleLogger": { "handleLogger": {
"type": "dateFile", "type": "dateFile",
"filename": handFile, "filename": handFile,
"pattern": "-yyyy-MM-dd.log", "pattern": "yyyy-MM-dd.log",
"alwaysIncludePattern": true, "alwaysIncludePattern": true,
"encoding": "utf-8", "encoding": "utf-8",
"maxLogSize": 1000, "maxLogSize": 1000,
......
src/util/myTools.ts 0 → 100644
import moment = require("moment");
const md5 = require("md5");
/**
* 生成工时填报的dateKey
* @returns
*/
export function generateDateKey(time?) {
if (time) {
return moment(time).format("YYYY-MM-DD")+ ' 18:00:00';
}
return moment().format("YYYY-MM-DD")+ ' 18:00:00'
}
/**
* 生成请假的id
* @param userId
* @returns
*/
export function generateAskForLeaveId(userId:number) {
return `al${userId}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`
}
export function getClientTime(time:string) {
return moment(time).format("YYYY/MM/DD HH:mm");
}
export function getDBTime(time?) {
if (!time) return moment().format("YYYY-MM-DD HH:mm:ss");
return moment(time).format("YYYY-MM-DD HH:mm:ss");
}
/**
* 生成加班填报的id
* @param userId
* @returns
*/
export function getOvertimeId(userId:number) {
return `ot${userId}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`
}
/**
* 获取token
* @param loginId 登录id
*/
export function getToken(loginId:string) {
return md5(`${loginId}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
}
/**
* 生成工时填报的id
* @param userId
* @returns
*/
export function getWorkingLogId(userId:number) {
return `wl${userId}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`
}
\ No newline at end of file
src/util/myXML.ts
/**
* 解析xml
*/
var xml2js = require("xml2js"); var xml2js = require("xml2js");
......
src/util/piecemeal.ts 0 → 100644
/**
* 零碎的通用工具
*/
import moment = require("moment");
/**
* 匹配新旧对象变化
* 将newObj 与 oldObj 比对，将newObj中发生变化的key返回
* 使用前需要校验对象中的内容
* @param newObj 新对象
* @param oldObj 旧对象
* @returns [key] 发生变化的key
*/
export function checkChange(newObj, oldObj) {
let changeKeyList = [];
for (let newKey in newObj) {
if (`${newObj[newKey]}` != `${oldObj[newKey]}`) changeKeyList.push(newKey);
}
return changeKeyList;
}
/**
* 根据conf截取data中的数据
* @param conf
* @param data
* @returns
*/
export function extractData(conf, data, isAdmin) {
let result = {};
for (let key in conf) {
let confInfo = conf[key];
if (confInfo.changeDate) {
if (isAdmin) result[key] = data[key] ? moment(data[key]).format("YYYY-MM-DD") : '-';
else result[key] = data[key] || 0;
} else if (confInfo.isAdd && isAdmin) {
let addStr = "";
data[key].forEach(str => {
addStr += str;
});
result[key] = addStr;
}
else {
result[key] = data[key];
if (typeof result[key] == 'string' && !result[key]) result[key] = '';
}
}
return result;
}
/**
* 校验数据对象是否有空
* @param data
* @param sensitive 敏感校验 true时 0 和 ""会校验失败 false时 校验成功
* @returns true/false true = 有空值 false=无空值
*/
export function checkDataHaveNull(data:object, sensitive:boolean) {
if (Array.isArray(data)) return data.length == 0;
if (Object.keys(data).length == 0) return true;
let success = false;
for (let key in data) {
if (data[key] == null || data[key] == undefined) success = true;
if (sensitive) {
if (data[key] === 0 || data[key] === "" ) success = true;
}
}
return success;
}
/**
* 将枚举值转换成对应的枚举名(key)
* @param enumConf 目标枚举
* @param value 目标值
* @returns string 返回字符串 如果传入多个枚举值，就拼接字符串
*/
export function changeEnumValue(enumConf, value:any) {
if (!value) return '';
if ( typeof value == 'number' ) {
return enumConf[value];
}
let str = "";
value.forEach((item, index) => {
str += enumConf[item];
if (index == value.length-1) str+="";
else str += ","
});
return str;
}
src/util/request.ts
/**
* 请求工具
*/
import * as request from 'request'; import * as request from 'request';
import { BizError } from './bizError'; import { BizError } from './bizError';
/**
* 请求接口（get）
* @param url 路由
* @param query 请求参数
* @param headers 请求头
* @returns
*/
export function get(url:string, query?, headers?) { export function get(url:string, query?, headers?) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误"); if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
return new Promise((resolve, reject)=>{ return new Promise((resolve, reject)=>{
...@@ -31,7 +42,7 @@ export function post(url, body, headers) { ...@@ -31,7 +42,7 @@ export function post(url, body, headers) {
resolve(body); resolve(body);
} }
else { else {
reject(error) // reject(error)
} }
}); });
}) })
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment