398 lines
11 KiB
TypeScript
398 lines
11 KiB
TypeScript
import type { CommonTableProps, TableUpperProps } from "@/app/store/common/type/header";
|
|
import type { FcPrfType } from "@/app/store/prfmncReg/pbnstPrfmncReg/type";
|
|
import { fetchType, getFetch, postFectch } from "@/components/lib/api";
|
|
import type { ReturnType } from "@common/business_components/ui";
|
|
import moment from "moment";
|
|
import { type z } from "zod";
|
|
import type { customPbnst, pubHasuType } from "../../fcltReg/pbnstReg/type";
|
|
import { controlHeadView } from "../rainSttn";
|
|
import type { sttnHeadListType } from "../rainSttn/headList";
|
|
import { excelPbnstSttnParsing } from "./excel";
|
|
import { pbnSttHeadListExport, pbnstSttNodeListExport, ruseDmdHeadListExport, ruseFcltHeadListExport, ruseFcltNodeListExport, ruseGuranteeHeadListExport, rusePplHeadListExport, ruseSplyHeadListExport } from "./headList";
|
|
import type { WaterReuseFacility } from "./type";
|
|
|
|
const pbnstSttHeadList = pbnSttHeadListExport;
|
|
const pbnstSttNodeList = pbnstSttNodeListExport;
|
|
|
|
export type pbnstSttnState = {
|
|
pbnstSttn: {
|
|
pbnstSttnRes: WaterReuseFacility[];
|
|
pbnstSearchData: WaterReuseFacility[];
|
|
pbnstSttHeadList: CommonTableProps[];
|
|
pbnstSttNodeList: CommonTableProps[];
|
|
pbnstDetail: customPbnst;
|
|
ruseFcltNodeList: TableUpperProps[]
|
|
ruseSplyHeadList: TableUpperProps[]
|
|
rusePplHeadList: TableUpperProps[]
|
|
ruseGuranteeHeadList: TableUpperProps[]
|
|
ruseDmdHeadList: TableUpperProps[]
|
|
ruseFcltHeadList: TableUpperProps[]
|
|
pbnstSttnResCount: number;
|
|
excelList: [];
|
|
fclts: string[]
|
|
isInit: boolean;
|
|
};
|
|
};
|
|
|
|
type pbnstSttnActions = {
|
|
pbnstChSttnHead: (headList: z.infer<typeof sttnHeadListType>) => void;
|
|
pbnstSttnSearch: (
|
|
isExcel: boolean,
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
searchNm: string | undefined,
|
|
year: string,
|
|
fclts: string[]
|
|
) => void;
|
|
getFlcts: () => void;
|
|
pbnSttnInit: (
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
year: string,
|
|
flcts: string[]
|
|
) => void;
|
|
getPbnStnDetail: (pbnstRuseFcltId: string) => void;
|
|
pbnNmSearch: (
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
searchNm: string | undefined,
|
|
year: string,
|
|
flcts: string[]
|
|
) => void;
|
|
resetPbnstDetail: () => void;
|
|
};
|
|
|
|
export type pbnstSttnType = pbnstSttnState & pbnstSttnActions;
|
|
|
|
export const pbnstSttnStateExport: pbnstSttnState = {
|
|
pbnstSttn: {
|
|
pbnstSttHeadList: pbnstSttHeadList,
|
|
pbnstSttNodeList: pbnstSttNodeList,
|
|
ruseFcltNodeList: ruseFcltNodeListExport,
|
|
ruseSplyHeadList: ruseSplyHeadListExport,
|
|
rusePplHeadList: rusePplHeadListExport,
|
|
ruseGuranteeHeadList: ruseGuranteeHeadListExport,
|
|
ruseDmdHeadList: ruseDmdHeadListExport,
|
|
ruseFcltHeadList: ruseFcltHeadListExport,
|
|
pbnstSttnRes: [],
|
|
pbnstSttnResCount: 1,
|
|
pbnstDetail: {} as customPbnst,
|
|
pbnstSearchData: [],
|
|
excelList: [],
|
|
fclts: [],
|
|
isInit: false,
|
|
},
|
|
};
|
|
|
|
export const hasuListFetch = async (
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
searchNm: string | undefined,
|
|
year: string,
|
|
flcts: string[]
|
|
) => {
|
|
let url = ``;
|
|
let filteredFclt = flcts;
|
|
const filterData = reurnValue.sigunValue !== '0' ? reurnValue.sigunValue : reurnValue.sidoValue
|
|
|
|
|
|
if(filterData !== '0')
|
|
filteredFclt= flcts.filter((fclt: string) => {
|
|
return filterData.length==2 ?fclt.slice(0, 2) === filterData:fclt.slice(0, 5) === filterData
|
|
})
|
|
if (reurnValue.partValue === "A") {
|
|
url += `${reurnValue.partValue}/${
|
|
// reurnValue.sidoValue ? reurnValue.sidoValue : reurnValue.sigunValue
|
|
reurnValue.sigunValue !== '0' ? reurnValue.sigunValue : reurnValue.sidoValue
|
|
}/0/1/SW`
|
|
|
|
if(filterData !== '0')
|
|
filteredFclt= flcts.filter((fclt: string) => {
|
|
return filterData.length==2 ?fclt.slice(0, 2) === filterData:fclt.slice(0, 5) === filterData
|
|
})
|
|
} else if (reurnValue.partValue === "R") {
|
|
url += `${reurnValue.partValue}/${reurnValue.regionValue
|
|
? reurnValue.regionValue
|
|
: reurnValue.unitWaterShedValue
|
|
? reurnValue.unitWaterShedValue
|
|
: reurnValue.middleRegionValue
|
|
}/0/1/SW`
|
|
} else if (reurnValue.partValue === 'G') {
|
|
url += `${reurnValue.envPartValue}/${reurnValue.sigunValue !== '0' ? reurnValue.sigunValue : reurnValue.sidoValue}/0/1/SW`
|
|
if(filterData !== '0')
|
|
filteredFclt= flcts.filter((fclt: string) => {
|
|
return filterData.length==2 ?fclt.slice(0, 2) === filterData:fclt.slice(0, 5) === filterData
|
|
})
|
|
|
|
} else {
|
|
url += `A/0/0/1/SW`
|
|
}
|
|
|
|
if (searchNm && searchNm?.length > 0) {
|
|
url += "/" + searchNm
|
|
}
|
|
|
|
const pbnList = await postFectch( `/prcsFclt/ruseInfo/1/${filteredFclt.length}/`+url, filteredFclt, fetchType.COMMON);
|
|
|
|
|
|
const checkRuseFcltList = searchNm && searchNm?.length > 0?pbnList.data.map((item)=> item.bscFctCd ):filteredFclt
|
|
const getRuseList = await postFectch(
|
|
`/reuseFc/pubDetailList/${year}/${filterData}/${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 +
|
|
cur.cleanToilUswtr +
|
|
cur.resn;
|
|
acc.outUsage +=
|
|
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 pbnstSttnActionsExport: (set: any) => pbnstSttnActions = (
|
|
set: any
|
|
) => {
|
|
return {
|
|
getFlcts: async () => {
|
|
const fclts = await getFetch(fetchType.WR, '/reuseFc/pubFc')
|
|
|
|
return set((state: pbnstSttnState) => ({
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
fclts: fclts
|
|
},
|
|
}));
|
|
},
|
|
pbnstChSttnHead: async (
|
|
headList: z.infer<typeof sttnHeadListType>
|
|
): Promise<void> => {
|
|
const changeNodeList = controlHeadView(headList, pbnstSttNodeList);
|
|
|
|
return set((state: pbnstSttnState) => ({
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
pbnstSttHeadList: headList,
|
|
pbnstSttNodeList: changeNodeList,
|
|
},
|
|
}));
|
|
},
|
|
pbnstSttnSearch: async (
|
|
isExcel: boolean,
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
searchNm: string | undefined,
|
|
year: string,
|
|
fclts: string[]
|
|
) => {
|
|
try {
|
|
|
|
const pbnstSttnRes = await hasuListFetch(
|
|
page,
|
|
total,
|
|
reurnValue,
|
|
searchNm,
|
|
year,
|
|
fclts,
|
|
);
|
|
|
|
// if (Number(total) > 9000) {
|
|
if (isExcel) {
|
|
const pbnstExcel = excelPbnstSttnParsing(pbnstSttnRes.data);
|
|
set((state: pbnstSttnState) => {
|
|
return {
|
|
...state,
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
excelList: pbnstExcel,
|
|
},
|
|
};
|
|
});
|
|
} else {
|
|
|
|
set((state: pbnstSttnState) => {
|
|
return {
|
|
...state,
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
pbnstSttnRes: pbnstSttnRes.data,
|
|
pbnstSttnResCount: pbnstSttnRes.count
|
|
// isInit: false,
|
|
},
|
|
};
|
|
});
|
|
}
|
|
} catch (erTxt) {
|
|
console.log("error", erTxt);
|
|
}
|
|
},
|
|
pbnSttnInit: async (
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
year: string,
|
|
fclts: string[]
|
|
) => {
|
|
try {
|
|
const pbnstSttnRes = await hasuListFetch(
|
|
page,
|
|
total,
|
|
reurnValue,
|
|
undefined,
|
|
year,
|
|
fclts
|
|
);
|
|
|
|
|
|
set((state: pbnstSttnState) => {
|
|
return {
|
|
...state,
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
pbnstSttnRes: pbnstSttnRes.data,
|
|
pbnstSttnResCount: pbnstSttnRes.count,
|
|
isInit: false,
|
|
pbnstDetail: {} as customPbnst
|
|
},
|
|
};
|
|
});
|
|
} catch (erTxt) {
|
|
console.log("error", erTxt);
|
|
}
|
|
},
|
|
resetPbnstDetail: async () => {
|
|
set((state: pbnstSttnState) => {
|
|
return {
|
|
...state,
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
pbnstDetail: {} as customPbnst
|
|
},
|
|
};
|
|
})
|
|
},
|
|
getPbnStnDetail: async (pbnstRuseFcltId: string) => {
|
|
try {
|
|
let pbnstDetail = await getFetch("wr", `/reuseFc/pubFc/${pbnstRuseFcltId}`);
|
|
if (pbnstDetail.length >= 0) {
|
|
pbnstDetail = pbnstDetail.find((item: customPbnst) => item.pbnstRuseFcltId === pbnstRuseFcltId)
|
|
}
|
|
set((state: pbnstSttnState) => {
|
|
return {
|
|
...state,
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
pbnstDetail: pbnstDetail,
|
|
},
|
|
};
|
|
});
|
|
} catch (errorHasu) {
|
|
console.log(errorHasu);
|
|
}
|
|
},
|
|
pbnNmSearch: async (
|
|
page: string,
|
|
total: string,
|
|
reurnValue: ReturnType,
|
|
searchNm: string | undefined,
|
|
year: string,
|
|
flcts: string[]
|
|
) => {
|
|
try {
|
|
|
|
const pbnstSttnRes = await hasuListFetch(
|
|
page,
|
|
total,
|
|
reurnValue,
|
|
searchNm,
|
|
year,
|
|
flcts
|
|
);
|
|
|
|
set((state: pbnstSttnState) => {
|
|
return {
|
|
...state,
|
|
pbnstSttn: {
|
|
...state.pbnstSttn,
|
|
pbnstSearchData: pbnstSttnRes.data,
|
|
pbnstSttnResCount: pbnstSttnRes.count,
|
|
},
|
|
};
|
|
});
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
},
|
|
};
|
|
};
|