Skip to content

S
saspAdminServer
Commit b8e90c2a by chenjinjing
Options

版本V1

parent 49e7d4d5
Showing with 9714 additions and 0 deletions
serverConfig.xml 0 → 100644
<config>
<port>7071</port>
<excelModelUrl>http://192.168.0.71:7071/template/</excelModelUrl>
<mongodb>
<path>192.168.0.105</path>
<port>27017</port>
<w>1</w>
<!-- <dataBase>baseDB</dataBase> -->
<dataBase>sasp</dataBase>
<wtimeoutMS>30000</wtimeoutMS>
</mongodb>
<!-- 小程序的secret 和 appid -->
<!-- <secret>5907d55efdd2f6b3e11e719b8d781111</secret>
<appId>wxbfc5695971b3e395</appId> -->
<!-- 获取小程序的openId地址 -->
<!-- <getOpenIdUrl>https://api.weixin.qq.com/sns/jscode2session</getOpenIdUrl> -->
<!-- 短信相关配置 -->
<!-- <sms>
<sdkAppId>1400799515</sdkAppId>
<appKey>a36634bd106ee72eeea4a4bb4e62a03b</appKey>
<smsSign>张江科创服务中心</smsSign>
修改密码的模板id
<changePwd>1729284</changePwd>
填报提示
<pointOut>1729286</pointOut>
初始化账号提示
<initPointOut>1729288</initPointOut>
</sms> -->
<!-- <baidumap>KI1jEpifrEQtgr7ZJ2zAOKlUw1tme7Eb</baidumap> -->
<!-- <baidumap>QCxLry4y9BjIDRDIsGAerkcHrnrbo55I</baidumap> 夏-->
<baidumap>yvr5gS5rGO6tFfq3gERdRfzTRsguXG9T</baidumap>
<qcc>
<key>2b14555ce89346e8b96684e2e2a1c7c2</key>
<SecretKey>452AAE887A1CDCAB8C9D730BA8B8FBF0</SecretKey>
</qcc>
</config>
src/biz/activity.ts 0 → 100644
/**
* 园区活动
*/
import * as verificationEnumTools from "../util/verificationEnum";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as activityData from "../data/activity";
import { checkChange, extractData } from "../util/piecemeal";
import * as splitResultConfig from '../config/splitResultConfig';
import { eccFormParam } from "../util/verificationParam";
import { ActivityAddConfig, ActivityUpdateConfig } from "../config/eccParam/admin";
import { randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
/**
* 园区活动-列表
* @param title 活动标题
* @param startTime 活动开始时间
* @param endTime 活动结束时间
* @param target 活动类型
* @param state 活动状态 未开始、活动中、已结束
* @param page 页
*/
export async function activityList(title:string, startTime:number, endTime:number, target, state:number, page:number) {
let selectParam:any = {};
if (title) {
selectParam.title = {"$regex":`${title}`};
}
if (startTime && endTime) {
selectParam.startTime = { "$gte": startTime };
selectParam.endTime = { "$lte": endTime };
}
if (target) {
verificationEnumTools.eccEnumValue('管理后台获取园区活动列表', 'target', configEnum.ACTIVITYTARGET, target);
selectParam.target = {"$in":target};
}
if (state) {
verificationEnumTools.eccEnumValue('管理后台获取园区活动列表', 'state', configEnum.ACTIVITYSTATE, state);
selectParam.state = state;
}
/**需要用到的查询数据 */
let activityDbList = await activityData.findActivityListToPage(selectParam, (page - 1) * 10);
let count = await activityData.findActivityCount(selectParam);//符合查询条件的数据总数
/**组合返回结果 */
let dataList = [];
activityDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.activityListConfig, info, true);
/**将枚举值转为字符 */
let target = [];
changeData.target.forEach( info => {
target.push(verificationEnumTools.changeEnumValue(configEnum.ACTIVITYTARGET, info))
})
changeData.target = target;
changeData.state = verificationEnumTools.changeEnumValue(configEnum.ACTIVITYSTATE, changeData.state);
dataList.push(changeData);
})
return {count, dataList};
}
/**
* 园区活动-新增
* @param uscc
* @param param
*/
export async function activityCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增园区活动企业", ActivityAddConfig, param);
/**校验枚举 */
if (param.target && param.target.length > 0) {
verificationEnumTools.eccEnumValue('管理后台新增园区活动', 'target', configEnum.ACTIVITYTARGET, param.target);
}
verificationEnumTools.eccEnumValue('管理后台新增园区活动', 'state', configEnum.ACTIVITYSTATE, param.state);
let enterpriseInfo = await activityData.findActivityByParam({title:param.title});
if (enterpriseInfo && enterpriseInfo.title) throw new BizError(ERRORENUM.该活动已存在, `${param.title}已经在库中存在`);
let activityInfo = {
id: randomId(TABLEID.活动),
title: param.title,
state: param.state,
startTime: param.startTime,
endTime: param.endTime,
target: param.target,
location: param.location,
desc:param.desc,
}
await activityData.createDataByParam(activityInfo);
return {isSuccess:true};
}
/**
* 园区活动-回显
* @param uscc
*/
export async function activityInfo(id:string) {
/**校验企业 */
let activityDbInfo = await activityData.findActivityByParam({id});
if (!activityDbInfo || !activityDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个活动`);
let dataInfo = {
title: activityDbInfo.title,
state: activityDbInfo.state,
startTime: activityDbInfo.startTime,
endTime: activityDbInfo.endTime,
target: activityDbInfo.target,
location: activityDbInfo.location,
desc: activityDbInfo.desc,
};
return {dataInfo};
}
/**
* 园区活动-修改
* @param uscc
* @param param
*/
export async function activityUpdate(id:string, param) {
/**校验参数 */
eccFormParam("管理后台修改园区活动企业", ActivityUpdateConfig, param);
/**校验枚举 */
if (param.target && param.target.length > 0) {
verificationEnumTools.eccEnumValue('管理后台新增园区活动', 'target', configEnum.ACTIVITYTARGET, param.target);
}
verificationEnumTools.eccEnumValue('管理后台新增园区活动', 'state', configEnum.ACTIVITYSTATE, param.state);
/**校验企业 */
let activityDbInfo = await activityData.findActivityByParam({id});
if (!activityDbInfo || !activityDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个活动`);
/**修改字段 */
let changeList = checkChange(param, activityDbInfo);
if (!changeList.length) throw new BizError(ERRORENUM.数据无更新, `${param.name}数据无更新`);
changeList.forEach(key => {
activityDbInfo[key] = param[key];
});
await activityDbInfo.save();
return {isSuccess:true};
}
/**
* 园区活动-删除
* @param id
*/
export async function activityDelete(id:string) {
let activityDbInfo = await activityData.findActivityByParam({id});
if (!activityDbInfo || !activityDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个活动`);
await activityData.removeOneData(id);
return {isSuccess:true};
}
/**
* 导出园区活动信息列表
* @param title 活动标题
* @param startTime 活动开始时间
* @param endTime 活动结束时间
* @param target 活动类型
* @param state 活动状态
* @returns 二维数组，第一行为表头，后续行为数据
*/
export async function outPutActivityData(title: string, startTime: number, endTime: number, target: number[], state: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (title) {
selectParam.title = { "$regex": `${title}` };
}
if (startTime && endTime) {
selectParam.startTime = { "$gte": startTime };
selectParam.endTime = { "$lte": endTime };
} else if (startTime) {
selectParam.startTime = { "$gte": startTime };
} else if (endTime) {
selectParam.endTime = { "$lte": endTime };
}
if (target && target.length > 0) {
selectParam.target = { "$in": target };
}
if (state) {
selectParam.state = state;
}
/** 查询园区活动数据 */
let activityDbList = await activityData.findActivityListByParam(selectParam);
/** 表头定义 */
const titleList = [
"活动标题",
"活动状态",
"开始时间",
"结束时间",
"活动类型",
"活动地点",
"活动描述"
];
let dataList = [titleList]; // 第一行为表头
activityDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.activityListConfig, info, true);
/** 枚举值转文本 */
// 活动类型（多选）
let targetTexts = [];
if (changeData.target && changeData.target.length > 0) {
changeData.target.forEach(targetId => {
const targetText = verificationEnumTools.changeEnumValue(configEnum.ACTIVITYTARGET, targetId);
if (targetText) {
targetTexts.push(targetText);
}
});
}
changeData.target = targetTexts.join("、") || "未选择";
// 活动状态
changeData.state = verificationEnumTools.changeEnumValue(configEnum.ACTIVITYSTATE, changeData.state) || "未选择";
/** 时间格式化 */
changeData.startTime = changeData.startTime ? formatDateTime(changeData.startTime) : "-";
changeData.endTime = changeData.endTime ? formatDateTime(changeData.endTime) : "-";
/** 处理活动描述（过长时截取） */
if (changeData.desc && changeData.desc.length > 100) {
changeData.desc = changeData.desc.substring(0, 100) + "...";
}
/** 生成一行数据 */
let row = [
changeData.title || "-",
changeData.state,
changeData.startTime,
changeData.endTime,
changeData.target,
changeData.location || "-",
changeData.desc || "-"
];
dataList.push(row);
});
return dataList;
}
/**
* 时间格式化辅助函数
* @param timestamp 时间戳
* @returns 格式化后的时间字符串
*/
function formatDateTime(timestamp: number): string {
const date = new Date(timestamp);
const year = date.getFullYear();
const month = (date.getMonth() + 1).toString().padStart(2, '0');
const day = date.getDate().toString().padStart(2, '0');
const hours = date.getHours().toString().padStart(2, '0');
const minutes = date.getMinutes().toString().padStart(2, '0');
return `${year}-${month}-${day} ${hours}:${minutes}`;
}
src/biz/adminuser.ts 0 → 100644
/**
* 管理后台管理员用户
*/
import { AdminUserAddConfig } from "../config/eccParam/admin";
import { eccFormParam } from "../util/verificationParam";
import * as adminuserData from "../data/adminuser";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
import { getPwdMd5, getToken } from "../tools/system";
import * as enterpriseData from "../data/enterprise";
import { ENTERPRISESYSTEMLABEL, PROPERTY } from "../config/enum/labelEnum";
import moment from "moment";
import { findTrackListByParam } from "../data/track";
import { TRACKTYPE } from "../config/enum";
import { changeEnumValue } from "../util/verificationEnum";
import * as labelEnum from "../config/enum/labelEnum";
let md5 = require("md5");
/**
* 登录
* @param loginId 登录账号
* @param pwd 密码
*/
export async function login(loginId:string, pwd:string) {
let userInfo = await adminuserData.findAdminuserByLoginId(loginId);
if (!userInfo || !userInfo.loginId) throw new BizError(ERRORENUM.未找到数据, `库中不存在loginId=${loginId}这个账号`);
let checkPwd = getPwdMd5(loginId, md5(pwd));
if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
let token = getToken(loginId);
let resultUserInfo = {
loginId: userInfo.loginId,
name: userInfo.name,
token,
};
userInfo.token = token;
userInfo.tokenMs = new Date().valueOf();
await userInfo.save();
return resultUserInfo;
}
/**
* 管理后台管理员用户-新增
* @param uscc
* @param param
*/
export async function adminUserCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增管理员用户", AdminUserAddConfig, param);
let adminuserDbInfo = await adminuserData.findAdminuserByParam({loginId:param.loginId});
if (adminuserDbInfo && adminuserDbInfo.loginId) throw new BizError(ERRORENUM.该账号已存在, `${param.loginId}已经在库中存在`);
let pwd = getPwdMd5(param.loginId, md5(param.pwd));
let adminuserInfo = {
loginId: param.loginId,
name: param.name,
pwd,
}
await adminuserData.createAdminuserByParam(adminuserInfo);
return {isSuccess:true};
}
/**
* 数据看板
*/
// export async function homePage() {
// let baseData = {
// "企业总数":0,
// "100平方公里范围企业":0,
// "3.73平方公里实体租赁":0,
// "关联入驻企业":0,
// "小台账企业":0,
// "重点稳商":0,
// /**上月 */
// "上月100平方公里范围企业":0,
// "上月3.73平方公里实体租赁":0,
// "上月关联入驻企业":0,
// "上月小台账企业":0,
// "上月重点稳商":0,
// };
// /** 查询企业数据 */
// let enterpriseDbList = await enterpriseData.findEnterpriseListByParam({});
// baseData.企业总数 = enterpriseDbList.length;
// enterpriseDbList.forEach( info => {
// let labels = info.labels;
// labels.forEach( info => {
// let {labelId, labelType, state} = info;
// if (state) {
// if (labelId == ENTERPRISESYSTEMLABEL["100平方公里"]) baseData["100平方公里范围企业"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL["3.73平方公里"]) baseData["3.73平方公里实体租赁"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL.软件关联入驻企业) baseData["关联入驻企业"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL.小台账企业) baseData["小台账企业"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL.重点稳商企业) baseData["重点稳商"] += 1;
// }
// })
// })
// /**上月 */
// /** 获取上月时间范围 */
// let now = moment();
// let lastMonthStart = moment().subtract(1, 'month').startOf('month').valueOf();
// let lastMonthEnd = moment().subtract(1, 'month').endOf('month').valueOf();
// /** 查询上月入驻的企业数据 */
// let enterpriseLastMonthDbList = await enterpriseData.findEnterpriseListByParam({
// parkEntryTime: {
// $gte: lastMonthStart,
// $lte: lastMonthEnd
// }
// });
// // 统计上月数据
// enterpriseLastMonthDbList.forEach(info => {
// let labels = info.labels;
// labels.forEach(label => {
// let {labelId, labelType, state} = label;
// if (state) {
// if (labelId == ENTERPRISESYSTEMLABEL["100平方公里"]) baseData["上月100平方公里范围企业"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL["3.73平方公里"]) baseData["上月3.73平方公里实体租赁"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL.软件关联入驻企业) baseData["上月关联入驻企业"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL.小台账企业) baseData["上月小台账企业"] += 1;
// if (labelId == ENTERPRISESYSTEMLABEL.重点稳商企业) baseData["上月重点稳商"] += 1;
// }
// });
// });
// return baseData;
// }
export async function homePage() {
/**汇总数据 */
let 汇总数据 = {
"企业总数": 0,
"100平方公里范围企业": 0,
"3.73平方公里实体租赁": 0,
"关联入驻企业": 0,
"小台账企业": 0,
"重点稳商": 0,
/**较上月变化量 */
"较上月100平方公里范围企业变化": 0,
"较上月3.73平方公里实体租赁变化": 0,
"较上月关联入驻企业变化": 0,
"较上月小台账企业变化": 0,
"较上月重点稳商变化": 0,
"较上月总入驻企业变化": 0
};
/** 获取时间范围 */
let lastMonthStart = moment().subtract(1, 'month').startOf('month').valueOf();
let lastMonthEnd = moment().subtract(1, 'month').endOf('month').valueOf();
/** 初始企业数据没有入驻时间处理：设置默认入驻时间：2025年12月 */
let defaultParkEntryTime = moment('2025-12-01').startOf('month').valueOf();
/** 查询所有企业数据 */
let enterpriseDbList = await enterpriseData.findEnterpriseListByParam({});
/** 统计当前所有企业数据 */
汇总数据.企业总数 = enterpriseDbList.length;
// 分别统计当前所有企业和上月企业
let currentMonthStats = {
"企业总数": 0,
"100平方公里范围企业": 0,
"3.73平方公里实体租赁": 0,
"关联入驻企业": 0,
"小台账企业": 0,
"重点稳商": 0,
"总入驻企业": 0
};
let lastMonthStats = {
"企业总数": 0,
"100平方公里范围企业": 0,
"3.73平方公里实体租赁": 0,
"关联入驻企业": 0,
"小台账企业": 0,
"重点稳商": 0,
"总入驻企业": 0
};
// 遍历所有企业进行统计
enterpriseDbList.forEach(info => {
// 处理入驻时间：如果为空则使用默认时间
let parkEntryTime = info.parkEntryTime || defaultParkEntryTime;
// 统计当前所有企业的标签
info.labels.forEach(label => {
let {labelId, state} = label;
if (state === false) return; //跳过失效标签
switch(parseInt(labelId)) {
case ENTERPRISESYSTEMLABEL["100平方公里"]:
currentMonthStats["100平方公里范围企业"] += 1;
break;
case ENTERPRISESYSTEMLABEL["3.73平方公里"]:
currentMonthStats["3.73平方公里实体租赁"] += 1;
break;
case ENTERPRISESYSTEMLABEL.软件关联入驻企业:
currentMonthStats["关联入驻企业"] += 1;
break;
case ENTERPRISESYSTEMLABEL.小台账企业:
currentMonthStats["小台账企业"] += 1;
break;
case ENTERPRISESYSTEMLABEL.重点稳商企业:
currentMonthStats["重点稳商"] += 1;
break;
}
});
// 判断是否是上月入驻的企业
if (parkEntryTime >= lastMonthStart && parkEntryTime <= lastMonthEnd) {
lastMonthStats["总入驻企业"] += 1;
// 统计上月企业的标签
info.labels.forEach(label => {
let {labelId, state} = label;
if (!state) return;
switch(parseInt(labelId)) {
case ENTERPRISESYSTEMLABEL["100平方公里"]:
lastMonthStats["100平方公里范围企业"] += 1;
break;
case ENTERPRISESYSTEMLABEL["3.73平方公里"]:
lastMonthStats["3.73平方公里实体租赁"] += 1;
break;
case ENTERPRISESYSTEMLABEL.软件关联入驻企业:
lastMonthStats["关联入驻企业"] += 1;
break;
case ENTERPRISESYSTEMLABEL.小台账企业:
lastMonthStats["小台账企业"] += 1;
break;
case ENTERPRISESYSTEMLABEL.重点稳商企业:
lastMonthStats["重点稳商"] += 1;
break;
}
});
}
});
// 设置当前所有企业数量到汇总数据
汇总数据["100平方公里范围企业"] = currentMonthStats["100平方公里范围企业"];
汇总数据["3.73平方公里实体租赁"] = currentMonthStats["3.73平方公里实体租赁"];
汇总数据["关联入驻企业"] = currentMonthStats["关联入驻企业"];
汇总数据["小台账企业"] = currentMonthStats["小台账企业"];
汇总数据["重点稳商"] = currentMonthStats["重点稳商"];
// 计算变化量（本月数据 - 上月数据）
汇总数据.较上月100平方公里范围企业变化 = currentMonthStats["100平方公里范围企业"] - lastMonthStats["100平方公里范围企业"];
汇总数据["较上月3.73平方公里实体租赁变化"] = currentMonthStats["3.73平方公里实体租赁"] - lastMonthStats["3.73平方公里实体租赁"];
汇总数据.较上月关联入驻企业变化 = currentMonthStats["关联入驻企业"] - lastMonthStats["关联入驻企业"];
汇总数据.较上月小台账企业变化 = currentMonthStats["小台账企业"] - lastMonthStats["小台账企业"];
汇总数据.较上月重点稳商变化 = currentMonthStats["重点稳商"] - lastMonthStats["重点稳商"];
汇总数据.较上月总入驻企业变化 = currentMonthStats["总入驻企业"] - lastMonthStats["总入驻企业"];
/**企业服务追踪 */
let 企业服务追踪 = {
企业需求总数:0,
已解决企业需求:0,
待解决需求数:0
};
/** 查询服务追踪数据 */
let trackDbList = await findTrackListByParam({});
企业服务追踪.企业需求总数 = trackDbList.length;
trackDbList.forEach( info => {
if (info.trackType == TRACKTYPE.已解决) 企业服务追踪.已解决企业需求 += 1;
if (info.trackType == TRACKTYPE.未解决) 企业服务追踪.待解决需求数 += 1;
})
/**实体租赁企业场地分布 */
let 实体租赁企业场地分布 = [];
// 定义物业列表（按你的需求顺序）
let propertyList = [
{ id: PROPERTY.于田大厦, name: "于田大厦" },
{ id: PROPERTY.汽车创新港, name: "汽车创新港" },
{ id: PROPERTY.汽车城大厦, name: "汽车城大厦" },
{ id: PROPERTY.嘉亭荟, name: "嘉亭荟" },
{ id: PROPERTY.智驾园, name: "智驾园" },
{ id: PROPERTY.同济科技园, name: "同济科技园" }
];
// 初始化统计数组
propertyList.forEach(property => {
实体租赁企业场地分布.push({
key: property.name,
value: 0
});
});
// 遍历所有企业，筛选实体型企业并按物业统计
enterpriseDbList.forEach(info => {
// 判断是否为实体型企业（ENTERPRISENATURE.实体型 = 6）
if (info.enterpriseNature === 6) {
let propertyValue = info.property;
// 转换为数字类型以确保类型匹配
let propertyValueNum = Number(propertyValue);
// 找到对应的物业并计数
let propertyIndex = propertyList.findIndex(p => p.id === propertyValueNum);
if (propertyIndex !== -1) {
实体租赁企业场地分布[propertyIndex].value += 1;
}
}
});
return {汇总数据, 企业服务追踪, 实体租赁企业场地分布};
}
src/biz/enterprise.ts 0 → 100644
/**
* 基础企业库
*/
import * as verificationEnumTools from "../util/verificationEnum";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as labelEnum from "../config/enum/labelEnum";
import * as enterpriseData from "../data/enterprise";
import { checkChange, extractData } from "../util/piecemeal";
import * as splitResultConfig from '../config/splitResultConfig';
import { eccFormParam } from "../util/verificationParam";
import { EnterpriseAddConfig, EnterpriseUpdateConfig, NegotiationAddConfig, NegotiationUpdateConfig } from "../config/eccParam/admin";
import { randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
import * as sysTools from "../tools/system";
import * as labelData from "../data/label";
import { generateEnterpriseLabels, uniqueLabelList } from '../util/labelUtils';
import moment from "moment";
let md5 = require("md5");
/**
* 企业库-获取所有企业uscc
* @param uscc
*/
export async function enterpriseUsccList() {
let enterpriseDbList = await enterpriseData.findEnterpriseListByParam({isSettled: configEnum.STATE.是});
/**组合返回结果 */
let dataList = [];
enterpriseDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.enterpriseUsccListConfig, info, true);
dataList.push(changeData);
})
return dataList;
}
/**
* 企业建档-新增
* @param param
*/
export async function enterpriseCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增企业建档", EnterpriseAddConfig, param);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'industry', industryEnum.ALLINDUSTRY, param.industry);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'enterpriseNature', labelEnum.ENTERPRISENATURE, param.enterpriseNature);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'property', labelEnum.PROPERTY, param.property);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'RAS', configEnum.RAS, param.RAS);
/**校验标签 */
if (param.labels && param.labels.length > 0) {
for (let i = 0; i < param.labels.length; i++) {
let labelDbInfo = await labelData.findOnceLabel(param.labels[i]);
if (!labelDbInfo && !labelDbInfo.id) throw new BizError(ERRORENUM.该标签不存在, `${param.labels[i]}在库中不存在`);
}
}
if (!sysTools.eccUscc(param.uscc)) throw new BizError(ERRORENUM.统一社会信用代码不合法);
let now = new Date().valueOf();
if (param.logonTime > now) throw new BizError(ERRORENUM.不可选择未来时间);
if (param.parkEntryTime > now) throw new BizError(ERRORENUM.不可选择未来时间);
/**不能出现重复的统一社会信用代码 */
let enterpriseDbInfo = await enterpriseData.findEnterpriseByUscc(param.uscc);
if (enterpriseDbInfo && enterpriseDbInfo.uscc) throw new BizError(ERRORENUM.该企业已存在, `${param.uscc}已经在库中存在`);
// 1. 获取所有可用的标签
const activeLabels = await labelData.selectLabelList({ state: false });
// 2. 生成企业标签数组
const labels = await generateEnterpriseLabels(param, activeLabels);
// 3. 准备企业数据
let enterpriseInfo = {
id: randomId(TABLEID.企业基础信息表),
name: param.name,
uscc: param.uscc,
logonAddress: param.logonAddress,
logonTime: param.logonTime,
parkEntryTime: param.parkEntryTime,
// industryCategoryGb: param.industryCategoryGb,
industry: param.industry,
property: param.property,
enterpriseNature: param.enterpriseNature,
leasedArea: param.leasedArea,
RAS: param.RAS,
jingYingFanWei: param.jingYingFanWei,
legalPerson: param.legalPerson,
zhuceziben: param.zhuceziben,
dianHua: param.dianHua,
createTime: new Date().valueOf(),
labels: labels,
pwd: sysTools.getPwdMd5(param.uscc, md5(param.uscc.slice(param.uscc.length-6))),
firstLoginIsChangePwd:false,
};
// 4. 保存企业数据
await enterpriseData.createDataByParam(enterpriseInfo);
return { isSuccess: true };
}
/**
* 企业库-列表
* @param dataType 不传=所有企业、1=100平方公里、2=3.73平方公里、3=软件关联入驻企业、4=小台账企业、5=重点稳商企业
* @param name 企业名称
* @param industry 行业领域
* @param parkEntryTime 入驻年份
* @param logonTime 企业成立年份
* @param labelIdList 企业标签 可多选
* @param page 页
*/
export async function enterpriseList(dataType:number, name:string, industry, parkEntryTime:number, logonTime:number, labelIdList, page:number) {
let selectParam:any = {};
if (name) {
selectParam.name = {"$regex":`${name}`};
}
if (industry && industry.length > 0) {
verificationEnumTools.eccEnumValue('管理后台获取在谈在跟列表', 'industry', industryEnum.ALLINDUSTRY, industry);
selectParam.industry = {"$in":industry};
}
if (parkEntryTime) {
let parkEntryStartTime = moment(`${parkEntryTime}-01-01`);
let parkEntryEndTime = moment(`${parkEntryTime}-12-31`);
selectParam.parkEntryTime = {"$gt":parkEntryStartTime, "$lt":parkEntryEndTime};
}
if (logonTime) {
let logonStartTime = moment(`${logonTime}-01-01`);
let logonEndTime = moment(`${logonTime}-12-31`);
selectParam.logonTime = {"$gt":logonStartTime, "$lt":logonEndTime};
}
//企业库列表分类
let allLabelList = [];
if (dataType) {
if (dataType == labelEnum.BASELABEL["100平方公里"]) allLabelList.push(labelEnum.BASELABEL["100平方公里"].toString());
else if (dataType == labelEnum.BASELABEL["3.73平方公里"]) allLabelList.push(labelEnum.BASELABEL["3.73平方公里"].toString());
else if (dataType == labelEnum.BASELABEL.小台账企业) allLabelList.push(labelEnum.BASELABEL.小台账企业.toString());
else if (dataType == labelEnum.BASELABEL.软件关联入驻企业) allLabelList.push(labelEnum.BASELABEL.软件关联入驻企业.toString());
else if (dataType == labelEnum.BASELABEL.重点稳商企业) allLabelList.push(labelEnum.BASELABEL.重点稳商企业.toString());
}
//标签筛选
if (labelIdList && labelIdList.length > 0) {
labelIdList.forEach( info => {
allLabelList.push(info.toString());
})
}
if (dataType || labelIdList && labelIdList.length > 0) {
let uniqueLabels = uniqueLabelList(allLabelList);
selectParam.labels = {"$elemMatch":{labelId:{"$in":uniqueLabels} } }
}
/**需要用到的查询数据 */
let enterpriseDbList = await enterpriseData.findEnterpriseListToPage(selectParam, (page - 1) * 10);
let count = await enterpriseData.findEnterpriseCount(selectParam);//符合查询条件的数据总数
/**组合返回结果 */
let dataList = [];
enterpriseDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.enterpriseListConfig, info, true);
/**将枚举值转为字符 */
let industry = [];
if (changeData.industry && changeData.industry.length > 0) {
industry.push(verificationEnumTools.changeEnumValue(industryEnum.ALLINDUSTRY, changeData.industry))
}
changeData.industry = industry;
let labels = [];
if (changeData.labels && changeData.labels.length > 0) {
changeData.labels.forEach( info => {
let {labelId, state} = info;
labels.push(verificationEnumTools.changeEnumValue(labelEnum.ENTERPRISESYSTEMLABEL, parseInt(labelId)))
})
}
changeData.labels = labels;
changeData.property = verificationEnumTools.changeEnumValue(labelEnum.PROPERTY, changeData.property);
changeData.enterpriseNature = verificationEnumTools.changeEnumValue(labelEnum.ENTERPRISENATURE, changeData.enterpriseNature)
changeData.RAS = verificationEnumTools.changeEnumValue(configEnum.RAS, changeData.RAS);
dataList.push(changeData);
})
return {count, dataList};
}
/**
* 企业库-回显
* @param uscc
*/
export async function enterpriseInfo(uscc:string) {
let enterpriseDbInfo = await enterpriseData.findEnterpriseByUscc(uscc);
if (!enterpriseDbInfo || !enterpriseDbInfo.uscc) throw new BizError(ERRORENUM.该企业不存在, `库中不存在uscc=${uscc}这个企业`);
/**标签转换 */
let labels = [];
if (enterpriseDbInfo.labels && enterpriseDbInfo.labels.length > 0) {
enterpriseDbInfo.labels.forEach( info => {
let {labelId, state} = info;
labels.push(labelId)
// labels.push(verificationEnumTools.changeEnumValue(labelEnum.ENTERPRISESYSTEMLABEL, parseInt(labelId)))
})
}
let dataInfo = {
name: enterpriseDbInfo.name, //企业名称
uscc: enterpriseDbInfo.uscc, //统一信用代码
logonAddress: enterpriseDbInfo.logonAddress, //企业注册地址
logonTime: enterpriseDbInfo.logonTime, //moment(enterpriseDbInfo.logonTime).format("YYYY-MM-DD"), //注册时间、成立时间
parkEntryTime: enterpriseDbInfo.parkEntryTime, //moment(enterpriseDbInfo.parkEntryTime).format("YYYY-MM-DD"), //入驻园区时间
labels: labels, //企业标签
industry: enterpriseDbInfo.industry, //行业领域
property: enterpriseDbInfo.property, //所属物业
enterpriseNature: enterpriseDbInfo.enterpriseNature, //企业性质
leasedArea: enterpriseDbInfo.leasedArea, //租赁面积（㎡）
RAS: enterpriseDbInfo.RAS, //登记状态
jingYingFanWei: enterpriseDbInfo.jingYingFanWei, //经营范围
legalPerson: enterpriseDbInfo.legalPerson, //法人
zhuceziben: enterpriseDbInfo.zhuceziben, //注册资本
dianHua: enterpriseDbInfo.dianHua, //电话、联系方式
};
return {dataInfo};
}
/**
* 企业库-修改
* @param uscc
* @param param
*/
export async function enterpriseUpdate(uscc:string, param) {
/**校验参数 */
eccFormParam("管理后台修改企业库", EnterpriseUpdateConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'industry', industryEnum.ALLINDUSTRY, param.industry);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'enterpriseNature', labelEnum.ENTERPRISENATURE, param.enterpriseNature);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'property', labelEnum.PROPERTY, param.property);
verificationEnumTools.eccEnumValue('管理后台新增企业建档', 'RAS', configEnum.RAS, param.RAS);
/**校验标签 */
if (param.labels && param.labels.length > 0) {
for (let i = 0; i < param.labels.length; i++) {
let labelDbInfo = await labelData.findOnceLabel(param.labels[i]);
if (!labelDbInfo && !labelDbInfo.id) throw new BizError(ERRORENUM.该标签不存在, `${param.labels[i]}在库中不存在`);
}
}
if (!sysTools.eccUscc(param.uscc)) throw new BizError(ERRORENUM.统一社会信用代码不合法);
let now = new Date().valueOf();
if (param.logonTime > now) throw new BizError(ERRORENUM.不可选择未来时间);
if (param.parkEntryTime > now) throw new BizError(ERRORENUM.不可选择未来时间);
/**校验企业 */
let enterpriseDbInfo = await enterpriseData.findEnterpriseByUscc(uscc);
if (!enterpriseDbInfo || !enterpriseDbInfo.uscc) throw new BizError(ERRORENUM.该企业不存在, `库中不存在uscc=${uscc}这个企业`);
/**修改字段 */
let changeList = checkChange(param, enterpriseDbInfo);
if (!changeList.length) throw new BizError(ERRORENUM.数据无更新, `${param.name}数据无更新`);
changeList.forEach(key => {
enterpriseDbInfo[key] = param[key];
});
await enterpriseDbInfo.save();
return {isSuccess:true};
}
/**
* 企业库-删除
* @param id
*/
export async function enterpriseDelete(uscc:string) {
let enterpriseDbInfo = await enterpriseData.findEnterpriseByUscc(uscc);
if (!enterpriseDbInfo || !enterpriseDbInfo.name) throw new BizError(ERRORENUM.未找到数据, `库中不存在uscc=${uscc}这个企业`);
await enterpriseData.removeOneData(uscc);
return {isSuccess:true};
}
/**
* 导出企业库信息列表
* @param name 企业名称
* @param industry 行业领域
* @param parkEntryTime 入驻年份
* @param logonTime 注册年份
* @param labelIdList 标签ID列表
* @param dataType 企业分类（1=100平方公里、2=3.73平方公里、3=软件关联入驻企业、4=小台账企业、5=重点稳商企业）
* @returns 二维数组，第一行为表头，后续行为数据
*/
export async function outPutEnterpriseData(name:string, industry:string[], parkEntryTime:number, logonTime:number, labelIdList:string[], dataType:number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (name) {
selectParam.name = { "$regex": `${name}` };
}
if (industry && industry.length > 0) {
selectParam.industry = { "$in": industry };
}
if (parkEntryTime) {
let parkEntryStartTime = moment(`${parkEntryTime}-01-01`).valueOf();
let parkEntryEndTime = moment(`${parkEntryTime}-12-31`).valueOf();
selectParam.parkEntryTime = { "$gte": parkEntryStartTime, "$lte": parkEntryEndTime };
}
if (logonTime) {
let logonStartTime = moment(`${logonTime}-01-01`).valueOf();
let logonEndTime = moment(`${logonTime}-12-31`).valueOf();
selectParam.logonTime = { "$gte": logonStartTime, "$lte": logonEndTime };
}
// 标签筛选
let allLabelList = [];
if (dataType) {
if (dataType == 1) allLabelList.push(labelEnum.BASELABEL["100平方公里"].toString());
else if (dataType == 2) allLabelList.push(labelEnum.BASELABEL["3.73平方公里"].toString());
else if (dataType == 3) allLabelList.push(labelEnum.BASELABEL.软件关联入驻企业.toString());
else if (dataType == 4) allLabelList.push(labelEnum.BASELABEL.小台账企业.toString());
else if (dataType == 5) allLabelList.push(labelEnum.BASELABEL.重点稳商企业.toString());
}
if (labelIdList && labelIdList.length > 0) {
labelIdList.forEach(info => {
allLabelList.push(info.toString());
});
}
if (allLabelList.length > 0) {
let uniqueLabels = uniqueLabelList(allLabelList);
selectParam.labels = { "$elemMatch": { labelId: { "$in": uniqueLabels } } };
}
/** 查询企业数据 */
let enterpriseDbList = await enterpriseData.findEnterpriseListByParam(selectParam);
/** 表头定义 */
const titleList = [
"企业名称",
"统一社会信用代码",
"注册地址",
"注册时间",
"入驻时间",
"行业领域",
"所属物业",
"企业性质",
"租赁面积（㎡）",
"登记状态",
"经营范围",
"法人",
"注册资本",
"联系电话",
"企业标签"
];
/** 字段映射 */
const keyList = [
"name",
"uscc",
"logonAddress",
"logonTime",
"parkEntryTime",
"industry",
"property",
"enterpriseNature",
"leasedArea",
"RAS",
"jingYingFanWei",
"legalPerson",
"zhuceziben",
"dianHua",
"labels"
];
let dataList = [titleList]; // 第一行为表头
enterpriseDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.enterpriseListConfig, info, true);
/** 枚举值转文本 */
changeData.industry = verificationEnumTools.changeEnumValue(industryEnum.ALLINDUSTRY, changeData.industry) || "未选择";
changeData.property = verificationEnumTools.changeEnumValue(labelEnum.PROPERTY, changeData.property) || "未选择";
changeData.enterpriseNature = verificationEnumTools.changeEnumValue(labelEnum.ENTERPRISENATURE, changeData.enterpriseNature) || "未选择";
changeData.RAS = verificationEnumTools.changeEnumValue(configEnum.RAS, changeData.RAS) || "未选择";
/** 标签转文本 */
let labelNames = [];
if (changeData.labels && changeData.labels.length > 0) {
changeData.labels.forEach(label => {
labelNames.push(verificationEnumTools.changeEnumValue(labelEnum.ENTERPRISESYSTEMLABEL, parseInt(label.labelId)) || "未知标签");
});
}
changeData.labels = labelNames.join("、") || "无标签";
/** 时间格式化 */
changeData.logonTime = changeData.logonTime ? moment(changeData.logonTime).format("YYYY-MM-DD") : "-";
changeData.parkEntryTime = changeData.parkEntryTime ? moment(changeData.parkEntryTime).format("YYYY-MM-DD") : "-";
/** 生成一行数据 */
let row = [];
keyList.forEach(key => {
let value = changeData[key];
if (value === null || value === undefined || value === "") {
value = "-";
}
row.push(value);
});
dataList.push(row);
});
return dataList;
}
src/biz/importData.ts 0 → 100644
/**
* 导入相关方法
*/
import { UpExcelNameType } from "../config/enum";
import { TABLEID } from "../config/enum/dbEnum";
import { systemConfig } from "../config/serverConfig";
import { randomId } from "../tools/system";
import { onceSheetBecomeOfblockData } from "../util/analysisExcel";
import * as verificationEnumTools from "../util/verificationEnum";
import * as labelEnum from "../config/enum/labelEnum";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as sysTools from "../tools/system";
import * as negotiationData from "../data/negotiation";
import * as enterpriseData from "../data/enterprise";
import * as manageData from "../data/manage";
const xlsx = require('node-xlsx');
const path = require('path');
const fs = require('fs');
let md5 = require("md5");
/**
* 导出excel模板地址
* @param excelType excel对应文件类型
* @returns
*/
export async function excelUrl(excelType) {
let excelName = verificationEnumTools.changeEnumValue(UpExcelNameType, excelType);
let excelUrl = `${systemConfig.excelModelUrl}${excelName}.xlsx`
return excelUrl;
}
/**
* 将文件数据写入对应文件
* @param list 文件数据
* @param excelName 需要写入的文件
* @returns
*/
export async function upShowExcel(list, excelType) {
let data = [];
list.forEach(info => {
data.push({
name:"Sheet1",
data:info.data
});
})
let buff = xlsx.build(data);
if (excelType == UpExcelNameType.在谈在跟) {
await 在谈在跟(buff);
}
return {isSuccess:true}
}
export async function 在谈在跟(buff) {
fs.writeFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", "在谈在跟.xlsx" ), buff);
let excelData = onceSheetBecomeOfblockData("在谈在跟.xlsx", "Sheet1");
// let excelData = [
// {
// blockData: [
// [
// "在跟在谈导入新增记录",
// "__EMPTY",
// "__EMPTY_1",
// "__EMPTY_2",
// "__EMPTY_3",
// "__EMPTY_4",
// ],
// [
// "企业名称",
// "行业领域",
// "推进、注册情况",
// "进展情况",
// "负责人、首谈人",
// "对接部门",
// ],
// [
// "上海测试在谈在跟企业2",
// "渔业",
// "洽谈中",
// "初次接触",
// "测试陈",
// "测试部",
// ],
// ],
// blockTitle: "0_0",
// },
// ]
let negotiationList = [];
excelData.forEach( info => {
let {blockData} = info;
for (let i = 2; i < blockData.length; i++) {
let rowData = blockData[i];
/**枚举转换 */
let industry = [industryEnum.ALLINDUSTRY[rowData[1]]];
let registrationStatus = configEnum.REGISTRATIONSTATUS[rowData[2]];
let progressStatus = configEnum.REGISTRATIONSTATUS[rowData[3]];
//准备在谈在跟数据
let negotiationInfo = {
id: randomId(TABLEID.在跟在谈),
name: rowData[0],
industry: industry,
registrationStatus: registrationStatus,
progressStatus: progressStatus,
primaryContact: rowData[4],
contactDepartment: rowData[5],
createTime:new Date().valueOf(),
}
negotiationList.push(negotiationInfo);
}
});
await negotiationData.createDataByParam(negotiationList);
console.log("在谈在跟数据导入成功");
}
export async function 全部企业(buff) {
fs.writeFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", "全部企业.xlsx" ), buff);
let excelData = onceSheetBecomeOfblockData("全部企业.xlsx", "Sheet1");
let enterpriseList = [];
excelData.forEach( info => {
let {blockData} = info;
for (let i = 2; i < blockData.length; i++) {
let rowData = blockData[i];
/**枚举转换 */
let industry = [industryEnum.ALLINDUSTRY[rowData[12]]]; //行业领域
let labelList = parseLabels(rowData); //解析标签
let enterpriseNature = labelEnum.ENTERPRISENATURE[rowData[13]]; //企业性质
let property = labelEnum.PROPERTY[rowData[14]]; //所属物业
let RAS = configEnum.RAS[rowData[18]];
let logonAddress = [rowData[2], rowData[3], rowData[4], rowData[5]];
//准备企业数据
let enterpriseInfo = {
id: randomId(TABLEID.企业基础信息表),
name: rowData[0],
uscc: rowData[1],
logonAddress: logonAddress,
logonTime: rowData[6],
parkEntryTime: rowData[7],
industry,
property,
enterpriseNature,
leasedArea: rowData[17],
RAS,
jingYingFanWei: rowData[19],
legalPerson: rowData[20],
zhuceziben: rowData[21],
dianHua: rowData[22],
createTime: new Date().valueOf(),
labels: labelList,
pwd: sysTools.getPwdMd5(rowData[1], md5(rowData[1].slice(rowData[1].length-6))),
firstLoginIsChangePwd:false,
};
enterpriseList.push(enterpriseInfo);
}
});
await enterpriseData.createDataByParam(enterpriseList);
console.log("全部企业数据导入成功");
}
export async function 经营数据(buff) {
fs.writeFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", "经营数据.xlsx" ), buff);
let excelData = onceSheetBecomeOfblockData("经营数据.xlsx", "Sheet1");
let manageList = [];
excelData.forEach( info => {
let {blockData} = info;
for (let i = 2; i < blockData.length; i++) {
let rowData = blockData[i];
/**枚举转换 */
let period = configEnum.REGISTRATIONSTATUS[rowData[2]];
//准备经营数据
let manageInfo = {
id: randomId(TABLEID.企业经营数据),
uscc: rowData[1],
name: rowData[0],
year: rowData[2],
period: period,
BI: rowData[4],
VAT: rowData[5],
CIT: rowData[6],
PIT: rowData[7],
RD: rowData[8],
isSubmit:true,
createTime:new Date().valueOf(),
}
manageList.push(manageInfo);
}
});
await manageData.createDataByParam(manageList);
console.log("经营数据数据导入成功");
}
/**
* 处理企业标签
* @param {Object} rowData Excel行数据
* @returns {Array} 标签数组
*/
function parseLabels(rowData) {
let labels = [];
let currentTime = new Date().valueOf();
// 1. 基础标签 (BASELABEL)
if (rowData[9] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["3.73平方公里"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData[8] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["100平方公里"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData[10] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["软件关联入驻企业"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData[11] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["小台账企业"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData[12] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["重点稳商企业"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
// 2. 入驻年份标签 (ENTERPRISESYSTEMLABEL)
let entryYear = rowData['parkEntryTime'];
if (entryYear && entryYear != "-") {
let yearValue;
switch (entryYear.toString()) {
case '2023年':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2023年"];
break;
case '2024年':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2024年"];
break;
case '2025年':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2025年"];
break;
case '2026年':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2026年"];
break;
case '2027年':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2027年"];
break;
case '2028年':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2028年"];
break;
// default:
// yearValue = labelEnum.ENTERPRISESYSTEMLABEL["其他年份"];
}
labels.push({
labelId: yearValue,
labelType: labelEnum.LABELTYPE.入驻年份,
state: true
});
}
// 3. 所属物业（PROPERTY）
let property = rowData['property'];
if (property && property != "-") {
let propertyValue;
switch (property) {
case "于田大厦":
propertyValue = labelEnum.PROPERTY.于田大厦;
break;
case "同济科技园":
propertyValue = labelEnum.PROPERTY.同济科技园;
break;
case "嘉亭荟":
propertyValue = labelEnum.PROPERTY.嘉亭荟;
break;
case "智驾园":
propertyValue = labelEnum.PROPERTY.智驾园;
break;
case "汽车创新港":
propertyValue = labelEnum.PROPERTY.汽车创新港;
break;
case "汽车城大厦":
propertyValue = labelEnum.PROPERTY.汽车城大厦;
break;
}
labels.push({
labelId: propertyValue,
labelType: labelEnum.LABELTYPE.所属物业,
state: true
});
}
// 4. 企业性质 enterpriseNature: EnterpriseNatureMap[rowData.enterpriseNature] || labelEnum.ENTERPRISENATURE.实体型
let enterpriseNature = rowData['enterpriseNature'];
if (enterpriseNature && enterpriseNature != "-") {
let enterpriseNatureValue;
switch (enterpriseNature) {
case "实体型":
enterpriseNatureValue = labelEnum.ENTERPRISENATURE.实体型;
break;
case "注册型":
enterpriseNatureValue = labelEnum.ENTERPRISENATURE.注册型;
break;
case "虚拟型":
enterpriseNatureValue = labelEnum.ENTERPRISENATURE.虚拟型;
break;
}
labels.push({
labelId: enterpriseNatureValue,
labelType: labelEnum.LABELTYPE.企业性质,
state: true
});
}
return labels;
}
src/biz/labelValue.ts 0 → 100644
/**
* 标签下拉
*/
import * as labelData from "../data/label";
export async function getLabel(labelType?) {
let selectParam:any = {};
if (labelType) {
selectParam.labelType = labelType;
}
/**需要用到的查询数据 */
let labelDbList = await labelData.selectLabelList(selectParam);
/**组合返回结果 */
let dataList = [];
labelDbList.forEach( info => {
dataList.push({
key: info.id,
value: info.labelName
})
})
return dataList;
}
/**
* 不包含某标签类型的其他所有标签
* @param labelType
* @returns
*/
export async function getNotTypeLabel(labelType) {
let selectParam:any = {};
if (labelType) {
selectParam.labelType = {"$nin": labelType};
}
/**需要用到的查询数据 */
let labelDbList = await labelData.selectLabelList(selectParam);
/**组合返回结果 */
let dataList = [];
labelDbList.forEach( info => {
dataList.push({
key: info.id,
value: info.labelName
})
})
return dataList;
}
src/biz/manage.ts 0 → 100644
/**
* 企业经营数据
*/
import * as verificationEnumTools from "../util/verificationEnum";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as manageData from "../data/manage";
import { checkChange, extractData } from "../util/piecemeal";
import * as splitResultConfig from '../config/splitResultConfig';
import { eccFormParam } from "../util/verificationParam";
import { ManageAddConfig, ManageUpdateConfig } from "../config/eccParam/admin";
import { randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
import moment from "moment";
/**
* 经营数据-列表
* @param name 企业名称
* @param year 数据年度
* @param period 数据时间 上半年、下半年、全年
* @param page 页
* @returns
*/
export async function manageList(name:string, year:number, period:number, page:number) {
let selectParam:any = {};
if (name) {
selectParam.name = {"$regex":`${name}`};
}
if (year) {
selectParam.year = year;
}
if (period) {
selectParam.period = period;
}
/**需要用到的查询数据 */
let manageDbList = await manageData.findManageListToPage(selectParam, (page - 1) * 10);
let count = await manageData.findManageCount(selectParam);//符合查询条件的数据总数
/**组合返回结果 */
let dataList = [];
manageDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.manageListConfig, info, true);
/**将枚举值转为字符 */
changeData.period = verificationEnumTools.changeEnumValue(configEnum.PERIOD, changeData.period);
dataList.push(changeData);
})
return {count, dataList};
}
/**
* 经营数据-新增
* @param param
*/
export async function manageCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增经营数据企业", ManageAddConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台新增经营数据', 'period', configEnum.PERIOD, param.period);
let enterpriseInfo = await manageData.findManageByParam({name:param.name});
if (enterpriseInfo && enterpriseInfo.name) throw new BizError(ERRORENUM.该企业已存在, `${param.name}已经在库中存在`);
let manageInfo = {
id: randomId(TABLEID.企业经营数据),
uscc: param.uscc,
name: param.name,
year: param.year,
period: param.period,
BI: param.BI,
VAT: param.VAT,
CIT: param.CIT,
PIT: param.PIT,
RD: param.RD,
isSubmit:true,
createTime:new Date().valueOf(),
}
await manageData.createDataByParam(manageInfo);
return {isSuccess:true};
}
/**
* 经营数据-回显
* @param uscc
*/
export async function manageInfo(id:string) {
/**校验企业 */
let manageDbInfo = await manageData.findManageByParam({id});
if (!manageDbInfo || !manageDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个经营数据`);
let dataInfo = {
uscc: manageDbInfo.uscc,
name: manageDbInfo.name,
year: manageDbInfo.year,
period: manageDbInfo.period, //verificationEnumTools.changeEnumValue(configEnum.PERIOD, manageDbInfo.period)
BI: manageDbInfo.BI,
VAT: manageDbInfo.VAT,
CIT: manageDbInfo.CIT,
PIT: manageDbInfo.PIT,
RD: manageDbInfo.RD,
};
return {dataInfo};
}
/**
* 经营数据-修改
* @param uscc
* @param param
*/
export async function manageUpdate(id:string, param) {
/**校验参数 */
eccFormParam("管理后台修改经营数据企业", ManageUpdateConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台修改经营数据企业', 'industry', industryEnum.ALLINDUSTRY, param.industry);
verificationEnumTools.eccEnumValue('管理后台修改经营数据企业', 'registrationStatus', configEnum.REGISTRATIONSTATUS, param.registrationStatus);
verificationEnumTools.eccEnumValue('管理后台修改经营数据企业', 'progressStatus', configEnum.PROGRESSSTATUS, param.progressStatus);
/**校验企业 */
let manageDbInfo = await manageData.findManageByParam({id});
if (!manageDbInfo || !manageDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
/**修改字段 */
let changeList = checkChange(param, manageDbInfo);
if (!changeList.length) throw new BizError(ERRORENUM.数据无更新, `${param.name}数据无更新`);
changeList.forEach(key => {
manageDbInfo[key] = param[key];
});
await manageDbInfo.save();
return {isSuccess:true};
}
/**
* 经营数据-删除
* @param id
*/
export async function manageDelete(id:string) {
let manageDbInfo = await manageData.findManageByParam({id});
if (!manageDbInfo || !manageDbInfo.name) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
await manageData.removeOneData(id);
return {isSuccess:true};
}
/**
* 导出经营数据信息列表
* @param name 企业名称
* @param year 数据年度
* @param period 数据期间 上半年、下半年、全年
* @returns 二维数组，第一行为表头，后续行为数据
*/
export async function outPutManageData(name: string, year: number, period: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (name) {
selectParam.name = { "$regex": `${name}` };
}
if (year) {
selectParam.year = year;
}
if (period) {
selectParam.period = period;
}
/** 查询经营数据 */
let manageDbList = await manageData.findManageListByParam(selectParam);
/** 表头定义 */
const titleList = [
"企业名称",
"统一社会信用代码",
"数据年度",
"数据期间",
"营业收入（万元）",
"增值税（万元）",
"企业所得税（万元）",
"个人所得税（万元）",
"研发投入（万元）",
"提交状态"
];
/** 字段映射 */
const keyList = [
"name",
"uscc",
"year",
"period",
"BI",
"VAT",
"CIT",
"PIT",
"RD",
"isSubmit"
];
let dataList = [titleList]; // 第一行为表头
manageDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.manageListConfig, info, true);
/** 枚举值转文本 */
changeData.period = verificationEnumTools.changeEnumValue(configEnum.PERIOD, changeData.period) || "未选择";
changeData.isSubmit = changeData.isSubmit ? "已提交" : "未提交";
/** 数字格式化（保留两位小数） */
const numberKeys = ["BI", "VAT", "CIT", "PIT", "RD"];
numberKeys.forEach(key => {
if (changeData[key] !== null && changeData[key] !== undefined) {
changeData[key] = parseFloat(changeData[key]).toFixed(2);
}
});
/** 生成一行数据 */
let row = [];
keyList.forEach(key => {
let value = changeData[key];
if (value === null || value === undefined || value === "") {
value = "-";
}
row.push(value);
});
dataList.push(row);
});
return dataList;
}
src/biz/negotiation.ts 0 → 100644
/**
* 在谈在跟
*/
import * as verificationEnumTools from "../util/verificationEnum";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as negotiationData from "../data/negotiation";
import { checkChange, extractData } from "../util/piecemeal";
import * as splitResultConfig from '../config/splitResultConfig';
import { eccFormParam } from "../util/verificationParam";
import { NegotiationAddConfig, NegotiationUpdateConfig } from "../config/eccParam/admin";
import { randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
import moment from "moment";
/**
* 在谈在跟-列表
* @param name 企业名称
* @param industry 行业领域
* @param registrationStatus 推进、注册情况
* @param primaryContact 负责人、首谈人
* @param contactDepartment 对接部门
* @param page 页
*/
export async function negotiationList(name:string, industry, registrationStatus:number, primaryContact:string, contactDepartment:string, page:number) {
let selectParam:any = {};
if (name) {
selectParam.name = {"$regex":`${name}`};
}
if (industry && industry.length > 0) {
verificationEnumTools.eccEnumValue('管理后台获取在谈在跟列表', 'industry', industryEnum.ALLINDUSTRY, industry);
selectParam.industry = {"$in":industry};
}
if (registrationStatus) {
verificationEnumTools.eccEnumValue('管理后台获取在谈在跟列表', 'registrationStatus', configEnum.REGISTRATIONSTATUS, registrationStatus);
selectParam.registrationStatus = registrationStatus;
}
if (primaryContact) {
selectParam.primaryContact = {"$regex":`${primaryContact}`};
}
if (contactDepartment) {
selectParam.contactDepartment = {"$regex":`${contactDepartment}`};
}
/**需要用到的查询数据 */
let negotiationDbList = await negotiationData.findNegotiationListToPage(selectParam, (page - 1) * 10);
let count = await negotiationData.findNegotiationCount(selectParam);//符合查询条件的数据总数
/**组合返回结果 */
let dataList = [];
negotiationDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.negotiationListConfig, info, true);
/**将枚举值转为字符 */
let industry = [];
if (changeData.industry && changeData.industry.length > 0) {
industry.push(verificationEnumTools.changeEnumValue(industryEnum.ALLINDUSTRY, changeData.industry))
}
changeData.industry = industry;
changeData.registrationStatus = verificationEnumTools.changeEnumValue(configEnum.REGISTRATIONSTATUS, changeData.registrationStatus);
changeData.progressStatus = verificationEnumTools.changeEnumValue(configEnum.PROGRESSSTATUS, changeData.progressStatus);
dataList.push(changeData);
})
return {count, dataList};
}
/**
* 在谈在跟-新增
* @param uscc
* @param param
*/
export async function negotiationCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增在谈在跟企业", NegotiationAddConfig, param);
/**校验枚举 */
if (param.industry && param.industry.length > 0) {
verificationEnumTools.eccEnumValue('管理后台新增在谈在跟', 'industry', industryEnum.ALLINDUSTRY, param.industry);
}
verificationEnumTools.eccEnumValue('管理后台新增在谈在跟', 'registrationStatus', configEnum.REGISTRATIONSTATUS, param.registrationStatus);
let enterpriseInfo = await negotiationData.findNegotiationByParam({name:param.name});
if (enterpriseInfo && enterpriseInfo.name) throw new BizError(ERRORENUM.该企业已存在, `${param.name}已经在库中存在`);
let negotiationInfo = {
id: randomId(TABLEID.在跟在谈),
name: param.name,
industry: param.industry,
registrationStatus: param.registrationStatus,
progressStatus: param.progressStatus,
primaryContact: param.primaryContact,
contactDepartment: param.contactDepartment,
createTime:new Date().valueOf(),
}
await negotiationData.createDataByParam(negotiationInfo);
return {isSuccess:true};
}
/**
* 在谈在跟-回显
* @param uscc
*/
export async function negotiationInfo(id:string) {
/**校验企业 */
let negotiationDbInfo = await negotiationData.findNegotiationByParam({id});
if (!negotiationDbInfo || !negotiationDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
/**将枚举值转为字符 */
// let industry = [];
// if (negotiationDbInfo.industry && negotiationDbInfo.industry.length > 0) {
// industry.push(verificationEnumTools.changeEnumValue(industryEnum.ALLINDUSTRY, negotiationDbInfo.industry))
// }
let dataInfo = {
name: negotiationDbInfo.name,
industry: negotiationDbInfo.industry,
registrationStatus: negotiationDbInfo.registrationStatus,
progressStatus: negotiationDbInfo.progressStatus,
primaryContact: negotiationDbInfo.primaryContact,
contactDepartment: negotiationDbInfo.contactDepartment,
};
return {dataInfo};
}
/**
* 在谈在跟-修改
* @param uscc
* @param param
*/
export async function negotiationUpdate(id:string, param) {
/**校验参数 */
eccFormParam("管理后台修改在谈在跟企业", NegotiationUpdateConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台修改在谈在跟企业', 'industry', industryEnum.ALLINDUSTRY, param.industry);
verificationEnumTools.eccEnumValue('管理后台修改在谈在跟企业', 'registrationStatus', configEnum.REGISTRATIONSTATUS, param.registrationStatus);
verificationEnumTools.eccEnumValue('管理后台修改在谈在跟企业', 'progressStatus', configEnum.PROGRESSSTATUS, param.progressStatus);
/**校验企业 */
let negotiationDbInfo = await negotiationData.findNegotiationByParam({id});
if (!negotiationDbInfo || !negotiationDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
/**修改字段 */
let changeList = checkChange(param, negotiationDbInfo);
if (!changeList.length) throw new BizError(ERRORENUM.数据无更新, `${param.name}数据无更新`);
changeList.forEach(key => {
negotiationDbInfo[key] = param[key];
});
await negotiationDbInfo.save();
return {isSuccess:true};
}
/**
* 在谈在跟-删除
* @param id
*/
export async function negotiationDelete(id:string) {
let negotiationDbInfo = await negotiationData.findNegotiationByParam({id});
if (!negotiationDbInfo || !negotiationDbInfo.name) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
await negotiationData.removeOneData(id);
return {isSuccess:true};
}
/**
* 导出在谈在跟企业信息列表
* @param name 企业名称
* @param industry 行业领域
* @param registrationStatus 推进、注册情况
* @param primaryContact 负责人、首谈人
* @param contactDepartment 对接部门
* @returns 二维数组，第一行为表头，后续行为数据
*/
export async function outPutNegotiationData(name:string, industry:string[], registrationStatus:number, primaryContact:string, contactDepartment:string) {
/** 拼接查询条件 */
let selectParam: any = {};
if (name) {
selectParam.name = {"$regex": `${name}`};
}
if (industry && industry.length > 0) {
verificationEnumTools.eccEnumValue('管理后台导出在谈在跟列表', 'industry', industryEnum.ALLINDUSTRY, industry);
selectParam.industry = {"$in": industry};
}
if (registrationStatus) {
verificationEnumTools.eccEnumValue('管理后台导出在谈在跟列表', 'registrationStatus', configEnum.REGISTRATIONSTATUS, registrationStatus);
selectParam.registrationStatus = registrationStatus;
}
if (primaryContact) {
selectParam.primaryContact = {"$regex": `${primaryContact}`};
}
if (contactDepartment) {
selectParam.contactDepartment = {"$regex": `${contactDepartment}`};
}
/** 查询在谈在跟数据 */
let negotiationDbList = await negotiationData.findNegotiationListByParam(selectParam);
/** 表头定义 */
const titleList = [
"企业名称",
"行业领域",
"推进状态",
"注册情况",
"负责人/首谈人",
"对接部门",
"创建时间"
];
/** 字段映射 */
const keyList = [
"name",
"industry",
"progressStatus",
"registrationStatus",
"primaryContact",
"contactDepartment",
"createTime"
];
let dataList = [titleList]; // 第一行为表头
negotiationDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.negotiationListConfig, info, true);
/** 枚举值转文本 */
let industryText = [];
if (changeData.industry && changeData.industry.length > 0) {
industryText.push(verificationEnumTools.changeEnumValue(industryEnum.ALLINDUSTRY, changeData.industry));
}
changeData.industry = industryText.join("、") || "未选择";
changeData.registrationStatus = verificationEnumTools.changeEnumValue(configEnum.REGISTRATIONSTATUS, changeData.registrationStatus) || "未选择";
changeData.progressStatus = verificationEnumTools.changeEnumValue(configEnum.PROGRESSSTATUS, changeData.progressStatus) || "未选择";
/** 时间格式化 */
changeData.createTime = changeData.createTime ? moment(changeData.createTime).format("YYYY-MM-DD HH:mm:ss") : "-";
/** 生成一行数据 */
let row = [];
keyList.forEach(key => {
let value = changeData[key];
if (value === null || value === undefined || value === "") {
value = "-";
}
// 确保值是字符串类型
if (Array.isArray(value)) {
value = value.join("、");
}
row.push(value);
});
dataList.push(row);
});
return dataList;
}
src/biz/policy.ts 0 → 100644
/**
* 政策
*/
import * as verificationEnumTools from "../util/verificationEnum";
import * as configEnum from "../config/enum";
import * as policyData from "../data/policy";
import { checkChange, extractData } from "../util/piecemeal";
import * as splitResultConfig from '../config/splitResultConfig';
import { eccFormParam } from "../util/verificationParam";
import { PolicyAddConfig, PolicyUpdateConfig } from "../config/eccParam/admin";
import { randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
/**
* 政策-列表
* @param title 活动标题
* @param startTime 活动开始时间
* @param endTime 活动结束时间
* @param policyType 政策类型 财政补贴 资质申报 政策扶持
* @param page 页
*/
export async function policyList(title:string, startTime:number, endTime:number, policyType:number, page:number) {
let selectParam:any = {};
if (title) {
selectParam.title = {"$regex":`${title}`};
}
if (startTime && endTime) {
selectParam.startTime = { "$gte": startTime };
selectParam.endTime = { "$lte": endTime };
}
if (policyType) {
verificationEnumTools.eccEnumValue('管理后台获取政策列表', 'policyType', configEnum.POLICYTYPE, policyType);
selectParam.policyType = policyType;
}
/**需要用到的查询数据 */
let policyDbList = await policyData.findPolicyListToPage(selectParam, (page - 1) * 10);
let count = await policyData.findPolicyCount(selectParam);//符合查询条件的数据总数
/**组合返回结果 */
let dataList = [];
policyDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.policyListConfig, info, true);
/**将枚举值转为字符 */
changeData.policyType = verificationEnumTools.changeEnumValue(configEnum.POLICYTYPE, changeData.policyType);
dataList.push(changeData);
})
return {count, dataList};
}
/**
* 政策-新增
* @param uscc
* @param param
*/
export async function policyCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增政策企业", PolicyAddConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台新增政策', 'policyType', configEnum.POLICYTYPE, param.policyType);
let enterpriseInfo = await policyData.findPolicyByParam({title:param.title});
if (enterpriseInfo && enterpriseInfo.title) throw new BizError(ERRORENUM.该政策已存在, `${param.title}已经在库中存在`);
let policyInfo = {
id: randomId(TABLEID.政策),
title: param.title,
policyType: param.policyType,
startTime: param.startTime,
endTime: param.endTime,
source: param.source,
desc:param.desc,
}
await policyData.createDataByParam(policyInfo);
return {isSuccess:true};
}
/**
* 政策-回显
* @param uscc
*/
export async function policyInfo(id:string) {
/**校验企业 */
let policyDbInfo = await policyData.findPolicyByParam({id});
if (!policyDbInfo || !policyDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个政策`);
let dataInfo = {
title: policyDbInfo.title,
policyType: policyDbInfo.policyType,
startTime: policyDbInfo.startTime,
endTime: policyDbInfo.endTime,
source: policyDbInfo.source,
desc:policyDbInfo.desc,
};
return {dataInfo};
}
/**
* 政策-修改
* @param uscc
* @param param
*/
export async function policyUpdate(id:string, param) {
/**校验参数 */
eccFormParam("管理后台修改政策企业", PolicyUpdateConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台新增政策', 'policyType', configEnum.POLICYTYPE, param.policyType);
/**校验企业 */
let policyDbInfo = await policyData.findPolicyByParam({id});
if (!policyDbInfo || !policyDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个政策`);
/**修改字段 */
let changeList = checkChange(param, policyDbInfo);
if (!changeList.length) throw new BizError(ERRORENUM.数据无更新, `${param.name}数据无更新`);
changeList.forEach(key => {
policyDbInfo[key] = param[key];
});
await policyDbInfo.save();
return {isSuccess:true};
}
/**
* 政策-删除
* @param id
*/
export async function policyDelete(id:string) {
let policyDbInfo = await policyData.findPolicyByParam({id});
if (!policyDbInfo || !policyDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个政策`);
await policyData.removeOneData(id);
return {isSuccess:true};
}
/**
* 导出政策信息列表
* @param title 政策标题
* @param startTime 开始时间
* @param endTime 结束时间
* @param policyType 政策类型
* @returns 二维数组，第一行为表头，后续行为数据
*/
export async function outPutPolicyData(title: string, startTime: number, endTime: number, policyType: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (title) {
selectParam.title = { "$regex": `${title}` };
}
if (startTime && endTime) {
selectParam.startTime = { "$gte": startTime };
selectParam.endTime = { "$lte": endTime };
} else if (startTime) {
selectParam.startTime = { "$gte": startTime };
} else if (endTime) {
selectParam.endTime = { "$lte": endTime };
}
if (policyType) {
selectParam.policyType = policyType;
}
/** 查询政策数据 */
let policyDbList = await policyData.findPolicyListByParam(selectParam);
/** 表头定义 */
const titleList = [
"政策标题",
"政策类型",
"生效时间",
"失效时间",
"政策来源",
"政策内容"
];
let dataList = [titleList]; // 第一行为表头
policyDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.policyListConfig, info, true);
/** 枚举值转文本 */
changeData.policyType = verificationEnumTools.changeEnumValue(configEnum.POLICYTYPE, changeData.policyType) || "未分类";
/** 时间格式化 */
changeData.startTime = changeData.startTime ? formatDate(changeData.startTime) : "长期有效";
changeData.endTime = changeData.endTime ? formatDate(changeData.endTime) : "长期有效";
/** 处理政策内容（过长时截取） */
let descText = changeData.desc || "-";
if (descText.length > 100) {
descText = descText.substring(0, 100) + "...";
}
/** 生成一行数据 */
let row = [
changeData.title || "-",
changeData.policyType,
changeData.startTime,
changeData.endTime,
changeData.source || "-",
descText
];
dataList.push(row);
});
return dataList;
}
/**
* 导出政策详细信息（带状态计算）
* @param title 政策标题
* @param startTime 开始时间
* @param endTime 结束时间
* @param policyType 政策类型
* @returns 二维数组，带政策状态计算
*/
export async function outPutPolicyDetailData(title: string, startTime: number, endTime: number, policyType: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (title) {
selectParam.title = { "$regex": `${title}` };
}
if (startTime && endTime) {
selectParam.startTime = { "$gte": startTime };
selectParam.endTime = { "$lte": endTime };
} else if (startTime) {
selectParam.startTime = { "$gte": startTime };
} else if (endTime) {
selectParam.endTime = { "$lte": endTime };
}
if (policyType) {
selectParam.policyType = policyType;
}
/** 查询政策数据 */
let policyDbList = await policyData.findPolicyListByParam(selectParam);
const now = Date.now();
/** 表头定义 - 增加状态、剩余时间等字段 */
const titleList = [
"政策标题",
"政策类型",
"生效时间",
"失效时间",
"政策状态",
"剩余/已过期时间",
"政策来源",
"政策内容摘要",
"政策ID",
"创建时间"
];
let dataList = [titleList];
policyDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.policyListConfig, info, true);
/** 枚举值转文本 */
const policyTypeText = verificationEnumTools.changeEnumValue(configEnum.POLICYTYPE, changeData.policyType) || "未分类";
/** 时间格式化 */
const startTimeText = changeData.startTime ? formatDate(changeData.startTime) : "长期有效";
const endTimeText = changeData.endTime ? formatDate(changeData.endTime) : "长期有效";
const createTimeText = changeData.createTime ? formatDateTime(changeData.createTime) : "-";
/** 计算政策状态 */
let policyStatus = "";
let remainingTime = "";
if (!changeData.startTime && !changeData.endTime) {
// 无时间限制
policyStatus = "长期有效";
remainingTime = "无限制";
} else if (changeData.startTime && changeData.endTime) {
// 有明确起止时间
if (now < changeData.startTime) {
// 未生效
const daysLeft = Math.ceil((changeData.startTime - now) / (1000 * 3600 * 24));
policyStatus = "未生效";
remainingTime = `${daysLeft}天后生效`;
} else if (now > changeData.endTime) {
// 已失效
const daysAgo = Math.ceil((now - changeData.endTime) / (1000 * 3600 * 24));
policyStatus = "已失效";
remainingTime = `已过期${daysAgo}天`;
} else {
// 有效期内
const daysLeft = Math.ceil((changeData.endTime - now) / (1000 * 3600 * 24));
policyStatus = "生效中";
remainingTime = `剩余${daysLeft}天`;
}
} else if (changeData.startTime && !changeData.endTime) {
// 只有生效时间，无失效时间
if (now < changeData.startTime) {
const daysLeft = Math.ceil((changeData.startTime - now) / (1000 * 3600 * 24));
policyStatus = "未生效";
remainingTime = `${daysLeft}天后生效`;
} else {
policyStatus = "生效中";
remainingTime = "长期有效";
}
} else if (!changeData.startTime && changeData.endTime) {
// 只有失效时间
if (now > changeData.endTime) {
const daysAgo = Math.ceil((now - changeData.endTime) / (1000 * 3600 * 24));
policyStatus = "已失效";
remainingTime = `已过期${daysAgo}天`;
} else {
const daysLeft = Math.ceil((changeData.endTime - now) / (1000 * 3600 * 24));
policyStatus = "生效中";
remainingTime = `剩余${daysLeft}天`;
}
}
/** 处理政策内容摘要 */
let descText = changeData.desc || "-";
if (descText.length > 80) {
descText = descText.substring(0, 80) + "...";
}
/** 生成一行数据 */
let row = [
changeData.title || "-",
policyTypeText,
startTimeText,
endTimeText,
policyStatus,
remainingTime,
changeData.source || "-",
descText,
changeData.id || "-",
createTimeText
];
dataList.push(row);
});
return dataList;
}
/**
* 按政策类型分组导出
* @returns 二维数组，按政策类型分组
*/
export async function outPutPolicyByTypeData() {
/** 查询所有政策数据 */
let policyDbList = await policyData.findPolicyListByParam({});
/** 按政策类型分组 */
const policyTypeMap = new Map();
policyDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.policyListConfig, info, true);
const policyType = changeData.policyType || 0;
const policyTypeText = verificationEnumTools.changeEnumValue(configEnum.POLICYTYPE, policyType) || "未分类";
if (!policyTypeMap.has(policyType)) {
policyTypeMap.set(policyType, {
typeName: policyTypeText,
policies: []
});
}
// 时间格式化
changeData.startTime = changeData.startTime ? formatDate(changeData.startTime) : "长期有效";
changeData.endTime = changeData.endTime ? formatDate(changeData.endTime) : "长期有效";
policyTypeMap.get(policyType).policies.push(changeData);
});
/** 表头定义 */
const titleList = [
"政策类型",
"政策标题",
"生效时间",
"失效时间",
"政策来源",
"政策内容摘要"
];
let dataList = [titleList];
/** 按政策类型顺序输出 */
const policyTypeOrder = Object.keys(configEnum.POLICYTYPE).filter(key => isNaN(Number(key))).map(key => configEnum.POLICYTYPE[key]);
policyTypeOrder.forEach(typeId => {
if (policyTypeMap.has(typeId)) {
const group = policyTypeMap.get(typeId);
// 添加分类标题行（可选）
// dataList.push(new Array(titleList.length).fill(""));
// const headerRow = new Array(titleList.length).fill("");
// headerRow[0] = `【${group.typeName}】`;
// dataList.push(headerRow);
group.policies.forEach((policy, index) => {
let row = [
index === 0 ? group.typeName : "", // 只在第一条显示类型
policy.title || "-",
policy.startTime,
policy.endTime,
policy.source || "-",
policy.desc ? (policy.desc.length > 80 ? policy.desc.substring(0, 80) + "..." : policy.desc) : "-"
];
dataList.push(row);
});
// 在不同类型之间添加空行
dataList.push(new Array(titleList.length).fill(""));
}
});
return dataList;
}
/**
* 日期格式化辅助函数（仅日期）
* @param timestamp 时间戳
* @returns 格式化后的日期字符串
*/
function formatDate(timestamp: number): string {
const date = new Date(timestamp);
const year = date.getFullYear();
const month = (date.getMonth() + 1).toString().padStart(2, '0');
const day = date.getDate().toString().padStart(2, '0');
return `${year}-${month}-${day}`;
}
/**
* 时间格式化辅助函数（日期+时间）
* @param timestamp 时间戳
* @returns 格式化后的时间字符串
*/
function formatDateTime(timestamp: number): string {
const date = new Date(timestamp);
const year = date.getFullYear();
const month = (date.getMonth() + 1).toString().padStart(2, '0');
const day = date.getDate().toString().padStart(2, '0');
const hours = date.getHours().toString().padStart(2, '0');
const minutes = date.getMinutes().toString().padStart(2, '0');
return `${year}-${month}-${day} ${hours}:${minutes}`;
}
src/biz/qccInit.ts 0 → 100644
/**
* 企查查数据同步
*/
import moment from "moment";
import * as configEnum from "../config/enum";
import * as enterpriseData from "../data/enterprise";
import * as labelData from "../data/label";
import * as enterpriseRiskData from "../data/enterpriseRisk";
import * as dishonestPersonData from "../data/dishonestPerson";
import * as illegalityData from "../data/illegality";
import * as qualificationsData from "../data/qualifications";
import { systemConfig } from "../config/serverConfig";
import { getQcc } from "../util/request";
import { formatAddress, randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { LABELGOAL, LABELTYPE } from "../config/enum/labelEnum";
const md5 = require("md5");
/**
* 同步企查查数据
* 逻辑：获取数据库所有企业uscc，进行企查查数据同步
*/
export async function updateQCCDataTask() {
let enterpriseList = await enterpriseData.findEnterpriseListByParam({isSettled: configEnum.STATE.是});
console.log(`开始同步企查查数据，${moment(new Date().valueOf()).format("YYYY-MM-DD HH:mm:ss")}：本次同步同${enterpriseList.length}家`);
for (let i = 0; i < enterpriseList.length; i++) {
let info = enterpriseList[i];
await updateItemQCCData(info.uscc, info.name);
console.log(`下标 ${i} => name：${info.name}，uscc：${info.uscc}`);
}
console.log(`${enterpriseList.length}家企业同步成功`);
}
/**
* 更新单个企业
* @param uscc
* @param name
*/
export async function updateItemQCCData(uscc, name) {
await 工商信息(uscc);
await 准入尽职调查(uscc);
await 失信核查(uscc);
await 严重违法核查(uscc);
await 科创分(uscc);
await 资质证书查询(uscc);
//"91310114MA1GY5G71E"
}
/**
* 封装了一个请求方法
* @param uscc
* @returns
*/
function getReqParam(uscc, isKeyNo?) {
const TimeSpan = Math.round(new Date().valueOf()/ 1000);
let header = {
Token:md5(`${systemConfig.qccKey}${TimeSpan}${systemConfig.qccSecretKey}`).toUpperCase(),
Timespan:TimeSpan
};
let query:any = {};
if (isKeyNo == "isKeyNo") {
query = {
key:systemConfig.qccKey,
keyNo:uscc,
};
} else if (isKeyNo == "Id") {
query = {
key:systemConfig.qccKey,
id:uscc,
};
} else if (isKeyNo == "certId") {
query = {
key:systemConfig.qccKey,
certId:uscc,
};
} else if (isKeyNo == "企业名称") {
query = {
key:systemConfig.qccKey,
keyword:uscc,
}
} else {
query = {
key:systemConfig.qccKey,
searchKey:uscc,
// keyNo:"云合智网（上海）技术有限公司"
};
}
return {header, query};
}
/**
* 同步工商信息数据
* @param uscc
* @param eId
* @returns
*/
async function 工商信息(uscc) {
let {header, query} = getReqParam(uscc);
let 工商信息:any = await getQcc('https://api.qichacha.com/ECIInfoVerify/GetInfo', query, header);//获取工商信息
if (Object.keys(工商信息).length) {
let enterInfo = await enterpriseData.findEnterpriseByUscc(uscc);
let khsfsb = getReqParam(uscc);
let 客户身份识别:any = await getQcc('https://api.qichacha.com/CustomerDueDiligence/KYC', khsfsb.query, khsfsb.header);//获取工商信息
let TermEnd = "无固定期限";
if (工商信息.TermEnd) TermEnd = moment(工商信息.TermEnd).format("YYYY-MM-DD");
if (工商信息.OperName) {
enterInfo.legalPerson = 工商信息.OperName;
}
//企业基础信息
let guanWang = "";
if (工商信息.ContactInfo &&工商信息.ContactInfo.WebSite && 工商信息.ContactInfo.WebSite[0]) {
enterInfo.guanWang = 工商信息.ContactInfo.WebSite[0].Url || "";
}
if (客户身份识别.Data && 客户身份识别.Data.Scale) {
switch (客户身份识别.Data.Scale) {
case "L": enterInfo.qiYeGuiMo = configEnum.ENTERPRISESIZE.大型; break;
case "M": enterInfo.qiYeGuiMo = configEnum.ENTERPRISESIZE.中型; break;
case "S": enterInfo.qiYeGuiMo = configEnum.ENTERPRISESIZE.小型; break;
case "XS": enterInfo.qiYeGuiMo = configEnum.ENTERPRISESIZE.微型; break;
}
}
if (工商信息.Address) {
let logonAddressList = formatAddress(工商信息.Address); //解析注册地址
enterInfo.logonAddress = logonAddressList;
}
enterInfo.zhuCeHao = 工商信息.No;
enterInfo.zuZhiJiGouDaiMa = 工商信息.OrgNo;
enterInfo.logonTime = new Date(工商信息.StartDate).valueOf();
if (!enterInfo.jingYingFanWei) enterInfo.jingYingFanWei = 工商信息.Scope; //经营范围
/**
* 股权结构
*/
if (工商信息.Partners) {
let ownershipList = [];
工商信息.Partners.forEach(info => {
let addInfo:any = {
name:info.StockName,
finalBenefitPercent:info.FinalBenefitPercent,
stockPercent:info.StockPercent,
stockType:info.StockType,
realCapi:info.RealCapi,
paidUpCapitalUnit:info.PaidUpCapitalUnit,
subscribedCapital:info.SubscribedCapital,
subscribedCapitalUnit:info.SubscribedCapitalUnit,
};
// if (info.CapiDate) addInfo.capiDate = getMySqlMs(info.CapiDate);
// if (info.ShoudDate) addInfo.shoudDate = getMySqlMs(info.ShoudDate);
ownershipList.push(addInfo);
});
enterInfo.guQuanJieGou = ownershipList;
}
/**
* 企业标签表
*/
if (工商信息.TagList) {
for (let i = 0; i < 工商信息.TagList.length; i++) {
let info = 工商信息.TagList[i];
let {Type, Name} = info;
if (Name == "曾用名") continue
let labelInfo = await labelData.selectLabelOne({labelName:Name});
if (!labelInfo || !labelInfo.id) {
//添加
labelInfo = {
id:LABELTYPE.自定义标签,
labelName:Name,
ctMs:new Date().valueOf(),
goal:LABELGOAL.企业,
labelType:LABELTYPE.自定义标签, //todo
state:false
};
await labelData.createOneLabel(labelInfo);
}
let thisEnterpriseHaveLabel = false;
enterInfo.labels.forEach(itemLabelInfo => {
if (itemLabelInfo.labelId == labelInfo.id) thisEnterpriseHaveLabel = true;
})
if (!thisEnterpriseHaveLabel) enterInfo.labels.push({labelId:labelInfo.id, labelType:LABELTYPE.自定义标签, state:true});
}
}
await enterInfo.save();
} else {
console.log(`企查查获取不到该企业数据：${uscc}`);
}
}
/**
* 准入尽职调查
* 逻辑：增量更新
* @param uscc
* @returns
*/
async function 准入尽职调查(uscc) {
let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(uscc);
let {header, query} = getReqParam(uscc);
let qccselectdata:any = await getQcc('https://api.qichacha.com/AcctScan/GetInfo', query, header);
if (qccselectdata.Data) {
for (let i = 0; i < qccselectdata.Data.length; i++) {
let info = qccselectdata.Data[i];
let item = await enterpriseRiskData.findOnce({uscc, title:info.Title});
if (!item || !item.id) {
let addInfo:any = {
id:randomId(TABLEID.准入尽职调查),
uscc,
enterpriseName:enterpriseInfo.name,
title:info.Title,
description:info.Description,
passage:info.Passage,
riskType:info.RiskType,
};
if (info.TypeCode) addInfo.typeCode = parseInt(info.TypeCode);
await enterpriseRiskData.createDataByParam(addInfo);
}
}
}
}
/**
* 失信核查
* 逻辑：全量更新 删除之前所有的 再添加
* @param uscc
* @returns
*/
async function 失信核查(uscc) {
let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(uscc);
let {header, query} = getReqParam(uscc);
let qccselectdata:any = await getQcc('https://api.qichacha.com/ShixinCheck/GetList', query, header);
await dishonestPersonData.removeMany({uscc});
if (qccselectdata.Data) {
let addList = [];
qccselectdata.Data.forEach(info => {
let addInfo:any = {
id:randomId(TABLEID.失信核查),
uscc,
enterpriseName:enterpriseInfo.name,
anno:info.Anno,
executegov:info.Executegov,
executestatus:info.Executestatus,
executeno:info.Executeno,
actionRemark:info.ActionRemark,
amount:info.Amount,
};
addList.push(addInfo);
});
await dishonestPersonData.addMany(addList);
}
}
/**
* 严重违法核查
* 逻辑：全量更新 删除之前所有的 再添加
* @param uscc
* @returns
*/
async function 严重违法核查(uscc) {
let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(uscc);
let {header, query} = getReqParam(uscc);
let qccselectdata:any = await getQcc('https://api.qichacha.com/SeriousIllegalCheck/GetList', query, header);
await illegalityData.removeMany({uscc});
if (qccselectdata.Data) {
let addList = [];
qccselectdata.Data.forEach(info => {
let addInfo:any = {
id:randomId(TABLEID.严重违法核查),
uscc,
enterpriseName:enterpriseInfo.name,
type:info.Type,
addReason:info.AddReason,
addOffice:info.AddOffice,
removeReason:info.RemoveReason,
removeOffice:info.RemoveOffice,
};
addList.push(addInfo);
});
await illegalityData.addMany(addList);
}
}
/**
* 科创分
* 有则更新，无则添加
* @param uscc
* @returns
*/
async function 科创分(uscc) {
let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(uscc);
let {header, query} = getReqParam(uscc);
let qccselectdata:any = await getQcc('https://api.qichacha.com/TechScore/GetInfo', query, header);
if (qccselectdata.Data) {
let kcf = {
industry:qccselectdata.Data.Industry.Industry,
subIndustry:qccselectdata.Data.Industry.SubIndustry,
industryRanking:qccselectdata.Data.IndustryRanking,
score:qccselectdata.Data.Score,
};
enterpriseInfo.kcf = kcf;
}
}
async function 资质证书详情查询(id) {
let {header, query} = getReqParam(id, "certId");
let qccselectdata:any = await getQcc('https://api.qichacha.com/ECICertification/GetCertificationDetailById', query, header);
return qccselectdata;
}
async function 资质证书查询(uscc) {
let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(uscc);
let {header, query} = getReqParam(uscc);
let qccselectdata:any = await getQcc('https://api.qichacha.com/ECICertification/SearchCertification', query, header);
await qualificationsData.removeMany({uscc});
if (Array.isArray(qccselectdata)) {
let addList = [];
for (let i = 0; i < qccselectdata.length; i++) {
let qcc资质证书详情 = {};
let info = qccselectdata[i];
let qcc资质证书Id = info.Id;
qccselectdata[i]["qcc资质证书详情"] = await 资质证书详情查询(qcc资质证书Id);
}
qccselectdata.forEach(info => {
let addInfo:any = {
uscc,
enterpriseName:enterpriseInfo.name,
id:randomId('qua'),
name:info.Name,
type:info.Type,
no:info.No,
typeDesc:info.TypeDesc,
institutionList:info.InstitutionList ? info.InstitutionList[0] :"",
status:info.Status,
};
if (info.StartDate) addInfo.startDate = new Date(info.StartDate).valueOf();
if (info.EndDate) addInfo.endDate = new Date(info.EndDate).valueOf();
addList.push(addInfo);
});
await qualificationsData.addMany( addList);
}
return qccselectdata;
}
src/biz/track.ts 0 → 100644
/**
* 企业服务追踪
*/
import * as verificationEnumTools from "../util/verificationEnum";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as trackData from "../data/track";
import { checkChange, extractData } from "../util/piecemeal";
import * as splitResultConfig from '../config/splitResultConfig';
import { eccFormParam } from "../util/verificationParam";
import { TrackAddConfig, TrackDetailsAddConfig, TrackDetailsUpdateConfig, TrackUpdateConfig } from "../config/eccParam/admin";
import { randomId } from "../tools/system";
import { TABLEID } from "../config/enum/dbEnum";
import { BizError } from "../util/bizError";
import { ERRORENUM } from "../config/errorEnum";
import moment from "moment";
/**
* 服务追踪-列表
* @param name 企业名称
* @param demand 需求类型
* @param trackType 需求跟进状态
* @param page 页
* @returns
*/
export async function trackList(name:string, demand:number, trackType:number, page:number) {
let selectParam:any = {};
if (name) {
selectParam.name = {"$regex":`${name}`};
}
if (demand) {
selectParam.demand = demand;
}
if (trackType) {
selectParam.trackType = trackType;
}
/**需要用到的查询数据 */
let trackDbList = await trackData.findTrackListToPage(selectParam, (page - 1) * 10);
let count = await trackData.findTrackCount(selectParam);//符合查询条件的数据总数
/**组合返回结果 */
let dataList = [];
trackDbList.forEach( info => {
/**截取返回数据 */
let changeData:any = extractData(splitResultConfig.trackListConfig, info, true);
/**将枚举值转为字符 */
changeData.demand = verificationEnumTools.changeEnumValue(configEnum.VISITDEMAND, changeData.demand);
changeData.trackType = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, changeData.trackType);
/**获取最新一条需求追踪详情 */
if (info.details && info.details.length > 0) {
let detailsInfo = getLatestFollowUpRecord(info.details);
changeData.followUpName = detailsInfo.followUpName; //跟进人
changeData.followUpTime = moment(detailsInfo.followUpTime).format("YYYY-MM-DD"); //跟进时间
changeData.followUpDsc = detailsInfo.followUpDsc; //跟进详情
}
dataList.push(changeData);
})
return {count, dataList};
}
/**
* 服务追踪-新增
* @param param
*/
export async function trackCreate(param) {
/**校验表单参数 */
eccFormParam("管理后台新增服务追踪", TrackAddConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台新增服务追踪', 'demand', configEnum.VISITDEMAND, param.demand);
//服务追踪详情
let details = [];
if (param.details && param.details.length > 0) {
/**校验表单详情参数 */
param.details.forEach( info => {
eccFormParam("管理后台新增服务追踪记录详情", TrackDetailsAddConfig, info);
let item = {
tdid: randomId(TABLEID.需求跟踪详情),
followUpName: info.followUpName,
followUpTime: info.followUpTime,
followUpDsc: info.followUpDsc,
followUpStatus: info.followUpStatus,
}
details.push(item)
})
}
/**
* 需求跟进状态需要获取服务追踪详情内最新一条的跟进状态followUpStatus
*/
let trackType = configEnum.TRACKTYPE.未解决;
if (param.details && param.details.length > 0) {
let latestRecord = getLatestFollowUpRecord(details);
trackType = latestRecord.followUpStatus;
}
let trackInfo = {
id: randomId(TABLEID.企业需求表),
uscc: param.uscc,
name: param.name,
demand: param.demand,
content: param.content,
contact: param.contact,
contactUs: param.contactUs,
trackType,
createTime: param.createTime, //new Date().valueOf(),
details,
}
await trackData.createDataByParam(trackInfo);
return {isSuccess:true};
}
/**
* 获取服务追踪详情最新记录
* @param details
* @returns
*/
function getLatestFollowUpRecord(details) {
if (!details || details.length === 0) return null;
return details.reduce((prev, current) =>
prev.followUpTime > current.followUpTime ? prev : current
);
}
/**
* 服务追踪-回显
* @param uscc
*/
export async function trackInfo(id:string) {
/**校验企业 */
let trackDbInfo = await trackData.findTrackByParam({id});
if (!trackDbInfo || !trackDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个服务追踪`);
//服务追踪详情
let details = [];
if (trackDbInfo.details && trackDbInfo.details.length > 0) {
trackDbInfo.details.forEach( info => {
let item = {
tdid: info.tdid,
followUpName: info.followUpName,
followUpTime: info.followUpTime,
followUpDsc: info.followUpDsc,
followUpStatus: info.followUpStatus,
}
details.push(item)
})
}
let dataInfo = {
id:trackDbInfo.id,
uscc: trackDbInfo.uscc,
name: trackDbInfo.name,
demand: trackDbInfo.demand,
content: trackDbInfo.content,
contact: trackDbInfo.contact,
contactUs: trackDbInfo.contactUs,
trackType: trackDbInfo.trackType,
createTime: trackDbInfo.createTime,
details,
};
return {dataInfo};
}
/**
* 服务追踪详情-回显
* @param uscc
*/
export async function trackDetailsInfo(tdid:string) {
/**校验服务追踪详情 */
let selectParam = {details: {"$elemMatch":{tdid:{"$in":tdid} } } };
let trackDbInfo = await trackData.findTrackByParam(selectParam);
if (!trackDbInfo || !trackDbInfo.details || !trackDbInfo.details[0].tdid) throw new BizError(ERRORENUM.未找到数据, `库中不存在tdid=${tdid}这个服务追踪`);
//服务追踪详情
let details = trackDbInfo.details[0];
let dataInfo = {
tdid: details.tdid,
followUpName: details.followUpName,
followUpTime: details.followUpTime,
followUpDsc: details.followUpDsc,
followUpStatus: details.followUpStatus,
}
return {dataInfo};
}
/**
* 服务追踪-修改
* @param uscc
* @param param
*/
export async function trackUpdate(id:string, param) {
/**校验表单参数 */
eccFormParam("管理后台修改服务追踪企业", TrackUpdateConfig, param);
/**校验枚举 */
verificationEnumTools.eccEnumValue('管理后台修改服务追踪企业', 'demand', configEnum.VISITDEMAND, param.demand);
//服务追踪详情
let details = [];
if (param.details && param.details.length > 0) {
/**校验表单详情参数 */
param.details.forEach( info => {
eccFormParam("管理后台新增服务追踪记录详情", TrackDetailsUpdateConfig, info);
verificationEnumTools.eccEnumValue('管理后台修改服务追踪企业', 'followUpStatus', configEnum.TRACKTYPE, info.followUpStatus);
let item = {
tdid: randomId(TABLEID.需求跟踪详情),
followUpName: info.followUpName,
followUpTime: info.followUpTime,
followUpDsc: info.followUpDsc,
followUpStatus: info.followUpStatus,
}
details.push(item)
})
}
/**校验企业 */
let trackDbInfo = await trackData.findTrackByParam({id});
if (!trackDbInfo || !trackDbInfo.id) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
/**
* 需求跟进状态需要获取服务追踪详情内最新一条的跟进状态followUpStatus
*/
if (param.details && param.details.length > 0) {
let latestRecord = getLatestFollowUpRecord(details);
trackDbInfo.trackType = latestRecord.followUpStatus;
}
/**修改字段 */
let changeList = checkChange(param, trackDbInfo);
if (!changeList.length) throw new BizError(ERRORENUM.数据无更新, `${param.name}数据无更新`);
changeList.forEach(key => {
trackDbInfo[key] = param[key];
});
await trackDbInfo.save();
return {isSuccess:true};
}
/**
* 服务追踪-删除
* @param id
*/
export async function trackDelete(id:string) {
let trackDbInfo = await trackData.findTrackByParam({id});
if (!trackDbInfo || !trackDbInfo.name) throw new BizError(ERRORENUM.未找到数据, `库中不存在id=${id}这个企业`);
await trackData.removeOneData(id);
return {isSuccess:true};
}
/**
* 导出服务追踪信息列表
* @param name 企业名称
* @param demand 需求类型
* @param trackType 需求跟进状态
* @returns 二维数组，第一行为表头，后续行为数据
*/
export async function outPutTrackData(name: string, demand: number, trackType: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (name) {
selectParam.name = { "$regex": `${name}` };
}
if (demand) {
selectParam.demand = demand;
}
if (trackType) {
selectParam.trackType = trackType;
}
/** 查询服务追踪数据 */
let trackDbList = await trackData.findTrackListByParam(selectParam);
/** 表头定义 */
const titleList = [
"企业名称",
"统一社会信用代码",
"需求类型",
"需求内容",
"联系人",
"联系方式",
"需求跟进状态",
"创建时间",
"最新跟进人",
"最新跟进时间",
"最新跟进详情",
"最新跟进状态",
"总跟进次数"
];
let dataList = [titleList]; // 第一行为表头
trackDbList.forEach(info => {
/** 提取数据 */
let changeData: any = extractData(splitResultConfig.trackListConfig, info, true);
/** 枚举值转文本 */
changeData.demand = verificationEnumTools.changeEnumValue(configEnum.VISITDEMAND, changeData.demand) || "未选择";
changeData.trackType = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, changeData.trackType) || "未选择";
/** 时间格式化 */
changeData.createTime = changeData.createTime ? moment(changeData.createTime).format("YYYY-MM-DD") : "-";
/** 处理跟进详情 */
let latestFollowUpName = "-";
let latestFollowUpTime = "-";
let latestFollowUpDsc = "-";
let latestFollowUpStatus = "-";
let followUpCount = 0;
if (info.details && info.details.length > 0) {
// 获取最新跟进记录
let latestRecord = getLatestFollowUpRecord(info.details);
if (latestRecord) {
latestFollowUpName = latestRecord.followUpName || "-";
latestFollowUpTime = latestRecord.followUpTime ? moment(latestRecord.followUpTime).format("YYYY-MM-DD") : "-";
latestFollowUpDsc = latestRecord.followUpDsc || "-";
latestFollowUpStatus = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, latestRecord.followUpStatus) || "-";
}
// 跟进次数
followUpCount = info.details.length;
}
/** 生成一行数据 */
let row = [
changeData.name || "-",
changeData.uscc || "-",
changeData.demand,
changeData.content || "-",
changeData.contact || "-",
changeData.contactUs || "-",
changeData.trackType,
changeData.createTime,
latestFollowUpName,
latestFollowUpTime,
latestFollowUpDsc,
latestFollowUpStatus,
followUpCount.toString()
];
dataList.push(row);
});
return dataList;
}
/**
* 导出服务追踪详细信息（空行分隔不同企业）
* @param name 企业名称
* @param demand 需求类型
* @param trackType 需求跟进状态
* @returns 二维数组，第一行为表头，后续行为数据（空行分隔）
*/
export async function outPutTrackDetailsData(name: string, demand: number, trackType: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (name) {
selectParam.name = { "$regex": `${name}` };
}
if (demand) {
selectParam.demand = demand;
}
if (trackType) {
selectParam.trackType = trackType;
}
/** 查询服务追踪数据 */
let trackDbList = await trackData.findTrackListByParam(selectParam);
/** 表头定义 */
const titleList = [
"企业名称",
"统一社会信用代码",
"需求类型",
"需求内容",
"联系人",
"联系方式",
"需求创建时间",
"当前跟进状态",
"跟进人",
"跟进时间",
"跟进详情",
"跟进状态",
// "跟进记录ID"
];
let dataList = [titleList]; // 第一行为表头
/** 处理每个企业的跟踪记录 */
trackDbList.forEach((info, enterpriseIndex) => {
/** 提取基础数据 */
let changeData: any = extractData(splitResultConfig.trackListConfig, info, true);
/** 枚举值转文本 */
const demandText = verificationEnumTools.changeEnumValue(configEnum.VISITDEMAND, changeData.demand) || "未选择";
const currentTrackType = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, changeData.trackType) || "未选择";
/** 时间格式化 */
const createTime = changeData.createTime ? moment(changeData.createTime).format("YYYY-MM-DD") : "-";
/** 在企业记录前添加空行（除了第一个企业） */
if (enterpriseIndex > 0) {
dataList.push(new Array(titleList.length).fill(""));
}
/** 处理跟进详情 */
if (info.details && info.details.length > 0) {
// 按跟进时间倒序排列，最新的在前
const sortedDetails = [...info.details].sort((a, b) =>
moment(b.followUpTime).valueOf() - moment(a.followUpTime).valueOf()
);
sortedDetails.forEach((detail, detailIndex) => {
const followUpStatus = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, detail.followUpStatus) || "未选择";
const followUpTime = detail.followUpTime ? moment(detail.followUpTime).format("YYYY-MM-DD") : "-";
/** 生成一行数据 */
let row = [
// 只在第一条记录显示企业信息，后续记录留空（Excel可以合并单元格）
detailIndex === 0 ? changeData.name || "-" : "",
detailIndex === 0 ? changeData.uscc || "-" : "",
detailIndex === 0 ? demandText : "",
detailIndex === 0 ? changeData.content || "-" : "",
detailIndex === 0 ? changeData.contact || "-" : "",
detailIndex === 0 ? changeData.contactUs || "-" : "",
detailIndex === 0 ? createTime : "",
detailIndex === 0 ? currentTrackType : "",
detail.followUpName || "-",
followUpTime,
detail.followUpDsc || "-",
followUpStatus,
// detail.tdid || "-"
];
dataList.push(row);
});
} else {
/** 如果没有跟进记录，显示一行基础数据 */
let row = [
changeData.name || "-",
changeData.uscc || "-",
demandText,
changeData.content || "-",
changeData.contact || "-",
changeData.contactUs || "-",
createTime,
currentTrackType,
"-",
"-",
"-",
"-",
// "-"
];
dataList.push(row);
}
});
return dataList;
}
/**
* 导出服务追踪信息（简化版，明确分隔）
* @param name 企业名称
* @param demand 需求类型
* @param trackType 需求跟进状态
* @returns 二维数组，明确分隔不同企业
*/
export async function outPutTrackSimpleData(name: string, demand: number, trackType: number) {
/** 拼接查询条件 */
let selectParam: any = {};
if (name) {
selectParam.name = { "$regex": `${name}` };
}
if (demand) {
selectParam.demand = demand;
}
if (trackType) {
selectParam.trackType = trackType;
}
/** 查询服务追踪数据 */
let trackDbList = await trackData.findTrackListByParam(selectParam);
/** 表头定义 */
const titleList = [
"企业名称",
"统一社会信用代码",
"需求类型",
"需求内容",
"联系人",
"联系方式",
"需求创建时间",
"当前跟进状态",
"跟进人",
"跟进时间",
"跟进详情",
"跟进状态"
];
let dataList = [titleList];
/** 处理每个企业 */
trackDbList.forEach((info, enterpriseIndex) => {
/** 提取基础数据 */
let changeData: any = extractData(splitResultConfig.trackListConfig, info, true);
/** 枚举值转文本 */
const demandText = verificationEnumTools.changeEnumValue(configEnum.VISITDEMAND, changeData.demand) || "未选择";
const currentTrackType = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, changeData.trackType) || "未选择";
/** 时间格式化 */
const createTime = changeData.createTime ? moment(changeData.createTime).format("YYYY-MM-DD") : "-";
/** 添加分隔行（除了第一个企业） */
if (enterpriseIndex > 0) {
dataList.push(new Array(titleList.length).fill(""));
}
/** 处理跟进详情 */
if (info.details && info.details.length > 0) {
// 按跟进时间倒序排列，最新的在前
const sortedDetails = [...info.details].sort((a, b) =>
moment(b.followUpTime).valueOf() - moment(a.followUpTime).valueOf()
);
sortedDetails.forEach((detail) => {
const followUpStatus = verificationEnumTools.changeEnumValue(configEnum.TRACKTYPE, detail.followUpStatus) || "未选择";
const followUpTime = detail.followUpTime ? moment(detail.followUpTime).format("YYYY-MM-DD") : "-";
/** 每行都显示完整信息 */
let row = [
changeData.name || "-",
changeData.uscc || "-",
demandText,
changeData.content || "-",
changeData.contact || "-",
changeData.contactUs || "-",
createTime,
currentTrackType,
detail.followUpName || "-",
followUpTime,
detail.followUpDsc || "-",
followUpStatus
];
dataList.push(row);
});
} else {
/** 如果没有跟进记录 */
let row = [
changeData.name || "-",
changeData.uscc || "-",
demandText,
changeData.content || "-",
changeData.contact || "-",
changeData.contactUs || "-",
createTime,
currentTrackType,
"-",
"-",
"-",
"-"
];
dataList.push(row);
}
});
return dataList;
}
src/config/eccParam/admin.ts 0 → 100644
/**
* 校验表单参数配置 【管理后台端】
* 使用场景： 验证客户端请求参数
* 限制： 1.使用端不同不能共用一份配置
* 2.需要搭配 util/verificationParam -> eccFormParam() 方法使用
* 说明: notMustHave = true 时说明该字段是非必填的;不配该字段说明是必填的
*/
/**
* 使用端: 管理后台
* 场景: 新增管理员用户
* 备注: 所有参数为必填
*/
export const AdminUserAddConfig = {
loginId:{type:"String"}, //登录账号
name:{type:"String"}, //名称
pwd:{type:"String"}, //密码
};
/**
* 使用端: 管理后台
* 场景: 新增在谈在跟企业
* 备注: 所有参数为必填
*/
export const NegotiationAddConfig = {
name:{type:"String"}, //企业名称
industry:{type:"[Number]"}, //行业领域
registrationStatus:{type:"Number"}, //推进、注册情况
progressStatus:{type:"Number"}, //进展情况
primaryContact:{type:"String"}, //负责人、首谈人
contactDepartment:{type:"String"}, //对接部门
};
/**
* 使用端: 管理后台
* 场景: 修改在谈在跟企业
* 备注:
*/
export const NegotiationUpdateConfig = {
name:{type:"String"}, //企业名称
industry:{type:"[Number]"}, //行业领域
registrationStatus:{type:"Number"}, //推进、注册情况
progressStatus:{type:"Number"}, //进展情况
primaryContact:{type:"String"}, //负责人、首谈人
contactDepartment:{type:"String"}, //对接部门
};
/**
* 使用端: 管理后台
* 场景: 新增企业建档
* 备注: 所有参数为必填
*/
export const EnterpriseAddConfig = {
name:{type:"String"}, //企业名称
uscc:{type:"String"}, //统一信用代码
logonAddress:{type:"[String]"}, //企业注册地址 ["所属省份", "所属城市", "所属区县", "详细地址"]
logonTime:{type:"Number"}, //注册时间、成立时间
parkEntryTime:{type:'Number'}, //入驻园区时间
labels:{type:"[String]"}, //企业标签
// industryCategoryGb:{type:"String"}, //国标行业门类
industry:{type:"[Number]"}, //行业领域
property:{type:"Number"}, //企业所属物业
enterpriseNature:{type:"Number"}, //企业性质
leasedArea:{type:"Number"}, //租赁面积（㎡）
RAS:{type:"Number"}, //登记状态
jingYingFanWei:{type:"String"}, //经营范围
legalPerson:{type:"String"}, //法人
zhuceziben:{type:"String"}, //注册资本
dianHua:{type:"String"}, //电话
};
/**
* 使用端: 管理后台
* 场景: 修改企业建档
* 备注: 所有参数为必填
*/
export const EnterpriseUpdateConfig = {
name:{type:"String"}, //企业名称
uscc:{type:"String"}, //统一信用代码
logonAddress:{type:"[String]"}, //企业注册地址 ["所属省份", "所属城市", "所属区县", "详细地址"]
logonTime:{type:"Number"}, //注册时间、成立时间
parkEntryTime:{type:'Number'}, //入驻园区时间
labels:{type:"[String]"}, //企业标签
industry:{type:"[Number]"}, //行业领域
property:{type:"Number"}, //企业所属物业
enterpriseNature:{type:"Number"}, //企业性质
leasedArea:{type:"Number"}, //租赁面积（㎡）
RAS:{type:"Number"}, //登记状态
jingYingFanWei:{type:"String"}, //经营范围
legalPerson:{type:"String"}, //法人
zhuceziben:{type:"String"}, //注册资本
dianHua:{type:"String"}, //电话
};
/**
* 使用端: 管理后台
* 场景: 新增企业经营数据
* 备注: 所有参数为必填
*/
export const ManageAddConfig = {
uscc:{type:"String"}, //统一信用代码
name:{type:"String"}, //企业名称
year:{type:"Number"}, //数据年度
period:{type:"Number"}, //数据时间 PERIOD 上半年(1-6月)、下半年(7-12月)、全年
BI:{type:"Number"}, //营业收入(万元)
VAT:{type:"Number"}, //企业增值税(万元)
CIT:{type:"Number"}, //企业所得税(万元)
PIT:{type:"Number"}, //个人所得税(万元)
RD:{type:"Number"}, //研发投入(万元)
};
/**
* 使用端: 管理后台
* 场景: 修改企业经营数据
* 备注:
*/
export const ManageUpdateConfig = {
uscc:{type:"String"}, //统一信用代码
name:{type:"String"}, //企业名称
year:{type:"Number"}, //数据年度
period:{type:"Number"}, //数据时间 PERIOD 上半年(1-6月)、下半年(7-12月)、全年
BI:{type:"Number"}, //营业收入(万元)
VAT:{type:"Number"}, //企业增值税(万元)
CIT:{type:"Number"}, //企业所得税(万元)
PIT:{type:"Number"}, //个人所得税(万元)
RD:{type:"Number"}, //研发投入(万元)
};
/**
* 使用端: 管理后台
* 场景: 新增企业服务追踪
* 备注: 所有参数为必填
*/
export const TrackAddConfig = {
uscc:{type:"String"}, //统一信用代码
name:{type:"String"}, //企业名称
demand:{type:"Number"}, //需求类型
content:{type:"String"}, //需求描述
contact:{type:"String"}, //企业联系人
contactUs:{type:"String"}, //企业联系方式
// trackType:{type:"Number"}, //需求跟进状态 同步详情记录的跟进状态
createTime:{type:"Number"}, //创建服务追踪时间
details:{type:"Array"}, //服务追踪记录
};
/**
* 使用端: 管理后台
* 场景: 新增企业服务追踪-详情记录
* 备注: 所有参数为必填
*/
export const TrackDetailsAddConfig = {
followUpName:{type:"String"}, //跟进人
followUpTime:{type:"Number"}, //跟进时间
followUpDsc:{type:"String"}, //跟进详情
followUpStatus:{type:"Number"}, //跟进状态
};
/**
* 使用端: 管理后台
* 场景: 修改企业服务追踪
* 备注:
*/
export const TrackUpdateConfig = {
uscc:{type:"String"}, //统一信用代码
name:{type:"String"}, //企业名称
demand:{type:"Number"}, //需求类型
content:{type:"String"}, //需求描述
contact:{type:"String"}, //企业联系人
contactUs:{type:"String"}, //企业联系方式
// trackType:{type:"Number"}, //需求跟进状态 同步详情记录的跟进状态
createTime:{type:"Number"}, //创建服务追踪时间
details:{type:"Array"}, //服务追踪记录
};
/**
* 使用端: 管理后台
* 场景: 修改企业服务追踪-详情记录
* 备注: 所有参数为必填
*/
export const TrackDetailsUpdateConfig = {
followUpName:{type:"String"}, //跟进人
followUpTime:{type:"Number"}, //跟进时间
followUpDsc:{type:"String"}, //跟进详情
followUpStatus:{type:"Number"}, //跟进状态
};
/**
* 使用端: 管理后台
* 场景: 新增园区活动数据
* 备注: 所有参数为必填
*/
export const ActivityAddConfig = {
title:{type:"String"}, //活动标题
state:{type:"Number"}, //活动状态
startTime:{type:"Number"}, //活动开始时间
endTime:{type:"Number"}, //活动结束时间
target:{type:"[Number]"}, //活动类型
location:{type:"String"}, //活动地点
desc:{type:"String"}, //活动详情
};
/**
* 使用端: 管理后台
* 场景: 修改园区活动数据
* 备注:
*/
export const ActivityUpdateConfig = {
title:{type:"String"}, //活动标题
state:{type:"Number"}, //活动状态
startTime:{type:"Number"}, //活动开始时间
endTime:{type:"Number"}, //活动结束时间
target:{type:"[Number]"}, //活动类型
location:{type:"String"}, //活动地点
desc:{type:"String"}, //活动详情
};
/**
* 使用端: 管理后台
* 场景: 新增政策数据
* 备注: 所有参数为必填
*/
export const PolicyAddConfig = {
title:{type:"String"}, //政策名称
policyType:{type:"Number"}, //政策类型
startTime:{type:"Number"}, //政策开始时间
endTime:{type:"Number"}, //政策结束时间
source:{type:"String"}, //来源，发布单位
desc:{type:"String"}, //政策详情
};
/**
* 使用端: 管理后台
* 场景: 修改政策数据
* 备注:
*/
export const PolicyUpdateConfig = {
title:{type:"String"}, //政策名称
policyType:{type:"Number"}, //政策类型
startTime:{type:"Number"}, //政策开始时间
endTime:{type:"Number"}, //政策结束时间
source:{type:"String"}, //来源，发布单位
desc:{type:"String"}, //政策详情
};
src/config/eccParam/enterprise.ts 0 → 100644
/**
* 校验表单参数配置 【小程序】【企业】
* 使用场景： 验证客户端请求参数
* 限制： 1.使用端不同不能共用一份配置
* 2.需要搭配 util/verificationParam -> eccFormParam() 方法使用
* 说明: notMustHave = true 时说明该字段是非必填的;不配该字段说明是必填的
*/
/**
* 使用端: 小程序端【企业入口】
* 场景: 创建新的融资信息
* 备注: 所有参数为必填
*/
export const EnterpriseCreateFinancingDataConfig = {
financingRounds:{type:"Number"},//融资轮次
financingAmount:{type:"Number"}, //融资金额_单位 万元
investmentInstitutionsName:{type:"String"},//投资机构名称
timeToObtainInvestment:{type:"Number"},//获得投资时间时间戳
fuHuaQiInvestment:{type:"Boolean"},//孵化器是否投资
fuHuaQiInvestmentAmount:{type:"Number"},//孵化器投资金额_单位 万元
fuHuaQiInvestmentStyle:{type:"Number"},//孵化器投资方式
}
src/config/enum.ts 0 → 100644
/**
* 导入相关
*/
export enum UpExcelNameType {
在谈在跟 = 1,
全部企业 = 2,
// "100平方公里" = 3,
// "3.73平方公里" = 4,
// 软件关联入驻企业 = 5,
// 小台账企业 = 6,
// 重点稳商企业 = 7,
经营数据 = 8,
// 企业服务追踪 = 9,
// 园区活动 = 10,
// 企业政策 = 11,
}
export enum STATE {
否 = 0,
是 = 1,
}
/**
* 登记状态
*/
export enum RAS {
续存 = 1,
注销 = 2
}
/**
* 企业规模
*/
export enum ENTERPRISESIZE {
未知 = 0,
大型,
中型,
小型,
微型
}
/**
* 纳税人资质
*/
export enum NASHUIRENZIZHI {
未知 = 0,
小规模纳税人,
一般纳税人,
增值税一般纳税人
}
/**
* 活动状态
*/
export enum ACTIVITYSTATE {
未开始 = 1,
活动中,
已结束,
}
/**
* 活动类型
*/
export enum ACTIVITYTARGET {
资金 = 1,
政策,
人才服务
}
/**
* 推进、注册情况
*/
export enum REGISTRATIONSTATUS {
洽谈中 = 1,
已注册,
已入驻,
已终止,
}
/**
* 进展情况
*/
export enum PROGRESSSTATUS {
初次接触 = 1,
深度洽谈,
协议草拟,
协议签订,
项目落地,
}
/**
* 经营填报报告时间
*/
export enum PERIOD {
上半年 = 1,
下半年,
全年,
}
/**
* 需求类型
*/
export enum VISITDEMAND {
技术 =1,
资金,
政策,
市场,
基础服务,
人才服务,
知识产权,
法律,
其他
}
/**
* 需求跟进状态
*/
export enum TRACKTYPE {
未解决 = 1,
已解决
}
/**
* 政策类型
*/
export enum POLICYTYPE {
财政补贴 = 1,
资质申报,
政策扶持
}
src/config/enum/dbEnum.ts 0 → 100644
export enum TABLEID {
活动 = 'ac',
企业基础信息表 = 'en',
企业标签表 = "el",
企业经营数据 = 'ma',
在跟在谈 = 'ne',
政策 = 'po',
企业需求表 = 'tr',
需求跟踪详情 = 'trd',
准入尽职调查 = 'risk',
失信核查 = 'dis',
严重违法核查 = 'ill',
资质证书查询 = 'qua',
}
src/config/enum/industryEnum.ts 0 → 100644
/**
* 国标行业门类 industryCategoryGb
*/
export enum INDUSTRY {
"农、林、牧、渔业" = "A",
"采矿业" = "B",
"制造业" = "C",
"电力、热力、燃气及水生产和供应业" = "D",
"建筑业" = "E",
"批发和零售业" = "F",
"交通运输、仓储和邮政业" = "G",
"住宿和餐饮业" = "H",
"信息传输、软件和信息技术服务业" = "I",
"金融业" = "J",
"房地产业" = "K",
"租赁和商务服务业" = "L",
"科学研究和技术服务业" = "M",
"水利、环境和公共设施管理业" = "N",
"居民服务、修理和其他服务业" = "O",
"教育" = "P",
"卫生和社会工作" = "Q",
"文化、体育和娱乐业" = "R",
"公共管理、社会保障和社会组织" = "S",
"国际组织" = "T",
}
// ----------------------国标行业大类-----------------------
/**
* 行业领域
*/
export enum ALLINDUSTRY {
农业 = 1,
林业 = 2,
畜牧业 = 3,
渔业 = 4,
"农、林、牧、渔专业及辅助性活动" = 5,
煤炭开采和洗选业 = 6,
石油和天然气开采业 = 7,
黑色金属矿采选业 = 8,
有色金属矿采选业 = 9,
非金属矿采选业 = 10,
开采专业及辅助性活动 = 11,
其他采矿业 = 12,
"农副食品加工业" = 13,
"食品制造业" = 14 ,
"酒、饮料及精制茶制造业" = 15,
"烟草制品业" = 16,
"纺织业" = 17,
"纺织服装、服饰业" = 18,
"皮革、毛皮、羽毛及其制品和制鞋业" = 19,
"木材加工和木、竹、藤、棕、草制品业" = 20,
"家具制造业" = 21,
"造纸和纸制品业" = 22,
"印刷和记录媒介复制业" = 23,
"文教、工美、体育和娱乐用品制造业" = 24,
"石油、煤炭及其他燃料加工业" = 25,
"化学原料和化学制品制造业" = 26,
"医药制造业" = 27,
"化学纤维制造业" = 28,
"橡胶和塑料制品业" = 29,
"非金属矿物制品业" = 30,
"黑色金属冶炼和压延加工业" = 31,
"有色金属冶炼和压延加工业" = 32,
"金属制品业" = 33,
"通用设备制造业" = 34,
"专用设备制造业" = 35,
"汽车制造业" = 36,
"铁路、船舶、航空航天和其他运输设备制造业" = 37,
"电气机械和器材制造业" = 38,
"计算机、通信和其他电子设备制造业" = 39,
"仪器仪表制造业" = 40,
"其他制造业" = 41,
"废弃资源综合利用业" = 42,
"金属制品、机械和设备修理业" = 43,
"电力、热力生产和供应业" = 44,
"燃气生产和供应业" = 45,
"水的生产和供应业" = 46,
"房屋建筑业" = 47,
"土木工程建筑业" = 48,
"建筑安装业" = 49,
"建筑装饰、装修和其他建筑业" = 50,
批发业 = 51,
零售业 = 52,
铁路运输业 = 53,
道路运输业 = 54,
水上运输业 = 55,
航空运输业 = 56,
管道运输业 = 57,
多式联运和运输代理业 = 58,
装卸搬运和仓储业 = 59,
邮政业 = 60,
住宿业 = 61,
餐饮业 = 62,
"电信、广播电视和卫星传输服务" = 63,
"互联网和相关服务" = 64,
"软件和信息技术服务业" = 65,
货币金融服务 = 66,
资本市场服务 = 67,
保险业 = 68,
其他金融业 = 69,
房地产业 = 70,
租赁业 = 71,
商务服务业 = 72,
研究和试验发展 = 73,
专业技术服务业 = 74,
科技推广和应用服务业 = 75,
水利管理业 = 76,
生态保护和环境治理业 = 77,
公共设施管理业 = 78,
土地管理业 = 79,
"居民服务业" = 80,
"机动车、电子产品和日用产品修理业" = 81,
"其他服务业" = 82,
教育 = 83,
卫生 = 84,
社会工作 = 85,
"新闻和出版业" = 86,
"广播、电视、电影和录音制作业" = 87,
"文化艺术业" = 88,
"体育" = 89,
"娱乐业" = 90,
"中国共产党机关" = 91,
"国家机构" = 92,
"人民政协、民主党派" = 93,
"社会保障" = 94,
"群众团体、社会团体和其他成员组织" = 95,
"基层群众自治组织及其他组织" = 96,
国际组织 = 97
}
/**
* 农、林、牧、渔业
*/
export enum A {
农业 = 1,
林业 = 2,
畜牧业 = 3,
渔业 = 4,
"农、林、牧、渔专业及辅助性活动" = 5,
}
/**
* 采矿业
*/
export enum B {
煤炭开采和洗选业 = 6,
石油和天然气开采业 = 7,
黑色金属矿采选业 = 8,
有色金属矿采选业 = 9,
非金属矿采选业 = 10,
开采专业及辅助性活动 = 11,
其他采矿业 = 12,
}
/**
* 制造业
*/
export enum C {
"农副食品加工业" = 13,
"食品制造业" = 14 ,
"酒、饮料及精制茶制造业" = 15,
"烟草制品业" = 16,
"纺织业" = 17,
"纺织服装、服饰业" = 18,
"皮革、毛皮、羽毛及其制品和制鞋业" = 19,
"木材加工和木、竹、藤、棕、草制品业" = 20,
"家具制造业" = 21,
"造纸和纸制品业" = 22,
"印刷和记录媒介复制业" = 23,
"文教、工美、体育和娱乐用品制造业" = 24,
"石油、煤炭及其他燃料加工业" = 25,
"化学原料和化学制品制造业" = 26,
"医药制造业" = 27,
"化学纤维制造业" = 28,
"橡胶和塑料制品业" = 29,
"非金属矿物制品业" = 30,
"黑色金属冶炼和压延加工业" = 31,
"有色金属冶炼和压延加工业" = 32,
"金属制品业" = 33,
"通用设备制造业" = 34,
"专用设备制造业" = 35,
"汽车制造业" = 36,
"铁路、船舶、航空航天和其他运输设备制造业" = 37,
"电气机械和器材制造业" = 38,
"计算机、通信和其他电子设备制造业" = 39,
"仪器仪表制造业" = 40,
"其他制造业" = 41,
"废弃资源综合利用业" = 42,
"金属制品、机械和设备修理业" = 43,
}
/**
* 电力、热力、燃气及水生产和供应业
*/
export enum D {
"电力、热力生产和供应业" = 44,
"燃气生产和供应业" = 45,
"水的生产和供应业" = 46,
}
/**
* 建筑业
*/
export enum E {
"房屋建筑业" = 47,
"土木工程建筑业" = 48,
"建筑安装业" = 49,
"建筑装饰、装修和其他建筑业" = 50,
}
/**
* 批发和零售业
*/
export enum F {
批发业 = 51,
零售业 = 52,
}
/**
* 交通运输、仓储和邮政业
*/
export enum G {
铁路运输业 = 53,
道路运输业 = 54,
水上运输业 = 55,
航空运输业 = 56,
管道运输业 = 57,
多式联运和运输代理业 = 58,
装卸搬运和仓储业 = 59,
邮政业 = 60,
}
/**
* 住宿和餐饮业
*/
export enum H {
住宿业 = 61,
餐饮业 = 62,
}
/**
* 信息传输、软件和信息技术服务业
*/
export enum I {
"电信、广播电视和卫星传输服务" = 63,
"互联网和相关服务" = 64,
"软件和信息技术服务业" = 65,
}
/**
* 金融业
*/
export enum J {
货币金融服务 = 66,
资本市场服务 = 67,
保险业 = 68,
其他金融业 = 69,
}
/**
* 房地产业
*/
export enum K {
房地产业 = 70,
}
/**
* 租赁和商务服务业
*/
export enum L {
租赁业 = 71,
商务服务业 = 72,
}
/**
* 科学研究和技术服务业
*/
export enum M {
研究和试验发展 = 73,
专业技术服务业 = 74,
科技推广和应用服务业 = 75,
}
/**
* 水利、环境和公共设施管理业
*/
export enum N {
水利管理业 = 76,
生态保护和环境治理业 = 77,
公共设施管理业 = 78,
土地管理业 = 79,
}
/**
* 居民服务、修理和其他服务业
*/
export enum O {
"居民服务业" = 80,
"机动车、电子产品和日用产品修理业" = 81,
"其他服务业" = 82,
}
/**
* 教育
*/
export enum P {
教育 = 83,
}
/**
* 卫生和社会工作
*/
export enum Q {
卫生 = 84,
社会工作 = 85,
}
/**
* 文化、体育和娱乐业
*/
export enum R {
"新闻和出版业" = 86,
"广播、电视、电影和录音制作业" = 87,
"文化艺术业" = 88,
"体育" = 89,
"娱乐业" = 90,
}
/**
* 公共管理、社会保障和社会组织
*/
export enum S {
"中国共产党机关" = 91,
"国家机构" = 92,
"人民政协、民主党派" = 93,
"社会保障" = 94,
"群众团体、社会团体和其他成员组织" = 95,
"基层群众自治组织及其他组织" = 96,
}
/**
* 国际组织
*/
export enum T {
国际组织 = 97
}
src/config/enum/labelEnum.ts 0 → 100644
/**
* 事件标签枚举
*
*/
export enum LABELTYPE {
基础标签 = 1,
入驻年份 = 2,
企业性质 = 3,
所属物业 = 4,
自定义标签 = 5,
}
/**
* 企业系统标签
*/
export enum ENTERPRISESYSTEMLABEL {
"100平方公里" = 1,
"3.73平方公里" = 2,
软件关联入驻企业 = 3,
小台账企业 = 4,
重点稳商企业 = 5,
/**企业性质 */
实体型 = 6,
虚拟型 = 7,
注册型 = 8,
/**所属物业 */
于田大厦 = 601,
汽车创新港 = 602,
汽车城大厦 = 603,
嘉亭荟 = 604,
智驾园 = 605,
同济科技园 = 606,
/**入驻年份 */
"2023年" = 2023,
"2024年" = 2024,
"2025年" = 2025,
"2026年" = 2026,
// "2027年" = 2027,
// "2028年" = 2028,
// "2029年" = 2029,
// "2030年" = 2030,
// "暂无年份" = 2100,
}
/**
* 除去基础标签的其他下拉筛选
*/
export enum REMOVEBASICLABEL {
实体型 = 6,
虚拟型 = 7,
注册型 = 8,
于田大厦 = 601,
汽车创新港 = 602,
汽车城大厦 = 603,
嘉亭荟 = 604,
智驾园 = 605,
同济科技园 = 606,
"2023年" = 2023,
"2024年" = 2024,
"2025年" = 2025,
"2026年" = 2026,
}
/**
* 基础标签
*/
export enum BASELABEL {
"100平方公里" = 1,
"3.73平方公里" = 2,
软件关联入驻企业 = 3,
小台账企业 = 4,
重点稳商企业 = 5,
}
/**
* 入驻年份
*/
export enum YEARLABEL {
"2023年" = 2023,
"2024年" = 2024,
"2025年" = 2025,
"2026年" = 2026,
}
/**
* 企业性质
*/
export enum ENTERPRISENATURE {
实体型 = 6,
虚拟型 = 7,
注册型 = 8,
}
/**
* 所属物业
*/
export enum PROPERTY {
于田大厦 = 601,
汽车创新港 = 602,
汽车城大厦 = 603,
嘉亭荟 = 604,
智驾园 = 605,
同济科技园 = 606,
}
/**
* 标签状态
*/
export enum LABELUPDATEROAD {
生效 = 1,
重新生效,
失效,
}
/**
* 标签对象
*/
export enum LABELGOAL {
企业 = 1,
}
/**
* 兼容管委会中企业管理前俩选项并不是标签
*/
export enum GUANWEIHUIMANANGENTERPRISELABEL {
新注册企业 = 'xzcqy',
新迁入企业 = 'xqrqy',
}
/**
* 标签事件
*/
export enum LABELEVENT {
入孵 = 1,
迁出,
融资,
资质更新,
孵化类型更新
}
src/config/errorEnum.ts 0 → 100644
export enum ERRORENUM {
未找到数据,
参数错误,
不能重复提交任务,
请完善信息,
该企业已存在,
数据无更新,
密码错误,
密码不允许有特殊字符,
不能重复修改密码,
身份验证失败,
非法登录,
身份验证过期,
密码长度不能超过24个字符,
账号不存在,
已入库的数据不能删除,
任务不存在,
该企业不存在,
密码不一致,
密码只能由6至18位字符和数字组成,
统一社会信用代码不合法,
统一社会信用代码重复,
系统错误,
该任务已提交,
无法操作其他孵化器的企业,
请填入其他原因,
账号非绑定关系,
code无效,
频繁操作请稍后再试,
高风险等级用户,
系统繁忙,
绑定失败,
发送验证码次数超限制,
发送验证码频率过快,
没有联系人,
号码与主体不一致,
验证码错误,
验证码失效,
验证码过期,
不能修改过期任务数据,
短信发送失败,
地址数据不完整,
字数超过200限制,
只能修改本企业信息,
请勿重复提交填报数据,
只能删除本企业信息,
不能补录已有数据,
请正确填报数据,
不能重复创建填报,
请先创建填报数据,
重复通过填报数据,
请先选择是否拥有,
请先关闭该资讯,
请不要重复开启资讯,
未填报数据不能删除,
已提交的数据不能进行操作,
请先填报数据,
只能上传png或jpg图片,
文件上传失败,
系统错误请联系管理员,
缺少关键参数导致修改失败,
不合规操作,
未填安全手机号无法修改密码,
请输入聊天内容,
目标数据不存在,
不能删除非自定义标签,
该数据周期已存在此类型任务,
任务延期不可将开始时间提前,
任务延期结束时间要大于开始时间,
不可提前回收已完成任务,
缺少月份参数,
多余年份与月份参数,
不可以创建未来数据月的任务,
填报周期不能小于数据周期,
不可选择未来时间,
手机号不存在,
只能上传doc或docx或png或jpg图片,
空文件失败,
上传时缺失关键参数,
该账号已存在,
该标签不存在,
该活动已存在,
该政策已存在
}
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, secret, getOpenIdUrl, appId, sms, baidumap, qcc } = configInfo.config;
let {port, excelModelUrl, mongodb, sms, baidumap, qcc } = configInfo.config;
systemConfig.port = parseInt(port[0]);
systemConfig.excelModelUrl = excelModelUrl[0];
// systemConfig.secret = secret[0];
// systemConfig.getOpenIdUrl = getOpenIdUrl[0];
// systemConfig.appId = appId[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);
// let smsInfo = sms[0];
// systemConfig.smsSign = smsInfo.smsSign[0];
// systemConfig.smsSDKId = smsInfo.sdkAppId[0];
// systemConfig.smsAppKey = smsInfo.appKey[0];
// systemConfig.smsModelChangePwd = smsInfo.changePwd[0];
// systemConfig.smsModelPointOut = smsInfo.pointOut[0];
// systemConfig.smsModelInitPointOut = smsInfo.initPointOut[0];
systemConfig.ak = baidumap[0];
systemConfig.qccKey = qcc[0].key[0];
systemConfig.qccSecretKey = qcc[0].SecretKey[0];
}
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}`
}
\ No newline at end of file
src/config/splitResult/admin.ts 0 → 100644
/**
* 拆分返回结果配置 【管理后台端】
* 使用场景：逻辑层中需要返回数据给客户端的地方
* 限制：使用端不同不能共用一份配置
*/
src/config/splitResult/enterprise.ts 0 → 100644
/**
* 拆分返回结果配置 【小程序端】【企业】
* 使用场景：逻辑层中需要返回数据给客户端的地方
* 限制：使用端不同不能共用一份配置
*/
\ No newline at end of file
src/config/splitResultConfig.ts 0 → 100644
/**
* 拆分返回结果配置
* 使用场景：逻辑层中需要返回数据给客户端的地方
* 限制：使用端不同不能共用一份配置
*/
/**
* 使用端: 管理后台
* 场景: 在谈在跟列表
* 备注: 导出和列表共用一份配置
*/
export const negotiationListConfig = {
id:{key:"标识"},
name:{key:"企业名称"},
industry:{key:"行业领域"},
registrationStatus:{key:"推进/注册情况"},
progressStatus:{key:"进展情况"},
primaryContact:{key:"负责人/首谈人"},
contactDepartment:{key:"对接部门"},
};
/**
* 使用端: 管理后台
* 场景: 企业库列表
* 备注: 导出和列表共用一份配置
*/
export const enterpriseListConfig = {
uscc:{key:"统一社会信用代码"},
name:{key:"企业名称"},
industry:{key:"行业领域[]"},
logonTime:{key:"企业成立时间", changeDate:true},
parkEntryTime:{key:"入驻园区年份", changeDate:true},
leasedArea:{key:"租赁面积(㎡)"},
labels:{key:"企业标签"},
jingYingFanWei:{key:"经营范围"},
RAS:{key:"登记状态"},
zhuceziben:{key:"注册资本"},
property:{key:"所属物业"},
enterpriseNature:{key:"企业性质"},
};
/**
* 使用端: 管理后台
* 场景: 企业库所有uscc列表
* 备注: 导出和列表共用一份配置
*/
export const enterpriseUsccListConfig = {
uscc:{key:"统一社会信用代码"},
name:{key:"企业名称"}
};
/**
* 使用端: 管理后台
* 场景: 经营数据列表
* 备注: 导出和列表共用一份配置
*/
export const manageListConfig = {
id:{key:"标识"},
uscc:{key:"统一信用代码"},
name:{key:"企业名称"},
year:{key:"数据年度"},
period:{key:"数据时间"},
BI:{key:"营业收入(万元)"},
VAT:{key:"企业增值税(万元)"},
CIT:{key:"企业所得税(万元)"},
PIT:{key:"个人所得税(万元)"},
RD:{key:"研发投入(万元)"},
};
/**
* 使用端: 管理后台
* 场景: 企业服务追踪列表
* 备注: 导出和列表共用一份配置
*/
export const trackListConfig = {
id:{key:"标识"},
uscc:{key:"统一信用代码"},
name:{key:"企业名称"},
demand:{key:"需求类型"},
content:{key:"需求描述详情"},
contact:{key:"企业联系人"},
contactUs:{key:"企业联系方式"},
createTime:{key:"创建时间", changeDate:true},
trackType:{key:"需求跟进状态"},
followUpName:{key:"跟进人"},
followUpTime:{key:"跟进时间"},
followUpDsc:{key:"跟进详情"},
};
/**
* 使用端: 管理后台
* 场景: 园区活动列表
* 备注: 导出和列表共用一份配置
*/
export const activityListConfig = {
id:{key:"标识"},
title:{key:"活动标题"},
state:{key:"活动状态"},
startTime:{key:"活动开始时间", changeDate:true},
endTime:{key:"活动结束时间", changeDate:true},
target:{key:"活动类型"},
location:{key:"活动地点"},
desc:{key:"活动详情"},
};
/**
* 使用端: 管理后台
* 场景: 政策列表
* 备注: 导出和列表共用一份配置
*/
export const policyListConfig = {
id:{key:"标识"},
title:{key:"政策名称"},
policyType:{key:"政策类型"},
startTime:{key:"政策开始时间", changeDate:true},
endTime:{key:"政策结束时间", changeDate:true},
source:{key:"来源，发布单位"},
desc:{key:"政策详情"},
};
src/config/systemClass.ts 0 → 100644
/**
* 系统配置类
*
*/
export class ServerConfig {
/**系统配置 */
port:number;
excelModelUrl:string;
mongodbStr:string;
/**小程序相关配置 */
// secret:string;
// getOpenIdUrl:string;
// appId:string;
/**短信相关配置 */
// smsSDKId:number;
// smsAppKey:string;
// smsSign:string;
// smsModelChangePwd:number;
// smsModelPointOut:number;
// smsModelInitPointOut:number;
/**百度地图api */
ak:string
/**企查查 */
qccKey:string;
qccSecretKey:string;
}
\ No newline at end of file
src/data/activity.ts 0 → 100644
/**
* 活动
*/
import {Schema} from 'mongoose';
import {sasp} from '../db/mongo/dbInit';
const activitySchema = new Schema({
id:{type:String, index:true}, //唯一标识
title:String, //活动标题
state:{type:Number, default:1}, //活动状态 未开始、活动中、已结束
startTime:Number, //活动开始时间
endTime:Number, //活动结束时间
target:{type:[Number], default:[]}, //活动类型
location:String, //活动地点
desc:String, //活动详情
})
var activityModel;
export function initModel(){
activityModel = sasp.model('activity', activitySchema);
activityModel.selectOnceData = async function (paramater:object) {
let selectInfo = await activityModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 分页获取所有园区活动
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 在跟在谈活动列表
*/
export async function findActivityListToPage(selectParam, skipCount) {
return await activityModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的活动数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findActivityCount(selectParam) {
return await activityModel.find(selectParam).countDocuments();
}
/**
* 获取符合条件的活动
* @param selectParam
*/
export async function findActivityByParam(selectParam) {
return await activityModel.selectOnceData(selectParam);
}
/**
* 获取符合条件的活动列表
* @param selectParam
*/
export async function findActivityListByParam(selectParam) {
return await activityModel.find(selectParam);
}
/**
* 新增园区活动
* @param param
* @returns
*/
export async function createDataByParam(param) {
return await activityModel.create(param);
}
/**
* 删除园区活动
* @param id
* @returns
*/
export async function removeOneData(id:string) {
return await activityModel.deleteOne({id});
}
src/data/adminuser.ts 0 → 100644
/**
* 管理后台用户
*/
import {Schema} from 'mongoose';
import {sasp} from '../db/mongo/dbInit';
const adminuserSchema = new Schema({
loginId:{type:String, index:true},//登录账号
name:{type:String, index:true}, //名称
pwd:String, //密码
token:String,
tokenMs:Number,
})
var adminuserModel;
export function initModel(){
adminuserModel = sasp.model('adminuser', adminuserSchema);
adminuserModel.selectOnceData = async function (paramater:object) {
let selectInfo = await adminuserModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 获取符合条件的管理后台用户
* @param selectParam
*/
export async function findAdminuserByLoginId(loginId:string) {
return await adminuserModel.findOne({loginId}).exec();
}
/**
* 分页获取所有管理后台用户
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 管理后台用户列表
*/
export async function findAdminuserListToPage(selectParam, skipCount) {
return await adminuserModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的管理后台用户数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findAdminuserCount(selectParam) {
return await adminuserModel.find(selectParam).countDocuments();
}
/**
* 获取符合条件的管理后台用户
* @param selectParam
*/
export async function findAdminuserByParam(selectParam) {
return await adminuserModel.selectOnceData(selectParam);
}
/**
* 新增管理后台用户
* @param param
* @returns
*/
export async function createAdminuserByParam(param) {
return await adminuserModel.create(param);
}
/**
* 删除管理后台用户
* @param id
* @returns
*/
export async function removeOneData(id:string) {
return await adminuserModel.deleteOne({id});
}
src/data/dishonestPerson.ts 0 → 100644
/**
* 失信核查
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const enterprisedishonestPersonSchema = new Schema({
id:{type:String, index: true},
uscc:{type:String, index: true},
enterpriseName:String,
anno:String,
executegov:String,
executestatus:String,
executeno:String,
actionRemark:String,
amount:String,
});
var enterprisedishonestPersonModel;
export function initModel(){
enterprisedishonestPersonModel = sasp.model('enterprisedishonestperson', enterprisedishonestPersonSchema);
enterprisedishonestPersonModel.selectOnceData = async function (paramater:object) {
let selectInfo = await enterprisedishonestPersonModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
export async function createOnce(param) {
return await enterprisedishonestPersonModel.create(param);
}
export async function findOnce(param) {
return await enterprisedishonestPersonModel.selectOnceData(param);
}
export async function findList(param) {
return await enterprisedishonestPersonModel.find(param);
}
export async function removeMany(param) {
return await enterprisedishonestPersonModel.deleteMany(param);
}
export async function addMany(params) {
await enterprisedishonestPersonModel.insertMany(params);
}
\ No newline at end of file
src/data/enterprise.ts 0 → 100644
/**
* 企业库
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
/**
* 创始团队
*/
const initialTeamSchema = new Schema({
type:Number,//创始团队人才类型
memberName:String,//成员姓名
memberSex:Number,//成员性别
memberAge:Number,//成员年龄 出生年月时间戳
memberDEGREE:Number,//成员最高学历
memberSchool:String,//毕业学校
des:String,//履历描述
},{_id:false});
/**企业资质 */
const qualificationSchema = new Schema({
isHighTech:Boolean,
highTechMs:Number,//高新技术
isZjtx:Boolean,
zjtxMs:Number,//专精特新
isXjrpy:Boolean,
xjrpyMs:Number,//小巨人培育
isXjr:Boolean,
xjrMs:Number,//小巨人
beOnTheMarket:[Number],//上市情况
isBeOnTheMarket:{type:Boolean, default:false}//是否上市
}, {_id:false});
/**专利 */
const intellectualPropertySchema = new Schema({
alienPatent:Number,//海外专利
classIPatent:Number,//一类专利
secondClassPatent:Number,//二类专利
}, {_id:false});
/**租赁合同 */
const leaseScheme = new Schema({
contractStartTime:Number,//合同开始时间
contractEndTime:Number,//合同结束时间
rentStartTime:Number,//租金开始时间
rentEndTime:Number,//租金结束时间
})
//科创分
const kcfScheme = new Schema({
industry:String,//
subIndustry:String,//
industryRanking:String,//
score:String,//
})
/**股权结构 */
const guQuanJieGouItemScheme = new Schema({
name:String,//名称
finalBenefitPercent:String,//最终受益股份
stockPercent:String,//持股比例
stockType:String,//投资人类型
realCapi:String,//实缴出资额
paidUpCapitalUnit:String,//实缴出资额单位
subscribedCapital:String,//认缴出资额数额
subscribedCapitalUnit:String//认缴出资额单位
})
/**标签 */
const enterpriseLabelSchema = new Schema({
labelId:String,
labelType:Number, //标签类型 ENTERPRISESYSTEMLABEL
state:{type:Boolean, default:true},//状态 false表示标签失效
},{_id:false});
/**企业库 */
const enterpriseSchema = new Schema({
name: {type:String, index: true}, //企业名称
uscc:{type:String, index: true}, //统一信用代码
isSettled: Number, //是否入驻
industry:[Number], //行业领域 INDUSTRY
logonAddress:{type:[String], default:[]},//注册地址
logonTime:Number, //注册时间、成立时间
parkEntryTime: Number, //入驻园区时间
leasedArea: Number, //租赁面积（㎡）
enterpriseNature: Number, //企业性质 ENTERPRISENATURE：虚拟型、实体型、注册型
property: Number, //所属物业 PROPERTY：于田大厦、同济科技园、汽车创新港......
isInPut:{type:Boolean, default:false}, //是否是初始数据
createTime:Number, //创建时间
qualification:{type:qualificationSchema},//企业资质
leaseInfo:{type:leaseScheme, default:{}},//租赁信息
intellectualProperty:{type:intellectualPropertySchema},//知识产权
initialTeam:{type:[initialTeamSchema], default:[]},//创始团队
labels:{type:[enterpriseLabelSchema], default:[]},//标签系统
/** 用户相关 */
pwd:String,//登录密码
token:{type:String, index:true},
tokenMs:Number,
firstLoginIsChangePwd:{type:Boolean, default:false},//首次登录是否修改密码
/**导入的补充数据 */
RAS:{type:Number}, //登记状态
logOffMS:{type:Number}, //注销时间
legalPerson:String, //法人
zhuceziben:{type:String, default:'-'}, //注册资本
shijiaoziben:{type:String, default:'-'}, //实缴资本
dianHua:String, //电话
gengDuoDianHua:{type:String}, //更多电话
mail:{type:String, default:'-'}, //邮箱
moreMail:{type:String, default:'-'}, //更多邮箱
enterpriseType:{type:String, index:true}, //企业（机构）类型
zhuCeHao:String, //注册号
zuZhiJiGouDaiMa:String, //组织机构代码
canBaoRenShu:Number, //参保人数
canBaoRenShuNianBao:Number, //参保人数所属年报
yingYeQiXian:String, //营业期限
qiYeGuiMo:{type:Number, index:true}, //企业规模
guanWang:String, //官网
tongXinDiZhi:String, //通信地址
jianJie:String, //企业简介
dengJiJiGuan:String, //登记机关
naShuiRenZiZhi:Number, //纳税人资质
zuiXinNianBaoNianFen:Number, //最新年报年份
jingYingFanWei:String, //经营范围
industryCategoryGb: String, // 国标行业门类 INDUSTRY
industryMajorGb: String, // 国标行业大类
industryMediumGb: String, // 国标行业中类
industryMinorGb: String, // 国标行业小类
industryCategoryQcc: String, // 企查查行业门类
industryMajorQcc: String, // 企查查行业大类
industryMediumQcc: String, // 企查查行业中类
industryMinorQcc: String, // 企查查行业小类
guQuanJieGou:{type:[guQuanJieGouItemScheme], default:[]},//股权结构
kcf:{type:kcfScheme, default:{}},//科创分
})
var enterpriseModel;
export function initModel(){
enterpriseModel = sasp.model('enterprise', enterpriseSchema);
enterpriseModel.selectOnceData = async function (paramater:object) {
let selectInfo = await enterpriseModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 分页获取所有企业
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 在跟在谈企业列表
*/
export async function findEnterpriseListToPage(selectParam, skipCount) {
return await enterpriseModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的企业数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findEnterpriseCount(selectParam) {
return await enterpriseModel.find(selectParam).countDocuments();
}
/**
* 通过企业统一信用代码获取企业信息
* 支持.save方法保存对象修改
* @param uscc 企业统一信用代码
* @returns {}
*/
export async function findEnterpriseByUscc(uscc:string) {
return await enterpriseModel.selectOnceData({uscc});
}
/**
* 获取符合条件的企业列表
* @param selectParam
*/
export async function findEnterpriseListByParam(selectParam) {
return await enterpriseModel.find(selectParam);
}
/**
* 获取符合条件的单个企业
* @param selectParam
*/
export async function findEnterpriseByParam(selectParam) {
return await enterpriseModel.selectOnceData(selectParam);
}
/**
* 新增企业基础信息
* @param param
* @returns
*/
export async function createDataByParam(param) {
return await enterpriseModel.create(param);
}
/**
* 删除企业
* @param uscc
* @returns
*/
export async function removeOneData(uscc:string) {
return await enterpriseModel.deleteOne({uscc});
}
src/data/enterpriseRisk.ts 0 → 100644
/**
* 风险提示
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const enterpriseriskSchema = new Schema({
id:{type:String, index: true},
uscc:{type:String, index: true},
enterpriseName:String,
title:String,
description:String,
passage:String,
riskType:String,
typeCode:Number,
});
var enterpriseriskModel;
export function initModel(){
enterpriseriskModel = sasp.model('enterpriserisk', enterpriseriskSchema);
enterpriseriskModel.selectOnceData = async function (paramater:object) {
let selectInfo = await enterpriseriskModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
export async function createDataByParam(param) {
return await enterpriseriskModel.create(param);
}
export async function findOnce(param) {
return await enterpriseriskModel.selectOnceData(param);
}
export async function findList(selectParam) {
return await enterpriseriskModel.find(selectParam);
}
src/data/illegality.ts 0 → 100644
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const illegalitySchema = new Schema({
id:{type:String, index: true},
uscc:{type:String, index: true},
enterpriseName:String,
type:String,
addReason:String,
addOffice:String,
removeReason:String,
removeOffice:String,
});
var illegalityModel;
export function initModel(){
illegalityModel = sasp.model('illegality', illegalitySchema);
illegalityModel.selectOnceData = async function (paramater:object) {
let selectInfo = await illegalityModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
export async function createOnce(param) {
return await illegalityModel.create(param);
}
export async function findOnce(param) {
return await illegalityModel.selectOnceData(param);
}
export async function findList(param) {
return await illegalityModel.find(param);
}
export async function removeMany(param) {
return await illegalityModel.deleteMany(param);
}
export async function addMany(params) {
await illegalityModel.insertMany(params);
}
\ No newline at end of file
src/data/label.ts 0 → 100644
/**
* 标签系统
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const labelSchema = new Schema({
id:{type:String, index:true},//标识
labelName:String,
ctMs:Number,//创建时间
goal:Number,//目标 LABELGOAL
labelType:Number,//标签类型 LABELTYPE 系统标签不可以删除
state:{type:Boolean, default:false}//是否停用 true表示已停用
});
var labelModel;
export function initModel(){
labelModel = sasp.model('label', labelSchema);
labelModel.selectOnceData = async function (paramater:object) {
let selectInfo = await labelModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
export async function createLabel(goal:number, labelType:number, name:string, id:string) {
let addInfo = { id, goal, labelType, labelName:name, ctMs:new Date().valueOf(), state:false, isDelete:false };
return await labelModel.create(addInfo);
}
export async function createOneLabel(param) {
return await labelModel.create(param);
}
export async function findOnceLabel(id:string) {
return await labelModel.selectOnceData({id});
}
export async function selectLabelList(param) {
return await labelModel.find(param);
}
export async function selectLabelOne(param) {
return await labelModel.selectOnceData(param);
}
export async function selectLabelListToPage(param, skipNumber) {
return await labelModel.find(param).skip(skipNumber).limit(10);
}
export async function selectLabelCount(param) {
return await labelModel.find(param).countDocuments();
}
export async function addSystemLabel(labels) {
await labelModel.insertMany(labels);
}
export async function delLabel(id) {
return await labelModel.deleteOne({id});
}
/**
* 获取标签名称与标签类型map
* @param goal 标签目标
* @returns
*/
export async function getEffectiveLabelMap(goal:number) {
let list = await labelModel.find({goal, state:false});
let map = {};
list.forEach( info => {
let {id, labelName, labelType} = info;
map[id] = {labelName, labelType};
});
return map;
}
/**
* 获取标签名称与状态map
* @param goal 标签目标
* @returns
*/
export async function getLabelNamMap(goal:number) {
let list = await labelModel.find({goal});
let nameMap = {};
list.forEach(info => {
let {id, labelName, state} = info;
nameMap[id] = {labelName, state};
});
return nameMap;
}
\ No newline at end of file
src/data/manage.ts 0 → 100644
/**
* 企业经营数据
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const manageSchema = new Schema({
id:{type:String, index:true}, //标识
uscc:{type:String, index:true}, //统一信用代码
name:{type:String, index:true}, //企业名称
year:{type:Number, index:true}, //数据年度
period:{type:Number, index:true}, //数据时间 PERIOD：上半年(1-6月)、下半年(7-12月)、全年
BI:{type:Number, default:0}, //营业收入(万元)
VAT:{type:Number, default:0}, //企业增值税(万元)
CIT:{type:Number, default:0}, //企业所得税(万元)
PIT:{type:Number, default:0}, //个人所得税(万元)
RD:{type:Number, default:0}, //研发投入(万元)
isUpdate:{type:Boolean, default:false}, //是否修改
isSubmit:{type:Boolean, default:false}, //是否提交
createTime:Number, //提交时间
})
var manageModel;
export function initModel(){
manageModel = sasp.model('manage', manageSchema);
manageModel.selectOnceData = async function (paramater:object) {
let selectInfo = await manageModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 分页获取所有经营数据
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 经营数据列表
*/
export async function findManageListToPage(selectParam, skipCount) {
return await manageModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的经营数据数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findManageCount(selectParam) {
return await manageModel.find(selectParam).countDocuments();
}
/**
* 获取符合条件的经营数据
* @param selectParam
*/
export async function findManageByParam(selectParam) {
return await manageModel.selectOnceData(selectParam);
}
/**
* 获取符合条件的经营数据列表
* @param selectParam
*/
export async function findManageListByParam(selectParam) {
return await manageModel.find(selectParam);
}
/**
* 通过企业统一信用代码获取经营数据
* @param uscc 企业统一信用代码
* @returns {}
*/
export async function findManageByUscc(uscc:string) {
return await manageModel.selectOnceData({uscc});
}
/**
* 新增经营数据
* @param param
* @returns
*/
export async function createDataByParam(param) {
return await manageModel.create(param);
}
/**
* 删除经营数据
* @param id
* @returns
*/
export async function removeOneData(id:string) {
return await manageModel.deleteOne({id});
}
src/data/negotiation.ts 0 → 100644
/**
* 在谈在跟
*/
import {Schema} from 'mongoose';
import {sasp} from '../db/mongo/dbInit';
const negotiationSchema = new Schema({
id:{type:String, index:true}, //标识
// uscc:{type:String, index:true}, //统一信用代码
name:{type:String, index:true}, //企业名称
industry: [Number], //行业领域 ALLINDUSTRY
registrationStatus:{type:Number, default:1}, //推进、注册情况 REGISTRATIONSTATUS: 1-洽谈中, 2-已注册, 3-已入驻, 4-已终止
progressStatus:{type:Number, default:1}, //进展情况 PROGRESSSTATUS：1-初次接触, 2-深度洽谈, 3-协议草拟, 4-协议签订, 5-项目落地
primaryContact:String, //负责人、首谈人
contactDepartment:String, //对接部门
createTime:Number, //创建时间
})
var negotiationModel;
export function initModel(){
negotiationModel = sasp.model('negotiation', negotiationSchema);
negotiationModel.selectOnceData = async function (paramater:object) {
let selectInfo = await negotiationModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 分页获取所有在谈在跟企业
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 在跟在谈企业列表
*/
export async function findNegotiationListToPage(selectParam, skipCount) {
return await negotiationModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的企业数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findNegotiationCount(selectParam) {
return await negotiationModel.find(selectParam).countDocuments();
}
/**
* 获取符合条件的企业
* @param selectParam
*/
export async function findNegotiationByParam(selectParam) {
return await negotiationModel.selectOnceData(selectParam);
}
/**
* 获取符合条件的企业列表
* @param selectParam
*/
export async function findNegotiationListByParam(selectParam) {
return await negotiationModel.find(selectParam);
}
/**
* 通过企业统一信用代码获取企业信息
* @param uscc 企业统一信用代码
* @returns {}
*/
export async function findNegotiationByUscc(uscc:string) {
return await negotiationModel.selectOnceData({uscc});
}
/**
* 新增在谈在跟企业
* @param param
* @returns
*/
export async function createDataByParam(param) {
return await negotiationModel.create(param);
}
/**
* 删除在谈在跟企业
* @param id
* @returns
*/
export async function removeOneData(id:string) {
return await negotiationModel.deleteOne({id});
}
src/data/policy.ts 0 → 100644
/**
* 政策
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const policySchema = new Schema({
id:{type:String, index:true},//标识
title:String,//政策名称
policyType:Number, //政策类型 1=财政补贴 2=资质申报 3=政策扶持
startTime:Number, //政策开始时间
endTime:Number, //政策结束时间
source:String, //来源，发布单位
desc:String, //政策详情
})
var policyModel;
export function initModel(){
policyModel = sasp.model('policy', policySchema);
policyModel.selectOnceData = async function (paramater:object) {
let selectInfo = await policyModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 分页获取所有政策
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 在跟在谈政策列表
*/
export async function findPolicyListToPage(selectParam, skipCount) {
return await policyModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的政策数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findPolicyCount(selectParam) {
return await policyModel.find(selectParam).countDocuments();
}
/**
* 获取符合条件的政策
* @param selectParam
*/
export async function findPolicyByParam(selectParam) {
return await policyModel.selectOnceData(selectParam);
}
/**
* 获取符合条件的政策列表
* @param selectParam
*/
export async function findPolicyListByParam(selectParam) {
return await policyModel.find(selectParam);
}
/**
* 新增政策
* @param param
* @returns
*/
export async function createDataByParam(param) {
return await policyModel.create(param);
}
/**
* 删除政策
* @param id
* @returns
*/
export async function removeOneData(id:string) {
return await policyModel.deleteOne({id});
}
src/data/qualifications.ts 0 → 100644
/**
* 资质证书
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
const qualificationsSchema = new Schema({
id:{type:String, index: true},
uscc:{type:String, index: true},
enterpriseName:String,
name:String,//产品名称或者资质类别及等级
type:String,//证书类型
startDate:Number,//证书生效时间
endDate:Number,//证书截止日期
no:String,//证书编号
typeDesc:String,//证书类型
institutionList:String,//发证机构
status:String,//证书状态
});
var qualificationsModel;
export function initModel(){
qualificationsModel = sasp.model('qualifications', qualificationsSchema);
qualificationsModel.selectOnceData = async function (paramater:object) {
let selectInfo = await qualificationsModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
export async function createOnce(param) {
return await qualificationsModel.create(param);
}
export async function findOnce(param) {
return await qualificationsModel.selectOnceData(param);
}
export async function findList(param) {
return await qualificationsModel.find(param);
}
export async function removeMany(param) {
return await qualificationsModel.deleteMany(param);
}
export async function addMany(params) {
await qualificationsModel.insertMany(params);
}
\ No newline at end of file
src/data/track.ts 0 → 100644
/**
* 企业需求
*/
import {Schema} from 'mongoose';
import { sasp } from '../db/mongo/dbInit';
/**
* 需求跟踪详情
*/
const trackDetailsSchema = new Schema({
tdid:String, //标识
followUpName:String, //跟进人
followUpTime:Number, //跟进时间
followUpDsc:String, //跟进详情
followUpStatus:Number, //跟进状态 未解决、已解决
})
/**
* 企业需求
*/
const trackSchema = new Schema({
id:{type:String, index:true}, //标识
uscc:{type:String, index:true}, //企业uscc
name:String, //企业名称
demand:Number, //需求类型 VISITDEMAND
content:String, //需求描述详情
contact:String, //企业联系人
contactUs:String, //企业联系方式
trackType:Number, //需求跟进状态
createTime:Number, //创建时间
details:{type:[trackDetailsSchema], default:[]}, //需求跟踪详情
});
var trackModel;
export function initModel(){
trackModel = sasp.model('track', trackSchema);
trackModel.selectOnceData = async function (paramater:object) {
let selectInfo = await trackModel.findOne(paramater).exec();
if (selectInfo) {
if (!selectInfo.runSave) {
selectInfo.runSave = selectInfo.save;
selectInfo.save = save.bind(selectInfo)
}
}
return selectInfo;
}
}
export async function save(throwError=false) {
if (!this.isModified()) return;
await this.runSave({validateBeforeSave:false}).catch(err=>{
console.log(err);
});
}
/**
* 分页获取所有服务追踪
* @param selectParam 查询参数
* @param skipCount 跳过数量
* @returns [] 在跟在谈企业列表
*/
export async function findTrackListToPage(selectParam, skipCount) {
return await trackModel.find(selectParam).skip(skipCount).limit(10);
}
/**
* 获取符合条件的服务追踪数量
* @param selectParam 查询参数
* @returns number 数据数量
*/
export async function findTrackCount(selectParam) {
return await trackModel.find(selectParam).countDocuments();
}
/**
* 获取符合条件的服务追踪
* @param selectParam
*/
export async function findTrackByParam(selectParam) {
return await trackModel.selectOnceData(selectParam);
}
/**
* 获取符合条件的服务追踪列表
* @param selectParam
*/
export async function findTrackListByParam(selectParam) {
return await trackModel.find(selectParam);
}
/**
* 通过企业统一信用代码获取服务追踪
* @param uscc 企业统一信用代码
* @returns {}
*/
export async function findTrackByUscc(uscc:string) {
return await trackModel.selectOnceData({uscc});
}
/**
* 新增服务追踪
* @param param
* @returns
*/
export async function createDataByParam(param) {
return await trackModel.create(param);
}
/**
* 删除服务追踪
* @param id
* @returns
*/
export async function removeOneData(id:string) {
return await trackModel.deleteOne({id});
}
src/db/mongo/dbConnect.ts 0 → 100644
import mongoose = require('mongoose');
let defaultOptions = {
useNewUrlParser:true,
auto_reconnect:true,
// reconnectTries:1000,
// reconnectInterval:3000,
keepAlive: 1,
connectTimeoutMS: 3000,
useCreateIndex: true,
useUnifiedTopology: true
};
export async function createDbConnect(connectUrl:string, options?:object) {
if (!options) options = defaultOptions;
return await mongoose.createConnection(connectUrl, options).catch(
(err)=>{
throw err
});
}
src/db/mongo/dbInit.ts 0 → 100644
import { systemConfig } from "../../config/serverConfig";
import { BizError } from "../../util/bizError";
import { createDbConnect } from "./dbConnect";
import { initTable } from "./tableInit";
var sasp;
export async function initDB() {
//如果配置了mongoServerConstVal 才会连接mongo
if (systemConfig.mongodbStr) {
console.log(systemConfig.mongodbStr);
sasp = await createDbConnect(systemConfig.mongodbStr).catch(err => {
throw err
});
await initTable();
console.log('mongodb init success');
} else {
throw new BizError("xml中未配置mongo连接字符串 无法连接到mongodb");
}
}
export { sasp };
src/db/mongo/tableInit.ts 0 → 100644
import * as enterpriseinModel from "../../data/enterprise";
import * as labelModel from "../../data/label";
import * as activityModel from "../../data/activity";
import * as manageModel from "../../data/manage";
import * as negotiationModel from "../../data/negotiation";
import * as policyModel from "../../data/policy";
import * as trackModel from "../../data/track";
import * as adminuserModel from "../../data/adminuser";
import * as dishonestPersonModel from "../../data/dishonestPerson";
import * as illegalityModel from "../../data/illegality";
import * as qualificationsModel from "../../data/qualifications";
import * as enterpriseriskModel from "../../data/enterpriseRisk";
export async function initTable() {
activityModel.initModel();
adminuserModel.initModel();
dishonestPersonModel.initModel();
enterpriseinModel.initModel();
illegalityModel.initModel();
labelModel.initModel();
manageModel.initModel();
negotiationModel.initModel();
policyModel.initModel();
qualificationsModel.initModel();
trackModel.initModel();
enterpriseriskModel.initModel();
}
src/main.ts 0 → 100644
import { updateQCCDataTask } from "./biz/qccInit";
import { initConfig, systemConfig} from "./config/serverConfig";
import { initDB } from "./db/mongo/dbInit";
import { httpServer } from "./net/http_server";
import { initBasicData } from "./tools/dataInit";
async function lanuch() {
/**初始化配置解析 */
await initConfig();
/**初始化数据库 */
await initDB();
/**初始化底表数据 */
// await initBasicData();
/**创建http服务 */
httpServer.createServer(systemConfig.port);
console.log('This indicates that the server is started successfully.');
/**初始化企查查数据 */
// await updateQCCDataTask();
}
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) {
if (!req.headers) req.headers = {};
let subPath = '';
if (req.originalUrl.indexOf("policy") > -1) subPath = "policy";
else subPath = "doc";
var form = new formidable.IncomingForm({
uploadDir:path.join(__dirname.substring(0,__dirname.indexOf("out")),'files', 'admin', subPath),
maxFildsSize:10*1024*1024,
keepExtensions:true
});
form.parse(req, (err, fields, files)=>{
if (err) {
return next(err);
} else if (!files || !Object.keys(files).length) {
return next(new BizError(ERRORENUM.空文件失败));
}
else {
req.fields = fields;
req.files = {};
if (!files.formData && !files.file ) return next(new BizError(ERRORENUM.文件上传失败) );
if (files.formData) {
req.files.formData = files.formData;
}
else {
req.files.formData = files.file;
}
if (!req.files.formData || !req.files.formData.name) {
return next(new BizError(ERRORENUM.文件上传失败) );
}
if ( req.files.formData.type == 'image/png') {
req.fileType = '.png';
return next();
} else if (req.files.formData.type == 'image/jpg' || req.files.formData.type == 'image/jpeg') {
req.fileType = '.jpg';
return next();
} else if (req.files.formData.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
req.fileType = '.docx';
return next();
} else if (req.files.formData.type == "application/msword") {
req.fileType = '.doc';
return next();
} else if (req.files.formData.type == "application/pdf") {
req.fileType = '.pdf';
return next();
} else if (req.files.formData.type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"){
req.fileType = '.xlsx';
return next();
} else {
return next(new BizError(ERRORENUM.只能上传doc或docx或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 { findAdminuserByLoginId } from "../data/adminuser";
import { findEnterpriseByUscc } from "../data/enterprise";
import { BizError } from "../util/bizError";
/**
* 中间件 校验管理后台token
* @param req
* @param res
* @param next
* @returns
*/
export async function checkAdminUserToken(req, res, next) {
if (!req.headers) req.headers = {};
const ReqToken = req.headers.token || "";
const UserId = req.headers.userid || "";
if (!UserId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${UserId} token:${ReqToken}`));
let userInfo = await findAdminuserByLoginId(UserId);
if (!userInfo || !userInfo.loginId) return next(new BizError(ERRORENUM.非法登录, `userId:${UserId} token:${ReqToken}`));
if (userInfo.token != ReqToken ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${UserId} token:${ReqToken}`));
// if (userInfo.token != ReqToken || (new Date().valueOf() - userInfo.tokenMs) > (3600*100*24*7) ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${UserId} token:${ReqToken}`));
next();
}
/**
* 中间件 校验企业token
* @param req
* @param res
* @param next
* @returns
*/
export async function checkEnterpriseToken(req, res, next) {
if (!req.headers) req.headers = {};
const reqToken = req.headers.token;
const userId = req.headers.userid || "";
if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
let userInfo = await findEnterpriseByUscc(userId);
if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`));
if (userInfo.token != reqToken || (new Date().valueOf() - userInfo.tokenMs) > (3600*100*24*7) ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${userId} token:${reqToken}`));
/**登录一次一直有效 */
// if (userInfo.token != reqToken ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${userId} token:${reqToken}`));
req.headers.uscc = req.headers.userid;
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();
}
/**
* 中间件 数据同步接口
* @param req
* @param res
* @param next
* @returns
*/
export async function checkDataAsyncInterior(req, res, next) {
if (!req.headers) req.headers = {};
const Sign = req.headers.sign;
let sysSign = 'sadfjslakdfjlksadjffujisdaiofjsajl09092302ddd'
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/activity.ts 0 → 100644
/**
* 管理后台 - 园区活动
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as activityBiz from "../biz/activity";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/activity/list', checkAdminUserToken, asyncHandler(getActivityList));
httpServer.post('/admin/activity/add', checkAdminUserToken, asyncHandler(addActivity));
httpServer.post('/admin/activity/info', checkAdminUserToken, asyncHandler(getActivityInfo));
httpServer.post('/admin/activity/update', checkAdminUserToken, asyncHandler(updateActivity));
httpServer.post('/admin/activity/del', checkAdminUserToken, asyncHandler(delActivity));
httpServer.post('/admin/activity/output', checkAdminUserToken, asyncHandler(outPutActivityList));
}
/**
* 园区活动-列表
* @param req
* @param res
*/
async function getActivityList(req, res) {
let reqConf = {title:'String', startTime:'Number', endTime:'Number', target:'[Number]', state:'Number', page:'Number'};
const NotMustHaveKeys = ['title', 'startTime', 'endTime', 'target', 'state'];
let {title, startTime, endTime, target, state, page} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await activityBiz.activityList(title, startTime, endTime, target, state, page);
res.success(result);
}
/**
* 园区活动-新增
* @param req
* @param res
*/
async function addActivity(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await activityBiz.activityCreate(param);
res.success(result);
}
/**
* 园区活动-回显
* @param req
* @param res
*/
async function getActivityInfo(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await activityBiz.activityInfo(id);
res.success(result);
}
/**
* 园区活动-修改
* @param req
* @param res
*/
async function updateActivity(req, res) {
let reqConf = {id:"String", param:"Object"};
let { id, param } = eccReqParamater(reqConf, req.body);
let result = await activityBiz.activityUpdate(id, param);
res.success(result);
}
/**
* 园区活动-删除
* @param req
* @param res
*/
async function delActivity(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await activityBiz.activityDelete(id);
res.success(result);
}
/**
* 园区活动-列表
* @param req
* @param res
*/
async function outPutActivityList(req, res) {
let reqConf = {title:'String', startTime:'Number', endTime:'Number', target:'[Number]', state:'Number'};
const NotMustHaveKeys = ['title', 'startTime', 'endTime', 'target', 'state'];
let {title, startTime, endTime, target, state} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await activityBiz.outPutActivityData(title, startTime, endTime, target, state);
res.success(result);
}
src/routers/adminuser.ts 0 → 100644
/**
* 管理后台 - 用户
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as adminuserBiz from "../biz/adminuser";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/user/login', asyncHandler(login));
httpServer.post('/admin/user/add', asyncHandler(AddAdminUser));
httpServer.post('/admin/user/homepage', checkAdminUserToken, asyncHandler(getHomePage));
}
/**
* 管理后台登录
* @param req
* @param res
*/
async function login(req, res) {
let reqConf = {loginId:'String', pwd:'String'};
let {loginId, pwd} = eccReqParamater(reqConf, req.body);
let userInfo = await adminuserBiz.login(loginId, pwd);
res.success(userInfo);
}
/**
* 用户-新增
* @param req
* @param res
*/
async function AddAdminUser(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await adminuserBiz.adminUserCreate(param);
res.success(result);
}
/**
* 数据看板
* @param req
* @param res
*/
async function getHomePage(req, res) {
let result = await adminuserBiz.homePage();
res.success(result);
}
src/routers/enterprise.ts 0 → 100644
/**
* 管理后台 - 基础企业库
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as enterpriseBiz from "../biz/enterprise";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/enterprise/list', checkAdminUserToken, asyncHandler(getEnterpriseList));
httpServer.post('/admin/enterprise/add', checkAdminUserToken, asyncHandler(addEnterprise));
httpServer.post('/admin/enterprise/info', checkAdminUserToken, asyncHandler(getEnterpriseInfo));
httpServer.post('/admin/enterprise/update', checkAdminUserToken, asyncHandler(updateEnterprise));
httpServer.post('/admin/enterprise/del', checkAdminUserToken, asyncHandler(delEnterprise));
httpServer.post('/admin/enterprise/output', checkAdminUserToken, asyncHandler(outPutEnterprise));
}
/**
* 基础企业库-列表
* @param req
* @param res
*/
async function getEnterpriseList(req, res) {
let reqConf = {dataType:'Number', name:'String', industry:'[Number]', parkEntryTime:'Number', logonTime:'Number', labelIdList:'[String]', page:'Number'};
const NotMustHaveKeys = ['dataType', 'name', 'industry', 'parkEntryTime', 'logonTime', 'labelIdList'];
let {dataType, name, industry, parkEntryTime, logonTime, labelIdList, page} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await enterpriseBiz.enterpriseList(dataType, name, industry, parkEntryTime, logonTime, labelIdList, page);
res.success(result);
}
/**
* 基础企业库-新增
* @param req
* @param res
*/
async function addEnterprise(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await enterpriseBiz.enterpriseCreate(param);
res.success(result);
}
/**
* 基础企业库-回显
* @param req
* @param res
*/
async function getEnterpriseInfo(req, res) {
let reqConf = {uscc:"String"};
let { uscc } = eccReqParamater(reqConf, req.body);
let result = await enterpriseBiz.enterpriseInfo(uscc);
res.success(result);
}
/**
* 基础企业库-修改
* @param req
* @param res
*/
async function updateEnterprise(req, res) {
let reqConf = {uscc:"String", param:"Object"};
let { uscc, param } = eccReqParamater(reqConf, req.body);
let result = await enterpriseBiz.enterpriseUpdate(uscc, param);
res.success(result);
}
/**
* 基础企业库-删除
* @param req
* @param res
*/
async function delEnterprise(req, res) {
let reqConf = {uscc:"String"};
let { uscc } = eccReqParamater(reqConf, req.body);
let result = await enterpriseBiz.enterpriseDelete(uscc);
res.success(result);
}
/**
* 基础企业库-导出
* @param req
* @param res
*/
async function outPutEnterprise(req, res) {
let reqConf = {name:'String', industry:'[Number]', parkEntryTime:'Number', logonTime:'Number', labelIdList:'[String]', dataType:'Number'};
const NotMustHaveKeys = ['name', 'industry', 'parkEntryTime', 'logonTime', 'labelIdList', 'dataType'];
let {name, industry, parkEntryTime, logonTime, labelIdList, dataType} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await enterpriseBiz.outPutEnterpriseData(name, industry, parkEntryTime, logonTime, labelIdList, dataType);
res.success(result);
}
src/routers/importData.ts 0 → 100644
/**
* 管理后台 - 导入
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as importDataBiz from "../biz/importData";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/show/excelurl', checkAdminUserToken, asyncHandler(getExcelModelUrl));
httpServer.post('/admin/show/updata', checkAdminUserToken, asyncHandler(upData));
}
async function getExcelModelUrl(req, res) {
let reqConf = {excelType:'Number'};
let {excelType} = eccReqParamater(reqConf, req.body);
let result = await importDataBiz.excelUrl(excelType);
res.success(result);
}
/**
* 导入
* @param req
* @param res
*/
async function upData(req, res) {
let reqConf = {list:'[Object]', excelType:'Number'};
let {list, excelType} = eccReqParamater(reqConf, req.body);
let result = await importDataBiz.upShowExcel(list, excelType);
res.success(result);
}
src/routers/manage.ts 0 → 100644
/**
* 管理后台 - 经营数据
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as manageBiz from "../biz/manage";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/manage/list', checkAdminUserToken, asyncHandler(getManageList));
httpServer.post('/admin/manage/add', checkAdminUserToken, asyncHandler(addManage));
httpServer.post('/admin/manage/info', checkAdminUserToken, asyncHandler(getManageInfo));
httpServer.post('/admin/manage/update', checkAdminUserToken, asyncHandler(updateManage));
httpServer.post('/admin/manage/del', checkAdminUserToken, asyncHandler(delManage));
httpServer.post('/admin/manage/output', checkAdminUserToken, asyncHandler(outPutManageList));
}
/**
* 经营数据-列表
* @param req
* @param res
*/
async function getManageList(req, res) {
let reqConf = {name:'String', year:'Number', period:'Number', page:'Number'};
const NotMustHaveKeys = ['name', 'year', 'period'];
let {name, year, period, page} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await manageBiz.manageList(name, year, period, page);
res.success(result);
}
/**
* 经营数据-新增
* @param req
* @param res
*/
async function addManage(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await manageBiz.manageCreate(param);
res.success(result);
}
/**
* 经营数据-回显
* @param req
* @param res
*/
async function getManageInfo(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await manageBiz.manageInfo(id);
res.success(result);
}
/**
* 经营数据-修改
* @param req
* @param res
*/
async function updateManage(req, res) {
let reqConf = {id:"String", param:"Object"};
let { id, param } = eccReqParamater(reqConf, req.body);
let result = await manageBiz.manageUpdate(id, param);
res.success(result);
}
/**
* 经营数据-删除
* @param req
* @param res
*/
async function delManage(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await manageBiz.manageDelete(id);
res.success(result);
}
/**
* 经营数据-列表
* @param req
* @param res
*/
async function outPutManageList(req, res) {
let reqConf = {name:'String', year:'Number', period:'Number'};
const NotMustHaveKeys = ['name', 'year', 'period'];
let {name, year, period} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await manageBiz.outPutManageData(name, year, period);
res.success(result);
}
src/routers/negotiation.ts 0 → 100644
/**
* 管理后台 - 在谈在跟
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as negotiationBiz from "../biz/negotiation";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/negotiation/list', checkAdminUserToken, asyncHandler(getNegotiationList));
httpServer.post('/admin/negotiation/add', checkAdminUserToken, asyncHandler(addNegotiation));
httpServer.post('/admin/negotiation/info', checkAdminUserToken, asyncHandler(getNegotiationInfo));
httpServer.post('/admin/negotiation/update', checkAdminUserToken, asyncHandler(updateNegotiation));
httpServer.post('/admin/negotiation/list', checkAdminUserToken, asyncHandler(getNegotiationList));
httpServer.post('/admin/negotiation/output', checkAdminUserToken, asyncHandler(outPutNegotiation));
}
/**
* 在谈在跟-列表
* @param req
* @param res
*/
async function getNegotiationList(req, res) {
let reqConf = {name:'String', industry:'[Number]', registrationStatus:'Number', primaryContact:'String', contactDepartment:'String', page:'Number'};
const NotMustHaveKeys = ['name', 'industry', 'registrationStatus', 'primaryContact', 'contactDepartment'];
let {name, industry, registrationStatus, primaryContact, contactDepartment, page} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await negotiationBiz.negotiationList(name, industry, registrationStatus, primaryContact, contactDepartment, page);
res.success(result);
}
/**
* 在谈在跟-新增
* @param req
* @param res
*/
async function addNegotiation(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await negotiationBiz.negotiationCreate(param);
res.success(result);
}
/**
* 在谈在跟-回显
* @param req
* @param res
*/
async function getNegotiationInfo(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await negotiationBiz.negotiationInfo(id);
res.success(result);
}
/**
* 在谈在跟-修改
* @param req
* @param res
*/
async function updateNegotiation(req, res) {
let reqConf = {id:"String", param:"Object"};
let { id, param } = eccReqParamater(reqConf, req.body);
let result = await negotiationBiz.negotiationUpdate(id, param);
res.success(result);
}
/**
* 在谈在跟-删除
* @param req
* @param res
*/
async function delNegotiation(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await negotiationBiz.negotiationDelete(id);
res.success(result);
}
/**
* 在谈在跟-列表
* @param req
* @param res
*/
async function outPutNegotiation(req, res) {
let reqConf = {name:'String', industry:'[Number]', registrationStatus:'Number', primaryContact:'String', contactDepartment:'String'};
const NotMustHaveKeys = ['name', 'industry', 'registrationStatus', 'primaryContact', 'contactDepartment'];
let {name, industry, registrationStatus, primaryContact, contactDepartment} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await negotiationBiz.outPutNegotiationData(name, industry, registrationStatus, primaryContact, contactDepartment);
res.success(result);
}
src/routers/policy.ts 0 → 100644
/**
* 管理后台 - 政策
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as policyBiz from "../biz/policy";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/policy/list', checkAdminUserToken, asyncHandler(getPolicyList));
httpServer.post('/admin/policy/add', checkAdminUserToken, asyncHandler(addPolicy));
httpServer.post('/admin/policy/info', checkAdminUserToken, asyncHandler(getPolicyInfo));
httpServer.post('/admin/policy/update', checkAdminUserToken, asyncHandler(updatePolicy));
httpServer.post('/admin/policy/del', checkAdminUserToken, asyncHandler(delPolicy));
httpServer.post('/admin/policy/output', checkAdminUserToken, asyncHandler(outPutPolicyList));
}
/**
* 政策-列表
* @param req
* @param res
*/
async function getPolicyList(req, res) {
let reqConf = {title:'String', startTime:'Number', endTime:'Number', policyType:'Number', page:'Number'};
const NotMustHaveKeys = ['title', 'startTime', 'endTime', 'policyType'];
let {title, startTime, endTime, policyType, page} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await policyBiz.policyList(title, startTime, endTime, policyType, page);
res.success(result);
}
/**
* 政策-新增
* @param req
* @param res
*/
async function addPolicy(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await policyBiz.policyCreate(param);
res.success(result);
}
/**
* 政策-回显
* @param req
* @param res
*/
async function getPolicyInfo(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await policyBiz.policyInfo(id);
res.success(result);
}
/**
* 政策-修改
* @param req
* @param res
*/
async function updatePolicy(req, res) {
let reqConf = {id:"String", param:"Object"};
let { id, param } = eccReqParamater(reqConf, req.body);
let result = await policyBiz.policyUpdate(id, param);
res.success(result);
}
/**
* 政策-删除
* @param req
* @param res
*/
async function delPolicy(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await policyBiz.policyDelete(id);
res.success(result);
}
/**
* 政策-导出
* @param req
* @param res
*/
async function outPutPolicyList(req, res) {
let reqConf = {title:'String', startTime:'Number', endTime:'Number', policyType:'Number'};
const NotMustHaveKeys = ['title', 'startTime', 'endTime', 'policyType'];
let {title, startTime, endTime, policyType} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await policyBiz.outPutPolicyData(title, startTime, endTime, policyType);
res.success(result);
}
src/routers/public.ts 0 → 100644
/**
* 公共资源路由
*/
import asyncHandler = require('express-async-handler');
import * as labelConfig from '../config/enum/labelEnum';
import * as industryConfig from '../config/enum/industryEnum';
import * as enumConfig from '../config/enum';
import * as labelBiz from '../biz/labelValue';
import * as enterpriseBiz from "../biz/enterprise";
import { eccReqParamater } from '../util/verificationParam';
const config = {
"/public/upexcel":enumConfig.UpExcelNameType, //导入相关
"/public/label/labeltype":labelConfig.LABELTYPE, //标签类型
"/public/industrycategorygb":industryConfig.INDUSTRY, //国标行业门类
"/public/industry":industryConfig.ALLINDUSTRY, //行业领域
"/public/ras":enumConfig.RAS, //登记状态
"/public/registrationstatus":enumConfig.REGISTRATIONSTATUS, //推荐/注册情况
"/public/progressstatus":enumConfig.PROGRESSSTATUS, //进展情况
"/public/period":enumConfig.PERIOD, //数据时间 上半年(1-6月)、下半年(7-12月)、全年
"/public/demand":enumConfig.VISITDEMAND, //需求类型
"/public/tracktype":enumConfig.TRACKTYPE, //需求跟进状态
"/public/activitystate":enumConfig.ACTIVITYSTATE, //活动状态
"/public/activitytarget":enumConfig.ACTIVITYTARGET, //活动类型
"/public/policytype":enumConfig.POLICYTYPE, //政策类型
}
export function setRouter(httpServer) {
for (let modelKey in config) {
httpServer.post(modelKey, asyncHandler(getEnum(config[modelKey])));
}
httpServer.post('/public/enterprise/uscc', asyncHandler(getAllUscc));
httpServer.post('/public/label/all', asyncHandler(getAllLabel));
httpServer.post('/public/label/base', asyncHandler(getBaseLabel));
httpServer.post('/public/label/property', asyncHandler(getPropertyLabel));
httpServer.post('/public/label/enterprisenature', asyncHandler(getEnterpriseNatureLabel));
httpServer.post('/public/label/year', asyncHandler(getYearLabel));
httpServer.post("/public/label/nottype", asyncHandler(getNotTypeLabel));
}
/**
* 获取所有企业uscc
* @param req
* @param res
*/
async function getAllUscc(req, res) {
let result = await enterpriseBiz.enterpriseUsccList();
res.success(result);
}
/**
* 获取所有标签下拉
* @param req
* @param res
*/
async function getAllLabel(req, res) {
let result = await labelBiz.getLabel();
res.success(result);
}
/**
* 获取基础标签下拉
* @param req
* @param res
*/
async function getBaseLabel(req, res) {
let result = await labelBiz.getLabel(labelConfig.LABELTYPE.基础标签);
res.success(result);
}
/**
* 获取所属物业标签下拉
* @param req
* @param res
*/
async function getPropertyLabel(req, res) {
let result = await labelBiz.getLabel(labelConfig.LABELTYPE.所属物业);
res.success(result);
}
/**
* 获取企业性质标签下拉
* @param req
* @param res
*/
async function getEnterpriseNatureLabel(req, res) {
let result = await labelBiz.getLabel(labelConfig.LABELTYPE.企业性质);
res.success(result);
}
/**
* 获取入驻年份标签下拉
* @param req
* @param res
*/
async function getYearLabel(req, res) {
let result = await labelBiz.getLabel(labelConfig.LABELTYPE.入驻年份);
res.success(result);
}
async function getNotTypeLabel(req, res) {
let reqConf = {labelType:"Number"};
let { labelType } = eccReqParamater(reqConf, req.body);
let result = await labelBiz.getNotTypeLabel(labelType);
res.success(result);
}
/**
* 获取枚举
* @param enumCof
* @returns
*/
function getEnum(enumCof) {
return async function (req, res) {
let dataList = [];
for (let key in enumCof) {
let anyKey:any = key;
if (isNaN(anyKey)) {
dataList.push({key, value:enumCof[key]});
}
}
res.success({dataList});
}
}
src/routers/router.ts 0 → 100644
/**
* 总路由入口
*/
import * as publicRouters from './public';
import * as adminuserRouters from './adminuser';
import * as negotiationRouters from './negotiation';
import * as enterpriseRouters from './enterprise';
import * as manageRouters from './manage';
import * as trackRouters from './track';
import * as activityRouters from './activity';
import * as policyRouters from './policy';
import * as importDataRouters from './importData';
export function setRouter(httpServer){
/**下拉框等公用 路由 */
publicRouters.setRouter(httpServer);
/**小程序端 入口路由 */
// mobileClientEnterpriseRouters.setRouter(httpServer);
/**管理后台端 入口路由 */
importDataRouters.setRouter(httpServer); //导入
adminuserRouters.setRouter(httpServer); //用户
negotiationRouters.setRouter(httpServer); //在谈在跟
enterpriseRouters.setRouter(httpServer); //企业库
manageRouters.setRouter(httpServer); //经营数据
trackRouters.setRouter(httpServer); //企业服务追踪
activityRouters.setRouter(httpServer); //园区活动
policyRouters.setRouter(httpServer); //政策
}
\ No newline at end of file
src/routers/track.ts 0 → 100644
/**
* 管理后台 - 服务追踪
*/
import asyncHandler = require('express-async-handler');
import { eccReqParamater } from "../util/verificationParam";
import * as trackBiz from "../biz/track";
import { checkAdminUserToken } from "../middleware/user";
export function setRouter(httpServer) {
httpServer.post('/admin/track/list', checkAdminUserToken, asyncHandler(getTrackList));
httpServer.post('/admin/track/add', checkAdminUserToken, asyncHandler(addTrack));
httpServer.post('/admin/track/info', checkAdminUserToken, asyncHandler(getTrackInfo));
httpServer.post('/admin/trackdetails/info', checkAdminUserToken, asyncHandler(getTrackDetailsInfo));
httpServer.post('/admin/track/update', checkAdminUserToken, asyncHandler(updateTrack));
httpServer.post('/admin/track/del', checkAdminUserToken, asyncHandler(delTrack));
httpServer.post('/admin/track/output', checkAdminUserToken, asyncHandler(outPutTrackList));
}
/**
* 服务追踪-列表
* @param req
* @param res
*/
async function getTrackList(req, res) {
let reqConf = {name:'String', demand:'Number', trackType:'Number', page:'Number'};
const NotMustHaveKeys = ['name', 'demand', 'trackType'];
let {name, demand, trackType, page} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await trackBiz.trackList(name, demand, trackType, page);
res.success(result);
}
/**
* 服务追踪-新增
* @param req
* @param res
*/
async function addTrack(req, res) {
let reqConf = {param:"Object"};
let { param } = eccReqParamater(reqConf, req.body);
let result = await trackBiz.trackCreate(param);
res.success(result);
}
/**
* 服务追踪-回显
* @param req
* @param res
*/
async function getTrackInfo(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await trackBiz.trackInfo(id);
res.success(result);
}
/**
* 服务追踪-回显
* @param req
* @param res
*/
async function getTrackDetailsInfo(req, res) {
let reqConf = {tdid:"String"};
let { tdid } = eccReqParamater(reqConf, req.body);
let result = await trackBiz.trackDetailsInfo(tdid);
res.success(result);
}
/**
* 服务追踪-修改
* @param req
* @param res
*/
async function updateTrack(req, res) {
let reqConf = {id:"String", param:"Object"};
let { id, param } = eccReqParamater(reqConf, req.body);
let result = await trackBiz.trackUpdate(id, param);
res.success(result);
}
/**
* 服务追踪-删除
* @param req
* @param res
*/
async function delTrack(req, res) {
let reqConf = {id:"String"};
let { id } = eccReqParamater(reqConf, req.body);
let result = await trackBiz.trackDelete(id);
res.success(result);
}
/**
* 服务追踪-导出-每个跟进记录单独一行
* @param req
* @param res
*/
async function outPutTrackList(req, res) {
let reqConf = {name:'String', demand:'Number', trackType:'Number'};
const NotMustHaveKeys = ['name', 'demand', 'trackType'];
let {name, demand, trackType} = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
let result = await trackBiz.outPutTrackDetailsData(name, demand, trackType);
res.success(result);
}
src/tools/dataInit.ts 0 → 100644
/**
* 数据初始化
* 底库数据
*/
import * as enterpriseData from "../data/enterprise";
import * as labelData from "../data/label";
import * as configEnum from "../config/enum";
import * as industryEnum from "../config/enum/industryEnum";
import * as labelEnum from "../config/enum/labelEnum";
import { createDataByParam, findEnterpriseByUscc } from "../data/enterprise";
import { formatAddress, getPwdMd5, randomId } from "./system";
import { TABLEID } from "../config/enum/dbEnum";
let xlsx = require('node-xlsx');
let path = require('path');
let md5 = require("md5");
/**
* 获取当个excel文件数据
* @param filePath
* @returns
*/
function getExcel(filePath) {
let 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}
}
const IndustryConfigMap = {
"农、林、牧、渔业" : "A",
"采矿业" : "B",
"制造业" : "C",
"电力、热力、燃气及水生产和供应业" : "D",
"建筑业" : "E",
"批发和零售业" : "F",
"交通运输、仓储和邮政业" : "G",
"住宿和餐饮业" : "H",
"信息传输、软件和信息技术服务业" : "I",
"金融业" : "J",
"房地产业" : "K",
"租赁和商务服务业" : "L",
"科学研究和技术服务业" : "M",
"水利、环境和公共设施管理业" : "N",
"居民服务、修理和其他服务业" : "O",
"教育" : "P",
"卫生和社会工作" : "Q",
"文化、体育和娱乐业" : "R",
"公共管理、社会保障和社会组织" : "S",
"国际组织" : "T",
}
/**
* 行业大类枚举映射
*/
const IndustryMajorEnumMap = {
'A': industryEnum.A,
'B': industryEnum.B,
'C': industryEnum.C,
'D': industryEnum.D,
'E': industryEnum.E,
'F': industryEnum.F,
'G': industryEnum.G,
'H': industryEnum.H,
'I': industryEnum.I,
'J': industryEnum.J,
'K': industryEnum.K,
'L': industryEnum.L,
'M': industryEnum.M,
'N': industryEnum.N,
'O': industryEnum.O,
'P': industryEnum.P,
'Q': industryEnum.Q,
'R': industryEnum.R,
'S': industryEnum.S,
'T': industryEnum.T
};
/**
* 企业性质映射
*/
const EnterpriseNatureMap = {
'实体型': labelEnum.ENTERPRISENATURE.实体型,
'虚拟型': labelEnum.ENTERPRISENATURE.虚拟型,
'注册型': labelEnum.ENTERPRISENATURE.注册型
};
/**
* 企业规模映射
*/
const EnterpriseSizeMap = {
'S(小型)': configEnum.ENTERPRISESIZE.小型,
'XS(微型)': configEnum.ENTERPRISESIZE.微型,
'M(中型)': configEnum.ENTERPRISESIZE.中型,
'L(大型)': configEnum.ENTERPRISESIZE.大型
};
/**
* 物业映射
*/
const propertyMap = {
'于田大厦': labelEnum.PROPERTY.于田大厦,
'汽车创新港': labelEnum.PROPERTY.汽车创新港,
'汽车城大厦': labelEnum.PROPERTY.汽车城大厦,
'嘉亭荟': labelEnum.PROPERTY.嘉亭荟,
'智驾园': labelEnum.PROPERTY.智驾园,
'同济科技园': labelEnum.PROPERTY.同济科技园
};
/**
* 处理行业信息
* @param {string} industryCategoryGb 国标行业门类
* @param {string} industryMajorGb 国标行业大类
* @returns {{industry: Array<number>, industryCategoryGb: string}}
*/
function parseIndustry(industryCategoryGb, industryMajorGb) {
if (!industryCategoryGb || !industryMajorGb) {
return { industry: [], industryCategoryGb: '' };
}
// 获取行业门类代码（字母）
let industryCategoryCode = IndustryConfigMap[industryCategoryGb] || '';
// 获取行业大类枚举值
let industryMajorValue = null;
// 获取对应的大类枚举
let majorEnum = IndustryMajorEnumMap[industryCategoryCode];
if (majorEnum) {
// 在大类枚举中查找对应的值
let entry = Object.entries(majorEnum).find(([key, value]) =>
key === industryMajorGb || String(value) === industryMajorGb
);
if (entry) {
industryMajorValue = entry[1];
}
}
// 返回对象，包含两个字段
return {
industry: industryMajorValue ? [industryMajorValue] : [],
industryCategoryGb: industryCategoryCode
};
}
/**
* 处理日期字符串
* @param {string} dateStr
* @returns {number|null}
*/
function parseDateString(dateStr) {
if (!dateStr || dateStr === '-') return null;
try {
// 处理Excel日期格式（如：2020-07-16）
if (typeof dateStr === 'string') {
let date = new Date(dateStr);
return isNaN(date.getTime()) ? null : date.getTime();
}
// 处理Excel数字日期
if (typeof dateStr === 'number') {
let utc = new Date();
return new Date((dateStr - 25569) * 86400 * 1000 + utc.getTimezoneOffset() * 1000 * 60).getTime();
}
return null;
} catch (error) {
console.error('日期解析错误:', dateStr, error);
return null;
}
}
/**
* 处理注册资本和实缴资本
* @param {string} capitalStr
* @returns {string}
*/
function parseCapital(capitalStr) {
if (!capitalStr || capitalStr === '-') return '-';
// 提取数字部分
let match = capitalStr.match(/([\d\.]+)/);
return match ? match[1] + '万元' : capitalStr;
}
/**
* 处理参保人数
* @param {string|number} peopleStr
* @returns {number}
*/
function parsePeopleCount(peopleStr) {
if (!peopleStr || peopleStr === '-' || peopleStr === '0') return 0;
if (typeof peopleStr === 'number') {
return peopleStr;
}
let num = parseInt(peopleStr);
return isNaN(num) ? 0 : num;
}
/**
* 处理租赁面积
* @param {string|number} areaStr
* @returns {number}
*/
function parseLeasedArea(areaStr) {
if (!areaStr || areaStr === '-' || areaStr === '0') return 0;
if (typeof areaStr === 'number') {
return areaStr;
}
let num = parseFloat(areaStr);
return isNaN(num) ? 0 : num;
}
/**
* 处理数字字段
*/
function parseNumber(value, defaultValue = 0) {
if (value === undefined || value === null || value === '' || value === '-') {
return defaultValue;
}
if (typeof value === 'number') {
return value;
}
const num = parseFloat(value);
return isNaN(num) ? defaultValue : num;
}
/**
* 处理企业标签
* @param {Object} rowData Excel行数据
* @returns {Array} 标签数组
*/
function parseLabels(rowData) {
let labels = [];
let currentTime = new Date().valueOf();
// 1. 基础标签 (BASELABEL)
if (rowData['area3_73'] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["3.73平方公里"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData['area100'] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["100平方公里"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData['isSoftwareRelated'] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["软件关联入驻企业"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData['isSmallAccount'] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["小台账企业"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
if (rowData['isKeyBusiness'] === '是') {
labels.push({
labelId: labelEnum.BASELABEL["重点稳商企业"],
labelType: labelEnum.LABELTYPE.基础标签,
state: true
});
}
// 2. 入驻年份标签 (ENTERPRISESYSTEMLABEL)
let entryYear = rowData['parkEntryTime'];
if (entryYear && entryYear != "-") {
let yearValue;
switch (entryYear.toString()) {
case '2023':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2023年"];
break;
case '2024':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2024年"];
break;
case '2025':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2025年"];
break;
case '2026':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2026年"];
break;
case '2027':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2027年"];
break;
case '2028':
yearValue = labelEnum.ENTERPRISESYSTEMLABEL["2028年"];
break;
// default:
// yearValue = labelEnum.ENTERPRISESYSTEMLABEL["其他年份"];
}
labels.push({
labelId: yearValue,
labelType: labelEnum.LABELTYPE.入驻年份,
state: true
});
}
// 3. 所属物业（PROPERTY）
let property = rowData['property'];
if (property && property != "-") {
let propertyValue;
switch (property) {
case "于田大厦":
propertyValue = labelEnum.PROPERTY.于田大厦;
break;
case "同济科技园":
propertyValue = labelEnum.PROPERTY.同济科技园;
break;
case "嘉亭荟":
propertyValue = labelEnum.PROPERTY.嘉亭荟;
break;
case "智驾园":
propertyValue = labelEnum.PROPERTY.智驾园;
break;
case "汽车创新港":
propertyValue = labelEnum.PROPERTY.汽车创新港;
break;
case "汽车城大厦":
propertyValue = labelEnum.PROPERTY.汽车城大厦;
break;
}
labels.push({
labelId: propertyValue,
labelType: labelEnum.LABELTYPE.所属物业,
state: true
});
}
// 4. 企业性质 enterpriseNature: EnterpriseNatureMap[rowData.enterpriseNature] || labelEnum.ENTERPRISENATURE.实体型
let enterpriseNature = rowData['enterpriseNature'];
if (enterpriseNature && enterpriseNature != "-") {
let enterpriseNatureValue;
switch (enterpriseNature) {
case "实体型":
enterpriseNatureValue = labelEnum.ENTERPRISENATURE.实体型;
break;
case "注册型":
enterpriseNatureValue = labelEnum.ENTERPRISENATURE.注册型;
break;
case "虚拟型":
enterpriseNatureValue = labelEnum.ENTERPRISENATURE.虚拟型;
break;
}
labels.push({
labelId: enterpriseNatureValue,
labelType: labelEnum.LABELTYPE.企业性质,
state: true
});
}
return labels;
}
/**
* 初始化原始数据
*/
export async function initBasicData() {
await initLabel();
await initEnterpriseFromExcel();
}
/**
* 初始化企业标签库
*/
async function initLabel() {
try {
// 检查是否已有数据
let count = await labelData.selectLabelCount({});
if (count > 10) {
console.log("*** 标签数据 无需初始化");
return;
}
let addList = [];
// 1. 基础标签
let baseLabel = convertEnumToObject(labelEnum.BASELABEL);
for (let key in baseLabel) {
addList.push({
id: baseLabel[key],
labelName: key,
ctMs: new Date().valueOf(),
goal: labelEnum.LABELGOAL.企业,
labelType: labelEnum.LABELTYPE.基础标签,
state: false,
});
}
// 2. 入驻年份
let yearLabel = convertEnumToObject(labelEnum.YEARLABEL);
for (let key in yearLabel) {
addList.push({
id: yearLabel[key],
labelName: key,
ctMs: new Date().valueOf(),
goal: labelEnum.LABELGOAL.企业,
labelType: labelEnum.LABELTYPE.入驻年份,
state: false,
});
}
// 3. 企业性质
let enterprisenatureLabel = convertEnumToObject(labelEnum.ENTERPRISENATURE);
for (let key in enterprisenatureLabel) {
addList.push({
id: enterprisenatureLabel[key],
labelName: key,
ctMs: new Date().valueOf(),
goal: labelEnum.LABELGOAL.企业,
labelType: labelEnum.LABELTYPE.企业性质,
state: false,
});
}
// 4. 所属物业
let propertyLabel = convertEnumToObject(labelEnum.PROPERTY);
for (let key in propertyLabel) {
addList.push({
id: propertyLabel[key],
labelName: key,
ctMs: new Date().valueOf(),
goal: labelEnum.LABELGOAL.企业,
labelType: labelEnum.LABELTYPE.所属物业,
state: false,
});
}
//导入数据库
console.log(`准备导入 ${addList.length} 条标签数据`);
for (let i = 0; i < addList.length; i ++) {
let item = addList[i];
// 检查是否已存在
let existing = await labelData.selectLabelOne({id:item.id});
if (existing) {
console.log(`标签 ${item.labelName} (${item.id}) 已存在，跳过`);
continue;
}
// 创建新企业
await labelData.createOneLabel(item);
console.log(`创建标签: ${item.labelName}`);
}
console.log("---> 标签数据 初始化成功");
} catch (error) {
console.error("初始化标签数据失败:", error);
throw error;
}
}
/**
* 通用枚举转对象函数
*/
function convertEnumToObject(enumObj) {
const result = {};
for (const key in enumObj) {
// 跳过数字键
if (isNaN(Number(key))) {
const value = enumObj[key];
result[key] = value;
}
}
return result;
}
/**
* 初始化企业数据
*/
async function initEnterpriseFromExcel() {
try {
// 检查是否已有数据
let count = await enterpriseData.findEnterpriseCount({});
if (count > 10) {
console.log("*** 企业数据 无需初始化");
return;
}
// 读取Excel文件
let {sheetMap} = getExcel(path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", '企业标签数据_完整更新V2.xlsx' ));
// 获取工作表数据（根据Excel中的工作表名称）
let sheetName = '企业数据';
let dataList = sheetMap[sheetName];
if (!dataList || dataList.length === 0) {
console.log(`工作表 ${sheetName} 无数据`);
return;
}
console.log(`读取到 ${dataList.length} 行数据`);
// 表头映射（根据Excel列顺序）
// Excel列顺序：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z AA AB AC AD AE AF AG AH AI AJ AK AL AM AN AO AP AQ AR AS AT AU AV AW
// 对应表头：企业名称、登记状态、成立日期、注册资本、企业简介、法定代表人、实缴资本、统一社会信用代码、企业地址、所属省份...
// 注意：需要根据实际的Excel列顺序调整
let titleMap = {
"0": "name", // A: 企业名称
"1": "RAS", // B: 登记状态
"2": "logonTime", // C: 成立日期
"3": "zhuceziben", // D: 注册资本
"4": "jianJie", // E: 企业简介
"5": "legalPerson", // F: 法定代表人
"6": "shijiaoziben", // G: 实缴资本
"7": "uscc", // H: 统一社会信用代码
"8": "logonAdd", // I: 企业地址
"9": "province", // J: 所属省份
"10": "city", // K: 所属城市
"11": "district", // L: 所属区县
"12": "dianHua", // M: 电话
"13": "gengDuoDianHua", // N: 更多电话
"14": "mail", // O: 邮箱
"15": "moreMail", // P: 更多邮箱
"16": "enterpriseType", // Q: 企业（机构）类型
"17":"naShuiRenShiBieHao", // R: 纳税人识别号
"18": "zhuCeHao", // S: 注册号
"19": "zuZhiJiGouDaiMa", // T: 组织机构代码
"20": "canBaoRenShu", // U: 参保人数
"21": "canBaoRenShuNianBao", // V: 参保人数所属年报
"22": "yingYeQiXian", // W: 营业期限
"23": "industryCategoryGb", // X: 国标行业门类
"24": "industryMajorGb", // Y: 国标行业大类
"25": "industryMediumGb", // Z: 国标行业中类
"26": "industryMinorGb", // AA: 国标行业小类
"27": "industryCategoryQcc", // AB: 企查查行业门类
"28": "industryMajorQcc", // AC: 企查查行业大类
"29": "industryMediumQcc", // AD: 企查查行业中类
"30": "industryMinorQcc", // AE: 企查查行业小类
"31": "qiYeGuiMo", // AF: 企业规模
"32": "cengYongMing", // AG: 曾用名
"33": "yingWenMing", // AH: 英文名
"34": "guanWang", // AI: 官网
"35": "tongXinDiZhi", // AJ: 通信地址
"36": "jingYingFanWei", // AK: 经营范围
"37": "dengJiJiGuan", // AL: 登记机关
"38": "naShuiRenZiZhi", // AM: 纳税人资质
"39": "zuiXinNianBaoNianFen", // AN: 最新年报年份
"40": "leasedArea", // AO: 租赁面积（㎡）
"41": "enterpriseNature", // AP: 企业性质
"42": "property", // AQ: 所属物业
"43": "parkEntryTime", // AR: 入驻年份（用于标签）
"44": "area3_73", // AS: 3.73平方公里（标签字段）
"45": "area100", // AT: 100平方公里（标签字段）
"46": "isSoftwareRelated", // AU: 软件关联入驻企业（标签字段）
"47": "isSmallAccount", // AV: 小台账企业（标签字段）
"48": "isKeyBusiness" // AW: 重点稳商企业（标签字段）
};
let titleIndexList = Object.keys(titleMap);
let currentTime = new Date().valueOf();
let addList = [];
// 提取表头行（第0行）
let headerRow = dataList[0] || [];
// 处理每一行数据（从第1行开始）
for (let rowIndex = 1; rowIndex < dataList.length; rowIndex++) {
let subList = dataList[rowIndex];
// 构建行数据对象（用于标签解析）
let rowData:any = {};
titleIndexList.forEach((colIndex, idx) => {
let key = titleMap[colIndex];
let value = subList[parseInt(colIndex)];
rowData[key] = value;
});
//处理行业领域
let industryData = {industry:[], industryCategoryGb:""}
if (rowData.industryCategoryGb != "-") {
industryData.industryCategoryGb = industryEnum.INDUSTRY[rowData.industryCategoryGb];
}
if (rowData.industryCategoryGb != "-" && rowData.industryMajorGb != "-") {
industryData.industry = [industryEnum.ALLINDUSTRY[rowData.industryMajorGb]];
}
let labelList = parseLabels(rowData); //解析标签
let logonAdd = formatAddress(rowData.logonAdd); //解析注册地址
// 创建企业数据对象
let addDataInfo:any = {
isInPut: true,
createTime: currentTime,
labels: labelList,
RAS: rowData.RAS === '存续' ? configEnum.RAS.续存 : configEnum.RAS.注销,
logOffMS: null, // 注销时间，Excel中暂无此字段
legalPerson: rowData.legalPerson || '',
zhuceziben: parseCapital(rowData.zhuceziben),
shijiaoziben: parseCapital(rowData.shijiaoziben),
dianHua: rowData.dianHua || '',
gengDuoDianHua: rowData.gengDuoDianHua || '',
mail: rowData.mail || '-',
moreMail: rowData.moreMail || '-',
enterpriseType: rowData.enterpriseType || '',
zhuCeHao: rowData.zhuCeHao || '',
zuZhiJiGouDaiMa: rowData.zuZhiJiGouDaiMa || '',
canBaoRenShu: parseNumber(rowData.canBaoRenShu, 0),
canBaoRenShuNianBao: parseNumber(rowData.canBaoRenShuNianBao, 0),
yingYeQiXian: rowData.yingYeQiXian || '',
qiYeGuiMo: EnterpriseSizeMap[rowData.qiYeGuiMo] || configEnum.ENTERPRISESIZE.未知,
guanWang: rowData.guanWang || '',
tongXinDiZhi: rowData.tongXinDiZhi || '',
jianJie: rowData.jianJie || '',
dengJiJiGuan: rowData.dengJiJiGuan || '',
naShuiRenZiZhi: rowData.naShuiRenZiZhi === '一般纳税人' ? configEnum.NASHUIRENZIZHI.小规模纳税人 :
rowData.naShuiRenZiZhi === '小规模纳税人' ? configEnum.NASHUIRENZIZHI.一般纳税人 :
rowData.naShuiRenZiZhi === '非纳税人' ? configEnum.NASHUIRENZIZHI.增值税一般纳税人 : configEnum.NASHUIRENZIZHI.未知,
zuiXinNianBaoNianFen: parseNumber(rowData.zuiXinNianBaoNianFen, 0),
jingYingFanWei: rowData.jingYingFanWei || '',
industryCategoryGb: industryData.industryCategoryGb || '',
industryMajorGb: rowData.industryMajorGb || '',
industryMediumGb: rowData.industryMediumGb || '',
industryMinorGb: rowData.industryMinorGb || '',
industryCategoryQcc: rowData.industryCategoryQcc || '',
industryMajorQcc: rowData.industryMajorQcc || '',
industryMediumQcc: rowData.industryMediumQcc || '',
industryMinorQcc: rowData.industryMinorQcc || '',
// 主字段
name: rowData.name || '',
uscc: rowData.uscc || '',
isSettled: rowData.RAS === '存续' ? 1 : 0,
// industry: industryData.industry,
logonAddress: logonAdd || '',
logonTime: parseDateString(rowData.logonTime),
parkEntryTime: parseDateString(rowData.parkEntryTime),
leasedArea: parseNumber(rowData.leasedArea, 0),
enterpriseNature: EnterpriseNatureMap[rowData.enterpriseNature] || labelEnum.ENTERPRISENATURE.实体型,
property: propertyMap[rowData.property] || null,
//用户相关
pwd:getPwdMd5(rowData.uscc, md5(rowData.uscc.slice(rowData.uscc.length-6))),
firstLoginIsChangePwd:false,
};
if (industryData.industry) addDataInfo.industry = industryData.industry;
// 验证必填字段
if (!addDataInfo.name || !addDataInfo.uscc) {
console.log(`第 ${rowIndex + 1} 行数据缺少企业名称或统一信用代码，跳过`);
continue;
}
addList.push(addDataInfo);
}
console.log(`准备导入 ${addList.length} 条企业数据`);
// 分批导入
let batchSize = 50;
for (let i = 0; i < addList.length; i += batchSize) {
let batch = addList.slice(i, i + batchSize);
await createEnterpriseToList(batch);
console.log(`已导入 ${Math.min(i + batchSize, addList.length)}/${addList.length} 条数据`);
// 每批导入后暂停一下
if (i + batchSize < addList.length) {
await new Promise(resolve => setTimeout(resolve, 1000));
}
}
console.log("---> 企业数据 初始化成功");
} catch (error) {
console.error("初始化企业数据失败:", error);
throw error;
}
}
/**
* 批量创建企业数据
* @param {Array} enterpriseList
*/
async function createEnterpriseToList(enterpriseList) {
// 这里调用你的数据库操作函数
for (let enterprise of enterpriseList) {
try {
// 检查是否已存在
let existing = await findEnterpriseByUscc(enterprise.uscc);
if (existing) {
console.log(`企业 ${enterprise.name} (${enterprise.uscc}) 已存在，跳过`);
continue;
}
// 创建新企业
await createDataByParam(enterprise);
console.log(`创建企业: ${enterprise.name}`);
} catch (error) {
console.error(`创建企业 ${enterprise.name} 失败:`, error);
}
}
}
src/tools/system.ts 0 → 100644
/**
* 系统中使用的工具
* 包括 草稿箱id生成规则
* 包括 密码加密规则
*/
import moment = require("moment");
const md5 = require("md5");
/**
* 生成任务草稿箱Id
* @param uscc
* @returns
*/
export function getDraftId(uscc:string) {
return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random()*1000)}`);
}
/**
* 密码加密
* @param uscc 信用代码
* @param pwd 密码
* @returns md5后的密码
*/
export function getPwdMd5(uscc:string, pwd:string) {
return md5(uscc+pwd);
}
/**
* md5加密
* @param pwd
* @returns pwd 加密后密码
*/
export function md5PwdStr(pwd:string) {
return md5(pwd);
}
/**
* 获取token
* @param uscc 统一信用代码
*/
export function getToken(uscc:string) {
return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
}
/**
* 校验uscc是否合法
* @param uscc
* @returns true/false
*/
export function eccUscc(uscc:string) {
let isSuccess = false;
if (uscc.search(/^[A-Za-z0-9]{16}$/) > -1) isSuccess = true;
else if (uscc.search(/^[A-Za-z0-9]{18}$/) > -1) isSuccess = true;
return isSuccess;
}
/**
* 获取绑定id
* @param uscc 孵化器统一信用代码
* @param bindUscc 被绑定的孵化器统一信用代码
* @returns
*/
export function getBindId(uscc:string, bindUscc:string) {
return md5(`${uscc}${bindUscc}${Math.ceil(Math.random() *100)}`);
}
/**
* 获取今天开始时刻的时间戳 0时0分
* @returns
*/
export function getTodayMs() {
let t =`${ moment().format("YYYY-MM-DD")} 00:00:00`;
return new Date(t).valueOf();
}
/**
* 获取这个月的开始时刻的时间戳 0时0分
* @returns
*/
export function getThisMonthMs() {
let t =`${ moment().format("YYYY-MM")}-01 00:00:00`;
return new Date(t).valueOf();
}
/**
* 获取code的id
* @param uscc 发送人的uscc
* @param todaySendCount 今日发送次数
* @returns ''
*/
export function getSMSCodeId(uscc:string, todaySendCount:number) {
return md5(`${uscc}${todaySendCount}${new Date().valueOf()}`);
}
/**
* 获取一个随机6位数的验证码
* @returns
*/
export function getSMSCode() {
let code = ``;
for (let i =0; i < 6; i++) {
code += Math.floor(Math.random() * 10)
}
return code;
}
/**
* 生成融资id
* @param uscc
* @returns
*/
export function getFinancingId(uscc) {
return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random() * 1000)}`);
}
/**
* 生成创始团队成员id
* @param uscc
* @param name
* @returns
*/
export function getInitialTeamMemberId(uscc:string, name:string) {
return md5(`${uscc}${name}${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
}
/**
* 生成 资讯id
* @returns
*/
export function getInformationId() {
return md5(`${Math.ceil(Math.ceil(Math.random() * 1000000))}${new Date().valueOf() }${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
}
/**
* 获取上一个季度 年和季度
* @returns declarationYear：数据填报年 declarationQuarter：数据填报季度
*/
export function getLastQuarter() {
let thisYear = new Date().getFullYear();
let thisQuarter = moment().quarter();//当月填报季度
if ( (thisQuarter - 1) < 1 ) {
thisYear = moment().subtract(1, 'years').year();
thisQuarter = 4;
} else thisQuarter = thisQuarter - 1;
return {year:thisYear, quarter:thisQuarter};
}
export function getI18nRegisterId(uscc:string) {
return md5(`${uscc}${new Date().valueOf() }${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
}
export function getPolicyBGImgId() {
return `bgImg_${md5(`bgImg${new Date().valueOf()}${Math.ceil(Math.ceil(Math.random() * 1000000))}`)}`
}
/**
* 获取随机id
* @param uscc
*/
export function randomId(tableName:string) {
let randomStr = `${new Date().valueOf()}_${Math.ceil(Math.random()*100000)}`;
return `${tableName}_${md5(randomStr)}`;
}
export function changeAddToString(address) {
if (!address) return "";
let str = "";
address.forEach((item, index) => {
if (index == 0 && item == "上海市") return;
str += item;
});
return str;
}
export function getLabelId() {
return `${md5(`label${new Date().valueOf()}${Math.ceil(Math.ceil(Math.random() * 10000))}${Math.ceil(Math.ceil(Math.random() * 10000))}`)}`
}
/**
* 匹配企查查注册地址规则
* @param original
* @returns
*/
export function formatAddress(original) {
// 匹配省/直辖市（支持"北京市"/"上海"等格式）
const cityMatch = original.match(/^(.*?(?:省|市|自治区|特别行政区))/);
const city = cityMatch ? cityMatch[1] : original.split(/[市区县]/)[0] + '市';
// 匹配区级（支持"浦东新区"/"朝阳区"等格式）
const districtMatch = original.match(/(?:省|市)(.*?(?:区|县|市|旗))/);
const district = districtMatch ? districtMatch[1] : '';
// 处理详细地址（自动保留原格式，仅修正明显错误）
let detail = original.replace(city, '').replace(district, '')
.replace(/(\d+)[幢栋](\d+)层/g, (_, num1, num2) => {
const chineseNums = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
return `${chineseNums[parseInt(num1)] || num1}幢${num2}${num2.length === 1 ? '室' : ''}`;
})
.trim();
return [city, city, district || city, detail || '地址不详'];
}
src/tools/taskTool.ts 0 → 100644
/**
* 孵化器 任务相关工具
* 只允许被孵化器任务相关逻辑使用
*
*/
import moment = require("moment");
const md5 = require("md5");
/**----------------------------------------------月度任务 */
/**
* 获取日期的key
* @param timeMs 指定时间, 如果不传就是当前数据
* @returns YYYYM
*/
export function getTimeKey(timeMs?) {
if (timeMs) return parseInt(`${new Date(timeMs).getFullYear()}${new Date(timeMs).getMonth() + 1 }`);
return parseInt(`${new Date().getFullYear()}${new Date().getMonth() + 1 }`);
}
/**
* 生成月度任务id
* @param uscc 企业统一信用代码
* @returns uscc+YYYYM
*/
export function generateMonthTaskId(uscc:string) {
return `${uscc}${getTimeKey()}`;
}
/**
* 获取当前时间月度任务id
* @param uscc 企业标识
* @returns uscc+YYYYM
*/
export function getTaskId(uscc:string) {
return `${uscc}${getTimeKey()}`;
}
/**
* 根据时间获取任务id
* @param uscc 企业标识
* @param timeMs 时间戳
* @returns uscc+YYYYM
*/
export function getMonthTaskIdByTime(uscc:string, timeMs:number) {
return `${uscc}${getTimeKey(timeMs) }`;
}
/**
* 获取上一个月的日期标识
* @returns YYYYM(当前月的上一个月)
*/
export function getLastMonthTimeKey() {
return moment().subtract(1,'months').format('YYYYM');
}
/** ----------------------------------------------- 季度任务 */
/**
* 生成季度任务id
* 生成时所在季度
* @param uscc 企业标识
* @returns uscc+YYYY+0+Quarter
*/
export function generateQuarterTaskId(uscc:string) {
let thisQuarter = moment().quarter();//当月填报季度
return `${uscc}${new Date().getFullYear()}0${thisQuarter}`;
}
/**
* 获取当前季度任务id
* 季度是以填报季度,也就是当前季度当前季度
* @param uscc 企业标识
* @returns uscc+YYYY+0+Quarter
*/
export function getQuarterTaskId(uscc:string) {
let thisQuarter = moment().quarter();//当月填报季度
return `${uscc}${new Date().getFullYear()}0${thisQuarter}`;
}
/**
* 获取当前季度的时间标识
* @returns YYYY+0+Quarter
*/
export function getQuarterTimeKey() {
return parseInt(`${new Date().getFullYear()}0${moment().quarter()}`);
}
/**
* 获取指定时间戳的任务id
* @param uscc 孵化器统一信用代码
* @param timeMs 时间标识
* @returns uscc+YYYY+0+Quarter
*/
export function getQuarterTaskIdByTime(uscc:string, timeMs:number) {
return `${uscc}${new Date(timeMs).getFullYear()}0${moment(timeMs).quarter() }`;
}
/**
* 根据指定年和季度生成任务id
* @param uscc 孵化器统一信用代码
* @param year 年
* @param quarter 季度
* @returns uscc+YYYY+0+Quarter
*/
export function getQuarterTaskIdByYearAndQuarter(uscc:string, year:number, quarter:number) {
return `${uscc}${year}0${quarter }`;
}
\ 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/industryUtils.ts 0 → 100644
/**
* 行业领域相关处理工具方法
*/
import * as industryConfig from "../config/enum/industryEnum";
/**
* 创建行业映射的函数
* 构建一个从行业大类数字编码（1-97）到行业门类字母编码（A-T）的映射关系
* keyof typeof industryConfig 获取该类型的所有键名
* typeof industryConfig 获取 industryConfig 的类型
* 结果是：'INDUSTRY' | 'A' | 'B' | 'C' | ... | 'T'
* @returns {number:string} 返回映射对象，格式如 {1: "A", 2: "A", ..., 90: "R", ...}
*/
function createIndustryMap() {
let map = {};
// 获取所有以单个字母命名的子枚举（A-T）
let subEnumKeys = Object.keys(industryConfig)
.filter(key => key.length === 1 && /^[A-T]$/.test(key));
subEnumKeys.forEach((categoryKey) => {
let subEnum = industryConfig[categoryKey as keyof typeof industryConfig];
if (subEnum && typeof subEnum === 'object') {
Object.values(subEnum).forEach((value) => {
if (typeof value === 'number') {
map[value] = categoryKey;
}
});
}
});
return map;
}
/**
* 调用函数初始化映射
*/
export const IndustryMap = createIndustryMap();
/**
* 根据数字代码获取门类字母
* getIndustryCategoryByCode(90);
* @param code
* @returns "R"
*/
export function getIndustryCategoryByCode(code: number) {
return IndustryMap[code] || null;
}
/**
* 根据门类字母获取所有数字代码
* getIndustryCodesByCategory('R')
* @param category
* @returns [86, 87, 88, 89, 90]
*/
export function getIndustryCodesByCategory(category: string) {
let subEnum = industryConfig[category as keyof typeof industryConfig];
if (!subEnum || typeof subEnum !== 'object') return [];
return Object.values(subEnum)
.filter(v => typeof v === 'number') as number[];
}
/**
* 获取完整的行业信息（包括门类和大类）
* getIndustryFullInfo(90);
* @param code
* @returns {category: "R", categoryName: "文化、体育和娱乐业", subCategoryName: "娱乐业"}
*/
export function getIndustryFullInfo(code: number) {
let categoryKey = IndustryMap[code];
if (!categoryKey) return null;
// 获取门类名称
let categoryName = industryConfig.INDUSTRY[categoryKey as keyof typeof industryConfig.INDUSTRY];
// 获取大类名称
let subEnum = industryConfig[categoryKey as keyof typeof industryConfig];
let subCategoryName = '';
if (subEnum && typeof subEnum === 'object') {
// 反转枚举以通过值获取键
let reversedSubEnum = Object.entries(subEnum).reduce((acc, [key, value]) => {
if (typeof value === 'number') {
acc[value] = key;
}
return acc;
}, {} as Record<number, string>);
subCategoryName = reversedSubEnum[code] || '';
}
return {
category: categoryKey,
categoryName: String(categoryName),
subCategoryName
};
}
src/util/labelUtils.ts 0 → 100644
/**
* 标签相关处理工具方法
*/
import { LABELUPDATEROAD } from "../config/enum/labelEnum";
import * as labelData from "../data/label";
/**
* 标签去重函数
* @param {Array} array - 需要去重的数组
* @param {string|Function} [key] - 对象去重的键名或自定义函数
* @returns {Array} 去重后的数组
*
* 使用方法：
* 1、labels = [1, 2, 2, 3, 4, 4, 5];
* uniqueLabelList(labels) //直接数组去重
*
* 2、labels = [ {id:"1", name:""}, {id:"2", name:""} ];
* uniqueLabelList(labels, 'id') //根据id去重
* uniqueLabelList(labels, labels => labels.name) //根据name去重
*/
export function uniqueLabelList(array, key?) {
if (!Array.isArray(array)) {
return [];
}
// 如果是基本类型数组
if (!key) {
return [...new Set(array)];
}
// 如果key是函数
if (typeof key === 'function') {
const seen = new Set();
return array.filter(item => {
const k = key(item);
if (seen.has(k)) {
return false;
}
seen.add(k);
return true;
});
}
// 如果key是字符串（对象数组）
const seen = new Set();
return array.filter(item => {
const k = item[key];
if (seen.has(k)) {
return false;
}
seen.add(k);
return true;
});
}
/**
* 获取年份标签ID
* @param {Number} parkEntryTime 入驻时间戳
* @returns {String} 年份标签ID
*/
function getYearLabelId(parkEntryTime) {
let entryDate = new Date(parkEntryTime);
let entryYear = entryDate.getFullYear();
if (entryYear === 2023) {
return "2023";
} else if (entryYear === 2024) {
return "2024";
} else {
return "2100"; // 其他年份
}
}
/**
* 检查标签是否已存在
* @param {String} labelId 标签ID
* @param {Array} enterpriseLabels 企业标签数组
* @returns {Boolean} 是否已存在
*/
function labelExists(labelId, enterpriseLabels) {
for (let i = 0; i < enterpriseLabels.length; i++) {
if (enterpriseLabels[i].labelId === labelId) {
return true;
}
}
return false;
}
/**
* 标签去重
* @param {Array} labels 标签数组 [{labelId:""}]
* @returns {Array} 去重后的标签数组
*/
function deduplicateLabels(labels) {
let uniqueLabels = [];
let labelIdSet = {};
if (labels && labels.length > 0) {
labels.forEach(label => {
if (label && label.labelId && !labelIdSet[label.labelId]) {
labelIdSet[label.labelId] = true;
uniqueLabels.push(label);
}
});
}
return uniqueLabels;
}
/**
* 根据企业数据生成标签数组
* @param {Object} enterpriseData 企业数据
* @param {Array} activeLabels 可用的标签列表（未停用）
* @returns {Array} 处理后的标签数组
*/
export async function generateEnterpriseLabels(enterpriseData, activeLabels = null) {
// 如果没有传入可用标签，则获取一次
let availableLabels = activeLabels;
if (!availableLabels) {
availableLabels = await labelData.selectLabelList({
state: false // 未停用的标签
});
}
// 创建标签映射对象
let activeLabelMap = {};
if (availableLabels && availableLabels.length > 0) {
availableLabels.forEach(label => {
let labelIdStr = '';
if (label.id) labelIdStr = label.id.toString();
if (labelIdStr) {
activeLabelMap[labelIdStr] = label;
}
});
}
// 构建企业标签数组
let enterpriseLabels = [];
// 处理直接传入的标签
if (enterpriseData.labels && Array.isArray(enterpriseData.labels) && enterpriseData.labels.length > 0) {
enterpriseData.labels.forEach(labelId => {
if (labelId !== undefined && labelId !== null) {
let labelIdStr = labelId.toString();
let labelInfo = activeLabelMap[labelIdStr];
if (labelInfo && labelInfo.state === false) {
enterpriseLabels.push({
labelId: labelIdStr,
state: true
});
}
}
});
}
// 处理企业性质标签
if (enterpriseData.enterpriseNature !== undefined && enterpriseData.enterpriseNature !== null) {
let natureLabelId = enterpriseData.enterpriseNature.toString();
let labelInfo = activeLabelMap[natureLabelId];
if (labelInfo && labelInfo.state === false && !labelExists(natureLabelId, enterpriseLabels)) {
enterpriseLabels.push({
labelId: natureLabelId,
state: true
});
}
}
// 处理所属物业标签
if (enterpriseData.property !== undefined && enterpriseData.property !== null) {
let propertyLabelId = enterpriseData.property.toString();
let labelInfo = activeLabelMap[propertyLabelId];
if (labelInfo && labelInfo.state === false && !labelExists(propertyLabelId, enterpriseLabels)) {
enterpriseLabels.push({
labelId: propertyLabelId,
state: true
});
}
}
// 处理入驻园区时间标签
if (enterpriseData.parkEntryTime !== undefined && enterpriseData.parkEntryTime !== null) {
let yearLabelId = getYearLabelId(enterpriseData.parkEntryTime);
let labelInfo = activeLabelMap[yearLabelId];
if (labelInfo && labelInfo.state === false && !labelExists(yearLabelId, enterpriseLabels)) {
enterpriseLabels.push({
labelId: yearLabelId,
state: true
});
}
}
// 去重处理
return deduplicateLabels(enterpriseLabels);
}
/**
* 获取企业标签（用于回显）
* @param {Object} enterprise 企业数据
* @returns {Array} 标签ID数组
*/
// export function getLabelIdsForDisplay(enterprise) {
// if (!enterprise || !enterprise.labels || !Array.isArray(enterprise.labels)) {
// return [];
// }
// let labelIds = [];
// enterprise.labels.forEach(label => {
// if (label && label.state === true) {
// labelIds.push(label.labelId);
// }
// });
// return labelIds;
// }
/**
* 更新企业标签（封装函数，包含获取可用标签）
* @param {Object} enterpriseData 企业数据
* @returns {Promise<Array>} 更新后的标签数组
*/
export async function updateEnterpriseLabels(enterpriseData) {
let activeLabels = await labelData.selectLabelList({
state: false // 未停用的标签
});
return await generateEnterpriseLabels(enterpriseData, activeLabels);
}
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 conf
* @param data
* @returns
*/
export function extractData(conf, data, isAdmin) {
let result = {};
for (let key in conf) {
let confInfo = conf[key];
if (confInfo.changeDate) {
if (isAdmin) result[key] = data[key] ? moment(data[key]).format("YYYY-MM-DD") : '-';
else result[key] = data[key] || 0;
} else if (confInfo.isAdd && isAdmin) {
let addStr = "";
data[key].forEach(str => {
addStr += str;
});
result[key] = addStr;
}
else {
result[key] = data[key];
if (typeof result[key] == 'string' && !result[key]) result[key] = '';
}
}
return result;
}
/**
* 校验数据对象是否有空
* @param data
* @param sensitive 敏感校验 true时 0 和 ""会校验失败 false时 校验成功
* @returns true/false true = 有空值 false=无空值
*/
export function checkDataHaveNull(data:object, sensitive:boolean) {
if (Array.isArray(data)) return data.length == 0;
if (Object.keys(data).length == 0) return true;
let success = false;
for (let key in data) {
if (data[key] == null || data[key] == undefined) success = true;
if (sensitive) {
if (data[key] === 0 || data[key] === "" ) success = true;
}
}
return success;
}
\ 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, resBody) {
if (!error && response.statusCode == 200) {
resolve(resBody);
}
else {
// reject(error)
}
});
})
}
export function getQcc(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 (body) {
if (body.Status == 200) return resolve(body.Result);
else if (body.Status == 201) return resolve({});
// else if (body.Status == 126) {
// console.log("当前企业查无科创分");
// return resolve({});
// }
}
console.log(query.searchKey, body.Message || body);
return resolve({});
});
})
}
export function postForm(url, body, headers) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
return new Promise((resolve, reject)=>{
request({
url: url,
method: "POST",
json: true,
form:body
}, function(error, response, res) {
if (!error) {
resolve(res);
}
else {
reject(error)
}
});
})
}
export function cozePost(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, resBody) {
if (!error) {
resolve(resBody);
}
else {
resolve(error);
}
});
})
}
export function cozeGet(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) {
resolve(body);
}
else {
resolve(err);
}
});
})
}
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;
}
export function changeEnumManyValue(enumConf, value:any) {
let list = [];
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("_",")");
}
list.push(subStr);
});
return list;
}
/**
* 根据枚举值反向获取名称
* @param enumConf
* @param code
* @returns
*/
export function changeEnumNameByCode(enumConf, code: string) {
for (const [name, value] of Object.entries(enumConf)) {
if (value === code) {
return name;
}
}
return '未知行业';
}
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(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.参数错误, `多余${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.参数错误, `缺失${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.地址数据不完整, `${key} 下标 ${nullIndex} 为空 `);
}
}
if (nullIndex == -1 && !param[key][i]) {
/**按顺序第一次赋值 */
nullIndex = i;
}
}
break;
}
errorStr = isError && errorStr == "" ? `${key}应该是${confType}型 而不是${valueType}`: errorStr;
if (isError) throw new BizError(ERRORENUM.参数错误, errorStr);
}
}
return param;
}
\ 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