no message

package-lock.json

@@ -990,6 +990,14 @@
         }
       }
     },
+    "mongoose-auto-increment": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/mongoose-auto-increment/-/mongoose-auto-increment-5.0.1.tgz",
+      "integrity": "sha512-fuSw0np0ZZXYjNBBrD6Wg0y70N0i5NhBuH3AIETTXCchaq45FeHpISoQ3fFbbdSFhfVEDRtg+hVxEDpFjdI2lw==",
+      "requires": {
+        "extend": "^3.0.0"
+      }
+    },
     "mongoose-legacy-pluralize": {
       "version": "1.0.2",
       "resolved": "https://registry.npm.taobao.org/mongoose-legacy-pluralize/download/mongoose-legacy-pluralize-1.0.2.tgz",

package.json

@@ -16,6 +16,7 @@
     "md5": "^2.2.1",
     "moment": "^2.24.0",
     "mongoose": "^5.4.0",
+    "mongoose-auto-increment": "^5.0.1",
     "mysql": "^2.18.1",
     "node-xlsx": "^0.16.1",
     "nodemailer": "^6.1.1",

serverConfig.xml

 <config>
-    <port>7078</port>
+    <port>7079</port>
     <mongodb>
         <path>127.0.0.1</path>
         <port>27017</port>

src/biz/applet/base.ts

@@ -9,26 +9,23 @@ import * as configEnum from "../../config/enum";
 import * as splitResultConfig from "../../config/splitResultConfig";
 import { extractData } from '../../util/piecemeal';
 import { changeEnumValue, eccEnumValue } from '../../util/verificationEnum';
-import { BizError } from '../../util/bizError';
-import { ERRORENUM } from '../../config/errorEnum';
+import moment = require('moment');
 
 
 /**
  * 主页基础数据
  */
 export async function homeData() {
-    /**党员总数 */
-    let partyMemberNum = await partyMemberData.groupFindPartyMemberCount({});
-    /**党建指令指数 */
-    let massIndex = 87.6;
+    let partyMemberNum = await partyMemberData.groupFindPartyMemberCount({}); //党员总数
+    let massIndex = 87.6; //党建指令指数
 
-    /**党内职务人员 */ 
-    let partyPositions = [];
+    let partyPositions = []; //党内职务人员
     for (let key in configEnum.PARTYPOSITIONS) {
         let anyKey:any = key;
+        if (key != "党员" && key != "入党积极分子" && key != "预备党员") {
             if (isNaN(anyKey)) { //枚举key  key = string
                 const EnumValue = parseInt(configEnum.PARTYPOSITIONS[key])
-            let dataBaseList = await partyMemberData.getBaseListByPartyPositions( EnumValue );
+                let dataBaseList = await partyMemberData.getBaseListByPartyPositions( [EnumValue] );
         
                 let nameList = [];
                 dataBaseList.forEach( info => {
@@ -43,6 +40,8 @@ export async function homeData() {
             }
         }
         
+    }
+
     return { partyMemberNum, massIndex, partyPositions };
 }
 
@@ -53,19 +52,15 @@ export async function homeData() {
  * @returns 
  */
 export async function informationData(informationType:number) {
-    let selectParam:any = {};
-    if (informationType) {
-        eccEnumValue("党建资讯列表查询", "资讯类型", configEnum.INFORMATIONTYPE, informationType);
-        selectParam.informationType = informationType;
-    }
+    if (informationType) eccEnumValue("党建资讯列表查询", "资讯类型", configEnum.INFORMATIONTYPE, informationType);
 
-    /**医院文化 */
-    let partyInformationInfo = await partyInformationData.findPartyInformationList(selectParam);
+    let partyInformationInfo = await partyInformationData.findPartyInformationListByType(informationType);
 
     let dataList = [];
     partyInformationInfo.forEach( info => {
         let changeData:any = extractData(splitResultConfig.partyInformationConfig, info, false);
         changeData.informationType = changeEnumValue(configEnum.INFORMATIONTYPE, changeData.informationType);
+        changeData.informationTime = moment(changeData.informationTime).format("YYYY.MM.DD HH:mm");
 
         dataList.push(changeData);
     })

src/biz/applet/organizationalLife/organizationalLife.ts

-/**
- * 小程序
- * 组织生活
- */
-
-import moment = require("moment");
-import * as organizationalLifeData from "../../../data/organizationalLife";
-import * as configEnum from "../../../config/enum";
-import { eccFormParam } from "../../../util/verificationParam";
-import * as eccFormParamConfig from "../../../config/eccFormParamConfig";
-import * as verificationEnumTools from "../../../util/verificationEnum";
-import { ERRORENUM } from "../../../config/errorEnum";
-import { BizError } from "../../../util/bizError";
-import { extractData } from "../../../util/piecemeal";
-import * as splitResultConfig from "../../../config/splitResultConfig";
-
-
-/**
- * 组织生活列表
- * todo  接口协议不对
- * @param status 活动状态 全部、正在进行、即将开展、已经开展
- * @return {allActivity, afootActivity, beginInActivity, startedActivity}
- * 返回说明 {全部活动列表, 正在进行活动列表, 即将开展活动列表, 已经开展活动列表}
- */
-export async function getOrganizationalLifeList(type) {
-
-    let selectParam = {};
-    let now = new Date().valueOf();
-    switch (type) {
-        case enum.正在进行:
-            selectParam.startTime:{"$gt"}
-    }
-
-    1000
-
-    let organizationalLifeInfo = await organizationalLifeData.findOrganizationalLifeList(selectParam);
-
-    
-    /**全部活动列表 */
-    let allActivity = [];
-    /**正在进行活动列表 */
-    let afootActivity = [];
-    /**即将开展活动列表 */
-    let beginInActivity = [];
-    /**已经开展活动列表 */
-    let startedActivity = [];
-
-    organizationalLifeInfo.forEach( info => {
-        let activityStatus = getActivityStatus(info.activityStartTime, info.activityEndTime)
-        let activityTime = "2023.05.17 14:00--16:00"; // -----------todo 活动时间 格式不确定，之后修改---------------------
-        
-        allActivity.push({
-            _id: info._id,
-            partyActivityType: info.partyActivityType,
-            activityTime,
-            activityAdd: info.activityAdd,
-            activityStatus
-        });
-
-        switch (activityStatus) {
-            case "正在进行":
-                afootActivity.push({
-                    _id: info._id,
-                    partyActivityType: info.partyActivityType,
-                    activityTime,
-                    activityAdd: info.activityAdd,
-                    activityStatus
-                });
-            break;
-            case "即将开展":
-                beginInActivity.push({
-                    _id: info._id,
-                    partyActivityType: info.partyActivityType,
-                    activityTime,
-                    activityAdd: info.activityAdd,
-                    activityStatus
-                });
-            break;
-            case "已经开展":
-                startedActivity.push({
-                    _id: info._id,
-                    partyActivityType: info.partyActivityType,
-                    activityTime,
-                    activityAdd: info.activityAdd,
-                    activityStatus
-                });
-            break;
-        }
-    })
-
-    return {allActivity, afootActivity, beginInActivity, startedActivity};
-}
-
-
-/**
- * 组织生活活动状态
- * 活动状态 1：正在进行、2：即将开展、3：已经开展
- * @param activityStartTime 活动开始时间
- * @param activityEndTime 活动结束时间
- * @return status --活动状态
- */
-function getActivityStatus(activityStartTime, activityEndTime) {
-    let nowTime = new Date().valueOf();
-
-    let startTime = moment(activityStartTime).format("YYYY.MM.DD HH:mm");
-    let endTime = moment(activityEndTime).format("YYYY.MM.DD HH:mm");
-    let underway = moment().isBetween(startTime, endTime); //true：正在进行
-
-    let status;
-    if (underway) {
-        status = "正在进行";
-    }
-
-    if (nowTime < activityStartTime) {
-        status = "即将开展";
-    }
-
-    if (nowTime > activityStartTime) {
-        status = "已经开展";
-    }
-
-    return status
-}
-
-
-/**
- * 创建组织生活活动
- * @param param  {党建活动类型, 活动开始时间, 活动结束时间, 活动地点, 活动主持人, 活动记录人, 请假党员, 参与党员, 活动记录}
- *      参数类型  {  number,      number,      number,    string,  [string],  [string],  [string], [string], string}
- * @return {isSuccess: true}
- */
-export async function createActivity(param) {
-    eccFormParam("创建组织生活活动", eccFormParamConfig.CreateActivityConfig, param)
-    verificationEnumTools.eccEnumValue('创建组织生活活动的党建活动类型', 'partyActivityType', configEnum.ACTIVITYTYPE, param.partyActivityType);
-
-    await organizationalLifeData.createActivity(param);
-
-    return {isSuccess: true};
-}
-
-
-export async function getActivityById(_id) {
-    let activityInfo = await organizationalLifeData.findEventDetails(_id);
-    if (!activityInfo ) throw new BizError(ERRORENUM.未找到数据, `库中不存在${_id}这个组织生活活动`);
-
-    /**截取返回字段 */
-    let data = extractData(splitResultConfig.activityInfoConfig, activityInfo, false);
-
-
-}
\ No newline at end of file

src/biz/applet/partyMember/organizationalLife.ts

+/**
+ * 小程序
+ * 组织生活
+ */
+
+import moment = require("moment");
+import * as organizationalLifeData from "../../../data/organizationalLife";
+import * as configEnum from "../../../config/enum";
+import { eccFormParam } from "../../../util/verificationParam";
+import * as eccFormParamConfig from "../../../config/eccFormParamConfig";
+import * as verificationEnumTools from "../../../util/verificationEnum";
+import { checkChange, extractData } from "../../../util/piecemeal";
+import * as splitResultConfig from "../../../config/splitResultConfig";
+import * as partyMemberData from "../../../data/partyMember";
+import { BizError } from "../../../util/bizError";
+import { ERRORENUM } from "../../../config/errorEnum";
+
+moment.suppressDeprecationWarnings = true;
+
+/**
+ * 组织生活列表
+ * todo  接口协议不对
+ * @param status 活动状态 全部、正在进行、即将开展、已经开展
+ * @return data
+ * 返回说明 根据传入的活动状态返回不同的列表
+ */
+export async function getOrganizationalLifeList(type:number, name:number) {
+    let allmoveAbout = []; //全部活动列表
+    let moveAboutList = [];
+
+    let data = [];
+
+    switch (type) {
+        case configEnum.TYPE.正在进行:
+            moveAboutList = await organizationalLifeData.findAfootActivityList(name);
+        break;
+        case configEnum.TYPE.即将开展:
+            moveAboutList = await organizationalLifeData.findBeginInActivityList(name);
+        break;
+        case configEnum.TYPE.已经开展:
+            moveAboutList = await organizationalLifeData.findStartedActivityList(name);
+        break;
+        default:
+            allmoveAbout = await organizationalLifeData.findOrganizationalLifeList({partyActivityType:name});
+            allmoveAbout.forEach(info => {
+                let activityStatus = getActivityStatus(info.activityStartTime, info.activityEndTime);
+                data.push({
+                    id: info.id,
+                    partyActivityType: verificationEnumTools.changeEnumValue(configEnum.ACTIVITYTYPE, info.partyActivityType),
+                    activityStartTime: moment(info.activityStartTime).format("YYYY.MM.DD HH:mm"),
+                    activityEndTime: moment(info.activityEndTime).format("YYYY.MM.DD HH:mm"),
+                    activityAdd: info.activityAdd,
+                    activityStatus
+                });
+            })
+        break;
+    }
+
+    moveAboutList.forEach( info => {
+        let changeData:any = extractData(splitResultConfig.moveAboutInfoConfig, info, false);
+        changeData.partyActivityType = verificationEnumTools.changeEnumValue(configEnum.ACTIVITYTYPE, info.partyActivityType);
+        changeData.activityStartTime = moment(info.activityStartTime).format("YYYY.MM.DD HH:mm"); 
+        changeData.activityEndTime = moment(info.activityEndTime).format("YYYY.MM.DD HH:mm");
+        changeData.activityStatus = getActivityStatus(info.activityStartTime, info.activityEndTime);
+        data.push(changeData);
+    })
+    
+    return data;
+}
+
+
+/**
+ * 创建组织生活活动
+ * @param param  {党建活动类型, 活动开始时间, 活动结束时间, 活动地点, 活动主持人, 活动记录人, 请假党员, 参与党员, 活动记录}
+ *      参数类型  {  number,      number,      number,    string,  [string],  [string],  [number], [number], string}
+ * @return {isSuccess: true}
+ */
+export async function createOrganizationalLife(param) {
+    eccFormParam("创建组织生活活动", eccFormParamConfig.CreateActivityConfig, param)
+    verificationEnumTools.eccEnumValue('创建组织生活活动的党建活动类型', 'partyActivityType', configEnum.ACTIVITYTYPE, param.partyActivityType);
+
+    await organizationalLifeData.createActivity(param);
+
+    return {isSuccess: true};
+}
+
+
+/**
+ * 组织生活详细信息
+ * @param oId 编号
+ * @returns 
+ */
+export async function getOrganizationalLifeById(oId:number) {
+    let activityInfo = await organizationalLifeData.findEventDetails(oId);
+    let changeData:any = {};
+    let leavePartyMember = [];
+    let participatingPartyMember = [];
+
+    /**截取返回字段 */
+    changeData = extractData(splitResultConfig.activityInfoConfig, activityInfo, false);
+    changeData.partyActivityType = verificationEnumTools.changeEnumValue(configEnum.ACTIVITYTYPE, activityInfo.partyActivityType);
+    changeData.activityStartTime = moment(activityInfo.activityStartTime).format("YYYY.MM.DD HH:mm"); 
+    changeData.activityEndTime = moment(activityInfo.activityEndTime).format("YYYY.MM.DD HH:mm"); 
+
+    //请假党员
+    for (let i = 0; i < activityInfo.leavePartyMember.length; i++) {
+        let nameData = await partyMemberData.getNameById(activityInfo.leavePartyMember[i]);
+        nameData.forEach( nameInfo => {
+            leavePartyMember.push(nameInfo.name);
+        })
+    };
+
+    //参与党员
+    for (let i = 0; i < activityInfo.participatingPartyMember.length; i++) {
+        let name = await partyMemberData.getNameById(activityInfo.participatingPartyMember[i]);
+        name.forEach( nameInfo => {
+            participatingPartyMember.push(nameInfo.name);
+        })
+    };
+    changeData.activityStatus = getActivityStatus(activityInfo.activityStartTime, activityInfo.activityEndTime);
+
+    changeData.leavePartyMember = leavePartyMember;
+    changeData.participatingPartyMember = participatingPartyMember;
+
+    
+    return changeData;
+}
+
+
+/**
+ * 修改组织生活活动详情
+ * @param oId 组织生活id 修改对应oId的组织生活信息
+ * @param param {党建活动类型, 活动开始时间, 活动结束时间, 活动地点, 活动主持人, 活动记录人, 请假党员, 参与党员, 活动记录}
+ *      参数类型 {  number,      number,      number,    string,  [string],  [string],  [number], [number], string}
+ * @returns 
+ */
+export async function updateOrganizationalLife(oId:number, param) {
+    /**校验表单参数 */
+    eccFormParam("组织生活活动表单修改", eccFormParamConfig.UpdateActivityFormConfig, param );
+    verificationEnumTools.eccEnumValue('修改组织生活', 'partyActivityType', configEnum.ACTIVITYTYPE, param.partyActivityType);
+    
+    let activityInfo = await organizationalLifeData.findEventDetails(oId);
+    if (!activityInfo) throw new BizError(ERRORENUM.未找到数据, `库中不存在id为${oId}的组织活动`);
+    
+    let changeList = checkChange(param, activityInfo);
+    if ( !changeList.length ) throw new BizError(ERRORENUM.数据无更新, `${oId}数据无更新`);
+
+    changeList.forEach(key => {
+        activityInfo[key] = param[key];
+    });
+
+    await activityInfo.save();
+
+    return {isSuccess:true};
+}
+
+
+/**
+ * 创建/修改组织生活选择党员
+ * @param type 1：党员干部、2：入党积极分子、3：预备党员、4：全部党员 用于选项卡切换类型 
+ * @param name 党员姓名  用于输入党员姓名查询
+ * @returns 根据传入的type返回不同党员信息
+ */
+export async function getPartyMemberNameList(type:number, name:string) {
+    let selectParam:any = {};
+    let partyMemberList;
+
+    if (type != 4) {
+        selectParam.entryType = type;
+        if(name != null) {
+            selectParam.name = name;
+        }
+        partyMemberList = await partyMemberData.getPartyMemberListByEntryType(selectParam);
+    } else {
+        partyMemberList = await partyMemberData.findPartyMemberAll(selectParam);
+    }
+
+    let data = [];
+    partyMemberList.forEach( info => {
+        let changeData:any = extractData(splitResultConfig.partyMemberConfig, info, false);
+        changeData.partyPositions = verificationEnumTools.changeEnumValue(configEnum.PARTYPOSITIONS, info.partyPositions);
+        data.push(changeData);
+    })
+    return data;
+}
+
+
+/**
+ * 创建/修改组织生活选择党员
+ * @returns 返回所有党员信息
+ */
+export async function getAllPartyMember() {
+    let partyMemberList = await partyMemberData.findPartyMemberAll({});
+    let data = [];
+    partyMemberList.forEach( info => {
+        let changeData:any = extractData(splitResultConfig.partyMemberConfig, info, false);
+        changeData.partyPositions = verificationEnumTools.changeEnumValue(configEnum.PARTYPOSITIONS, info.partyPositions);
+        switch (changeData.entryType) {
+            case 1:
+                changeData.color = "#C62A23";
+            break;
+            case 2:
+                changeData.color = "#3549B0";
+            break;
+            case 3:
+                changeData.color = "#E4B386";
+            break;
+        }
+        data.push(changeData);
+    })
+
+    return data;
+}
+
+
+/**
+ * 删除组织生活活动
+ * @param oId 活动id
+ * @returns 
+ */
+export async function deleteOrganizationalLife(oId:number) {
+    let activityInfo = await organizationalLifeData.findEventDetails(oId);
+    if (activityInfo) throw new BizError(ERRORENUM.未找到数据, `库中不存在id为${oId}的组织活动`);
+
+    await organizationalLifeData.deleteActivity(oId);
+
+    return {isSuccess:true};
+}
+
+
+/**
+ * 组织生活活动状态
+ * 活动状态 1：正在进行、2：即将开展、3：已经开展
+ * @param activityStartTime 活动开始时间
+ * @param activityEndTime 活动结束时间
+ * @return status --活动状态
+ */
+function getActivityStatus(activityStartTime:number, activityEndTime:number) {
+    let nowTime = new Date().valueOf();
+
+    let startTime = moment(activityStartTime).format("YYYY.MM.DD HH:mm");
+    let endTime = moment(activityEndTime).format("YYYY.MM.DD HH:mm");
+    let underway = moment().isBetween(startTime, endTime); //true：正在进行
+
+    let status;
+    if (underway) {
+        status = "正在进行";
+    }
+
+    if (nowTime < activityStartTime) {
+        status = "即将开展";
+    }
+
+    if (nowTime > activityStartTime) {
+        status = "已经开展";
+    }
+
+    return status;
+}
\ No newline at end of file

src/biz/applet/partyMember/partyInforMation.ts

+/**
+ * 小程序
+ * 党建资讯
+ */
+
+import * as partyInformationData from "../../../data/partyInformation";
+import { eccFormParam } from "../../../util/verificationParam";
+import * as eccFormParamConfig from "../../../config/eccFormParamConfig";
+import * as verificationEnumTools from "../../../util/verificationEnum";
+import * as configEnum from "../../../config/enum";
+
+
+/**
+ * 创建党建资讯
+ * @param param {informationType: 党建资讯类型, title: "资讯标题", branch: "支部名称", informationTime: 资讯时间, detailedInformation: "资讯详细", img: "资讯图片"}
+ * @return {isSuccess: true}
+ */
+export async function createPartyInformation(param) {
+    eccFormParam("创建党建资讯", eccFormParamConfig.CreatePartyMemberFormConfig, param)
+    let partyInformation = await partyInformationData.createPartyInformation(param);
+    verificationEnumTools.eccEnumValue('党建资讯类型', 'informationType', configEnum.INFORMATIONTYPE, param.informationType);
+
+    await partyInformation.save();
+
+    return {isSuccess: true};
+}
\ No newline at end of file

src/biz/applet/partyMember/partyMember.ts

+/**
+ * 小程序
+ * 党员基本信息
+ */
+
+import * as partyMemberData from "../../../data/partyMember";
+import * as configEnum from "../../../config/enum";
+import { extractData } from "../../../util/piecemeal";
+import * as splitResultConfig from "../../../config/splitResultConfig";
+import * as verificationEnumTools from "../../../util/verificationEnum";
+import { eccFormParam } from "../../../util/verificationParam";
+import * as eccFormParamConfig from "../../../config/eccFormParamConfig";
+import { getPwdMd5, getToken } from "../../../tools/system";
+
+
+/**
+ * 创建党员基础信息
+ * @param param  {name: "姓名", sex: 性别, birthDate: 出生年月, phone: "手机号码", levelOfEducation: "文化程度", partyJoiningTime: 入党时间, administrativePosition: 行政职务, 
+ *                remarks: "备注", entryType: 名册录入类型, partyPositions: [党内职务, ...], listedAsActivistsTime: 列为积极份子时间, talkTime: 谈话时间, loginId: "登录账号"}
+ * @return {isSuccess: true}
+ */
+ export async function createPartyMember(param) {
+    eccFormParam("创建正式党员录入", eccFormParamConfig.CreatePartyMemberFormConfig, param);
+    verificationEnumTools.eccEnumValue('正式党员录入性别', 'partyActivityType', configEnum.SEX, param.partyActivityType);
+    verificationEnumTools.eccEnumValue('正式党员录入党内职务', 'partyPositions', configEnum.PARTYPOSITIONS, param.partyPositions);
+    verificationEnumTools.eccEnumValue('正式党员名册录入类型', 'entryType', configEnum.ENTRYTYPE, param.entryType);
+
+    let partyMemberInfo:any = await partyMemberData.createPartyMember(param);
+    partyMemberInfo.pwd = getPwdMd5(param.phone, param.phone.slice(5, 11));
+    partyMemberInfo.token = getToken(param.phone);
+    partyMemberInfo.tokenMs = new Date().valueOf();
+
+    await partyMemberInfo.save();
+
+    return {isSuccess: true};
+}
\ No newline at end of file

src/biz/applet/user.ts

@@ -36,6 +36,7 @@ export async function login(loginId:string, pwd:string) {
     return loginUserInfo;
 }
 
+
 /**
  * 首次登录修改密码
  * @param loginId 登录账号
@@ -57,3 +58,34 @@ export async function firstLoginChangePwd(loginId:string, pwd:string, confirmPwd
 
     return {isSuccess: true};
 }
+
+
+/**
+ * 修改密码
+ * 小程序端 2.0
+ * @param uscc 信用代码
+ * @param pwd 原密码  md5之后的
+ * @param newPwd 新密码  未md5
+ * @param confirmPwd 确认新密码  未md5
+ * @returns {isSuccess:true/false}
+ */
+ export async function changePassword(loginId:string, pwd:string, newPwd:string, confirmPwd:string ) {
+    if (newPwd != confirmPwd) throw new BizError(ERRORENUM.密码不一致);
+    if (newPwd.search(/^[A-Za-z0-9]{6,18}$/) < 0) throw new BizError(ERRORENUM.密码只能由6至18位字符和数字组成);
+
+    let partyMemberInfo = await partyMemberData.findPartyMemberByLoginId(loginId);
+    if (!partyMemberInfo) throw new BizError(ERRORENUM.未找到数据);
+
+    /**由于pwd是md5之后的 所以这里md5一次即可 */
+    let checkPwd = sysTools.getPwdMd5(partyMemberInfo.uscc, pwd);
+    if (partyMemberInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+
+    /**考虑到如果前端把新密码也md5 就不可以验证是不是符合规则 所以前端传的是明文
+     * 我们初始化密码的时候 有两次加密 第一次是密码md5 然后再和uscc 进行md5
+     * 于是这里也要如此操作
+     */
+     partyMemberInfo.pwd = sysTools.getPwdMd5(loginId, sysTools.md5PwdStr(newPwd));
+    await partyMemberInfo.save();
+
+    return {isSuccess:true};
+}
\ No newline at end of file

src/config/eccFormParamConfig.ts

@@ -8,18 +8,76 @@
 
 
 /**
- * 使用端: 小程序端
+ * 使用端: 小程序端_党员入口
  *   场景: 创建组织生活活动表单
- *   备注:   
+ *   备注: 全部非必填
  */
 export const CreateActivityConfig = {
-    partyActivityType:{type:"Number"},//党建活动类型
-    activityStartTime:{type:"Number"},//活动开始时间
-    activityEndTime:{type:"Number"},//活动结束时间
-    activityAdd:{type:"String"},//活动地点
-    activityHost:{type:"[Object]"},//活动主持人
-    activityNoteTaker:{type:"[Object]"},//活动记录人
-    leavePartyMember:{type:"[Object]", notMustHave:true},//请假党员
-    participatingPartyMember:{type:"[Object]", notMustHave:true},//参与党员
+    partyActivityType:{type:"Number", notMustHave:true},//党建活动类型
+    activityStartTime:{type:"Number", notMustHave:true},//活动开始时间
+    activityEndTime:{type:"Number", notMustHave:true},//活动结束时间
+    activityAdd:{type:"String", notMustHave:true},//活动地点
+    activityHost:{type:"[String]", notMustHave:true},//活动主持人
+    activityNoteTaker:{type:"[String]", notMustHave:true},//活动记录人
+    leavePartyMember:{type:"[Number]", notMustHave:true},//请假党员
+    participatingPartyMember:{type:"[Number]", notMustHave:true},//参与党员
     participationRecord:{type:"String", notMustHave:true},//活动记录
 };
+
+
+/**
+ * 使用端: 小程序端_党员入口
+ *   场景: 修改组织生活活动表单
+ *   备注: 全部非必填
+ */
+export const UpdateActivityFormConfig = {
+    partyActivityType:{type:"Number", notMustHave:true},//党建活动类型
+    activityStartTime:{type:"Number", notMustHave:true},//活动开始时间
+    activityEndTime:{type:"Number", notMustHave:true},//活动结束时间
+    activityAdd:{type:"String", notMustHave:true},//活动地点
+    activityHost:{type:"[String]", notMustHave:true},//活动主持人
+    activityNoteTaker:{type:"[String]", notMustHave:true},//活动记录人
+    leavePartyMember:{type:"[Number]", notMustHave:true},//请假党员
+    participatingPartyMember:{type:"[Number]", notMustHave:true},//参与党员
+    participationRecord:{type:"String", notMustHave:true},//活动记录
+}
+
+
+
+/**
+ * 使用端: 小程序端_党员入口
+ *   场景: 创建正式党员录入表单
+ *   备注: 全部非必填
+ */
+ export const CreatePartyMemberFormConfig = {
+    name:{type:"String"},//姓名
+    sex:{type:"Number"},//性别
+    birthDate:{type:"Number"},//出生年月
+    phone:{type:"String"},//手机号码
+    levelOfEducation:{type:"String"},//文化程度
+    partyJoiningTime:{type:"Number"},//入党时间
+    administrativePosition:{type:"Number"},//行政职务
+    remarks:{type:"String", notMustHave:true},//备注
+    entryType:{type:"Number"},//名册录入类型
+    partyPositions:{type:"[Number]"},//党内职务
+    listedAsActivistsTime:{type:"Number", notMustHave:true},//列为积极份子时间
+    talkTime:{type:"Number", notMustHave:true},//谈话时间
+    loginId:{type:"String", notMustHave:true},//登录账号
+    pwd:{type:"String", notMustHave:true},//密码
+}
+
+
+/**
+ *  使用端: 小程序端_党员入口
+ *   场景: 创建党建资讯录入表单
+ *   备注: 全部非必填
+ */
+export const createPartyInformation = {
+    pid:{type:"Number", notMustHave:true},
+    informationType:{type:"Number", notMustHave:true},
+    title:{type:"String", notMustHave:true},
+    branch:{type:"String", notMustHave:true},
+    inforMationTime:{type:"Number", notMustHave:true},
+    detailedInformation:{type:"String", notMustHave:true},
+    img:{type:"String", notMustHave:true}
+}
\ No newline at end of file

src/config/enum.ts

@@ -7,7 +7,20 @@ export enum PARTYPOSITIONS {
     支部副书记,
     纪检委员,
     组织委员,
-    宣传委员
+    宣传委员,
+    党员,
+    入党积极分子,
+    预备党员,
+}
+
+
+/**
+ * 组织生活活动类型
+ */
+export enum TYPE {
+    正在进行 = 1,
+    即将开展,
+    已经开展
 }
 
 
@@ -34,7 +47,7 @@ export enum ACTIVITYTYPE {
 }
 
 /**
- * 党建咨询类型
+ * 党建资讯类型
  */
 export enum INFORMATIONTYPE {
     医院文化 = 1,
@@ -44,15 +57,6 @@ export enum INFORMATIONTYPE {
 }
 
 /**
- * 最高学历
- */
-export enum DEGREE {
-    本科 = 1,
-    硕士,
-    博士
-}
-
-/**
  * 性别
  */
 export enum SEX {

src/config/errorEnum.ts

 
 export enum ERRORENUM {
     未找到数据,
+    账号不存在,
+    密码错误,
+    密码不一致,
+    密码只能由6至18位字符和数字组成,
+    不能重复修改密码,
+    表单校验失败,
+    参数错误,
+    数据无更新,
+    地址数据不完整
 }
 
 export enum ERRORCODEENUM {

src/config/splitResultConfig.ts

@@ -6,12 +6,12 @@
 
 
 /**
- * 使用端:   管理后台
- * 场景:     孵化器基础数据列表
- * 备注:     导出和列表共用一份配置
+ * 使用端:   小程序_党员入口
+ * 场景:     首页党建资讯列表
+ * 备注:     
  */
 export const partyInformationConfig = {
-    _id:{key:"id"},
+    id:{key:"id"},
     informationType:{key:"党建资讯类型"},
     title:{key:"资讯标题"},
     branch:{key:"支部"},
@@ -20,8 +20,12 @@ export const partyInformationConfig = {
 };
 
 
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     组织生活详细信息
+ * 备注:     
+ */
 export const activityInfoConfig = {
-    
     partyActivityType:{key:"党建活动类型"},
     activityStartTime:{key:"活动开始时间"},
     activityEndTime:{key:"活动结束时间"},
@@ -31,4 +35,34 @@ export const activityInfoConfig = {
     leavePartyMember:{key:"请假党员"},
     participatingPartyMember:{key:"参与党员"},
     participationRecord:{key:"活动记录"},
+    activityStatus:{key:"活动状态"}
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     组织生活
+ * 备注:     
+ */
+export const moveAboutInfoConfig = {
+    id:{key:"id"},
+    partyActivityType:{key:"党建活动类型"},
+    activityStartTime:{key:"活动时间"},
+    activityEndTime:{key:"活动结束时间"},
+    activityAdd:{key:"活动地点"},
+    activityStatus:{key:"活动状态"}
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     选择党员
+ * 备注:     
+ */
+export const partyMemberConfig = {
+    id:{key:"id"},
+    name:{key:"姓名"},
+    entryType:{key: "党员类型"},
+    partyPositions:{key:"党内职务"},
+    color:{key:"颜色"},
 }
\ No newline at end of file

src/data/organizationalLife.ts

@@ -4,35 +4,35 @@
  */
 
 import { Schema } from "mongoose";
-import {yfsDB} from '../db/mongo/dbInit';
+import {yfsDB} from '../db/dbInit';
+var autoIncrement = require('mongoose-auto-increment');
 
 const organizationalLifeSchema = new Schema({
-    //todo 缺个id
-   /**党建活动类型 1：日常教育培训、2：主题党日活动、3：骨干队伍培训、4：支部工作会、5：二十大精神、6：三会一课 */
-   partyActivityType: Number,
-   /**活动开始时间 */
-   activityStartTime: {type:Number, index:true},
-   /**活动结束时间 */
-   activityEndTime:{type:Number, index:true},
-   /**活动地点 */
-   activityAdd: String,
-   /**活动主持人 */
-   activityHost: [String],
-   /**活动记录人 */
-   activityNoteTaker:[String],
-   /**请假党员 非必填*/
-   leavePartyMember:[String],
-   /**参与党员 */
-   participatingPartyMember:[String],
-   /**活动记录 */
-   participationRecord:String,
+    oId: {type:Number, index:{unique: true}}, //自增的活动id
+    partyActivityType: Number, //党建活动类型 1：日常教育培训、2：主题党日活动、3：骨干队伍培训、4：支部工作会、5：二十大精神、6：三会一课
+    activityStartTime: {type:Number, index:true}, //活动开始时间
+    activityEndTime:{type:Number, index:true}, //活动结束时间
+    activityAdd: String, //活动地点
+    activityHost: {type:[String], default:[]}, //活动主持人
+    activityNoteTaker:{type:[String], default:[]}, //活动记录人
+    leavePartyMember:[Number], //请假党员 非必填
+    participatingPartyMember:[Number], //参与党员
+    participationRecord:String, //活动记录
 
 })
 
 var organizationalLifeModel;
 
 export function initModel(){
+    organizationalLifeSchema.plugin(autoIncrement.plugin, {
+        model: 'organizationalLifeSchema',
+        field: 'oId',
+        startAt: 1, //初始化id从1开始
+        incrementBy: 1 //每次自增1
+    });
+
     organizationalLifeModel = yfsDB.model('organizationalLife', organizationalLifeSchema);
+
     organizationalLifeModel.selectOnceData = async function (paramater:object) {
         let selectInfo = await organizationalLifeModel.findOne(paramater).exec();
         if (selectInfo) {
@@ -41,10 +41,13 @@ export function initModel(){
                 selectInfo.save = save.bind(selectInfo)
             }
         }
+
         return selectInfo;
     }
+
 }
 
+
 export async function save(throwError=false) {
     if (!this.isModified()) return;
     await this.runSave({validateBeforeSave:false}).catch(err=>{
@@ -54,12 +57,46 @@ export async function save(throwError=false) {
  
 
 /**
- * 获取符合条件的党建资讯列表
- * @param selectParam 查询参数
+ * 获取符合条件的组织生活列表
+ * @param param 查询参数
+ * @returns 
+ */
+export async function findOrganizationalLifeList(param) {
+    return await organizationalLifeModel.find(param);
+}
+
+
+/**
+ * 获取正在进行的组织生活列表
+ * 开始时间小于当前时间，结束时间大于当前时间
+ * gt：大于某个值的数据、lt：小于某个值的数据
+ * @returns 
+ */
+export async function findAfootActivityList(partyActivityType:number) {
+    let nowTime = new Date().valueOf();
+    return await organizationalLifeModel.find({"$and":[ {"activityStartTime":{"$lt":(nowTime)}}, {"activityEndTime":{"$gt":(nowTime)}}, {partyActivityType} ]});
+}
+
+
+/**
+ * 获取即将开展的组织生活列表
+ * 开始时间大于当前时间
  * @returns 
  */
-export async function findOrganizationalLifeList(selectParam) {
-    return await organizationalLifeModel.find(selectParam);
+export async function findBeginInActivityList(partyActivityType:number) {
+    let nowTime = new Date().valueOf();
+    return await organizationalLifeModel.find({"activityStartTime":{"$gt":(nowTime)}, partyActivityType});
+}
+
+
+/**
+ * 获取已经开展的组织生活列表
+ * 结束时间小于当前时间
+ * @returns 
+ */
+export async function findStartedActivityList(partyActivityType:number) {
+    let nowTime = new Date().valueOf();
+    return await organizationalLifeModel.find({"activityEndTime":{"$lt":(nowTime)}, partyActivityType});
 }
 
 
@@ -74,9 +111,19 @@ export async function createActivity(param) {
 
 /**
  * 获取活动详情
- * @param _id id 唯一标识
+ * @param id id 唯一标识
+ * @returns 
+ */
+export async function findEventDetails(oId) {
+    return await organizationalLifeModel.findOne({oId});
+}
+
+
+/**
+ * 删除组织生活活动
+ * @param oId 活动id
  * @returns 
  */
-export async function findEventDetails(_id) {
-    return await organizationalLifeModel.find({_id});
+export async function deleteActivity(oId:number) {
+    return await organizationalLifeModel.deleteOne({oId}).exec();
 }
\ No newline at end of file

src/data/partyInformation.ts

@@ -4,28 +4,29 @@
  */
 
 import { Schema } from "mongoose";
-import {yfsDB} from '../db/mongo/dbInit';
-
+import {yfsDB} from '../db/dbInit'
+var autoIncrement = require('mongoose-auto-increment');;
 
 const partyInformationSchema = new Schema({
-   _id: {type: String, index:true},
-   /**党建资讯类型 1：医院文化、2：精神文明、3：科普知识、4、先进典型 */
-   informationType: Number,
-   /**资讯标题 */
-   title: String,
-   /**支部 */
-   branch: String,
-   /**资讯时间 */
-   informationTime: Number,
-   /**资讯详细 */
-   detailedInformation: String,
-   /**图片 */
-   img: String,
+    pId: {type:Number, index:{unique: true}}, //自增的id
+    informationType: Number, //党建资讯类型 1：医院文化、2：精神文明、3：科普知识、4、先进典型
+    title: String, //资讯标题
+    branch: String, //支部
+    informationTime: Number, //资讯时间
+    detailedInformation: String, //资讯详细
+    img: {type:String, data:Buffer}, //图片
 })
 
 var partyInformationModel;
 
 export function initModel(){
+    partyInformationSchema.plugin(autoIncrement.plugin, {
+        model: 'partyInformationSchema',
+        field: 'pId',
+        startAt: 1, //初始化id从1开始
+        incrementBy: 1 //每次自增1
+    });
+
     partyInformationModel = yfsDB.model('partyInformation', partyInformationSchema);
     partyInformationModel.selectOnceData = async function (paramater:object) {
         let selectInfo = await partyInformationModel.findOne(paramater).exec();
@@ -35,10 +36,12 @@ export function initModel(){
                 selectInfo.save = save.bind(selectInfo)
             }
         }
+        
         return selectInfo;
     }
 }
 
+
 export async function save(throwError=false) {
     if (!this.isModified()) return;
     await this.runSave({validateBeforeSave:false}).catch(err=>{
@@ -48,11 +51,20 @@ export async function save(throwError=false) {
 
 
 /**
- * 获取符合条件的党建资讯列表
- * @param selectParam 查询参数
+ * 根据党建资讯类型查询的党建资讯列表
+ * @param informationType 党建资讯类型 1：医院文化、2：精神文明、3：科普知识、4、先进典型
  * @returns 
  */
-export async function findPartyInformationList(selectParam) {
-   return await partyInformationModel.find(selectParam);
+export async function findPartyInformationListByType(informationType:number) {
+   return await partyInformationModel.find({informationType});
 }
  
+
+/**
+ * 创建党建资讯
+ * @param param 所添加表单 需要提前验证
+ * @returns 
+ */
+export async function createPartyInformation(param) {
+    return await partyInformationModel.create(param);
+}
\ No newline at end of file

src/data/partyMember.ts

 /**
- * 党员基本信息表
+ * 党员基础信息表
  */
 
 import { Schema } from "mongoose";
-import {yfsDB} from '../db/mongo/dbInit';
+import {yfsDB} from '../db/dbInit';
+var autoIncrement = require('mongoose-auto-increment');
 
 const partyMemberSchema = new Schema({
-    _id: {type: String, index:true},
-    /**姓名 必填 */
-    name: String,
-    /**性别 0：男、1：女 必填 */
-    sex: Number,
-    /**出生年月 必填 */
-    birthDate: Number,
-    /**手机号码 必填 */
-    phone: Number,
-    /**文化程度 必填 */
-    levelOfEducation: Number,
-    /**入党时间 必填 */
-    partyJoiningTime: Number,
-    /**行政职务 必填 1： */
-    administrativePosition: Number,
-    /**备注 非必填 */
-    remarks: String,
-    /**名册录入类型 1：正式党员录入、2：入党积极分子录入、3：入党申请录入 */
-    entryType: Number,
-    /**党内职务 多选 --正式党员录入  1：书记、2：副书记、3：纪检委员、4：组织委员、5：宣传委员 */
-    partyPositions: [Number],
-    /**列为积极份子时间 --入党积极份子录入 */
-    listedAsActivistsTime: Number,
-    /**谈话时间 --入党申请录入 */
-    talkTime: Number,
+    id: {type:Number, index:{unique: true}}, //自增的id
+    name: String, //姓名
+    sex: Number, //性别 1：男、2：女
+    birthDate: Number, //出生年月
+    phone: String, //手机号码
+    levelOfEducation: String, //文化程度
+    partyJoiningTime: Number, //入党时间
+    administrativePosition: Number, //行政职务 1：
+    remarks: String, //备注
+    entryType: Number, //名册录入类型 1：正式党员录入、2：入党积极分子录入、3：入党申请录入
+    partyPositions: [Number], //党内职务 多选 --正式党员录入  1：书记、2：副书记、3：纪检委员、4：组织委员、5：宣传委员、6：党员、7：入党积极分子、8：预备党员
+    listedAsActivistsTime: Number, //列为积极份子时间 --入党积极份子录入
+    talkTime: Number, //谈话时间 --入党申请录入
 
     /**-----用户相关----- */
-    /**登录账号 */
-    loginId: {type: String, index: true},
-    /**密码 */
-    pwd: String,
+    loginId: {type: String, index: true}, //登录账号
+    pwd: String, //密码
     token:{type:String, index:true},
     tokenMs:Number,
-    /**首次登录是否修改密码 */
-    firstLoginIsChangePwd:{type:Boolean, default:false},
+    firstLoginIsChangePwd:{type:Boolean, default:false}, //首次登录是否修改密码
 })
 
 var partyMemberModel;
 
 export function initModel(){
+    partyMemberSchema.plugin(autoIncrement.plugin, {
+        model: 'partyMemberSchema',
+        field: 'id',
+        startAt: 1, //初始化id从1开始
+        incrementBy: 1 //每次自增1
+    });
+
     partyMemberModel = yfsDB.model('partyMember', partyMemberSchema);
     partyMemberModel.selectOnceData = async function (paramater:object) {
         let selectInfo = await partyMemberModel.findOne(paramater).exec();
@@ -55,10 +48,12 @@ export function initModel(){
                 selectInfo.save = save.bind(selectInfo)
             }
         }
+
         return selectInfo;
     }
 }
 
+
 export async function save(throwError=false) {
     if (!this.isModified()) return;
     await this.runSave({validateBeforeSave:false}).catch(err=>{
@@ -66,8 +61,14 @@ export async function save(throwError=false) {
     });
 }
 
-export async function findPartyMemberAll() {
-    return await partyMemberModel.find({});
+
+/**
+ * 获取符合条件的所有党员信息
+ * @param param 查询参数
+ * @returns 
+ */
+export async function findPartyMemberAll(param) {
+    return await partyMemberModel.find(param);
 }
 
 
@@ -83,22 +84,48 @@ export async function findPartyMemberByLoginId(loginId:string) {
 
 /**
  * 获取符合条件的党员数量
- * @param selectParam 查询参数
+ * @param param 查询参数
  * @returns number 数据数量
  */
-export async function groupFindPartyMemberCount(selectParam) {
-    return await partyMemberModel.find(selectParam).count();
+export async function groupFindPartyMemberCount(param:object) {
+    return await partyMemberModel.find(param).count();
 }
 
 
 /**
  * 根据党内职务查询在职人员信息
- * @param partyPositions  党内职务
+ * @param partyPositions  党内职务 [1, 2]
  * @returns 
  */
-export async function getBaseListByPartyPositions(partyPositions:number) {
-    //todo  sql有问题，重写一下
-    return await partyMemberModel.find({partyPositions:{"in": partyPositions }});
+export async function getBaseListByPartyPositions(partyPositions) {
+    return await partyMemberModel.find({partyPositions:{$in: partyPositions }});
 }
 
 
+/**
+ * 
+ * @param id 根据id查询党员名称
+ * @returns 
+ */
+export async function getNameById(id:number) {
+    return await partyMemberModel.find({id});
+}
+
+
+/**
+ * 根据党员类型查询党员信息
+ * @param param entryType 党员类型
+ * @returns 
+ */
+export async function getPartyMemberListByEntryType(param) {
+    return await partyMemberModel.find(param);
+}
+
+
+/**
+ * 创建正式党员信息
+ * @param param 所添加表单 需要提前验证
+ */
+ export async function createPartyMember(param) {
+    return await partyMemberModel.create(param);
+}

src/db/dbConnect.ts

@@ -13,6 +13,7 @@ let defaultOptions = {
 
 
 export async function createDbConnect(connectUrl:string, options?:object) {
+  mongoose.set('useFindAndModify', false); //解决mongoose旧版弹出的警告
   if (!options) options = defaultOptions;
   return await mongoose.createConnection(connectUrl, options).catch(
     (err)=>{

src/db/dbInit.ts

-
-
 import { systemConfig } from "../config/systemConfig";
 import { BizError } from "../util/bizError";
 import { createDbConnect } from "./dbConnect";
 import { initTable } from "./tableInit";
+var autoIncrement = require('mongoose-auto-increment');
 var yfsDB;
 
 export async function initDB() {
@@ -14,6 +13,7 @@ export async function initDB() {
             throw err
         });
         
+        autoIncrement.initialize(yfsDB);
         await initTable();
         console.log('mongodb init success');
     } else {

src/db/tableInit.ts

-// import * as taskinModel  from "../../data/fuHuaQi/task";
+import * as organizationalLifeModel  from "../data/organizationalLife";
+import * as partyInformationModel from "../data/partyInformation";
+import * as partyMemberModel from "../data/partyMember";
+
 
 export async function initTable() {
-    // taskinModel.initModel();
+    partyMemberModel.initModel();
+    organizationalLifeModel.initModel();
+    partyInformationModel.initModel();
 }
\ No newline at end of file

src/main.ts

 import { initConfig, systemConfig} from "./config/systemConfig";
 import { initDB } from "./db/dbInit";
 import { httpServer } from "./net/http_server";
+import { getPwdMd5, getToken } from "./tools/system";
 
 async function lanuch() {
+    // test();
     /**初始化配置解析 */
     await initConfig();
     /**初始化数据库 */
@@ -12,6 +14,10 @@ async function lanuch() {
     console.log('This indicates that the server is started successfully.');
 }
 
-
+function test() {
+    let pwd = getPwdMd5("13572364589", "364589");
+    let token = getToken("13572364589");
+    console.log();
+}
 
 lanuch();
\ No newline at end of file

src/routers/applet/base.ts

+/**
+ * 小程序端 党员入口 党建首页路由
+ */
+
+import * as baseBiz from '../../biz/applet/base';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+
+export function setRouter(httpServer) {
+    httpServer.post('/partymember/home', asyncHandler(homeBase));
+    httpServer.post('/partymember/information', asyncHandler(informationBase));
+}
+
+
+/**
+ * 党建首页基础数据
+ * @param req 
+ * @param res 
+ */
+async function homeBase(req, res) {
+    let baseInfo = await baseBiz.homeData();
+    res.success(baseInfo);
+}
+
+
+/**
+ * 党建首页党建资讯列表
+ * @param req 
+ * @param res 
+ */
+async function informationBase(req, res) {
+    let reqConf = {informationType:'Number'};
+    let {informationType} = eccReqParamater(reqConf, req.body);
+
+    let informationInfo = await baseBiz.informationData(informationType);
+    res.success(informationInfo);
+}
\ No newline at end of file

src/routers/applet/organizationalLife.ts

+/**
+ * 小程序端 党员入口 组织生活路由
+ */
+
+import * as organizationalLifeBiz from '../../biz/applet/organizationalLife/organizationalLife';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+
+export function setRouter(httpServer) {
+    httpServer.post('/partymember/organizationallife/list', asyncHandler(organizationalLifeList));
+    httpServer.post('/partymember/organizationallife/create', asyncHandler(createOrganizationalLife));
+    httpServer.post('/partymember/organizationallife/details', asyncHandler(detailsList));
+    httpServer.post('/partymember/organizationallife/update', asyncHandler(updateOrganizationalLife));
+    // httpServer.post('/applet/organizationallife/partymembernamelist', asyncHandler(getPartyMemberNameList));
+    httpServer.post('/partymember/organizationallife/partymembernamelist', asyncHandler(getAllPartyMember));
+}
+
+
+/**
+ * 组织生活列表
+ * @param req 
+ * @param res 
+ */
+async function organizationalLifeList(req, res) {
+    let reqConf = {type:'Number', name:'Number'};
+    let {type, name} = eccReqParamater(reqConf, req.body, ["name"]);
+
+    let result = await organizationalLifeBiz.getOrganizationalLifeList(type, name);
+    res.success(result);
+}
+
+
+/**
+ * 创建活动
+ * @param req 
+ * @param res 
+ */
+async function createOrganizationalLife(req, res) {
+    let reqConf = {form: 'Object' };
+    let { form } = eccReqParamater(reqConf, req.body);
+    
+    let result = await organizationalLifeBiz.createOrganizationalLife(form);
+    res.success(result);
+}
+
+
+/**
+ * 组织生活详情
+ * @param req 
+ * @param res 
+ */
+async function detailsList(req, res) {
+    let reqConf = {oId: 'Number' };
+    let {oId} = eccReqParamater(reqConf, req.body);
+
+    let result = await organizationalLifeBiz.getOrganizationalLifeById(oId);
+    res.success(result);
+}
+
+
+/**
+ * 修改对应oId的组织生活
+ * @param req 
+ * @param res 
+ */
+async function updateOrganizationalLife(req, res) {
+    let reqConf = {oId: 'Number', form: 'Object' };
+    let { oId, form } = eccReqParamater(reqConf, req.body);
+
+    let result = await organizationalLifeBiz.updateOrganizationalLife(oId, form);
+    res.success(result);
+}
+
+
+/**
+ * 获取选择类型的党员信息
+ * @param req 
+ * @param res 
+ * 停用
+ */
+async function getPartyMemberNameList(req, res) {
+    let reqConf = {type: "Number", name: "String"};
+    let {type, name} = eccReqParamater(reqConf, req.body, ["name"]);
+
+    let result = await organizationalLifeBiz.getPartyMemberNameList(type, name);
+    res.success(result);
+}
+
+
+/**
+ * 获取全部党员信息
+ * @param req 
+ * @param res 
+ */
+async function getAllPartyMember(req, res) {
+    let result = await organizationalLifeBiz.getAllPartyMember();
+    res.success(result);
+}
\ No newline at end of file

src/routers/applet/partyInforMation.ts

+/**
+ * 小程序端 党员入口 党建资讯
+ */
+
+import * as partyInforMationBiz from '../../biz/applet/partyMember/partyInforMation';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+ 
+export function setRouter(httpServer) {
+    httpServer.post('/partymember/partyInforMation/create', asyncHandler(createPartyInformation));
+}
+ 
+
+/**
+ * 创建党员
+ * @param req 
+ * @param res 
+ */
+async function createPartyInformation(req, res) {
+    let reqConf = {form: 'Object' };
+    let { form } = eccReqParamater(reqConf, req.body);
+    
+    let result = await partyInforMationBiz.createPartyInformation(form);
+    res.success(result);
+}

src/routers/applet/partyMember.ts

+/**
+ * 小程序端 党员入口 党员基础信息
+ */
+
+ import * as partyMemberBiz from '../../biz/applet/partyMember/partyMember';
+ import * as asyncHandler from 'express-async-handler';
+ import { eccReqParamater } from '../../util/verificationParam';
+ 
+ export function setRouter(httpServer) {
+     httpServer.post('/partymember/partymember/create', asyncHandler(createPartyMenber));
+ }
+ 
+
+
+
+/**
+ * 创建党员
+ * @param req 
+ * @param res 
+ */
+ async function createPartyMenber(req, res) {
+    let reqConf = {form: 'Object' };
+    let { form } = eccReqParamater(reqConf, req.body);
+    
+    let result = await partyMemberBiz.createPartyMember(form);
+    res.success(result);
+}

src/routers/applet/user.ts

+/**
+ * 小程序端 党员入口 用户基础功能路由
+ */
+
+import * as userBiz from '../../biz/applet/user';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+
+export function setRouter(httpServer) {
+    httpServer.post('/partymember/login', asyncHandler(login));
+    httpServer.post('/partymember/changePwd', asyncHandler(changePwd));
+    httpServer.post('/partymember/login/firstupdate', asyncHandler(firstUpdatePwd));
+}
+
+
+/**
+ * 党员入口登录
+ * @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 userBiz.login(loginId, pwd);
+    res.success(userInfo);
+}
+
+
+/**
+ * 首次登录 
+ * @param req 
+ * @param res 
+ */
+ async function firstUpdatePwd(req, res) {
+    let reqConf = {confirmPwd:'String', pwd:'String' };
+    let {confirmPwd, pwd} = eccReqParamater(reqConf, req.body);
+
+    const LoginId = req.headers.loginId;
+    
+    let result = await userBiz.firstLoginChangePwd(LoginId, pwd, confirmPwd);
+
+    res.success(result);
+}
+
+
+/**
+ * 修改密码
+ * @param req 
+ * @param res 
+ */
+ async function changePwd(req, res) {
+    let reqConf = {confirmPwd:'String', newPwd:'String', pwd:'String' };
+    let {confirmPwd, newPwd, pwd} = eccReqParamater(reqConf, req.body);
+    const Uscc = req.headers.uscc;
+
+    let result = await userBiz.changePassword(Uscc, pwd, newPwd, confirmPwd); 
+
+    res.success(result);
+}
\ No newline at end of file

src/routers/public.ts

+/**
+ * 公共资源路由
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import * as configEnum from "../config/enum";
+
+export function setRouter(httpServer) {
+    httpServer.post('/public/partypositions', asyncHandler(partyPositions));
+    httpServer.post('/public/type', asyncHandler(type));
+    httpServer.post('/public/entrytype', asyncHandler(entryType));
+    httpServer.post('/public/activitytype', asyncHandler(activityType));
+    httpServer.post('/public/informationtype', asyncHandler(informationType));
+}
+
+
+/**
+ * 党内职务
+ * @param req  
+ * @param res 
+ */
+function partyPositions(req, res) {
+    let dataList = [];
+    for (let key in configEnum.PARTYPOSITIONS) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            dataList.push({key:keyStr, value:configEnum.PARTYPOSITIONS[key]});
+        }
+    }
+    res.success(dataList);
+}
+
+
+/**
+ * 组织生活活动类型
+ * @param req  
+ * @param res 
+ */
+ function type(req, res) {
+    let dataList = [];
+    for (let key in configEnum.TYPE) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            dataList.push({key:keyStr, value:configEnum.TYPE[key]});
+        }
+    }
+    res.success(dataList);
+}
+
+
+/**
+ * 名册录入类型
+ * @param req  
+ * @param res 
+ */
+ function entryType(req, res) {
+    let dataList = [];
+    for (let key in configEnum.ENTRYTYPE) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            dataList.push({key:keyStr, value:configEnum.ENTRYTYPE[key]});
+        }
+    }
+    res.success(dataList);
+}
+
+
+/**
+ * 党建活动类型
+ * @param req  
+ * @param res 
+ */
+ function activityType(req, res) {
+    let dataList = [];
+    for (let key in configEnum.ACTIVITYTYPE) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            dataList.push({key:keyStr, value:configEnum.ACTIVITYTYPE[key]});
+        }
+    }
+    res.success(dataList);
+}
+
+
+/**
+ * 党建资讯类型
+ * @param req  
+ * @param res 
+ */
+ function informationType(req, res) {
+    let dataList = [];
+    for (let key in configEnum.INFORMATIONTYPE) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            dataList.push({key:keyStr, value:configEnum.INFORMATIONTYPE[key]});
+        }
+    }
+    res.success(dataList);
+}
+

src/routers/router.ts

@@ -2,6 +2,22 @@
  * 总路由入口
  */
 
+import * as appletUserRouters from '../routers/applet/user';
+import * as appletBaseRouters from '../routers/applet/base';
+import * as appletOrganizationalLifeRouters from '../routers/applet/organizationalLife';
+import * as appletPartyMemberRouters from '../routers/applet/partyMember';
+import * as appletPartyInforMationRouters from '../routers/applet/partyInforMation';
+import * as publicRouters from '../routers/public';
+
 export function setRouter(httpServer){
+    /**小程序端 党员入口 */
+    appletUserRouters.setRouter(httpServer);
+    appletBaseRouters.setRouter(httpServer);
+    appletOrganizationalLifeRouters.setRouter(httpServer);
+    appletPartyMemberRouters.setRouter(httpServer);
+    appletPartyMemberRouters.setRouter(httpServer);
+    appletPartyInforMationRouters.setRouter(httpServer);
 
+    /**小程序端 公共资源 */
+    publicRouters.setRouter(httpServer);
 }
\ No newline at end of file

src/tools/system.ts

@@ -95,10 +95,10 @@ export function md5PwdStr(pwd:string) {
 
 /**
  * 获取token
- * @param uscc 统一信用代码
+ * @param loginId 统一信用代码
  */
-export function getToken(uscc:string) {
-    return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
+export function getToken(loginId:string) {
+    return md5(`${loginId}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
 }
 
 

src/util/verificationParam.ts

@@ -17,7 +17,19 @@ import { BizError } from "./bizError";
  * @param param 需要校验的参数
  * @returns true 无需关注返回
  */
-export function eccFormParam(name:string, keyTypeConf:object, param:object) {
+
+/**
+ * 通过config校验表单参数param
+ * 包括类型 String, Number, Boolean, [Number], [Object]
+ * 参数是必填
+ * 方法会校验表单中存在的多余字段
+ * todo 后续优化配置
+ * @param name 被调用的方法名
+ * @param config 校验配置
+ * @param param 需要校验的参数
+ * @returns true 无需关注返回
+ */
+ export function eccFormParam(name:string, keyTypeConf:object, param:object) {
     for (let key in keyTypeConf ) {
         let {type, notMustHave} = keyTypeConf[key];
 
@@ -58,6 +70,16 @@ export function eccFormParam(name:string, keyTypeConf:object, param:object) {
                         }
                     }
                 break;
+                case '[String]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'string' ) {
+                            isError = true;
+                            errorStr = `${key}应是string型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
                 case '[Object]':
                     if ( !Array.isArray(param[key]) ) isError = true;
                     for (let i =0; i <  param[key].length; i++) {
@@ -68,6 +90,39 @@ export function eccFormParam(name:string, keyTypeConf:object, param:object) {
                         }
                     }
                 break;
+                case 'Address':
+                    /**地址类型 基本数据类型为数组字符串但是要判断层级关系 */
+                    if ( !Array.isArray(param[key]) ) {
+                        isError = true;
+                        errorStr = `${key}应是数组形`;
+                    }
+                    if ( param[key].length != 4) {
+                        isError = true;
+                        errorStr = `${key}超过特定长度4 目前长度 ${param[key].length}`;
+                    }
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'string' ) {
+                            isError = true;
+                            errorStr = `${key}应是string型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                    /** 不符合规则的 */
+                    let nullIndex = -1;
+                    for (let i = 0; i < param[key].length; i++) {
+                        if (nullIndex != -1) {//出现过空 第一次出现后的位置 都不能有值
+                            if (param[key]) {
+                                //做一个特化
+                                throw new BizError(ERRORENUM.地址数据不完整, `${key} 下标 ${nullIndex} 为空 `);
+                            }
+                        }
+                        if (nullIndex == -1 && !param[key][i]) {
+                            /**按顺序第一次赋值 */
+                            nullIndex = i;
+                        }
+                    }
+
+                break;
             }
             errorStr = isError && errorStr == "" ? `${key}应该是${type}型 而不是${paramType}`: errorStr;