Merge stores and handle fetching from router

web/src/store/index.js

@@ -1,5 +1,4 @@
 import { createStore, createLogger } from 'vuex'
-import dashboard from './modules/dashboard'
 import { LOGIN, LOGIN_SUCCESS, LOGOUT, TITLE } from './mutation-types'
 
 const store = createStore({
@@ -10,6 +9,12 @@ const store = createStore({
                 User: null
             },
             Budgets: {},
+            CurrentBudgetID: null,
+            Accounts: [],
+            CurrentAccountID: null,
+            Categories: [],
+            Transactions: [],
+            Assignments: []
         }
     },
     mutations: {
@@ -41,6 +46,18 @@ const store = createStore({
         },
         [LOGOUT](state, token) {
             state.Session = { Token: null, User: null }
+        },
+        setCurrentBudgetID(state, budgetid) {
+            state.CurrentBudgetID = budgetid;
+        },
+        setCurrentAccountID(state, accountid) {
+            state.CurrentAccountID = accountid;
+        },
+        setAccounts (state, accounts) {
+            state.Accounts = accounts;
+        },
+        setTransactions(state, transactions){
+            state.Transactions = transactions;
         }
     },
     actions: {
@@ -66,6 +83,56 @@ const store = createStore({
                 headers: getters.AuthHeaders,
                 body: body,
             })
+        },
+        /*async fetchDashboard ({state, commit, rootState}) {
+            const response = await fetch("/api/v1/dashboard", {
+                headers: {
+                    'Authorization': 'Bearer ' + rootState.Session.Token
+                }
+            })
+            const data = await response.json();
+            commit("setBudgets", data.Budgets);
+        },*/
+        async newBudget ({state, commit, dispatch, rootState}, budgetName) {
+            const result = await dispatch("POST", {
+                path: "/budget/new", 
+                body: JSON.stringify({name: budgetName})});
+            const response = await result.json();
+            commit("addBudget", response)
+        },
+        async setCurrentBudget({state, commit, dispatch, rootState}, budgetid) {
+            commit("setCurrentBudgetID", budgetid);
+
+            if (budgetid == null)
+                return
+
+            await dispatch("fetchBudget", budgetid)
+        },
+        async fetchBudget ({state, commit, dispatch, rootState}, budgetid) {
+            const result = await dispatch("GET", {path: "/budget/" + budgetid});
+            const response = await result.json();
+            return commit("setAccounts", response.Accounts);
+        },
+        async fetchAccount ({state, commit, rootState}, accountid) {
+            const result = await fetch("/api/v1/account/" + accountid + "/transactions", {
+                headers: {
+                    'Authorization': 'Bearer ' + rootState.Session.Token
+                }
+            });
+            const response = await result.json();
+            commit("setTransactions", response.Transactions);
+        },
+        async setCurrentAccount({state, commit, dispatch, getters}, {budgetid, accountid}) {
+            if (budgetid == null)
+                return
+
+            await dispatch("fetchBudget", budgetid);
+            commit("setCurrentAccountID", accountid);
+            if (accountid == null)
+                return
+
+            commit(TITLE, getters.CurrentAccount.Name);
+            await dispatch("fetchAccount", accountid)
         }
     },
     getters: {
@@ -76,30 +143,46 @@ const store = createStore({
             return {
                 'Authorization': 'Bearer ' + state.Session.Token
             }
+        },
+        CurrentBudget(state) {
+            if(state.CurrentBudgetID == null)
+                return {};
+
+            console.log(state.Budgets, state.CurrentBudgetID);
+            const budgets = state.Budgets.filter(x => x.ID == state.CurrentBudgetID);
+            if(budgets.length > 0)
+                return budgets[0];
+            
+            return {};
+        },
+        Accounts(state) {
+            return state.Accounts || [];
+        },
+        CurrentAccount(state) {
+            if(state.CurrentAccountID == null)
+                return {name: "Not found"};
+            return state.Accounts.filter(x => x.ID == state.CurrentAccountID)[0];
+        },
+        OnBudgetAccounts(state) {
+            return (state.Accounts || []).filter(x => x.OnBudget);
+        },
+        OffBudgetAccounts(state) {
+            return (state.Accounts || []).filter(x => !x.OnBudget);
+        },
+        Transactions(state) {
+            return (state.Transactions || []);
         }
     },
-    modules: {
-        dashboard
-    },
     plugins: [createLogger()]
 })
 
-store.subscribeAction({
-    after(mutation, state) {
-        switch(mutation.type){
-            case "setCurrentBudget":
-                return store.dispatch("fetchBudget", mutation.payload)
-            case "setCurrentAccount":
-                return store.dispatch("fetchAccount", mutation.payload)
-        }
-    }
-})
-
 store.subscribe((mutation, state) => {
     let persistedState = {
         Session: state.Session,
         Budgets: state.Budgets,
-        CurrentBudget: state.CurrentBudget
+        Accounts: state.Accounts,
+        CurrentBudgetID: state.CurrentBudgetID,
+        CurrentAccountID: state.CurrentAccountID
     }
     localStorage.setItem("store", JSON.stringify(persistedState));
 })

web/src/store/modules/dashboard.js

@@ -1,110 +0,0 @@
-import { TITLE } from "../mutation-types";
-
-const dashboard = {
-    state () {
-        return {
-            CurrentBudget: null,
-            Accounts: [],
-            CurrentAccount: null,
-            Categories: [],
-            Transactions: [],
-            Assignments: []
-        }
-    },
-    mutations: {
-        setCurrentBudget(state, budget) {
-            state.CurrentBudget = budget;
-        },
-        setAccounts (state, accounts) {
-            state.Accounts = accounts;
-        },
-        setCurrentAccount(state, account) {
-            state.CurrentAccount = account;
-        },
-        setTransactions(state, transactions){
-            state.Transactions = transactions;
-        }
-    },
-    getters: {
-        CurrentBudget(state) {
-            return state.CurrentBudget || {};
-        },
-        Accounts(state) {
-            return state.Accounts || [];
-        },
-        CurrentAccount(state) {
-            return state.CurrentAccount || {};
-        },
-        OnBudgetAccounts(state) {
-            return (state.Accounts || []).filter(x => x.OnBudget);
-        },
-        OffBudgetAccounts(state) {
-            return (state.Accounts || []).filter(x => !x.OnBudget);
-        },
-        Transactions(state) {
-            return (state.Transactions || []);
-        }
-    },
-    actions: {
-        /*async fetchDashboard ({state, commit, rootState}) {
-            const response = await fetch("/api/v1/dashboard", {
-                headers: {
-                    'Authorization': 'Bearer ' + rootState.Session.Token
-                }
-            })
-            const data = await response.json();
-            commit("setBudgets", data.Budgets);
-        },*/
-        async newBudget ({state, commit, rootState}, budgetName) {
-            fetch("/api/v1/budget/new", {
-                method: "POST",
-                body: JSON.stringify({name: budgetName}),
-                headers: {
-                    'Authorization': 'Bearer ' + rootState.Session.Token
-                }
-            })
-                .then(x => x.json())
-                .then(x => commit("addBudget", x));
-        },
-        async setCurrentBudget({state, commit, dispatch, rootState}, budgetid) {
-            for (const element of rootState.Budgets) {
-                if(element.ID != budgetid) 
-                    continue
-                
-                commit("setCurrentBudget", element);
-                break
-            }
-        },
-        async fetchBudget ({state, commit, rootState}, budgetid) {
-            const result = await fetch("/api/v1/budget/" + budgetid, {
-                headers: {
-                    'Authorization': 'Bearer ' + rootState.Session.Token
-                }
-            });
-            const response = await result.json();
-            return commit("setAccounts", response.Accounts);
-        },
-        async fetchAccount ({state, commit, rootState}, accountid) {
-            const result = await fetch("/api/v1/account/" + accountid + "/transactions", {
-                headers: {
-                    'Authorization': 'Bearer ' + rootState.Session.Token
-                }
-            });
-            const response = await result.json();
-            return commit("setTransactions", response.Transactions);
-        },
-        async setCurrentAccount({state, commit, dispatch}, {budgetid, accountid}) {
-            await dispatch("fetchBudget", budgetid);
-            for (const element of state.Accounts) {
-                if(element.ID != accountid) 
-                    continue
-                
-                commit("setCurrentAccount", element);
-                commit(TITLE, element.Name);
-                break
-            }
-        }
-    }
-}
-
-export default dashboard