462 lines
14 KiB
JavaScript
462 lines
14 KiB
JavaScript
import Vue from "vue"
|
|
import Vuex from "vuex"
|
|
import {
|
|
Couchbase
|
|
} from "nativescript-couchbase-plugin"
|
|
import {
|
|
getFileAccess
|
|
} from "@nativescript/core"
|
|
const EnRecipesDB = new Couchbase("EnRecipes")
|
|
const userCategoriesDB = new Couchbase("userCategories")
|
|
const userYieldUnitsDB = new Couchbase("userYieldUnits")
|
|
const mealPlansDB = new Couchbase("mealPlans")
|
|
Vue.use(Vuex)
|
|
const defaultCategories = ["Appetizers", "Barbecue", "Beverages", "Breads", "Breakfast", "Desserts", "Dinner", "Drinks", "Healthy", "Lunch", "Main dishes", "Meat", "Noodles", "Pasta", "Poultry", "Rice", "Salads", "Sauces", "Seafood", "Side dishes", "Snacks", "Soups", "Undefined", "Vegan", "Vegetarian", ]
|
|
const defaultYieldUnits = ["Serving", "Piece", "Teaspoon", "Tablespoon", "Fluid Ounce", "Ounce", "Pound", "Gram", "Kilogram", "Cup", "Gallon", "Millilitre", "Litre", "Roll", "Patty", "Loaf", ]
|
|
export default new Vuex.Store({
|
|
state: {
|
|
recipes: [],
|
|
categories: [],
|
|
userCategories: [],
|
|
units: ["unit", "tsp", "dsp", "tbsp", "fl oz", "cup", "pt", "qt", "gal", "ml", "l", "oz", "lb", "mg", "g", "kg", "cm", "in", "leaf", "clove", "piece", "pinch", "drop", "dozen", "stick", "small", "medium", "large", ],
|
|
yieldUnits: [],
|
|
userYieldUnits: [],
|
|
mealPlans: [],
|
|
icon: {
|
|
home: "\ued3b",
|
|
heart: "\ued36",
|
|
heartOutline: "\uea6c",
|
|
label: "\ued51",
|
|
labelOutline: "\uea8b",
|
|
cog: "\ueca6",
|
|
info: "\ued49",
|
|
menu: "\ueac1",
|
|
search: "\ueb54",
|
|
sort: "\ueac2",
|
|
plus: "\ueb21",
|
|
plusCircle: "\ueb22",
|
|
close: "\uebe9",
|
|
image: "\uea7f",
|
|
food: "\ueb3e",
|
|
back: "\uea95",
|
|
save: "\uedeb",
|
|
camera: "\uec61",
|
|
share: "\uedf3",
|
|
edit: "\uedba",
|
|
theme: "\uecaa",
|
|
link: "\ueaa0",
|
|
file: "\ued02",
|
|
detail: "\ue9f9",
|
|
user: "\uee33",
|
|
trash: "\uee26",
|
|
donate: "\ueb4f",
|
|
trylater: "\uec31",
|
|
trylaterOutline: "\ue94a",
|
|
note: "\ueb04",
|
|
copy: "\ue9e6",
|
|
check: "\ue9a4",
|
|
telegram: "\ueec7",
|
|
time: "\ueba2",
|
|
item: "\ue99d",
|
|
step: "\ue948",
|
|
source: "\ueaa0",
|
|
export: "\ued07",
|
|
import: "\ued0c",
|
|
outline: "\ueb07",
|
|
calendar: "\uec55",
|
|
today: "\ue97c",
|
|
globe: "\uea5a",
|
|
},
|
|
currentComponent: "EnRecipes",
|
|
language: [{
|
|
locale: 'en',
|
|
title: 'English'
|
|
}, {
|
|
locale: 'de',
|
|
title: 'Deutsch'
|
|
}, {
|
|
locale: 'ta',
|
|
title: 'தமிழ்'
|
|
}, ]
|
|
},
|
|
mutations: {
|
|
initializeRecipes(state) {
|
|
EnRecipesDB.query({
|
|
select: []
|
|
}).forEach((recipe) => {
|
|
state.recipes.push(recipe)
|
|
})
|
|
},
|
|
initializeCategories(state) {
|
|
let isCategoriesStored = userCategoriesDB.query({
|
|
select: []
|
|
}).length
|
|
if (isCategoriesStored) {
|
|
state.userCategories = userCategoriesDB.getDocument("userCategories").userCategories
|
|
let categoriesWithRecipes = state.recipes.map((e) => e.category)
|
|
state.userCategories = state.userCategories.filter((e) => categoriesWithRecipes.includes(e))
|
|
} else {
|
|
userCategoriesDB.createDocument({
|
|
userCategories: []
|
|
}, "userCategories")
|
|
}
|
|
state.categories = [...defaultCategories, ...state.userCategories]
|
|
state.categories.sort()
|
|
},
|
|
initializeYieldUnits(state) {
|
|
let isYieldUnitsStored = userYieldUnitsDB.query({
|
|
select: []
|
|
}).length
|
|
if (isYieldUnitsStored) {
|
|
state.userYieldUnits = userYieldUnitsDB.getDocument("userYieldUnits").userYieldUnits
|
|
let yieldUnitsWithRecipes = state.recipes.map((e) => e.yield.unit)
|
|
state.userYieldUnits = state.userYieldUnits.filter((e) => yieldUnitsWithRecipes.includes(e))
|
|
} else {
|
|
userYieldUnitsDB.createDocument({
|
|
userYieldUnits: []
|
|
}, "userYieldUnits")
|
|
}
|
|
state.yieldUnits = [...defaultYieldUnits, ...state.userYieldUnits]
|
|
},
|
|
initializeMealPlans(state) {
|
|
let isMealPlansDBStored = mealPlansDB.query({
|
|
select: []
|
|
}).length
|
|
if (isMealPlansDBStored) {
|
|
state.mealPlans = mealPlansDB.getDocument("mealPlans").mealPlans
|
|
} else {
|
|
mealPlansDB.createDocument({
|
|
mealPlans: []
|
|
}, "mealPlans")
|
|
}
|
|
},
|
|
importRecipes(state, recipes) {
|
|
let localRecipesIDs, partition
|
|
if (state.recipes.length) {
|
|
localRecipesIDs = state.recipes.map((e) => e.id)
|
|
partition = recipes.reduce(
|
|
(result, recipe, i) => {
|
|
localRecipesIDs.indexOf(recipe.id) < 0 ? result[0].push(recipe) // create candidates
|
|
: result[1].push(recipe) // update candidates
|
|
return result
|
|
},
|
|
[
|
|
[],
|
|
[]
|
|
])
|
|
if (partition[0].length) createDocuments(partition[0])
|
|
if (partition[1].length) updateDocuments(partition[1])
|
|
} else {
|
|
createDocuments(recipes)
|
|
}
|
|
|
|
function getUpdatedData(data) {
|
|
return data.map((recipe) => {
|
|
let r = Object.assign({}, recipe)
|
|
if (r.timeRequired) {
|
|
r.prepTime = "00:00"
|
|
r.cookTime = r.timeRequired
|
|
delete r.timeRequired
|
|
}
|
|
return r
|
|
})
|
|
}
|
|
|
|
function createDocuments(data) {
|
|
data = getUpdatedData(data)
|
|
state.recipes = [...state.recipes, ...data]
|
|
data.forEach((recipe) => {
|
|
EnRecipesDB.createDocument(recipe, recipe.id)
|
|
})
|
|
}
|
|
|
|
function updateDocuments(data) {
|
|
data = getUpdatedData(data)
|
|
data.forEach((recipe) => {
|
|
let recipeIndex = state.recipes.map((e, i) => {
|
|
let d1 = new Date(e.lastModified).getTime()
|
|
let d2 = new Date(recipe.lastModified).getTime()
|
|
return e.id === recipe.id && d1 < d2 ? i : -1
|
|
}).filter((e) => e >= 0)[0]
|
|
if (recipeIndex >= 0) {
|
|
Object.assign(state.recipes[recipeIndex], recipe)
|
|
EnRecipesDB.updateDocument(recipe.id, recipe)
|
|
}
|
|
})
|
|
}
|
|
},
|
|
importCategories(state, categories) {
|
|
state.userCategories = new Set([...state.userCategories, ...categories])
|
|
userCategoriesDB.updateDocument("userCategories", {
|
|
userCategories: [...state.userCategories],
|
|
})
|
|
state.categories = [...defaultCategories, ...state.userCategories]
|
|
state.categories.sort()
|
|
},
|
|
importYieldUnits(state, yieldUnits) {
|
|
state.userYieldUnits = new Set([...state.userYieldUnits, ...yieldUnits])
|
|
userYieldUnitsDB.updateDocument("userYieldUnits", {
|
|
userYieldUnits: [...state.userYieldUnits],
|
|
})
|
|
state.yieldUnits = [...defaultYieldUnits, ...state.userYieldUnits]
|
|
},
|
|
importMealPlans(state, mealPlans) {
|
|
let newMealPlans = mealPlans.filter(
|
|
(e) => !state.mealPlans.some(
|
|
(f) => f.title === e.title && f.startDate === e.startDate))
|
|
state.mealPlans = [...state.mealPlans, ...newMealPlans]
|
|
mealPlansDB.updateDocument("mealPlans", {
|
|
mealPlans: [...state.mealPlans],
|
|
})
|
|
},
|
|
addRecipe(state, {
|
|
id,
|
|
recipe
|
|
}) {
|
|
state.recipes.push(recipe)
|
|
EnRecipesDB.createDocument(recipe, id)
|
|
},
|
|
addCategory(state, category) {
|
|
let lowercase = state.categories.map((e) => e.toLowerCase())
|
|
if (lowercase.indexOf(category.toLowerCase()) == -1) {
|
|
state.userCategories.push(category)
|
|
userCategoriesDB.updateDocument("userCategories", {
|
|
userCategories: [...state.userCategories],
|
|
})
|
|
state.categories = [...defaultCategories, ...state.userCategories]
|
|
state.categories.sort()
|
|
}
|
|
},
|
|
addYieldUnit(state, yieldUnit) {
|
|
let lowercase = state.yieldUnits.map((e) => e.toLowerCase())
|
|
if (lowercase.indexOf(yieldUnit.toLowerCase()) == -1) {
|
|
state.userYieldUnits.push(yieldUnit)
|
|
userYieldUnitsDB.updateDocument("userYieldUnits", {
|
|
userYieldUnits: [...state.userYieldUnits],
|
|
})
|
|
state.yieldUnits = [...defaultYieldUnits, ...state.userYieldUnits]
|
|
}
|
|
},
|
|
addMealPlan(state, {
|
|
event,
|
|
eventColor
|
|
}) {
|
|
state.mealPlans.push({
|
|
title: event.title,
|
|
startDate: event.startDate,
|
|
endDate: event.endDate,
|
|
eventColor,
|
|
})
|
|
mealPlansDB.updateDocument("mealPlans", {
|
|
mealPlans: [...state.mealPlans],
|
|
})
|
|
},
|
|
deleteRecipe(state, {
|
|
index,
|
|
id
|
|
}) {
|
|
getFileAccess().deleteFile(state.recipes[index].imageSrc)
|
|
state.recipes.splice(index, 1)
|
|
EnRecipesDB.deleteDocument(id)
|
|
state.recipes.forEach((e, i) => {
|
|
if (e.combinations.includes(id)) {
|
|
state.recipes[i].combinations.splice(e.combinations.indexOf(id), 1)
|
|
EnRecipesDB.updateDocument(state.recipes[i].id, state.recipes[i])
|
|
}
|
|
})
|
|
},
|
|
deleteMealPlan(state, {
|
|
title,
|
|
startDate
|
|
}) {
|
|
let mealPlan = state.mealPlans.filter((e) => {
|
|
console.log(e.startDate, startDate)
|
|
let sd = new Date(e.startDate).getTime()
|
|
return e.title === title && sd === startDate.getTime()
|
|
})[0]
|
|
let index = state.mealPlans.indexOf(mealPlan)
|
|
state.mealPlans.splice(index, 1)
|
|
state.mealPlans = [...state.mealPlans]
|
|
let mealPlans = mealPlansDB.getDocument("mealPlans").mealPlans
|
|
mealPlans.splice(index, 1)
|
|
mealPlansDB.updateDocument("mealPlans", {
|
|
mealPlans: [...mealPlans],
|
|
})
|
|
},
|
|
overwriteRecipe(state, {
|
|
id,
|
|
recipe
|
|
}) {
|
|
let index = state.recipes.indexOf(state.recipes.filter((e) => e.id === id)[0])
|
|
Object.assign(state.recipes[index], recipe)
|
|
EnRecipesDB.updateDocument(id, recipe)
|
|
},
|
|
toggleState(state, {
|
|
id,
|
|
recipe,
|
|
key,
|
|
setDate
|
|
}) {
|
|
let index = state.recipes.indexOf(state.recipes.filter((e) => e.id === id)[0])
|
|
state.recipes[index][key] = !state.recipes[index][key]
|
|
if (setDate) state.recipes[index].lastTried = new Date()
|
|
EnRecipesDB.updateDocument(id, recipe)
|
|
},
|
|
setRecipeAsTried(state, {
|
|
id,
|
|
recipe
|
|
}) {
|
|
let index = state.recipes.indexOf(state.recipes.filter((e) => e.id === id)[0])
|
|
state.recipes[index].tried = true
|
|
state.recipes[index].lastTried = new Date()
|
|
EnRecipesDB.updateDocument(id, recipe)
|
|
},
|
|
setLastTriedDate(state, index) {
|
|
state.recipes[index].lastTried = new Date()
|
|
EnRecipesDB.updateDocument(state.recipes[index].id, state.recipes[index])
|
|
},
|
|
renameCategory(state, {
|
|
current,
|
|
updated
|
|
}) {
|
|
let lowercase = state.categories.map((e) => e.toLowerCase())
|
|
if (lowercase.indexOf(updated.toLowerCase()) == -1) {
|
|
state.userCategories.push(updated)
|
|
userCategoriesDB.updateDocument("userCategories", {
|
|
userCategories: [...state.userCategories],
|
|
})
|
|
state.categories = [...defaultCategories, ...state.userCategories]
|
|
state.categories.sort()
|
|
}
|
|
state.recipes.forEach((e, i) => {
|
|
if (e.category == current) {
|
|
state.recipes[i].category = updated
|
|
EnRecipesDB.inBatch(() => {
|
|
EnRecipesDB.updateDocument(state.recipes[i].id, state.recipes[i])
|
|
})
|
|
}
|
|
})
|
|
},
|
|
setCurrentComponent(state, comp) {
|
|
state.currentComponent = comp
|
|
},
|
|
unSyncCombinations(state, {
|
|
id,
|
|
combinations
|
|
}) {
|
|
state.recipes.forEach((e, i) => {
|
|
if (combinations.includes(e.id)) {
|
|
state.recipes[i].combinations.splice(e.combinations.indexOf(id), 1)
|
|
EnRecipesDB.updateDocument(state.recipes[i].id, state.recipes[i])
|
|
}
|
|
})
|
|
},
|
|
},
|
|
actions: {
|
|
initializeRecipes({
|
|
commit
|
|
}) {
|
|
commit("initializeRecipes")
|
|
},
|
|
initializeCategories({
|
|
commit
|
|
}) {
|
|
commit("initializeCategories")
|
|
},
|
|
initializeYieldUnits({
|
|
commit
|
|
}) {
|
|
commit("initializeYieldUnits")
|
|
},
|
|
initializeMealPlans({
|
|
commit
|
|
}) {
|
|
commit("initializeMealPlans")
|
|
},
|
|
importRecipesAction({
|
|
commit
|
|
}, recipes) {
|
|
commit("importRecipes", recipes)
|
|
},
|
|
importCategoriesAction({
|
|
commit
|
|
}, categories) {
|
|
commit("importCategories", categories)
|
|
},
|
|
importYieldUnitsAction({
|
|
commit
|
|
}, yieldUnits) {
|
|
commit("importYieldUnits", yieldUnits)
|
|
},
|
|
importMealPlansAction({
|
|
commit
|
|
}, mealPlans) {
|
|
commit("importMealPlans", mealPlans)
|
|
},
|
|
addRecipeAction({
|
|
commit
|
|
}, recipe) {
|
|
commit("addRecipe", recipe)
|
|
},
|
|
addYieldUnitAction({
|
|
commit
|
|
}, yieldUnit) {
|
|
commit("addYieldUnit", yieldUnit)
|
|
},
|
|
addCategoryAction({
|
|
commit
|
|
}, category) {
|
|
commit("addCategory", category)
|
|
},
|
|
addMealPlanAction({
|
|
commit
|
|
}, mealPlan) {
|
|
commit("addMealPlan", mealPlan)
|
|
},
|
|
deleteMealPlanAction({
|
|
commit
|
|
}, mealPlan) {
|
|
commit("deleteMealPlan", mealPlan)
|
|
},
|
|
deleteRecipeAction({
|
|
commit
|
|
}, recipe) {
|
|
commit("deleteRecipe", recipe)
|
|
},
|
|
overwriteRecipeAction({
|
|
commit
|
|
}, updatedRecipe) {
|
|
commit("overwriteRecipe", updatedRecipe)
|
|
},
|
|
toggleStateAction({
|
|
commit
|
|
}, toggledRecipe) {
|
|
commit("toggleState", toggledRecipe)
|
|
},
|
|
setRecipeAsTriedAction({
|
|
commit
|
|
}, recipe) {
|
|
commit("setRecipeAsTried", recipe)
|
|
},
|
|
setLastTriedDateAction({
|
|
commit
|
|
}, index) {
|
|
commit("setLastTriedDate", index)
|
|
},
|
|
renameCategoryAction({
|
|
commit
|
|
}, category) {
|
|
commit("renameCategory", category)
|
|
},
|
|
setCurrentComponentAction({
|
|
commit
|
|
}, comp) {
|
|
commit("setCurrentComponent", comp)
|
|
},
|
|
unSyncCombinationsAction({
|
|
commit
|
|
}, combinations) {
|
|
commit("unSyncCombinations", combinations)
|
|
},
|
|
},
|
|
})
|