Skip to content

W
wenHuaBu_adminServer
Commit 943b86e1 by lixinming
Options

init

parents
Showing with 4456 additions and 0 deletions
.gitignore 0 → 100644
.idea
/out
/node_modules
/test
/public
/logs
/video
*.logs
*.zip
.vscode/launch.json 0 → 100644
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "启动程序",
"program": "${workspaceFolder}/src/main.ts",
"outFiles": [
"${workspaceFolder}/**/*.js"
]
}
]
}
\ No newline at end of file
package.json 0 → 100644
{
"name": "screen",
"version": "1.0.0",
"description": "",
"main": "main.ts",
"dependencies": {
"@alicloud/sms-sdk": "^1.1.6",
"@types/node": "^10.12.18",
"compression": "^1.7.4",
"express": "^4.17.1",
"express-async-handler": "^1.1.4",
"express-history-api-fallback": "^2.2.1",
"formidable": "^1.2.1",
"log4js": "^6.6.1",
"lru-cache": "^4.1.5",
"md5": "^2.2.1",
"moment": "^2.24.0",
"mongoose": "^5.4.0",
"mysql": "^2.18.1",
"mysql2": "^3.7.0",
"node-xlsx": "^0.16.1",
"nodemailer": "^6.1.1",
"officegen": "^0.6.5",
"qs": "^6.11.0",
"request": "^2.88.0",
"sequelize": "^6.35.2",
"svg-captcha": "^1.3.12",
"tencentcloud-sdk-nodejs": "^4.0.562",
"ws": "^5.2.2",
"xml2js": "^0.4.23"
},
"devDependencies": {},
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "cjj",
"license": "ISC",
"bin": "./out/main.js",
"pkg": {
"scripts": "out/**/*.js",
"assets": [
"public/**/*",
"res/**/*",
"images/**/*",
"video/**/*"
],
"outputPath": "dist"
}
}
serverConfig.xml 0 → 100644
<config>
<port>40011</port>
<!-- 默认null mysql填入mysql mongodb填入mongo 都有填all 如果没有数据库填null -->
<specifyDB>all</specifyDB>
<mongodb>
<path>127.0.0.1</path>
<port>27017</port>
<w>1</w>
<!-- <dataBase>baseDB</dataBase> -->
<dataBase>xuehui</dataBase>
<wtimeoutMS>30000</wtimeoutMS>
</mongodb>
<mysqldb>
<!-- 本地mysql配置 -->
<mysqlHost>192.168.0.105</mysqlHost>
<mysqlPort>3306</mysqlPort>
<mysqlUser>root</mysqlUser>
<mysqlPwd>123456</mysqlPwd>
<dataBase>xuehui</dataBase>
</mysqldb>
</config>
src/biz/member/member.ts 0 → 100644
/**
* 会员逻辑
*/
/**
* 单位会员列表
* @param param0
*/
export async function unitMemberList({unitName, joinTime}) {
}
export async function memberList({}) {
}
src/biz/member/user.ts 0 → 100644
/**
* 用户逻辑
*/
import { DOCUMENTTYPE, MEMBERTYPE, NATION, PROFCATEGORY, SEX, UNITINFOTYPE } from "../../config/enum";
import { ERRORCODEENUM, ERRORENUM } from "../../config/errorEnum";
import { addOneData } from "../../data/add";
import { TABLEENUM } from "../../data/models/model";
import { findOnce } from "../../data/select";
import { updateOneData } from "../../data/update";
import { generateToken, generateUserId, successResult } from "../../tools/system";
import { BizError } from "../../util/bizError";
import { eccEnumValue } from "../../util/verificationEnum";
/**
* 注册个人会员
* @param param0
*/
export async function signInOfEntity({form}) {
/**校验枚举 */
const EccFuncName = '注册个人会员';
eccEnumValue(EccFuncName, '性别', SEX, form.sex);
eccEnumValue(EccFuncName, '证件类型', DOCUMENTTYPE, form.documentType);
eccEnumValue(EccFuncName, '民族', NATION, form.nation);
eccEnumValue(EccFuncName, '专业类别', PROFCATEGORY, form.profCategory);
let oldData = await findOnce(TABLEENUM.用户表, {"$or":[{loginId:form.loginId}, {phone:form.phone}, {mail:form.mail}] });
if (oldData && oldData.userId) {
if (oldData.loginId == form.loginId) throw new BizError(ERRORENUM.用户名重复, form.loginId );
if (oldData.phone == form.phone) throw new BizError(ERRORENUM.联系人手机号重复, form.phone );
if (oldData.mail == form.mail) throw new BizError(ERRORENUM.邮箱重复, form.loginId );
}
/**校验密码 */
if (form.pwd.search(/^[A-Za-z0-9]{6,18}$/) < 0) throw new BizError(ERRORENUM.密码只能由6至18位字符和数字组成);
if (form.pwd != form.confirmation) throw new BizError(ERRORENUM.两次密码不一致);
delete form.confirmation;
form.userId = generateUserId();
form.memberType = MEMBERTYPE.个人会员;
form.isAdmin = 0;
await addOneData(TABLEENUM.用户表, form);
return successResult();
}
/**
* 单位会员
* @param param0
*/
export async function singInOfUnit({form}) {
/**校验枚举 */
const EccFuncName = '注册单位会员';
eccEnumValue(EccFuncName, '单位信息类型', UNITINFOTYPE, form.unitInfoType);
let oldData = await findOnce(TABLEENUM.用户表, {"$or":[{loginId:form.loginId}, {phone:form.phone}, {mail:form.mail}] });
if (oldData && oldData.userId) {
if (oldData.loginId == form.loginId) throw new BizError(ERRORENUM.用户名重复, form.loginId );
if (oldData.phone == form.phone) throw new BizError(ERRORENUM.联系人手机号重复, form.phone );
if (oldData.mail == form.mail) throw new BizError(ERRORENUM.邮箱重复, form.loginId );
}
/**校验密码 */
if (form.pwd.search(/^[A-Za-z0-9]{6,18}$/) < 0) throw new BizError(ERRORENUM.密码只能由6至18位字符和数字组成);
if (form.pwd != form.confirmation) throw new BizError(ERRORENUM.两次密码不一致);
delete form.confirmation;
form.userId = generateUserId();
form.memberType = MEMBERTYPE.单位会员;
form.isAdmin = 0;
await addOneData(TABLEENUM.用户表, form);
return successResult();
}
/**
* 登陆
* @param param0
* @returns
*/
export async function login({loginId, pwd }) {
let userInfo = await findOnce(TABLEENUM.用户表, {loginId});
if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号或密码错误);
if (userInfo.pwd != pwd ) throw new BizError(ERRORENUM.账号或密码错误);
let token = generateToken(userInfo.userId);
await updateOneData(TABLEENUM.用户表, {userId:userInfo.userId}, {token, tokenMs:new Date().valueOf()});
return {
userInfo:{
isAdmin:userInfo.isAdmin == 1,
name:userInfo.name,
userId:userInfo.userId,
token:token
}
}
}
/**
* 退出登陆
* @param userId
* @returns
*/
export async function logout({userId}) {
let token = generateToken(userId);
await updateOneData(TABLEENUM.用户表, {userId:userId}, {token});
return successResult();
}
src/biz/portal/dangJianGonZuo/wenZiZiLiao.ts 0 → 100644
/**
* 文字资料
*/
import { ARTICLEPOSITION } from "../../../config/enum";
import { ERRORENUM } from "../../../config/errorEnum";
import { addManyData } from "../../../data/add";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
import { changeEnumValue, eccEnumValue } from "../../../util/verificationEnum";
/**
* 列表
* @param param0
* @returns
*/
export async function list({userId, type}) {
let dbList = await find(TABLEENUM.文字资料, {type});
let dataList = [];
if ( !dbList || !dbList.length) {
let addList = [];
for (let i = 1; i <= 8; i++) {
let id = generateSystemId(TABLEENUM.文字资料, userId);
addList.push({id, rank:i, title:'', articleUrl:'', type, imgUrl:"", position:0, articleTitle:'', updateTime:0});
dataList.push({id, rank:i, title:'', articleUrl:'', type, imgUrl:"", position:0, articleTitle:'', updateTime:0});
}
await addManyData(TABLEENUM.文字资料, addList);
}
dataList.sort((a:any, b:any) => {return a.rank - b.rank });
dbList.forEach(info => {
let item:any = extractData(info, ["id", "title", "rank", "position", "articleTitle" ]);
if (!item.position) item.position = "未选择";
else changeEnumValue(ARTICLEPOSITION, item.position);
dataList.push(item);
});
return {dataList};
}
/**
* 预览
*/
export async function preview({userId, type}) {
let dbList = await find(TABLEENUM.文字资料, {type});
let dataList = [];
if (!dbList || !dbList.length) {
let addList = [];
for (let i = 1; i <= 8; i++) {
let id = generateSystemId(TABLEENUM.文字资料, userId);
addList.push({id, rank:i, title:'', articleUrl:'', type, imgUrl:"", position:0, articleTitle:'', updateTime:0});
dataList.push({id, rank:i, title:'', articleUrl:'', type, imgUrl:"", position:0, articleTitle:'', updateTime:0});
}
await addManyData(TABLEENUM.文字资料, addList);
}
dataList.sort((a:any, b:any) => {return a.rank - b.rank });
dbList.forEach(info => {
let item = extractData(info, ["id", "title", "rank", "imgUrl", "updateTime"]);
dataList.push(item);
});
return {dataList};
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, title, imgUrl, position, articleTitle, articleUrl, updateTime}) {
eccEnumValue('修改文字资料', '位置', ARTICLEPOSITION, position );
let oldInfo = await findOnce(TABLEENUM.文字资料, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.文字资料, {id}, {title, imgUrl, position, articleTitle, articleUrl, updateTime});
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.文字资料, {id});
if (!dataInfo || !dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.文字资料, {id}, {title:'', imgUrl:'', position:0, articleTitle:'', articleUrl:'', updateTime:0});
return successResult();
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.文字资料, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let dataInfo = extractData(oldInfo, ["id", "title", "imgUrl", "position", "articleTitle", "articleUrl", "updateTime"]);
return { dataInfo };
}
\ No newline at end of file
src/biz/portal/dangJianGonZuo/xueXiYuanDi.ts 0 → 100644
/**
* 学习园地
*
*
*/
import { PARTYBUILDSUBTYPEENUM, PARTYBUILDTYPEENUM, STATE } from "../../../config/enum";
import { ERRORENUM } from "../../../config/errorEnum";
import { addManyData } from "../../../data/add";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
export async function list() {
let dbList = await find(TABLEENUM.党建, {type:PARTYBUILDTYPEENUM.学习园地});
if (!dbList || !dbList.length) {
let dbList = [
{id:1100, type:PARTYBUILDTYPEENUM.学习园地, subType:PARTYBUILDSUBTYPEENUM.视频资料, display:true, name:"类型1"},
{id:1101, type:PARTYBUILDTYPEENUM.学习园地, subType:PARTYBUILDSUBTYPEENUM.视频资料, display:true, name:"类型2"},
{id:1102, type:PARTYBUILDTYPEENUM.学习园地, subType:PARTYBUILDSUBTYPEENUM.视频资料, display:true, name:"类型3"},
{id:1200, type:PARTYBUILDTYPEENUM.学习园地, subType:PARTYBUILDSUBTYPEENUM.文字资料, display:true, name:"类型1"},
{id:1201, type:PARTYBUILDTYPEENUM.学习园地, subType:PARTYBUILDSUBTYPEENUM.文字资料, display:true, name:"类型2"},
{id:1202, type:PARTYBUILDTYPEENUM.学习园地, subType:PARTYBUILDSUBTYPEENUM.文字资料, display:true, name:"类型3"}
];
await addManyData(TABLEENUM.党建, dbList);
}
let videoList = [];
let fileList = [];
dbList.forEach(info => {
let {id, subType, name, display} = info;
if (subType == PARTYBUILDSUBTYPEENUM.文字资料) {
fileList.push({
id,
subType,
name,
display:display == STATE.是,
count:11
});
} else {
videoList.push({
id,
subType,
name,
display:display == STATE.是,
count:11
});
}
});
return {fileList, videoList};
}
export async function update(secureArgs:any) {
let {userId, id, typeName} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.党建, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.党建, {id}, {name:typeName});
return successResult();
}
export async function changeState({userId, id}) {
let oldInfo = await findOnce(TABLEENUM.党建, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.display == 1 ? 0 : 1;
await updateOneData(TABLEENUM.党建, {id}, {display:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/dangJianGonZuo/zhuTiJiaoYu.ts 0 → 100644
/**
* 主题教育
*/
import { PARTYBUILDTYPEENUM, STATE } from "../../../config/enum";
import { ERRORENUM } from "../../../config/errorEnum";
import { addManyData } from "../../../data/add";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
export async function list() {
let dbList = await find(TABLEENUM.党建, {type:PARTYBUILDTYPEENUM.主题教育});
if (!dbList || !dbList.length) {
let dbList = [
{id:1000, type:PARTYBUILDTYPEENUM.主题教育, display:true, name:"类型1"},
{id:1001, type:PARTYBUILDTYPEENUM.主题教育, display:true, name:"类型2"},
{id:1002, type:PARTYBUILDTYPEENUM.主题教育, display:true, name:"类型3"},
{id:1003, type:PARTYBUILDTYPEENUM.主题教育, display:true, name:"类型4"}
];
await addManyData(TABLEENUM.党建, dbList);
}
let dataList = [];
dbList.forEach(info => {
let {id, name, display} = info;
dataList.push({
id,name,count:88, display:display == STATE.是
});
});
return {dataList};
}
export async function update({userId, id, typeName}) {
let oldInfo = await findOnce(TABLEENUM.党建, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.党建, {id}, {name:typeName});
return successResult();
}
export async function changeState({userId, id}) {
let oldInfo = await findOnce(TABLEENUM.党建, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.display == 1 ? 0 : 1;
await updateOneData(TABLEENUM.党建, {id}, {display:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/fenZhiJiGou/gongZuoDongTai.ts 0 → 100644
/**
* 分支机构-机构管理-内容管理-工作动态
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建工作动态
* @param userId
* @param param
* @returns
*/
export async function create({userId, agencyId, form}) {
form.id = generateSystemId(TABLEENUM.工作动态, userId);
form.agencyId = agencyId;
await addOneData(TABLEENUM.工作动态, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.工作动态, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
if (form.agencyId) {
delete form.agencyId;
}
await updateOneData(TABLEENUM.工作动态, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.工作动态, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.工作动态, {id});
return successResult();
}
export async function list({userId, agencyId}) {
let jiGouNameMap = await getJiGouMap();
let dbList = await find(TABLEENUM.工作动态, {agencyId});
let dataList = [];
dbList.forEach(info => {
let item:any = extractData(info, ["id", "title", "activityTime", "isUse"]);
item.jiGouName = jiGouNameMap[info.agencyId];
dataList.push(item);
});
return {dataList};
}
async function getJiGouMap() {
let jiGouList = await find(TABLEENUM.机构管理, {});
let map = {};
jiGouList.forEach(info => {
let {id, name} = info;
map[id] = name;
});
return map;
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.工作动态, {id});
let dataInfo = extractData(oldInfo, ["id", "title", "activityTime", "imgUrl", "isUse", "desc"]);
return { dataInfo };
}
export async function changeUse({id}) {
let oldInfo = await findOnce(TABLEENUM.工作动态, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.isUse == 1 ? 0 : 1;
await updateOneData(TABLEENUM.工作动态, {id}, {isUse:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/fenZhiJiGou/jiGouGuanLi.ts 0 → 100644
/**
* 机构管理
* 排序，后一个排序会与修改前的排序互换
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建机构管理
* @param userId
* @param param
* @returns
*/
export async function create({userId, form}) {
let oldRankInfo = await findOnce(TABLEENUM.机构管理, {rank:form.rank});
if(oldRankInfo && oldRankInfo.id) {
/**存在原来的排名，将上一个去掉 */
await deleteOneData(TABLEENUM.机构管理, {id:oldRankInfo.id});
}
form.id = generateSystemId(TABLEENUM.机构管理, userId);
await addOneData(TABLEENUM.机构管理, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.机构管理, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
if (oldInfo.rank != form.rank) {
//排名发生变化
let oldRankInfo = await findOnce(TABLEENUM.机构管理, {rank:form.rank});
await updateOneData(TABLEENUM.机构管理, {id:oldRankInfo.id}, {rank:oldInfo.rank});
}
await updateOneData(TABLEENUM.机构管理, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.机构管理, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.机构管理, {id});
return successResult();
}
export async function list() {
let dbList = await find(TABLEENUM.机构管理, {});
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "rank", "name", "awardsCount", "logoUrl", "desc"]);
dataList.push(item);
});
dataList.sort((a, b) => {return a.rank - b.rank});
return {dataList};
}
/**
* 预览
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.机构管理, {id});
let dataInfo = extractData(oldInfo, ["id", "rank", "name", "awardsCount", "desc", "logoUrl"]);
/**获取上下3位的排名列表 */
return { dataInfo };
}
src/biz/portal/fenZhiJiGou/weiYuanMingDan.ts 0 → 100644
/**
* 分支机构-机构管理-内容管理-委员名单
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建委员名单
* @param userId
* @param param
* @returns
*/
export async function create({userId, agencyId, form}) {
form.id = generateSystemId(TABLEENUM.委员名单, userId);
form.agencyId = agencyId;
await addOneData(TABLEENUM.委员名单, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.委员名单, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
if (form.agencyId) {
delete form.agencyId;
}
await updateOneData(TABLEENUM.委员名单, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.委员名单, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.委员名单, {id});
return successResult();
}
export async function list({userId, agencyId}) {
let jiGouNameMap = await getJiGouMap();
let dbList = await find(TABLEENUM.委员名单, {agencyId});
let dataList = [];
dbList.forEach(info => {
let item:any = extractData(info, ["id", "name", "branchDuties", "unit", "unitDuties"]);
item.jiGouName = jiGouNameMap[info.agencyId];
dataList.push(item);
});
return {dataList};
}
async function getJiGouMap() {
let jiGouList = await find(TABLEENUM.机构管理, {});
let map = {};
jiGouList.forEach(info => {
let {id, name} = info;
map[id] = name;
});
return map;
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.委员名单, {id});
let dataInfo = extractData(oldInfo, ["id", "name", "branchDuties", "unit", "unitDuties"]);
return { dataInfo };
}
src/biz/portal/fenZhiJiGou/xiaZaiZhuanQu.ts 0 → 100644
/**
* 下载专区
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建下载专区
* @param userId
* @param param
* @returns
*/
export async function create({userId, agencyId, form}) {
form.id = generateSystemId(TABLEENUM.下载专区, userId);
form.agencyId = agencyId;
form.ct = new Date().valueOf();
await addOneData(TABLEENUM.下载专区, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.下载专区, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
if (form.agencyId) {
delete form.agencyId;
}
await updateOneData(TABLEENUM.下载专区, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.下载专区, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.下载专区, {id});
return successResult();
}
export async function list({userId, agencyId}) {
let jiGouNameMap = await getJiGouMap();
let dbList = await find(TABLEENUM.下载专区, {agencyId});
let dataList = [];
dbList.forEach(info => {
let item:any = extractData(info, ["id", "name", "ct"]);
item.jiGouName = jiGouNameMap[info.agencyId];
dataList.push(item);
});
return {dataList};
}
async function getJiGouMap() {
let jiGouList = await find(TABLEENUM.机构管理, {});
let map = {};
jiGouList.forEach(info => {
let {id, name} = info;
map[id] = name;
});
return map;
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.下载专区, {id});
let dataInfo = extractData(oldInfo, ["id", "name", "type", "fileUrl"]);
return { dataInfo };
}
src/biz/portal/neiRongGuanLi/bannerGuanLi.ts 0 → 100644
/**
* banner管理
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建banner
* @param userId
* @param param
* @returns
*/
export async function create(secureArgs) {
let {userId, form} = secureArgs;
form.ct = new Date().valueOf();
form.id = generateSystemId(TABLEENUM.banner管理, userId);
await addOneData(TABLEENUM.banner管理, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update(secureArgs:any) {
let {userId, id, form} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.banner管理, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.banner管理, {id}, form);
return successResult();
}
export async function del(secureArgs:any) {
let {userId, id} = secureArgs;
let dataInfo = await findOnce(TABLEENUM.banner管理, {id});
if (!dataInfo || !dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.banner管理, {id});
return successResult();
}
export async function list(secureArgs:any) {
let {userId, title} = secureArgs;
let selectParam:any = {};
if (title) selectParam.title = title;
let dbList = await find(TABLEENUM.banner管理, selectParam);
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, [ "id", "location","articleTitle", "position","articleUrl", "display", "desc"]);
dataList.push(item);
});
return {dataList};
}
/**
* 回显
* @param id
*/
export async function info(secureArgs:any) {
let {id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.banner管理, {id});
let dataInfo = extractData(oldInfo, [ "id", "location", "articleTitle", "position", "imgUrl", "articleUrl", "desc"]);
return { dataInfo };
}
export async function changePush({id}) {
let oldInfo = await findOnce(TABLEENUM.banner管理, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.display == 1 ? 0 : 1;
await updateOneData(TABLEENUM.banner管理, {id}, {display:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/neiRongGuanLi/shiPinGuanLi.ts 0 → 100644
/**
* 视频管理
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建文章
* @param userId
* @param param
* @returns
*/
export async function create(secureArgs) {
let {userId, form} = secureArgs;
form.ct = new Date().valueOf();
form.id = generateSystemId(TABLEENUM.视频管理, userId);
await addOneData(TABLEENUM.视频管理, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update(secureArgs:any) {
let {userId, id, form} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.视频管理, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.视频管理, {id}, form);
return successResult();
}
export async function del(secureArgs:any) {
let {userId, id} = secureArgs;
let dataInfo = await findOnce(TABLEENUM.视频管理, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.视频管理, {id});
return successResult();
}
export async function list(secureArgs:any) {
let {userId, videoType, title, videoTime} = secureArgs;
let selectParam:any = {};
if (videoType) selectParam.videoType = videoType;
if (title) selectParam.title = title;
if (videoTime) {
selectParam["$and"] = [
{videoTime:{"$gt":videoTime}},
{videoTime:{"$lt":videoTime+(24*3600*1000)}}
];
}
let dbList = await find(TABLEENUM.视频管理, selectParam);
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "title", "videoType", "videoTime", "desc", "display"]);
dataList.push(item);
});
return {dataList};
}
/**
* 回显
* @param id
*/
export async function info(secureArgs:any) {
let {id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.视频管理, {id});
let dataInfo = extractData(oldInfo, ["id", "title", "videoType", "videoUrl", "videoTime", "desc"]);
return { dataInfo };
}
export async function changePush({id}) {
let oldInfo = await findOnce(TABLEENUM.视频管理, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.display == 1 ? 0 : 1;
await updateOneData(TABLEENUM.视频管理, {id}, {display:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/neiRongGuanLi/wenZhangGuanLi.ts 0 → 100644
/**
* 文章管理
*/
import { STATE } from "../../../config/enum";
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建文章
* @param userId
* @param param
* @returns
*/
export async function create(secureArgs) {
let {userId, form} = secureArgs;
form.ct = new Date().valueOf();
form.id = generateSystemId(TABLEENUM.文章管理, userId);
await addOneData(TABLEENUM.文章管理, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update(secureArgs:any) {
let {userId, id, form} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.文章管理, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.文章管理, {id}, form);
return successResult();
}
export async function del(secureArgs:any) {
let {userId, id} = secureArgs;
let dataInfo = await findOnce(TABLEENUM.文章管理, {id});
if (!dataInfo || !dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.文章管理, {id});
return successResult();
}
export async function list(secureArgs:any) {
let {userId, articleType, title, articleTime} = secureArgs;
let selectParam:any = {};
if (articleType) selectParam.articleType = articleType;
if (title) selectParam.title = title;
if (articleTime) {
selectParam["$and"] = [
{videoTime:{"$gt":articleTime}},
{videoTime:{"$lt":articleTime+(24*3600*1000)}}
];
}
let dbList = await find(TABLEENUM.文章管理, selectParam);
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, [ "id", "title", "articleType", "imgUrl", "articleTime", "desc", "display"]);
dataList.push(item);
});
return {dataList};
}
/**
* 回显
* @param id
*/
export async function info(secureArgs:any) {
let {id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.文章管理, {id});
let dataInfo = extractData(oldInfo, ["id", "title", "articleType", "imgUrl", "articleTime", "desc"]);
return { dataInfo };
}
export async function changePush({id}) {
let oldInfo = await findOnce(TABLEENUM.文章管理, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.display == 1 ? 0 : 1;
await updateOneData(TABLEENUM.文章管理, {id}, {display:newPush});
return successResult();
}
export async function getTitleList({type}) {
let selectParam = {articleType:{"$in":[type]}, display:STATE.是};
let dbList = await find(TABLEENUM.文章管理, selectParam, ["id", "title"]);
let dataList = [];
dbList.forEach(info => {
dataList.push({
key:info.title,
value:info.id
});
});
return {dataList}
}
\ No newline at end of file
src/biz/portal/pinPaiXiangMu/fangHuaBei.ts 0 → 100644
/**
* 芳华杯
*/
import moment = require("moment");
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建芳华杯信息
* @param userId
* @param param
* @returns
*/
export async function create(secureArgs) {
let {userId, form} = secureArgs;
form.id = generateSystemId(TABLEENUM.芳华杯, userId);
await addOneData(TABLEENUM.芳华杯, form);
return successResult();
}
/**
* 修改芳华杯信息
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update(secureArgs:any) {
let {userId, id, form} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.芳华杯, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.芳华杯, {id}, form);
return successResult();
}
export async function del(secureArgs:any) {
let {userId, id} = secureArgs;
let dataInfo = await findOnce(TABLEENUM.芳华杯, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.芳华杯, {id});
return successResult();
}
export async function list({desc, worksType, year}) {
let param:any = {};
if (desc) param.desc = {"$regex":`${desc}`};
if (worksType) param.worksType = worksType;
if (year) {
let st = new Date(`${year}-01-01 00:00:00`).valueOf();
let et = new Date(`${year+1}-01-01 00:00:00`).valueOf();
param["$and"] = [
{awardTime:{"$gt":st}},
{awardTime:{"$lt":et}}
];
}
let dbList = await find(TABLEENUM.芳华杯, param);
let dataList = [];
dbList.forEach(info => {
let item:any = extractData(info, ["id", "name", "works", "worksType", "awardTime", "desc"]);
// item.awardTime = moment(item.awardTime).format("YYYY-MM-DD");
dataList.push(item);
});
return dataList;
}
/**
* 回显
* @param id
*/
export async function info(secureArgs:any) {
let {id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.芳华杯, {id});
let dataInfo = extractData(oldInfo, ["id", "name", "works", "worksType", "awardTime", "desc"]);
return { dataInfo };
}
src/biz/portal/pinPaiXiangMu/xueShuYanJiu.ts 0 → 100644
/**
* 学术研究
*/
import { IMGEDITFUNENUM } from "../../../config/enum";
import { ERRORENUM } from "../../../config/errorEnum";
import { addManyData } from "../../../data/add";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
/**
* 列表
* @param secureArgs
* @returns
*/
export async function list(secureArgs:any) {
let {userId} = secureArgs;
let dbList = await find(TABLEENUM.图片编辑, {type:IMGEDITFUNENUM.学术研究});
if (!dbList.length) {
/**不存在数据时需要给两个默认的数据 */
dbList = [
{ id:generateSystemId(TABLEENUM.图片编辑, userId), type:IMGEDITFUNENUM.学术研究, index:1, imgUrl:'', desc:'' },
{ id:generateSystemId(TABLEENUM.图片编辑, userId), type:IMGEDITFUNENUM.学术研究, index:2, imgUrl:'', desc:'' },
];
await addManyData(TABLEENUM.图片编辑, dbList);
}
let dataList = [];
dbList.forEach(info => {
let {id, index, imgUrl, desc} = info;
dataList.push({id, imgUrl, desc, name:`图${index}`, index});
});
return {dataList};
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update(secureArgs:any) {
let {userId, id, imgUrl, desc} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.图片编辑, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.图片编辑, {id}, {desc, imgUrl});
return successResult();
}
/**
* 逻辑删除
* @param secureArgs
* @returns
*/
export async function del(secureArgs:any) {
let {userId, id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.图片编辑, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.图片编辑, {id}, {desc:"", imgUrl:""});
return successResult();
}
/**
* 详情
* @param secureArgs
* @returns
*/
export async function info(secureArgs:any) {
let {userId, id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.图片编辑, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let {imgUrl, desc} = oldInfo;
return {dataInfo:{imgUrl, desc}};
}
/**
* 预览
*/
export async function preview({userId}) {
let dbList = await find(TABLEENUM.图片编辑, {type:IMGEDITFUNENUM.学术研究});
dbList.sort((a, b) => {return a.index - b.index});
let imgList = [];
dbList.forEach(info => {
let {id, index, imgUrl, desc} = info;
imgList.push({id, imgUrl, index, desc});
});
let contentList = [
{
year:2021,
month:12,
day:31,
title:'学术研究标题',
author:'张三'
},
{
year:2021,
month:12,
day:31,
title:'学术研究标题',
author:'张三'
},
{
year:2021,
month:12,
day:31,
title:'学术研究标题',
author:'张三'
},
{
year:2021,
month:12,
day:31,
title:'学术研究标题',
author:'张三'
},
{
year:2021,
month:12,
day:31,
title:'学术研究标题',
author:'张三'
}
];
return {imgList, contentList};
}
src/biz/portal/shouYe/zhuanTiXiLie.ts 0 → 100644
/**
* 专题系列
*/
import { ARTICLEPOSITION } from "../../../config/enum";
import { ERRORENUM } from "../../../config/errorEnum";
import { addManyData } from "../../../data/add";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
import { changeEnumValue } from "../../../util/verificationEnum";
/**
* 列表
* @param param0
* @returns
*/
export async function list({userId}) {
let dbList = await find(TABLEENUM.专题系列, {});
let dataList = [];
if ( !dbList || !dbList.length) {
let addList = [];
for (let i = 1; i <= 5; i++) {
let id = generateSystemId(TABLEENUM.专题系列, userId);
addList.push({id, rank:i, title:'', articleUrl:'', position:0, articleTitle:'', ct:new Date().valueOf(), imgUrl:"" });
dataList.push({id, rank:i, title:'', articleUrl:'', position:0, articleTitle:'', imgUrl:""});
}
await addManyData(TABLEENUM.专题系列, addList);
}
dataList.sort((a:any, b:any) => {return a.rank - b.rank });
dbList.forEach(info => {
let item:any = extractData(info, ["id", "title", "articleUrl", "position", "articleTitle", "imgUrl"]);
if (!item.position) item.position = "未选择";
else changeEnumValue(ARTICLEPOSITION, item.position);
dataList.push(item);
});
return {dataList};
}
/**
* 预览
*/
export async function preview({userId}) {
let dbList = await find(TABLEENUM.专题系列, {});
let dataList = [];
if ( !dbList || !dbList.length) {
let addList = [];
for (let i = 1; i <= 5; i++) {
let id = generateSystemId(TABLEENUM.专题系列, userId);
addList.push({id, rank:i, title:'', articleUrl:'', position:0, articleTitle:'', ct:new Date().valueOf(), imgUrl:"" });
dataList.push({id, rank:i, title:'', articleUrl:'', position:0, articleTitle:'', imgUrl:""});
}
await addManyData(TABLEENUM.专题系列, addList);
}
dataList.sort((a:any, b:any) => {return a.rank - b.rank });
dbList.forEach(info => {
let item = extractData(info, ["id", "title", "imgUrl"]);
dataList.push(item);
});
return {dataList};
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, title, imgUrl, position, articleTitle, articleUrl}) {
let oldInfo = await findOnce(TABLEENUM.专题系列, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.专题系列, {id}, {title, imgUrl, articleUrl, position, articleTitle});
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.专题系列, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.专题系列, {id}, {title:'', imgUrl:'', articleUrl:''});
return successResult();
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.专题系列, {id});
let dataInfo = extractData(oldInfo, ["id", "title", "imgUrl","position", "articleTitle"]);
return { dataInfo };
}
src/biz/portal/tongZhiGongGao/huiYiTongZhi.ts 0 → 100644
/**
* 会议通知
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建会议通知
* @param userId
* @param param
* @returns
*/
export async function create({userId, form}) {
form.ct = new Date().valueOf();
form.id = generateSystemId(TABLEENUM.会议通知, userId);
await addOneData(TABLEENUM.会议通知, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.会议通知, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.会议通知, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.会议通知, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.会议通知, {id});
return successResult();
}
export async function list({userId, desc}) {
let selectParam:any = {};
if (desc) selectParam.desc = {"$regex":desc}
let dbList = await find(TABLEENUM.会议通知, selectParam);
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "name", "st", "et", "addrest", "members", "push", "desc"]);
dataList.push(item);
});
dataList.sort((a, b) => {return a.rank - b.rank});
return dataList;
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.会议通知, {id});
let dataInfo = extractData(oldInfo, ["id", "name", "st", "et", "addrest", "members", "push", "desc"]);
return { dataInfo };
}
export async function changePush({id}) {
let oldInfo = await findOnce(TABLEENUM.会议通知, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.push == 1 ? 0 : 1;
await updateOneData(TABLEENUM.会议通知, {id}, {push:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/tongZhiGongGao/huoDongTongZhi.ts 0 → 100644
/**
* 活动通知
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建活动通知
* @param userId
* @param param
* @returns
*/
export async function create({userId, form}) {
form.ct = new Date().valueOf();
form.id = generateSystemId(TABLEENUM.活动通知, userId);
await addOneData(TABLEENUM.活动通知, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.活动通知, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.活动通知, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM.活动通知, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.活动通知, {id});
return successResult();
}
export async function list({userId, desc}) {
let selectParam:any = {};
if (desc) selectParam.desc = {"$regex":desc}
let dbList = await find(TABLEENUM.活动通知, selectParam);
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "name", "st", "addrest", "members", "push", "desc"]);
dataList.push(item);
});
dataList.sort((a, b) => {return a.rank - b.rank});
return dataList;
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.活动通知, {id});
let dataInfo = extractData(oldInfo, ["id", "name", "st", "addrest", "members", "push", "desc"]);
return { dataInfo };
}
export async function changePush({id}) {
let oldInfo = await findOnce(TABLEENUM.活动通知, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.push == 1 ? 0 : 1;
await updateOneData(TABLEENUM.活动通知, {id}, {push:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/tongZhiGongGao/xiangMuGongGao.ts 0 → 100644
/**
* 项目公告
*
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建项目公告
* @param userId
* @param param
* @returns
*/
export async function create({userId, form}) {
form.ct = new Date().valueOf();
form.id = generateSystemId(TABLEENUM.项目公告, userId);
await addOneData(TABLEENUM.项目公告, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update({userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.项目公告, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.项目公告, {id}, form);
return successResult();
}
export async function del({userId, id}) {
let dataInfo = await findOnce(TABLEENUM. 项目公告, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM. 项目公告, {id});
return successResult();
}
export async function list({userId, desc}) {
let selectParam:any = {};
if (desc) selectParam.desc = {"$regex":desc}
let dbList = await find(TABLEENUM. 项目公告, selectParam);
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "name", "st", "addrest", "members", "push", "desc"]);
dataList.push(item);
});
dataList.sort((a, b) => {return a.rank - b.rank});
return dataList;
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM. 项目公告, {id});
let dataInfo = extractData(oldInfo, ["id", "name", "st", "addrest", "members", "push", "desc"]);
return { dataInfo };
}
export async function changePush({id}) {
let oldInfo = await findOnce(TABLEENUM. 项目公告, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let newPush = oldInfo.push == 1 ? 0 : 1;
await updateOneData(TABLEENUM. 项目公告, {id}, {push:newPush});
return successResult();
}
\ No newline at end of file
src/biz/portal/xueHui/xueHuiGaikuo.ts 0 → 100644
/**
* 学会概括
*/
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { extractData } from "../../../util/piecemeal";
export async function info(secureArgs:any) {
let {userId} = secureArgs;
let dbInfo = await findOnce(TABLEENUM.学会概括, {});
if (!dbInfo || !dbInfo.id) {
dbInfo = JSON.parse(JSON.stringify({
id:generateSystemId(TABLEENUM.学会概括, userId),
title:'',
desc:'',
imgList:[],
ut:new Date().valueOf()
}));
await addOneData(TABLEENUM.学会概括, dbInfo);
}
let dataInfo = extractData(dbInfo, ["title", "desc", "imgList"]);
return {dataInfo};
}
/**
* 修改
* @param secureArgs
* @returns
*/
export async function update(secureArgs:any) {
let {userId, desc, title, imgList} = secureArgs;
await updateOneData(TABLEENUM.学会概括, {}, {desc, title, imgList});
return successResult();
}
src/biz/portal/xueHui/xueHuiJiaGou.ts 0 → 100644
/**
* 学会架构
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建学会架构
* @param userId
* @param param
* @returns
*/
export async function create({userId, form}) {
form.id = generateSystemId(TABLEENUM.学会架构, userId);
await addOneData(TABLEENUM.学会架构, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update( {userId, id, form}) {
let oldInfo = await findOnce(TABLEENUM.学会架构, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await updateOneData(TABLEENUM.学会架构, {id}, form);
return successResult();
}
/**
* 修改显示状态
* @param param0
* @returns
*/
export async function updateDisplay({userId, id}) {
let oldInfo = await findOnce(TABLEENUM.学会架构, {id});
if (!oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
let changeDisplay = oldInfo.display ? 0 : 1;
await updateOneData(TABLEENUM.学会架构, {id}, {display:changeDisplay});
return successResult();
}
/**
* 删除
* @param param0
* @returns
*/
export async function del( {userId, id}) {
let dataInfo = await findOnce(TABLEENUM.学会架构, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.学会架构, {id});
return successResult();
}
/**
* 列表
* @returns
*/
export async function list() {
let dbList = await find(TABLEENUM.学会架构, {});
let dataList = [];
dbList.forEach(info => {
let item:any = extractData(info, ["id", "departmentName", "desc", "display"]);
item.display = item.display == 1;
dataList.push(item);
});
return {dataList};
}
/**
* 回显
* @param id
*/
export async function info({id}) {
let oldInfo = await findOnce(TABLEENUM.学会架构, {id});
let dataInfo = extractData(oldInfo, [ "departmentName", "desc"]);
return { dataInfo };
}
src/biz/portal/xueHui/xueHuiLingDao.ts 0 → 100644
/**
* 学会领导
* 排序，后一个排序会与修改前的排序互换
*/
import { ERRORENUM } from "../../../config/errorEnum";
import { addOneData } from "../../../data/add";
import { deleteOneData } from "../../../data/delete";
import { TABLEENUM } from "../../../data/models/model";
import { find, findOnce } from "../../../data/select";
import { updateOneData } from "../../../data/update";
import { generateSystemId, successResult } from "../../../tools/system";
import { BizError } from "../../../util/bizError";
import { extractData } from "../../../util/piecemeal";
/**
* 创建学会领导
* @param userId
* @param param
* @returns
*/
export async function create(secureArgs) {
let {userId, form} = secureArgs;
let oldRankInfo = await findOnce(TABLEENUM.学会领导, {rank:form.rank});
if(oldRankInfo && oldRankInfo.id) {
/**存在原来的排名，将上一个去掉 */
await deleteOneData(TABLEENUM.学会领导, {id:oldRankInfo.id});
}
form.id = generateSystemId(TABLEENUM.学会领导, userId);
await addOneData(TABLEENUM.学会领导, form);
return successResult();
}
/**
* 修改
* @param userId
* @param id
* @param updateParam
* @returns
*/
export async function update(secureArgs:any) {
let {userId, id, form} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.学会领导, {id});
if (!oldInfo || !oldInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
if (oldInfo.rank != form.rank) {
//排名发生变化
let oldRankInfo = await findOnce(TABLEENUM.学会领导, {rank:form.rank});
if (oldRankInfo) {
await updateOneData(TABLEENUM.学会领导, {id:oldRankInfo.id}, {rank:oldInfo.rank});
}
}
await updateOneData(TABLEENUM.学会领导, {id}, form);
return successResult();
}
export async function del(secureArgs:any) {
let {userId, id} = secureArgs;
let dataInfo = await findOnce(TABLEENUM.学会领导, {id});
if (!dataInfo.id) throw new BizError(ERRORENUM.目标数据不存在);
await deleteOneData(TABLEENUM.学会领导, {id});
return successResult();
}
export async function list() {
let dbList = await find(TABLEENUM.学会领导, {});
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "rank", "name", "position", "desc"]);
dataList.push(item);
});
dataList.sort((a, b) => {return a.rank - b.rank});
return {dataList};
}
/**
* 预览
* @param id
*/
export async function preview(secureArgs:any) {
/**获取上下3位的排名列表 */
let dbList = await find(TABLEENUM.学会领导, {});
let dataList = [];
dbList.forEach(info => {
let item = extractData(info, ["id", "rank", "name", "position", "imgUrl", "miniImgUrl", "desc"]);
dataList.push(item);
});
dataList.sort((a, b) => {return a.rank - b.rank});
return {dataList};
}
/**
* 回显
* @param id
*/
export async function info(secureArgs:any) {
let {id} = secureArgs;
let oldInfo = await findOnce(TABLEENUM.学会领导, {id});
let dataInfo = extractData(oldInfo, ["id", "rank", "name", "position", "imgUrl", "miniImgUrl", "desc"]);
return { dataInfo };
}
src/config/enum.ts 0 → 100644
/**
* 图片编辑表中的type
*/
export enum IMGEDITFUNENUM {
学术研究 = 1,
}
/**
* 党建栏目类型
*/
export enum PARTYBUILDTYPEENUM {
主题教育 = 1,
学习园地,
}
/**
* 党建子栏目
*/
export enum PARTYBUILDSUBTYPEENUM {
视频资料 = 1,
文字资料
}
/**
* 动态资讯子栏目
*/
export enum DONGTAIZIXUNSUBTYPE {
政策动向 = 3,
学会动态,
行业风采
}
/**
* 资料类型
*/
export enum INFORMATIONTYPEENUM {
文件类型 = 1,
视频类型
}
/**
* 通知公告
*/
export enum TONGZHIGONGGAO {
会议通知 = 1,
活动通知,
项目公告
}
/**
* 会员类型
*/
export enum MEMBERTYPE {
个人会员 = 1,
单位会员
}
/**
* 性别
*/
export enum SEX {
男 = 1,
女,
}
/**
* 专业类别
*/
export enum PROFCATEGORY {
教育理论 = 1,
教学管理,
舞蹈,
音乐,
美术设计,
戏剧影视,
戏曲,
曲艺杂技,
舞台技术,
群众艺术,
旅游相关,
文化产业,
文化管理,
文化科技,
其他
}
/**
* 作品类型
*/
export enum TYPEOFWORKS {
作品类型1 = 1,
作品类型2,
作品类型3,
作品类型4,
作品类型5,
作品类型6
}
/**
* 内容管理banner位置
*/
export enum BANNERPOSITION {
首页_hghbanner01 = 1,
首页_hghbanner02,
首页_hghbanner03,
学会概况_hghbanner01,
学会概况_hghbanner02,
学会概况_hghbanner03,
动态资讯,
品牌项目_hghbanner01,
品牌项目_hghbanner02,
品牌项目_hghbanner03,
}
/**
* 内容管理文章位置
*/
export enum ARTICLEPOSITION {
首页_hgh学会动态 = 1,
学会概况_hgh学会规章,
动态资讯_hgh政策动向 = 3,
动态资讯_hgh学会动态,
动态资讯_hgh行业风采,
品牌项目_hgh乡村振兴,
品牌项目_hgh学术研究,
品牌项目_hgh芳华杯,
// 党建工作_hgh主题教育
}
/**
* 内容管理视频位置
*/
export enum VIDEOPOSITION {
首页_hgh热点视频 = 1,
党建工作_hgh主题教育,
党建工作_hgh工作动态,
党建工作_hgh学习交流
}
export enum YEARENUM {
_kbh2024 = 2024,
_kbh2023 = 2023,
_kbh2022 = 2022,
_kbh2021 = 2021,
_kbh2020 = 2020,
_kbh2019 = 2019,
_kbh2018 = 2018,
_kbh2017 = 2017,
_kbh2016 = 2016,
_kbh2015 = 2015,
_kbh2014 = 2014,
_kbh2013 = 2013,
_kbh2012 = 2012,
_kbh2011 = 2011,
_kbh2010 = 2010,
}
/**
* 证件类型
*/
export enum DOCUMENTTYPE {
身份证 = 1,
}
/**
* 民族
*/
export enum NATION {
汉族 = 1,
壮族,
满族,
回族,
苗族,
维吾尔族,
土家族,
彝族,
蒙古族,
藏族,
布依族,
侗族,
瑶族,
朝鲜族,
白族,
哈尼族,
哈萨克族,
黎族,
傣族,
畲族,
傈僳族,
仡佬族,
东乡族,
高山族,
拉祜族,
水族,
佤族,
纳西族,
羌族,
土族,
仫佬族,
锡伯族,
柯尔克孜族,
达斡尔族,
景颇族,
毛南族,
撒拉族,
布朗族,
塔吉克族,
阿昌族,
普米族,
鄂温克族,
怒族,
京族,
基诺族,
德昂族,
保安族,
俄罗斯族,
裕固族,
乌孜别克族,
门巴族,
鄂伦春族,
独龙族,
塔塔尔族,
赫哲族,
珞巴族
}
/**
* 参加会议成员 participant
*/
export enum CODPARTICIPANT {
会议成员1 = 1,
会议成员2,
会议成员3,
会议成员4,
会议成员5,
会议成员6,
会议成员7,
会议成员8,
会议成员9
}
/**
* 委员名单
*/
export enum COMMITTEEMEMBER {
委员1 = 1,
委员2,
委员3
}
/**
* 单位信息类型
*/
export enum UNITINFOTYPE {
类型1 = 1,
类型2,
类型3,
类型4
}
/**
* 状态
*/
export enum STATE {
否 = 0,
是 = 1
}
/**
* 下载专区分类
*/
export enum DWTYPE {
分类1 = 1,
分类2,
分类3,
分类4,
分类5,
分类6,
分类7
}
/**
* 会员状态
*/
export enum MEMBERSTATE {
正常 = 1,
异常,
冻结
}
export enum UNITMEMBERTYPE {
}
\ No newline at end of file
src/config/errorEnum.ts 0 → 100644
export enum ERRORENUM {
身份验证失败,
非法登录,
身份验证过期,
code无效,
频繁操作请稍后再试,
高风险等级用户,
系统繁忙,
请完善信息,
参数错误,
地址数据不完整,
文件上传失败,
只能上传png或jpg图片,
系统错误,
目标数据不存在,
账号或密码错误,
用户名重复,
联系人手机号重复,
邮箱重复,
两次密码不一致,
密码只能由6至18位字符和数字组成
}
export enum ERRORCODEENUM {
身份验证失败 = 401,
非法登录 = 402,
身份验证过期 = 403,
code无效 = 40029,
频繁操作请稍后再试 = 45011,
高风险等级用户 = 40226,
系统繁忙 = 40227
}
let bizErrorMsgMap = {};
for (let key in ERRORENUM) {
bizErrorMsgMap[ERRORENUM[key]] = key;
}
export function getBizMsg(param) {
return bizErrorMsgMap[param];
}
\ No newline at end of file
src/config/serverConfig.ts 0 → 100644
const path = require('path');
import * as fs from "fs";
import { BizError } from "../util/bizError";
import { analysisXml } from "../util/myXML";
import { ServerConfig } from "../config/systemClass";
const os = require('os');
export let systemConfig = new ServerConfig;
const ConfigName = "serverConfig.xml";
export async function initConfig() {
try {
let buff = fs.readFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), ConfigName));
let configStr = buff.toString();
let configInfo:any = await analysisXml(configStr);
if (!configInfo || !configInfo.config) throw new BizError('xml中无配置');
else {
let {port, mongodb, mysqldb, specifyDB } = configInfo.config;
systemConfig.port = parseInt(port[0]);
const MongoPath = mongodb[0].path[0];
const MongoPort = mongodb[0].port[0];
const MongoW = mongodb[0].w[0];
const MongoDataBase = mongodb[0].dataBase[0];
const MongoWtimeoutMS = mongodb[0].wtimeoutMS[0];
systemConfig.mongodbStr = analysisMongoConnectStr( MongoPath, MongoPort, MongoDataBase, MongoW, MongoWtimeoutMS);
if (mysqldb) {
let dbConfigInfo = mysqldb[0];
systemConfig.mysqldb = {host:'', port:0, user:'', pwd:'', dataBase:''};
if (dbConfigInfo.mysqlHost && dbConfigInfo.mysqlPort && dbConfigInfo.mysqlUser && dbConfigInfo.dataBase) {
systemConfig.mysqldb.host=dbConfigInfo.mysqlHost[0];
systemConfig.mysqldb.port=parseInt(dbConfigInfo.mysqlPort[0]);
systemConfig.mysqldb.user=dbConfigInfo.mysqlUser[0];
systemConfig.mysqldb.pwd=dbConfigInfo.mysqlPwd[0] || "";
systemConfig.mysqldb.dataBase=dbConfigInfo.dataBase[0];
}
}
if (specifyDB) {
systemConfig.specifyDB = specifyDB[0];
} else systemConfig.specifyDB = null;
}
console.log("config init success");
} catch(err) {
console.log('ERROR => 服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确');
console.log(err);
throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确");
}
}
function analysisMongoConnectStr(path, port, dataBase, w, timeOutMs) {
return `mongodb://${path}:${port}/${dataBase}?w=${w}&wtimeoutMS=${timeOutMs}`
}
export function getEnum() {
}
\ No newline at end of file
src/config/systemClass.ts 0 → 100644
/**
* 系统配置类
*
*/
export class ServerConfig {
/**系统配置 */
port:number;
mongodbStr:string;
specifyDB:string;//指定使用哪种数据库 mongo mysql all
mysqldb:{
host:string,
port:number,
user:string,
pwd:string,
dataBase:string
}
}
\ No newline at end of file
src/data/add.ts 0 → 100644
/**
* 添加数据相关操作
*/
import { dataModels } from "./models/modelInit";
export async function addOneData(tableEnumValue:string, data:object) {
await dataModels[tableEnumValue].addOneData(data);
return { isSuccess:true };
}
export async function addManyData(tableEnumValue:string, dataArray:object) {
await dataModels[tableEnumValue].addManyData(dataArray);
return { isSuccess:true };
}
\ No newline at end of file
src/data/db/db.ts 0 → 100644
import mongoose = require('mongoose');
import { initMongoModel, initMysqlModel } from '../models/modelInit';
import { ERRORENUM } from '../../config/errorEnum';
import { systemConfig } from '../../config/serverConfig';
import { BizError } from '../../util/bizError';
const Sequelize = require('sequelize');
/**
* 初始化数据库
*/
export async function initDataBaseModel() {
if (systemConfig.specifyDB == 'mongo') {
await toMongo();
} else if (systemConfig.specifyDB == 'mysql') {
await toMysql();
} else if (systemConfig.specifyDB == 'all') {
await toMongo();
await toMysql();
} else {
console.log(`this service does not use a database`);
}
}
async function toMysql() {
let {dataBase, user, pwd, host, port} = systemConfig.mysqldb;
let mysqlDB = new Sequelize(dataBase, user, pwd,{
host:host,
port:port,
dialect:'mysql', //数据库类型
pool:{ //数据库连接池
max:20, //最大连接对象的个数
min:5, //最小连接对象的个数
idle:1000 //最长等待时间，单位为毫秒
},
timezone: '+08:00', //东八时区
dialectOptions: {
dateStrings: true,
typeCast: true
},
});
await initMysqlModel(mysqlDB);
console.log(`mysql connection success, connection config:${host}:${port}/${dataBase}`);
}
async function toMongo() {
const DefaultOptions = {
useNewUrlParser:true,
auto_reconnect:true,
// reconnectTries:1000,
// reconnectInterval:3000,
keepAlive: true,
connectTimeoutMS: 3000,
useCreateIndex: true,
useUnifiedTopology: true
};
//如果配置了mongoServerConstVal 才会连接mongo
if (systemConfig.mongodbStr) {
console.log(systemConfig.mongodbStr);
let dataBase = await mongoose.createConnection(systemConfig.mongodbStr, DefaultOptions).catch(
(err)=>{
throw err
});
await initMongoModel(dataBase);
console.log(`mongodb connection success, connection config:${systemConfig.mongodbStr}`);
} else {
throw new BizError(ERRORENUM.系统错误, "xml中未配置mongo连接字符串 无法连接到mongodb");
}
}
\ No newline at end of file
src/data/delete.ts 0 → 100644
/**
* 删除
*/
import { dataModels } from "./models/modelInit";
export async function deleteManyData(tableEnumValue:string, param:object) {
await dataModels[tableEnumValue].deleteManyData(param);
return {isSuccess:true};
}
export async function deleteOneData(tableEnumValue:string, param:object) {
await dataModels[tableEnumValue].deleteOneData(param);
return {isSuccess:true};
}
\ No newline at end of file
src/data/models/modelInit.ts 0 → 100644
/**
* 模型控制器 根据配置初始化模型
*/
import mongoose = require('mongoose');
import { ModelArray, TABLESOURCEENUM } from './model';
import { ERRORENUM } from '../../config/errorEnum';
import { BizError } from '../../util/bizError';
/**
* 匹配mongo数据类型
* @param typeInfo
* @returns
*/
function checkTypeIsMongoDBType(typeInfo:any) {
const TypeList = ['String', '[String]', 'Number', '[Number]', 'Boolean'];
if (typeof typeInfo == 'string') {
return TypeList.indexOf(typeInfo) > -1;
} else if (typeof typeInfo == 'object') {
return TypeList.indexOf(typeInfo.type) > -1;
}
else throw new BizError(ERRORENUM.系统错误, `初始化 mongodb 的 model 时 ${typeInfo} 不可被系统识别`)
}
/**
* 校验mongo类型
* @param fileKey
* @param fileValue
* @returns
*/
function eccMongoFile(fileKey, fileValue:any) {
if (typeof fileValue == 'string') {
switch(fileValue) {
case 'String': return String;
case '[String]': return [String];
case 'Number': return Number;
case '[Number]': return [Number];
case 'Boolean': return Boolean;
// default: throw new BizError(ERRORENUM.系统错误, `${fileKey}字段类型为${fileValue} 解析失败`);
}
} else {
let fileInfo:any = {type:null};
if (fileValue.type) {
switch(fileValue.type) {
case 'String': fileInfo.type = String; break;
case '[String]': fileInfo.type = [String]; break;
case 'Number': fileInfo.type = Number; break;
case '[Number]': fileInfo.type = [Number]; break;
case 'Boolean': fileInfo.type = Boolean; break;
}
} else throw new BizError(ERRORENUM.系统错误, `${fileKey}字段缺失类型 解析失败`);
if (fileValue.index) fileInfo.index = true;
if (fileValue.default != null || fileValue.default != undefined) {
fileInfo.default = fileValue.default;
}
return fileInfo;
}
}
let dataModels = {};
/**
* 初始化mongodb数据库模型
* @param dataBase
*/
async function initMongoModel(myMongoDB:any) {
/**得到文档树 */
let modelListData = [];
let modelMapData = {};
ModelArray.forEach(info => {
let {tableName, source} = info;
if (source == TABLESOURCEENUM.mongo) {
modelMapData[tableName] = info;
modelListData.push(info);
}
});
let distinctMap = {};
function arrayToObject(array, parentKey) {
let modelSchema = {};
for (let i = 0; i < array.length; i++) {
let item = typeof array[i] == 'string' ? modelMapData[array[i]]: array[i];
let {tableName, schema} = item;
if (!parentKey) {
modelSchema[tableName] = {};
for (let key in schema) {
/**解析字段 */
let fileKey = key;
let fileValue = schema[fileKey];
if ( !checkTypeIsMongoDBType(fileValue) ) {//非基础数据类型
modelSchema[tableName][key] = arrayToObject([ modelMapData[fileValue] ], tableName);
distinctMap[fileValue] = 1;
} else {
modelSchema[tableName][key] = eccMongoFile(fileKey, fileValue);
}
}
} else {
for (let key in schema) {
/**解析子文档字段 */
let fileKey = key;
let fileValue = schema[fileKey];
if ( !checkTypeIsMongoDBType(fileValue) ) {//非基础数据类型
modelSchema[key] = arrayToObject([ modelMapData[fileValue] ], tableName);
distinctMap[fileValue] = 1;
} else {
modelSchema[key] = eccMongoFile(fileKey, fileValue);
}
}
}
}
return parentKey ? new mongoose.Schema(modelSchema) : modelSchema;
}
let tree = arrayToObject(modelListData, '');
for (let tableName in tree) {
if (distinctMap[tableName]) continue;
dataModels[tableName] = myMongoDB.model(tableName, tree[tableName]);
dataModels[tableName].addOneData = async function(data) {
return await dataModels[tableName].create(data);
}
dataModels[tableName].addManyData = async function(dataList) {
return await dataModels[tableName].insertMany(dataList);
}
dataModels[tableName].findCount = async function(param) {
return await dataModels[tableName].find(param).count();
}
dataModels[tableName].updateManyData = async function(param, updateInfo) {
return await dataModels[tableName].updateMany(param, {$set:updateInfo});
}
dataModels[tableName].updateOneData = async function(param, updateInfo) {
return await dataModels[tableName].updateOne(param, {$set:updateInfo});
}
dataModels[tableName].deleteManyData = async function(param) {
return await dataModels[tableName].deleteMany(param);
}
dataModels[tableName].deleteOneData = async function(param) {
return await dataModels[tableName].deleteOne(param);
}
}
console.log(`mongo database model init success`);
}
async function initMysqlModel(mysqlDB:any) {
/**初始化表 */
for (let i =0; i < ModelArray.length; i++) {
let { tableName, schema, source } = ModelArray[i];
if (source == TABLESOURCEENUM.mysql) {
let schemaConf = {
freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
timestamps:false //true表示给模型加上时间戳属性(createAt、updateAt),false表示不带时间戳属性
};
let model = mysqlDB.define( tableName, schema, schemaConf);
dataModels[tableName] = await model.sync({}).then();
}
}
/**初始化表关联 */
for (let i =0; i < ModelArray.length; i++) {
let { tableName, association }:any = ModelArray[i];
association = association || [];
association.forEach( (item:any) => {
if (item) {
let {type, check, foreignKey} = item;
if (type == "hasOne") {
dataModels[check].hasOne(dataModels[tableName]);
} else if (type == "hasMany") {
dataModels[tableName].hasMany(dataModels[check], {foreignKey});
}
dataModels[check].belongsTo(dataModels[tableName], {foreignKey});
}
});
}
console.log(`mysql database model init success`);
}
export {initMongoModel, initMysqlModel, dataModels};
\ No newline at end of file
src/data/select.ts 0 → 100644
import { dataModels } from "./models/modelInit";
export async function findToPage(tableEnumValue:string, param:object, files:object, pageNumber:number, pageSize?) {
pageSize = pageSize || 10;//默认每页10个
let data = await dataModels[tableEnumValue].find(param, files, pageNumber, pageSize);
return data;
}
export async function findCount(tableEnumValue:string, param:object) {
let data = await dataModels[tableEnumValue].findCount(param);
return data;
}
export async function findOnce(tableEnumValue:string, param:object, files?) {
let data = await dataModels[tableEnumValue].findOne(param, files);
return data;
}
export async function find(tableEnumValue:string, param, files?) {
files = files || [];
let data = await dataModels[tableEnumValue].find(param, files);
return data;
}
\ No newline at end of file
src/data/update.ts 0 → 100644
/**
* 修改
*/
import { dataModels } from "./models/modelInit";
export async function updateManyData(tableEnumValue:string, param:object, data:object) {
await dataModels[tableEnumValue].updateManyData(param, data);
return {isSuccess:true};
}
export async function updateOneData(tableEnumValue:string, param:object, data:object) {
await dataModels[tableEnumValue].updateOneData(param, data);
return {isSuccess:true};
}
\ No newline at end of file
src/main.ts 0 → 100644
import { initConfig, systemConfig} from "./config/serverConfig";
import { initDataBaseModel } from "./data/db/db";
import { httpServer } from "./net/http_server";
async function lanuch() {
/**初始化配置解析 */
await initConfig();
/**初始化数据库 */
await initDataBaseModel();
/**创建http服务 */
httpServer.createServer(systemConfig.port);
// await smsTask();
console.log('This indicates that the server is started successfully.');
}
lanuch();
\ No newline at end of file
src/middleware/fromParam.ts 0 → 100644
import { ERRORENUM } from "../config/errorEnum";
import { BizError } from "../util/bizError";
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;
if (!files.file) {
return next(new BizError(ERRORENUM.文件上传失败) )
}
if ( files.file.type == 'image/png') {
req.fileType = '.png';
next();
} else if (files.file.type == 'image/jpg' || files.file.type == 'image/jpeg') {
req.fileType = '.jpg';
next();
} else {
return next(new BizError(ERRORENUM.只能上传png或jpg图片) )
}
}
})
}
src/middleware/httpErrorHandler.ts 0 → 100644
import { bizlive } from "tencentcloud-sdk-nodejs";
import { ERRORCODEENUM } from "../config/errorEnum";
/**
* 中间件 错误返回
* @param err
* @param req
* @param res
* @param next
*/
export function httpErrorHandler(err, req, res, next) {
console.log("in httpErrorHandler");
console.log(err);
//todo 自定义错误编码
if (err) {
if ( ERRORCODEENUM[err.message] ) {
res.success({success:false, msg:err.message, code:ERRORCODEENUM[err.message]});
next();
}
else {
res.success({success:false, msg:err.message, code:500});
next();
}
}
}
\ No newline at end of file
src/middleware/user.ts 0 → 100644
import { ERRORENUM } from "../config/errorEnum";
import { TABLEENUM } from "../data/models/model";
import { findOnce } from "../data/select";
import { updateOneData } from "../data/update";
import { BizError } from "../util/bizError";
/**
* 中间件 校验孵化器token
* @param req
* @param res
* @param next
* @returns
*/
export async function checkFuHuaQiToken(req, res, next) {
if (!req.headers) req.headers = {};
const reqToken = req.headers.token;
const userId = req.headers.userid || "";
if (!reqToken || !userId ) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
let userInfo = await findOnce(TABLEENUM.用户表, {userId});
if (!userInfo || !userInfo.userId) return next(new BizError(ERRORENUM.身份验证失败));
if (userInfo.token != reqToken) return next(new BizError(ERRORENUM.身份验证过期));
let checkToken = '';
//30分钟更新token
if ( (userInfo.tokenMs - new Date().valueOf()) >= (30 * 60 * 1000) ) {
return next(new BizError(ERRORENUM.身份验证过期));
} else {
checkToken = reqToken;
await updateOneData(TABLEENUM.用户表, {userId:userInfo.userId}, { tokenMs:new Date().valueOf()});
}
req.headers.userInfo = {
userId,
isAdmin:userInfo.isAdmin
}
next();
}
/**
* 中间件 数据维护接口
* @param req
* @param res
* @param next
* @returns
*/
export async function checkInterior(req, res, next) {
if (!req.headers) req.headers = {};
const Sign = req.headers.sign;
let sysSign = 'sadfjslakdfjlksadjffujisdaiofjsajl09092302'
if (!Sign || Sign != sysSign) return next(new BizError(ERRORENUM.非法登录, `内部接口非法调用 ${Sign}`));
next();
}
\ No newline at end of file
src/middleware/watch.ts 0 → 100644
export function watch(req, res, next) {
res.success = success.bind({res:res, req:req});
return next();
}
/**
* 中间件正确返回方法
* @param data
*/
function success(data) {
let resultPack;
if (data ) {
if ( data.success === undefined || data.success === true ) {
resultPack = {data, success:true, code:200};
}
else {
resultPack = data;
}
}else {
resultPack = {code:500, success:false, msg:'result is null'};
}
this.res.send(resultPack);
}
src/net/http_server.ts 0 → 100644
import express = require('express');
import bodyParser = require('body-parser');
import routers = require('../routers/router');
import compression = require('compression');
import { watch } from '../middleware/watch';
import { httpErrorHandler } from '../middleware/httpErrorHandler';
import * as path from "path";
import * as fallback from 'express-history-api-fallback';
export class httpServer {
static createServer(port:number) {
var httpServer = express();
httpServer.all('*', (req, res, next) => {
res.header('Access-Control-Allow-Origin', req.headers.origin);
res.header("Access-Control-Allow-Headers", "X-Requested-With");
res.header('Access-Control-Allow-Headers', 'Content-Type,request-origin,userid,token');
res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
res.header('Access-Control-Allow-Credentials', true);
res.header("X-Powered-By", ' 3.2.1');
next();
// if(req.method === 'OPTIONS'){
// res.statusCode = 200;
// res.end();
// }else{
// next();
// }
});
// httpServer.use(bodyParser.json({limit:'5mb'}));
// httpServer.use(bodyParser.urlencoded({limit:'5mb', extends:true}));
httpServer.use(express.static("./static") );
httpServer.use(express.static("./files") );
const root = path.join(__dirname, "../../public");
httpServer.use(express.static(root));
httpServer.use(fallback('index.html', { root }));
httpServer.use(compression());
httpServer.use(watch);
httpServer.use(bodyParser.json({limit:"5000kb"}));
routers.setRouter(httpServer);
httpServer.use(httpErrorHandler);
httpServer.listen(port);
console.log('server listen on port:'+port);
}
}
\ No newline at end of file
src/routers/member/router.ts 0 → 100644
import * as memberBiz from "../../biz/member/user";
export const FirstName = '用户路由';
export const FirstRouter = '/manage/member';
export const Config = {
"用户注册":[
{
apiName:"个人会员注册",
subUrl:'/signin/entity',
param:[
{key:"form", type:"Object", sub:
{
loginId:{ type:'String', desc:"用户名"},
pwd:{ type:'String', desc:"密码"},
confirmation:{type:'String', desc:"确认密码"},
phone:{type:'String', desc:"电话"},
mail:{type:'String', desc:"邮件"},
name:{type:'String', desc:"真实姓名"},
sex:{type:'Number', desc:"性别"},
documentType:{type:'Number', desc:"证件类型"},
documentId:{type:'String', desc:"证件id"},
birth:{type:'Number', desc:"出生年月 时间戳"},
nation:{type:'Number', desc:"民族"},
sheng:{type:'String', desc:"省"},
shi:{type:'String', desc:"市"},
qu:{type:'String', desc:"区"},
addres:{type:'String', desc:"通信地址"},
photoUrl:{type:'String', desc:"证件照图片地址"},
workUnit:{type:'String', desc:"工作单位"},
workDuties:{type:'String', desc:"职务"},
workTitle:{type:'String', desc:"职称"},
profCategory:{type:'Number', desc:"专业类别"},
studyResume:{type:'String', desc:"学习简历"},
workResume:{type:'String', desc:"工作简历"},
profAchievement:{type:'String', desc:"专业成果"},
otherEMP:{type:'String', desc:"其他任职情况"},
otherPROF:{type:'String', desc:"其他专业情况"},
cardUrl:{type:'[String]', desc:"身份证正反面图片地址"},
academicCERTUrl:{type:'String', desc:"学历证明地址"},
professionalCERTUrl:{type:'String', desc:"工作证明"},
auxiliaryMaterial:{type:'[String]', desc:"其他辅助材料上传地址"},
},
desc:"表单"
}
],
bindBiz:memberBiz.signInOfEntity
},
{
apiName:"单位会员注册",
subUrl:'/signin/unit',
param:[
{key:"form", type:"Object", sub:
{
loginId:{ type:'String', desc:"用户名"},
pwd:{ type:'String', desc:"密码"},
confirmation:{type:'String', desc:"确认密码"},
phone:{type:'String', desc:"电话"},
mail:{type:'String', desc:"邮件"},
unitName:{type:'String', desc:"单位名称"},
officialWebsite:{type:'String', desc:"官网"},
uscc:{type:'String', desc:"统一信用代码"},
legalPerson:{type:'String', desc:"法人"},
legalPersonPhone:{type:'String', desc:"法人代表联系电话"},
gongZhongHao:{type:'String', desc:"单位公众号"},
unitPhone:{type:'Number', desc:"单位电话"},
contactPerson:{type:'String', desc:"日常联系人"},
contactPersonDuties:{type:'String', desc:"日常联系人职务"},
uusinessLicenseUrl:{type:'String', desc:"营业执照"},
personInChargeDesc:{type:'String', desc:"单位主要负责人或负责人集体描述"},
unitInfoType:{type:'Number', desc:"单位信息类型 公用接口中获取"},
yuanXiaoBanXueLeiXing:{type:'String', desc:"院校办学类型"},
yuanXiaoZhuGuanBuMen:{type:'String', desc:"院校主管部门"},
yuanXiaoFuZeRen:{type:'String', desc:"院校主要负责人"},
yuanXiaoFuZeRenZhiWu:{type:'String', desc:"院校主要负责人职务"},
yuanXiaoFuZeRenDianHua:{type:'String', desc:"院校主要负责人电话"},
yuanXiaoBanGongFuZeRen:{type:'String', desc:"院校办公负责人"},
yuanXiaoBanGongFuZeRenZhiWu:{type:'String', desc:"院校办公负责人职务"},
yuanXiaoBanGongFuZeRenDianHua:{type:'String', desc:"院校办公负责人电话"},
yuanXiaoKeYanFuZeRen:{type:'String', desc:"院校办公负责人"},
yuanXiaoKeYanFuZeRenZhiWu:{type:'String', desc:"院校办公负责人职务"},
yuanXiaoKeYanFuZeRenDianHua:{type:'String', desc:"院校办公负责人电话"},
yuanXiaoXueShengZongRenShu:{type:'String', desc:"学生总人数"},
yuanXiaoJiaoZhiGongZongRenShu:{type:'String', desc:"教职工总人数"},
yuanXiaoJianZhuMianJi:{type:'String', desc:"院校建筑面积"},
yuanXiaoGaoJiZhiCheng:{type:'String', desc:"院校职称"},
yuanXiaoKaiSheZhuanYe:{type:'String', desc:"院校开设专业数"}
},
desc:"表单"
}
],
bindBiz:memberBiz.singInOfUnit
}
],
"登陆相关":[
{
apiName:"登陆",
subUrl:'/login',
param:[
{key:"lolginId", type:"String", desc:"账号"},
{key:"pwd", type:"String", desc:"密码"}
],
bindBiz:memberBiz.login
},
{
apiName:"注销登陆",
subUrl:'/logout',
param:[
],
bindBiz:memberBiz.logout
},
]
}
\ No newline at end of file
src/routers/officalWebsite/router.ts 0 → 100644
import * as officialWebsiteBiz from "../../biz/officialWebsite";
export const FirstName = '官网路由';
export const FirstRouter = '/officialwebsite';
export const Config = {
"首页":[
{
apiName:"banner图",
subUrl:'/banner',
param:[],
bindBiz:officialWebsiteBiz.banner
},
{
apiName:"内容",
subUrl:'/homepage',
param:[],
bindBiz:officialWebsiteBiz.homePage
},
],
"学会概况":[
{
apiName:"学会概况",
subUrl:'/xuehuigaikuang',
param:[],
bindBiz:officialWebsiteBiz.xueHuiGaiKuang
},
{
apiName:"学会概况详情",
subUrl:'/xuehuigaikuangxiangqing',
param:[],
bindBiz:officialWebsiteBiz.xueHuiGaiKuangXiangQing
},
{
apiName:"学会规章列表（更多按钮触发）",
subUrl:'/xuehuiguizhang',
param:[
{key:"pageNumber", type:"Number", desc:"当前页"},
],
bindBiz:officialWebsiteBiz.guiZhangLieBiaoFenYe
},
{
apiName:"学会规则详情",
subUrl:'/xuehuiguizhangxiangqing',
param:[
{key:"id", type:"String", desc:"规章列表下发的标识"},
],
bindBiz:officialWebsiteBiz.guiZhangZhiDuXiangQing
},
],
"动态资讯":[
{
apiName:"动态资讯列表",
subUrl:'/xuehuiguizhangxiangqing',
param:[
{key:"type", type:"Number", desc:"政策动向学会动态行业风采，参考公用接口"},
{key:"pageNumber", type:"Number", desc:"当前页"},
],
bindBiz:officialWebsiteBiz.dongTaiZiXun
},
{
apiName:"文章详情",
subUrl:'/wenzhangxiangqing',
param:[
{key:"id", type:"String", desc:"动态资讯列表中的标识"},
],
bindBiz:officialWebsiteBiz.wenZhangXiangQing
}
],
"品牌项目":[
{
apiName:"品牌项目banner",
subUrl:'/pinpaixiangmubanner',
param:[],
bindBiz:officialWebsiteBiz.pinPaiXiangMuBanner
},
{
apiName:"品牌项目信息",
subUrl:'/pinpaixiangmu',
param:[],
bindBiz:officialWebsiteBiz.pinPaiXiangMu
},
{
apiName:"学术研究列表",
subUrl:'/xueshuyanjiu',
param:[
{key:"pageNumber", type:"Number", desc:"单前页"}
],
bindBiz:officialWebsiteBiz.xueshuyanjiu
},
{
apiName:"乡村振兴列表",
subUrl:'/xiangcunzhenxing',
param:[
{key:"pageNumber", type:"Number", desc:"单前页"}
],
bindBiz:officialWebsiteBiz.xiangCunZhenXing
},
],
"党建工作":[
{
apiName:"主题教育",
subUrl:'/zhutijiaoyu',
param:[],
bindBiz:officialWebsiteBiz.zhuTiJiaoYu
},
{
apiName:"学习园地",
subUrl:'/xuexiyuandi',
param:[
{key:"type", type:"Number", desc:"类型"}
],
bindBiz:officialWebsiteBiz.xueXiYuanDi
},
{
apiName:"党建资源列表",
subUrl:'/dangjianziyuan',
param:[
{key:"first", type:"Number", desc:"一级目录 参考公用接口"},
{key:"secondary", type:"Number", desc:"二级目录 参考公用接口"},
{key:"three", type:"Number", desc:"三级目录", isNull:true},
{key:"pageNumber", type:"Number", desc:"单前页"}
],
bindBiz:officialWebsiteBiz.dangJianZiYuan
},
],
"通知公告":[
{
apiName:"主题教育",
subUrl:'/tongzhigonggao',
param:[
{key:"type", type:"Number", desc:"类型 参考公用组件"},
{key:"pageNumber", type:"Number", desc:"单前页"}
],
bindBiz:officialWebsiteBiz.tongZhiGongGao
},
]
}
\ No newline at end of file
src/routers/public/router.ts 0 → 100644
import * as enumConfig from '../../config/enum';
function setEnumInterface(enumConfig) {
let dataList = [];
for (let key in enumConfig) {
let anyKey:any = key;
if (isNaN(anyKey)) {
let keyStr = key;
let value = enumConfig[key];
if(/_dou/.test(keyStr)) keyStr = keyStr.replace(/_dou/, "，");
if(/_zyh/.test(keyStr)) keyStr = keyStr.replace(/_zyh/, "“");
if(/_yyh/.test(keyStr)) keyStr = keyStr.replace(/_yyh/, "”");
if(/_dun/.test(keyStr)) keyStr = keyStr.replace(/_dun/, "、");
if(/_ju/.test(keyStr)) keyStr = keyStr.replace(/_ju/, "。");
if(/_hgh/.test(keyStr)) keyStr = keyStr.replace(/_hgh/, "-");
if(/_kbh/.test(keyStr)) keyStr = keyStr.replace(/_kbh/, "");
dataList.push({key:keyStr, value});
}
}
return {dataList};
}
export const FirstName = '公共接口';
export const FirstRouter = '/public';
export const Config = {
"下拉框数据":[
{
apiName:"性别",
subUrl:'/sex',
param:[],
bindBiz:setEnumInterface(enumConfig.SEX)
},
{
apiName:"会员类型",
subUrl:'/membertype',
param:[],
bindBiz:setEnumInterface(enumConfig.MEMBERTYPE)
},
{
apiName:"专业类别",
subUrl:'/profcategory',
param:[],
bindBiz:setEnumInterface(enumConfig.PROFCATEGORY)
},
{
apiName:"内容管理banner位置",
subUrl:'/position',
param:[],
bindBiz:setEnumInterface(enumConfig.BANNERPOSITION)
},
{
apiName:"内容管理文章位置",
subUrl:'/articleposition',
param:[],
bindBiz:setEnumInterface(enumConfig.ARTICLEPOSITION)
},
{
apiName:"内容管理视频位置",
subUrl:'/videoposition',
param:[],
bindBiz:setEnumInterface(enumConfig.VIDEOPOSITION)
},
{
apiName:"年筛选",
subUrl:'/years',
param:[],
bindBiz:setEnumInterface(enumConfig.YEARENUM)
},
{
apiName:"作品类型",
subUrl:'/typeofworks',
param:[],
bindBiz:setEnumInterface(enumConfig.TYPEOFWORKS)
},
{
apiName:"参会人员",
subUrl:'/codparticipant',
param:[],
bindBiz:setEnumInterface(enumConfig.CODPARTICIPANT)
},
{
apiName:"分委会职务",
subUrl:'/committeemember',
param:[],
bindBiz:setEnumInterface(enumConfig.COMMITTEEMEMBER)
},
{
apiName:"下载专区分类",
subUrl:'/dwtype',
param:[],
bindBiz:setEnumInterface(enumConfig.DWTYPE)
},
],
}
src/routers/router.ts 0 → 100644
/**
* 总路由入口
*
*
* */
import { ERRORENUM } from "../config/errorEnum";
import { getDoc, initDoc } from "../tools/reqResult";
import { BizError } from "../util/bizError";
import { eccFormParam, eccReqParamater } from "../util/verificationParam";
import * as portalRouter from "./portal/router";
import * as publicRouter from "./public/router";
import * as memberRouter from "./member/router";
import * as officalWebsiteRouter from "./officalWebsite/router";
import * as asyncHandler from 'express-async-handler';
const Look = true;//true更新文档
export async function setRouter(httpServer){
if (Look) {
await getDoc();
await initDoc(portalRouter.FirstName, portalRouter.Config, portalRouter.FirstRouter);//网站编辑
await initDoc(publicRouter.FirstName, publicRouter.Config, publicRouter.FirstRouter);//公用组件
await initDoc(memberRouter.FirstName, memberRouter.Config, memberRouter.FirstRouter);//用户路由
await initDoc(officalWebsiteRouter.FirstName, officalWebsiteRouter.Config, officalWebsiteRouter.FirstRouter);//官网路由
}
await analysisRouter(httpServer, portalRouter.Config, portalRouter.FirstRouter);//网站编辑
await analysisRouter(httpServer, publicRouter.Config, publicRouter.FirstRouter);//公用组件
await analysisRouter(httpServer, memberRouter.Config, memberRouter.FirstRouter);//用户路由
await analysisRouter(httpServer, officalWebsiteRouter.Config, officalWebsiteRouter.FirstRouter);//官网路由
}
async function analysisRouter(httpServer, config, firstRouter) {
for (let modelKey in config) {
config[modelKey].forEach(info => {
let {apiName, subUrl, param, bindBiz} = info;
httpServer.post(firstRouter+subUrl, asyncHandler( async (req, res) => {
let chackObjectList = [];
let checkStringMap = {};
let stringNotMustHaveKeys = [];
let funcParam:any = {};
funcParam.userId = req.headers.userId;
for (let i = 0; i < param.length; i++) {
let info:any = param[i];
let {key, type} = param[i];
if (info.isNull) stringNotMustHaveKeys.push(key);
if (type == 'Object') {
chackObjectList.push(param[i]);
checkStringMap[key] = type;
}
else checkStringMap[key] = type;
}
/**校验参数 */
if (chackObjectList.length) {
chackObjectList.forEach(item => {
if (!req.body[item.key]) throw new BizError(ERRORENUM.参数错误, `缺少参数${item.key}`);
eccFormParam(apiName, item.sub, req.body[item.key]);
funcParam[item.key] = req.body[item.key];
});
}
if (Object.keys(checkStringMap).length) {
let eccResult = eccReqParamater(apiName, checkStringMap, req.body, stringNotMustHaveKeys);
for (let key in eccResult) {
funcParam[key] = eccResult[key];
}
}
let result;
if (firstRouter == '/public') result = await bindBiz;
else result = await bindBiz(funcParam);
res.success(result);
}));
});
}
}
\ No newline at end of file
src/tools/reqResult.ts 0 → 100644
import { systemConfig } from "../config/serverConfig";
import { postForm } from "../util/request";
const Cookie = [
'sidebar_collapsed=false',
'cookie_token=6a28392e71084032f8076d24e32fc15e6dc8532d0717f8183529ce0d9a7e0df5',
'_gitlab_session=a8de022ccd772cd40a82f6e9cc11b061',
'PHPSESSID=62mlp67e45ijp450hs9f5tt9h5',
'think_language=zh-CN'
];
let headers = {
Cookie,
Accept:"application/json, text/plain, */*",
"Accept-Encoding":"gzip, deflate",
"Content-Type":['application/x-www-form-urlencoded', 'charset=UTF-8'],
"Connection":"keep-alive",
"Accept-Language":['zh-CN,zh', 'q=0.9'],
"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
Host:"123.207.147.179:2222",
Origin:"http://123.207.147.179:2222",
Referer:"http://123.207.147.179:2222/showdoc/web/"
};
const ItemId = 81;//项目id
let distinctMap = {};
export async function getDoc() {
let body = {
item_id:ItemId,
page_id: 1642
};
let result:any = await postForm('http://123.207.147.179:2222/showdoc/server/index.php?s=/api/item/info', body, headers);
result.data.menu.catalogs.forEach(info => {
let {cat_name, catalogs, cat_id} = info;//一级目录
if (!distinctMap[cat_name]) distinctMap[cat_name] = {firstId:cat_id, secondMap:{} };
catalogs.forEach(item => {
let {pages} = item;
if (!distinctMap[cat_name].secondMap[item.cat_name]) {
distinctMap[cat_name].secondMap[item.cat_name] = {secondId:item.cat_id, apiMap:{} };
}
pages.forEach(apiItem => {
let {page_title, page_id } = apiItem;
distinctMap[cat_name].secondMap[item.cat_name].apiMap[page_title] = page_id;
});
});
});
}
export async function initDoc(firstName, apiConfig, apiFirstRouter) {
let itemHeaders = Object.assign({ Accept:"application/json, text/plain, */*", "Cache-Control":"no-store, no-cache, must-revalidate, post-check=0, pre-check=0"}, headers);
/**创建一级目录 */
if (!distinctMap[firstName]) {
let addFirstParam = {
item_id:ItemId,
cat_name:firstName
};
let addFirstResult:any = await postForm('http://123.207.147.179:2222/showdoc/server/index.php?s=/api/catalog/save', addFirstParam , itemHeaders);
distinctMap[firstName] = {firstId:addFirstResult.data.cat_id, secondMap:{} };
}
for (let pKey in apiConfig) {
if (!distinctMap[firstName].secondMap[pKey]) {
/**创建二级目录 */
let addSecondParam = {
item_id:ItemId,
cat_name:pKey,
parent_cat_id:distinctMap[firstName].firstId
};
let addSecondResult:any = await postForm('http://123.207.147.179:2222/showdoc/server/index.php?s=/api/catalog/save', addSecondParam , itemHeaders);
distinctMap[firstName].secondMap[pKey] = {secondId:addSecondResult.data.cat_id, apiMap:{} };
}
let subAPIList = apiConfig[pKey];
for (let i = 0; i < subAPIList.length; i++) {
let info = subAPIList[i];
const ApiIsExistent = distinctMap[firstName].secondMap[pKey].apiMap[info.apiName];
let itemStr = `**<h4>接口描述</h4>**\n`;
itemStr += `- ${info.apiName}\n\n------\n`;
itemStr += `**<h4>接口说明</h4>**\n\n`;
itemStr += `|方式|ip|端口|URL地址|\n`;
itemStr += `|:----- |:----- |----- |-------------- |\n`;
itemStr += `|post|192.168.0.105|${systemConfig.port} |${apiFirstRouter}${info.subUrl}|\n`;
itemStr += `**<h4>接口地址</h4>**\n\n`;
itemStr += `\`http://192.168.0.105:${systemConfig.port}${apiFirstRouter}${info.subUrl}\`\n\n------\n`;
itemStr += `**<h4>请求头（headers）</h4>**\n\n`;
itemStr += `|参数名|类型|说明|\n`;
itemStr += `|:---- |:----- |----- |\n`;
itemStr += `|userid |string |用户id |\n`;
itemStr += `|token |string |登录下发的token |\n\n ------\n`;
if (!info.param || !info.param.length) {
itemStr += `**<h4>请求参数参数（body）</h4>**\n\n`;
itemStr += `· 无 \n\n ------\n`;
} else {
itemStr += `**<h4>请求参数参数（body）</h4>**\n\n`;
itemStr += `|参数名|必选|类型|说明|\n`;
itemStr += `|:----|:---|:-----|-----|\n`;
let subMap = {};
info.param.forEach(subInfo => {
let {key, type, sub, desc, isNull} = subInfo;
if (sub) {
itemStr += `|${key}|是|object| 参考 ${key}参数 |\n`;
subMap[key] = sub;
} else {
itemStr += `|${key}|${isNull == true?"否":"是"}|${type}| ${desc||''} |\n`;
}
});
itemStr += `\n------\n\n`;
for (let subMapKey in subMap) {
itemStr+=`**<h5>${subMapKey}参数</h5>**\n\n`;
itemStr += `|参数名|必选|类型|说明|\n`;
itemStr += `|:----|:---|:-----|-----|\n`;
for (let subMapItemKey in subMap[subMapKey]) {
let subMapItemValue = subMap[subMapKey][subMapItemKey];
itemStr += `|${subMapItemKey}|${subMapItemValue.notMustHave==false? '否' : '是'}|${subMapItemValue.type}| ${subMapItemValue.desc||''} |\n`;
}
itemStr += `\n\n----------------\n`;
}
}
itemStr += `**<h4>返回示例</h4>**\n`;
if (ApiIsExistent) {
let oldItemData:any = await postForm('http://123.207.147.179:2222/showdoc/server/index.php?s=/api/page/info', {page_id:ApiIsExistent} , itemHeaders);
let oldItemDataStrList = oldItemData.data.page_content.split('```');
itemStr += `\`\`\``;
let checkItemStr = oldItemDataStrList[1].replace(/&amp;/g, "");
checkItemStr = checkItemStr.replace(/&quot;/g, "");
checkItemStr = checkItemStr.replace(/&amp;/g, "");
itemStr += checkItemStr;
itemStr += `\`\`\` \n\n`;
} else {
itemStr += `\`\`\` \n`;
itemStr += ` {\n`;
itemStr += ` "code":200,//接口状态码\n`;
itemStr += ` "success":true,//响应状态\n`;
itemStr += ` "data":{//数据主体\n`;
itemStr += ` "success":true\n`;
itemStr += ` }\n`;
itemStr += ` }\n`;
itemStr += `\`\`\` \n\n`;
}
itemStr += `------\n\n`;
itemStr += `**<h4>错误码</h4>**\n\n`;
itemStr += `|code码|说明|错误原因|后续操作|\n`;
itemStr += `|:---- |:----- |:----- |----- |\n`;
itemStr += `|401 |身份验证失败 |headers中的userid错误 |强制跳转到登陆页面 |\n`;
itemStr += `|402 |非法登录 |headers中没有token或者userid |强制跳转到登陆页面 |\n`;
itemStr += `|403 |身份验证过期 |token过期 |+强制跳转到登陆页面 |\n`;
itemStr += ``;
let body = {
page_id:ApiIsExistent || 0,
item_id:ItemId,
page_title:info.apiName,
cat_id: distinctMap[firstName].secondMap[pKey].secondId,
page_content:itemStr
};
let result = await postForm('http://123.207.147.179:2222/showdoc/server/index.php?s=/api/page/save', body , itemHeaders);
console.log(`${info.apiName}文档${ApiIsExistent ? "修改 ":"创建 "}成功`);
}
}
console.log("所有接口文档已更新完毕");
}
src/tools/system.ts 0 → 100644
/**
* 系统中使用的工具
* 包括 草稿箱id生成规则
* 包括 密码加密规则
*/
import moment = require("moment");
const md5 = require("md5");
/**
* 返回编辑正确的结果
* @returns
*/
export function successResult() {
return {success:true}
}
/**
* 生成系统id
* @param tableName
* @param userId
* @returns
*/
export function generateSystemId(tableName:string, userId:string) {
return md5(`${tableName}${Math.floor(Math.random() * 10000)}${userId}${new Date().valueOf()}${Math.floor(Math.random() * 100)}`);
}
/**
* 生成token
* @param userId
* @returns
*/
export function generateToken(userId:string) {
return md5(`${userId}${Math.floor(Math.random() * 10000)}${new Date().valueOf()}${Math.floor(Math.random() * 100)}`);
}
/**
* 生成userid
*/
export function generateUserId() {
return md5(`${Math.random() * 100}${new Date().valueOf()}${Math.random() * 10000}`);
}
\ No newline at end of file
src/util/analysisExcel.ts 0 → 100644
const xlsx = require('node-xlsx');
const path = require('path');
/**
* onceSheetBecomeOfblockData 将excel文件的指定sheet解析成数据块数据
* @param fileName 文件名称
* @param sheetName 表名称
* @returns [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
*/
export function onceSheetBecomeOfblockData(fileName, sheetName) {
let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
// return sheetMap;
let thisBlockData = getBlockData(sheetMap[sheetName]);
return thisBlockData;
}
/**
* excelBecomeOfBlockData 将excel所有的sheet解析成数据块
* @param fileName 文件名称
* @returns {"sheetName1":[ {blockData:数据块(二维数组), blockTitle:"数据标题"}], ...}
*/
export function excelBecomeOfBlockData(fileName) {
let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
let result = {};
for (let sheetName in sheetMap) {
result[sheetName] = getBlockData(sheetMap[sheetName]);
}
return result;
}
/**
* planaryArrayBecomeOfBlockData 将符合excel规则的sheet二维数组转为 数据块
* @param dataList excel解出来的数据
* @returns thisBlockData 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
*/
export function planaryArrayBecomeOfBlockData(planaryArray) {
return getBlockData(planaryArray);;
}
//===
/**
* getBlockData 数据分块
* @param dataList 解析出来的excel二维数组
* @returns 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
*/
function getBlockData(dataList) {
let blockList = [];
for (let i = 0; i < 999; i++) {
let {blockData, blockTitle, notItem, delDataList} = checkBlock(dataList);
if (notItem) break;
dataList = delDataList;
if (blockTitle) blockList.push({blockData, blockTitle});
}
return blockList;
}
function getListFristNotNullItemIndex(list) { //获取起始坐标
if (!list.length) return null;
for (let i = 0; i < list.length; i++) {
if (list[i]) return i;
}
}
function getListFirstNullItemIndex(startX, list) { //获取第一个为空的坐标
if (!list.length) return null;
let checkItem = false;
let firstItemIndex = 0;
for (let i = startX; i <= list.length; i++) {
let item = list[i];
if (!checkItem && item) checkItem = true;
if (checkItem && !item) {
firstItemIndex = i;
break;
}
}
return firstItemIndex;
}
function listRegionIsNull(list, startX, endX) { //指定区间内数据是否未空
let isNull = true;
if ( !list.length ) return isNull;
for (let i = startX; i < endX; i++) {
let item = list[i];
if (item) {
isNull = false;
break;
}
}
return isNull;
}
function thisListNotItem(list) {
for (let i = 0; i < list.length; i++) {
if (list[i]) return false;
}
return true
}
function checkBlock(dataList) {
//纵向有效起始点
let startY = 0;
let startX = 0;
let isNotBlockTitle = false; //没有块标题
let isLook = false;
let endX = 0;//x轴最长结束下标 【包括下标】
let blockTitle = ''; //标题块名称
let notItem = true;
for (let i = 0; i < dataList.length; i++) {
let childList = dataList[i] || [];
if (!thisListNotItem(childList)) {
if ( !isLook ) {
let thisRoowStartX = getListFristNotNullItemIndex(childList);
let thisRoowLastItem = childList[thisRoowStartX + 1];
let LastList = dataList[i+1] || [];
// let lastRoowStartX = getListFristNotNullItemIndex(LastList);
let lastRoowHaveItem = LastList[thisRoowStartX];
if ( thisRoowLastItem || (LastList.length && lastRoowHaveItem) ) {
if (lastRoowHaveItem && thisRoowLastItem ) {
isNotBlockTitle = true; //不存在标题块
blockTitle = `${thisRoowStartX}_${i}`;
startY = i;
startX = thisRoowStartX;
}
else {
blockTitle = dataList[i][thisRoowStartX];
dataList[i][thisRoowStartX] = null;
if ( thisRoowLastItem ) { // 同行存在元素 标题在y轴上
startY = i;
startX = thisRoowStartX + 1;
} else { // 同行存在元素 标题在x轴上
startY = i + 1;
startX = thisRoowStartX;
}
}
isLook = true;
} else { //只有标题 无内容
console.log(dataList[i][thisRoowStartX]);
dataList[i][thisRoowStartX] = null;
}
} else {
//测量最大连续长度
let firstNullX = getListFirstNullItemIndex(startX, childList);
if (firstNullX) endX = Math.max(endX, firstNullX-1);
break;
}
notItem = false;
}
}
let endY = 0;//y轴连续下标 【包括下标】
let yInfoStart = false;
let yInfoEnd = false;
for (let y = startY; y < dataList.length; y++) {
//纵向找连续性
let thisRoow = dataList[y];
let regionIsNull = listRegionIsNull(thisRoow, startX, endX);
if (!regionIsNull) {
endY = y;
if (!yInfoStart) yInfoStart = true;
}
if (yInfoStart && regionIsNull) yInfoEnd = true;
if (yInfoEnd) break;
}
let blockData = [];
for (let y = startY; y <= endY; y++) {
let onceList = [];
for (let x = startX; x <= endX; x++) {
onceList.push(dataList[y][x]);
dataList[y][x] = null;
}
blockData.push(onceList);
}
return {blockData, blockTitle, delDataList:dataList,notItem};
}
//获取单个excel文件的数据
function getExcel(filePath) {
const workSheetsFromFile = xlsx.parse(filePath);
let sheetMap = {};
let sheetList = [];
for (let i = 0; i < workSheetsFromFile.length; i++) {
let sheetInfo = workSheetsFromFile[i];
sheetMap[sheetInfo.name] = sheetInfo.data;
sheetList.push(sheetInfo);
}
return {sheetMap, sheetList}
}
\ No newline at end of file
src/util/bizError.ts 0 → 100644
/**
* 异常类
* 需要和log4js共同使用
*/
import { getBizMsg } from "../config/errorEnum";
import { logError } from "./log";
export class BizError extends Error {
constructor(...msgs) {
let reqErrorMsg = '';
let logErrorMsg = '';
for (let i = 0; i <msgs.length; i++) {
if (!i) {
let msg = getBizMsg(msgs[i]);
reqErrorMsg = msg;
logErrorMsg = msg;
} else {
logErrorMsg += ` | ${msgs[i]} `;
}
}
logError(logErrorMsg);
super(reqErrorMsg);
}
}
src/util/log.ts 0 → 100644
/**
* 日志类
* 包括错误日志 普通日志
* 日志存放在根目录的logs内
*/
let log4js = require('log4js');
let path = require('path');
//log路径
export const systemLogPath = {
errorLogFile:"error",
errorLogDir:"error",
handleLogFile:"handle",
handleLogDir:"handle"
}
//日志根目录
// let baseLogPath = path.resolve(__dirname.substring(0, __dirname.indexOf("out")), 'logs');
let baseLogPath = path.resolve('./', 'logs');
let errFile = path.resolve(baseLogPath, systemLogPath.errorLogDir, systemLogPath.errorLogFile);
let handFile =path.resolve(baseLogPath, systemLogPath.handleLogDir, systemLogPath.handleLogFile);
let config = {
appenders:
{
"rule-console": {"type": "console"},
"errorLogger": {
"type": "dateFile", // 日志类型
"filename": errFile, // 输出文件名
"pattern": "yyyy-MM-dd.log", // 后缀
"alwaysIncludePattern": true, // 上面两个参数是否合并
"encoding": "utf-8", // 编码格式
"maxLogSize": 1000, // 最大存储内容
"numBackups": 3, // 当文件内容超过文件存储空间时，备份文件的数量
"path": `/${systemLogPath.errorLogDir}`
},
"handleLogger": {
"type": "dateFile",
"filename": handFile,
"pattern": "yyyy-MM-dd.log",
"alwaysIncludePattern": true,
"encoding": "utf-8",
"maxLogSize": 1000,
"numBackups": 3,
"path": `/${systemLogPath.handleLogDir}`
}
},
categories: {
"default": {"appenders": ["rule-console"], "level": "all"}, //这个配置一定要有
"errorLogger": {"appenders": ["errorLogger"], "level": "error"},
"handleLogger": {"appenders": ["handleLogger"], "level": "all"}
},
"baseLogPath": path.resolve(baseLogPath, systemLogPath.handleLogDir, systemLogPath.handleLogFile)
};
log4js.configure(config); //加载配置文件
//调用预先定义的日志名称
let errorLogger = log4js.getLogger("errorLogger");
let handleLogger = log4js.getLogger("handleLogger");
let consoleLogger = log4js.getLogger("rule-console");
//错误日志
export function logError(...errStrs) {
let str = "";
errStrs.forEach(item => {
str += item + " | ";
});
errorLogger.error(`errorInfo => ${str}`);
}
//普通日志
export function logHandle(msgStr:string) {
handleLogger.info(`logInfo => ${msgStr}`);
}
//输出日志
export function logConsole(logStr:string) {
consoleLogger.info(`logInfo => ${logStr}`);
}
src/util/myXML.ts 0 → 100644
/**
* 解析xml
*/
var xml2js = require("xml2js");
/**
*
* @param str 需要解析的xml文本
* @returns 解析好的对象
*/
export function analysisXml(str) {
return new Promise( (resolve, reject) => {
xml2js.parseString(str, (err, result) => {
if (err) return reject(err);
return resolve(result);
});
});
}
\ No newline at end of file
src/util/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 data
* @param conf
* @returns
*/
export function extractData(data, conf) {
if (!conf.length) conf = Object.keys(data);
let result = {};
conf.forEach(key => {
result[key] = data[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;
}
\ No newline at end of file
src/util/request.ts 0 → 100644
/**
* 请求工具
*/
import * as request from 'request';
import { BizError } from './bizError';
/**
* 请求接口（get）
* @param url 路由
* @param query 请求参数
* @param headers 请求头
* @returns
*/
export function get(url:string, query?, headers?) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
return new Promise((resolve, reject)=>{
let paramater:any = { url, json:true };
if (query) paramater.qs = query;
if (headers) paramater.headers = headers;
request.get(paramater, function (err, r, body) {
if (err) return reject(err);
if (r && r.statusCode != 200) return reject(new Error('httpError:'+r.statusCode));
resolve(body);
});
})
}
export function post(url, body, headers) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
let header = {"content-type": "application/json"};
return new Promise((resolve, reject)=>{
request({
url: url,
method: "POST",
json: true,
headers: Object.assign(header, headers),
body: body
}, function(error, response, body) {
if (!error && response.statusCode == 200) {
resolve(body);
}
else {
// reject(error)
}
});
})
}
export function postForm(url, body, headers) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
return new Promise((resolve, reject)=>{
request({
url: url,
method: "POST",
json: true,
form:body,
headers
}, function(error, response, res) {
if (!error) {
resolve(res);
}
else {
reject(error)
}
});
})
}
src/util/verificationEnum.ts 0 → 100644
/**
* 校验枚举工具
*
*/
import { ERRORENUM } from "../config/errorEnum";
import { BizError } from "./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} 不满足枚举范围`);
}
/**
* 将枚举值转换成对应的枚举名(key)
* @param enumConf 目标枚举
* @param value 目标值
* @returns string 返回字符串 如果传入多个枚举值，就拼接字符串
*/
export function changeEnumValue(enumConf, value:any) {
if (!value) return '';
if ( typeof value == 'number' ) {
let str = enumConf[value];
/** 特化处理 中文引号在枚举中不适用*/
if (str == "_投资__孵化_类型") {
str = str.replace("__","+");
str = str.replace("_","“");
str = str.replace("_","”");
}
if (str == "经营成本过高_场地成本或人员成本_" || str == "办公空间拓展_无合适办公空间_") {
str = str.replace("_","(");
str = str.replace("_",")");
}
if (str == "迁出孵化器_仍在张江" || str == "迁出张江_仍在浦东" || str == "迁出浦东_仍在上海") {
str = str.replace("_",",");
}
if (str == "科技金融_风险投资_" || str == "科技金融_其他_" || str == "技术专家_法律专家_") {
str = str.replace("_","(");
str = str.replace("_",")");
}
return str
}
let str = "";
value.forEach((item, index) => {
let subStr = enumConf[item];
/** 特化处理 中文引号在枚举中不适用*/
if (subStr == "_投资__孵化_类型") {
subStr = subStr.replace("__","+");
subStr = subStr.replace("_","“");
subStr = subStr.replace("_","”");
}
if (subStr == "经营成本过高_场地成本或人员成本_" || subStr == "办公空间拓展_无合适办公空间_") {
subStr = subStr.replace("_","(");
subStr = subStr.replace("_",")");
}
if (subStr == "迁出孵化器_仍在张江" || subStr == "迁出张江_仍在浦东" || subStr == "迁出浦东_仍在上海") {
subStr = subStr.replace("_",",");
}
if (subStr == "科技金融_风险投资_" || subStr == "科技金融_其他_" || subStr == "技术专家_法律专家_") {
subStr = subStr.replace("_","(");
subStr = subStr.replace("_",")");
}
str += subStr;
if (index == value.length-1) str+="";
else str += ","
});
return str;
}
\ No newline at end of file
src/util/verificationParam.ts 0 → 100644
/**
* 校验参数工具
*
*/
import { ERRORENUM } from "../config/errorEnum";
import { BizError } from "./bizError";
/**
* 通过config校验表单参数param
* 包括类型 String, Number, Boolean, [Number], [Object]
* 参数是必填
* 方法会校验表单中存在的多余字段
* @param name 被调用的方法名
* @param config 校验配置
* @param param 需要校验的参数
* @returns true 无需关注返回
*/
export function eccFormParam(name:string, keyTypeConf:object, param:object) {
/**校验多余字段 */
for (let key in param) {
if (!keyTypeConf[key]) throw new BizError(ERRORENUM.参数错误, name, `多余${key}字段`);
}
/**校验已填参数 */
for (let key in keyTypeConf ) {
let {type, notMustHave} = keyTypeConf[key];
let isError = false; //校验是否异常
let errorStr = "";//异常说明
let value = param[key];
let valueType = typeof value;
if ( value == null || value == undefined ) {
if (!notMustHave) throw new BizError(ERRORENUM.参数错误, name, `缺失${key}字段`);
} else {
switch(type) {
case 'Number':
if ( type.toLowerCase() != valueType ) {
isError = true;
} else {
if ((""+param[key]).indexOf('.') > -1) {
param[key] = parseInt(`${param[key] *1000}`)/1000;
}
}
break;
case 'String':
case 'Boolean':
if ( type.toLowerCase() != valueType ) isError = true;
break;
case '[Number]':
if ( !Array.isArray(param[key]) ) isError = true;
for (let i =0; i < param[key].length; i++) {
let item = param[key][i];
if ( typeof item != 'number' ) {
isError = true;
errorStr = `${key}应是number型数组其中下标${i}是${typeof item}`;
}
}
break;
case '[Object]':
if ( !Array.isArray(param[key]) ) isError = true;
for (let i =0; i < param[key].length; i++) {
let item = param[key][i];
if ( typeof item != 'object' ) {
isError = true;
errorStr = `${key}应是object型数组其中下标${i}是${typeof item}`;
}
}
break;
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.地址数据不完整, name, `${key} 下标 ${nullIndex} 为空 `);
}
}
if (nullIndex == -1 && !param[key][i]) {
/**按顺序第一次赋值 */
nullIndex = i;
}
}
break;
}
errorStr = isError && errorStr == "" ? `${key}应该是${type}型 而不是${valueType}`: errorStr;
if ( isError ) throw new BizError(ERRORENUM.请完善信息, name, errorStr);
}
}
return true;
}
/**
* 根据conf配置校验请求参数
* @param conf 配置
* @param param 表单
* @param skipKeys []不必填的字段
*/
export function eccReqParamater(apiName:string, conf:object, param, skipKeys?) {
skipKeys = skipKeys || [];
let skipMap = {};
skipKeys.forEach(keyName => {
skipMap[keyName] = 1;
});
/**校验多余字段 */
for (let key in param) {
if (!conf[key]) throw new BizError(ERRORENUM.参数错误, apiName,`多余${key}字段`);
}
/**校验必填和缺失字段 */
for (let key in conf) {
let confType = conf[key];
let value = param[key];
let valueType = typeof value;
if ( value == null || value == undefined ) {
if (!skipMap[key]) throw new BizError(ERRORENUM.参数错误, apiName,`缺失${key}字段`);
} else {
let isError = false;
let errorStr = "";
switch(confType) {
case 'Number':
if ( confType.toLowerCase() != valueType ) isError = true;
else {
if ((""+param[key]).indexOf('.') > -1) {
param[key] = parseInt(`${param[key] *100}`)/100;
}
}
break;
case 'String':
case 'Boolean':
if ( confType.toLowerCase() != valueType ) isError = true;
break;
case '[Number]':
if ( !Array.isArray(param[key]) ) isError = true;
for (let i =0; i < param[key].length; i++) {
let item = param[key][i];
if ( typeof item != 'number' ) {
isError = true;
errorStr = `${key}应是number型数组其中下标${i}是${typeof item}`;
}
}
break;
case '[Object]':
if ( !Array.isArray(param[key]) ) isError = true;
for (let i =0; i < param[key].length; i++) {
let item = param[key][i];
if ( typeof item != 'object' ) {
isError = true;
errorStr = `${key}应是object型数组其中下标${i}是${typeof item}`;
}
}
break;
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.地址数据不完整,apiName, `${key} 下标 ${nullIndex} 为空 `);
}
}
if (nullIndex == -1 && !param[key][i]) {
/**按顺序第一次赋值 */
nullIndex = i;
}
}
break;
}
errorStr = isError && errorStr == "" ? `${key}应该是${confType}型 而不是${valueType}`: errorStr;
if (isError) throw new BizError(ERRORENUM.参数错误, apiName, errorStr);
}
}
return param;
}
\ No newline at end of file
tsconfig.json 0 → 100644
{
"compilerOptions": {
"module": "commonjs",
"target": "es2017",
"sourceMap": true,
"rootDir":"./src",
"outDir":"./out"
},
"exclude": [
"node_modules"
]
}
\ No newline at end of file
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