juggl/juggl-vue/src/store/index.js

import Vue from "vue";
import Vuex from "vuex";
import { jugglService } from "@/services/juggl.service.js";

Vue.use(Vuex);

export default new Vuex.Store({
    state: {
        apiUrl: "https://juggl.giller.dev/api",
        projects: {},
        records: {},
        user: undefined,
        auth: undefined,
    },
    mutations: {
        setKey(state, key) {
            state.key = key;
        },
        setProjects(state, projects) {
            state.projects = projects;
        },
        setRecords(state, records) {
            state.records = records;
        },
        setUser(state, user) {
            state.user = user;
        },
        logout(state) {
            state.auth = undefined;
            // TODO: Doesn't work apparently
            localStorage.removeItem("apiKey");
            localStorage.removeItem("userId");
        },
        login(state, { apiKey, userId }) {
            state.auth = { apiKey: apiKey, userId: userId };
            localStorage.setItem("apiKey", apiKey);
            localStorage.setItem("userId", userId);
        },
    },
    getters: {
        runningRecords: (state) => {
            return Object.values(state.records).filter((record) => record.running);
        },
        finishedRecords: (state) => {
            return Object.values(state.records).filter(
                (record) => !record.running
            );
        },
        auth: (state) => state.auth,
        apiUrl: (state) => state.apiUrl,
        user: (state) => state.user,
        isLoggedIn: (state) => !!state.auth,
        records: (state) => state.records,
        projects: (state) => state.projects,
        projectIds: (state) => {
            var projectIds = [];
            Object.values(state.projects).forEach((project) => {
                projectIds.push(project.project_id);
            });
            return projectIds;
        },
        runningProjectIds: (state, getters) => {
            var runningProjectIds = [];
            Object.values(getters.runningRecords).forEach((record) => {
                var projectId = record.project_id;
                if (runningProjectIds.includes(runningProjectIds) === false) {
                    runningProjectIds.push(projectId);
                }
            });
            return runningProjectIds;
        },
        finishedProjectIds: (state, getters) => {
            var runningProjectIds = getters.runningProjectIds;
            return getters.projectIds.filter(
                (id) => !runningProjectIds.includes(id)
            );
        },
        finishedProjects: (state, getters) => {
            var ids = getters.finishedProjectIds;
            return Object.values(state.projects).filter((project) =>
                ids.includes(project.project_id)
            );
        },
        runningProjects: (state, getters) => {
            var ids = getters.runningProjectIds;
            return Object.values(state.projects).filter((project) =>
                ids.includes(project.project_id)
            );
        },
        getProjectById: (state, getters) => (id) => {
            return Object.values(getters.projects).find(
                (project) => project.project_id === id
            );
        },
        getRecordById: (state, getters) => (id) => {
            return Object.values(getters.records).find((record) => record.record_id === id);
        },
    },
    actions: {
        loadProjects({ commit }) {
            jugglService.getProjects().then((r) => {
                commit("setProjects", r.data.projects);
            });
        },
        loadAllRecords({ commit }) {
            jugglService.getRecords().then((r) => {
                commit("setRecords", r.data.records);
            });
        },
        loadRunningRecords({ commit, getters }) {
            jugglService.getRunningRecords().then((r) => {
                var allRecords = {
                    ...getters.finishedRecords,
                    ...r.data.records,
                };
                commit("setRecords", allRecords);
            });
        },
        login({ commit, getters }, { userId, apiKey }) {
            // Is already logged in?
            if (getters.isLoggedIn) {
                this.dispatch("logout");
            }

            commit("login", { apiKey: apiKey, userId: userId });

            return jugglService
                .getUser()
                .catch(() => {
                    this.dispatch("logout");
                    return false;
                })
                .then((r) => {
                    commit("setUser", r.data.users[0]);
                    return true;
                });
        },
        logout({ commit }) {
            commit("setUser", undefined);
            commit("logout");
        },
        endRecord(context, recordId) {
            return jugglService
                .endRecord(recordId)
                .catch(() => {
                    return false;
                })
                .then(() => {
                    this.dispatch("loadRunningRecords");
                    this.dispatch("loadProjects");
                    return true;
                });
        },
        startRecord(context, projectId) {
            return jugglService
                .startRecord(projectId)
                .catch(() => {
                    return false;
                })
                .then(() => {
                    this.dispatch("loadRunningRecords");
                    return true;
                });
        }
    },
});