src/api/chat.ts - master - SOFG1/hasida

src/api/chat.ts
173 строки5 KB
Eddy
initial commit
22 июл 2024, 17:14
22 июл 2024, 17:14b43c0d0
import { createApi } from "@reduxjs/toolkit/dist/query/react";
import { baseQuery, getSocketInstance } from ".";
import { UserPhotoType } from "./user";

export const chatApi = createApi({
  reducerPath: "chatApi",
  baseQuery,
  endpoints: (builder) => {
    return {
      chatGetDialogs: builder.query<IDialog[], void>({
        query: () => {
          return {
            url: `chat/dialogs/`,
            method: "GET",
          };
        },
      }),
      chatCreateDialog: builder.mutation<IDialog, number>({
        query: (id) => {
          return {
            url: `chat/dialogs/`,
            method: "POST",
            body: {
              opponent: id,
            },
          };
        },
        async onQueryStarted(payload, { dispatch, queryFulfilled }) {
          const { data } = await queryFulfilled;
          dispatch(
            chatApi.util.updateQueryData(
              "chatGetDialogs",
              undefined,
              (draft) => {
                const alreadyExist = draft.find((d) => d.id === data.id);
                if (!alreadyExist) {
                  draft.push(data);
                }
              }
            )
          );
        },
      }),
      chatGetMessages: builder.query<IChatMessage[], number>({
        query: (id) => {
          return {
            url: `chat/messages/${id}`,
            method: "GET",
          };
        },
        onCacheEntryAdded: (arg, { getState, updateCachedData }) => {
          const state = getState();
          //@ts-ignore
          const token = state?.user?.token || null;
          const socket = getSocketInstance(token);
          socket?.addEventListener("message", (m) => {
            const res = JSON.parse(m.data);
            //Response of sent message
            if (res.event_type === "response" && res.data.status === 1) {
              if (res.data.message?.dialog_id === arg) {
                updateCachedData((draft) => {
                  draft.unshift(res.data.message);
                });
              }
            }
            //New message from opponent
            if (res.event_type === "message") {
              updateCachedData((draft) => {
                draft.unshift(res.data);
              });
            }
            if (res.event_type === "read_message") {
              updateCachedData((draft) => {
                draft.forEach(d => {
                  if(res.data.message === d.id) d.read = true;
                });
              });
            }
          });
        },
      }),
      chatSetMessagesRead: builder.mutation<any, { unreadList: number[], chatId: number }>({
        query: (messages) => {
          return {
            url: `chat/messages/set_read/`,
            method: "POST",
            body: {
              messages: messages.unreadList,
            },
          };
        },
        onQueryStarted(payload, { getState }) {
          const state = getState();
          //@ts-ignore
          const token = state?.user?.token || null;
          const socket = getSocketInstance(token);
            const data = {
              event_type: "read_message",
              data: {
                message: payload.unreadList[0],
                dialog: payload.chatId
              }
            };
            socket?.send(JSON.stringify(data))
        },
      }),
      chatGetComplainDetails: builder.query<any, void>({
        query: () => {
          return {
            url: `chat/complaint/`,
            method: "GET",
          };
        },
      }),
      chatComplain: builder.mutation<any, ChatComplainParams>({
        query: ({ id, reason, description }: ChatComplainParams) => {
          return {
            url: `chat/complaint/${id}/`,
            method: "POST",
            body: {
              reason,
              description,
            },
          };
        },
        transformErrorResponse: (raw: any) => {
          return raw.data.detail;
        },
      }),
    };
  },
});

export interface IDialogOpponent {
  id: number;
  age: number;
  city: { id: number; name: string } | null;
  distance: null;
  first_name: string;
  second_name: string;
  gender: string;
  main_photo: UserPhotoType | null;
  online: true | string;
  photos: UserPhotoType[];
  user_name: string;
}

export interface IDialog {
  id: number;
  is_closed: boolean;
  new_messages: number;
  opponent: IDialogOpponent;
}

export interface IChatMessage {
  id: number;
  date: string;
  dialog_id: number;
  read: boolean;
  sender_id: number;
  text: string;
}

type ChatComplainParams = { id: number; reason?: string; description?: string };

export const {
  useChatGetDialogsQuery,
  useChatCreateDialogMutation,
  useChatGetComplainDetailsQuery,
  useChatComplainMutation,
  useChatGetMessagesQuery,
  useChatSetMessagesReadMutation,
} = chatApi;