640 lines
29 KiB
TypeScript
640 lines
29 KiB
TypeScript
import { getFetch, postFetch } from "@/app/components/api";
|
|
// import CalcRainEffect from "@/app/components/common/CalcRainEffect";
|
|
import { roundNumber } from "@/app/components/common/DataForm";
|
|
import { OSU_PERCENT } from "../common";
|
|
import type { TableUpperProps } from "../dashboard";
|
|
import { fetchFacilityListInit } from "../processFacility";
|
|
export type { TableUpperProps };
|
|
|
|
/**
|
|
* 운영실태 >오수발생량 추정
|
|
*/
|
|
// 시설별 강수현황
|
|
export type SewageOccurProps = {
|
|
bscFctCd: string,
|
|
sidoNm: string,
|
|
sggNm: string,
|
|
lclgvrnmntNm: string,
|
|
bscFctNm: string,
|
|
daddr: string,
|
|
fctCpc: number,
|
|
waterUsage: number,
|
|
swageChangePercent: number,
|
|
estimationSewage: number,
|
|
sewageInputYear: number,
|
|
sewageInputChungchun: number,
|
|
rgnNm: string,
|
|
rvbsn: string,
|
|
lgbsn: string,
|
|
mdmbsn: string,
|
|
msrDt: string,
|
|
}
|
|
export type modalTableType = { msrDt: string, waterUsage: number, swageChangePercent: number, estimationSewage: number };
|
|
export type SewageOccurDetailProps = {
|
|
cnt: number,
|
|
sum: number,
|
|
yr: string,
|
|
usage: number, // 일평균 유입량
|
|
cntWtrUsg: number, // 물사용량 일자수
|
|
sumWtrUsg: number, // 물사용량 합
|
|
avgWtrUsg: number, // 일평균 물사용량
|
|
monWtrUsg: number, // 월 물사용량
|
|
}
|
|
export type WtrUsgYmProps = {
|
|
bscFctCd: string, // 처리구역시설코드
|
|
levyYm: string, // 부과년월
|
|
wtrUsg: number, // 월별 물사용량(m³/월)
|
|
}
|
|
// 검색단
|
|
const LabelArray: string[] = ['구분', '시도', '시군구', '용량별', '시설명', '조회기간', '시설상태', '권역', '단위유역', '중권역', '환경청별'];
|
|
|
|
export interface ExcelType {
|
|
시설코드: string,
|
|
권역: string | '',
|
|
단위유역: string | '',
|
|
중권역: string | '',
|
|
환경청: string | '',
|
|
시도: string,
|
|
시군구: string,
|
|
시설명: string,
|
|
주소: string,
|
|
"시설용량(m³/일)": number,
|
|
"물사용량(m³/일)": number | '',
|
|
"오수전환율(%)": number | '',
|
|
"오수발생량추정(m³/일)": number | '',
|
|
"연간하수유입량(m³/일)": number | '',
|
|
"청천시하수유입량(m³/일)": number | '',
|
|
}
|
|
|
|
// 리스트 헤더
|
|
const upHeadList1: TableUpperProps[] = [
|
|
{ id: "A", title: "행정구역", row: 0, colSpan: 2 },
|
|
{ id: "sidoNm", title: "시도", row: 1, widthPercent: 8 },
|
|
{ id: "sggNm", title: "시군구", row: 1, widthPercent: 8 },
|
|
{ id: "bscFctNm", title: "시설명", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "daddr", title: "주소", row: 0, rowSpan: 2 },
|
|
{ id: "fctCpc", title: "시설용량(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "waterUsage", title: "물사용량(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "swageChangePercent", title: "오수전환율\n(%)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "estimationSewage", title: "오수발생량 추정\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "sewageInputYear", title: "연간 하수유입량\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "sewageInputChungchun", title: "청천시 하수유입량\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
];
|
|
|
|
const upHeadList2: TableUpperProps[] = [
|
|
{ id: "A", title: "유역", row: 0, colSpan: 3 },
|
|
{ id: "rvbsn", title: "권역", row: 1, widthPercent: 6 },
|
|
{ id: "lgbsn", title: "단위유역", row: 1, widthPercent: 6 },
|
|
{ id: "mdmbsn", title: "중권역", row: 1, widthPercent: 6 },
|
|
{ id: "bscFctNm", title: "시설명", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "daddr", title: "주소", row: 0, rowSpan: 2 },
|
|
{ id: "fctCpc", title: "시설용량(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "waterUsage", title: "물사용량(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "swageChangePercent", title: "오수전환율", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "estimationSewage", title: "오수발생량 추정\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "sewageInputYear", title: "연간 하수유입량\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "sewageInputChungchun", title: "청천시 하수유입량\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
];
|
|
|
|
const upHeadList3: TableUpperProps[] = [
|
|
{ id: "A", title: "유역", row: 0, colSpan: 3 },
|
|
{ id: "rvbsn", title: "권역", row: 1, widthPercent: 5 },
|
|
{ id: "lgbsn", title: "단위유역", row: 1, widthPercent: 5 },
|
|
{ id: "mdmbsn", title: "중권역", row: 1, widthPercent: 5 },
|
|
{ id: "rgnNm", title: "환경청", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "B", title: "행정구역", row: 0, colSpan: 2 },
|
|
{ id: "sidoNm", title: "시도", row: 1, widthPercent: 6 },
|
|
{ id: "sggNm", title: "시군구", row: 1, widthPercent: 6 },
|
|
{ id: "bscFctNm", title: "시설명", row: 0, rowSpan: 2, widthPercent: 8 },
|
|
{ id: "daddr", title: "주소", row: 0, rowSpan: 2 },
|
|
{ id: "fctCpc", title: "시설용량(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 6 },
|
|
{ id: "waterUsage", title: "물사용량(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 6 },
|
|
{ id: "swageChangePercent", title: "오수전환율", align: "right", row: 0, rowSpan: 2, widthPercent: 6 },
|
|
{ id: "estimationSewage", title: "오수발생량 추정\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 6 },
|
|
{ id: "sewageInputYear", title: "연간 하수유입량\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 6 },
|
|
{ id: "sewageInputChungchun", title: "청천시 하수유입량\n(m³/일)", align: "right", row: 0, rowSpan: 2, widthPercent: 6 },
|
|
];
|
|
|
|
const upHeadListSewageOccurDetail: TableUpperProps[] = [
|
|
{ id: "msrDt", title: "년월" },
|
|
{ id: "waterUsage", title: "물사용량(m³/일)", align: "right" },
|
|
{ id: "swageChangePercent", title: "오수전환율(%)", align: "right" },
|
|
{ id: "estimationSewage", title: "오수발생량 추정(m³/일)", row: 0, rowSpan: 2, align: "right" },
|
|
];
|
|
|
|
const sewageOccurList: SewageOccurProps[] = []
|
|
|
|
const tempSewageOccurList: modalTableType[] = []
|
|
|
|
/**
|
|
* yyyymm 형태의 문자열을 받아 해당 월의 일수를 반환
|
|
* @param {string} yyyymm - 예: "202502", "202412"
|
|
* @returns {number} 해당 월의 일수 (예: 28, 29, 30, 31)
|
|
*/
|
|
function getDaysInMonth(yyyymm) {
|
|
if (typeof yyyymm !== 'string' || yyyymm.length !== 6) {
|
|
throw new Error("입력은 'yyyymm' 형식의 문자열이어야 합니다. 예: '202502'");
|
|
}
|
|
|
|
const year = parseInt(yyyymm.slice(0, 4), 10); // "2025" -> 2025
|
|
const month = parseInt(yyyymm.slice(4, 6), 10); // "02" -> 2
|
|
|
|
if (isNaN(year) || isNaN(month) || month < 1 || month > 12) {
|
|
throw new Error("유효한 년/월이 아닙니다.");
|
|
}
|
|
|
|
// Date(year, month, 0) -> 전달의 마지막 날
|
|
// month에 '다음달'을 넣고, 일(day)에 0을 주면 해당 월의 마지막 날짜가 됨
|
|
return new Date(year, month, 0).getDate();
|
|
}
|
|
/**====================================
|
|
* Store - API
|
|
====================================*/
|
|
|
|
/*const fetchSewageOccurList = async (pageNo: number, pageSize: number, searchYear: string, partCd?: string, nameCd?: string, fcltCpct?: string, operationValue?: string, fcltyNm?: string) => {
|
|
// 20250701임시시
|
|
const tailStr = partCd ? '/'+ partCd + '/' + nameCd + '/' + fcltCpct + '/' + operationValue + (fcltyNm && fcltyNm !== '' ? '/' + fcltyNm : '') : '';
|
|
const url = '/fclt/flow/' + pageNo + '/' + pageSize + '/' + searchYear + tailStr;
|
|
const res = await getFetch('fo', url);
|
|
return { data: res.data, count: res.count }
|
|
|
|
const tailStr = partCd ? '/'+ partCd + '/' + nameCd + '/' + fcltCpct + '/' + operationValue + (fcltyNm && fcltyNm !== '' ? '/' + fcltyNm : '') : '';
|
|
const url = '/fclt/qlty/' + pageNo + '/' + pageSize + '/' + searchYear + tailStr;
|
|
const res = await getFetch('fo', url);
|
|
return { data: res.data, count: res.count }
|
|
}*/
|
|
|
|
// const fetchSweageOccurListFlow = async(fcltyCd : string, searchYear : string) => {
|
|
// const url = '/fclt/flow/' + fcltyCd + '/' + searchYear;
|
|
// const res = await getFetch('fo', url);
|
|
// return res;
|
|
// }
|
|
|
|
// 시설들 유량 정보 조회
|
|
export const fetchSweageOccurListFlow = async (searchYear: string | undefined, fcltCdList: string[]): Promise<SewageOccurProps | null> => {
|
|
try {
|
|
const res = await postFetch('fo', '/fclt/flow/' + searchYear, fcltCdList);
|
|
return res;
|
|
} catch (error) {
|
|
console.error('시설정보 오수발생량 상세 데이터를 가져오는데 실패했습니다:', error);
|
|
return null;
|
|
}
|
|
};
|
|
// 시설별 물사용량 정보 조회
|
|
export const fetchWtrUsgYmList = async (searchYear: string | undefined, fcltCdList: string[]): Promise<WtrUsgYmProps | null> => {
|
|
try {
|
|
const res = await postFetch('fo', '/fclt/flow/wtrUsgYm/' + searchYear, fcltCdList);
|
|
return res;
|
|
} catch (error) {
|
|
console.error('시설들 월별 물사용량 데이터를 가져오는데 실패했습니다:', error);
|
|
return null;
|
|
}
|
|
};
|
|
|
|
/**====================================
|
|
* Store - expaort
|
|
====================================*/
|
|
export type SewageOccurActions = {
|
|
searchSewageOccurList: (pageNo: number, pageSize: number, searchYear: string, part?: string, nameCd?: string, fcltCpct?: string, operationValue?: string, fcltyNm?: string) => void;
|
|
searchSewageOccurDetailList: (bscFctCd: string, searchYear: string, startYm?: string, endYm?: string) => void;
|
|
}
|
|
|
|
export type SewageOccurType = {
|
|
SewageOccurSearch: {
|
|
isInit: boolean;
|
|
labelArray: string[];
|
|
},
|
|
|
|
SewageOccur: {
|
|
isInit: boolean;
|
|
upHeadList1: TableUpperProps[];
|
|
upHeadList2: TableUpperProps[];
|
|
upHeadList3: TableUpperProps[];
|
|
sewageOccurList: SewageOccurProps[]; // Changed from facilityAreaProps to ProcessAreaProps
|
|
sewageOccurCount: number;
|
|
excelList: ExcelType[];
|
|
isLoading: boolean;
|
|
},
|
|
|
|
SewageOccurDetail: {
|
|
isInit: boolean;
|
|
upHeadListSewageOccurDetail: TableUpperProps[];
|
|
gridListSewageOccurDetail: modalTableType[];
|
|
}
|
|
}
|
|
|
|
export const sewageOccurInitState: SewageOccurType = {
|
|
SewageOccurSearch: {
|
|
isInit: false,
|
|
labelArray: LabelArray,
|
|
},
|
|
|
|
SewageOccur: {
|
|
isInit: false,
|
|
upHeadList1: upHeadList1,
|
|
upHeadList2: upHeadList2,
|
|
upHeadList3: upHeadList3,
|
|
sewageOccurList: sewageOccurList,
|
|
sewageOccurCount: 2,
|
|
excelList: [],
|
|
isLoading: true,
|
|
},
|
|
|
|
SewageOccurDetail: {
|
|
isInit: false,
|
|
upHeadListSewageOccurDetail: upHeadListSewageOccurDetail,
|
|
gridListSewageOccurDetail: tempSewageOccurList,
|
|
}
|
|
}
|
|
|
|
// 병렬 처리 제한용 헬퍼
|
|
// async function processInBatches(items, batchSize, callback) {
|
|
// const results:any = [];
|
|
// for (let i = 0; i < items.length; i += batchSize) {
|
|
// const batch = items.slice(i, i + batchSize);
|
|
// const batchResults = await Promise.all(batch.map(callback));
|
|
// results.push(...batchResults);
|
|
// }
|
|
// return results;
|
|
// }
|
|
|
|
export type SewageOccurStore = SewageOccurType & SewageOccurActions;
|
|
|
|
// Add type definitions for API responses
|
|
export type FlowDataItem = {
|
|
inflAmnt: string | number;
|
|
infoRnDay: string | number;
|
|
bscFctCd: string;
|
|
msrDt: string;
|
|
rainEffectDay?: number;
|
|
}
|
|
|
|
export type FlowResponse = {
|
|
data: FlowDataItem[];
|
|
count: number;
|
|
}
|
|
|
|
export const sewageOccurReducer: (set: any) => SewageOccurActions = (set: any) => {
|
|
return {
|
|
searchSewageOccurList: async (pageNo: number, pageSize: number, searchYear: string, part?: string, nameCd?: string, fcltCpct?: string, operationValue?: string, fcltyNm?: string) => {
|
|
const facilityInitData = await fetchFacilityListInit(pageNo, pageSize, part, nameCd, fcltCpct, operationValue, fcltyNm);
|
|
if (pageSize < 5000) {
|
|
set((state: SewageOccurType) => ({
|
|
...state,
|
|
SewageOccur: {
|
|
...state.SewageOccur,
|
|
sewageOccurList: [],
|
|
sewageOccurCount: facilityInitData.count,
|
|
excelList: [],
|
|
isLoading: true
|
|
},
|
|
}));
|
|
} else {
|
|
set((state: SewageOccurType) => ({
|
|
...state,
|
|
SewageOccur: {
|
|
...state.SewageOccur,
|
|
excelList: [],
|
|
isLoading: true
|
|
},
|
|
}));
|
|
}
|
|
|
|
const fcltylist = facilityInitData.data; // 시설목록
|
|
const fcltCdList: string[] = []; // 시설코드목록
|
|
const sewageOccurPropsList: SewageOccurProps[] = []; // 오수발생량시설목록
|
|
fcltylist.forEach(item => {
|
|
fcltCdList.push(item.bscFctCd);
|
|
sewageOccurPropsList.push({
|
|
bscFctCd: item.bscFctCd,
|
|
sidoNm: item.sido,
|
|
sggNm: item.gugun,
|
|
lclgvrnmntNm: '',
|
|
bscFctNm: item.bscFctNm,
|
|
daddr: item.daddr,
|
|
fctCpc: parseFloat(item.fctCpc.toString().replace(/,/g, '')),
|
|
waterUsage: 0,
|
|
swageChangePercent: 0,
|
|
estimationSewage: 0,
|
|
sewageInputYear: 0,
|
|
sewageInputChungchun: 0,
|
|
rgnNm: item.rgnNm,
|
|
rvbsn: item.rvbsn,
|
|
lgbsn: item.lgbsn,
|
|
mdmbsn: item.mdmbsn,
|
|
msrDt: '',
|
|
});
|
|
});
|
|
|
|
const soccurDetailRes: any = await fetchSweageOccurListFlow(searchYear, fcltCdList);
|
|
const wtrUsgYmRes: any = await fetchWtrUsgYmList(searchYear, fcltCdList);
|
|
// const wtrUsgMap : Record<string, number> = {};
|
|
// wtrUsgRes.data.forEach(fclt => {
|
|
// wtrUsgMap[fclt.bscFctCd] = fclt.wtrUsg;
|
|
// });
|
|
for (const item of sewageOccurPropsList) {
|
|
|
|
const detailList = soccurDetailRes?.data[item.bscFctCd];
|
|
const wtrUsgYmList = wtrUsgYmRes?.data[item.bscFctCd];
|
|
|
|
item.swageChangePercent = 90;
|
|
let sumChungcunDay = 0; // 청천일수
|
|
let chungcunSumFlow = 0;// 청천시 하수유입량
|
|
let totWaterUsage = 0; // 연간 하수유입량
|
|
let rainEffectDay = 0;
|
|
detailList?.forEach(item2 => {
|
|
|
|
if (item2.infoRnDay == null || item2.infoRnDay == 'x') item2.infoRnDay = 0;
|
|
if (item2.infoRnDay >= 3) {
|
|
rainEffectDay = 2;
|
|
} else {
|
|
rainEffectDay--;
|
|
}
|
|
if (rainEffectDay < 0) { //청천시
|
|
chungcunSumFlow += item2.inflAmnt && item2.inflAmnt !== 'x' ? Number(item2.inflAmnt.toString().trim()) : 0;//Number(item2.inflAmnt);
|
|
sumChungcunDay += 1;
|
|
}
|
|
totWaterUsage += Number(item2.inflAmnt);
|
|
});
|
|
|
|
let wtrUsgYearTotal = 0; // 연간 물사용량
|
|
let wtrUsgYearDays = 0; // 연간 물사용 일수
|
|
wtrUsgYmList?.forEach(item3 => {
|
|
const days = getDaysInMonth(item3.levyYm);
|
|
wtrUsgYearTotal += Number(item3.wtrUsg);
|
|
wtrUsgYearDays += days;
|
|
});
|
|
|
|
// console.log("totWaterUsage:", totWaterUsage);
|
|
const count = detailList ? detailList.length : 0;
|
|
const avg = count == 0 ? 0 : totWaterUsage / count; // 일평균 유입량
|
|
item.waterUsage = parseFloat((avg * 0.65).toFixed(2)); // 물사용량 = 일평균 유입량 * 65%
|
|
if (wtrUsgYearTotal > 0 && wtrUsgYearDays > 0) {
|
|
item.waterUsage = wtrUsgYearDays > 0 ? wtrUsgYearTotal / wtrUsgYearDays : 0; // 일평균 물사용량
|
|
}
|
|
item.sewageInputYear = parseFloat(avg.toFixed(2)); // 연간 하수유입량(m³/일)
|
|
item.sewageInputChungchun = parseFloat((chungcunSumFlow === 0 ? 0 : (chungcunSumFlow / sumChungcunDay)).toFixed(2)); // 청천시 하수유입량
|
|
item.estimationSewage = parseFloat((item.waterUsage * OSU_PERCENT).toFixed(2)); // 오수발생량 추정(m³/일)
|
|
if (item.bscFctCd === '11200PB001R') {
|
|
console.log('chungcunSumFlow:', chungcunSumFlow);
|
|
console.log('sumChungcunDay:', sumChungcunDay);
|
|
}
|
|
// 반올림 처리
|
|
["fctCpc", "waterUsage", "swageChangePercent", "estimationSewage", "sewageInputYear", "sewageInputChungchun"].forEach(
|
|
(key) => (item[key] = roundNumber(item[key], 0))
|
|
);
|
|
}
|
|
|
|
if (pageSize >= 5000) {
|
|
const excelDownList: ExcelType[] = [];
|
|
sewageOccurPropsList.forEach((item: SewageOccurProps) => {
|
|
excelDownList.push({
|
|
시설코드: item.bscFctCd,
|
|
권역: item.rvbsn,
|
|
단위유역: item.lgbsn,
|
|
중권역: item.mdmbsn,
|
|
환경청: item.rgnNm,
|
|
시설명: item.bscFctNm,
|
|
시도: item.sidoNm,
|
|
시군구: item.sggNm,
|
|
주소: item.daddr,
|
|
"시설용량(m³/일)": item.fctCpc,
|
|
"물사용량(m³/일)": item.waterUsage,
|
|
"오수전환율(%)": item.swageChangePercent,
|
|
"오수발생량추정(m³/일)": item.estimationSewage,
|
|
"연간하수유입량(m³/일)": item.sewageInputYear,
|
|
"청천시하수유입량(m³/일)": item.sewageInputChungchun,
|
|
});
|
|
});
|
|
set((state: SewageOccurType) => ({
|
|
...state,
|
|
SewageOccur: {
|
|
...state.SewageOccur,
|
|
excelList: excelDownList,
|
|
isLoading: false,
|
|
},
|
|
}));
|
|
} else {
|
|
set((state: SewageOccurType) => ({
|
|
...state,
|
|
SewageOccur: {
|
|
...state.SewageOccur,
|
|
sewageOccurList: sewageOccurPropsList,
|
|
sewageOccurCount: facilityInitData.count,
|
|
isLoading: false,
|
|
excelList: [],
|
|
},
|
|
}));
|
|
}
|
|
|
|
/* fetchSewageOccurList(pageNo, pageSize, searchYear, part, nameCd, fcltCpct, operationValue, fcltyNm).then(async (res) => {
|
|
const excelDownList: ExcelType[] = [];
|
|
const data = res.data;
|
|
// Promise.all을 사용하여 모든 비동기 작업이 완료될 때까지 기다림
|
|
const calData = await Promise.all(data.map(async (item: SewageOccurProps) => {
|
|
item.sidoNm = item.lclgvrnmntNm.split(' ')[0]?.toString() || '';
|
|
item.sggNm = item.lclgvrnmntNm.split(' ')[1]?.toString() || '';
|
|
item.fctCpc = parseFloat(item.fctCpc.toString().replace(/,/g, ''));
|
|
item.swageChangePercent = 90;
|
|
|
|
const bscFctCd = item.bscFctCd;
|
|
const res2 = await getFetch('fo', '/fclt/flow/' + bscFctCd + '/' + searchYear) as FlowResponse;
|
|
|
|
let sumChungcunDay = 0;
|
|
let chungcunSumFlow = 0;
|
|
let totWaterUsage = 0;
|
|
|
|
// 강우영향일 계산 (강우량이 3 초과이면 무조건 강우영향일)
|
|
const rainEffectData = CalcRainEffect(res2.data);
|
|
|
|
rainEffectData.forEach((item: FlowDataItem) => {
|
|
|
|
if(Number(item.rainEffectDay) === 0){
|
|
chungcunSumFlow += Number(item.inflAmnt);
|
|
sumChungcunDay += 1;
|
|
}
|
|
|
|
totWaterUsage += Number(item.inflAmnt);
|
|
});
|
|
const avg = totWaterUsage /res2.count;
|
|
item.waterUsage = parseFloat((avg * 0.65).toFixed(2));
|
|
item.sewageInputYear = parseFloat(avg.toFixed(2));
|
|
item.sewageInputChungchun = parseFloat((chungcunSumFlow===0?0:(chungcunSumFlow / sumChungcunDay)).toFixed(2));
|
|
item.estimationSewage = parseFloat((item.waterUsage * (item.swageChangePercent/100)).toFixed(2));
|
|
return item;
|
|
}));
|
|
|
|
calData.forEach((item: SewageOccurProps) => {
|
|
DataForm({ type: 'float0', column: 'fctCpc', item: item as unknown as Record<string, unknown> });
|
|
DataForm({ type: 'float0', column: 'waterUsage', item: item as unknown as Record<string, unknown> });
|
|
DataForm({ type: 'float0', column: 'swageChangePercent', item: item as unknown as Record<string, unknown> });
|
|
DataForm({ type: 'float0', column: 'estimationSewage', item: item as unknown as Record<string, unknown> });
|
|
DataForm({ type: 'float0', column: 'sewageInputYear', item: item as unknown as Record<string, unknown> });
|
|
DataForm({ type: 'float0', column: 'sewageInputChungchun', item: item as unknown as Record<string, unknown> });
|
|
});
|
|
|
|
if(pageSize>5000){
|
|
calData.forEach((item: SewageOccurProps) => {
|
|
excelDownList.push({
|
|
시설코드: item.bscFctCd,
|
|
권역: item.rvbsn,
|
|
단위유역: item.lgbsn,
|
|
중권역: item.mdmbsn,
|
|
환경청: item.rgnNm,
|
|
시설명: item.bscFctNm,
|
|
시도: item.sidoNm,
|
|
시군구: item.sggNm,
|
|
주소: item.daddr,
|
|
"시설용량(m³/일)": item.fctCpc,
|
|
"물사용량(m³/일)": item.waterUsage,
|
|
"오수전환율(%)": item.swageChangePercent,
|
|
"오수발생량추정(m³/일)": item.estimationSewage,
|
|
"연간하수유입량(m³/일)": item.sewageInputYear,
|
|
"청천시하수유입량(m³/일)": item.sewageInputChungchun,
|
|
});
|
|
});
|
|
}
|
|
// 조회 데이터 설정
|
|
set((state: any) => ({
|
|
...state,
|
|
SewageOccur: pageSize<5000?{
|
|
...state.SewageOccur,
|
|
sewageOccurList: calData,
|
|
sewageOccurCount: res.count,
|
|
isLoading : false,
|
|
}:{
|
|
...state.SewageOccur,
|
|
excelList: excelDownList,
|
|
isLoading : false,
|
|
},
|
|
}))
|
|
}); */
|
|
},
|
|
|
|
searchSewageOccurDetailList: async (bscFctCd: string, searchYear: string, startYm?: string, endYm?: string) => {
|
|
const fcltCdList = [bscFctCd];
|
|
const wtrUsgRes: any = await fetchWtrUsgYmList(searchYear, fcltCdList);
|
|
const res = await getFetch('fo', '/fclt/flow/' + bscFctCd + '/' + searchYear);
|
|
const monthData: SewageOccurDetailProps[] = [];
|
|
let tot = 0, cnt = 0;
|
|
|
|
if (startYm) {
|
|
res.data = res.data.filter((item: FlowDataItem) => {
|
|
const month = item.msrDt?.substring(0, 6);
|
|
return month >= startYm;
|
|
});
|
|
if (wtrUsgRes && wtrUsgRes.data && wtrUsgRes.data[bscFctCd]) {
|
|
wtrUsgRes.data = wtrUsgRes.data.filter((item: WtrUsgYmProps) => {
|
|
const month = item.levyYm?.substring(0, 6);
|
|
return month >= startYm;
|
|
});
|
|
}
|
|
}
|
|
if (endYm) {
|
|
res.data = res.data.filter((item: FlowDataItem) => {
|
|
const month = item.msrDt?.substring(0, 6);
|
|
return month <= endYm;
|
|
});
|
|
if (wtrUsgRes && wtrUsgRes.data && wtrUsgRes.data[bscFctCd]) {
|
|
wtrUsgRes.data = wtrUsgRes.data.filter((item: WtrUsgYmProps) => {
|
|
const month = item.levyYm?.substring(0, 6);
|
|
return month <= endYm;
|
|
});
|
|
}
|
|
}
|
|
|
|
// 유입량
|
|
res.data.forEach((item: FlowDataItem) => {
|
|
const month = item.msrDt?.substring(4, 6);
|
|
const monthIdx = month ? Number(month) - 1 : -1;
|
|
if (monthIdx >= 0) {
|
|
if (typeof monthData[monthIdx] === 'object') {
|
|
monthData[monthIdx].sum += Number(item.inflAmnt);
|
|
monthData[monthIdx].cnt++;
|
|
} else {
|
|
monthData[monthIdx] = {
|
|
cnt: 1, sum: Number(item.inflAmnt), yr: item.msrDt.substring(0, 4)
|
|
, usage: 0, cntWtrUsg: 0, sumWtrUsg: 0, avgWtrUsg: 0, monWtrUsg: 0
|
|
};
|
|
}
|
|
}
|
|
tot += Number(item.inflAmnt)
|
|
cnt++
|
|
});
|
|
|
|
// 물사용량
|
|
let totWtrUsg = 0;
|
|
let cntWtrUsg = 0;
|
|
if (wtrUsgRes && wtrUsgRes.data && wtrUsgRes.data[bscFctCd]) {
|
|
wtrUsgRes.data.forEach((item: WtrUsgYmProps) => {
|
|
const month = item.levyYm?.substring(4, 6);
|
|
const monthIdx = month ? Number(month) - 1 : -1;
|
|
if (monthIdx >= 0) {
|
|
if (typeof monthData[monthIdx] === 'object') {
|
|
monthData[monthIdx].sumWtrUsg += Number(item.wtrUsg);
|
|
monthData[monthIdx].cntWtrUsg += getDaysInMonth(item.levyYm);
|
|
}
|
|
}
|
|
totWtrUsg += Number(item.wtrUsg);
|
|
cntWtrUsg += getDaysInMonth(item.levyYm);
|
|
});
|
|
}
|
|
|
|
const tableData: modalTableType[] = []
|
|
|
|
let maxWaterUsage = 0;
|
|
let minWaterUsage = 9999999999;
|
|
let avgWaterUsage = 0;
|
|
monthData.forEach((item, index) => {
|
|
item.avgWtrUsg = item.sum / item.cnt * 0.65; // 일평균 물사용량 = 일평균유입수 * 0.65
|
|
if (item.sumWtrUsg > 0 && item.cntWtrUsg > 0) item.avgWtrUsg = item.sumWtrUsg / item.cntWtrUsg;
|
|
tableData.push({
|
|
msrDt: item.yr + '-' + (index + 1 >= 10 ? String(index + 1) : '0' + (index + 1)),
|
|
waterUsage: Math.round(item.avgWtrUsg * 1) / 1,
|
|
swageChangePercent: OSU_PERCENT * 100,//(Math.round((item.usage/item.usage*OSU_PERCENT) * 100) / 100) * 100,
|
|
estimationSewage: Math.round(item.avgWtrUsg * OSU_PERCENT * 1) / 1
|
|
})
|
|
if (item.avgWtrUsg > maxWaterUsage) {
|
|
maxWaterUsage = item.avgWtrUsg;
|
|
}
|
|
|
|
if (item.avgWtrUsg < minWaterUsage) {
|
|
minWaterUsage = item.avgWtrUsg;
|
|
}
|
|
|
|
});
|
|
avgWaterUsage = tot / cnt * 0.65
|
|
if (totWtrUsg > 0 && cntWtrUsg > 0) avgWaterUsage = totWtrUsg / cntWtrUsg;
|
|
|
|
const newData = [
|
|
{
|
|
msrDt: '평균',
|
|
waterUsage: roundNumber(Math.round(avgWaterUsage * 1) / 1, 0),
|
|
swageChangePercent: OSU_PERCENT * 100,
|
|
estimationSewage: roundNumber(Math.round(avgWaterUsage * OSU_PERCENT * 1) / 1, 0),
|
|
},
|
|
{
|
|
msrDt: '최대',
|
|
waterUsage: roundNumber(Math.round(maxWaterUsage * 100) / 100, 0),
|
|
swageChangePercent: OSU_PERCENT * 100,
|
|
estimationSewage: roundNumber(Math.round(maxWaterUsage * OSU_PERCENT * 1) / 1, 0),
|
|
},
|
|
{
|
|
msrDt: '최소',
|
|
waterUsage: roundNumber(Math.round(minWaterUsage * 100) / 100, 0),
|
|
swageChangePercent: OSU_PERCENT * 100,
|
|
estimationSewage: roundNumber(Math.round(minWaterUsage * OSU_PERCENT * 1) / 1, 0),
|
|
},
|
|
...tableData
|
|
]
|
|
|
|
set((state: SewageOccurType) => ({
|
|
...state,
|
|
SewageOccurDetail: {
|
|
...state.SewageOccurDetail,
|
|
gridListSewageOccurDetail: newData,
|
|
}
|
|
}))
|
|
},
|
|
}
|
|
} |