think/packages/client/src/data/document.ts

import type { IUser, IDocument } from '@think/domains';
import useSWR from 'swr';
import { useState, useCallback, useEffect } from 'react';
import { useAsyncLoading } from 'hooks/useAsyncLoading';
import { HttpClient } from 'services/HttpClient';
import { getPublicDocumentDetail } from 'services/document';

interface IAuthority {
  id: string;
  documentId: string;
  userId: string;
  readable: boolean;
  editable: boolean;
}

type ICreateDocument = Partial<Pick<IDocument, 'wikiId' | 'parentDocumentId'>>;
type IDocumentWithAuth = { document: IDocument; authority: IAuthority };
type IUpdateDocument = Partial<Pick<IDocument, 'title' | 'content'>>;

/**
 * 创建文档
 * @returns
 */
export const useCreateDocument = () => {
  const [create, loading] = useAsyncLoading((data: ICreateDocument): Promise<IDocument> => {
    return HttpClient.post('/document/create', data);
  });
  return { create, loading };
};

/**
 * 更新文档阅读量
 * @param id
 * @returns
 */
export const updateDocumentViews = (id: string) => {
  return HttpClient.get('/document/views/' + id);
};

/**
 * 删除文档
 * @param id
 * @returns
 */
export const useDeleteDocument = (id) => {
  const [deleteDocument, loading] = useAsyncLoading((): Promise<IDocument> => {
    return HttpClient.delete('/document/delete/' + id);
  });
  return { deleteDocument, loading };
};

/**
 * 获取文档详情
 * @param documentId
 * @returns
 */
export const useDocumentDetail = (documentId, options = null) => {
  const { data, error, mutate } = useSWR<IDocumentWithAuth>(
    `/document/detail/${documentId}`,
    (url) => HttpClient.get(url),
    options
  );
  const loading = !data && !error;
  const update = async (data: IUpdateDocument) => {
    const res = await HttpClient.post('/document/update/' + documentId, data);
    mutate();
    return res;
  };

  const toggleStatus = async (data: Partial<Pick<IDocument, 'sharePassword'>>) => {
    const ret = await HttpClient.post('/document/share/' + documentId, data);
    mutate();
    return ret;
  };

  return { data, loading, error, update, toggleStatus };
};

/**
 * 获取知识库最近更新的10条文档
 * @returns
 */
export const useRecentDocuments = () => {
  const { data, error, mutate } = useSWR<IDocument[]>('/document/recent', (url) => HttpClient.get(url));
  const loading = !data && !error;
  return { data, error, loading, refresh: mutate };
};

/**
 * 收藏文档
 * @param documentId
 * @returns
 */
export const useDocumentStar = (documentId) => {
  const { data, error, mutate } = useSWR<boolean>(`/collector/check/${documentId}`, () =>
    HttpClient.post(`/collector/check`, {
      type: 'document',
      targetId: documentId,
    })
  );

  const toggleStar = async () => {
    await HttpClient.post('/collector/toggle/', {
      type: 'document',
      targetId: documentId,
    });
    mutate();
  };

  return { data, error, toggleStar };
};

/**
 * 获取用户收藏的文档
 * @returns
 */
export const useStaredDocuments = () => {
  const { data, error, mutate } = useSWR<IDocument[]>('/collector/documents', (url) => HttpClient.post(url));
  const loading = !data && !error;

  return { data, error, loading, refresh: mutate };
};

/**
 * 获取公开文档
 * @param documentId
 * @returns
 */
export const usePublicDocument = (documentId: string) => {
  const [fetch] = useAsyncLoading(getPublicDocumentDetail);
  const [document, setDocument] = useState<IDocument | null>(null);
  const [error, setError] = useState<(Error & { statusCode?: number }) | null>(null);
  const loading = !document && !error;

  const queryData = useCallback(
    (sharePassword = '') => {
      fetch(documentId, { sharePassword })
        .then((doc) => {
          setDocument(doc);
          setError(null);
        })
        .catch(setError);
    },
    [documentId, error]
  );

  useEffect(() => {
    queryData();
  }, [documentId]);

  return {
    data: document,
    loading,
    error,
    query: queryData,
  };
};

/**
 * 协作文档
 * @param documentId
 * @returns
 */
export const useCollaborationDocument = (documentId) => {
  const { data, error, mutate } = useSWR<Array<IAuthority & IUser>>(
    `/document/user/${documentId}`,
    (url) => HttpClient.get(url),
    { shouldRetryOnError: false }
  );
  const loading = !data && !error;

  const addUser = async (userName) => {
    const ret = await HttpClient.post(`/document/user/${documentId}/add`, {
      documentId,
      userName,
      readable: true,
      editable: false,
    });
    mutate();
    return ret;
  };

  const updateUser = async (docAuth) => {
    const ret = await HttpClient.post(`/document/user/${documentId}/update`, {
      documentId,
      ...docAuth,
    });
    mutate();
    return ret;
  };

  const deleteUser = async (docAuth) => {
    const ret = await HttpClient.post(`/document/user/${documentId}/delete`, {
      documentId,
      ...docAuth,
    });
    mutate();
    return ret;
  };

  return { users: data, loading, error, addUser, updateUser, deleteUser };
};

/**
 * 获取子文档
 * @param documentId
 * @param isShare 访问路径
 * @returns
 */
export const useChildrenDocument = ({ wikiId, documentId, isShare = false }) => {
  const { data, error, mutate } = useSWR<Array<IDocument>>(
    isShare ? '/document/public/children' : `/document/children`,
    wikiId || documentId ? (url) => HttpClient.post(url, { wikiId, documentId, isShare }) : null,
    { shouldRetryOnError: false }
  );
  const loading = !data && !error;

  return { data, loading, error, refresh: mutate };
};