no message

src/biz/admin/caiShou.ts

+/**
+ * 采收逻辑
+ */
+import { TABLENAME } from "../../config/dbEnum";
+import { CaiShouConfig } from "../../config/eccParam";
+import { PLANTTYPE, PURPOSE, ZHONGYANGTYPE } from "../../config/enum";
+import { ERRORENUM } from "../../config/errorEnum";
+import * as caishouData from "../../data/caishou";
+import * as dikuaiData from "../../data/dikuai";
+import * as zhongzhiData from "../../data/zhongzhi";
+import { randomId, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import moment = require("moment");
+
+
+/**
+ * 添加采收
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addCaiShou(reqUser, param) {
+    let funName = `添加采收`;
+    eccFormParam(funName, CaiShouConfig, param );
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+    
+    //修改种养
+    let zhongyangParam = {isEnd:0, plantType:param.plantType, dId:param.dId};
+    let zhongzhiList = await zhongzhiData.selectToParam(zhongyangParam);
+
+    let sizeCount = 0;
+    for (let i = 0; i < zhongzhiList.length; i++) {
+        let {dId, size} = zhongzhiList[i];
+        sizeCount += size;
+    }
+
+    //释放地块
+    let diKuaiInfo = await dikuaiData.selectOne({dId:param.dId});
+    diKuaiInfo.nullSize = diKuaiInfo.nullSize + sizeCount;
+    diKuaiInfo.useSize = diKuaiInfo.useSize - sizeCount;
+    await diKuaiInfo.save();
+
+    let  csId = randomId(TABLENAME.采收);
+    //改变种植面积
+    await zhongzhiData.updateManyToParam({isEnd:0, plantType:param.plantType}, {isEnd:1, csId});
+
+    //添加采收记录
+    let addInfo = {
+        csId,
+        dIdList:param.dId,
+        plantType:param.plantType,
+        operationTime:param.operationTime,
+        weight:param.weight,
+        ct:new Date().valueOf(),
+        createUser:reqUser.userId
+    };
+    await caishouData.addData(addInfo)
+
+    return successResult();
+}
+
+
+
+/**
+ * 采收列表
+ * @param selectStr 
+ * @param dId 
+ * @param zhongYangType 
+ * @param plantType 
+ * @param operationTime 
+ * @returns 
+ */
+export async function caiShouList(zhongYangType:number, dId:string, plantType:number, operationTime:number, pageNumber) {
+    let funName = "采收列表";
+    eccEnumValue(funName, "zhongYangType", ZHONGYANGTYPE, zhongYangType);
+
+    let param:any = { plantType : {"$gte":zhongYangType, "$lt":zhongYangType+99} };
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":[dId]};
+    }
+    if (operationTime) {
+        let startMs = moment(operationTime).startOf("day").valueOf();
+        let endMs = moment(operationTime).endOf("day").valueOf();
+        param.operationTime = {"$gte":startMs, "$lte":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code, purpose} = info;
+        diKuaiMap[dId] = {code, purpose};
+    });
+
+    let caishouList = await caishouData.findDataToParamToSortPage(param, {operationTime:-1}, pageNumber);
+    let dataCount = await caishouData.findDataToParamCouant(param);
+    let dataList = [];
+    caishouList.forEach(item => {
+        let {csId, plantType, dIdList, operationTime, weight, ct } = item;
+        let dIds = dIdList;
+        let didStr = "";
+        let purpose = "";
+        dIds.forEach(dId => {
+            didStr += `${diKuaiMap[dId].code} `;
+            purpose += `${changeEnumValue(PURPOSE, diKuaiMap[dId].purpose)} `;
+        });
+        let operationTimeNum;
+        if (operationTime) operationTimeNum = operationTime;
+        else operationTimeNum = ct
+        dataList.push({
+            csId,
+            plantType:changeEnumValue(PLANTTYPE, plantType),
+            code:didStr,
+            purpose,
+            operationTime:moment(operationTimeNum).format("YYYY-MM-DD"),
+            weight,
+            operationTimeNum,
+            ctTime:moment(ct).format("YYYY-MM-DD"),
+        });
+    });
+
+    dataList.sort( (a, b) => {
+        return b.operationTimeNum - a.operationTimeNum;
+    })
+
+    return {dataList, dataCount}
+}
+
+
+/**
+ * 采收回显
+ * @param csId 
+ * @returns 
+ */
+ export async function caishouInfo(csId) {
+    let caishouInfo = await caishouData.findOne({csId});
+
+    let dataInfo = {
+        plantType:changeEnumValue(PLANTTYPE, caishouInfo.plantType),
+        code:caishouInfo.dIdList[0] || "",
+        operationTime:moment(caishouInfo.operationTime).format("YYYY-MM-DD"),
+        weight:caishouInfo.weight
+    };
+
+    return dataInfo;
+}
+
+
+/**
+ * 修改采收
+ * @param reqUser 
+ * @param csId 
+ * @param param 
+ * @returns 
+ */
+export async function updateCaiShou(reqUser, csId, param) {
+    let funName = `修改采收`;
+    eccFormParam(funName, CaiShouConfig, param );
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+    if (!diKuaiMap[param.dId]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+    let caiShouInfo = await caishouData.findOne({csId});
+
+    caiShouInfo.plantType = param.plantType; //种植种类【枚举】 PLANTTYPE
+    caiShouInfo.dIdList = param.dId;//地块id
+    caiShouInfo.weight = param.weight;//采收重量
+    caiShouInfo.operationTime = param.operationTime; //采收时间
+
+    await caiShouInfo.save();
+
+    return successResult();
+}
+
+
+
+/**
+ * 删除采收
+ * @param nzId 
+ * @returns 
+ */
+export async function deleteCaiShou(csId) {
+    let caishouInfo = await caishouData.findOne({csId});
+    if (!caishouInfo || !caishouInfo.csId) throw new BizError(ERRORENUM.数据不存在);
+
+    await caishouData.deleteData({csId});
+
+    return successResult();
+}
+
+
+

src/biz/diKuai.ts → src/biz/admin/diKuai.ts

@@ -3,15 +3,15 @@
  */
 
 import moment = require("moment");
-import { TABLENAME } from "../config/dbEnum";
-import { DiKuaiConfig, YangZhiChiConfig } from "../config/eccParam";
-import { AREARANGE, PLANTTYPE, PLOTTYPE, PURPOSE, ZHONGYANGTYPE } from "../config/enum";
-import { ERRORENUM } from "../config/errorEnum";
-import * as dikuaiData from "../data/dikuai";
-import { randomId, successResult } from "../tools/system";
-import { BizError } from "../util/bizError";
-import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
-import { eccFormParam } from "../util/verificationParam";
+import { TABLENAME } from "../../config/dbEnum";
+import { DiKuaiConfig, YangZhiChiConfig } from "../../config/eccParam";
+import { AREARANGE, PLANTTYPE, PLOTTYPE, PURPOSE, ZHONGYANGTYPE } from "../../config/enum";
+import { ERRORENUM } from "../../config/errorEnum";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
 
 
 /**
@@ -75,7 +75,7 @@ export async function diKuaiInfo(dId:String ) {
 
 
 /**
- * 地块列表
+ * 地块列表-暂无使用
  * @param plotType 
  * @param selectStr 
  * @param code 
@@ -133,7 +133,7 @@ export async function diKuaiListToPage(code, area, purpose, pageNumber) {
         param.purpose = purpose;
     }
 
-    let diKuaiList = await dikuaiData.findDataToParamToPage(param, pageNumber);
+    let diKuaiList = await dikuaiData.findDataToParamToSortPage(param, {ct:-1}, pageNumber);
     let dataCount = await dikuaiData.findDataToParamCouant({});
     let dataList = [];
     diKuaiList.forEach(item => {
@@ -200,7 +200,7 @@ export async function keXuanDiKuaiList(zhongYangType:number) {
         if (zhongYangType == ZHONGYANGTYPE.水产) purpose = PURPOSE.养殖;
         else if (zhongYangType == ZHONGYANGTYPE.花卉 ||zhongYangType == ZHONGYANGTYPE.蔬菜 ) purpose = PURPOSE.菜田;
         else if (zhongYangType == ZHONGYANGTYPE.粮食) purpose = PURPOSE.粮田;
-        param.nullSize = {"$gt":0};
+        // param.nullSize = {"$gt":0};
         param.purpose = purpose;
     }
 
@@ -220,7 +220,7 @@ export async function keXuanDiKuaiList(zhongYangType:number) {
 
 
 /**
- * 当前采收地块列表
+ * 当前采收地块列表-暂无使用
  * @returns 
  */
 export async function keCaiShouList(zhongYangType:number) {
@@ -243,7 +243,7 @@ export async function keCaiShouList(zhongYangType:number) {
 }
 
 /**
- * 全部地块列表
+ * 全部地块列表-暂无使用
  * @param plotType 
  * @param selectStr 
  * @param code 
@@ -266,3 +266,4 @@ export async function allDiKuaiList(plotType:number ) {
 
     return {dataList}
 }
+

src/biz/admin/nongShi.ts

+import { TABLENAME } from "../../config/dbEnum";
+import { CaiShouConfig, NongShiAdminConfig } from "../../config/eccParam";
+import { NONGSHITYPE, PLANTTYPE, PURPOSE } from "../../config/enum";
+import * as nongshiData from "../../data/nongshi";
+import * as dikuaiData from "../../data/dikuai";
+import { getMySqlMs, randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import moment = require("moment");
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
+
+/**
+ * 添加农事
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addNongShi(reqUser, param) {
+    let funName = `添加农事`;
+    eccFormParam(funName, NongShiAdminConfig, param );
+    eccEnumValue(funName, "nsType", NONGSHITYPE, param.nsType);
+    //确保添加时地块还在
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+    if (!diKuaiMap[param.dIdList]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+    let addInfo = {
+        nsId:randomId(TABLENAME.农事),
+        nsType:param.nsType,
+        dIdList:[param.dIdList],
+        operationTime:param.operationTime,
+        ct:new Date().valueOf()
+    };
+    await nongshiData.addData(addInfo)
+
+    return successResult();
+}
+
+/**
+ * 农事列表
+ * @param selectStr 
+ * @param dId 
+ * @param nsType 
+ * @param operationTime 
+ * @returns 
+ */
+export async function nongShiList(nsType:number, dId:string, operationTime:number, pageNumber:number) {
+    let funName = "农事列表";
+    let param:any = {};
+    if (nsType) {
+        eccEnumValue(funName, "nsType", NONGSHITYPE, nsType);
+        param.nsType = nsType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":dId};
+    }
+    if (operationTime) {
+        let startMs = moment(operationTime).startOf("day").valueOf();
+        let endMs = moment(operationTime).endOf("day").valueOf();
+        param.operationTime = {"$gte":startMs, "$lte":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code, purpose} = info;
+        diKuaiMap[dId] = {code, purpose};
+    });
+
+    let nongShiList = await nongshiData.findDataToParamToSortPage(param, {operationTime:-1}, pageNumber);
+    let dataCount = await nongshiData.findDataToParamCouant({});
+    let dataList = [];
+    nongShiList.forEach(item => {
+        let {nsId, nsType, dIdList, operationTime } = item;
+        let dIds = dIdList;
+        let didStr = "";
+        let purpose = "";
+        dIds.forEach(dId => {
+            didStr += `${diKuaiMap[dId].code} `;
+            purpose += `${changeEnumValue(PURPOSE, diKuaiMap[dId].purpose)} `;
+        });
+
+        dataList.push({
+            nsId,
+            nsType:changeEnumValue(NONGSHITYPE, nsType),
+            // dIdList:didStr,
+            operationTime:moment(operationTime).format("YYYY-MM-DD"),
+            operationTimeNum:operationTime,
+            code:didStr,
+            purpose,
+        });
+    });
+
+    dataList.sort( (a, b) => {
+        return b.operationTimeNum - a.operationTimeNum;
+    })
+
+    return {dataList, dataCount}
+}
+
+
+/**
+ * 农事回显
+ * @param nzId 
+ * @returns 
+ */
+export async function nongShiInfo(nsId) {
+    let nongShiInfo = await nongshiData.findOne({nsId});
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code, purpose} = info;
+        diKuaiMap[dId] = {code, purpose};
+    });
+
+    let didStr = "";
+    let purpose = "";
+    nongShiInfo.dIdList.forEach(dId => {
+        didStr += `${diKuaiMap[dId].code} `;
+        purpose += `${changeEnumValue(PURPOSE, diKuaiMap[dId].purpose)} `;
+    });
+
+    let dataInfo = {
+        nsType:changeEnumValue(NONGSHITYPE, nongShiInfo.nsType),
+        operationTime:moment(nongShiInfo.operationTime).format("YYYY-MM-DD"),
+        code:didStr,
+        purpose
+    };
+
+    return dataInfo;
+}
+
+
+/**
+ * 修改农事
+ * @param reqUser 
+ * @param nzId 
+ * @param param 
+ * @returns 
+ */
+export async function updateNongShi(reqUser, nsId, param) {
+    let funName = `修改农事`;
+    eccFormParam(funName, NongShiAdminConfig, param );
+    eccEnumValue(funName, "nsType", NONGSHITYPE, param.nsType);
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code, purpose} = info;
+        diKuaiMap[dId] = {code, purpose};
+    });
+    if (!diKuaiMap[param.dIdList]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+    let nongShiInfo = await nongshiData.findOne({nsId});
+
+    nongShiInfo.nsType = param.nsType;//农资类型
+    nongShiInfo.dIdList = param.dIdList;//地块id
+    nongShiInfo.operationTime = param.operationTime; //操作时间
+
+    await nongShiInfo.save();
+
+    return successResult();
+}
+
+
+/**
+ * 删除农事
+ * @param nzId 
+ * @returns 
+ */
+export async function deleteNongShi(nsId) {
+    let nongShiInfo = await nongshiData.findOne({nsId});
+    if (!nongShiInfo || !nongShiInfo.nsId) throw new BizError(ERRORENUM.数据不存在);
+
+    await nongshiData.deleteData({nsId});
+
+    return successResult();
+}
+
+

src/biz/admin/nongzi.ts

+/**
+ * 农资
+ */
+
+import moment = require("moment");
+import { TABLENAME } from "../../config/dbEnum";
+import { NongZiConfig } from "../../config/eccParam";
+import { NONGZITYPE, PLANTTYPE, PURPOSE } from "../../config/enum";
+import * as nongziData from "../../data/nongzi";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
+
+
+
+/**
+ * 添加农资
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addNongZi(reqUser, param) {
+    let funName = `添加农资`;
+    eccFormParam(funName, NongZiConfig, param );
+    eccEnumValue(funName, "nzType", NONGZITYPE, param.nzType);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+    //确保添加时地块还在
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+    if (!diKuaiMap[param.dIdList]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+    let addInfo = {
+        nzId:randomId(TABLENAME.农资),
+        nzType:param.nzType,
+        dIdList:[param.dIdList],
+        plantType:param.plantType,
+        count:param.count,
+        useTime:param.useTime,
+        ct:new Date().valueOf()
+    };
+    await nongziData.addData(addInfo)
+
+    return successResult();
+}
+
+
+/**
+ * 农资列表 暂无使用
+ * @param selectStr 
+ * @param dId 
+ * @param nzType 
+ * @param useTime 
+ * @returns 
+ */
+export async function nongZiList(selectStr:string, dId:string, nzType:number, useTime:number) {
+    let funName = "农资列表";
+    let param:any = {};
+    if (nzType) {
+        eccEnumValue(funName, "nzType", NONGZITYPE, nzType);
+        param.nzType = nzType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":dId};
+    }
+    if (useTime) {
+        let startMs = moment(useTime).startOf("day").valueOf();
+        let endMs = moment(useTime).endOf("day").valueOf();
+        param.useTime = {"$gte":startMs, "$lte":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let diKuaiList = await nongziData.selectToParam( param );
+
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let {nzType, dIdList, plantType, count, useTime } = item;
+        let didStr = "";
+        dIdList.forEach(dId => {
+            didStr += `${diKuaiMap[dId] || "-"}`;
+        })
+        dataList.push({
+            nzType:changeEnumValue(NONGZITYPE, nzType),
+            dIdList:didStr,
+            plantType:changeEnumValue(PLANTTYPE, plantType),
+            count,
+            useTime:moment(useTime).format("YYYY-MM-DD")
+        });
+    });
+
+    return {dataList};
+}
+
+
+/**
+ * 修改农资
+ * @param reqUser 
+ * @param nzId 
+ * @param param 
+ * @returns 
+ */
+export async function updateNongZi(reqUser, nzId, param) {
+    let funName = `修改农资`;
+    eccFormParam(funName, NongZiConfig, param);
+    eccEnumValue(funName, "nzType", NONGZITYPE, param.nzType);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+    if (!diKuaiMap[param.dIdList]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+
+    let nongZiInfo = await nongziData.findOne({nzId});
+
+    
+    nongZiInfo.nzType = param.nzType;//农资类型
+    nongZiInfo.dIdList = param.dIdList;//地块id
+    nongZiInfo.plantType = param.plantType; //种植种类【枚举】 PLANTTYPE
+    nongZiInfo.count = param.count;//用量
+    nongZiInfo.useTime = param.useTime; //用时间
+
+    await nongZiInfo.save();
+
+    return successResult();
+}
+
+
+/**
+ * 农资回显
+ * @param nzId 
+ * @returns 
+ */
+export async function nongZiInfo(nzId) {
+    let nongZiInfo = await nongziData.findOne({nzId});
+
+    let dataInfo = {
+        nzType:nongZiInfo.nzType,//农资类型
+        // dIdList:didStr, //地块id
+        dIdList:nongZiInfo.dIdList[0],//地块id
+        plantType:nongZiInfo.plantType,//种植种类【枚举】 PLANTTYPE
+        count:nongZiInfo.count,//用量
+        useTime:nongZiInfo.useTime//时间
+    };
+
+    return {dataInfo}
+}
+
+
+/**
+ * 农资列表
+ * @param selectStr 
+ * @param dId 
+ * @param nzType 
+ * @param useTime 
+ * @returns 
+ */
+export async function nongZiListToPage(nzType:number, dId:string, useTime:number, pageNumber:number) {
+    let funName = "农资列表";
+    let param:any = {};
+    if (nzType) {
+        eccEnumValue(funName, "nzType", NONGZITYPE, nzType);
+        param.nzType = nzType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":dId};
+    }
+    if (useTime) {
+        let startMs = moment(useTime).startOf("day").valueOf();
+        let endMs = moment(useTime).endOf("day").valueOf();
+        param.useTime = {"$gte":startMs, "$lte":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let nongziList = await nongziData.findDataToParamToSortPage( param, {useTime:-1}, pageNumber );
+    let dataCount = await nongziData.findDataToParamCouant(param);
+
+    let dataList = [];
+    nongziList.forEach(item => {
+        let {nzId, nzType, dIdList, plantType, count, useTime, ct } = item;
+        let didStr = "";
+        let area = "";
+        let purpose = "";
+        let size = "";
+        dIdList.forEach(dId => {
+            didStr += `${diKuaiMap[dId] || "-"}`;
+        })
+        dataList.push({
+            nzId,
+            nzType:changeEnumValue(NONGZITYPE, nzType), //农资类型
+            dIdList:didStr, //地块id
+            plantType:changeEnumValue(PLANTTYPE, plantType), //种植种类【枚举】 PLANTTYPE
+            count, //用量
+            useTime:moment(useTime).format("YYYY-MM-DD"), //时间
+            ct:moment(ct).format("YYYY-MM-DD"), //创建时间
+            area, //所属区域
+            purpose:changeEnumValue(PURPOSE, purpose), //地块用途
+            size, //地块面积
+        });
+    });
+
+    return {dataList, dataCount}
+}
+
+
+/**
+ * 删除农资
+ * @param nzId 
+ * @returns 
+ */
+export async function deleteNongZi(nzId) {
+    let nongZiInfo = await nongziData.findOne({nzId});
+    if (!nongZiInfo || !nongZiInfo.nzId) throw new BizError(ERRORENUM.数据不存在);
+
+    await nongziData.deleteData({nzId});
+
+    return successResult();
+}
+

src/biz/admin/user.ts

+/**
+ * 用户
+ */
+
+
+import { ERRORENUM } from "../../config/errorEnum";
+import { findUserInfoByLoginId, findUserInfoByUserId } from "../../data/users";
+import * as caishouData from "../../data/caishou";
+import { getPwdMd5, getToken, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import * as diKuaiData from "../../data/dikuai";
+import * as zhongZhiData from "../../data/zhongzhi";
+import { selectChanLiangOfMonth, selectChanLiangOfzuoWu } from "../../data/caishou";
+import { changeEnumValue } from "../../util/verificationEnum";
+import { PLANTTYPE, PLOTTYPE } from "../../config/enum";
+import { selectXiaoShouOfMonth, selectXiaoShouOfzuoWu } from "../../data/xiaoshou";
+import moment = require("moment");
+
+
+/**
+ * 登录
+ * @param loginId 
+ * @param pwd 
+ * @returns 
+ */
+export async function adminUserLogin(loginId:string, pwd:string) {
+    let userInfo:any = await findUserInfoByLoginId(loginId);
+    if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
+
+    let checkPwd = getPwdMd5(loginId, pwd); 
+    if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+
+    let token = getToken(loginId);
+    
+    let resultUserInfo = {
+        loginId:userInfo.loginId,
+        name: userInfo.name,
+        userId:userInfo.userId,
+        token:token,
+    };
+
+    userInfo.adminToken = token;
+    userInfo.adminTokenMs = new Date().valueOf();
+
+    await userInfo.save();
+    
+    return {dataInfo:resultUserInfo};
+}
+
+
+
+/**
+ * 登出
+ * @param userInfo 
+ */
+export async function adminUserLogout(reqUserInfo) {
+    let userInfo = await findUserInfoByUserId(reqUserInfo.userId);
+
+    userInfo.adminToken = getToken(userInfo.loginId);
+    userInfo.adminTokenMs = new Date().valueOf();
+
+    await userInfo.save();
+
+    return successResult(); 
+}
+
+
+
+/**
+ * 统计页产量统计
+ * @param type 
+ * @returns 
+ */
+export async function homePageStatisChanLiang(type:number) {
+    //产量 时间分
+    let zuoWuMonthDBList = await caishouData.selectToParam({plantType:{"$lt":PLANTTYPE.鲈鱼}});
+    let zuoWuDistinctMap = {};
+    let zuoWuCount = 0;
+
+    let map1 = {};
+    zuoWuMonthDBList.forEach(info => {
+        let {ct, weight} = info;
+        
+        let year = moment(ct).year();
+        let month = moment(ct).month();
+        if (!map1[''+year+''+month]) map1[''+year+''+month] = {month, year, totalWeight:0}
+        map1[''+year+''+month].totalWeight += weight;
+    })
+
+    let list1 =  Object.values(map1);
+    list1.forEach(info => {
+        let {year, month, totalWeight}:any = info;
+        
+        let strKey:any = "";
+        if (type == 1) {//年
+            strKey = year;
+        } else if (type == 2) {//季度
+            let quarter = 1;
+            if (month >= 10) quarter = 4;
+            else if (month >= 7) quarter = 3;
+            else if (month >= 4) quarter = 2;
+            strKey = `${year}-${quarter}`;
+        } else {//月
+            strKey = `${year}-${month}`;
+        }
+
+        if (!zuoWuDistinctMap[strKey]) zuoWuDistinctMap[strKey] = {key:strKey, value:0};
+        zuoWuDistinctMap[strKey].value += totalWeight;
+
+        zuoWuCount += totalWeight;
+    });
+    let nongChanPin = Object.values(zuoWuDistinctMap);
+
+    for (let i = 0; i < nongChanPin.length; i++) {
+        nongChanPin[i]["value"] =  Math.ceil(nongChanPin[i]["value"] / 10)/100;
+    }
+    //农作物产量
+    let zuoWuDBList = await selectChanLiangOfzuoWu({plantType:{"$lt":PLANTTYPE.鲈鱼}});
+    let zuoWu = [];
+    zuoWuDBList.forEach(info => {
+        let {_id, totalWeight} = info;
+        zuoWu.push({
+            key:changeEnumValue(PLANTTYPE, _id),
+            value:totalWeight/1000
+        });
+    });
+    zuoWu.sort((a,b) =>{return b.value - a.value});
+
+
+    //产量 
+    let shuiChanMonthDBList = await selectChanLiangOfMonth({plantType:{"$gte":PLANTTYPE.鲈鱼}});
+    let shuiChanDistinctMap = {};
+    let shuiChanCount = 0;
+    shuiChanMonthDBList.forEach(info => {
+        let {year, month, totalWeight} = info;
+        
+        let strKey = "";
+        if (type == 1) {//年
+            strKey = year;
+        } else if (type == 2) {//季度
+            let quarter = 1;
+            if (month >= 10) quarter = 4;
+            else if (month >= 7) quarter = 3;
+            else if (month >= 4) quarter = 2;
+            strKey = `${year}-${quarter}`;
+        } else {//月
+            strKey = `${year}-${month}`;
+        }
+
+        if (!shuiChanDistinctMap[strKey]) shuiChanDistinctMap[strKey] = {key:strKey, value:0};
+        shuiChanDistinctMap[strKey].value += totalWeight;
+
+        shuiChanCount += totalWeight;
+    });
+    let shuiChanPin = Object.values(shuiChanDistinctMap);
+
+    for (let i = 0; i < nongChanPin.length; i++) {
+        nongChanPin[i]["value"] =  Math.ceil(nongChanPin[i]["value"] / 100)/100;
+    }
+    //农作物产量
+    let shuiChanDBList = await selectChanLiangOfzuoWu({plantType:{"$gte":PLANTTYPE.鲈鱼}});
+    let shuiChan = [];
+    shuiChanDBList.forEach(info => {
+        let {_id, totalWeight} = info;
+        shuiChan.push({
+            key:changeEnumValue(PLANTTYPE, _id),
+            value:totalWeight/10000
+        });
+    });
+    shuiChan.sort((a,b) =>{return b.value - a.value});
+
+    
+    let shuiChanZhognYang = [];
+    let shuiChanZhognYangCount = 0;
+    let zhognYangDBList = await zhongZhiData.zhongYangTongJiCount();
+    zhognYangDBList.forEach(info => {
+        let {_id, sizeCount} = info;
+        shuiChanZhognYang.push({
+            key:changeEnumValue(PLANTTYPE, _id),
+            value:sizeCount
+        });
+        shuiChanZhognYangCount += sizeCount;
+    });
+
+    let dataInfo = {
+        zuoWu:{
+            count:Math.ceil(zuoWuCount/10)/100,
+            nongChanPin,
+            zuoWu:zuoWu,
+        },
+        shuiChan:{
+            count:Math.ceil(shuiChanCount/100)/100,
+            shuiChanPin,
+            shuiChan,
+        },
+        shuiChanZhognYang:{
+            shuiChanZhognYangList:shuiChanZhognYang,
+            count:shuiChanZhognYangCount,
+        }
+       
+    };
+
+    return {dataInfo};
+}
+
+
+
+
+

src/biz/admin/xiaoShou.ts

+/**
+ * 销售
+ */
+import { TABLENAME } from "../../config/dbEnum";
+import { XiaoShouConfig } from "../../config/eccParam";
+import { PLANTTYPE, XIAOSHOUQUXIANG } from "../../config/enum";
+import * as xiaoshouData from "../../data/xiaoshou";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import moment = require("moment");
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
+
+/**
+ * 添加销售
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addXiaoShou(reqUser, param) {
+    let funName = `添加销售`;
+    eccFormParam(funName, XiaoShouConfig, param );
+    eccEnumValue(funName, "quXiang", XIAOSHOUQUXIANG, param.quXiang);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+    
+    let addInfo = {
+        xsId:randomId(TABLENAME.销售),
+        quXiang:param.quXiang,
+        plantType:param.plantType,
+        operationTime:param.operationTime,
+        weight:param.weight,
+        ct:new Date().valueOf(),
+        createUser:reqUser.userId
+    };
+
+    await xiaoshouData.addData(addInfo)
+
+    return successResult();
+}
+
+
+/**
+ * 销售列表
+ * @param quXiang 销售去向
+ * @param plantType 
+ * @param operationTime 
+ * @returns 
+ */
+export async function xiaoShouList(quXiang:number, plantType:number, operationTime:number, pageNumber:number) {
+    let funName = "销售列表";
+    let param:any = {};
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (quXiang) {
+        eccEnumValue(funName, "quXiang", XIAOSHOUQUXIANG, quXiang);
+        param.quXiang = quXiang;
+    }
+    if (operationTime) {
+        let startMs = moment(operationTime).startOf("day").valueOf();
+        let endMs = moment(operationTime).endOf("day").valueOf();
+        param.operationTime = {"$gte":startMs, "$lte":endMs};
+    }
+
+    let nongShiList = await xiaoshouData.findDataToParamToSortPage(param, {operationTime:-1}, pageNumber);
+    let dataCount = await xiaoshouData.selectCountByParam(param);
+
+    let dataList = [];
+    nongShiList.forEach(item => {
+        let {xsId, plantType, quXiang, operationTime, weight } = item;
+        
+        dataList.push({
+            xsId,
+            plantType:changeEnumValue(PLANTTYPE, plantType),
+            quXiang:changeEnumValue(XIAOSHOUQUXIANG, quXiang),
+            operationTime:moment(operationTime).format("YYYY-MM-DD"),
+            weight,
+            operationTimeNum:operationTime
+        });
+    });
+
+    dataList.sort( (a, b) => {
+        return b.operationTimeNum - a.operationTimeNum;
+    })
+
+    return {dataList, dataCount}
+}
+
+
+/**
+ * 修改销售
+ * @param reqUser 
+ * @param nzId 
+ * @param param 
+ * @returns 
+ */
+ export async function updateXiaoShou(reqUser, xsId, param) {
+    let funName = `修改销售`;
+    eccFormParam(funName, XiaoShouConfig, param );
+    eccEnumValue(funName, "quXiang", XIAOSHOUQUXIANG, param.quXiang);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+
+    let xiaoShouInfo = await xiaoshouData.selectOne({xsId});
+    
+    xiaoShouInfo.plantType = param.plantType;//销售种类【枚举】 PLANTTYPE
+    xiaoShouInfo.quXiang = param.quXiang;//销售去向
+    xiaoShouInfo.operationTime = param.operationTime;//销售时间
+    xiaoShouInfo.weight = param.weight;//销售重量
+
+    await xiaoShouInfo.save();
+
+    return successResult();
+}
+
+
+/**
+ * 销售回显
+ * @param nzId 
+ * @returns 
+ */
+export async function xiaoShouInfo(xsId) {
+    let xiaoShouInfo = await xiaoshouData.selectOne({xsId});
+
+    let dataInfo = {
+        plantType:changeEnumValue(PLANTTYPE, xiaoShouInfo.plantType),//种植种类【枚举】 PLANTTYPE
+        quXiang:changeEnumValue(XIAOSHOUQUXIANG, xiaoShouInfo.quXiang),//销售去向
+        operationTime:moment(xiaoShouInfo.operationTime).format("YYYY-MM-DD"),//销售时间
+        weight:xiaoShouInfo.weight//销售重量
+    };
+
+    return dataInfo;
+}
+
+
+/**
+ * 删除销售
+ * @param nzId 
+ * @returns 
+ */
+export async function deleteXiaoShou(xsId) {
+    let xiaoShouInfo = await xiaoshouData.selectOne({xsId});
+    if (!xiaoShouInfo || !xiaoShouInfo.xsId) throw new BizError(ERRORENUM.数据不存在);
+
+    await xiaoshouData.deleteData({xsId});
+
+    return successResult();
+}
+
+
+
+
+
+
+
+

src/biz/admin/zhongYang.ts

+/**
+ * 种养
+ */
+
+import moment = require("moment");
+import { TABLENAME } from "../../config/dbEnum";
+import { DiKuaiConfig, ZhongYangConfig } from "../../config/eccParam";
+import { PLANTTYPE, PLOTTYPE, PURPOSE, ZHONGYANGTYPE } from "../../config/enum";
+import * as zhongzhiData from "../../data/zhongzhi";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
+
+/**
+ * 种养列表-暂无使用
+ * @param plantType 种养类型
+ * @param selectStr 
+ * @returns 
+ */
+export async function zhongYangDangQianList(zhongYangType:number, selectStr:string) {
+    let funName = `当前种养列表`;
+    eccEnumValue(funName, 'zhongYangType', ZHONGYANGTYPE, zhongYangType);
+
+    let param = {
+        plantType:{"$gte":zhongYangType, "$lt":zhongYangType+99},
+        isEnd:0
+    };
+    let zyList = await zhongzhiData.selectToParam( param );
+    
+    let typeMap = {};
+    zyList.forEach(info => {
+        let {plantType} = info;
+        typeMap[plantType] = {value:plantType, key:changeEnumValue(PLANTTYPE, plantType)};
+    });
+    let dataList = Object.values(typeMap);
+
+    return {dataList};
+}
+
+
+/**
+ * 种养列表-分页
+ * @param zhongYangType 种养类型
+ * @param dId 使用地块
+ * @param plantTime 种养时间
+ * @param pageNumber 
+ * @returns 
+ */
+export async function zhongYangDangQianListToPage(zhongYangType:number, plantType:number, dId:number, plantTime:number, pageNumber:number) {
+    let funName = `当前种养列表`;
+    let param:any = { plantType:{"$gte":zhongYangType, "$lt":zhongYangType+99} };
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (dId) {
+        param.dId = dId;
+    }
+    if (plantTime) {
+        let selectStartTime = moment(plantTime).startOf('day').valueOf();
+        let selectEndTime = moment(plantTime).endOf("day").valueOf();
+        // let selectStartTime = moment(plantTime).valueOf();
+        // let selectEndTime = moment(plantTime).valueOf();
+        param.plantTime = {"$gte":selectStartTime, "$lte":selectEndTime};
+    }
+    
+    /**获取地块名称 */
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code, purpose} = info;
+        diKuaiMap[dId] = {code, purpose};
+    });
+
+    let zyList = await zhongzhiData.findDataToParamToSortPage( param, {plantTime:-1}, pageNumber );
+    let dataCount = await zhongzhiData.findDataToParamCouant(param);
+    let dataList = [];
+    zyList.forEach(info => {
+        let addInfo = {
+            zId : info.zId,
+            size : info.size,
+            plantType : changeEnumValue(PLANTTYPE, info.plantType),
+            code:diKuaiMap[info.dId].code,
+            plantTime:moment(info.plantTime).format("YYYY-MM-DD"),
+            purpose:changeEnumValue(PURPOSE, diKuaiMap[info.dId].purpose),
+            plantTimeNum:info.plantTime,
+            ctTime:moment(info.ct).format("YYYY-MM-DD"),
+        };
+        dataList.push(addInfo);
+    });
+
+    dataList.sort( (a, b) => {
+        return b.plantTimeNum - a.plantTimeNum;
+    })
+
+    return {dataList, dataCount};
+}
+
+
+/**
+ * 删除种养
+ * @param zId 
+ * @returns 
+ */
+export async function deleteZhongYang(zId) {
+    let zhongYangInfo = await zhongzhiData.selectOne({zId});
+    if (!zhongYangInfo || !zhongYangInfo.zId) throw new BizError(ERRORENUM.数据不存在);
+
+    await zhongzhiData.deleteData({zId});
+
+    return successResult();
+}
+
+
+/**
+ * 添加种养
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addZhongYang(reqUser, param) {
+    let funName = `添加种养`;
+    eccFormParam(funName, ZhongYangConfig, param);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+
+    //校验地块大小是否符合扣除
+    let dkInfo = await dikuaiData.selectOne({dId:param.dId});
+    if (!dkInfo || !dkInfo.dId) throw new BizError(ERRORENUM.地块不存在);
+    if (dkInfo.size < param.size) throw new BizError(ERRORENUM.地块大小不足);
+
+    let addInfo = {
+        zId:randomId(TABLENAME.种植表),
+        size:param.size,//种植大小
+        plantType:param.plantType,//
+        dId:param.dId,//地块id
+        plantTime:param.plantTime,//种植时间
+        uId:reqUser.userId,
+        isEnd:0,
+        ct:new Date().valueOf()
+    };
+
+    await zhongzhiData.addData(addInfo);
+
+    dkInfo.nullSize = dkInfo.size - param.size;
+    dkInfo.useSize = dkInfo.useSize + param.size;
+    await dkInfo.save();
+
+    return successResult();
+}
+
+
+/**
+ * 修改种养
+ * @param reqUser 
+ * @param zId 
+ * @param param 
+ * @returns 
+ */
+export async function updateZhongYang(reqUser, zId, param) {
+    let funName = `修改种养`;
+    eccFormParam(funName, ZhongYangConfig, param);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+
+    let dkInfo = await dikuaiData.selectOne({dId:param.dId});
+    if (!dkInfo || !dkInfo.dId) throw new BizError(ERRORENUM.地块不存在);
+    if (dkInfo.size < param.size) throw new BizError(ERRORENUM.地块大小不足);
+
+    let zhongYangInfo = await zhongzhiData.selectOne({zId});
+
+    zhongYangInfo.plantType = param.plantType;
+    zhongYangInfo.dId = param.dId;
+    zhongYangInfo.size = param.size;
+    zhongYangInfo.plantTime = param.plantTime;
+
+    await zhongYangInfo.save();
+
+    return successResult();
+}
+
+
+/**
+ * 种养回显
+ * @param zId 
+ * @returns 
+ */
+export async function zhognYangInfo(zId) {
+
+    let dikuaiInfo = await zhongzhiData.selectOne({zId});
+    let dataInfo = {
+        plantType:dikuaiInfo.plantType,//编号
+        dId:dikuaiInfo.dId,//地块id
+        size:dikuaiInfo.size,//地块大小
+        plantTime:dikuaiInfo.plantTime,//种植时间
+    };
+
+    return {dataInfo}
+}
+
+
+/**
+ * 种养记录-暂无使用
+ * @param zhongYangType 
+ * @param selectStr 
+ * @param plantType 
+ * @param plantTime 
+ * @param dId 
+ * @returns 
+ */
+export async function zhongYangJiLu(zhongYangType:number, selectStr:string, plantType:number, plantTime:number, dId:string) {
+    let funName = `种养记录`;
+ 
+    let param:any = { plantType:{"$gte":zhongYangType, "$lt":zhongYangType+99} };
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (dId) {
+        param.dId = dId;
+    }
+    if (plantTime) {
+        let selectStartTime = moment(plantTime).startOf('day').valueOf();
+        let selectEndTime = moment(plantTime).endOf("day").valueOf();
+        param.plantTime = {"$gte":selectStartTime, "$lte":selectEndTime};
+    }
+    
+    /**获取地块名称 */
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let dbList = await zhongzhiData.selectToParam(param);
+    let dataList = [];
+    dbList.forEach(info => {
+        dataList.push({
+            plantType:changeEnumValue(PLANTTYPE, info.plantType),
+            size:info.size,
+            code:diKuaiMap[info.dId],
+            plantTime:moment(info.plantTime).format("YYYY-MM-DD")
+        })
+    });
+
+    return {dataList};
+}
+
+

src/biz/caiShou.ts → src/biz/xcx/caiShou.ts

 /**
- * 采收逻辑
+ * 小程序-采收逻辑
  */
-import { TABLENAME } from "../config/dbEnum";
-import { CaiShouConfig } from "../config/eccParam";
-import { PLANTTYPE, ZHONGYANGTYPE } from "../config/enum";
-import * as caishouData from "../data/caishou";
-import * as dikuaiData from "../data/dikuai";
-import * as zhongzhiData from "../data/zhongzhi";
-import { randomId, successResult } from "../tools/system";
-import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
-import { eccFormParam } from "../util/verificationParam";
+import { TABLENAME } from "../../config/dbEnum";
+import { CaiShouConfig } from "../../config/eccParam";
+import { PLANTTYPE, ZHONGYANGTYPE } from "../../config/enum";
+import * as caishouData from "../../data/caishou";
+import * as dikuaiData from "../../data/dikuai";
+import * as zhongzhiData from "../../data/zhongzhi";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
 import moment = require("moment");
 
 
@@ -47,7 +47,7 @@ export async function addCaiShou(reqUser, param) {
     //添加采收记录
     let addInfo = {
         csId,
-        dIdList:param.dIdList,
+        dIdList:param.dId,
         plantType:param.plantType,
         operationTime:param.operationTime,
         weight:param.weight,
@@ -83,9 +83,9 @@ export async function caiShouList(zhongYangType:number, selectStr:string, dId:st
         param.dIdList = {"$in":dId};
     }
     if (operationTime) {
-        let startMs = moment(operationTime).startOf("month").valueOf();
-        let endMs = moment(operationTime).endOf("month").valueOf();
-        param.useTime = {"$gt":startMs, "$lt":endMs};
+        let startMs = moment(operationTime).startOf("day").valueOf();
+        let endMs = moment(operationTime).endOf("day").valueOf();
+        param.useTime = {"$gte":startMs, "$lte":endMs};
     }
 
     let dikuaiList = await dikuaiData.selectToParam({});
@@ -98,19 +98,28 @@ export async function caiShouList(zhongYangType:number, selectStr:string, dId:st
     let nongShiList = await caishouData.selectToParam(param);
     let dataList = [];
     nongShiList.forEach(item => {
-        let {plantType, dIdList, operationTime, weight } = item;
+        let {plantType, dIdList, operationTime, weight, ct } = item;
         let dIds = dIdList;
         let didStr = "";
         dIds.forEach(dId => {
             didStr += `${diKuaiMap[dId]} `;
         });
+        let operationTimeNum;
+        if (operationTime) operationTimeNum = operationTime;
+        else operationTimeNum = ct
         dataList.push({
             plantType:changeEnumValue(PLANTTYPE, plantType),
             dIdList:didStr,
-            operationTime:moment(operationTime).format("YYYY-MM-DD"),
-            weight
+            operationTime:moment(operationTimeNum).format("YYYY-MM-DD"),
+            weight,
+            operationTimeNum
         });
     });
 
+    dataList.sort( (a, b) => {
+        return b.operationTimeNum - a.operationTimeNum;
+    })
+
     return {dataList}
 }
+

src/biz/xcx/diKuai.ts

+/**
+ * 地块
+ */
+
+import moment = require("moment");
+import { TABLENAME } from "../../config/dbEnum";
+import { DiKuaiConfig, YangZhiChiConfig } from "../../config/eccParam";
+import { AREARANGE, PLANTTYPE, PLOTTYPE, PURPOSE, ZHONGYANGTYPE } from "../../config/enum";
+import { ERRORENUM } from "../../config/errorEnum";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+
+
+/**
+ * 添加地块
+ * @param reqUser 
+ * @param plotType 
+ * @param param 
+ * @returns 
+ */
+export async function addDiKuai(reqUser, plotType, param) {
+    let funName = `添加地块`;
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+
+    let purpose = PURPOSE.养殖;
+    if (plotType == PLOTTYPE.地块) {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), DiKuaiConfig, param);
+        eccEnumValue(funName, "param=>type", PURPOSE, param.type);
+        purpose = param.type;
+    } else {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), YangZhiChiConfig, param);
+    }
+
+    let addInfo = {
+        dId:randomId(TABLENAME.地块表),
+        size:param.size,
+        useSize:0,//使用大小默认0
+        nullSize:param.size,//初始可使用大小为大小
+        code:param.code,
+        name:param.code, //地块名称
+        plotType,
+        purpose,//用途 【枚举】 PURPOSE
+        createUser:reqUser.userId,
+        ct:new Date().valueOf()
+    };
+    await dikuaiData.addData(addInfo);
+
+    return successResult();
+}
+
+/**
+ * 地块信息
+ * @param plotType 
+ * @param selectStr 
+ * @param code 
+ * @param purpose 
+ * @param area 
+ * @returns 
+ */
+export async function diKuaiInfo(dId:String ) {
+    let dikuaiInfo = await dikuaiData.selectOne({dId});
+    let dataInfo = {
+        size:dikuaiInfo.size, 
+        dId:dikuaiInfo.dId, 
+        type:dikuaiInfo.purpose,
+        purpose:changeEnumValue(PURPOSE, dikuaiInfo.purpose),
+        code:dikuaiInfo.code
+    };
+
+    return {dataInfo}
+}
+
+
+/**
+ * 地块列表
+ * @param plotType 
+ * @param selectStr 
+ * @param code 
+ * @param purpose 
+ * @param area 
+ * @returns 
+ */
+export async function diKuaiList(plotType:number, selectStr:string, code:string, purpose:number, area:number ) {
+    let funName = "地块列表";
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+   
+    let param:any = {plotType};
+    if (code) {
+        param.code = { "$regex":code };
+    }
+    if (purpose) {
+        eccEnumValue(funName, "purpose", PURPOSE, purpose);
+        param.purpose = purpose;
+    }
+    if (area) {
+        eccEnumValue(funName, "area", AREARANGE, area);
+        param.size = {"$lte": parseInt(AREARANGE[area].replace("<=", "")) };
+    }
+
+    let diKuaiList = await dikuaiData.selectToParam(param);
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let { size, dId, purpose, code } = item;
+        dataList.push({size,dId,type:changeEnumValue(PURPOSE, purpose),code});
+    });
+
+    return {dataList}
+}
+
+
+/**
+ * 地块列表分页-暂无使用
+ * @param code 地块编号 string
+ * @param area 地块区域 string
+ * @param purpose 地块用途 number
+ * @param pageNumber 页码
+ * @returns 
+ */
+export async function diKuaiListToPage(code, area, purpose, pageNumber) {
+    let funName = "地块列表";
+    let param:any = {};
+    if (code) {
+        param.code = { "$regex":code };
+    }
+    if (area) {
+        param.area = { "$regex":area };
+    }
+    if (purpose) {
+        eccEnumValue(funName, "purpose", PURPOSE, purpose);
+        param.purpose = purpose;
+    }
+
+    let diKuaiList = await dikuaiData.findDataToParamToSortPage(param, {ct:-1}, pageNumber);
+    let dataCount = await dikuaiData.findDataToParamCouant({});
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let { size, dId, plotType, purpose, code, area, ct } = item;
+        dataList.push({
+            size,
+            dId,
+            plotType:changeEnumValue(PLOTTYPE, plotType),
+            type:changeEnumValue(PURPOSE, purpose),
+            code,
+            area,
+            ct:moment(ct).format("YYYY-MM-DD")
+        });
+    });
+
+    return {dataList, dataCount}
+}
+
+
+
+/**
+ * 修改地块信息
+ * @param reqUser 
+ * @param plotType 
+ * @param dId 
+ * @param param 
+ * @returns 
+ */
+export async function updateDiKuai(reqUser, plotType, dId, param) {
+    let funName = `修改地块`;
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+
+    let purpose = PURPOSE.养殖;
+    if (plotType == PLOTTYPE.地块) {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), DiKuaiConfig, param);
+        eccEnumValue(funName, "param=>type", PURPOSE, param.type);
+        purpose = param.type;
+    } else {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), YangZhiChiConfig, param);
+    }
+
+    let dInfo = await dikuaiData.selectOne({dId});
+    if (!dInfo || !dInfo.dId) throw new BizError(ERRORENUM.地块不存在);
+
+    dInfo.code = param.code,
+    dInfo.size = param.size,
+    dInfo.purpose = purpose;
+
+    await dInfo.save();
+
+    return successResult();
+}
+
+
+
+/**
+ * 当前可种植地块
+ * @returns 
+ */
+export async function keXuanDiKuaiList(zhongYangType:number) {
+    let param:any = {};
+    if (zhongYangType) {
+        let purpose = 1;
+        if (zhongYangType == ZHONGYANGTYPE.水产) purpose = PURPOSE.养殖;
+        else if (zhongYangType == ZHONGYANGTYPE.花卉 ||zhongYangType == ZHONGYANGTYPE.蔬菜 ) purpose = PURPOSE.菜田;
+        else if (zhongYangType == ZHONGYANGTYPE.粮食) purpose = PURPOSE.粮田;
+        // param.nullSize = {"$gt":0};
+        param.purpose = purpose;
+    }
+
+    console.log("------>", JSON.stringify(param));
+   
+    let dbList = await dikuaiData.selectToParam(param);
+
+    let dataList = [];
+
+    dbList.forEach(info => {
+        let {code, purpose, dId, size} = info;
+        dataList.push( {code, purpose:changeEnumValue(PURPOSE, purpose), dId, size});
+    });
+
+    return {dataList};
+}
+
+
+/**
+ * 当前采收地块列表
+ * @returns 
+ */
+export async function keCaiShouList(zhongYangType:number) {
+    let purpose = 1;
+    if (zhongYangType == ZHONGYANGTYPE.水产) purpose = PURPOSE.养殖;
+    else if (zhongYangType == ZHONGYANGTYPE.花卉 ||zhongYangType == ZHONGYANGTYPE.蔬菜 ) purpose = PURPOSE.菜田;
+    else if (zhongYangType == ZHONGYANGTYPE.粮食) purpose = PURPOSE.粮田;
+    let param = {useSize:{"$gt":0}, purpose:purpose};
+
+    let dbList = await dikuaiData.selectToParam(param);
+
+    let dataList = [];
+
+    dbList.forEach(info => {
+        let {code, purpose, dId, size} = info;
+        dataList.push( {code, purpose:changeEnumValue(PURPOSE, purpose), dId, size});
+    });
+
+    return {dataList}
+}
+
+/**
+ * 全部地块列表
+ * @param plotType 
+ * @param selectStr 
+ * @param code 
+ * @param purpose 
+ * @param area 
+ * @returns 
+ */
+export async function allDiKuaiList(plotType:number ) {
+    let funName = "地块列表";
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+   
+    let param:any = {plotType};
+
+    let diKuaiList = await dikuaiData.selectToParam(param);
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let { size, dId, purpose, code } = item;
+        dataList.push({dId, code});
+    });
+
+    return {dataList}
+}
+

src/biz/nongShi.ts → src/biz/xcx/nongShi.ts

-import { TABLENAME } from "../config/dbEnum";
-import { CaiShouConfig, NongShiConfig } from "../config/eccParam";
-import { NONGSHITYPE, PLANTTYPE } from "../config/enum";
-import * as nongshiData from "../data/nongshi";
-import * as dikuaiData from "../data/dikuai";
-import { getMySqlMs, randomId, successResult } from "../tools/system";
-import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
-import { eccFormParam } from "../util/verificationParam";
+import { TABLENAME } from "../../config/dbEnum";
+import { CaiShouConfig, NongShiConfig } from "../../config/eccParam";
+import { NONGSHITYPE, PLANTTYPE } from "../../config/enum";
+import * as nongshiData from "../../data/nongshi";
+import * as dikuaiData from "../../data/dikuai";
+import { getMySqlMs, randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
 import moment = require("moment");
-import { BizError } from "../util/bizError";
-import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
 
 /**
  * 添加农事
@@ -60,9 +60,9 @@ export async function nongShiList(selectStr:string, dId:string, nsType:number, o
         param.dIdList = {"$in":dId};
     }
     if (operationTime) {
-        let startMs = moment(operationTime).startOf("month").valueOf();
-        let endMs = moment(operationTime).endOf("month").valueOf();
-        param.operationTime = {"$gt":startMs, "$lt":endMs};
+        let startMs = moment(operationTime).startOf("day").valueOf();
+        let endMs = moment(operationTime).endOf("day").valueOf();
+        param.operationTime = {"$gte":startMs, "$lte":endMs};
     }
 
     let dikuaiList = await dikuaiData.selectToParam({});
@@ -83,9 +83,14 @@ export async function nongShiList(selectStr:string, dId:string, nsType:number, o
         dataList.push({
             nsType:changeEnumValue(NONGSHITYPE, nsType),
             dIdList:didStr,
-            operationTime:moment(operationTime).format("YYYY-MM-DD")
+            operationTime:moment(operationTime).format("YYYY-MM-DD"),
+            operationTimeNum:operationTime
         });
     });
 
+    dataList.sort( (a, b) => {
+        return b.operationTimeNum - a.operationTimeNum;
+    })
+
     return {dataList}
 }
\ No newline at end of file

src/biz/nongzi.ts → src/biz/xcx/nongzi.ts

@@ -3,19 +3,16 @@
  */
 
 import moment = require("moment");
-import { TABLENAME } from "../config/dbEnum";
-import { NongZiConfig } from "../config/eccParam";
-import { NONGZITYPE, PLANTTYPE, PURPOSE } from "../config/enum";
-import * as nongziData from "../data/nongzi";
-import * as dikuaiData from "../data/dikuai";
-import { randomId, successResult } from "../tools/system";
-import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
-import { eccFormParam } from "../util/verificationParam";
-import { BizError } from "../util/bizError";
-import { ERRORENUM } from "../config/errorEnum";
-
-
-
+import { TABLENAME } from "../../config/dbEnum";
+import { NongZiConfig } from "../../config/eccParam";
+import { NONGZITYPE, PLANTTYPE, PURPOSE } from "../../config/enum";
+import * as nongziData from "../../data/nongzi";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
 
 
 /**
@@ -72,9 +69,9 @@ export async function nongZiList(selectStr:string, dId:string, nzType:number, us
         param.dIdList = {"$in":dId};
     }
     if (useTime) {
-        let startMs = moment(useTime).startOf("month").valueOf();
-        let endMs = moment(useTime).endOf("month").valueOf();
-        param.useTime = {"$gt":startMs, "$lt":endMs};
+        let startMs = moment(useTime).startOf("day").valueOf();
+        let endMs = moment(useTime).endOf("day").valueOf();
+        param.useTime = {"$gte":startMs, "$lte":endMs};
     }
 
     let dikuaiList = await dikuaiData.selectToParam({});
@@ -98,16 +95,21 @@ export async function nongZiList(selectStr:string, dId:string, nzType:number, us
             dIdList:didStr,
             plantType:changeEnumValue(PLANTTYPE, plantType),
             count,
-            useTime:moment(useTime).format("YYYY-MM-DD")
+            useTime:moment(useTime).format("YYYY-MM-DD"),
+            useTimeNum:useTime
         });
     });
 
+    dataList.sort( (a, b) => {
+        return b.useTimeNum - a.useTimeNum;
+    })
+
     return {dataList};
 }
 
 
 /**
- * 修改农资
+ * 修改农资 暂无使用
  * @param reqUser 
  * @param nzId 
  * @param param 
@@ -144,7 +146,7 @@ export async function updateNongZi(reqUser, nzId, param) {
 
 
 /**
- * 农资回显
+ * 农资回显 暂无使用
  * @param nzId 
  * @returns 
  */
@@ -165,14 +167,14 @@ export async function nongZiInfo(nzId) {
 
 
 /**
- * 农资列表
+ * 农资列表 暂无使用
  * @param selectStr 
  * @param dId 
  * @param nzType 
  * @param useTime 
  * @returns 
  */
- export async function nongZiListToPage(nzType:number, dId:string, useTime:number, pageNumber:number) {
+export async function nongZiListToPage(nzType:number, dId:string, useTime:number, pageNumber:number) {
     let funName = "农资列表";
     let param:any = {};
     if (nzType) {
@@ -183,9 +185,9 @@ export async function nongZiInfo(nzId) {
         param.dIdList = {"$in":dId};
     }
     if (useTime) {
-        let startMs = moment(useTime).startOf("month").valueOf();
-        let endMs = moment(useTime).endOf("month").valueOf();
-        param.useTime = {"$gt":startMs, "$lt":endMs};
+        let startMs = moment(useTime).startOf("day").valueOf();
+        let endMs = moment(useTime).endOf("day").valueOf();
+        param.useTime = {"$gte":startMs, "$lte":endMs};
     }
 
     let dikuaiList = await dikuaiData.selectToParam({});
@@ -195,7 +197,7 @@ export async function nongZiInfo(nzId) {
         diKuaiMap[dId] = code;
     });
 
-    let nongziList = await nongziData.findDataToParamToPage( param, pageNumber );
+    let nongziList = await nongziData.findDataToParamToSortPage( param, {useTime:-1}, pageNumber );
     let dataCount = await nongziData.findDataToParamCouant({});
 
     let dataList = [];

src/biz/user.ts → src/biz/xcx/user.ts

@@ -3,17 +3,17 @@
  */
 
 
-import { ERRORENUM } from "../config/errorEnum";
-import { findUserInfoByLoginId, findUserInfoByUserId } from "../data/users";
-import * as caishouData from "../data/caishou";
-import { getPwdMd5, getToken, successResult } from "../tools/system";
-import { BizError } from "../util/bizError";
-import * as diKuaiData from "../data/dikuai";
-import * as zhongZhiData from "../data/zhongzhi";
-import { selectChanLiangOfMonth, selectChanLiangOfzuoWu } from "../data/caishou";
-import { changeEnumValue } from "../util/verificationEnum";
-import { PLANTTYPE, PLOTTYPE } from "../config/enum";
-import { selectXiaoShouOfMonth, selectXiaoShouOfzuoWu } from "../data/xiaoshou";
+import { ERRORENUM } from "../../config/errorEnum";
+import { findUserInfoByLoginId, findUserInfoByUserId } from "../../data/users";
+import * as caishouData from "../../data/caishou";
+import { getPwdMd5, getToken, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import * as diKuaiData from "../../data/dikuai";
+import * as zhongZhiData from "../../data/zhongzhi";
+import { selectChanLiangOfMonth, selectChanLiangOfzuoWu } from "../../data/caishou";
+import { changeEnumValue } from "../../util/verificationEnum";
+import { PLANTTYPE, PLOTTYPE } from "../../config/enum";
+import { selectXiaoShouOfMonth, selectXiaoShouOfzuoWu } from "../../data/xiaoshou";
 import moment = require("moment");
 
 
@@ -23,54 +23,6 @@ import moment = require("moment");
  * @param pwd 
  * @returns 
  */
-export async function userAdminLogin(loginId:string, pwd:string) {
-    let userInfo:any = await findUserInfoByLoginId(loginId);
-    if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
-
-    let checkPwd = getPwdMd5(loginId, pwd); 
-    if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
-
-    let token = getToken(loginId);
-    
-    let resultUserInfo = {
-        loginId:userInfo.loginId,
-        name: userInfo.name,
-        userId:userInfo.userId,
-        token:token,
-    };
-
-    userInfo.adminToken = token;
-    userInfo.adminTokenMs = new Date().valueOf();
-
-    await userInfo.save();
-    
-    return {dataInfo:resultUserInfo};
-}
-
-
-
-/**
- * 登出
- * @param userInfo 
- */
-export async function userAdminLogout(reqUserInfo) {
-    let userInfo = await findUserInfoByUserId(reqUserInfo.userId);
-
-    userInfo.token = getToken(userInfo.loginId);
-    userInfo.tokenMs = new Date().valueOf();
-
-    await userInfo.save();
-
-    return successResult(); 
-}
-
-
-/**
- * 登录
- * @param loginId 
- * @param pwd 
- * @returns 
- */
 export async function userLogin(loginId:string, pwd:string) {
     let userInfo:any = await findUserInfoByLoginId(loginId);
     if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
@@ -281,9 +233,10 @@ export async function homePageStatisChanLiang(type:number) {
     });
     let shuiChanPin = Object.values(shuiChanDistinctMap);
 
-    for (let i = 0; i < nongChanPin.length; i++) {
-        nongChanPin[i]["value"] =  Math.ceil(nongChanPin[i]["value"] / 100)/100;
-    }
+    /**重复换算了 */
+    // for (let i = 0; i < nongChanPin.length; i++) {
+    //     nongChanPin[i]["value"] =  Math.ceil(nongChanPin[i]["value"] / 100)/100;
+    // }
     //农作物产量
     let shuiChanDBList = await selectChanLiangOfzuoWu({plantType:{"$gte":PLANTTYPE.鲈鱼}});
     let shuiChan = [];
@@ -427,49 +380,4 @@ export async function homePageStatisXiaoShou() {
 }
 
 
-/**
- * 登录
- * @param loginId 
- * @param pwd 
- * @returns 
- */
-export async function adminUserLogin(loginId:string, pwd:string) {
-    let userInfo:any = await findUserInfoByLoginId(loginId);
-    if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
-
-    let checkPwd = getPwdMd5(loginId, pwd); 
-    if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
-
-    let token = getToken(loginId);
-    
-    let resultUserInfo = {
-        loginId:userInfo.loginId,
-        name: userInfo.name,
-        userId:userInfo.userId,
-        token:token,
-    };
-
-    userInfo.adminToken = token;
-    userInfo.adminTokenMs = new Date().valueOf();
-
-    await userInfo.save();
-    
-    return {dataInfo:resultUserInfo};
-}
-
-
 
-/**
- * 登出
- * @param userInfo 
- */
-export async function adminUserLogout(reqUserInfo) {
-    let userInfo = await findUserInfoByUserId(reqUserInfo.userId);
-
-    userInfo.adminToken = getToken(userInfo.loginId);
-    userInfo.adminTokenMs = new Date().valueOf();
-
-    await userInfo.save();
-
-    return successResult(); 
-}
\ No newline at end of file

src/biz/xiaoShou.ts → src/biz/xcx/xiaoShou.ts

 /**
  * 销售
  */
-import { TABLENAME } from "../config/dbEnum";
-import { XiaoShouConfig } from "../config/eccParam";
-import { PLANTTYPE, XIAOSHOUQUXIANG } from "../config/enum";
-import * as xiaoshouData from "../data/xiaoshou";
-import { randomId, successResult } from "../tools/system";
-import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
-import { eccFormParam } from "../util/verificationParam";
+import { TABLENAME } from "../../config/dbEnum";
+import { XiaoShouConfig } from "../../config/eccParam";
+import { PLANTTYPE, XIAOSHOUQUXIANG } from "../../config/enum";
+import * as xiaoshouData from "../../data/xiaoshou";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
 import moment = require("moment");
 
 /**
@@ -58,9 +58,9 @@ export async function xiaoShouList(selectStr:string, quXiang:string, plantType:n
         param.quXiang = quXiang;
     }
     if (operationTime) {
-        let startMs = moment(operationTime).startOf("month").valueOf();
-        let endMs = moment(operationTime).endOf("month").valueOf();
-        param.useTime = {"$gt":startMs, "$lt":endMs};
+        let startMs = moment(operationTime).startOf("day").valueOf();
+        let endMs = moment(operationTime).endOf("day").valueOf();
+        param.useTime = {"$gte":startMs, "$lte":endMs};
     }
 
     let nongShiList = await xiaoshouData.selectToParam(param);
@@ -72,9 +72,14 @@ export async function xiaoShouList(selectStr:string, quXiang:string, plantType:n
             plantType:changeEnumValue(PLANTTYPE, plantType),
             quXiang:changeEnumValue(XIAOSHOUQUXIANG, quXiang),
             operationTime:moment(operationTime).format("YYYY-MM-DD"),
-            weight
+            weight,
+            operationTimeNum:operationTime
         });
     });
 
+    dataList.sort( (a, b) => {
+        return b.operationTimeNum - a.operationTimeNum;
+    })
+
     return {dataList}
 }
\ No newline at end of file

src/biz/zhongYang.ts → src/biz/xcx/zhongYang.ts

@@ -3,16 +3,16 @@
  */
 
 import moment = require("moment");
-import { TABLENAME } from "../config/dbEnum";
-import { DiKuaiConfig, ZhongYangConfig } from "../config/eccParam";
-import { PLANTTYPE, PLOTTYPE, ZHONGYANGTYPE } from "../config/enum";
-import * as zhongzhiData from "../data/zhongzhi";
-import * as dikuaiData from "../data/dikuai";
-import { randomId, successResult } from "../tools/system";
-import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
-import { eccFormParam } from "../util/verificationParam";
-import { BizError } from "../util/bizError";
-import { ERRORENUM } from "../config/errorEnum";
+import { TABLENAME } from "../../config/dbEnum";
+import { DiKuaiConfig, ZhongYangConfig } from "../../config/eccParam";
+import { PLANTTYPE, PLOTTYPE, ZHONGYANGTYPE } from "../../config/enum";
+import * as zhongzhiData from "../../data/zhongzhi";
+import * as dikuaiData from "../../data/dikuai";
+import { randomId, successResult } from "../../tools/system";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
 
 /**
  * 种养列表
@@ -41,6 +41,13 @@ export async function zhongYangDangQianList(zhongYangType:number, selectStr:stri
 }
 
 
+/**
+ * 种养列表-分页 暂无使用
+ * @param zhongYangType 
+ * @param selectStr 
+ * @param pageNumber 
+ * @returns 
+ */
 export async function zhongYangDangQianListToPage(zhongYangType:number, selectStr:string, pageNumber) {
     let funName = `当前种养列表`;
     let param:any = { };
@@ -49,7 +56,7 @@ export async function zhongYangDangQianListToPage(zhongYangType:number, selectSt
         param.plantType = {"$gte":zhongYangType, "$lt":zhongYangType+99};
     }
 
-    let zyList = await zhongzhiData.findDataToParamToPage( param, pageNumber );
+    let zyList = await zhongzhiData.findDataToParamToSortPage( param, {plantTime:-1}, pageNumber );
     let dataCount = await zhongzhiData.findDataToParamCouant(param);
     let dataList = [];
     zyList.forEach(info => {
@@ -67,6 +74,11 @@ export async function zhongYangDangQianListToPage(zhongYangType:number, selectSt
 }
 
 
+/**
+ * 删除种养 暂无使用
+ * @param zId 
+ * @returns 
+ */
 export async function deleteZhongYang(zId) {
     let zhongYangInfo = await zhongzhiData.selectOne({zId});
     if (!zhongYangInfo || !zhongYangInfo.zId) throw new BizError(ERRORENUM.数据不存在);
@@ -91,7 +103,7 @@ export async function addZhongYang(reqUser, param) {
     //校验地块大小是否符合扣除
     let dkInfo = await dikuaiData.selectOne({dId:param.dId});
     if (!dkInfo || !dkInfo.dId) throw new BizError(ERRORENUM.地块不存在);
-    if (dkInfo.nullSize < param.size) throw new BizError(ERRORENUM.地块大小不足);
+    if (dkInfo.size < param.size) throw new BizError(ERRORENUM.地块大小不足);
 
     let addInfo = {
         zId:randomId(TABLENAME.种植表),
@@ -114,6 +126,13 @@ export async function addZhongYang(reqUser, param) {
 }
 
 
+/**
+ * 修改种养 暂无使用
+ * @param reqUser 
+ * @param zId 
+ * @param param 
+ * @returns 
+ */
 export async function updateZhongYang(reqUser, zId, param) {
     let funName = `修改种养`;
     eccFormParam(funName, ZhongYangConfig, param);
@@ -121,7 +140,7 @@ export async function updateZhongYang(reqUser, zId, param) {
 
     let dkInfo = await dikuaiData.selectOne({dId:param.dId});
     if (!dkInfo || !dkInfo.dId) throw new BizError(ERRORENUM.地块不存在);
-    if (dkInfo.nullSize < param.size) throw new BizError(ERRORENUM.地块大小不足);
+    if (dkInfo.size < param.size) throw new BizError(ERRORENUM.地块大小不足);
 
     let zhongYangInfo = await zhongzhiData.selectOne({zId});
 
@@ -136,8 +155,12 @@ export async function updateZhongYang(reqUser, zId, param) {
 }
 
 
+/**
+ * 种养回显 暂无使用
+ * @param zId 
+ * @returns 
+ */
 export async function zhognYangInfo(zId) {
-
     let dikuaiInfo = await zhongzhiData.selectOne({zId});
     let dataInfo = {
         plantType:dikuaiInfo.plantType,//编号
@@ -171,9 +194,9 @@ export async function zhongYangJiLu(zhongYangType:number, selectStr:string, plan
         param.dId = dId;
     }
     if (plantTime) {
-        let selectStartTime = moment(plantTime).startOf('month').valueOf();
-        let selectEndTime = moment(plantTime).endOf("month").valueOf();
-        param.plantTime = {"$gt":selectStartTime, "$lt":selectEndTime};
+        let selectStartTime = moment(plantTime).startOf('day').valueOf();
+        let selectEndTime = moment(plantTime).endOf("day").valueOf();
+        param.plantTime = {"$gte":selectStartTime, "$lte":selectEndTime};
     }
     
     /**获取地块名称 */
@@ -191,9 +214,16 @@ export async function zhongYangJiLu(zhongYangType:number, selectStr:string, plan
             plantType:changeEnumValue(PLANTTYPE, info.plantType),
             size:info.size,
             code:diKuaiMap[info.dId],
-            plantTime:moment(info.plantTime).format("YYYY-MM-DD")
+            plantTime:moment(info.plantTime).format("YYYY-MM-DD"),
+            plantTimeNum:info.plantTime
         })
     });
 
+    dataList.sort( (a, b) => {
+        return b.plantTimeNum - a.plantTimeNum;
+    })
+
     return {dataList};
 }
+
+

src/config/eccParam.ts

@@ -30,7 +30,14 @@ export const NongZiConfig = {
 export const NongShiConfig = {
     nsType:{type:"Number" },//农事类型
     dIdList:{type:"[String]" },//地块id
-    operationTime:{type:"Number"},//使用时间
+    operationTime:{type:"Number"},//操作时间
+}
+
+
+export const NongShiAdminConfig = {
+    nsType:{type:"Number" },//农事类型
+    dIdList:{type:"String" },//地块id
+    operationTime:{type:"Number"},//操作时间
 }
 
 
@@ -38,7 +45,7 @@ export const CaiShouConfig = {
     plantType:{type:"Number"}, //种植种类【枚举】 PLANTTYPE
     dId:{type:"String" },//地块id
     weight:{type:"Number"},//采收重量
-    operationTime:{type:"Number"},//使用时间
+    operationTime:{type:"Number"},//采收时间
 }
 
 

src/data/caishou.ts

@@ -51,6 +51,22 @@ export async function addManyData(param) {
     return await caishouModel.insertMany(param);
 }
 
+export async function findDataToParamToSortPage(param, sort, pageNumber) {
+    return await caishouModel.find(param).sort(sort).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function findDataToParamToPage(param, pageNumber) {
+    return await caishouModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function findDataToParamCouant(param) {
+  return await caishouModel.find(param).countDocuments();
+}
+
+export async function deleteData(param) {
+    return await caishouModel.deleteOne(param);
+}
+
 
 export async function selectChanLiangOfMonth(param) {
     return await caishouModel.aggregate([

src/data/dikuai.ts

@@ -59,6 +59,10 @@ export async function selectToParam(param) {
     return await dikuaiModel.find(param);
 }
 
+export async function findDataToParamToSortPage(param, sort, pageNumber) {
+    return await dikuaiModel.find(param).sort(sort).skip((pageNumber-1)*10).limit(10);
+}
+
 export async function findDataToParamToPage(param, pageNumber) {
     return await dikuaiModel.find(param).skip((pageNumber-1)*10).limit(10);
 }

src/data/nongshi.ts

@@ -57,6 +57,21 @@ export async function selectCountByParam(param) {
     return await nongshiModel.find(param).countDocuments();
 }
 
+export async function findDataToParamToSortPage(param, sort, pageNumber) {
+    return await nongshiModel.find(param).sort(sort).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function findDataToParamToPage(param, pageNumber) {
+    return await nongshiModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function findDataToParamCouant(param) {
+    return await nongshiModel.find(param).countDocuments();
+}
+
+export async function deleteData(param) {
+    return await nongshiModel.deleteOne(param);
+}
 
 export async function statisNongShiType() {
     let list = await nongshiModel.aggregate([

src/data/nongzi.ts

@@ -54,20 +54,21 @@ export async function selectToParam(param) {
     return await nongziModel.find(param);
 }
 
-export async function findDataToParamCouant(param) {
-    return await nongziModel.find(param).countDocuments();
-}
-
-
 export async function deleteData(param) {
     return await nongziModel.deleteOne(param);
 }
 
+export async function findDataToParamToSortPage(param, sort, pageNumber) {
+    return await nongziModel.find(param).sort(sort).skip((pageNumber-1)*10).limit(10);
+}
+
 export async function findDataToParamToPage(param, pageNumber) {
     return await nongziModel.find(param).skip((pageNumber-1)*10).limit(10);
 }
 
-
+export async function findDataToParamCouant(param) {
+    return await nongziModel.find(param).countDocuments();
+}
 
 export async function statisNongZiType() {
     let list = await nongziModel.aggregate([
@@ -82,7 +83,6 @@ export async function statisNongZiType() {
     return list;
 }
 
-
 export async function statisNongZiTypeCountByTime() {
     let list = await nongziModel.aggregate([
         {
@@ -111,3 +111,4 @@ export async function statisNongZiTypeCountByTime() {
 
     return list;
 }
+

src/data/xiaoshou.ts

@@ -54,6 +54,21 @@ export async function selectToParam(param) {
     return await xiaoshouModel.find(param);
 }
 
+export async function selectCountByParam(param) {
+    return await xiaoshouModel.find(param).countDocuments();
+}
+
+export async function findDataToParamToPage(param, pageNumber) {
+    return await xiaoshouModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function findDataToParamToSortPage(param, sort, pageNumber) {
+    return await xiaoshouModel.find(param).sort(sort).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function deleteData(param) {
+    return await xiaoshouModel.deleteOne(param);
+}
 
 export async function selectXiaoShouOfMonth(param) {
     return await xiaoshouModel.aggregate([

src/data/zhongzhi.ts

@@ -57,6 +57,10 @@ export async function selectToParam(param) {
     return await zhongzhiModel.find(param);
 }
 
+export async function findDataToParamToSortPage(param, sort, pageNumber) {
+    return await zhongzhiModel.find(param).sort(sort).skip((pageNumber-1)*10).limit(10);
+}
+
 export async function findDataToParamToPage(param, pageNumber) {
     return await zhongzhiModel.find(param).skip((pageNumber-1)*10).limit(10);
 }

src/main.ts

@@ -4,7 +4,7 @@ import { httpServer } from "./net/http_server";
 import { initDB } from "./db/dbInit";
 import { dataInit0516, dataInit, dataInit0508, yjDataInit0508, dataInit0522, dataInit0604, dataInit0609, dataInit0618 } from "./biz/dataInt";
 import { getDataOut, getGuiYuOut } from "./biz/dataOut";
-import { homePageStatisChanLiang } from "./biz/user";
+import { homePageStatisChanLiang } from "./biz/xcx/user";
 import { getPwdMd5, md5PwdStr } from "./tools/system";
 
 async function lanuch() {
@@ -28,7 +28,7 @@ async function lanuch() {
     // await dataInit0604();
     // await dataInit0618();
 
-    let checkPwd = getPwdMd5("18120935727", md5PwdStr("123456"))
+    // let checkPwd = getPwdMd5("18120935727", md5PwdStr("123456"))
     console.log();
 }
 

src/routers/admin.ts

-import * as asyncHandler from 'express-async-handler'
+import asyncHandler = require('express-async-handler');
 import { eccReqParamater } from '../util/verificationParam';
-import * as diKuaiBiz from '../biz/diKuai';
-import * as userBiz from '../biz/user';
-import * as zhongYangBiz from '../biz/zhongYang';
-import * as nongziBiz from '../biz/nongzi';
-import * as nongShiBiz from '../biz/nongShi';
+import * as diKuaiBiz from '../biz/admin/diKuai';
+import * as userBiz from '../biz/admin/user';
+import * as zhongYangBiz from '../biz/admin/zhongYang';
+import * as nongziBiz from '../biz/admin/nongzi';
+import * as caishouBiz from '../biz/admin/caiShou';
+import * as nongShiBiz from '../biz/admin/nongShi';
 import * as publicRouters from './public';
-import * as caiShouBiz from '../biz/caiShou';
-import * as xiaoShouBiz from '../biz/xiaoShou';
+import * as xiaoShouBiz from '../biz/admin/xiaoShou';
 import { checkAdminUserToken } from '../middleware/user';
 import * as dataOutBiz from '../biz/dataOut';
 
@@ -147,9 +147,9 @@ async function zhongyang_info(req, res) {
 }
 
 async function zhongyang_list(req, res) {
-    let reqConf = {zhongYangType:"Number", selectStr:"String", page:"Number"};
-    let { zhongYangType, selectStr, pageNumber } = eccReqParamater(reqConf, req.body, ["zhongYangType", "selectStr"]);
-    let result = await zhongYangBiz.zhongYangDangQianListToPage(zhongYangType, selectStr, pageNumber);
+    let reqConf = {zhongYangType:"Number", plantType:"Number", dId:"String", plantTime:"Number", pageNumber:"Number"};
+    let { zhongYangType, plantType, dId, plantTime, pageNumber } = eccReqParamater(reqConf, req.body, ["dId", "plantType", "zhongYangType", "plantTime"]);
+    let result = await zhongYangBiz.zhongYangDangQianListToPage(zhongYangType, plantType, dId, plantTime, pageNumber);
     res.success(result);
 }
 
@@ -166,7 +166,6 @@ async function nongzi_add(req, res) {
     let reqConf = {param:'Object'};
     let { param } = eccReqParamater(reqConf, req.body);
     let userInfo = req.headers;
-
     let result = await nongziBiz.addNongZi(userInfo, param);
     res.success(result);
 }
@@ -197,116 +196,129 @@ async function nongzi_list(req, res) {
     res.success(result);
 }
 
-//todo
 
 async function nongzi_del(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {nzId:'String'};
+    let { nzId } = eccReqParamater(reqConf, req.body);
+    let result = await nongziBiz.deleteNongZi(nzId);
+    res.success(result);
 }
 
+
+//todo
 async function nongshi_add(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {param:'Object'};
+    let { param } = eccReqParamater(reqConf, req.body);
+    let userInfo = req.headers;
+    let result = await nongShiBiz.addNongShi(userInfo, param);
+    res.success(result);
 }
 
+
 async function nongshi_update(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {param:'Object', nsId:"String"};
+    let { param, nsId} = eccReqParamater(reqConf, req.body);
+    let userInfo = req.headers;
+    let result = await nongShiBiz.updateNongShi(userInfo, nsId, param);
+    res.success(result);
 }
 
 async function nongshi_info(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {nsId:'String'};
+    let { nsId } = eccReqParamater(reqConf, req.body);
+    let result = await nongShiBiz.nongShiInfo(nsId);
+    res.success(result);
 }
 
 async function nongshi_list(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {nsType:'Number', dId:'String', operationTime:'Number', pageNumber:'Number'};
+    let { nsType, dId, operationTime, pageNumber } = eccReqParamater(reqConf, req.body, ["nsType", "dId", "operationTime"]);
+    let result = await nongShiBiz.nongShiList(nsType, dId, operationTime, pageNumber);
+    res.success(result);
 }
 
 async function nongshi_del(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {nsId:'String'};
+let { nsId } = eccReqParamater(reqConf, req.body);
+let result = await nongShiBiz.deleteNongShi(nsId);
 res.success(result);
 }
 
 async function caishou_add(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {param: 'Object'};
+    const NotMustHaveKeys = [];
+    let { param } = eccReqParamater(reqConf, req.body, NotMustHaveKeys);
+
+    const UserInfo = req.userInfo;
+
+    let result = await caishouBiz.addCaiShou(UserInfo, param);
+    res.success(result);
 }
 
 async function caishou_update(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {param:'Object', csId:"String"};
+    let { param, csId} = eccReqParamater(reqConf, req.body);
+    let userInfo = req.headers;
+    let result = await caishouBiz.updateCaiShou(userInfo, csId, param);
+    res.success(result);
 }
 
 async function caishou_info(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {csId:'String'};
+let { csId } = eccReqParamater(reqConf, req.body);
+let result = await caishouBiz.caishouInfo(csId);
 res.success(result);
 }
 
 async function caishou_list(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {zhongYangType:'Number', dId:'String', plantType:'Number', operationTime:'Number', pageNumber:'Number'};
+let { zhongYangType, dId, plantType, operationTime, pageNumber } = eccReqParamater(reqConf, req.body, ["dId", "plantType", "operationTime"]);
+let result = await caishouBiz.caiShouList(zhongYangType, dId, plantType, operationTime, pageNumber);
 res.success(result);
 }
 
 async function caishou_del(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {csId:'String'};
+let { csId } = eccReqParamater(reqConf, req.body);
+let result = await caishouBiz.deleteCaiShou(csId);
 res.success(result);
 }
 
 async function xiaoshou_add(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {param: 'Object'};
+    let { param } = eccReqParamater(reqConf, req.body);
+
+    const UserInfo = req.userInfo;
+
+    let result = await xiaoShouBiz.addXiaoShou(UserInfo, param);
+    res.success(result);
 }
 
 async function xiaoshou_update(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
-res.success(result);
+    let reqConf = {param:'Object', xsId:"String"};
+    let { param, xsId} = eccReqParamater(reqConf, req.body);
+    let userInfo = req.headers;
+    let result = await xiaoShouBiz.updateXiaoShou(userInfo, xsId, param);
+    res.success(result);
 }
 
 async function xiaoshou_info(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {xsId:'String'};
+let { xsId } = eccReqParamater(reqConf, req.body);
+let result = await xiaoShouBiz.xiaoShouInfo(xsId);
 res.success(result);
 }
 
 async function xiaoshou_list(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {quXiang:'Number', plantType:'Number', operationTime:'Number', pageNumber:'Number'};
+let { quXiang, plantType, operationTime, pageNumber } = eccReqParamater(reqConf, req.body, ["quXiang", "plantType", "operationTime"]);
+let result = await xiaoShouBiz.xiaoShouList(quXiang, plantType, operationTime, pageNumber);
 res.success(result);
 }
 
 async function xiaoshou_del(req, res) {
-    let reqConf = {type:'Number'};
-let { type } = eccReqParamater(reqConf, req.body);
-let result = await userBiz.homePageStatisChanLiang(type);
+    let reqConf = {xsId:'String'};
+let { xsId } = eccReqParamater(reqConf, req.body);
+let result = await xiaoShouBiz.deleteXiaoShou(xsId);
 res.success(result);
 }

src/routers/public.ts

 /**
  * 公共资源路由
  */
-import * as asyncHandler from 'express-async-handler';
+import asyncHandler = require('express-async-handler');
 import * as enumConfig from '../config/enum';
 
 const config = {

src/routers/router.ts

-import * as asyncHandler from 'express-async-handler'
+import asyncHandler = require('express-async-handler');
 import { eccReqParamater } from '../util/verificationParam';
-import * as diKuaiBiz from '../biz/diKuai';
-import * as userBiz from '../biz/user';
-import * as zhongYangBiz from '../biz/zhongYang';
-import * as nongziBiz from '../biz/nongzi';
-import * as nongShiBiz from '../biz/nongShi';
+import * as diKuaiBiz from '../biz/xcx/diKuai';
+import * as userBiz from '../biz/xcx/user';
+import * as zhongYangBiz from '../biz/xcx/zhongYang';
+import * as nongziBiz from '../biz/xcx/nongzi';
+import * as nongShiBiz from '../biz/xcx/nongShi';
 import * as publicRouters from './public';
 import * as adminRouters from './admin';
-import * as caiShouBiz from '../biz/caiShou';
-import * as xiaoShouBiz from '../biz/xiaoShou';
+import * as caiShouBiz from '../biz/xcx/caiShou';
+import * as xiaoShouBiz from '../biz/xcx/xiaoShou';
 import { checkUserToken } from '../middleware/user';
 import * as dataOutBiz from '../biz/dataOut';