Skip to content

S
saspAdminServer
Commit b8e90c2a by chenjinjing
Options

版本V1

parent 49e7d4d5
Showing with 5052 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/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/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/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/log.ts 0 → 100644
This diff is collapsed. Click to expand it.
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