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 });
    }
  }
};