juggl/src/store/modules/juggl.js

import { jugglService } from "@/services/juggl.service.js";

export const juggl = {
    state: {
        apiUrl: "https://juggl.giller.dev/api",
        projects: {},
        records: {},
        user: undefined,
        auth: undefined,
        usingFinishedRecords: false,
        usingRunningRecords: false,
        usingProjects: false,
        recordsLimit: 0,
    },
    mutations: {
        setKey(state, key) {
            state.key = key;
        },
        setProjects(state, projects) {
            state.projects = projects;
        },
        setRecords(state, records) {
            state.records = records;
        },
        usingFinishedRecords(state, using) {
            state.usingFinishedRecords = using;
        },
        usingRunningRecords(state, using) {
            state.usingRunningRecords = using;
        },
        usingProjects(state, using) {
            state.usingProjects = using;
        },
        setRecordsLimit(state, limit) {
            state.recordsLimit = limit;
        },
        setUser(state, user) {
            state.user = user;
        },
        logout(state) {
            state.auth = undefined;
            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 }) {
            return jugglService.getProjects().then((r) => {
                commit("setProjects", r.data.projects);
                commit("usingProjects", true);
            });
        },
        loadUser({ commit }) {
            return jugglService
                .getUser()
                .catch(() => {
                    return false;
                })
                .then((r) => {
                    commit("setUser", r.data.users[0]);
                    return true;
                });
        },
        loadRecords({ commit, state }, { limit, finished }) {
          commit("setRecordsLimit", limit);
          return jugglService.getRecords({ limit: state.recordsLimit, finished: finished }).then((r) => {
                commit("setRecords", r.data.records);
                commit("usingFinishedRecords", true);
                commit("usingRunningRecords", true);
            });
        },
        loadRunningRecords({ commit, getters }) {
            return jugglService.getRunningRecords().then((r) => {
                var allRecords = {
                    ...getters.finishedRecords,
                    ...r.data.records,
                };
                commit("setRecords", allRecords);
                commit("usingRunningRecords", true);
            });
        },
        login({ commit, getters }, { userId, apiKey }) {
            // Is already logged in?
            if (getters.isLoggedIn) {
                this.dispatch("logout");
            }

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

            return this.dispatch("loadUser")
                .catch(() => {
                    this.dispatch("logout");
                    return false;
                })
                .then((r) => {
                    if (r === false) {
                        this.dispatch("logout");
                        return false;
                    } else {
                        return true;
                    }
                });
        },
        logout({ commit }) {
            commit("setUser", undefined);
            commit("logout");
        },
        endRecord(context, recordId) {
            return jugglService
                .endRecord(recordId)
                .catch(() => {
                    return false;
                })
                .then(() => {
                    this.dispatch("updateState");
                    return true;
                });
        },
        addProject(context, { name }) {
            return jugglService
                .addProject(name)
                .catch(() => {
                    return false;
                })
                .then(() => {
                    this.dispatch("updateState");
                    return true;
                });
        },
        startRecord(context, projectId) {
            return jugglService
                .startRecord(projectId)
                .catch(() => {
                    return false;
                })
                .then(() => {
                    this.dispatch("updateState");
                    return true;
                });
        },
        removeRecord(context, recordId) {
            return jugglService
                .removeRecord(recordId)
                .catch(() => {
                    return false;
                })
                .then(() => {
                    this.dispatch("updateState");
                    return true;
                });
        },
        updateState({ state }) {
            if (state.usingProjects) {
                this.dispatch("loadProjects");
            }
            if (state.usingRunningRecords && state.usingFinishedRecords) {
                this.dispatch("loadRecords");
            } else if (state.usingRunningRecords) {
                this.dispatch("loadRunningRecords");
            }
            if (state.user === undefined) {
                this.dispatch("loadUser");
            }
        },
        loadSavedLogin({ commit }) {
            var userId = localStorage.getItem("userId");
            var apiKey = localStorage.getItem("apiKey");

            if (userId === undefined || apiKey === undefined) {
                return;
            }

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