jws-frontend/src/stores/branch/index.ts

import { ref, watch } from 'vue';
import { defineStore } from 'pinia';
import { Pagination } from '../types';
import { api } from 'src/boot/axios';
import { Branch, BranchCreate } from './types';
import { BranchContact } from '../branch-contact/types';
import axios from 'axios';

type BranchId = string;

const useBranchStore = defineStore('api-branch', () => {
  const data = ref<Pagination<Branch[]>>({
    result: [],
    page: 0,
    pageSize: 0,
    total: 0,
  });
  const map = ref<Record<BranchId, Branch & { contact?: BranchContact[] }>>({});
  const contact: Record<BranchId, BranchContact[]> = {};

  watch(data, () => {
    data.value.result.forEach((v) => {
      map.value[v.id] = v;
    });
  });

  async function fetchList<
    Options extends {
      page?: number;
      pageSize?: number;
      zipCode?: string;
      query?: string;
      tree?: boolean;
      filter?: 'head' | 'sub';
    },
    Data extends Pagination<Branch[]>,
  >(
    opts?: Options,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ): Promise<Data | false> {
    const params = new URLSearchParams();

    if (opts?.pageSize && opts?.pageSize > 0) {
      params.append('pageSize', `${opts.pageSize}`);
    }
    if (opts?.page && opts.page > 0) params.append('page', `${opts.page}`);
    if (opts?.zipCode) params.append('zipCode', opts.zipCode);
    if (opts?.query) params.append('query', opts.query);
    if (opts?.filter) params.append('filter', opts.filter);
    if (opts?.tree) params.append('tree', 'true');

    const query = params.toString();

    const res = await api.get<Data>(
      `/branch${(params && '?'.concat(query)) || ''}`,
      {
        headers: {
          'X-Session-Id': flow?.sessionId,
          'X-Rtid': flow?.refTransactionId,
          'X-Tid': flow?.transactionId,
        },
      },
    );

    if (res && res.status === 200) {
      data.value = res.data;
      return res.data;
    }
    return false;
  }

  async function fetchById<
    Options extends { includeSubBranch?: boolean; includeContact?: boolean },
    Data extends Branch &
      (Options['includeSubBranch'] extends true
        ? { branch: Branch[] }
        : unknown) &
      (Options['includeContact'] extends true
        ? { contact: BranchContact[] }
        : unknown),
  >(
    id: string,
    opts?: Options,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ): Promise<Data | false> {
    const params = new URLSearchParams();

    for (const [k, v] of Object.entries(opts || {})) {
      v !== undefined && params.append(k, v.toString());
    }

    const query = params.toString();

    const res = await api.get<Data>(
      `/branch/${id}${(params && '?'.concat(query)) || ''}`,
      {
        headers: {
          'X-Session-Id': flow?.sessionId,
          'X-Rtid': flow?.refTransactionId,
          'X-Tid': flow?.transactionId,
        },
      },
    );

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function create(
    branch: BranchCreate,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const { qrCodeImage, ...payload } = branch;

    const res = await api.post<
      Branch & { qrCodeImageUrl: string; qrCodeImageUploadUrl: string }
    >('/branch', payload, {
      headers: {
        'X-Session-Id': flow?.sessionId,
        'X-Rtid': flow?.refTransactionId,
        'X-Tid': flow?.transactionId,
      },
    });

    qrCodeImage &&
      (await axios
        .put(res.data.qrCodeImageUploadUrl, qrCodeImage, {
          headers: { 'Content-Type': qrCodeImage.type },
          onUploadProgress: (e) => console.log(e),
        })
        .catch((e) => console.error(e)));
    if (!res) return false;

    return res.data;
  }

  async function editById(
    id: string,
    data: Partial<BranchCreate & { status: 'ACTIVE' | 'INACTIVE' }>,
    qrCodeImage?: File,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const { ...payload } = data;
    const res = await api.put<Branch & { qrCodeImageUploadUrl: string }>(
      `/branch/${id}`,
      payload,
      {
        headers: {
          'X-Session-Id': flow?.sessionId,
          'X-Rtid': flow?.refTransactionId,
          'X-Tid': flow?.transactionId,
        },
      },
    );

    if (qrCodeImage) {
      await axios
        .put(res.data.qrCodeImageUploadUrl, qrCodeImage, {
          headers: { 'Content-Type': qrCodeImage.type },
          onUploadProgress: (e) => console.log(e),
        })
        .catch((e) => console.error(e));
    }

    if (!res) return false;

    return res.data;
  }

  async function deleteById(
    id: string,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const res = await api.delete<Branch>(`/branch/${id}`, {
      headers: {
        'X-Session-Id': flow?.sessionId,
        'X-Rtid': flow?.refTransactionId,
        'X-Tid': flow?.transactionId,
      },
    });

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function getUser(
    branchId: string,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const res = await api.get(`/branch/${branchId}/user`, {
      headers: {
        'X-Session-Id': flow?.sessionId,
        'X-Rtid': flow?.refTransactionId,
        'X-Tid': flow?.transactionId,
      },
    });

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function addUser(
    branchId: string,
    userId: string | string[],
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const res = await api.post(
      `/branch/${branchId}/user`,
      { user: ([] as string[]).concat(userId) },
      {
        headers: {
          'X-Session-Id': flow?.sessionId,
          'X-Rtid': flow?.refTransactionId,
          'X-Tid': flow?.transactionId,
        },
      },
    );

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function removeUser(
    branchId: string,
    userId: string | string[],
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const res = await api.delete(`/branch/${branchId}/user`, {
      headers: {
        'X-Session-Id': flow?.sessionId,
        'X-Rtid': flow?.refTransactionId,
        'X-Tid': flow?.transactionId,
      },
      data: { user: ([] as string[]).concat(userId) },
    });

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function stats(flow?: {
    sessionId: string;
    refTransactionId: string;
    transactionId: string;
  }) {
    const res = await api.get<{
      hq: number;
      br: number;
    }>('/branch/stats', {
      headers: {
        'X-Session-Id': flow?.sessionId,
        'X-Rtid': flow?.refTransactionId,
        'X-Tid': flow?.transactionId,
      },
    });

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function userStats(
    userType: string,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    const res = await api.get(
      `/branch/user-stats${userType ? '?'.concat(userType) : ''}`,
      {
        headers: {
          'X-Session-Id': flow?.sessionId,
          'X-Rtid': flow?.refTransactionId,
          'X-Tid': flow?.transactionId,
        },
      },
    );

    if (!res) return false;
    if (res.status === 200) return res.data;

    return false;
  }

  async function getContact(
    branchId: BranchId,
    force = false,
    flow?: {
      sessionId: string;
      refTransactionId: string;
      transactionId: string;
    },
  ) {
    if (!force && contact[branchId]) return contact[branchId];

    const res = await fetchById(branchId, { includeContact: true }, flow);

    if (res) {
      contact[branchId] = res.contact;
      return res.contact;
    }

    return false;
  }

  return {
    data,
    map,
    fetchList,
    fetchById,

    create,
    editById,
    deleteById,

    getUser,
    addUser,
    removeUser,

    getContact,

    stats,
    userStats,
  };
});

export default useBranchStore;