Merge branch 'strategy' into 'master'

Strategy

See merge request !7

README.md

+# 寿州古城数据接口
+[中文](#中文) [English](#English)
+# 中文
+## 端点：`/szgc/getdata`
+## 参数：
+- `content`:
+  - 左侧API：
+    - sightVisitorFlowByDay
+    - gateStatus
+    - sightVisitorFlowPerHour
+    - guchengLoad
+    - totalVisitorFlow
+    - totalVisitorFlowByDay
+  - 中间API：
+    - currentEventStrategy
+    - totalEventCount
+    - allEvents
+  - 右侧API：
+    - getEventCountByYear
+    - getEventTimeDistribution
+    - getEventMonthDistribution
+    - getEventCategoryCount
+    - getEventSubCategoryCount
+    - getEventSourceCount
+    - getGridEventCount
+    - getEventProcessingTime
+
+
+
+
+
+
+  

src/biz/getData.ts

 /**寿州古城智慧调度事件态势感知 */
-import { DataExtractor } from "../util/dataExtractor";
+import { strategyFactory } from "./strategies/strategyFactory";
 
 /**
  * 主界面
@@ -7,23 +7,13 @@ import { DataExtractor } from "../util/dataExtractor";
  * @param res 
  */
 export function getData(req, res) {
-
-    // TODO: 和前端讨论具体数据需求
-
-    /**填充数据格式处理 */
-    const dataExtractor = DataExtractor.getInstance();
-    const ret = dataExtractor.getData(req.query.fileName, req.query.sheetName);
-
-
-    
-
+    const strategy = strategyFactory.createStrategy(req.query.content)
+    let ret = strategy.execute(req);
     res.send(ret);
 }
 
 export function test(req, res) {
-    const ret = "Success!";
-
-    res.send(ret);
+    res.send("Success!");
 }
 
 

src/biz/strategies/dataStrategy.ts

+import { DataExtractor } from "../../util/dataExtractor";
+
+export interface dataStrategy {
+    execute(params?: any): any;
+}
\ No newline at end of file

src/biz/strategies/left/abstractDataStrategyLeft.ts

+import { dataStrategy } from "../dataStrategy";
+import {DataExtractor} from "../../../util/dataExtractor";
+
+export abstract class abstractDataStrategyLeft implements dataStrategy {
+    extractor = DataExtractor.getInstance();
+    static readonly FILENAME = '票务系统.xlsx';
+    static readonly SHEETNAME = '票务系统-订单主表';
+    static readonly TIMEDIFFERENCE = 8;
+
+    execute(params?: any): any {
+    }
+
+}
\ No newline at end of file

src/biz/strategies/left/guchengLoadStrategy.ts

+import { randomStatusGenerator } from "../../../util/randomStatusGenerator";
+import {abstractDataStrategyLeft} from "./abstractDataStrategyLeft";
+
+export class guchengLoadStrategy extends abstractDataStrategyLeft {
+    execute(): any {
+        return randomStatusGenerator.getRandomStatus();
+    }
+}
\ No newline at end of file

src/biz/strategies/left/sightVisitorFlowByDayStrategy.ts

+import { randomStatusGenerator } from "../../../util/randomStatusGenerator";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import {abstractDataStrategyLeft} from "./abstractDataStrategyLeft";
+
+export class sightVisitorFlowByDayStrategy extends abstractDataStrategyLeft {
+    execute(params?: any): any {
+        if (!params || !params.query || !params.query.date) {
+            throw new Error("Date parameter is required.")
+        }
+        let sightData = this.extractor.getData(sightVisitorFlowByDayStrategy.FILENAME, sightVisitorFlowByDayStrategy.SHEETNAME);
+        return this.getVisitorFlowByDay(sightData, params.query.date);
+    }
+
+    private getVisitorFlowByDay(data: any, date: string) {
+        const visitorCount: { [sight: string]: { count: number, status: string } } = {};
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['游玩时间']);
+            let rowDateString = '';
+            try {
+                rowDateString = rowDate.toISOString().split('T')[0];
+            }
+            catch (e) {
+                rowDateString = 'invalid time'
+            }
+            const sight = row['景点名称'];
+
+            if (rowDateString == date) {
+                if (!visitorCount[sight]) {
+                    visitorCount[sight] = {count: 0, status: randomStatusGenerator.getRandomStatus()};
+                }
+                visitorCount[sight].count++;
+            }
+        });
+        return visitorCount;
+
+    }
+
+}
+

src/biz/strategies/left/sightVisitorFlowPerHourStrategy.ts

+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import mapToObj from "../../../util/mapToObj";
+import {abstractDataStrategyLeft} from "./abstractDataStrategyLeft";
+
+export class sightVisitorFlowByHourStrategy extends abstractDataStrategyLeft {
+
+    execute(params?: any): any {
+        if (!params || !params.query || !params.query.date || !params.query.sight) {
+            throw new Error('Date and sight parameters are required');
+        }
+        const sightData = this.extractor.getData(sightVisitorFlowByHourStrategy.FILENAME, sightVisitorFlowByHourStrategy.SHEETNAME);
+        return mapToObj(this.getVisitorFlowByHour(sightData, params.query.sight, params.query.date));
+    }
+
+    private getVisitorFlowByHour(data: any, sight: string, date: string) {
+        const visitorCount: Map<number, number> = new Map();
+        for (let hour = 0; hour < 24; hour++) {
+            visitorCount.set(hour, 0);
+        }
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['游玩时间']);
+            const rowHour = rowDate.getHours();
+            let rowDateString = '';
+            try {
+                rowDateString = rowDate.toISOString().split('T')[0];
+            }
+            catch (e) {
+                rowDateString = 'invalid time';
+            }
+            const rowSight = row['景点名称'];
+            rowDate.setHours(rowDate.getHours() - sightVisitorFlowByHourStrategy.TIMEDIFFERENCE);
+
+            if (rowDateString == date && rowSight == sight) {
+                visitorCount.set(rowHour, (visitorCount.get(rowHour) || 0) + 1);
+            }
+        });
+        return visitorCount;
+    }
+}

src/biz/strategies/left/totalVisitorFlowByHourStrategy.ts

+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import mapToObj from "../../../util/mapToObj";
+import {abstractDataStrategyLeft} from "./abstractDataStrategyLeft";
+
+export class totalVisitorFlowByHourStrategy extends abstractDataStrategyLeft {
+
+
+    execute(params?: any): any {
+        if (!params || !params.query || !params.query.date) {
+            throw new Error('Date parameters are required');
+        }
+        const sightData = this.extractor.getData(totalVisitorFlowByHourStrategy.FILENAME, totalVisitorFlowByHourStrategy.SHEETNAME);
+        return mapToObj(this.getTotalVisitorFlowByHour(sightData, params.query.date));
+    }
+
+    private getTotalVisitorFlowByHour(data: any, date: string) {
+        const visitorCount: Map<number, number> = new Map();
+        for (let hour = 0; hour < 24; hour++) {
+            visitorCount.set(hour, 0);
+        }
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['游玩时间']);
+            const rowHour = rowDate.getHours();
+            let rowDateString = '';
+            try {
+                rowDateString = rowDate.toISOString().split('T')[0];
+            }
+            catch (e) {
+                rowDateString = 'invalid time';
+            }
+            rowDate.setHours(rowDate.getHours() - totalVisitorFlowByHourStrategy.TIMEDIFFERENCE);
+
+            if (rowDateString == date) {
+                visitorCount.set(rowHour, (visitorCount.get(rowHour) || 0) + 1);
+            }
+        });
+        return visitorCount;
+    }
+
+}
\ No newline at end of file

src/biz/strategies/left/totalVisitorFlowStrategy.ts

+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import mapToObj from "../../../util/mapToObj";
+import { abstractDataStrategyLeft } from "./abstractDataStrategyLeft";
+
+export class totalVisitorFlowStrategy extends abstractDataStrategyLeft {
+
+    execute(params?: any): any {
+        if (!params || !params.query || !params.query.date) {
+            throw new Error("Date parameter is required.")
+        }
+        let sightData = this.extractor.getData(totalVisitorFlowStrategy.FILENAME, totalVisitorFlowStrategy.SHEETNAME);
+        return mapToObj(this.getTotalVisitorByDay(sightData, params.query.date));
+    }
+
+    private getTotalVisitorByDay(data: any, date: string) {
+        const visitorCount: Map<string, number> = new Map();
+        visitorCount.set('total', 0);
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['游玩时间']);
+            let rowDateString = '';
+            try {
+                rowDateString = rowDate.toISOString().split('T')[0];
+            }
+            catch (e) {
+                rowDateString = 'invalid time'
+            }
+            if (rowDateString === date) {
+                visitorCount.set('total', visitorCount.get('total') + 1);
+                visitorCount.set(row['订单游客类型'], (visitorCount.get(row['订单游客类型']) || 0) + 1);
+            }
+        });
+
+        return visitorCount;
+
+    }
+
+}
\ No newline at end of file

src/biz/strategies/middle/abstractDataStrategyMid.ts

+import {dataStrategy} from "../dataStrategy";
+import {DataExtractor} from "../../../util/dataExtractor";
+
+export abstract class abstractDataStrategyMid implements dataStrategy {
+    extractor = DataExtractor.getInstance();
+    static readonly fileName = '寿州古城.xlsx';
+    static readonly sheetName = '指挥调度系统';
+    execute(params?: any): any {
+    }
+
+}
\ No newline at end of file

src/biz/strategies/middle/currentEventStrategy.ts

+import {abstractDataStrategyMid} from "./abstractDataStrategyMid";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import mapToObj from "../../../util/mapToObj";
+
+export class currentEventStrategy extends abstractDataStrategyMid {
+    execute(params?: any): any {
+        if (!params || !params.query || !params.query.date) {
+            throw new Error("Date parameter is required.")
+        }
+        let dayData = this.extractor.getData(currentEventStrategy.fileName, currentEventStrategy.sheetName);
+        return mapToObj(this.getCurrentDayEventDate(dayData, params.query.date));
+    }
+
+    private getCurrentDayEventDate(data: any, date: string) {
+        const eventCount: Map<string, number> = new Map();
+        eventCount.set('pendingEvents', 0);
+        eventCount.set('processedEvents', 0);
+
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['数据更新时间']);
+            let rowDateString = '';
+            try {
+                rowDateString = rowDate.toISOString().split('T')[0];
+            }
+            catch (e) {
+                rowDateString = 'invalid time'
+            }
+            if (rowDateString === date) {
+                if (row['处置状态'] == '待调度' || row['处置状态'] == '处置中') {
+                    eventCount.set('pendingEvents', eventCount.get('pendingEvents') + 1);
+                }
+                else {
+                    eventCount.set('processedEvents', eventCount.get('processedEvents') + 1);
+                }
+            }
+        });
+
+        return eventCount;
+    }
+
+}
\ No newline at end of file

src/biz/strategies/middle/eventDataStrategy.ts

+import {abstractDataStrategyMid} from "./abstractDataStrategyMid";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+
+export class allEventDataStrategy extends abstractDataStrategyMid {
+    static readonly RELEVANTINFO = ['事件标题', '处置状态', '数据更新时间', '事件类型', '事件子类型', '事件来源'];
+
+    execute(): any {
+        let eventData = this.extractor.getData(allEventDataStrategy.fileName, allEventDataStrategy.sheetName);
+        this.removeUnusedColumns(eventData);
+        return eventData;
+    }
+
+    private removeUnusedColumns(data: any) {
+        data.forEach(row => {
+            Object.keys(row).forEach(key => {
+                if (!allEventDataStrategy.RELEVANTINFO.includes(key)) {
+                    delete row[key];
+                }
+                if (key === '数据更新时间') {
+                    row[key] = excelSerialToJSDate(row[key]);
+                }
+            });
+        });
+    }
+}
\ No newline at end of file

src/biz/strategies/middle/totalEventCountStrategy.ts

+import {abstractDataStrategyMid} from "./abstractDataStrategyMid";
+import mapToObj from "../../../util/mapToObj";
+
+export class totalEventCountStrategy extends abstractDataStrategyMid {
+    execute(): any {
+        let eventData = this.extractor.getData(totalEventCountStrategy.fileName, totalEventCountStrategy.sheetName);
+        return mapToObj(this.getEventCount(eventData));
+    }
+
+    private getEventCount(data: any) {
+        const eventCount : Map<string, number> = new Map();
+        eventCount.set('全部事件', 0);
+
+        data.forEach(row => {
+            eventCount.set(row['处置状态'], (eventCount.get(row['处置状态']) || 0) + 1);
+            eventCount.set('全部事件', eventCount.get('全部事件') + 1);
+        });
+
+        return eventCount;
+
+    }
+}
\ No newline at end of file

src/biz/strategies/right/abstractDataStrategyRight.ts

+import {dataStrategy} from "../dataStrategy";
+import {DataExtractor} from "../../../util/dataExtractor";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+
+
+export abstract class abstractDataStrategyRight implements dataStrategy {
+    extractor = DataExtractor.getInstance();
+    static readonly FILENAME = '寿州古城.xlsx';
+    static readonly SHEETNAME = '指挥调度系统';
+    static readonly TIMEDIFFERENCE = 8;
+    protected eventData;
+
+    constructor() {
+        this.eventData = this.readDataFromExcel();
+    }
+
+
+    execute(params?: any): any {
+    }
+
+    protected paramsCheck(params) {
+        if (!params || !params.query || !params.query.year) {
+            throw new Error('Year parameters are required');
+        }
+    }
+
+    protected readDataFromExcel() {
+        return this.extractor.getData(abstractDataStrategyRight.FILENAME, abstractDataStrategyRight.SHEETNAME);
+    }
+
+    protected registerItems(list: string[]) {
+        const eventCount: Map<string, number> = new Map();
+        list.forEach(event => {
+            eventCount.set(event, 0);
+        });
+        return eventCount;
+    }
+
+    protected getListCount(list: string[], target: string, data: any, year: number) {
+        const count = this.registerItems(list);
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['创建时间']);
+            const rowYear = rowDate.getFullYear();
+
+            if (rowYear == year) {
+                count.set(row[target], count.get(row[target]) + 1);
+            }
+        });
+        return count;
+    }
+
+}
\ No newline at end of file

src/biz/strategies/right/dispatchTimeStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import getRandomNumber from "../../../util/randomNumberGenerator";
+
+export class dispatchTimeStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        return this.getAverageDispatchTime(this.eventData, params.query.year);
+    }
+
+    private getAverageDispatchTime(data: any, year: number) {
+        let count = 0, time = 0;
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['创建时间']);
+            const rowYear = rowDate.getFullYear();
+            if (rowYear == year) {
+                if (row['处置状态'] == '待调度') {
+                    time = getRandomNumber(0.5, 1.7, 1);
+                    count++;
+                }
+            }
+        })
+        return time / count;
+    }
+}
\ No newline at end of file

src/biz/strategies/right/eventCategoryCountStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import mapToObj from "../../../util/mapToObj";
+
+export class eventCategoryCountStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        const eventList = ['咨询', '求助', '预警系统', '投诉', '指挥调度', '建议']
+        const target = '事件类型';
+        return mapToObj(this.getListCount(eventList, target, this.eventData, params.query.year));
+    }
+}
\ No newline at end of file

src/biz/strategies/right/eventMonthDistributionStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import mapToObj from "../../../util/mapToObj";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+
+export class eventMonthDistributionStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any{
+        this.paramsCheck(params);
+        return mapToObj(this.getEventMonthDistribution(this.eventData, params.query.year));
+    }
+
+    private getEventMonthDistribution(data: any, year: number) {
+        const eventCount: Map<number, number> = new Map();
+        for (let month = 1; month <= 12; month++) {
+            eventCount.set(month, 0);
+        }
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['创建时间']);
+            const rowYear = rowDate.getFullYear();
+            const rowMonth = rowDate.getMonth();
+
+            if (rowYear == year) {
+                eventCount.set(rowMonth + 1, eventCount.get(rowMonth + 1) + 1);
+            }
+        });
+        return eventCount;
+
+    }
+}
\ No newline at end of file

src/biz/strategies/right/eventProcessingTimeStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import getRandomNumber from "../../../util/randomNumberGenerator";
+import mapToObj from "../../../util/mapToObj";
+
+export class eventProcessingTimeStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        return mapToObj(this.getEventProcessingTime(this.eventData, params.query.year));
+    }
+
+    private getEventProcessingTime(data: any, year: number) {
+        const statusList = ['调度时长', '处置等待', '处置时长', '办结时长']
+        const timeMap = this.registerItems(statusList);
+        let assignCount = 0, waitCount = 0, processCount = 0, finishingCount = 0;
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['创建时间']);
+            const rowYear = rowDate.getFullYear();
+            let waitTime, processTime, closeTime;
+            if (rowYear == year) {
+                switch (row['处置状态']) {
+                    case '待调度':
+                        const time = getRandomNumber(0.5, 1.7, 1);
+                        timeMap.set('调度时长', timeMap.get('调度时长') + time);
+                        assignCount++;
+                    case '处置中':
+                        waitTime = this.calculateTimeDifference(row['处置时间'], row['创建时间']);
+                        if (isNaN(row['处置时间'])) {
+                            waitTime = 0;
+                            waitCount--;
+                        }
+                        timeMap.set('处置等待', timeMap.get('处置等待') + waitTime);
+                        waitCount++;
+                    case '已处置':
+                        waitTime = this.calculateTimeDifference(row['处置时间'], row['创建时间']);
+                        processTime = this.calculateTimeDifference(row['处置完成时间'], row['处置时间']);
+                        if (isNaN(row['处置时间'])) {
+                            waitTime = 0;
+                            waitCount--;
+                        }
+                        if (isNaN(row['处置完成时间'])) {
+                            processTime = 0;
+                            processCount--;
+                        }
+                        timeMap.set('处置等待', timeMap.get('处置等待') + waitTime);
+                        timeMap.set('处置时长', timeMap.get('处置时长') + processTime);
+                        waitCount++;
+                        processCount++;
+                    case '已办结':
+                        waitTime = this.calculateTimeDifference(row['处置时间'], row['创建时间']);
+                        processTime = this.calculateTimeDifference(row['处置完成时间'], row['处置时间']);
+                        closeTime = this.calculateTimeDifference(row['办结时间'], row['创建时间']);
+                        if (isNaN(row['处置时间'])) {
+                            waitTime = 0;
+                            waitCount--;
+                        }
+                        if (isNaN(row['处置完成时间'])) {
+                            processTime = 0;
+                            processCount--;
+                        }
+                        if (isNaN(row['办结时间'])) {
+                            closeTime = 0;
+                            finishingCount--;
+                        }
+                        timeMap.set('处置等待', timeMap.get('处置等待') + waitTime);
+                        timeMap.set('处置时长', timeMap.get('处置时长') + processTime);
+                        timeMap.set('办结时长', timeMap.get('办结时长') + processTime);
+                        waitCount++;
+                        processCount++;
+                        finishingCount++;
+                }
+            }
+        });
+
+        timeMap.set('调度时长', timeMap.get('调度时长') / assignCount);
+        timeMap.set('处置等待', timeMap.get('处置等待') / waitCount);
+        timeMap.set('处置时长', timeMap.get('处置时长') / processCount);
+        timeMap.set('办结时长', timeMap.get('办结时长') / finishingCount);
+        return timeMap
+
+    }
+
+    private calculateTimeDifference(start: number, end: number): number {
+        const time = excelSerialToJSDate(start).getTime() - excelSerialToJSDate(end).getTime();
+        return time / (1000 * 60);
+    }
+}
\ No newline at end of file

src/biz/strategies/right/eventSrcStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import mapToObj from "../../../util/mapToObj";
+
+export class eventSrcStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        const sourceList = ['景管通', '12301热线', '舆情平台', '电话热线', '指挥调度', '12345热线']
+        const target = '事件来源';
+        return mapToObj(this.getListCount(sourceList, target, this.eventData, params.query.year));
+    }
+}
\ No newline at end of file

src/biz/strategies/right/eventSubCategoryCountStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import mapToObj from "../../../util/mapToObj";
+
+export class eventSubCategoryCountStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        const eventList = ['服务质量', '医疗救助', '纠纷', '环境卫生', '血族调查', '设施设备'];
+        const target = '事件子类型';
+        return mapToObj(this.getListCount(eventList, target, this.eventData, params.query.year));
+    }
+}
\ No newline at end of file

src/biz/strategies/right/eventTimeDistributionStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import mapToObj from "../../../util/mapToObj";
+
+export class eventTimeDistributionStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any{
+        this.paramsCheck(params);
+        return mapToObj(this.getEventTimeDistribution(this.eventData, params.query.year));
+    }
+
+    private getEventTimeDistribution(data: any, year: number) {
+        const eventCount: Map<number, number> = new Map();
+        for (let hour = 0; hour < 24; hour++) {
+            eventCount.set(hour, 0);
+        }
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['创建时间']);
+            const rowHour = rowDate.getHours()
+            const rowYear = rowDate.getFullYear();
+            rowDate.setHours(rowDate.getHours() - eventTimeDistributionStrategy.TIMEDIFFERENCE);
+
+            if (rowYear == year) {
+                eventCount.set(rowHour, (eventCount.get(rowHour) || 0) + 1);
+            }
+        });
+        return eventCount;
+    }
+}
\ No newline at end of file

src/biz/strategies/right/getEventCountByYearStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import excelSerialToJSDate from "../../../util/excelDateToJSDate";
+import mapToObj from "../../../util/mapToObj";
+
+export class getEventCountByYearStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        return mapToObj(this.getEventCountForYear(this.eventData, params.query.year));
+    }
+
+    private getEventCountForYear(data: any, year: number) {
+        const eventList = ['事件总数', '历史遗留', '办结率'];
+        const eventCount = this.registerItems(eventList);
+
+        let finishedEventCount = 0;
+
+        data.forEach(row => {
+            const rowDate = excelSerialToJSDate(row['创建时间']);
+            let rowYear;
+            try {
+                rowYear = rowDate.getFullYear();
+            } catch (e) {
+                rowYear = 0;
+            }
+            if (rowYear == year) {
+                eventCount.set('事件总数', eventCount.get('事件总数') + 1);
+                if (row['处置状态'] == '已办结') {
+                    finishedEventCount++;
+                }
+            }
+            else if (rowYear == year - 1 && row['处置状态'] != '已办结') {
+                eventCount.set('历史遗留', eventCount.get('历史遗留') + 1);
+            }
+        });
+        eventCount.set('办结率', finishedEventCount / eventCount.get('事件总数'));
+        return eventCount;
+    }
+}
\ No newline at end of file

src/biz/strategies/right/gridEventCountStrategy.ts

+import {abstractDataStrategyRight} from "./abstractDataStrategyRight";
+import mapToObj from "../../../util/mapToObj";
+
+export class gridEventCountStrategy extends abstractDataStrategyRight {
+    execute(params?: any): any {
+        this.paramsCheck(params);
+        const gridList = ['寿州全域', '八公山景区', '寿县古城'];
+        const target = '网格名称';
+        return mapToObj(this.getListCount(gridList, target, this.eventData, params.query.year));
+    }
+}
\ No newline at end of file

src/biz/strategies/strategyFactory.ts

+import {dataStrategy} from "./dataStrategy";
+
+import {sightVisitorFlowByDayStrategy} from "./left/sightVisitorFlowByDayStrategy";
+import {gateStatusStrategy} from "./left/gateStatusStrategy";
+import {sightVisitorFlowByHourStrategy} from "./left/sightVisitorFlowPerHourStrategy";
+import {guchengLoadStrategy} from "./left/guchengLoadStrategy";
+import {totalVisitorFlowStrategy} from "./left/totalVisitorFlowStrategy";
+import {totalVisitorFlowByHourStrategy} from "./left/totalVisitorFlowByHourStrategy";
+
+import {currentEventStrategy} from "./middle/currentEventStrategy";
+import {totalEventCountStrategy} from "./middle/totalEventCountStrategy";
+import {allEventDataStrategy} from "./middle/eventDataStrategy";
+
+import {getEventCountByYearStrategy} from "./right/getEventCountByYearStrategy";
+import {eventTimeDistributionStrategy} from "./right/eventTimeDistributionStrategy";
+import {eventMonthDistributionStrategy} from "./right/eventMonthDistributionStrategy";
+import {eventCategoryCountStrategy} from "./right/eventCategoryCountStrategy";
+import {eventSubCategoryCountStrategy} from "./right/eventSubCategoryCountStrategy";
+import {eventSrcStrategy} from "./right/eventSrcStrategy";
+import {gridEventCountStrategy} from "./right/gridEventCountStrategy";
+import {eventProcessingTimeStrategy} from "./right/eventProcessingTimeStrategy";
+
+export class strategyFactory {
+    private static strategies: { [key: string]: new () => dataStrategy } = {
+        'allEvents': allEventDataStrategy,
+        'sightVisitorFlowByDay': sightVisitorFlowByDayStrategy,
+        'gateStatus': gateStatusStrategy,
+        'sightVisitorFlowPerHour': sightVisitorFlowByHourStrategy,
+        'guchengLoad': guchengLoadStrategy,
+        'totalVisitorFlow': totalVisitorFlowStrategy,
+        'totalVisitorFlowByDay': totalVisitorFlowByHourStrategy,
+        'currentEventStrategy': currentEventStrategy,
+        'totalEventCount': totalEventCountStrategy,
+        'getEventCountByYear': getEventCountByYearStrategy,
+        'getEventTimeDistribution': eventTimeDistributionStrategy,
+        'getEventMonthDistribution': eventMonthDistributionStrategy,
+        'getEventCategoryCount': eventCategoryCountStrategy,
+        'getEventSubCategoryCount': eventSubCategoryCountStrategy,
+        'getEventSourceCount': eventSrcStrategy,
+        'getGridEventCount': gridEventCountStrategy,
+        'getEventProcessingTime': eventProcessingTimeStrategy
+    };
+
+    static createStrategy(type: string): dataStrategy {
+        const StrategyClass = this.strategies[type];
+        if (!StrategyClass) {
+            throw new Error('Invalid strategy type.');
+        }
+        return new StrategyClass();
+    }
+
+    static registerStrategy(type: string, strategy: new () => dataStrategy) {
+        this.strategies[type] = strategy;
+    }
+
+}
\ No newline at end of file

src/main.ts

 import { httpServer } from "./net/http_server";
 import { initConfig, systemConfig } from "./config/serverConfig";
-import { DataExtractor } from "./util/dataExtractor";
 
 let fs = require('fs');
 
 async function lanuch() {
     /**初始化xml文件配置 */
     await initConfig();
-    const de = DataExtractor.getInstance();
-    
     httpServer.createServer( systemConfig.port );
     console.log('This indicates that the server is started successfully.');
 }

src/middleware/httpErrorHandler.ts

 export function httpErrorHandler(err, req, res, next) {
     console.log("in httpErrorHandler");
     console.log(err);
-    //TODO 自定义错误编码
     if (err) {
         if (err.message == "Excel文件不存在") {
             res.success({success: false, msg: err.message, code: 501});
@@ -11,6 +10,22 @@ export function httpErrorHandler(err, req, res, next) {
             res.success({success: false, msg: err.message, code: 502});
             next();
         }
+        else if (err.message == "Date parameter is required.") {
+            res.success({success: false, msg: err.message, code: 503});
+            next();
+        }
+        else if (err.message == "Date and sight parameters are required.") {
+            res.success({success: false, msg: err.message, code: 504});
+            next();
+        }
+        else if (err.message == "Invalid strategy type.") {
+            res.success({success: false, msg: "不支持该请求", code: 505});
+            next();
+        }
+        else if (err.message == 'Year parameter is required.') {
+            res.success({success: false, msg: err.message, code: 506});
+            next();
+        }
         else {
             res.success({success:false, msg: err.message, code: 500});
             next();

src/net/http_server.ts

@@ -6,7 +6,7 @@ import * as fallback from 'express-history-api-fallback';
 import * as path from "path";
 import { watch } from '../middleware/watch';
 import { httpErrorHandler } from '../middleware/httpErrorHandler';
-
+import { DataExtractor } from "../util/dataExtractor";
 
 export class httpServer {
    static createServer(port:number) {
@@ -48,6 +48,7 @@ export class httpServer {
     
     httpServer.listen(port);
     console.log('server listen on port:'+port);
+    DataExtractor.getInstance();
     
     return httpServer;
   }

src/routers/router.ts

@@ -7,8 +7,7 @@ import * as szgcBiz from '../biz/getData';
 
 
 export function setRouter(httpServer){
-    httpServer.get('/getdata', asyncHandler(szgcBiz.getData));
+    httpServer.get('/szgc/getdata', asyncHandler(szgcBiz.getData));
     httpServer.get('/test', szgcBiz.test);
-
 }
 

src/util/excelDateToJSDate.ts

+export default function excelSerialToJSDate(serial: number): Date {
+    const EXCEL_EPOCH = 25569;
+    const MS_PER_DAY = 86400000;
+
+    // Split the excelDate into integer and fractional parts
+    const days = Math.floor(serial);
+    const fractionalDay = serial - days;
+
+    // Convert to milliseconds
+    const jsDateMilliseconds = (days - EXCEL_EPOCH) * MS_PER_DAY + fractionalDay * MS_PER_DAY;
+
+    return new Date(jsDateMilliseconds);
+}
\ No newline at end of file

src/util/mapToObj.ts

+export default function mapToObj(map) {
+    let Obj: { [key: string]: string } = {};
+    map.forEach((value, key) => {
+        Obj[key] = value;
+    });
+    return Obj;
+}
\ No newline at end of file

src/util/randomNumberGenerator.ts

+export default function getRandomNumber(min: number, max: number, decimalPlaces: number): number {
+    const randomNum = Math.random() * (max - min) + min;
+    return Math.round(randomNum * Math.pow(10, decimalPlaces)) / Math.pow(10, decimalPlaces);
+}
\ No newline at end of file

src/util/randomStatusGenerator.ts

+export class randomStatusGenerator {
+    private static statuses: string[] = ['正常', '拥挤', '顺畅'];
+
+    static getRandomStatus(): string {
+        const randomIndex = Math.floor(Math.random() * randomStatusGenerator.statuses.length);
+        return this.statuses[randomIndex];
+    }
+}
\ No newline at end of file