Refactor library editing

2025-06-26 04:50:36 +03:00 · 2023-08-09 17:19:12 +03:00 · 2023-08-09 17:19:12 +03:00 · db4ba706fb
commit db4ba706fb
parent cd96ad2274
4 changed files with 198 additions and 202 deletions
--- a/rsconcept/frontend/src/context/LibraryContext.tsx
+++ b/rsconcept/frontend/src/context/LibraryContext.tsx
@ -1,17 +1,19 @@
 import { createContext, useCallback, useContext, useEffect, useState } from 'react';

 import { ErrorInfo } from '../components/BackendError';
-import { getLibrary } from '../utils/backendAPI';
-import { ILibraryFilter, IRSFormMeta, matchRSFormMeta } from '../utils/models';
+import { DataCallback, getLibrary, postNewRSForm } from '../utils/backendAPI';
+import { ILibraryFilter, IRSFormCreateData, IRSFormMeta, matchRSFormMeta } from '../utils/models';

 interface ILibraryContext {
  items: IRSFormMeta[]
  loading: boolean
+  processing: boolean
  error: ErrorInfo
  setError: (error: ErrorInfo) => void

  reload: () => void 
  filter: (params: ILibraryFilter) => IRSFormMeta[]
+  createSchema: (data: IRSFormCreateData, callback?: DataCallback<IRSFormMeta>) => void
 }

 const LibraryContext = createContext<ILibraryContext | null>(null)
@ -30,9 +32,10 @@ interface LibraryStateProps {
 }

 export const LibraryState = ({ children }: LibraryStateProps) => {
-  const [items, setItems] = useState<IRSFormMeta[]>([])
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<ErrorInfo>(undefined);
+  const [ items, setItems ] = useState<IRSFormMeta[]>([])
+  const [ loading, setLoading ] = useState(false);
+  const [ processing, setProcessing ] = useState(false);
+  const [ error, setError ] = useState<ErrorInfo>(undefined);

  const filter = useCallback(
  (params: ILibraryFilter) => {
@ -63,12 +66,27 @@ export const LibraryState = ({ children }: LibraryStateProps) => {

  useEffect(() => {
    reload();
-  }, [reload])
+  }, [reload]);
+
+  const createSchema = useCallback(
+  (data: IRSFormCreateData, callback?: DataCallback<IRSFormMeta>) => {
+    setError(undefined);
+    postNewRSForm({
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error); },
+      onSuccess: newSchema => {
+        reload();
+        if (callback) callback(newSchema);
+      }
+    });
+  }, [reload]);

  return (
    <LibraryContext.Provider value={{ 
-      items, loading, error, setError, 
-      reload, filter
+      items, loading, processing, error, setError, 
+      reload, filter, createSchema
    }}>
      { children }
    </LibraryContext.Provider>
--- a/rsconcept/frontend/src/context/RSFormContext.tsx
+++ b/rsconcept/frontend/src/context/RSFormContext.tsx
@ -5,14 +5,17 @@ import { type ErrorInfo } from '../components/BackendError'
 import { useRSFormDetails } from '../hooks/useRSFormDetails'
 import {
  type DataCallback, deleteRSForm, getTRSFile,
-  patchConstituenta, patchDeleteConstituenta, patchMoveConstituenta, patchResetAliases,
-patchRSForm,
-patchUploadTRS,  postClaimRSForm, postCloneRSForm,postNewConstituenta} from '../utils/backendAPI'
+  patchConstituenta, patchDeleteConstituenta, 
+  patchMoveConstituenta, patchResetAliases, patchRSForm,
+  patchUploadTRS,  postClaimRSForm, postCloneRSForm, postNewConstituenta
+} from '../utils/backendAPI'
 import {
  IConstituentaList, IConstituentaMeta, ICstCreateData,
-  ICstMovetoData, ICstUpdateData, IRSForm, IRSFormCreateData, IRSFormData, IRSFormMeta, IRSFormUpdateData, IRSFormUploadData
+  ICstMovetoData, ICstUpdateData, IRSForm, IRSFormCreateData, 
+  IRSFormData, IRSFormMeta, IRSFormUpdateData, IRSFormUploadData
 } from '../utils/models'
 import { useAuth } from './AuthContext'
+import { useLibrary } from './LibraryContext'

 interface IRSFormContext {
  schema?: IRSForm
@ -63,15 +66,16 @@ interface RSFormStateProps {
 }

 export const RSFormState = ({ schemaID, children }: RSFormStateProps) => {
-  const { user } = useAuth()
-  const { schema, reload, error, setError, setSchema, loading } = useRSFormDetails({ target: schemaID })
-  const [processing, setProcessing] = useState(false)
+  const { user } = useAuth();
+  const { schema, reload, error, setError, setSchema, loading } = useRSFormDetails({ target: schemaID });
+  const [ processing, setProcessing ] = useState(false);
+  const library = useLibrary();

-  const [isForceAdmin, setIsForceAdmin] = useState(false)
-  const [isReadonly, setIsReadonly] = useState(false)
+  const [ isForceAdmin, setIsForceAdmin ] = useState(false);
+  const [ isReadonly, setIsReadonly ] = useState(false);

-  const isOwned = useMemo(() => user?.id === schema?.owner || false, [user, schema?.owner])
-  const isClaimable = useMemo(() => user?.id !== schema?.owner || false, [user, schema?.owner])
+  const isOwned = useMemo(() => user?.id === schema?.owner || false, [user, schema?.owner]);
+  const isClaimable = useMemo(() => user?.id !== schema?.owner || false, [user, schema?.owner]);
  const isEditable = useMemo(
    () => {
      return (
@ -83,181 +87,185 @@ export const RSFormState = ({ schemaID, children }: RSFormStateProps) => {
  const isTracking = useMemo(
    () => {
      return true
-    }, [])
+    }, []);

  const toggleTracking = useCallback(
    () => {
      toast.info('Отслеживание в разработке...')
-    }, [])
+    }, []);

  const update = useCallback(
-    (data: IRSFormUpdateData, callback?: DataCallback<IRSFormMeta>) => {
-      if (!schema) {
-        return;
+  (data: IRSFormUpdateData, callback?: DataCallback<IRSFormMeta>) => {
+    if (!schema) {
+      return;
+    }
+    setError(undefined)
+    patchRSForm(schemaID, {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => setError(error),
+      onSuccess: newData => {
+        setSchema(Object.assign(schema, newData));
+        if (callback) callback(newData);
      }
-      setError(undefined)
-      patchRSForm(schemaID, {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(Object.assign(schema, newData));
-          if (callback) callback(newData);
-        }
-      });
-    }, [schemaID, setError, setSchema, schema])
+    });
+  }, [schemaID, setError, setSchema, schema]);
  
  const upload = useCallback(
-    (data: IRSFormUploadData, callback?: () => void) => {
-      if (!schema) {
-        return;
+  (data: IRSFormUploadData, callback?: () => void) => {
+    if (!schema) {
+      return;
+    }
+    setError(undefined)
+    patchUploadTRS(schemaID, {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => setError(error),
+      onSuccess: newData => {
+        setSchema(newData);
+        if (callback) callback();
      }
-      setError(undefined)
-      patchUploadTRS(schemaID, {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(newData);
-          if (callback) callback();
-        }
-      });
-    }, [schemaID, setError, setSchema, schema])
+    });
+  }, [schemaID, setError, setSchema, schema]);

  const destroy = useCallback(
-    (callback?: () => void) => {
-      setError(undefined)
-      deleteRSForm(schemaID, {
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: () => {
-          setSchema(undefined);
-          if (callback) callback();
-        }
-      });
-    }, [schemaID, setError, setSchema])
+  (callback?: () => void) => {
+    setError(undefined)
+    deleteRSForm(schemaID, {
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => setError(error),
+      onSuccess: () => {
+        setSchema(undefined);
+        library.reload();
+        if (callback) callback();
+      }
+    });
+  }, [schemaID, setError, setSchema, library]);

  const claim = useCallback(
-    (callback?: DataCallback<IRSFormMeta>) => {
-      if (!schema || !user) {
-        return;
+  (callback?: DataCallback<IRSFormMeta>) => {
+    if (!schema || !user) {
+      return;
+    }
+    setError(undefined)
+    postClaimRSForm(schemaID, {
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => setError(error),
+      onSuccess: newData => {
+        setSchema(Object.assign(schema, newData));
+        if (callback) callback(newData);
      }
-      setError(undefined)
-      postClaimRSForm(schemaID, {
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(Object.assign(schema, newData));
-          if (callback) callback(newData);
-        }
-      });
-    }, [schemaID, setError, schema, user, setSchema])
+    });
+  }, [schemaID, setError, schema, user, setSchema]);

  const clone = useCallback(
-    (data: IRSFormCreateData, callback: DataCallback<IRSFormData>) => {
-      if (!schema || !user) {
-        return;
+  (data: IRSFormCreateData, callback: DataCallback<IRSFormData>) => {
+    if (!schema || !user) {
+      return;
+    }
+    setError(undefined)
+    postCloneRSForm(schemaID, {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => setError(error),
+      onSuccess: newSchema => {
+        library.reload();
+        if (callback) callback(newSchema);
      }
-      setError(undefined)
-      postCloneRSForm(schemaID, {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: callback
-      });
-    }, [schemaID, setError, schema, user])
+    });
+  }, [schemaID, setError, schema, user, library]);

  const resetAliases = useCallback(
-    (callback?: () => void) => {
-      if (!schema || !user) {
-        return;
+  (callback?: () => void) => {
+    if (!schema || !user) {
+      return;
+    }
+    setError(undefined)
+    patchResetAliases(schemaID, {
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error) },
+      onSuccess: newData => {
+        setSchema(Object.assign(schema, newData));
+        if (callback) callback();
      }
-      setError(undefined)
-      patchResetAliases(schemaID, {
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(Object.assign(schema, newData));
-          if (callback) callback();
-        }
-      });
-    }, [schemaID, setError, schema, user, setSchema])
+    });
+  }, [schemaID, setError, schema, user, setSchema]);

  const download = useCallback(
-    (callback: DataCallback<Blob>) => {
-      setError(undefined)
-      getTRSFile(schemaID, {
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: callback
-      });
-    }, [schemaID, setError])
+  (callback: DataCallback<Blob>) => {
+    setError(undefined)
+    getTRSFile(schemaID, {
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error) },
+      onSuccess: callback
+    });
+  }, [schemaID, setError]);

  const cstCreate = useCallback(
-    (data: ICstCreateData, callback?: DataCallback<IConstituentaMeta>) => {
-      setError(undefined)
-      postNewConstituenta(schemaID, {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(newData.schema);
-          if (callback) callback(newData.new_cst);
-        }
-      });
-    }, [schemaID, setError, setSchema]);
+  (data: ICstCreateData, callback?: DataCallback<IConstituentaMeta>) => {
+    setError(undefined)
+    postNewConstituenta(schemaID, {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error) },
+      onSuccess: newData => {
+        setSchema(newData.schema);
+        if (callback) callback(newData.new_cst);
+      }
+    });
+  }, [schemaID, setError, setSchema]);

  const cstDelete = useCallback(
-    (data: IConstituentaList, callback?: () => void) => {
-      setError(undefined)
-      patchDeleteConstituenta(schemaID, {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(newData);
-          if (callback) callback();
-        }
-      });
-    }, [schemaID, setError, setSchema]);
+  (data: IConstituentaList, callback?: () => void) => {
+    setError(undefined)
+    patchDeleteConstituenta(schemaID, {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error) },
+      onSuccess: newData => {
+        setSchema(newData);
+        if (callback) callback();
+      }
+    });
+  }, [schemaID, setError, setSchema]);

  const cstUpdate = useCallback(
-    (data: ICstUpdateData, callback?: DataCallback<IConstituentaMeta>) => {
-      setError(undefined)
-      patchConstituenta(String(data.id), {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          reload(setProcessing, () => { if (callback != null) callback(newData); })
-        }
-      });
-    }, [setError, reload])
+  (data: ICstUpdateData, callback?: DataCallback<IConstituentaMeta>) => {
+    setError(undefined)
+    patchConstituenta(String(data.id), {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error) },
+      onSuccess: newData => {
+        reload(setProcessing, () => { if (callback != null) callback(newData); })
+      }
+    });
+  }, [setError, reload]);

  const cstMoveTo = useCallback(
-    (data: ICstMovetoData, callback?: () => void) => {
-      setError(undefined)
-      patchMoveConstituenta(schemaID, {
-        data: data,
-        showError: true,
-        setLoading: setProcessing,
-        onError: error => { setError(error) },
-        onSuccess: newData => {
-          setSchema(newData);
-          if (callback) callback();
-        }
-      });
-    }, [schemaID, setError, setSchema]);
+  (data: ICstMovetoData, callback?: () => void) => {
+    setError(undefined)
+    patchMoveConstituenta(schemaID, {
+      data: data,
+      showError: true,
+      setLoading: setProcessing,
+      onError: error => { setError(error) },
+      onSuccess: newData => {
+        setSchema(newData);
+        if (callback) callback();
+      }
+    });
+  }, [schemaID, setError, setSchema]);

  return (
    <RSFormContext.Provider value={{
@ -273,5 +281,5 @@ export const RSFormState = ({ schemaID, children }: RSFormStateProps) => {
    }}>
      { children }
    </RSFormContext.Provider>
-  )
+  );
 }
--- a/rsconcept/frontend/src/hooks/useNewRSForm.ts
+++ b/rsconcept/frontend/src/hooks/useNewRSForm.ts
@ -1,25 +0,0 @@
-import { useState } from 'react'
-
-import { type ErrorInfo } from '../components/BackendError';
-import { DataCallback, postNewRSForm } from '../utils/backendAPI';
-import { IRSFormCreateData, IRSFormMeta } from '../utils/models';
-
-function useNewRSForm() {
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<ErrorInfo>(undefined);
-
-  function createSchema(data: IRSFormCreateData, onSuccess: DataCallback<IRSFormMeta>) {
-    setError(undefined);
-    postNewRSForm({
-      data: data,
-      showError: true,
-      setLoading: setLoading,
-      onError: error => { setError(error); },
-      onSuccess: onSuccess
-    });
-  }
-
-  return { createSchema, error, setError, loading };
-}
-
-export default useNewRSForm;
--- a/rsconcept/frontend/src/pages/CreateRSFormPage.tsx
+++ b/rsconcept/frontend/src/pages/CreateRSFormPage.tsx
@ -11,13 +11,11 @@ import TextArea from '../components/Common/TextArea';
 import TextInput from '../components/Common/TextInput';
 import RequireAuth from '../components/RequireAuth';
 import { useLibrary } from '../context/LibraryContext';
-import useNewRSForm from '../hooks/useNewRSForm';
-import { IRSFormCreateData, IRSFormMeta } from '../utils/models';
+import { IRSFormCreateData } from '../utils/models';

 function CreateRSFormPage() {
  const navigate = useNavigate();
-  const { createSchema, error, setError, loading } = useNewRSForm();
-  const library = useLibrary();
+  const { createSchema, error, setError, processing } = useLibrary();

  const [title, setTitle] = useState('');
  const [alias, setAlias] = useState('');
@ -36,16 +34,10 @@ function CreateRSFormPage() {
      setFile(undefined);
    }
  }
-
-  function onSuccess(newSchema: IRSFormMeta) {
-    toast.success('Схема успешно создана');
-    library.reload();
-    navigate(`/rsforms/${newSchema.id}`);
-  }
  
  function handleSubmit(event: React.FormEvent<HTMLFormElement>) {
    event.preventDefault();
-    if (loading) {
+    if (processing) {
      return;
    }
    const data: IRSFormCreateData = {
@ -56,7 +48,10 @@ function CreateRSFormPage() {
      file: file,
      fileName: file?.name
    };
-    createSchema(data, onSuccess);
+    createSchema(data, (newSchema) => {
+      toast.success('Схема успешно создана');
+      navigate(`/rsforms/${newSchema.id}`);
+    });
  }

  return (
@ -95,7 +90,7 @@ function CreateRSFormPage() {
      <div className='flex items-center justify-center py-2 mt-4'>
        <SubmitButton 
          text='Создать схему'
-          loading={loading} 
+          loading={processing} 
        />
      </div>
      { error && <BackendError error={error} />}