bluenote/src/store/documentStore.ts

import { create } from 'zustand'

import { getDocumentList as _getDocumentList, deleteDocument as _del, createDocument as _createDocument } from '@/service/document'
import { IEntityDocument, IPageParams, IDocumentReq } from '@/types/index'
import { TFileItem } from '@/types/file-types'

export interface DocumentState {
  loading: boolean
  documents: IEntityDocument[] | []
  fetchDocumentList: (data: IPageParams) => Promise<IEntityDocument[]>
  deleteDocument: (id: number) => Promise<void>
  createDocument: (data: IDocumentReq) => Promise<IEntityDocument|null>
  uploadingList: TFileItem[]
  setUploadingList: (list: TFileItem[]) => void
  setUploadListItem: (fileItem: TFileItem) => void
}




export const useDocumentStore = create<DocumentState>((set, get) => ({
  loading: false,
  documents: [],
  uploadingList: [],
  setUploadingList: (list: TFileItem[]) => {
    set({ uploadingList: list })
  },
  setUploadListItem: (fileItem: TFileItem) => {
    set((state) => {
      let list = state.uploadingList.map(item => {
        if(item.file.name === fileItem.file.name){
          return{
            ...item,
            status: fileItem.status,
          }
        }
        return {...item}
      })
      const uploaded = list.filter(item => item.status === 2);
      if(uploaded.length === list.length ){
        list = []
      }
      return {
        uploadingList: list
      }
    })
    
  },
  fetchDocumentList: async (data: IPageParams) => {
    const response = await _getDocumentList(data)
    if (response.code === 0 && response.data) {
      
      set({ documents: response.data})
    }
    return response?.data
  },
  createDocument: async (c: IDocumentReq) => {
    set({ loading: true })
    const response = await _createDocument(c)
    if(response.code !== 0){
      return null
    }
    set((state) => {
      return {
        documents: [...state.documents, response.data],
        loading: false
      }
    })
    return response?.data
  },
  
  deleteDocument: async (id) => {
    const res = await _del(id)
    if (res.code === 0) {
      set((state) => {
        const docs = state.documents.filter((item: IEntityDocument) => item?.id !== id)
        return {
          documents: [...docs]
        }
      })
    }
  },
  setLoading: (loading: boolean) => {
    set({ loading })
  }
}))