no message

serverConfig.xml

 <config>
     <port>40003</port>
     <db>
-        <url>http://192.168.0.71:40002</url>
+        <url>http://192.168.0.105:40002</url>
         <sign>xxx90909082fsdahfjosadjfpoiwausjorip2hjklrhn1ioud0u124rx0qwejfokasjfolksaujfoas</sign>
     </db>
     <imgUrl>http://123.207.147.179:40003/</imgUrl>

src/biz/abi/organizationalLife.ts

-/**
- * ABI_智慧党建管理分析平台
- * 组织生活
- */
-
-//  import * as organizationalLifeData from "../../data/organizationalLife";
- import * as configEnum from "../../config/enum";
- 
- /**
-  * ABI 组织生活
-  * @returns {activityCount:"活动开展次数", dataList:"组织生活扇形图"}
-  */
- export async function getActivityCount() {
-     
- }
- 
- 
\ No newline at end of file

src/biz/abi/partyBuilding.ts

+/**
+ * ABI_智慧党建管理分析平台——党建分析
+ */
+
+import moment = require("moment");
+import { OPERATIONALDATATYPE, TABLENAME } from "../../config/dbEnum";
+import * as enums from "../../config/enum";
+import { selectData } from "../../middleware/databaseSuccess";
+
+/**
+ * 党建分析——左屏
+ * @returns {baseData:基本情况, ratio:男女占比, qualifications:学历情况, ageDistribution:年龄分布, partyExpenses:党费管理}
+ */
+export async function getLeftScreen() {
+  let baseData = {title:"基本情况", list:[]};
+  baseData.list.push(
+    {key:"支部", value:await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.支部表, {}, null)},
+    {key:"正式党员", value:await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {etId:enums.ENTRYTYPE.正式党员}, null)},
+    {key:"预备党员", value:await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {etId:enums.ENTRYTYPE.预备党员}, null)}
+  );
+
+  let male = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {sex:enums.SEX.男}, null);
+  let female = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {sex:enums.SEX.女}, null);
+  let ratio = {title:"男女占比", list:[{key:"男", value:male},{key:"女", value:female}]};
+
+  let qualifications = {title:"学历情况", list:[]};
+  for(let key in enums.DEGREE) {
+      let anyKey:any = key;
+      if (isNaN(anyKey)) {
+          let keyStr = key;
+          let levelOfEducation = enums.DEGREE[key];
+          let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {levelOfEducation}, null);
+          qualifications.list.push({key:keyStr, value:count});
+      }
+  }
+
+  let ageDistribution = {title:"年龄分布", list:[]};
+  let ageDistributionMap = {
+    小于29: 0,
+    大于30小于39: 0,
+    大于40小于49: 0,
+    大于50: 0,
+  }
+  let 小于29 = {"birthDate": {"%gt%": moment().add(-29, 'y').format("YYYY-MM-DD HH:mm:ss")}};
+  ageDistributionMap.小于29 = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, 小于29, ["birthDate"]);
+  let 大于30小于39 = {"birthDate": {"%between%": [moment().add(-39, 'y').format("YYYY-MM-DD HH:mm:ss"), moment().add(-30, 'y').format("YYYY-MM-DD HH:mm:ss")]}};
+  ageDistributionMap.大于30小于39 = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, 大于30小于39, ["birthDate"]);
+  let 大于40小于49 = {"birthDate": {"%between%": [moment().add(-49, 'y').format("YYYY-MM-DD HH:mm:ss"), moment().add(-40, 'y').format("YYYY-MM-DD HH:mm:ss")]}};
+  ageDistributionMap.大于40小于49 = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, 大于40小于49, ["birthDate"]);
+  let 大于50 = {"birthDate": {"%lt%": moment().add(-50, 'y').format("YYYY-MM-DD HH:mm:ss")}};
+  ageDistributionMap.大于50 = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, 大于50, ["birthDate"]);
+
+  for (let key in ageDistributionMap) {
+    ageDistribution.list.push({key, value: ageDistributionMap[key]});
+  }
+
+  let partyExpenses = {title:"党费管理", list: []};
+
+  let stTime = moment(new Date().valueOf()).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+  let etTime = moment(new Date().valueOf()).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+  let monthParam = {payType:enums.PAYTYPE.已缴纳, payTime:{"%between%":[stTime, etTime]}};
+  let monthPayment = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党费管理表, monthParam, ["payAmount"]);
+  let payAmount = 0;
+  monthPayment.forEach( item => {
+    payAmount += item.payAmount;
+  })
+  partyExpenses["monthPayment"] = payAmount;
+  let paymentCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {}, null);
+  let paidCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党费管理表, {payType:enums.PAYTYPE.已缴纳}, null);
+  partyExpenses["paymentRatio"] = Math.round((paidCount / paymentCount)*100)/100;
+
+  for(let key in enums.BRANCHNAME) {
+      let anyKey:any = key;
+      if (isNaN(anyKey)) {
+          let keyStr = key;
+          let bId = enums.BRANCHNAME[key];
+          let param = {
+            bId,
+            payType: enums.PAYTYPE.已缴纳,
+            payTime: {"%between%":[stTime, etTime]}
+          }
+          let branchPayment = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党费管理表, param, ["payAmount"]);
+          let branchPayAmount = 0;
+          branchPayment.forEach( item => {
+            branchPayAmount += item.payAmount;
+          })
+          partyExpenses.list.push({key:keyStr, value:branchPayAmount});
+      }
+  }
+
+  return {baseData, ratio, qualifications, ageDistribution, partyExpenses};
+}
+
+
+/**
+ * 党建分析——中屏
+ * @param year 
+ * @returns {partyQualityList:党建质量雷达图, branchPartyQuality:各支部党建质量评分, buildingDynamic:党建动态}
+ */
+export async function getMidScreen(year:string) {
+  let clomun = ["primaryIndicators", "completionProgress"];
+  let partyQuality = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量三级指标, {dataYear:year}, clomun);
+
+  let partyQualityList = {title:"党建质量雷达图", list:[]};
+  for (let key in enums.PRIMARYINDICATORS) {
+      let anyKey:any = key;
+      if (isNaN(anyKey)) {
+          const EnumValue = parseInt(enums.PRIMARYINDICATORS[key])
+          let completion = 0
+          let count = 0;
+          partyQuality.forEach( info => {
+              let {primaryIndicators, completionProgress} = info; //一级指标、完成进度
+              if (primaryIndicators == EnumValue) {
+                completion += completionProgress;
+                count++;
+              }
+          })
+          
+          let changeData = {
+            key:anyKey, 
+            value:Math.round((completion / count)*100)/100
+          };
+
+          partyQualityList.list.push(changeData);
+      }
+  }
+
+  let branchPartyQuality = {title:"各支部党建质量评分", list:[]};
+  for(let key in enums.BRANCHNAME) {
+    let anyKey:any = key;
+    if (isNaN(anyKey)) {
+        let keyStr = key;
+        let bId = enums.BRANCHNAME[key];
+        let branchPartyQualityInfo = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量三级指标, {bId}, ["currentScore"]);
+        let branchScore = 0;
+        branchPartyQualityInfo.forEach( item => {
+          branchScore += item.currentScore;
+        })
+        branchPartyQuality.list.push({key:keyStr, value:branchScore});
+    }
+  }
+
+  let buildingDynamic = {title:"党建动态", list:[]};
+  buildingDynamic.list = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建动态表, {}, ["theme"])
+
+  return {partyQualityList, branchPartyQuality, buildingDynamic};
+}
+
+
+/**
+  * 党建分析——右屏
+  * @returns {activity:组织生活, basicSystem:, totalIntegral, partyVanguard}
+  */
+export async function getRightScreen() {
+  let activity = {title:"组织生活", activityCount:0, list:[]}
+  activity.activityCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.组织生活表, {}, null); //组织生活总数
+  
+  for(let key in enums.BRANCHNAME) {
+      let anyKey:any = key;
+      if (isNaN(anyKey)) {
+          let keyStr = key;
+          let bId = enums.BRANCHNAME[key];
+          let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.组织生活表, {bId}, null);
+          activity.list.push({key:keyStr, value:count});
+      }
+  }
+
+  let basicSystem = {title:"基本制度", list:[]};
+  basicSystem.list = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.支部制度表, {}, ["systemTitle"]);
+
+  let totalIntegral = {title:"学习强国", monthTotalScore:0, list:[]};
+  let totalScore = 0;
+  for(let key in enums.BRANCHNAME) {
+    let anyKey:any = key;
+    if (isNaN(anyKey)) {
+        let keyStr = key;
+        let bId = enums.BRANCHNAME[key];
+        let totalIntegralInfo = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习强国, {bId}, ["totalIntegral"]);
+        let changeScore = 0;
+        totalIntegralInfo.forEach(item => {
+          changeScore += item.totalIntegral;
+          totalScore += item.totalIntegral;
+        })
+        totalIntegral.list.push({key:keyStr, value:changeScore});
+    }
+  }
+  totalIntegral.monthTotalScore = totalScore;
+
+  let partyVanguard = {title:"党建先锋", list:[]};
+  let partyVanguardInfo = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建先锋表, {}, ["honorName", "grantTime"]);
+
+  partyVanguardInfo.forEach( item => {
+    let grantTime = moment(item.grantTime).format("YYYY-MM-DD");
+    partyVanguard.list.push({honorName:item.honorName, grantTime});
+  })
+
+  return {activity, basicSystem, totalIntegral, partyVanguard};
+}
+

src/biz/abi/target.ts

+/**
+ * ABI_智慧党建管理分析平台——党建目标
+ */
+
+import { OPERATIONALDATATYPE, TABLENAME } from "../../config/dbEnum";
+import { PRIMARYINDICATORS, SECONDARYINDICATORS } from "../../config/enum";
+import { selectData } from "../../middleware/databaseSuccess";
+import { changeEnumValue } from "../../util/verificationEnum";
+
+export async function getTargetData() {
+    let clomun = ["tlId", "primaryIndicators", "secondaryIndicators", "thirdLevelContent", "thirdLevelScore", "currentScore", "completionProgress"];
+    let partyQualityData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量三级指标, {}, clomun);
+    
+    let partyQualityList = [];
+    for (let key in PRIMARYINDICATORS) {
+        let primaryIndicatorsData = {};
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            const EnumValue = parseInt(PRIMARYINDICATORS[key])
+            primaryIndicatorsData = {key: anyKey, list: {}};
+
+            partyQualityData.forEach( info => {
+                let {primaryIndicators, secondaryIndicators, thirdLevelContent, thirdLevelScore, currentScore, completionProgress} = info; //一级指标、总分、三级指标得分、完成进度
+                if (primaryIndicators == EnumValue) {
+                    let secondary = changeEnumValue(SECONDARYINDICATORS, secondaryIndicators);
+                    if(!primaryIndicatorsData["list"][secondary]) primaryIndicatorsData["list"][secondary] = []
+                    primaryIndicatorsData["list"][secondary].push({
+                        completionProgress
+                    });
+
+                }
+            })
+            partyQualityList.push(primaryIndicatorsData);
+        }
+    }
+
+    let partyQuality = [];
+    partyQualityList.forEach( item => {
+        let {key, list} = item;
+        
+        let secondLevel = [];
+        for (let second in list) {
+            let completionProgress = 0;
+            list[second].forEach( completion => {
+                completionProgress += completion.completionProgress;
+            })
+            completionProgress = completionProgress/list[second].length;
+            secondLevel.push({key:second, completionProgress})
+        }
+
+        partyQuality.push({key, dataList:secondLevel});
+
+    })
+
+    return partyQuality;
+}
+
+
+
+
+
+
+

src/biz/base.ts

@@ -14,7 +14,11 @@ import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
 /**
  * 主页基础数据
  * @param bId 支部id
- * @returns {支部名称, 党员总数, 党建质量总数, 党建质量指数, 党内职务人员列表}
+ * @returns 支部名称：branch:"牙防所第一支部"
+ * @returns 党员总数：partyMemberNum:0 
+ * @returns 党建质量总数：massSum:0 
+ * @returns 党建质量指数：massIndex:0 
+ * @returns 党内职务人员列表：partyPositions:[{"key":"支部书记", "list":["张三","李四"]}, {"key":"支部副书记", "list":["暂无数据"]}, ......] 
  */
  export async function homeData(bId:number) {
     let branch = changeEnumValue(configEnum.BRANCHNAME, bId); //支部名称
@@ -29,7 +33,6 @@ import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
         massIndex += score.currentScore;
     });
 
-
     let partyPositionsMap = {}; // = []; //党内职务人员 [{key, list:["", ""]}]
     for (let key in clientConfigEnum.PARTYPOSITIONS) {
         let anyKey:any = key;
@@ -38,7 +41,7 @@ import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
         }
     }
 
-    let selectAllColumn = [["bId", "partyPositionsName", "name"]];
+    let selectAllColumn = ["bId", "partyPositionsName", "name"];
     let allMemberList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党员基础信息表, param, selectAllColumn);
     
     let partyMemberNum = 0;//本支部人员总数
@@ -67,7 +70,7 @@ import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
 /**
  * 职务人员数组数据转换
  * @param numberList [100,101]
- * @returns ["支部书记", "支部副书记" ]
+ * @returns strList:["支部书记", "支部副书记" ]
  */
 function getPartyPositionsList(numberList) {
     let strList = [];
@@ -82,10 +85,10 @@ function getPartyPositionsList(numberList) {
 /**
  * 查询党建资讯列表
  * @param bId 支部id
- * @returns dataList:[返回字段参考splitResultConfig文件中的partyInformamtionConfig配置]
+ * @returns 资讯列表：dataList:[返回字段参考splitResultConfig文件中的partyInformamtionConfig配置]
  */
  export async function activitiesData(bId:number) {
-    let param = { bId:{"%like%": bId} };
+    let param = { bId };
     let partyInformationList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.专题活动表, param, ["theme", "dataMonth"]);
 
     let dataList = [];

src/biz/branchSystem.ts

@@ -12,7 +12,7 @@ import { BizError } from "../util/bizError";
  * 支部制度列表
  * @param bId 支部id
  * @param systemTitle 制度主题 可模糊查询 
- * @returns 
+ * @returns branchSystemList:[{"bsId":1, "systemTitle":"制度标题"}, ......]
  */
 export async function branchSystemList(bId:number, systemTitle:string) {
     let param = { bId:{"%like%": bId} };
@@ -28,7 +28,7 @@ export async function branchSystemList(bId:number, systemTitle:string) {
 /**
  * 制度细则
  * @param bsId 支部制度id 
- * @returns 
+ * @returns branchSystemInfo:{"bsId":1, "systemTitle":"制度标题", "fileName":["制度文件1", ......]}
  */
 export async function branchSystemDetsils(bsId:number) {
     let clomun = ["bsId", "systemTitle", "fileName"];

src/biz/memberLearning.ts

@@ -5,7 +5,7 @@
  */
 
 import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
-import { selectData } from "../middleware/databaseSuccess";
+import { operationalData, selectData, selectManyTableData } from "../middleware/databaseSuccess";
 import moment = require("moment");
 import * as verificationEnumTools from "../util/verificationEnum";
 import * as configEnum from "../config/enum";
@@ -17,49 +17,64 @@ import * as configEnum from "../config/enum";
  * @param courseEntryType 学习类型 视频/文字
  * @param courseTypeName 课程类型
  * @param contentTitle 课程标题
- * @returns 
+ * @returns rateLearningList:[{"contentTitle":"学习课题名称", "fileName":["视频地址", ......], "rateOfLearning":0, "learningCompleted":0}]
  */
 export async function memberLearningList(pmId:string, courseEntryType:number, courseTypeName:number, contentTitle:string) {
-    //优化点  功能有bug重写
+    let rateColumn =  ["rlId", "mlId", "rateOfLearning", "learningCompleted"];
+    let rateLearningInfo = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习进度表, {pmId}, rateColumn);
+    let rateLearningList = [];
+    let rateLearningMap = {};
+    rateLearningInfo.forEach(info => {
+        let {rlId, mlId, rateOfLearning, learningCompleted} = info;
+        rateLearningMap[mlId] = {rlId, rateOfLearning, learningCompleted}
+    });
+
+    let param = {courseEntryType};
+    if(courseTypeName) param["courseTypeName"] = courseTypeName;
+    if(contentTitle) param["contentTitle"] = {"%like%": contentTitle};
+
+    let clomun = ["mlId", "contentTitle", "fileName", "coverImage", "videoDuration"];
+    let memberLearningInfo = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党员学习表, param, clomun); 
     
-    let column = ["mlId", "rateOfLearning", "learningCompleted"];
-    let rateLearningList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习进度表, {pmId}, column);
-
-    let memberLearningList = [];
-    for (let i = 0; i < rateLearningList.length; i++) {
-        let rateLearning = rateLearningList[i];
-        let {mlId, rateOfLearning, learningCompleted} = rateLearning;
-        let param = {
-            mlId,
-            isUse: 1,
-            courseEntryType
-        };
-        if(courseTypeName) param["courseTypeName"] = courseTypeName;
-        if(contentTitle) param["contentTitle"] = {"%like%": contentTitle};
-
-        let clomun = ["contentTitle", "fileName"];
-        
-        let memberLearningData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员学习表, param, clomun); 
-        if (!memberLearningData) continue;
-        memberLearningData.rateOfLearning = rateOfLearning;
-        memberLearningData.learningCompleted = learningCompleted;
-        memberLearningData.fileName = JSON.parse(memberLearningData.fileName);
-        
-        memberLearningList.push(memberLearningData);
+    for(let i = 0; i < memberLearningInfo.length; i++) {
+        let memberInfo = memberLearningInfo[i];
+        let {mlId, contentTitle, fileName, coverImage, videoDuration} = memberInfo;
+        let learningInfo =  rateLearningMap[mlId];
+        if (!learningInfo) { //如果对应学习课程没有进度数据，创建一条对应进度为0的数据
+            let addInfo = {
+                pmId,
+                mlId,
+                rateOfLearning:0,
+                learningCompleted: 1
+            }
+            await operationalData(OPERATIONALDATATYPE.增加, TABLENAME.学习进度表, addInfo, {});
+            learningInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习进度表, {pmId, mlId}, rateColumn); 
+            console.log(learningInfo);
+        }
+        rateLearningList.push({
+            rlId: learningInfo.rlId,
+            contentTitle,
+            fileName: JSON.parse(fileName),
+            rateOfLearning: learningInfo.rateOfLearning,
+            learningCompleted: learningInfo.learningCompleted,
+            coverImage,
+            videoDuration
+        })
     }
 
-    return memberLearningList;
+    return rateLearningList;
 }
 
 
 /**
- * 本月学习排行
+ * 学习排行
  * 该用户支部的排名
  * 展示数据最新月份的每日积分总和
- * @param bId 支部id
- * @returns 
+ * @param bId 支部id 参数存在返回数据最新月份登录账号支部的学习排行，参数不存在返回数据最新月份所有支部的学习排行
+ * @returns learningPowerList:[{"pmId":"党员id", "name":"党员名称", "bId":"所属支部", "dayIntegral":得分, "dataTime":"数据月份", "ranking":排名}]
+ * @returns oneselfRanking:{"pmId":"党员id", "name":"党员名称", "bId":"所属支部", "dayIntegral":得分, "dataTime":"数据月份", "ranking":排名}
  */
- export async function branchRanking(bId?) {
+ export async function branchRanking(pmId, bId?) {
     let orderParam = {"%orderDesc%": "dataTime", "%limit%": 1};
     let monthData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习强国, orderParam, ["dataTime"]);
     if (!monthData || !monthData.dataTime) return [];
@@ -69,27 +84,28 @@ export async function memberLearningList(pmId:string, courseEntryType:number, co
     let etTime = moment(dataTime).endOf('month').format("YYYY-MM-DD HH:mm:ss");
     
     let param = {
-        dataTime:{"%between%": [stTime, etTime]} //`DATE_FORMAT(dataMonth, '%Y-%m') = DATE_FORMAT(${dataMonth}, '%Y-%m')`;
+        dataTime:{"%between%": [stTime, etTime]}
     };
-    if (bId) param[bId] = {"%like%": bId};
+    if (bId) param["bId"] = {"%like%": bId};
    
-    let clomun = ["pmId", "partyMemberName", "bId", "dayIntegral", "dataTime"];
-    let learningPowerData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习强国, param, clomun);
+    let clomun = ["pmId", "bId", "dayIntegral", "dataTime"];
+    let includeConf = {"partyMember":["name"]}
+    let learningPowerData = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.学习强国, param, clomun, includeConf);
 
-    let partyMemberNameData = {};//{成员名称:{pmId, bId, score, dataTime} }
+    let partyMemberNameData = {}; //{成员名称:{pmId, bId, score, dataTime} }
     learningPowerData.forEach( info => {
-        let {pmId, partyMemberName, bId, dayIntegral, dataTime} = info;
-        if (!partyMemberNameData[partyMemberName]) {
-            partyMemberNameData[partyMemberName] = {
-                timeStr: moment(dataTime).format("YYYY-MM"),
+        let {pmId, partyMember, bId, dayIntegral, dataTime} = info;
+        if (!partyMemberNameData[partyMember.name]) {
+            partyMemberNameData[partyMember.name] = {
                 pmId,
-                name:partyMemberName,
+                name:partyMember.name,
                 bId:verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, bId), 
-                dayIntegral:0
+                dayIntegral:0,
+                dataTime: moment(dataTime).format("YYYY-MM"),
             };
         }
 
-        partyMemberNameData[partyMemberName].dayIntegral += dayIntegral;
+        partyMemberNameData[partyMember.name].dayIntegral += dayIntegral;
     });
     let learningPowerList = Object.values(partyMemberNameData);
 
@@ -97,15 +113,33 @@ export async function memberLearningList(pmId:string, courseEntryType:number, co
         return b.dayIntegral - a.dayIntegral;
     });
 
+    let oneselfRanking = {};
     for ( let i = 0; i < learningPowerList.length; i++) {
-        learningPowerList[i]["ranking"] = i + 1;
+        learningPowerList[i]["ranking"] = i + 1; //排名
+        if(learningPowerList[i]["pmId"] == pmId) {
+            oneselfRanking = learningPowerList[i];
+        }
     }
 
-    return learningPowerList;
+    return {learningPowerList, oneselfRanking};
 }
 
 
+/**
+ * 修改学习进度
+ * @param rlId 学习进度id
+ * @param rateOfLearning 学习进度
+ */
+export async function updateRateOfLearning(rlId:number, rateOfLearning:number) {
+    let learningCompleted = 1;
+    if (rateOfLearning == 100) learningCompleted = 2
+    let learningInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习进度表, {rlId}, ["rateOfLearning"]);
+    if (learningInfo.rateOfLearning < rateOfLearning) {
+        let row = await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.学习进度表, {rateOfLearning, learningCompleted}, {rlId});
+    }
 
+    return {isSuccess:true};
+}
 
 
 

src/biz/organizationalLife.ts

@@ -19,10 +19,10 @@ import * as configEnum from "../config/enum";
  * @param theme 活动名称 模糊查询
  * @param themeType 活动类型
  * @param dataMonth 活动月份
- * @returns 
+ * @returns organizationalLifeList[{"oId":1, "theme":"活动主题", "themeType":"活动类型", "dataMonth":"活动月份"}]
  */
 export async function organizationalLifeList(bId:number, theme:string, themeType:number, dataMonth:string) {
-    let param = { bId: {"%like%": bId} };
+    let param = { bId };
     if (theme) param["theme"] = {"%like%": theme};
     if (themeType) param["themeType"] = themeType;
     if (dataMonth) {
@@ -48,7 +48,7 @@ export async function organizationalLifeList(bId:number, theme:string, themeType
 /**
  * 获取组织生活详情
  * @param oId 组织生活id
- * @returns 
+ * @returns orgLifeInfo:{"oId":1, "theme":"活动主题", "themeType":"活动类型", "fileName":["活动文件名称", ......]}
  */
 export async function organlzationalLifeListDetsils(oId:number) {
     let clomun = ["oId", "theme", "themeType", "dataMonth", "fileName"];

src/biz/partyBuildingDynamic.ts

@@ -13,12 +13,12 @@ import moment = require("moment");
  * 获取党建动态列表
  * @param bId 
  * @param theme 主题
- * @param activityYear 
- * @param activityMonth 
- * @returns 
+ * @param activityYear 年份
+ * @param activityMonth 月份
+ * @returns partyBuildingDynamicList:[{"pbId":1, "theme":"党建动态主题", "dataMonth":"数据月份"}, ......]
  */
-export async function partyBuildingDynamicList(bId, theme, activityYear:number, activityMonth:number) {
-    let timeStr = `${activityYear}-${activityMonth}-1 00:00:01`;
+export async function partyBuildingDynamicList(bId:number, theme:string, activityYear:string, activityMonth:string) {
+    let timeStr = new Date(`${activityYear}-${activityMonth}`).valueOf();
     let stTime = moment(timeStr).startOf("month").format("YYYY-MM-DD HH:mm:ss");
     let etTime = moment(timeStr).endOf('month').format("YYYY-MM-DD HH:mm:ss");
 
@@ -44,9 +44,9 @@ export async function partyBuildingDynamicList(bId, theme, activityYear:number,
 /**
  * 获取党建动态详情
  * @param pbId 
- * @returns 
+ * @returns partyBuildingDynamicInfo:{ "theme":"党建动态主题", "dataMonth":"数据月份", "fileName":["党建动态文件名称", ......] }
  */
-export async function partyBuildingDynamicDetsils(pbId) {
+export async function partyBuildingDynamicDetsils(pbId:number) {
     let param = {pbId};
     let clomun = ["theme", "dataMonth", "fileName"];
     let partyBuildingDynamicInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党建动态表, param, clomun);

src/biz/partyExpenses.ts

@@ -17,10 +17,11 @@ import { PARTYPOSITIONSICON } from "../config/clientEnum";
  * @param payType 缴纳状态
  * @param payableYear 缴纳时间-年份
  * @param payableMonth 缴纳时间-月份
- * @returns 
+ * @returns 基础数据："baseData": {"partyCount":党员总数, "paid":已缴纳人数, "unpaid":未缴纳人数}
+ * @returns 党费列表："partyExpensesList": [{"name":"党员名称","payType":"缴纳状态","pmId":"党员id","payTime":"缴纳时间","partyPositionsName":"党内职务","departmentName":"所属科室","partyJoiningTime":"党龄"}, ......]
  */
  export async function partyExpensesData(bId, name, payType, payableYear, payableMonth) {
-    let timeStr = `${payableYear}-${payableMonth}-1 00:00:01`;
+    let timeStr = new Date(`${payableYear}-${payableMonth}`).valueOf();
     let stTime = moment(timeStr).startOf("month").format("YYYY-MM-DD HH:mm:ss");
     let etTime = moment(timeStr).endOf('month').format("YYYY-MM-DD HH:mm:ss");
     let param = {
@@ -38,6 +39,7 @@ import { PARTYPOSITIONSICON } from "../config/clientEnum";
     });
 
     let memberParam = { etId: 1, bId: {"%like%": bId} };
+    if(name) memberParam["name"] = {"%like%": name};
     let memberClomun = ["pmId", "name", "partyPositionsName", "departmentName", "partyJoiningTime"];
     let partyMenberDataList = await selectData(OPERATIONALDATATYPE.查询多个 , TABLENAME.党员基础信息表, memberParam, memberClomun);
 
@@ -51,19 +53,20 @@ import { PARTYPOSITIONSICON } from "../config/clientEnum";
     partyMenberDataList.forEach(info => {
         let {name, pmId, partyPositionsName, departmentName, partyJoiningTime} = info;
         let expInfo = expMap[pmId];
-        if (!expInfo) expInfo = {payType:configEnum.PAYTYPE.未缴纳, payTime:timeStr};
+        if (!expInfo) expInfo = {payType:configEnum.PAYTYPE.未缴纳, payTime:timeStr}; //对应党员没有缴纳信息，返回一条该月未缴纳数据
 
         if (expInfo.payType == configEnum.PAYTYPE.已缴纳) baseData.paid += 1;
         else baseData.unpaid += 1;
-
+        let payTime = "";
+        if(expInfo.payTime) payTime = moment(expInfo.payTime).format("YYYY-MM-DD");
         partyExpensesList.push({
             name,
             payType:changeEnumValue(configEnum.PAYTYPE, expInfo.payType),
             pmId,
-            payTime:moment(expInfo.payTime).format("YYYY-MM-DD"),
-            partyPositionsName:changeEnumValue(PARTYPOSITIONSICON, JSON.parse(partyPositionsName)), //党内职务
-            departmentName:changeEnumValue(configEnum.DEDPARTMENT, JSON.parse(departmentName)), //所属科室
-            partyJoiningTime:`${new Date().getFullYear() - parseInt(partyJoiningTime)}年` //党龄
+            payTime,
+            partyPositionsName: changeEnumValue(PARTYPOSITIONSICON, JSON.parse(partyPositionsName)), //党内职务
+            departmentName: changeEnumValue(configEnum.DEDPARTMENT, JSON.parse(departmentName)), //所属科室
+            partyJoiningTime: `${new Date().getFullYear() - parseInt(partyJoiningTime)}年` //党龄
         });
     });
 

src/biz/partyMember.ts

@@ -9,14 +9,14 @@ import { extractData } from "../util/piecemeal";
 import * as splitResultConfig from "../config/splitResultConfig";
 import moment = require("moment");
 import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
-import { selectData } from "../middleware/databaseSuccess";
+import { selectData, selectManyTableData } from "../middleware/databaseSuccess";
 
 /**
  * 获取党员名册
  * @param branchId 支部id
  * @returns 返回格式 {nameList:[返回字段参考splitResultConfig文件中的partyMemberConfig配置], partyMemberCount:{目前党员人数}}
  */
-export async function partyMemberNameList(bId, name) {
+export async function partyMemberNameList(bId:number, name:string) {
     let branchName = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, bId);
     
     let partyMemberNum = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {bId:{"%like%":bId}}, []); //党员总数
@@ -69,7 +69,7 @@ export async function partyMemberNameList(bId, name) {
  * @param pmId 党员id
  * @returns changeData:{返回字段参考splitResultConfig文件中的partyMemberDetailsConfig配置} 根据党员id返回党员详细信息
  */
- export async function partyMemberDetails(bId, pmId) {
+ export async function partyMemberDetails(bId:number, pmId:string) {
     let clomun = ["bId", "pmId", "etId", "name", "sex", "birthDate", "phone", "levelOfEducation", "bId", "partyPositionsName", "partyJoiningTime", "administrativePositionName", 
     "departmentName", "askForTime", "listedAsActivistsTime", "liaison", "talkTime", "partyState"]
     let partyMemberList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {pmId}, clomun);
@@ -115,51 +115,44 @@ export async function partyMemberNameList(bId, name) {
  * 党员学习数据
  * @param bId 支部
  * @param pmId 党员
- * @returns 
+ * @returns studentData:[{key:"学习排名", value:0},{key:"学习课时", value:0},{key:"学习进度", value:0}]
  */
-export async function getStudent(bId, pmId) {
+export async function getStudent(bId:number, pmId:string) {
     let orderParam = {"%orderDesc%": "dataTime", "%limit%": 1};
     let monthData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习强国, orderParam, ["dataTime"]);
+    if (!monthData || !monthData.dataTime) return [];
 
-    let param = {
-        bId: {"%like%": bId}
-    }
-
-    let stTime = moment(monthData.dataTime).startOf("month").format("YYYY-MM-DD HH:mm:ss");
-    let etTime = moment(monthData.dataTime).endOf('month').format("YYYY-MM-DD HH:mm:ss");
-    if (monthData.dataTime) param["dataTime"] = {"%between%": [stTime, etTime]} //`DATE_FORMAT(dataMonth, '%Y-%m') = DATE_FORMAT(${dataMonth}, '%Y-%m')`;
-
-    let clomun = ["pmId", "partyMemberName", "bId", "dayIntegral", "dataTime"]
+    let dataTime = monthData.dataTime;
+    let stTime = moment(dataTime).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(dataTime).endOf('month').format("YYYY-MM-DD HH:mm:ss");
     
-    let learningPowerData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习强国, param, clomun);
+    let param = {
+        dataTime:{"%between%": [stTime, etTime]}
+    };
+    if (bId) param["bId"] = {"%like%": bId};
+   
+    let clomun = ["pmId", "bId", "dayIntegral", "dataTime"];
+    let includeConf = {"partyMember":["name"]}
+    let learningPowerData = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.学习强国, param, clomun, includeConf);
 
     let partyMemberNameData = {};
     learningPowerData.forEach( info => {
-        let {pmId, partyMemberName, bId, dayIntegral, dataTime} = info;
-        if (!partyMemberNameData[partyMemberName]) partyMemberNameData[partyMemberName] = [];
-        dataTime = moment(dataTime).format("YYYY-MM")
-        partyMemberNameData[partyMemberName].push({pmId, bId, dayIntegral, dataTime});
-    })
+        let {pmId, partyMember, bId, dayIntegral, dataTime} = info;
+        if (!partyMemberNameData[partyMember.name]) {
+            partyMemberNameData[partyMember.name] = {
+                pmId,
+                name:partyMember.name,
+                bId:verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, bId), 
+                dayIntegral:0,
+                dataTime: moment(dataTime).format("YYYY-MM"),
+            };
+        }
 
-    let learningPowerList = [];
-    for (let key in partyMemberNameData) {
-        let partyMemberDayData = partyMemberNameData[key];
-        let dayIntegralData = {pmId:"", name: key, bId:0, dayIntegral:0, dataTime:""};
-        partyMemberDayData.forEach( info => {
-            let {pmId, bId, dayIntegral, dataTime} = info;
-            dayIntegralData.pmId = pmId;
-            dayIntegralData.bId = bId;
-            dayIntegralData.dayIntegral += dayIntegral;
-            dayIntegralData.dataTime = dataTime;
-        })
-
-        let changeData:any = extractData(splitResultConfig.learningPowerConfig, dayIntegralData);
-        changeData.bId = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, dayIntegralData.bId);
-        changeData.dataTime = moment(dayIntegralData.dataTime).format("YYYY-MM");
-        learningPowerList.push(changeData);
-    }
+        partyMemberNameData[partyMember.name].dayIntegral += dayIntegral;
+    });
+    let learningPowerList = Object.values(partyMemberNameData);
 
-    learningPowerList.sort( (a, b) => {
+    learningPowerList.sort( (a:any, b:any) => {
         return b.dayIntegral - a.dayIntegral;
     });
 
@@ -168,11 +161,6 @@ export async function getStudent(bId, pmId) {
     }
     
     let studentData:any = [{key: "学习排名", value: 0}];
-    learningPowerList.forEach( info => {
-        if (info.pmId == pmId) {
-            studentData[0]["value"] = info.ranking;
-        }
-    })
 
     let rateLearningData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习进度表, {pmId}, ["mlId", "pmId", "rateOfLearning", "learningCompleted"]);
 

src/biz/partyQuality.ts

@@ -6,11 +6,18 @@ import * as configEnum from "../config/enum";
 import { selectData } from "../middleware/databaseSuccess";
 import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
 import * as verificationEnumTools from "../util/verificationEnum";
+import moment = require("moment");
 
 
-export async function partyQualityList(bId) {
-    let clomun = ["pqId", "primaryIndicators", "secondaryIndicators", "thirdLevelContent", "thirdLevelScore", "currentScore", "completionProgress"];
-    let partyQualityData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量, {bId:{"%like%": bId}}, clomun);
+/**
+ * 党建质量指数列表
+ * @param bId 支部id
+ * @returns [{"dataList":{"key":"一级指标名称","list":{"totalScore":0,"completionProgress":}}}]
+ */
+export async function partyQualityList(bId:number) {
+    let dataYear = moment(new Date().valueOf()).format("YYYY");
+    let clomun = ["tlId", "primaryIndicators", "secondaryIndicators", "thirdLevelContent", "thirdLevelScore", "currentScore", "completionProgress"];
+    let partyQualityData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量三级指标, {bId:{"%like%": bId}, dataYear}, clomun);
     
     let partyQualityList = [];
     for (let key in configEnum.PRIMARYINDICATORS) {
@@ -23,7 +30,7 @@ export async function partyQualityList(bId) {
 
             partyQualityData.forEach( info => {
                 let schedule = "进行中";
-                let {pqId, primaryIndicators, secondaryIndicators, thirdLevelContent, thirdLevelScore, currentScore, completionProgress} = info; //一级指标、总分、三级指标得分、完成进度
+                let {tlId, primaryIndicators, secondaryIndicators, thirdLevelContent, thirdLevelScore, currentScore, completionProgress} = info; //一级指标、总分、三级指标得分、完成进度
                 if (completionProgress == 100) schedule = "已完成"
                 if (primaryIndicators == EnumValue) {
                     primaryIndicatorsData["dataList"]["list"].push({
@@ -32,16 +39,17 @@ export async function partyQualityList(bId) {
                         currentScore,
                         completionProgress,
                         schedule
-                    })
+                    });
+
                     let secondary = verificationEnumTools.changeEnumValue(configEnum.SECONDARYINDICATORS, secondaryIndicators);
                     if(!primaryIndicatorsData["detail"][secondary]) primaryIndicatorsData["detail"][secondary] = {schedule, dataList: []};
                     if (thirdLevelScore != currentScore) primaryIndicatorsData["detail"][secondary]["schedule"] = "进行中";
                     primaryIndicatorsData["detail"][secondary]["dataList"].push({
                         thirdLevelContent,
                         thirdLevelScore,
-                    })
+                    });
+
                 }
-                
             })
             partyQualityList.push(primaryIndicatorsData);
         }

src/biz/partyVanguard.ts

@@ -12,13 +12,12 @@ import moment = require("moment");
 
 /**
  * 获取党建先锋列表
- * @param bId 
+ * @param bId 弃用支部id，数据表删除该字段
  * @param honorName 
  * @returns 
  */
-export async function partyVanguardList(bId, honorName) {
+export async function partyVanguardList(bId:number, honorName:string) {
     let param = {
-        bId: {"%like%":bId},
         isUse: 1,
     };
     if(honorName) param["honorName"] = {"%like%":honorName};
@@ -45,7 +44,7 @@ export async function partyVanguardList(bId, honorName) {
  * @param pvId 
  * @returns 
  */
-export async function partyVanguardDetsils(pvId) {
+export async function partyVanguardDetsils(pvId:number) {
     let param = {pvId};
     let clomun = ["honorName", "honorType", "grantingRange", "grantingUnit", "grantTime"];
 

src/biz/user.ts

@@ -26,7 +26,7 @@ export async function login(loginId:string, pwd:string) {
     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.党员基础信息表, updateLogin, {loginId});
 
     return {
-        userid: loginInfo.pmId,
+        userid: loginInfo.loginId,
         token: Token,
         bId: loginInfo.bId,
     };

src/config/dbEnum.ts

 
 /**
- * 请求数据中心类型
- */
+ * 请求数据中心类型
+ */
 export enum OPERATIONALDATATYPE {
-    增加='/yfs/dataserver/mysql/table/add',
-    修改='/yfs/dataserver/mysql/table/update',
-    删除='/yfs/dataserver/mysql/table/delete',
-    查询单个='/yfs/dataserver/mysql/table/find/one',
-    查询多个='/yfs/dataserver/mysql/table/find/many',
-    分页查询='/yfs/dataserver/mysql/table/find/manytopage',
-    查询数据量='/yfs/dataserver/mysql/table/find/count',
-    多表联查='/yfs/dataserver/mysql/table/find/aggragate',
+    增加 = '/yfs/dataserver/mysql/table/add',
+    修改 = '/yfs/dataserver/mysql/table/update',
+    删除 = '/yfs/dataserver/mysql/table/delete',
+    查询单个 = '/yfs/dataserver/mysql/table/find/one',
+    查询多个 = '/yfs/dataserver/mysql/table/find/many',
+    分页查询 = '/yfs/dataserver/mysql/table/find/manytopage',
+    查询数据量 = '/yfs/dataserver/mysql/table/find/count',
+    多表联查 = '/yfs/dataserver/mysql/table/find/aggragate',
+    多表分页 = '/yfs/dataserver/mysql/table/find/aggragatetopage',
+    多表查询单个 = '/yfs/dataserver/mysql/table/find/aggragateone'
 }
 
 
@@ -31,5 +33,5 @@ export enum TABLENAME {
     学习进度表='rateLearning',
     课程类型='courseType',
     学习强国='learningPower',
-    党建质量='partyQuality',
+    党建质量三级指标='thirdLevel',
 }
\ No newline at end of file

src/config/enum.ts

@@ -188,24 +188,24 @@ export enum PRIMARYINDICATORS {
 
 /**二级指标 */
 export enum  SECONDARYINDICATORS {
-    "突出政治功能，确保政治站位" = 1.1,
-    "组织架构完备，配强工作力量" = 1.2,
-    "支部制度完善" = 1.3,
-    "“三会一课”、主题党日活动规范落实" = 2.1,
-    "党员发展、党籍管理、党费收缴、使用、管理规范" = 2.2,
-    "教育培训及时到位" = 2.3,
-    "日常亮身份、树形象" = 3.1,
-    "各类先进评选" = 3.2,
-    "参与行业党建、区域化党建" = 3.3,
-    "履行党风廉政建设主体责任和监督责任" = 4.1,
-    "医德医风和行风建设" = 4.2,
-    "医院文化建设" = 5.1,
-    "精神文明建设、统战和群团工作" = 5.2,
-    "培育选树先进典型，打造医疗服务品牌" = 5.3,
-    "常态化了解困难诉求，健全职工意见诉求机制" = 5.4,
-    "开展党建课题研究，刊登发表党建论文" = 6.1,
-    "社会影响大、特别典型" = 6.2,
-    "积极开展党支部品牌创建" = 6.3,
+    突出政治功能_dou确保政治站位 = 11,
+    组织架构完备_dou配强工作力量 = 12,
+    支部制度完善 = 13,
+    _zyh三会一课_yyh_dun主题党日活动规范落实 = 21,
+    党员发展_dun党籍管理_dun党费收缴_dun使用_dun管理规范 = 22,
+    教育培训及时到位 = 23,
+    日常亮身份_dun树形象 = 31,
+    各类先进评选 = 32,
+    参与行业党建_dun区域化党建 = 33,
+    履行党风廉政建设主体责任和监督责任 = 41,
+    医德医风和行风建设 = 42,
+    医院文化建设 = 51,
+    精神文明建设_dun统战和群团工作 = 52,
+    培育选树先进典型_dou打造医疗服务品牌 = 53,
+    常态化了解困难诉求_dou健全职工意见诉求机制 = 54,
+    开展党建课题研究_dou刊登发表党建论文 = 61,
+    社会影响大_dun特别典型 = 62,
+    积极开展党支部品牌创建 = 63,
 }
 
 

src/config/errorEnum.ts

 
 export enum ERRORENUM {
-    未找到数据,
-    账号不存在,
-    密码错误,
-    密码不一致,
-    密码只能由6至18位字符和数字组成,
-    不能重复修改密码,
-    表单校验失败,
+    身份验证失败 = 1,
+    非法登录,
+    身份验证过期,
     参数错误,
-    数据无更新,
     地址数据不完整,
-    身份验证失败,
-    非法登录,
-    非党员账号,
-    参数不符合规则,
+    请完善信息,
     该方法仅可进行数据操作,
     数据操作失败,
+    数据查询失败,
+    数据联合查询失败,
+    该方法仅可进行查询操作,
+    该方法仅可进行联合查询操作,
     分页请设置当前页数,
+    密码错误,
+    用户不存在,
+    该用户不是管理员,
+    目标用户不是正式党员,
+    管理员不可被删除,
+    权限不足,
+    目标数据不存在,
+    账号不存在,
+    密码不一致,
+    密码只能由6至18位字符和数字组成,
+    未找到数据,
     库中不存在对应数据,
+    表单校验失败,
     暂无对应数据
 }
 

src/main.ts

-import moment = require("moment");
 import { initConfig, systemConfig} from "./config/systemConfig";
 import { httpServer } from "./net/http_server";
-import { getPwdMd5, getToken, md5PwdStr } from "./tools/system";
-import { initBasicData } from "./tools/dataInit";
-import { operationalData } from "./middleware/databaseSuccess";
-import { OPERATIONALDATATYPE, TABLENAME } from "./config/dbEnum";
+import { md5PwdStr } from "./tools/system";
 
 async function lanuch() {
     /**初始化配置解析 */
     await initConfig();
     /**初始化底表数据 */
-    await initBasicData();
+    // await initBasicData();
     /**创建http服务 */
     httpServer.createServer(systemConfig.port);
     console.log('This indicates that the server is started successfully.');
-    // await test();
+    await test();
 }
 
-lanuch();
+lanuch();
\ No newline at end of file
+
+
+function test() {
+    let pwd = md5PwdStr("admin");
+    console.log();
+}
\ No newline at end of file

src/middleware/databaseSuccess.ts

@@ -64,36 +64,43 @@ export async function selectData(url, tableName, param, column, pageNumber?, pag
 }
 
 
+
 /**
- * 多表联查
- * @param url url地址 根据枚举获取值
- * @param tableName 表名
- * @param includeConf {"表名":["",""] } 
- * @param param 条件
- * @param pageNumber 分页传入的页数  非分页可不传
- * @param pageSize 分页传入的单页大小  非分页可不传
- */
-export async function associationSelectData(url, tableName, includeConf, param, column, pageNumber?, pageSize?) {
-    if (url != OPERATIONALDATATYPE.多表联查) {
-        throw new BizError(ERRORENUM.该方法仅可进行数据操作, '该方法仅可进行查询操作');
+ * 多表联查
+ * @param url url地址 根据枚举获取值
+ * @param tableName 表名
+ * @param param 参数
+ * @param column 返回的列
+ * @param includeConf {"表名":["",""]}
+ * @param pageNumber 分页传入的页数 非分页可不传
+ * @param pageSize 分页传入的单页大小 非分页可不传
+ * @returns 
+ */
+ export async function selectManyTableData(url, tableName, param, column,  includeConf, pageNumber?, pageSize?) {
+    if (url != OPERATIONALDATATYPE.多表联查 && url != OPERATIONALDATATYPE.多表分页) {
+        throw new BizError(ERRORENUM.该方法仅可进行联合查询操作, '该方法仅可进行联合查询操作');
     }
     let header = {table:tableName, sign:systemConfig.dbSign};
-    let queray:any = {param, includeConf, column};
-
+    let queray:any = {param, includeConf};
+    if (column && column.length) {
+        queray.column = column;
+    }
+    
     if (url == OPERATIONALDATATYPE.分页查询) {
         if (!pageNumber) throw new BizError(ERRORENUM.分页请设置当前页数, `pageNumber:${pageNumber};pageSize:${pageSize}`);
         queray.pageNumber = pageNumber;
         queray.pageSize = pageSize || 10;
     }
-    
+
+
     let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
-    if (result.code != 200) throw new BizError(ERRORENUM.数据操作失败, result.code);
-    if (!result.data || !result.data.isSuccess) throw new BizError(ERRORENUM.数据操作失败, JSON.stringify(result.data));
-    
-    return result.data;
+    if (result.code != 200) throw new BizError(ERRORENUM.数据联合查询失败, result.code);
+    if (!result.data || !result.data.data) throw new BizError(ERRORENUM.数据联合查询失败, JSON.stringify(result.data));
+    return result.data.data;
 }
 
 
+
 export async function getDatabaseSuccess(url, data) {
     let result;
     if (data) {

src/middleware/user.ts

@@ -3,7 +3,6 @@ import { ERRORCODEENUM, ERRORENUM } from "../config/errorEnum";
 import { BizError } from "../util/bizError";
 import { selectData } from "./databaseSuccess";
 
-
 /**
  * 中间件 校验小程序token
  * @param req 
@@ -13,14 +12,14 @@ import { selectData } from "./databaseSuccess";
  */
 export async function checkAppletToken(req, res, next) {
     if (!req.headers) req.headers = {};
+    let ReqToken = req.headers.token;
+    let UserId = req.headers.userid;
 
-    const ReqToken = req.headers.token;
-    const UserId = req.headers.userid || "";
-
-    if(!UserId) return next(new BizError(ERRORCODEENUM.身份验证失败, `loginId:${UserId} token:${ReqToken}`));
+    if(!UserId || !ReqToken) return next(new BizError(ERRORENUM.非法登录));
 
     let partyMemberInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {loginId: UserId}, ["pmId", "bId", "loginId", "token"]);
-    if (!partyMemberInfo) return next(new BizError(ERRORCODEENUM.非法登录, `loginId:${UserId} token:${ReqToken}`));
+    if (!partyMemberInfo || !partyMemberInfo.pmId) return next(new BizError(ERRORENUM.身份验证失败));
+    if (!partyMemberInfo.token || partyMemberInfo.token != ReqToken) return next(new BizError(ERRORENUM.身份验证过期));
 
     req.headers.userid = partyMemberInfo.pmId;
     

src/routers/abi/partyBuilding.ts

+/**
+ * abi接口——党建分析
+ */
+
+import * as partyBuildingBiz from '../../biz/abi/partyBuilding';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/abi/partybuilding/leftscreen', asyncHandler(leftScreen));
+    httpServer.post('/yfs/abi/partybuilding/midscreen', asyncHandler(midScreen));
+    httpServer.post('/yfs/abi/partybuilding/rightscreen', asyncHandler(rightScreen));
+}
+
+
+async function leftScreen(req, res) {
+    let result = await partyBuildingBiz.getLeftScreen();
+    res.success(result);
+}
+
+
+async function midScreen(req, res) {
+    let {year} = eccReqParamater({year:'String'}, req.body);
+    let result = await partyBuildingBiz.getMidScreen(year);
+    res.success(result)
+}
+
+
+
+async function rightScreen(req, res) {
+    let result = await partyBuildingBiz.getRightScreen();
+    res.success(result);
+}
\ No newline at end of file

src/routers/abi/organizationalLife.ts → src/routers/abi/target.ts

 /**
- * abi用接口
+ * abi接口——党建目标
  */
 
-import * as organizationalLifeBiz from '../../biz/abi/organizationalLife';
+import * as targetBiz from '../../biz/abi/target';
 import * as asyncHandler from 'express-async-handler';
 
 export function setRouter(httpServer) {
-    httpServer.post('/abi/activity', asyncHandler(activity));
+    httpServer.post('/yfs/abi/target/list', asyncHandler(targetData));
 }
 
 
-async function activity(req, res) {
-    let result = await organizationalLifeBiz.getActivityCount();
+async function targetData(req, res) {
+    let result = await targetBiz.getTargetData();
     res.success(result);
-}
+}
\ No newline at end of file
+
+
+
+
+
+
+
+
+

src/routers/applet/base.ts

@@ -5,10 +5,11 @@
 import * as baseBiz from '../../biz/base';
 import * as asyncHandler from 'express-async-handler';
 import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
 
 export function setRouter(httpServer) {
-    httpServer.post('/yfs/applet/partymember/home', asyncHandler(homeBase));
-    httpServer.post('/yfs/applet/partymember/activities', asyncHandler(activitiesBase));
+    httpServer.post('/yfs/applet/partymember/home', checkAppletToken, asyncHandler(homeBase));
+    httpServer.post('/yfs/applet/partymember/activities', checkAppletToken, asyncHandler(activitiesBase));
 }
 
 

src/routers/applet/branchSystem.ts

@@ -8,8 +8,8 @@
 import { checkAppletToken } from '../../middleware/user';
  
  export function setRouter(httpServer) {
-    httpServer.post('/yfs/applet/branchsystem/list', asyncHandler(getBranchSystem));
-    httpServer.post('/yfs/applet/branchsystem/detsils', asyncHandler(getBranchSystemDetsils));
+    httpServer.post('/yfs/applet/branchsystem/list', checkAppletToken, asyncHandler(getBranchSystem));
+    httpServer.post('/yfs/applet/branchsystem/detsils', checkAppletToken, asyncHandler(getBranchSystemDetsils));
  }
  
 

src/routers/applet/memberLearning.ts

@@ -11,11 +11,12 @@ export function setRouter(httpServer) {
     httpServer.post('/yfs/applet/memberlearning/list', checkAppletToken, asyncHandler(getMemberLearning));
     httpServer.post('/yfs/applet/memberlearning/branchranking', checkAppletToken, asyncHandler(getBranchRanking));
     httpServer.post('/yfs/applet/memberlearning/monthranking', checkAppletToken, asyncHandler(getMonthRanking));
+    httpServer.post('/yfs/applet/memberlearning/updateschedule', checkAppletToken, asyncHandler(updateRateLearning));
 }
 
 
 /**  
-  * 党建先锋 视频课程列表
+  * 党建先锋 视频课程与文字课程列表
   * @param req 
   * @param res 
   */
@@ -35,9 +36,10 @@ async function getMemberLearning(req, res) {
  * @param res 
  */
 async function getBranchRanking(req, res) {
+  let pmId = req.headers.userid;
   let {bId} = eccReqParamater({bId:'Number'}, req.body);
 
-  let result = await memberLearningBiz.branchRanking(bId);
+  let result = await memberLearningBiz.branchRanking(pmId, bId);
   res.success(result);
 }
 
@@ -48,14 +50,31 @@ async function getBranchRanking(req, res) {
  * @param res 
  */
 async function getMonthRanking(req, res) {
-  let result = await memberLearningBiz.branchRanking();
+  let pmId = req.headers.userid;
+  let result = await memberLearningBiz.branchRanking(pmId);
   res.success(result);
 }
 
 
+/**
+ * 修改学习进度
+ * @param req 
+ * @param res 
+ */
+async function updateRateLearning(req, res) {
+  let reqConf = {rlId:'Number', rateOfLearning:'Number'};
+  let {rlId, rateOfLearning} = eccReqParamater(reqConf, req.body);
+
+  let result = await memberLearningBiz.updateRateOfLearning(rlId, rateOfLearning);
+  res.success(result);
+}
+
+
+
+
+
+
+
 
 
 
- 
- 
- 
\ No newline at end of file

src/routers/applet/organizationalLife.ts

@@ -8,8 +8,8 @@ import { eccReqParamater } from '../../util/verificationParam';
 import { checkAppletToken } from '../../middleware/user';
 
 export function setRouter(httpServer) {
-    httpServer.post('/yfs/applet/organizationallife/list', asyncHandler(organizationalLifeList));
-    httpServer.post('/yfs/applet/organizationallife/details', asyncHandler(detailsList));
+    httpServer.post('/yfs/applet/organizationallife/list', checkAppletToken, asyncHandler(organizationalLifeList));
+    httpServer.post('/yfs/applet/organizationallife/details', checkAppletToken, asyncHandler(detailsList));
 }
 
 

src/routers/applet/partyBuildingDynamic.ts

@@ -8,8 +8,8 @@
  import { checkAppletToken } from '../../middleware/user';
  
  export function setRouter(httpServer) {
-     httpServer.post('/yfs/applet/buildingdynamic/list', asyncHandler(partyBuildingDynamicList));
-     httpServer.post('/yfs/applet/buildingdynamic/details', asyncHandler(detailsList));
+     httpServer.post('/yfs/applet/buildingdynamic/list', checkAppletToken, asyncHandler(partyBuildingDynamicList));
+     httpServer.post('/yfs/applet/buildingdynamic/details', checkAppletToken, asyncHandler(detailsList));
  }
  
  

src/routers/applet/partyExpenses.ts

@@ -8,7 +8,7 @@ import { eccReqParamater } from '../../util/verificationParam';
 import { checkAppletToken } from '../../middleware/user';
  
 export function setRouter(httpServer) {
-    httpServer.post('/yfs/applet/partymember/partyexpenses', asyncHandler(getPartyExpenses));
+    httpServer.post('/yfs/applet/partyexpenses/list', checkAppletToken, asyncHandler(getPartyExpenses));
     
 }
  

src/routers/applet/partyInforMation.ts

-/**
- * 小程序端 党员入口 党建资讯
- */
-
-import * as asyncHandler from 'express-async-handler';
-import { eccReqParamater } from '../../util/verificationParam';
-import { checkAppletToken } from '../../middleware/user';
- 
-export function setRouter(httpServer) {
-    
-}
-

src/routers/applet/partyMember.ts

@@ -8,8 +8,8 @@ import { eccReqParamater } from '../../util/verificationParam';
 import { checkAppletToken } from '../../middleware/user';
  
 export function setRouter(httpServer) {
-    httpServer.post('/yfs/applet/partymember/partymembername', asyncHandler(getPartyMemberName));
-    httpServer.post('/yfs/applet/partymember/detsils', asyncHandler(partyDetsils));
+    httpServer.post('/yfs/applet/partymember/partymembername', checkAppletToken, asyncHandler(getPartyMemberName));
+    httpServer.post('/yfs/applet/partymember/detsils', checkAppletToken, asyncHandler(partyDetsils));
 }
  
 
@@ -20,7 +20,7 @@ export function setRouter(httpServer) {
   */
 async function getPartyMemberName(req, res) {
     let reqConf = {bId:'Number', name:'String'};
-    let {bId, name} = eccReqParamater(reqConf, req.body);
+    let {bId, name} = eccReqParamater(reqConf, req.body, ["name"]);
 
     let result = await partyMemberBiz.partyMemberNameList(bId, name);
     res.success(result);

src/routers/applet/partyQuality.ts

@@ -8,7 +8,7 @@ import { eccReqParamater } from '../../util/verificationParam';
 import { checkAppletToken } from '../../middleware/user';
 
 export function setRouter(httpServer) {
-    httpServer.post('/yfs/applet/partyquality/list', asyncHandler(getPartyQuality));
+    httpServer.post('/yfs/applet/partyquality/list', checkAppletToken, asyncHandler(getPartyQuality));
     // httpServer.post('/yfs/applet/partyquality/detsils', asyncHandler(getPartyVanguardDetsils));
 }
 

src/routers/applet/partyVanguard.ts

@@ -8,12 +8,8 @@ import { eccReqParamater } from '../../util/verificationParam';
 import { checkAppletToken } from '../../middleware/user';
 
 export function setRouter(httpServer) {
-  httpServer.post('/yfs/applet/partyvanguard/list', asyncHandler(getPartyVanguard));
-  httpServer.post('/yfs/applet/partyvanguard/detsils', asyncHandler(getPartyVanguardDetsils));
-  // httpServer.post('/partymember/partyvanguard/createbranchpioneer', checkAppletToken, asyncHandler(createBranchPioneer));
-  // httpServer.post('/partymember/partyvanguard/createmodelparty', checkAppletToken, asyncHandler(createModelParty));
-  // httpServer.post('/partymember/partyvanguard/update', checkAppletToken, asyncHandler(updatePartyVanguard));
-  // httpServer.post('/partymember/partyvanguard/delete', checkAppletToken, asyncHandler(deletePartyVanguard));
+  httpServer.post('/yfs/applet/partyvanguard/list', checkAppletToken, asyncHandler(getPartyVanguard));
+  httpServer.post('/yfs/applet/partyvanguard/detsils', checkAppletToken, asyncHandler(getPartyVanguardDetsils));
 }
 
 

src/routers/router.ts

@@ -7,7 +7,6 @@ import * as appletBaseRouters from '../routers/applet/base';
 import * as appletPartyMemberRouters from '../routers/applet/partyMember';
 import * as appletBranchSystemRouters from '../routers/applet/branchSystem';
 import * as appletOrganizationalLifeRouters from '../routers/applet/organizationalLife';
-import * as appletPartyInforMationRouters from '../routers/applet/partyInforMation';
 import * as appletPartyVanguardRouters from '../routers/applet/partyVanguard';
 import * as appletPartyExpensesRouters from '../routers/applet/partyExpenses';
 import * as appletPartyQualityRouters from '../routers/applet/partyQuality';
@@ -15,7 +14,8 @@ import * as partyBuildingDynamicRouters from '../routers/applet/partyBuildingDyn
 import * as memberLearningRouters from '../routers/applet/memberLearning';
 
 import * as publicRouters from '../routers/public';
-import * as abiOrganizationalLifeRouters from '../routers/abi/organizationalLife';
+import * as abiPartyBuildingRouters from './abi/partyBuilding';
+import * as abiTargetRouters from './abi/target';
 
 export function setRouter(httpServer){
     /**小程序端 党员入口 */
@@ -24,7 +24,6 @@ export function setRouter(httpServer){
     appletPartyMemberRouters.setRouter(httpServer);
     appletBranchSystemRouters.setRouter(httpServer);
     appletOrganizationalLifeRouters.setRouter(httpServer);
-    appletPartyInforMationRouters.setRouter(httpServer);
     appletPartyVanguardRouters.setRouter(httpServer);
     appletPartyExpensesRouters.setRouter(httpServer);
     appletPartyQualityRouters.setRouter(httpServer);
@@ -35,5 +34,6 @@ export function setRouter(httpServer){
     publicRouters.setRouter(httpServer);
 
     /**ABI */
-    abiOrganizationalLifeRouters.setRouter(httpServer);
+    abiPartyBuildingRouters.setRouter(httpServer);
+    abiTargetRouters.setRouter(httpServer);
 }
\ No newline at end of file

src/tools/dataInit.ts

@@ -245,7 +245,6 @@ async function initLearningPower() {
             let addDataInfo:any = {
                 lpId: id,
                 pmId: null,
-                partyMemberName: null,
                 bId: null,
                 dayIntegral: null,
                 totalIntegral: null,
@@ -261,7 +260,7 @@ async function initLearningPower() {
                 let value = item;
                 if (i == 0) {
                     console.log(item);
-                    let partyMemberDate = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {name:item}, ["pmId", "name"]); //党员总数
+                    let partyMemberDate = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {name:item}, ["pmId"]); //党员总数
                     if (!partyMemberDate) continue;
                     addDataInfo["pmId"] = partyMemberDate.pmId;
                     value = item;
@@ -333,7 +332,14 @@ async function initOrganizationalLife() {
                 value = moment(item).format("YYYY-MM-DD HH:mm:ss");
             }
             if (i == 3 && item) {
-                value = enums.BRANCHNAME[item] || 1;
+                value = [];
+                if (item) {
+                    let oldList = item.split(',');
+                    oldList.forEach(oldStr => {
+                        let valueNum = BranchNameChangeConfig[oldStr.trim()];
+                        if (valueNum) value.push(valueNum);
+                    });
+                };
             }
             if (i == 5) {
                 value = enums.FILETYPE[item] || 1;
@@ -496,4 +502,12 @@ async function initBranchSystem() {
     }
 
     return {sheetMap, sheetList}  
-}
+}
\ No newline at end of file
+
+
+
+
+
+
+
+

src/util/verificationEnum.ts

@@ -37,11 +37,24 @@ export function changeEnumValue(enumConf, value:any) {
     if (!value) return '';
     if ( typeof value == 'number' || typeof value == 'string' ) {
         let str = enumConf[value];
+        /**特化处理 */
+        if(/_dou/.test(str)) str = str.replace(/_dou/, "，");
+        if(/_zyh/.test(str)) str = str.replace(/_zyh/, "“");
+        if(/_yyh/.test(str)) str = str.replace(/_yyh/, "”");
+        if(/_dun/.test(str)) str = str.replace(/_dun/, "、");
+        if(/_ju/.test(str)) str = str.replace(/_ju/, "。");
+
         return str
     }
     let str = "";
     value.forEach((item, index) => {
         let subStr = enumConf[item];
+        /**特化处理 */
+        if(/_dou/.test(subStr)) subStr = subStr.replace(/_dou/, "，");
+        if(/_zyh/.test(subStr)) subStr = subStr.replace(/_zyh/, "“");
+        if(/_yyh/.test(subStr)) subStr = subStr.replace(/_yyh/, "”");
+        if(/_dun/.test(subStr)) subStr = subStr.replace(/_dun/, "、");
+        if(/_ju/.test(subStr)) subStr = subStr.replace(/_ju/, "。");
         
         str += subStr;
         if (index == value.length-1) str+="";