517 lines
16 KiB
JavaScript
517 lines
16 KiB
JavaScript
import { getCustomerPhysicalSignsByCusId } from "@/api/custom/customer";
|
|
import { dealHealthy } from "@/utils/healthyData";
|
|
import {
|
|
getRecipesApi,
|
|
updateDishesDetailApi,
|
|
addDishesApi,
|
|
deleteDishesApi,
|
|
addRecipesApi
|
|
} from "@/api/custom/recipes";
|
|
import { getDishesMenuTypes } from "@/api/custom/dishes";
|
|
import { getRecipesTemplateDetail } from "@/api/custom/recipesTemplate";
|
|
import { getRecipesPlan, updateRecipesPlan } from "@/api/custom/recipesPlan";
|
|
import { getDicts } from "@/api/system/dict/data";
|
|
|
|
const oriState = {
|
|
cusId: undefined,
|
|
name: undefined,
|
|
planId: undefined,
|
|
temId: undefined,
|
|
recipesId: undefined,
|
|
healthyData: {},
|
|
healthDataLoading: false,
|
|
healthyDataType: 0,
|
|
recipesData: [],
|
|
recipesDataLoading: false,
|
|
cusUnitOptions: [],
|
|
cusWeightOptions: [],
|
|
typeOptions: [],
|
|
currentDay: -1,
|
|
startNum: 0,
|
|
endNum: 0,
|
|
reviewStatus: 0,
|
|
templateInfo: undefined,
|
|
copyData: undefined,
|
|
canCopyMenuTypes: [],
|
|
fontSize: parseInt(localStorage.getItem("fontSize")) || 12
|
|
};
|
|
|
|
const mutations = {
|
|
updateRecipesDishesDetail(state, payload) {
|
|
const { num, actionType } = payload;
|
|
const tarDishes = state.recipesData[num].dishes.find(
|
|
obj =>
|
|
obj.id === (actionType === "replace" ? payload.data.id : payload.id)
|
|
);
|
|
if (tarDishes) {
|
|
if (actionType === "replace") {
|
|
tarDishes.remark = "";
|
|
// 替换菜品,修改类型
|
|
Object.keys(payload.data).forEach(key => {
|
|
tarDishes[key] = payload.data[key];
|
|
});
|
|
} else if (actionType === "remark") {
|
|
tarDishes.remark = payload.remark;
|
|
} else if (actionType === "menuType") {
|
|
tarDishes.type = payload.type;
|
|
} else if (actionType === "weight" || actionType === "unit") {
|
|
const tarIgd = tarDishes.igdList.find(obj => obj.id === payload.igdId);
|
|
if (tarIgd) {
|
|
payload.weight && (tarIgd.weight = payload.weight);
|
|
payload.cusWeight && (tarIgd.cusWeight = payload.cusWeight);
|
|
payload.cusUnit && (tarIgd.cusUnit = payload.cusUnit);
|
|
}
|
|
} else if (actionType === "delIgd") {
|
|
tarDishes.igdList = tarDishes.igdList.filter(
|
|
igd => igd.id !== payload.igdId
|
|
);
|
|
}
|
|
}
|
|
},
|
|
updateFontSize(state, payload) {
|
|
state.fontSize = payload.fontSize;
|
|
localStorage.setItem("fontSize", payload.fontSize);
|
|
},
|
|
addRecipesDishes(state, payload) {
|
|
state.recipesData[payload.num].dishes.push(payload.data);
|
|
},
|
|
setCurrentDay(state, payload) {
|
|
if (state.currentDay !== payload.currentDay) {
|
|
state.currentDay = payload.currentDay;
|
|
}
|
|
},
|
|
resetCurrentDay(state, payload) {
|
|
// console.log(payload);
|
|
state.currentDay =
|
|
payload.currentDay === state.currentDay ? -1 : payload.currentDay;
|
|
},
|
|
deleteSomeDayDishes(state, payload) {
|
|
// console.log(payload);
|
|
state.recipesData[payload.num].dishes = state.recipesData[
|
|
payload.num
|
|
].dishes.filter(obj => obj.id !== payload.id);
|
|
},
|
|
updateStateData(state, payload) {
|
|
Object.keys(payload).forEach(key => {
|
|
state[key] = payload[key];
|
|
});
|
|
},
|
|
setDate(state, payload) {
|
|
state.startDate = payload.startDate;
|
|
state.endDate = payload.endDate;
|
|
},
|
|
clean(state) {
|
|
// console.log("clean");
|
|
Object.keys(oriState).forEach(key => {
|
|
state[key] = oriState[key];
|
|
});
|
|
}
|
|
};
|
|
|
|
const actions = {
|
|
async init({ commit, dispatch }, payload) {
|
|
//
|
|
// console.log(payload);
|
|
const planResponse = await getRecipesPlan(payload.planId);
|
|
const {
|
|
startNumDay,
|
|
endNumDay,
|
|
recipesId,
|
|
cusId,
|
|
reviewStatus
|
|
} = planResponse.data;
|
|
commit("updateStateData", {
|
|
cusId,
|
|
recipesId,
|
|
reviewStatus,
|
|
temId: payload.temId,
|
|
planId: payload.planId,
|
|
startNum: startNumDay,
|
|
endNum: endNumDay
|
|
});
|
|
getDicts("cus_cus_unit").then(response => {
|
|
commit("updateStateData", { cusUnitOptions: response.data });
|
|
});
|
|
getDicts("cus_cus_weight").then(response => {
|
|
commit("updateStateData", { cusWeightOptions: response.data });
|
|
});
|
|
getDicts("cus_dishes_type").then(response => {
|
|
commit("updateStateData", { typeOptions: response.data });
|
|
});
|
|
|
|
return new Promise((res, rej) => {
|
|
// 健康数据
|
|
if (cusId) {
|
|
dispatch("getHealthyData", { cusId }).catch(err => rej(err));
|
|
}
|
|
|
|
// 模板信息
|
|
if (payload.temId) {
|
|
dispatch("getRecipesTemplate", payload).catch(err => rej(err));
|
|
}
|
|
|
|
// 食谱数据
|
|
if (recipesId) {
|
|
dispatch("getRecipesInfo", { recipesId }).catch(err => rej(err));
|
|
}
|
|
});
|
|
},
|
|
async getRecipesTemplate({ commit, state }, { temId }) {
|
|
const response = await getRecipesTemplateDetail(temId);
|
|
if (response.code === 200) {
|
|
commit("updateStateData", {
|
|
templateInfo: response.data
|
|
});
|
|
}
|
|
},
|
|
async updateReviewStatus({ commit, state }, payload) {
|
|
const response = await updateRecipesPlan({
|
|
id: state.planId,
|
|
reviewStatus: payload.reviewStatus
|
|
});
|
|
if (response.code === 200) {
|
|
commit("updateStateData", payload);
|
|
}
|
|
},
|
|
async getHealthyData({ commit }, payload) {
|
|
commit("updateStateData", { healthDataLoading: true });
|
|
const healthyDataResult = await getCustomerPhysicalSignsByCusId(
|
|
payload.cusId
|
|
);
|
|
let healthyData = undefined,
|
|
healthyDataType = 0;
|
|
if (healthyDataResult.code === 200) {
|
|
if (!healthyDataResult.data.customerHealthy) {
|
|
throw new Error("客户还没填写健康评估表");
|
|
}
|
|
healthyDataType = healthyDataResult.data.type;
|
|
healthyData = dealHealthy(healthyDataResult.data.customerHealthy);
|
|
} else {
|
|
throw new Error(healthyDataResult.msg);
|
|
}
|
|
commit("updateStateData", {
|
|
healthDataLoading: false,
|
|
healthyDataType,
|
|
healthyData
|
|
});
|
|
},
|
|
async getRecipesInfo({ commit, state }, payload) {
|
|
commit("updateStateData", {
|
|
recipesDataLoading: true
|
|
});
|
|
const recipesDataResult = await getRecipesApi(payload.recipesId);
|
|
let recipesData = [];
|
|
if (recipesDataResult.code === 200) {
|
|
const { endNum, startNum, recipesId } = state;
|
|
// 计算
|
|
let length = endNum - startNum;
|
|
recipesData = recipesDataResult.data.reduce((outArr, dayData, idx) => {
|
|
if (!recipesId || length >= idx) {
|
|
outArr.push({
|
|
id: dayData.id,
|
|
numDay: !recipesId ? startNum + idx : dayData.numDay,
|
|
dishes: dayData.dishes.reduce((arr, cur) => {
|
|
if (
|
|
cur.dishesId > -1 &&
|
|
cur.name &&
|
|
cur.igdList.length > 0 &&
|
|
cur.type !== "0"
|
|
) {
|
|
arr.push({
|
|
id: cur.id,
|
|
dishesId: cur.dishesId,
|
|
name: cur.name,
|
|
menuId: cur.menuId,
|
|
methods: cur.methods,
|
|
remark: cur.remark,
|
|
type: cur.type,
|
|
isMain: cur.isMain,
|
|
igdList: cur.igdList.reduce((igdArr, igdData) => {
|
|
if (igdData.id > 0) {
|
|
const tarDetail = cur.detail.find(
|
|
obj => obj.id === igdData.id
|
|
);
|
|
if (tarDetail) {
|
|
igdArr.push({
|
|
id: igdData.id,
|
|
name: igdData.name,
|
|
carbonRatio: igdData.carbonRatio,
|
|
fatRatio: igdData.fatRatio,
|
|
proteinRatio: igdData.proteinRatio,
|
|
cusUnit: tarDetail.cus_unit,
|
|
cusWeight: tarDetail.cus_weight,
|
|
weight: parseFloat(tarDetail.weight),
|
|
notRec: igdData.notRec,
|
|
rec: igdData.rec,
|
|
type: igdData.type
|
|
});
|
|
}
|
|
}
|
|
return igdArr;
|
|
}, [])
|
|
});
|
|
}
|
|
return arr;
|
|
}, [])
|
|
});
|
|
}
|
|
return outArr;
|
|
}, []);
|
|
} else {
|
|
throw new Error(recipesDataResult.msg);
|
|
}
|
|
commit("updateStateData", { recipesDataLoading: false, recipesData });
|
|
},
|
|
async saveRecipes({ commit, dispatch, state }, payload) {
|
|
const { recipesData, cusId, planId } = state;
|
|
const params = {
|
|
cusId: payload.cusId !== undefined ? payload.cusId : cusId,
|
|
planId: payload.planId || planId,
|
|
menus: recipesData.map((menu, idx) => ({
|
|
numDay: menu.numDay,
|
|
cusId,
|
|
dishes: menu.dishes.map(dObj => ({
|
|
dishesId: dObj.dishesId,
|
|
type: dObj.type,
|
|
remark: dObj.remark,
|
|
detail: dObj.igdList.map(igd => ({
|
|
id: igd.id,
|
|
weight: igd.weight,
|
|
cus_unit: igd.cusUnit,
|
|
cus_weight: igd.cusWeight
|
|
}))
|
|
}))
|
|
}))
|
|
};
|
|
|
|
const result = await addRecipesApi(params);
|
|
if (result.code === 200) {
|
|
const recipesId = result.data;
|
|
if (!payload.planId) {
|
|
// 非保存模板
|
|
commit("updateStateData", { recipesId });
|
|
dispatch("getRecipesInfo", { recipesId });
|
|
}
|
|
payload.callback &&
|
|
payload.callback({
|
|
name: state.name,
|
|
planId: state.planId
|
|
});
|
|
}
|
|
// console.log(params);
|
|
},
|
|
async addDishes({ commit, state }, payload) {
|
|
// console.log(payload);
|
|
const tarDishesList = state.recipesData[payload.num].dishes.filter(
|
|
obj => obj.type === payload.data.type
|
|
);
|
|
if (tarDishesList.some(obj => obj.dishesId === payload.data.dishesId)) {
|
|
return new Promise((res, rej) =>
|
|
rej(`目标餐类已有相同的菜品「${payload.data.name}」`)
|
|
);
|
|
}
|
|
if (state.recipesId) {
|
|
const tarRecipesObj = state.recipesData[payload.num];
|
|
if (tarRecipesObj && payload.data) {
|
|
const { dishesId, type, igdList } = payload.data;
|
|
const params = {
|
|
type,
|
|
dishesId,
|
|
menuId: tarRecipesObj.id,
|
|
detail: igdList.map(igd => ({
|
|
id: igd.id,
|
|
weight: igd.weight,
|
|
cus_unit: igd.cusUnit,
|
|
cus_weight: igd.cusWeight
|
|
}))
|
|
};
|
|
const result = await addDishesApi(params);
|
|
if (result.code === 200) {
|
|
payload.menuId = tarRecipesObj.id;
|
|
// 更新id
|
|
payload.data.id = result.data;
|
|
commit("addRecipesDishes", payload);
|
|
}
|
|
}
|
|
// console.log(result);
|
|
} else {
|
|
commit("addRecipesDishes", payload);
|
|
}
|
|
},
|
|
async updateDishes({ commit, state }, payload) {
|
|
const { num, actionType } = payload;
|
|
if (actionType === "replace") {
|
|
const tarDishesList = state.recipesData[payload.num].dishes.filter(
|
|
obj => obj.type === payload.data.type
|
|
);
|
|
if (tarDishesList.some(obj => obj.dishesId === payload.data.dishesId)) {
|
|
return new Promise((res, rej) =>
|
|
rej(`目标餐类已有相同的菜品「${payload.data.name}」`)
|
|
);
|
|
}
|
|
}
|
|
// console.log(payload);
|
|
if (state.recipesId) {
|
|
const tarDishes = state.recipesData[num].dishes.find(
|
|
obj =>
|
|
obj.id === (actionType === "replace" ? payload.data.id : payload.id)
|
|
);
|
|
if (tarDishes) {
|
|
const mTarDishes = JSON.parse(JSON.stringify(tarDishes));
|
|
const params = {
|
|
id: mTarDishes.id
|
|
};
|
|
if (actionType === "menuType") {
|
|
// 修改餐类
|
|
params.type = payload.type;
|
|
} else if (actionType === "remark") {
|
|
params.remark = payload.remark;
|
|
} else if (actionType === "replace") {
|
|
params.dishesId = payload.data.dishesId;
|
|
params.remark = "";
|
|
params.detail = payload.data.igdList.map(igd => ({
|
|
id: igd.id,
|
|
weight: igd.weight,
|
|
cus_unit: igd.cusUnit,
|
|
cus_weight: igd.cusWeight
|
|
}));
|
|
} else if (actionType === "delIgd") {
|
|
// 删除某食材
|
|
params.detail = mTarDishes.igdList.reduce((arr, igd) => {
|
|
if (igd.id !== payload.igdId) {
|
|
arr.push({
|
|
id: igd.id,
|
|
weight: igd.weight,
|
|
cus_unit: igd.cusUnit,
|
|
cus_weight: igd.cusWeight
|
|
});
|
|
}
|
|
return arr;
|
|
}, []);
|
|
} else if (actionType === "unit" || actionType === "weight") {
|
|
// 修改食材
|
|
params.detail = mTarDishes.igdList.map(igd => {
|
|
const isTarIgd = igd.id === payload.igdId;
|
|
return {
|
|
id: igd.id,
|
|
weight: isTarIgd && payload.weight ? payload.weight : igd.weight,
|
|
cus_unit:
|
|
isTarIgd && payload.cusUnit ? payload.cusUnit : igd.cusUnit,
|
|
cus_weight:
|
|
isTarIgd && payload.cusWeight
|
|
? payload.cusWeight
|
|
: igd.cusWeight
|
|
};
|
|
});
|
|
}
|
|
const result = await updateDishesDetailApi(params);
|
|
if (result.code === 200) {
|
|
commit("updateRecipesDishesDetail", payload);
|
|
}
|
|
}
|
|
} else {
|
|
commit("updateRecipesDishesDetail", payload);
|
|
}
|
|
},
|
|
async deleteDishes({ commit, state }, payload) {
|
|
if (state.recipesId) {
|
|
const tarDishes = state.recipesData[payload.num].dishes.find(
|
|
obj => obj.id === payload.id
|
|
);
|
|
if (tarDishes) {
|
|
const result = await deleteDishesApi(tarDishes.id);
|
|
if (result.code === 200) {
|
|
commit("deleteSomeDayDishes", payload);
|
|
}
|
|
// console.log(params);
|
|
}
|
|
} else {
|
|
commit("deleteSomeDayDishes", payload);
|
|
}
|
|
},
|
|
async deleteMenu({ commit }, payload) {},
|
|
async setCopyData({ commit, state }, payload) {
|
|
return new Promise(async (res, rej) => {
|
|
const tarDishes = state.recipesData[payload.num].dishes.find(
|
|
obj => obj.id === payload.id
|
|
);
|
|
if (tarDishes) {
|
|
const response = await getDishesMenuTypes(tarDishes.dishesId);
|
|
if (response.code === 200) {
|
|
commit("updateStateData", {
|
|
copyData: tarDishes,
|
|
canCopyMenuTypes: response.data.type.split(",")
|
|
});
|
|
res("复制成功");
|
|
} else {
|
|
rej("复制失败");
|
|
}
|
|
} else {
|
|
rej("复制失败");
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
const getters = {
|
|
analyseData: state => {
|
|
if (!state.recipesData.length) {
|
|
return [];
|
|
}
|
|
const datas =
|
|
state.currentDay > -1
|
|
? [state.recipesData[state.currentDay]]
|
|
: state.recipesData;
|
|
|
|
const nutriData = datas.map(data =>
|
|
data.dishes.reduce(
|
|
(obj, cur) => {
|
|
cur.igdList.forEach(igd => {
|
|
obj.pWeight += (igd.weight / 100) * igd.proteinRatio;
|
|
obj.pHeat = obj.pWeight * 4;
|
|
obj.fWeight += (igd.weight / 100) * igd.fatRatio;
|
|
obj.fHeat = obj.fWeight * 9;
|
|
obj.cWeight += (igd.weight / 100) * igd.carbonRatio;
|
|
obj.cHeat = obj.cWeight * 4;
|
|
});
|
|
return obj;
|
|
},
|
|
{
|
|
name: `第${data.numDay}天`,
|
|
pWeight: 0,
|
|
fWeight: 0,
|
|
cWeight: 0,
|
|
pHeat: 0,
|
|
fHeat: 0,
|
|
cHeat: 0
|
|
}
|
|
)
|
|
);
|
|
// console.log(nutriData);
|
|
return nutriData;
|
|
},
|
|
cusUnitDict: state =>
|
|
state.cusUnitOptions.reduce((obj, cur) => {
|
|
obj[cur.dictValue] = cur.dictLabel;
|
|
return obj;
|
|
}, {}),
|
|
cusWeightDict: state =>
|
|
state.cusWeightOptions.reduce((obj, cur) => {
|
|
obj[cur.dictValue] = cur.dictLabel;
|
|
return obj;
|
|
}, {}),
|
|
typeDict: state =>
|
|
state.typeOptions.reduce((obj, cur) => {
|
|
obj[cur.dictValue] = cur.dictLabel;
|
|
return obj;
|
|
}, {})
|
|
};
|
|
|
|
export default {
|
|
namespaced: true,
|
|
state: Object.assign({}, oriState),
|
|
mutations,
|
|
actions,
|
|
getters
|
|
};
|