Sophie-Gaëlle CALLOCH
88 lines
3.7 KiB
TypeScript
88 lines
3.7 KiB
TypeScript
import {
|
|
BalanceResponse,
|
|
CombinedLedgerResponse,
|
|
CombinedLedgerResponseTypeEnum,
|
|
CreateCombinedLedgerRequest,
|
|
CreateMainLedgerRequest,
|
|
LedgerResponseTypeEnum,
|
|
MainLedgerResponse,
|
|
MainLedgerResponseTypeEnum,
|
|
TransactionResponse,
|
|
UpdateCombinedLedgerRequest,
|
|
UpdateMainLedgerRequest
|
|
} from "@/generated/mammon";
|
|
import {defineStore} from "pinia";
|
|
import {computed, ref, triggerRef} from "vue";
|
|
import {ledgerApi, transactionApi} from "@/mammon";
|
|
import {useRouteParams} from "@vueuse/router";
|
|
|
|
export const LedgerTypes = LedgerResponseTypeEnum;
|
|
|
|
export type LedgerType = LedgerResponseTypeEnum;
|
|
export type MainLedger = MainLedgerResponse & {type: MainLedgerResponseTypeEnum}
|
|
export type CombinedLedger = CombinedLedgerResponse & {type: CombinedLedgerResponseTypeEnum}
|
|
export type Ledger = MainLedger | CombinedLedger;
|
|
|
|
export const systemLedgerRef = 'system';
|
|
export const systemLedger = {
|
|
type: LedgerTypes.Main,
|
|
ledgerId: "00000000-0000-0000-0000-000000000001",
|
|
name: "Eve Economy",
|
|
balance: 0,
|
|
_system: true
|
|
} as MainLedger;
|
|
|
|
export const isMain = (ledger: Ledger): ledger is MainLedger => {
|
|
return ledger.type === LedgerTypes.Main;
|
|
}
|
|
export const isCombined = (ledger: Ledger): ledger is CombinedLedger => {
|
|
return ledger.type === LedgerTypes.Combined;
|
|
}
|
|
|
|
export const useLedgersStore = defineStore('ledgers', () => {
|
|
const ledgers = ref<Ledger[]>([]);
|
|
|
|
const addLedger = (ledger: Ledger) => {
|
|
ledgers.value.push(ledger);
|
|
triggerRef(ledgers);
|
|
return ledger;
|
|
};
|
|
|
|
const replaceLedger = (ledger: Ledger) => {
|
|
const index = ledgers.value.findIndex(l => l.ledgerId === ledger.ledgerId);
|
|
|
|
if (index !== -1) {
|
|
ledgers.value[index] = ledger;
|
|
}
|
|
triggerRef(ledgers);
|
|
return ledger;
|
|
};
|
|
|
|
const findById = (ledgerId: string): Ledger | undefined => ledgers.value.find(l => l.ledgerId === ledgerId);
|
|
const findAllById = (ledgerIds: string[]): Ledger[] => ledgerIds.map(findById).filter((x): x is Ledger => x !== undefined)
|
|
|
|
const createMain = (ledger: CreateMainLedgerRequest) => ledgerApi.createMainLedger(ledger).then(response => addLedger(response.data as Ledger));
|
|
const createCombined = (ledger: CreateCombinedLedgerRequest) => ledgerApi.createCombinedLedger(ledger).then(response => addLedger(response.data as Ledger));
|
|
const updateMain = (ledgerId: string, ledger: UpdateMainLedgerRequest) => ledgerApi.updateMainLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
|
|
const updateCombined = (ledgerId: string, ledger: UpdateCombinedLedgerRequest) => ledgerApi.updateCombinedLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
|
|
|
|
const refresh = () => ledgerApi.findAllLedgers().then(response => ledgers.value = response.data as Ledger[]);
|
|
|
|
refresh();
|
|
|
|
return {ledgers, findById, findAllById, createMain, createCombined, updateMain, updateCombined, refresh};
|
|
})
|
|
|
|
const getLedgerId = (ledger: Ledger | string): string => typeof ledger == 'string' ? ledger : ledger.ledgerId;
|
|
|
|
export const findAllTransactionInLeger = (ledger: Ledger | string): Promise<TransactionResponse[]> => transactionApi.finAllTransactionsInLedger(getLedgerId(ledger)).then(response => response.data)
|
|
export const getLedgerBalance = (ledger: Ledger | string): Promise<BalanceResponse> => ledgerApi.findBalanceByLedgerId(getLedgerId(ledger)).then(response => response.data)
|
|
|
|
export const useLedgerParam = () => {
|
|
const {findById} = useLedgersStore();
|
|
const ledgerId = useRouteParams<string, string>('ledgerId', '', { transform: v => typeof v === 'string' ? v : v[0]});
|
|
const ledger = computed(() => findById(ledgerId.value))
|
|
|
|
return {ledgerId, ledger};
|
|
}
|