ami/tl-vikunja
1
0
Fork 0
Code

feat: namespaces store with composition api (#2607)

Browse Source 
Co-authored-by: Dominik Pschenitschni <mail@celement.de>
Reviewed-on: https://kolaente.dev/vikunja/frontend/pulls/2607
Reviewed-by: konrad <k@knt.li>
Co-authored-by: Dominik Pschenitschni <dpschen@noreply.kolaente.de>
Co-committed-by: Dominik Pschenitschni <dpschen@noreply.kolaente.de>
This commit is contained in:
Dominik Pschenitschni 2022-10-31 20:40:55 +00:00 committed by konrad
parent a50eca852f
commit 0832184222
1 changed files with 188 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

361
src/stores/namespaces.ts
View File

@ -1,3 +1,4 @@
import {computed, readonly, ref} from 'vue'
import {defineStore, acceptHMRUpdate} from 'pinia' import {defineStore, acceptHMRUpdate} from 'pinia'
import NamespaceService from '../services/namespace' import NamespaceService from '../services/namespace'
@ -9,210 +10,224 @@ import {useListStore} from '@/stores/lists'
const {add, remove, search, update} = createNewIndexer('namespaces', ['title', 'description']) const {add, remove, search, update} = createNewIndexer('namespaces', ['title', 'description'])
export interface NamespaceState { export const useNamespaceStore = defineStore('namespace', () => {
namespaces: INamespace[] const listStore = useListStore()
isLoading: boolean,
}
export const useNamespaceStore = defineStore('namespace', { const isLoading = ref(false)
state: (): NamespaceState => ({ // FIXME: should be object with id as key
isLoading: false, const namespaces = ref<INamespace[]>([])
// FIXME: should be object with id as key
namespaces: [],
}),
getters: {
getListAndNamespaceById: (state) => (listId: IList['id'], ignorePseudoNamespaces = false) => {
for (const n in state.namespaces) {
if (ignorePseudoNamespaces && state.namespaces[n].id < 0) { const getListAndNamespaceById = computed(() => (listId: IList['id'], ignorePseudoNamespaces = false) => {
continue for (const n in namespaces.value) {
}
for (const l in state.namespaces[n].lists) { if (ignorePseudoNamespaces && namespaces.value[n].id < 0) {
if (state.namespaces[n].lists[l].id === listId) { continue
return { }
list: state.namespaces[n].lists[l],
namespace: state.namespaces[n], for (const l in namespaces.value[n].lists) {
} if (namespaces.value[n].lists[l].id === listId) {
return {
list: namespaces.value[n].lists[l],
namespace: namespaces.value[n],
} }
} }
} }
return null }
}, return null
})
getNamespaceById: state => (namespaceId: INamespace['id']) => { const getNamespaceById = computed(() => (namespaceId: INamespace['id']) => {
return state.namespaces.find(({id}) => id == namespaceId) || null return namespaces.value.find(({id}) => id == namespaceId) || null
}, })
searchNamespace() { const searchNamespace = computed(() => {
return (query: string) => ( return (query: string) => (
search(query) search(query)
?.filter(value => value > 0) ?.filter(value => value > 0)
.map(this.getNamespaceById) .map(getNamespaceById.value)
.filter(n => n !== null) .filter(n => n !== null)
|| [] || []
) )
}, })
},
actions: {
setIsLoading(isLoading: boolean) {
this.isLoading = isLoading
},
setNamespaces(namespaces: INamespace[]) { function setIsLoading(newIsLoading: boolean) {
this.namespaces = namespaces isLoading.value = newIsLoading
namespaces.forEach(n => { }
add(n)
// Check for each list in that namespace if it has a subscription and set it if not function setNamespaces(newNamespaces: INamespace[]) {
n.lists.forEach(l => { namespaces.value = newNamespaces
if (l.subscription === null || l.subscription.entity !== 'list') { newNamespaces.forEach(n => {
l.subscription = n.subscription add(n)
}
})
})
},
setNamespaceById(namespace: INamespace) {
const namespaceIndex = this.namespaces.findIndex(n => n.id === namespace.id)
if (namespaceIndex === -1) {
return
}
if (!namespace.lists || namespace.lists.length === 0) {
namespace.lists = this.namespaces[namespaceIndex].lists
}
// Check for each list in that namespace if it has a subscription and set it if not // Check for each list in that namespace if it has a subscription and set it if not
namespace.lists.forEach(l => { n.lists.forEach(l => {
if (l.subscription === null || l.subscription.entity !== 'list') { if (l.subscription === null || l.subscription.entity !== 'list') {
l.subscription = namespace.subscription l.subscription = n.subscription
} }
}) })
})
}
this.namespaces[namespaceIndex] = namespace function setNamespaceById(namespace: INamespace) {
update(namespace) const namespaceIndex = namespaces.value.findIndex(n => n.id === namespace.id)
},
setListInNamespaceById(list: IList) { if (namespaceIndex === -1) {
for (const n in this.namespaces) { return
// We don't have the namespace id on the list which means we need to loop over all lists until we find it. }
// FIXME: Not ideal at all - we should fix that at the api level.
if (this.namespaces[n].id === list.namespaceId) { if (!namespace.lists || namespace.lists.length === 0) {
for (const l in this.namespaces[n].lists) { namespace.lists = namespaces.value[namespaceIndex].lists
if (this.namespaces[n].lists[l].id === list.id) { }
const namespace = this.namespaces[n]
namespace.lists[l] = list // Check for each list in that namespace if it has a subscription and set it if not
this.namespaces[n] = namespace namespace.lists.forEach(l => {
return if (l.subscription === null || l.subscription.entity !== 'list') {
} l.subscription = namespace.subscription
}
})
namespaces.value[namespaceIndex] = namespace
update(namespace)
}
function setListInNamespaceById(list: IList) {
for (const n in namespaces.value) {
// We don't have the namespace id on the list which means we need to loop over all lists until we find it.
// FIXME: Not ideal at all - we should fix that at the api level.
if (namespaces.value[n].id === list.namespaceId) {
for (const l in namespaces.value[n].lists) {
if (namespaces.value[n].lists[l].id === list.id) {
const namespace = namespaces.value[n]
namespace.lists[l] = list
namespaces.value[n] = namespace
return
} }
} }
} }
}, }
}
addNamespace(namespace: INamespace) { function addNamespace(namespace: INamespace) {
this.namespaces.push(namespace) namespaces.value.push(namespace)
add(namespace) add(namespace)
}, }
removeNamespaceById(namespaceId: INamespace['id']) { function removeNamespaceById(namespaceId: INamespace['id']) {
for (const n in this.namespaces) { for (const n in namespaces.value) {
if (this.namespaces[n].id === namespaceId) { if (namespaces.value[n].id === namespaceId) {
remove(this.namespaces[n]) remove(namespaces.value[n])
this.namespaces.splice(n, 1) namespaces.value.splice(n, 1)
return
}
}
},
addListToNamespace(list: IList) {
for (const n in this.namespaces) {
if (this.namespaces[n].id === list.namespaceId) {
this.namespaces[n].lists.push(list)
return
}
}
},
removeListFromNamespaceById(list: IList) {
for (const n in this.namespaces) {
// We don't have the namespace id on the list which means we need to loop over all lists until we find it.
// FIXME: Not ideal at all - we should fix that at the api level.
if (this.namespaces[n].id === list.namespaceId) {
for (const l in this.namespaces[n].lists) {
if (this.namespaces[n].lists[l].id === list.id) {
this.namespaces[n].lists.splice(l, 1)
return
}
}
}
}
},
async loadNamespaces() {
const cancel = setModuleLoading(this)
const namespaceService = new NamespaceService()
try {
// We always load all namespaces and filter them on the frontend
const namespaces = await namespaceService.getAll({}, {is_archived: true}) as INamespace[]
this.setNamespaces(namespaces)
// Put all lists in the list state
const lists = namespaces.flatMap(({lists}) => lists)
const listStore = useListStore()
listStore.setLists(lists)
return namespaces
} finally {
cancel()
}
},
loadNamespacesIfFavoritesDontExist() {
// The first or second namespace should be the one holding all favorites
if (this.namespaces[0].id === -2 || this.namespaces[1]?.id === -2) {
return return
} }
return this.loadNamespaces() }
}, }
removeFavoritesNamespaceIfEmpty() { function addListToNamespace(list: IList) {
if (this.namespaces[0].id === -2 && this.namespaces[0].lists.length === 0) { for (const n in namespaces.value) {
this.namespaces.splice(0, 1) if (namespaces.value[n].id === list.namespaceId) {
namespaces.value[n].lists.push(list)
return
} }
}, }
}
async deleteNamespace(namespace: INamespace) { function removeListFromNamespaceById(list: IList) {
const cancel = setModuleLoading(this) for (const n in namespaces.value) {
const namespaceService = new NamespaceService() // We don't have the namespace id on the list which means we need to loop over all lists until we find it.
// FIXME: Not ideal at all - we should fix that at the api level.
try { if (namespaces.value[n].id === list.namespaceId) {
const response = await namespaceService.delete(namespace) for (const l in namespaces.value[n].lists) {
this.removeNamespaceById(namespace.id) if (namespaces.value[n].lists[l].id === list.id) {
return response namespaces.value[n].lists.splice(l, 1)
} finally { return
cancel() }
}
} }
}, }
}
async createNamespace(namespace: INamespace) { async function loadNamespaces() {
const cancel = setModuleLoading(this) const cancel = setModuleLoading(this, setIsLoading)
const namespaceService = new NamespaceService()
try { const namespaceService = new NamespaceService()
const createdNamespace = await namespaceService.create(namespace) try {
this.addNamespace(createdNamespace) // We always load all namespaces and filter them on the frontend
return createdNamespace const namespaces = await namespaceService.getAll({}, {is_archived: true}) as INamespace[]
} finally { setNamespaces(namespaces)
cancel()
} // Put all lists in the list state
}, const lists = namespaces.flatMap(({lists}) => lists)
},
listStore.setLists(lists)
return namespaces
} finally {
cancel()
}
}
function loadNamespacesIfFavoritesDontExist() {
// The first or second namespace should be the one holding all favorites
if (namespaces.value[0].id === -2 || namespaces.value[1]?.id === -2) {
return
}
return loadNamespaces()
}
function removeFavoritesNamespaceIfEmpty() {
if (namespaces.value[0].id === -2 && namespaces.value[0].lists.length === 0) {
namespaces.value.splice(0, 1)
}
}
async function deleteNamespace(namespace: INamespace) {
const cancel = setModuleLoading(this, setIsLoading)
const namespaceService = new NamespaceService()
try {
const response = await namespaceService.delete(namespace)
removeNamespaceById(namespace.id)
return response
} finally {
cancel()
}
}
async function createNamespace(namespace: INamespace) {
const cancel = setModuleLoading(this, setIsLoading)
const namespaceService = new NamespaceService()
try {
const createdNamespace = await namespaceService.create(namespace)
addNamespace(createdNamespace)
return createdNamespace
} finally {
cancel()
}
}
return {
isLoading: readonly(isLoading),
namespaces: readonly(namespaces),
getListAndNamespaceById,
getNamespaceById,
searchNamespace,
setNamespaces,
setNamespaceById,
setListInNamespaceById,
addNamespace,
removeNamespaceById,
addListToNamespace,
removeListFromNamespaceById,
loadNamespaces,
loadNamespacesIfFavoritesDontExist,
removeFavoritesNamespaceIfEmpty,
deleteNamespace,
createNamespace,
}
}) })
// support hot reloading // support hot reloading