374 lines
10 KiB
TypeScript
374 lines
10 KiB
TypeScript
import { fetchType, getFetch, postFectch } from "@/components/lib/api";
|
|
import type { FcPrfType } from "@/app/store/prfmncReg/pbnstPrfmncReg/type";
|
|
import moment from "moment";
|
|
import type { CommonTableProps } from "../../common/type/header";
|
|
import type { WaterReuseFacility } from "../../ruseFcltMng/fcltSttn/pbnstSttn/type";
|
|
import {
|
|
pbnstSttNodeListExport,
|
|
pbnSttHeadListExport,
|
|
} from "../../ruseFcltMng/fcltSttn/pbnstSttn/headList";
|
|
import type { ReturnType } from "@common/business_components/ui";
|
|
import type { customPbnst, pubHasuType } from "../../ruseFcltMng/fcltReg/pbnstReg/type";
|
|
import { excelPbnstSttnParsing } from "../../ruseFcltMng/fcltSttn/pbnstSttn/excel";
|
|
|
|
const getCurrentYear = () => String(new Date().getFullYear());
|
|
|
|
const sumPrfUsage = (prfList: FcPrfType["prfList"] = []) => {
|
|
return prfList.reduce(
|
|
(acc, cur) => {
|
|
acc.inUsage +=
|
|
cur.wshwtr +
|
|
cur.coolUswtr +
|
|
cur.cleanUswtr +
|
|
cur.drwtUswtr +
|
|
cur.dltnUswtr +
|
|
cur.ithlRswtr +
|
|
cur.ithlEtcUswtr;
|
|
acc.outUsage +=
|
|
cur.cleanToilUswtr +
|
|
cur.resn +
|
|
cur.lndwtr +
|
|
cur.hydUswtr +
|
|
cur.ugwtChr +
|
|
cur.farmUswtr +
|
|
cur.rvrKeepUswtr +
|
|
cur.indstUswtr;
|
|
acc.total = acc.inUsage + acc.outUsage;
|
|
|
|
return acc;
|
|
},
|
|
{ total: 0, inUsage: 0, outUsage: 0 }
|
|
);
|
|
};
|
|
|
|
export const ruseMapSize = 15;
|
|
export type ruseMapState = {
|
|
ruseMap: {
|
|
ruseMapRes: WaterReuseFacility[];
|
|
ruseMapCount: number;
|
|
isInit: boolean;
|
|
fclts: string[];
|
|
ruseExcelList: [];
|
|
ruseDetailList: customPbnst[];
|
|
ruseMapHeadList: CommonTableProps[];
|
|
ruseMapNodeList: CommonTableProps[];
|
|
};
|
|
};
|
|
|
|
type ruseMapActions = {
|
|
getMapFlcts: () => void;
|
|
ruseMapInit: (
|
|
page: number,
|
|
total: number,
|
|
reurnValue: ReturnType,
|
|
year: string,
|
|
fclts: string[]
|
|
) => void;
|
|
ruseMapSearch: (
|
|
isExcel: boolean,
|
|
page: number,
|
|
total: number,
|
|
reurnValue: ReturnType,
|
|
year: string,
|
|
fclts: string[],
|
|
fcltNm: string
|
|
) => void;
|
|
getRuseMaplList: (bscFctCd: string) => void;
|
|
getRuseMaplListReturn: (bscFctCd: string) => Promise<customPbnst | undefined>;
|
|
};
|
|
|
|
export type ruseMapType = ruseMapState & ruseMapActions;
|
|
|
|
export const ruseMapStateExport: ruseMapState = {
|
|
ruseMap: {
|
|
isInit: false,
|
|
ruseMapRes: [],
|
|
ruseDetailList: [],
|
|
fclts: [],
|
|
ruseMapCount: 1,
|
|
ruseExcelList: [],
|
|
ruseMapHeadList: pbnSttHeadListExport,
|
|
ruseMapNodeList: pbnstSttNodeListExport,
|
|
},
|
|
};
|
|
|
|
const hasuListFetch = async (
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
searchNm: string | undefined,
|
|
year: string,
|
|
flcts: string[]
|
|
) => {
|
|
if (flcts.length === 0) {
|
|
return { data: [], count: 0 };
|
|
}
|
|
|
|
let url = ``;
|
|
let filteredFclt = flcts;
|
|
let nameCd = "0",
|
|
partStr = "A",
|
|
sidogunValue = "0";
|
|
|
|
switch (reurnValue.partValue) {
|
|
case "R":
|
|
if (reurnValue.regionValue !== "0") {
|
|
if (reurnValue.unitWaterShedValue === "0") nameCd = reurnValue.regionValue;
|
|
else if (reurnValue.middleRegionValue === "0") nameCd = reurnValue.unitWaterShedValue;
|
|
else nameCd = reurnValue.middleRegionValue;
|
|
}
|
|
partStr = reurnValue.partValue;
|
|
break;
|
|
default:
|
|
if (reurnValue.sidoValue && reurnValue.sidoValue !== "0") nameCd = reurnValue.sidoValue;
|
|
if (reurnValue.sigunValue && reurnValue.sigunValue !== "0") nameCd = reurnValue.sigunValue;
|
|
sidogunValue = nameCd;
|
|
partStr = reurnValue.envPartValue !== "0" ? reurnValue.envPartValue : "A";
|
|
break;
|
|
}
|
|
|
|
if (sidogunValue && sidogunValue !== "0") {
|
|
filteredFclt = flcts.filter((fclt: string) => {
|
|
return sidogunValue.length == 2
|
|
? fclt.slice(0, 2) === sidogunValue
|
|
: fclt.slice(0, 5) === sidogunValue;
|
|
});
|
|
}
|
|
|
|
url = `${partStr}/${nameCd}/0/1/SW`;
|
|
|
|
if (searchNm && searchNm.length > 0) {
|
|
url += "/" + searchNm;
|
|
}
|
|
|
|
if (filteredFclt.length === 0) {
|
|
return { data: [], count: 0 };
|
|
}
|
|
|
|
const pbnList = await postFectch(
|
|
`/prcsFclt/ruseInfo/1/${filteredFclt.length}/` + url,
|
|
filteredFclt,
|
|
fetchType.COMMON
|
|
);
|
|
|
|
const checkRuseFcltList = pbnList.data.map((item) => item.bscFctCd);
|
|
|
|
const getRuseList = await postFectch(
|
|
`/reuseFc/pubDetailList/${year}/${sidogunValue}/${page}/${total}`,
|
|
checkRuseFcltList,
|
|
fetchType.WR
|
|
);
|
|
const checkWrRegListRes = getRuseList.data;
|
|
|
|
const data: WaterReuseFacility[] = checkWrRegListRes
|
|
.map((item: FcPrfType) => {
|
|
const findData = pbnList.data.find(
|
|
(fclt: pubHasuType) =>
|
|
fclt.bscFctCd === item.pbnstRuseFcltId.substring(0, 11)
|
|
);
|
|
|
|
if (findData) {
|
|
const usage = item.prfList.reduce(
|
|
(acc, cur) => {
|
|
acc.inUsage +=
|
|
cur.wshwtr +
|
|
cur.coolUswtr +
|
|
cur.cleanUswtr +
|
|
cur.drwtUswtr +
|
|
cur.dltnUswtr +
|
|
cur.ithlRswtr +
|
|
cur.ithlEtcUswtr;
|
|
acc.outUsage +=
|
|
cur.cleanToilUswtr +
|
|
cur.resn +
|
|
cur.lndwtr +
|
|
cur.hydUswtr +
|
|
cur.ugwtChr +
|
|
cur.farmUswtr +
|
|
cur.rvrKeepUswtr +
|
|
cur.indstUswtr;
|
|
acc.total = acc.inUsage + acc.outUsage;
|
|
|
|
return acc;
|
|
},
|
|
{ total: 0, inUsage: 0, outUsage: 0 }
|
|
);
|
|
return {
|
|
rvbsn: findData?.rvbsn || "-",
|
|
lgbsn: findData?.lgbsn || "-",
|
|
mdmbsn: findData?.mdmbsn || "-",
|
|
rgnNm: findData?.rgnNm || "-",
|
|
sido: findData?.sido || "-",
|
|
gugun: findData?.gugun || "-",
|
|
bscFctNm: findData?.bscFctNm || "-",
|
|
efflWqltStndrdNm: findData?.efflWqltStndrdNm || "-",
|
|
fctCpc: Number(findData?.fctCpc) || 0,
|
|
tel: findData?.tel ?? "-",
|
|
ruseUtztnFcltNm: item?.ruseUtztnFcltNm || "-",
|
|
fcltCpct: item?.fcltCpct || "-",
|
|
splyExtraCpct: item?.splyExtraCpct || "-",
|
|
ruseCpct: item?.ruseCpct || "-",
|
|
pbnstRuseFcltId: item.pbnstRuseFcltId || "-",
|
|
usageTotal: usage?.total,
|
|
inUsage: usage?.inUsage,
|
|
outUsage: usage?.outUsage,
|
|
operMthd: item.operList[0]?.operMthd || "-",
|
|
rprtvBzenty: item.operList[0]?.rprtvBzenty,
|
|
bgngDt: moment(item.operList[0]?.bgngDt).format("YYYY-MM-DD") ?? "",
|
|
endDt: moment(item.operList[0]?.endDt).format("YYYY-MM-DD") ?? "",
|
|
searchNm: findData?.bscFctNm || "-",
|
|
searchPk: findData?.bscFctCd || "-",
|
|
prfList: item?.prfList ?? [],
|
|
};
|
|
}
|
|
})
|
|
.filter(Boolean);
|
|
|
|
return { data: data, count: getRuseList.count };
|
|
};
|
|
|
|
export const ruseMapActionsExport: (set: any) => ruseMapActions = (
|
|
set: any
|
|
) => {
|
|
return {
|
|
getMapFlcts: async () => {
|
|
const fclts = await getFetch(fetchType.WR, "/reuseFc/pubFc");
|
|
|
|
return set((state: ruseMapState) => ({
|
|
ruseMap: {
|
|
...state.ruseMap,
|
|
fclts: fclts,
|
|
},
|
|
}));
|
|
},
|
|
ruseMapInit: async (
|
|
page: number,
|
|
total: number,
|
|
reurnValue: ReturnType,
|
|
year: string,
|
|
fclts: string[]
|
|
) => {
|
|
try {
|
|
const ruseMapRes = await hasuListFetch(
|
|
String(page),
|
|
String(total),
|
|
reurnValue,
|
|
undefined,
|
|
year,
|
|
fclts
|
|
);
|
|
set((state: ruseMapState) => {
|
|
return {
|
|
...state,
|
|
ruseMap: {
|
|
...state.ruseMap,
|
|
ruseMapRes: ruseMapRes.data,
|
|
ruseMapCount: ruseMapRes.count,
|
|
isInit: false,
|
|
},
|
|
};
|
|
});
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
},
|
|
|
|
getRuseMaplList: async (bscFctCd: string) => {
|
|
try {
|
|
const ruseDetailList = await getFetch(
|
|
fetchType.WR,
|
|
`/reuseFc/pubFc/${bscFctCd}?year=${getCurrentYear()}`
|
|
);
|
|
const dataList = ruseDetailList.map((ruse) => {
|
|
return {
|
|
...ruse,
|
|
prfList: ruse.prfList ?? [],
|
|
};
|
|
});
|
|
console.log("/dataList ", dataList);
|
|
set((state: ruseMapState) => {
|
|
return {
|
|
...state,
|
|
ruseMap: {
|
|
...state.ruseMap,
|
|
ruseDetailList: dataList,
|
|
},
|
|
};
|
|
});
|
|
} catch (errorHasu) {
|
|
console.log(errorHasu);
|
|
throw errorHasu; // 호출부에서 catch 가능하도록
|
|
}
|
|
},
|
|
ruseMapSearch: async (
|
|
isExcel: boolean,
|
|
page: number,
|
|
total: number,
|
|
reurnValue: ReturnType,
|
|
year: string,
|
|
fclts: string[],
|
|
fcltNm: string
|
|
) => {
|
|
try {
|
|
const ruseMapRes = await hasuListFetch(
|
|
String(page),
|
|
String(total),
|
|
reurnValue,
|
|
fcltNm,
|
|
year,
|
|
fclts
|
|
);
|
|
if (isExcel) {
|
|
const ruseMapExcel = excelPbnstSttnParsing(ruseMapRes.data);
|
|
set((state: ruseMapState) => {
|
|
return {
|
|
...state,
|
|
ruseMap: {
|
|
...state.ruseMap,
|
|
ruseExcelList: ruseMapExcel,
|
|
},
|
|
};
|
|
});
|
|
} else {
|
|
set((state: ruseMapState) => {
|
|
return {
|
|
...state,
|
|
ruseMap: {
|
|
...state.ruseMap,
|
|
ruseMapRes: ruseMapRes.data,
|
|
ruseMapCount: ruseMapRes.count,
|
|
isInit: false,
|
|
},
|
|
};
|
|
});
|
|
}
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
},
|
|
|
|
getRuseMaplListReturn: async (bscFctCd: string) => {
|
|
try {
|
|
const ruseDetailList = await getFetch(
|
|
fetchType.WR,
|
|
`/reuseFc/pubFc/${bscFctCd}?year=${getCurrentYear()}`
|
|
);
|
|
const dataList = ruseDetailList.map((ruse) => {
|
|
const usage = sumPrfUsage(ruse.prfList ?? []);
|
|
return {
|
|
...ruse,
|
|
prfList: ruse.prfList ?? [],
|
|
inUsage: usage?.inUsage,
|
|
outUsage: usage?.outUsage,
|
|
|
|
};
|
|
});
|
|
return dataList
|
|
} catch (errorHasu) {
|
|
console.log(errorHasu);
|
|
throw errorHasu; // 호출부에서 catch 가능하도록
|
|
}
|
|
}
|
|
};
|
|
};
|