359 lines
10 KiB
JavaScript
359 lines
10 KiB
JavaScript
import { getCustomerPhysicalSignsByCusId } from "@/api/custom/customer";
|
|
import { dealHealthy } from "@/utils/healthyData";
|
|
import {
|
|
getRecipesApi,
|
|
updateDishesDetailApi,
|
|
addDishesApi,
|
|
deleteDishesApi,
|
|
addRecipesApi
|
|
} from "@/api/custom/recipes";
|
|
import { getDicts } from "@/api/system/dict/data";
|
|
import dayjs from "dayjs";
|
|
|
|
const oriState = {
|
|
cusId: undefined,
|
|
planId: undefined,
|
|
recipesId: undefined,
|
|
healthyData: {},
|
|
healthDataLoading: false,
|
|
healthyDataType: 0,
|
|
recipesData: [],
|
|
recipesDataLoading: false,
|
|
cusUnitOptions: [],
|
|
cusWeightOptions: [],
|
|
dishesTypeOptions: [],
|
|
typeOptions: [],
|
|
currentDay: -1,
|
|
startDate: "",
|
|
endDate: ""
|
|
};
|
|
|
|
const mutations = {
|
|
updateRecipesDishesDetail(state, payload) {
|
|
const tarDishes = state.recipesData[payload.num].dishes.find(
|
|
obj => obj.dishesId === payload.dishesId
|
|
);
|
|
if (tarDishes) {
|
|
const tarIgd = tarDishes.igdList.find(obj => obj.id === payload.igdId);
|
|
if (tarIgd) {
|
|
Object.keys(payload).forEach(key => {
|
|
tarIgd[key] = payload[key];
|
|
});
|
|
}
|
|
}
|
|
},
|
|
addRecipesDishes(state, payload) {
|
|
state.recipesData[payload.num].dishes.push(payload.data);
|
|
},
|
|
setCurrentDay(state, 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);
|
|
//
|
|
commit("updateStateData", payload);
|
|
//
|
|
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 });
|
|
});
|
|
getDicts("cus_dishes_type").then(response => {
|
|
commit("updateStateData", { dishesTypeOptions: response.data });
|
|
});
|
|
|
|
// 健康数据
|
|
if (payload.cusId) {
|
|
dispatch("getHealthyData", payload);
|
|
}
|
|
|
|
// 食谱数据
|
|
if (payload.recipesId) {
|
|
dispatch("getRecipesInfo", 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 }, payload) {
|
|
commit("updateStateData", {
|
|
recipesDataLoading: true
|
|
});
|
|
const recipesDataResult = await getRecipesApi(payload.recipesId);
|
|
let recipesData = undefined;
|
|
if (recipesDataResult.code === 200) {
|
|
recipesData = recipesDataResult.data.map(dayData => {
|
|
return {
|
|
id: dayData.id,
|
|
numDay: 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,
|
|
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
|
|
);
|
|
igdArr.push({
|
|
id: igdData.id,
|
|
name: igdData.name,
|
|
carbonRatio: igdData.carbonRatio,
|
|
fatRatio: igdData.fatRatio,
|
|
proteinRatio: igdData.proteinRatio,
|
|
cusUnit: tarDetail ? tarDetail.cus_unit : igdData.cusUnit,
|
|
cusWeight: tarDetail
|
|
? parseFloat(tarDetail.cus_weight)
|
|
: igdData.cusWeight,
|
|
weight: tarDetail
|
|
? parseFloat(tarDetail.weight)
|
|
: igdData.weight,
|
|
notRec: igdData.notRec,
|
|
rec: igdData.rec,
|
|
type: igdData.type
|
|
});
|
|
}
|
|
return igdArr;
|
|
}, [])
|
|
});
|
|
}
|
|
return arr;
|
|
}, [])
|
|
};
|
|
});
|
|
} 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,
|
|
planId,
|
|
menus: recipesData.map((menu, idx) => ({
|
|
date: dayjs(state.startDate)
|
|
.add(idx, "day")
|
|
.format("YYYY-MM-DD"),
|
|
cusId,
|
|
dishes: menu.dishes.map(dObj => ({
|
|
dishesId: dObj.dishesId,
|
|
type: dObj.type,
|
|
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;
|
|
commit("updateStateData", { recipesId });
|
|
dispatch("getRecipesInfo", { recipesId });
|
|
}
|
|
// console.log(params);
|
|
},
|
|
async addDishes({ commit, state }, payload) {
|
|
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) {
|
|
if (state.recipesId) {
|
|
const tarDishes = state.recipesData[payload.num].dishes.find(
|
|
obj => obj.dishesId === payload.dishesId
|
|
);
|
|
if (tarDishes) {
|
|
const mTarDishes = JSON.parse(JSON.stringify(tarDishes));
|
|
const tarIgd = mTarDishes.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);
|
|
|
|
const params = {
|
|
id: mTarDishes.id,
|
|
detail: mTarDishes.igdList.map(igd => ({
|
|
id: igd.id,
|
|
weight: igd.weight,
|
|
cus_unit: igd.cusUnit,
|
|
cus_weight: 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) {}
|
|
};
|
|
|
|
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
|
|
};
|