flaschengeist-frontend/src/plugins/balance/store/balance.ts

import { Module, MutationTree, ActionTree, GetterTree } from 'vuex';
//import store, { StateInterface } from 'src/store';
import store, { StateInterface } from 'src/store';
import { axios } from 'src/boot/axios';
import { AxiosResponse } from 'axios';

interface BalanceResponse {
  balance: number;
  credit: number;
  debit: number;
}

export interface BalancesResponse extends BalanceResponse {
  userid: string;
}

export interface TransactionsResponse {
  transactions: Array<FG.Transaction>;
  count?: number;
}

export interface UserBalance extends BalanceResponse {
  limit: number | null;
}

export interface BalanceInterface {
  balances: Map<string, UserBalance>;
  shortcuts: Array<number>;
  transactions: Array<FG.Transaction>;
  loading: number;
}

//export interface StateInterfaceBalance extends StateInterface {
export interface StateInterfaceBalance {
  balance: BalanceInterface;
}

const state: BalanceInterface = {
  balances: new Map<string, UserBalance>(),
  shortcuts: [],
  transactions: [],
  loading: 0,
};

function fixTransaction(t: FG.Transaction) {
  t.time = new Date(t.time);
}

const mutations: MutationTree<BalanceInterface> = {
  setBalance(state, data: { userid: string; balance: BalanceResponse }) {
    state.balances.set(
      data.userid,
      Object.assign({ limit: state.balances.get(data.userid)?.limit || null }, data.balance)
    );
  },
  changeBalance(state, data: { userid: string; amount: number }) {
    const user = <UserBalance>state.balances.get(data.userid);
    if (data.amount < 0) user.debit += data.amount;
    else user.credit += data.amount;
    user.balance += data.amount;
  },
  setLimit(state, data: { userid: string; limit: number | null }) {
    if (state.balances.has(data.userid))
      (<UserBalance>state.balances.get(data.userid)).limit = data.limit;
    else state.balances.set(data.userid, { balance: 0, debit: 0, credit: 0, limit: data.limit });
  },
  setLoading(state, data = true) {
    if (data) state.loading += 1;
    else state.loading -= 1;
  },
  setShortcuts(state, data: Array<number>) {
    state.shortcuts.splice(0, state.shortcuts.length, ...data);
  },
  addTransaction(state, data: FG.Transaction) {
    state.transactions.push(data);
  },
  addTransactions(state, data: [FG.Transaction]) {
    data.forEach((transaction) => {
      if (!state.transactions.find((t) => t.id == transaction.id)) {
        state.transactions.push(transaction);
      }
    });
    state.transactions.sort((a, b) => (a.time <= b.time ? -1 : 1));
  },
  reverseTransaction(state, data: { transaction: FG.Transaction; reversal: FG.Transaction }) {
    const idx = state.transactions.findIndex((value) => value.id === data.transaction.id);
    data.transaction.reversal_id = data.reversal.id;
    if (idx > -1) state.transactions[idx] = data.transaction;
    else state.transactions.push(data.transaction);
  },
};

const actions: ActionTree<BalanceInterface, StateInterface> = {
  //const actions: ActionTree<BalanceInterface, any> = {
  addShortcut({ commit, state, rootState }, shortcut) {
    const sc = [...state.shortcuts, shortcut];
    sc.sort();

    const user = <FG.User>rootState.user.currentUser;
    return axios.put(`/users/${user.userid}/balance/shortcuts`, sc).then(() => {
      commit('setShortcuts', sc);
    });
  },
  removeShortcut({ commit, state, rootState }, shortcut) {
    const sc = state.shortcuts.filter((value: number) => value != shortcut);

    const user = <FG.User>rootState.user.currentUser;
    return axios.put(`/users/${user.userid}/balance/shortcuts`, sc).then(() => {
      commit('setShortcuts', sc);
    });
  },
  getShortcuts({ commit, state, rootState }, force = false) {
    if (force || state.shortcuts.length == 0) {
      commit('setLoading');
      const user = <FG.User>rootState.user.currentUser;
      return axios
        .get(`/users/${user.userid}/balance/shortcuts`)
        .then(({ data }: AxiosResponse<BalanceResponse>) => {
          commit('setShortcuts', data);
          return data;
        })
        .finally(() => commit('setLoading', false));
    }
  },
  getBalance({ commit, rootState }, user: FG.User | undefined = undefined) {
    commit('setLoading');
    if (!user) user = <FG.User>rootState.user.currentUser;
    return axios
      .get(`/users/${user.userid}/balance`)
      .then(({ data }: AxiosResponse<BalanceResponse>) => {
        commit('setBalance', { userid: user?.userid, balance: data });
        return data;
      })
      .finally(() => commit('setLoading', false));
  },
  getBalances() {
    return axios.get('/balance').then(({ data }: AxiosResponse<Array<BalancesResponse>>) => {
      return data;
    });
  },
  getTransactions(
    { commit, rootState },
    payload: {
      userid?: string;
      filter?: {
        limit?: number;
        offset?: number;
        from?: Date;
        to?: Date;
        showReversals?: boolean;
        showCancelled?: boolean;
      };
    }
  ) {
    commit('setLoading');
    if (!payload.userid) payload.userid = (<FG.User>rootState.user.currentUser).userid;
    if (!payload.filter) payload.filter = { limit: 10 };
    return axios
      .get(`/users/${payload.userid}/balance/transactions`, { params: payload.filter || {} })
      .then(({ data }: AxiosResponse<TransactionsResponse>) => {
        data.transactions.forEach((t) => fixTransaction(t));
        commit('addTransactions', data.transactions);
        return data;
      })
      .finally(() => commit('setLoading', false));
  },
  getLimit({ rootState, commit }) {
    commit('setLoading');
    axios
      /* eslint-disable-next-line @typescript-eslint/restrict-template-expressions */
      .get(`/users/${rootState.user.currentUser?.userid}/balance/limit`)
      .then(({ data }) => {
        console.log(data);
      })
      .catch((err) => {
        console.warn(err);
      })
      .finally(() => commit('setLoading', false));
  },
  revert({ dispatch, commit }, transaction: FG.Transaction) {
    return axios
      .delete(`/balance/${transaction.id}`)
      .then(({ data }: AxiosResponse<FG.Transaction>) => {
        fixTransaction(data);
        commit('reverseTransaction', { transaction: transaction, reversal: data });
        dispatch('getBalance').catch((err) => console.warn(err));
      });
  },
  changeBalance(
    { dispatch, commit, rootState },
    data: { amount: number; user: string; sender?: string }
  ) {
    commit('setLoading');
    return axios
      .put(`/users/${data.user}/balance`, data)
      .then((response: AxiosResponse<FG.Transaction>) => {
        const transaction = response.data;
        fixTransaction(transaction);
        if (
          data.user == rootState.user.currentUser?.userid ||
          data.sender === rootState.user.currentUser?.userid
        )
          commit('addTransaction', transaction);
        commit(state.balances.has(data.user) ? 'changeBalance' : 'setBalance', {
          userid: data.user,
          amount: data.amount,
        });
        if (data.sender)
          commit(state.balances.has(data.sender) ? 'changeBalance' : 'setBalance', {
            userid: data.sender,
            amount: -1 * data.amount,
          });
        return transaction;
      })
      .catch((err) => {
        console.debug(err);
        // Maybe Balance changed
        void dispatch('getTransactions', {});
        return dispatch('getBalance', data.sender ? data.sender : data.user);
      })
      .finally(() => commit('setLoading', false));
  },
};

const getters: GetterTree<BalanceInterface, StateInterface> = {
  balances: ({ balances }) => {
    return balances;
  },
  shortcuts: ({ shortcuts }) => {
    return shortcuts;
  },
  transactions: ({ transactions }) => {
    return transactions;
  },
};

const balance: Module<BalanceInterface, StateInterface> = {
  namespaced: true,
  state,
  mutations,
  actions,
  getters,
};

export default balance;