HKSingleParty/03_source/frontend/src/actions/party-user.ts

// src/actions/party-user.ts
//
import { useMemo } from 'react';
import axiosInstance, { endpoints, fetcher } from 'src/lib/axios';
import type { IPartyUserItem } from 'src/types/party-user';
import type { IProductItem } from 'src/types/product';
import type { SWRConfiguration } from 'swr';
import useSWR, { mutate } from 'swr';

// ----------------------------------------------------------------------

const swrOptions: SWRConfiguration = {
  revalidateIfStale: false,
  revalidateOnFocus: false,
  revalidateOnReconnect: false,
};

// ----------------------------------------------------------------------

type PartyUsersData = {
  partyUsers: IPartyUserItem[];
};

// TODO: i want to refactor / tidy here
export function useGetPartyUsers() {
  const url = endpoints.partyUser.list;

  const { data, isLoading, error, isValidating } = useSWR<PartyUsersData>(url, fetcher, swrOptions);

  const memoizedValue = useMemo(
    () => ({
      partyUsers: data?.partyUsers || [],
      partyUsersLoading: isLoading,
      partyUsersError: error,
      partyUsersValidating: isValidating,
      partyUsersEmpty: !isLoading && !isValidating && !data?.partyUsers.length,
    }),
    [data?.partyUsers, error, isLoading, isValidating]
  );

  return memoizedValue;
}

// ----------------------------------------------------------------------

type PartyUserData = {
  partyUser: IPartyUserItem;
};

export function useGetPartyUser(partyUserId: string) {
  const { data, isLoading, error, isValidating } = useSWR<PartyUserData>(
    endpoints.partyUser.detailsByPartyUserId(partyUserId),
    fetcher,
    swrOptions
  );

  const memoizedValue = useMemo(
    () => ({
      partyUser: data?.partyUser,
      partyUserLoading: isLoading,
      partyUserError: error,
      partyUserValidating: isValidating,
    }),
    [data?.partyUser, error, isLoading, isValidating]
  );

  return memoizedValue;
}

// ----------------------------------------------------------------------

type SearchResultsData = {
  results: IProductItem[];
};

// TODO: update useSearchProducts
export function useSearchProducts(query: string) {
  const url = query ? [endpoints.product.search, { params: { query } }] : '';

  const { data, isLoading, error, isValidating } = useSWR<SearchResultsData>(url, fetcher, {
    ...swrOptions,
    keepPreviousData: true,
  });

  const memoizedValue = useMemo(
    () => ({
      searchResults: data?.results || [],
      searchLoading: isLoading,
      searchError: error,
      searchValidating: isValidating,
      searchEmpty: !isLoading && !isValidating && !data?.results.length,
    }),
    [data?.results, error, isLoading, isValidating]
  );

  return memoizedValue;
}

// ----------------------------------------------------------------------

type SaveUserData = {
  name: string;
  city: string;
  role: string;
  email: string;
  state: string;
  status: string;
  address: string;
  country: string;
  zipCode: string;
  company: string;
  avatarUrl: string;
  phoneNumber: string;
  isVerified: boolean;
  //
  username: string;
  password: string;
};

export async function createPartyUser(partyUserData: CreateUserData) {
  /**
   * Work on server
   */
  const data = { partyUserData };
  const {
    data: { id },
  } = await axiosInstance.post(endpoints.partyUser.create, data);

  /**
   * Work in local
   */
  mutate(
    endpoints.partyUser.list,
    (currentData: any) => {
      const currentPartyUsers: IPartyUserItem[] = currentData?.partyUsers;

      const partyUsers = [...currentPartyUsers, { ...partyUserData, id }];

      return { ...currentData, partyUsers };
    },
    false
  );
}

// ----------------------------------------------------------------------

export async function updatePartyUser(partyUserData: Partial<IPartyUserItem>) {
  /**
   * Work on server
   */
  const data = { partyUserData };
  await axiosInstance.put(endpoints.partyUser.update, data);

  /**
   * Work in local
   */
  mutate(
    endpoints.partyUser.list,
    (currentData: any) => {
      const currentPartyUsers: IPartyUserItem[] = currentData?.partyUsers;

      const partyUsers = currentPartyUsers.map((partyUser) =>
        partyUser.id === partyUserData.id ? { ...partyUser, ...partyUserData } : partyUser
      );

      return { ...currentData, partyUsers };
    },
    false
  );

  const partyUserId: string = partyUserData.id || '';
  mutate(
    endpoints.partyUser.detailsByPartyUserId(partyUserId),
    (currentData: any) => {
      const currentPartyUser: IPartyUserItem = currentData?.partyUser;

      console.log({ currentPartyUser });
      const partyUser = partyUserData;

      return { ...currentData, partyUser };
    },
    false
  );
}

export async function uploadUserImage(saveUserData: SaveUserData) {
  console.log('uploadUserImage ?');
  // const url = userId ? [endpoints.user.details, { params: { userId } }] : '';

  const res = await axiosInstance.get('http://localhost:7272/api/product/helloworld');

  return res;
}

// ----------------------------------------------------------------------

type CreateUserData = {
  name: string;
  city: string;
  role: string;
  email: string;
  state: string;
  status: string;
  address: string;
  country: string;
  zipCode: string;
  company: string;
  avatarUrl: string;
  phoneNumber: string;
  isVerified: boolean;
  //
  username: string;
  password: string;
};

export async function deletePartyUser(partyUserId: string) {
  /**
   * Work on server
   */
  const data = { partyUserId };
  await axiosInstance.patch(endpoints.partyUser.delete, data);

  /**
   * Work in local
   */
  mutate(
    endpoints.partyUser.list,
    (currentData: any) => {
      const currentPartyUsers: IPartyUserItem[] = currentData?.partyUsers;

      const partyUsers = currentPartyUsers.filter((partyUser) => partyUser.id !== partyUserId);

      return { ...currentData, partyUsers };
    },
    false
  );
}