@gadmin2n/schematics 0.0.71 → 0.0.72

package/src/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useBatchOperations.ts

@@ -1,153 +0,0 @@
-import { useCallback } from 'react';
-import { useRowSelection, UseRowSelectionResult } from './useRowSelection';
-import {
-  useBatchUpdate,
-  UseBatchUpdateConfig,
-  BatchUpdateResult,
-} from './useBatchUpdate';
-import {
-  useBatchDelete,
-  UseBatchDeleteConfig,
-  BatchDeleteResult,
-} from './useBatchDelete';
-
-export interface UseBatchOperationsConfig
-  extends
-    Omit<UseBatchUpdateConfig, 'onComplete' | 'onSuccess' | 'onError'>,
-    Omit<
-      UseBatchDeleteConfig,
-      'onComplete' | 'onSuccess' | 'onError' | 'resourceName'
-    > {
-  /** Called after batch update completes */
-  onUpdateComplete?: (result: BatchUpdateResult) => void;
-  /** Called after batch delete completes */
-  onDeleteComplete?: (result: BatchDeleteResult) => void;
-  /** Called when any batch operation succeeds (for refetch, etc.) */
-  onSuccess?: () => void;
-}
-
-export interface UseBatchOperationsResult extends UseRowSelectionResult {
-  /** Update selected items */
-  updateSelectedItems: (values: any) => Promise<void>;
-  /** Delete selected items */
-  deleteSelectedItems: () => Promise<void>;
-  /** Update a single item */
-  updateOne: (id: number, values: any) => Promise<void>;
-  /** Delete a single item */
-  deleteOne: (id: number) => Promise<void>;
-  /** Update loading state */
-  updateManyIsLoading: boolean;
-  /** Delete loading state */
-  deleteManyIsLoading: boolean;
-}
-
-/**
- * Combined hook for all batch operations (selection, update, delete)
- *
- * @example
- * // Basic usage
- * const batchOps = useBatchOperations({
- *   resourceName: 'audit',
- *   apiUrl: '/api',
- *   onSuccess: () => refetch(),
- * });
- *
- * @example
- * // With custom handlers
- * const batchOps = useBatchOperations({
- *   resourceName: 'audit',
- *   apiUrl: '/api',
- *   showNotification: false,
- *   onUpdateComplete: (result) => {
- *     console.log('Updated:', result.successCount);
- *   },
- *   onDeleteComplete: (result) => {
- *     console.log('Deleted:', result.successCount);
- *   },
- * });
- */
-export function useBatchOperations({
-  resourceName,
-  apiUrl,
-  requestHeaders,
-  onSuccess,
-  onUpdateComplete,
-  onDeleteComplete,
-  t,
-  showNotification,
-  customNotification,
-  customUpdateFn,
-  customDeleteFn,
-  confirmDelete,
-}: UseBatchOperationsConfig): UseBatchOperationsResult {
-  const {
-    selectedRowKeys,
-    setSelectedRowKeys,
-    rowSelection,
-    hasSelected,
-    clearSelection,
-  } = useRowSelection();
-
-  const {
-    updateSelectedItems: batchUpdate,
-    updateOne,
-    updateManyIsLoading,
-  } = useBatchUpdate({
-    resourceName,
-    apiUrl,
-    requestHeaders,
-    t,
-    showNotification,
-    customNotification: customNotification as any,
-    customUpdateFn,
-    onComplete: onUpdateComplete,
-    onSuccess: onSuccess ? () => onSuccess() : undefined,
-  });
-
-  const {
-    deleteSelectedItems: batchDelete,
-    deleteOne,
-    deleteManyIsLoading,
-  } = useBatchDelete({
-    resourceName,
-    t,
-    showNotification,
-    customNotification: customNotification as any,
-    customDeleteFn,
-    confirmDelete,
-    onComplete: onDeleteComplete,
-    onSuccess: onSuccess ? () => onSuccess() : undefined,
-  });
-
-  const updateSelectedItems = useCallback(
-    async (values: any) => {
-      const failedIds = await batchUpdate(selectedRowKeys, values);
-      setSelectedRowKeys(failedIds);
-    },
-    [batchUpdate, selectedRowKeys, setSelectedRowKeys],
-  );
-
-  const deleteSelectedItems = useCallback(async () => {
-    const failedIds = await batchDelete(selectedRowKeys);
-    setSelectedRowKeys(failedIds);
-  }, [batchDelete, selectedRowKeys, setSelectedRowKeys]);
-
-  return {
-    // Selection
-    selectedRowKeys,
-    setSelectedRowKeys,
-    rowSelection,
-    hasSelected,
-    clearSelection,
-
-    // Operations
-    updateSelectedItems,
-    deleteSelectedItems,
-    updateOne,
-    deleteOne,
-
-    // Loading states
-    updateManyIsLoading,
-    deleteManyIsLoading,
-  };
-}

package/src/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useBatchOperationsCore.ts

@@ -1,193 +0,0 @@
-import { useState, useCallback } from 'react';
-import { useRowSelection } from './useRowSelection';
-
-export interface BatchOperationResult {
-  successIds: React.Key[];
-  failedIds: React.Key[];
-  successCount: number;
-  failedCount: number;
-}
-
-export interface UseBatchOperationsCoreConfig {
-  /** Function to update a single item */
-  updateFn?: (id: number, values: any) => Promise<void>;
-  /** Function to delete a single item */
-  deleteFn?: (id: number) => Promise<void>;
-}
-
-export interface UseBatchOperationsCoreResult {
-  // Selection
-  selectedRowKeys: React.Key[];
-  setSelectedRowKeys: React.Dispatch<React.SetStateAction<React.Key[]>>;
-  rowSelection: {
-    selectedRowKeys: React.Key[];
-    onChange: (keys: React.Key[]) => void;
-  };
-  hasSelected: boolean;
-  clearSelection: () => void;
-
-  // Core operations (no UI, no notifications)
-  updateMany: (keys: React.Key[], values: any) => Promise<BatchOperationResult>;
-  deleteMany: (keys: React.Key[]) => Promise<BatchOperationResult>;
-  updateOne: (id: number, values: any) => Promise<void>;
-  deleteOne: (id: number) => Promise<void>;
-
-  // Loading states
-  isUpdating: boolean;
-  isDeleting: boolean;
-}
-
-/**
- * Core hook for batch operations - NO UI logic, NO notifications
- * Use this when you need full control over the UI and feedback.
- *
- * @example
- * const {
- *   selectedRowKeys,
- *   rowSelection,
- *   updateMany,
- *   deleteMany,
- *   isUpdating,
- *   isDeleting,
- * } = useBatchOperationsCore({
- *   updateFn: async (id, values) => {
- *     await api.patch(`/audit/${id}`, values);
- *   },
- *   deleteFn: async (id) => {
- *     await api.delete(`/audit/${id}`);
- *   },
- * });
- *
- * // Handle update with custom UI
- * const handleBatchUpdate = async (values) => {
- *   const result = await updateMany(selectedRowKeys, values);
- *
- *   // Custom notification
- *   if (result.failedCount > 0) {
- *     toast.error(`Failed to update ${result.failedCount} items`);
- *   } else {
- *     toast.success(`Updated ${result.successCount} items`);
- *   }
- *
- *   // Update selection to only keep failed items
- *   setSelectedRowKeys(result.failedIds);
- * };
- */
-export function useBatchOperationsCore({
-  updateFn,
-  deleteFn,
-}: UseBatchOperationsCoreConfig = {}): UseBatchOperationsCoreResult {
-  const {
-    selectedRowKeys,
-    setSelectedRowKeys,
-    rowSelection,
-    hasSelected,
-    clearSelection,
-  } = useRowSelection();
-
-  const [isUpdating, setIsUpdating] = useState(false);
-  const [isDeleting, setIsDeleting] = useState(false);
-
-  // Single item operations
-  const updateOne = useCallback(
-    async (id: number, values: any): Promise<void> => {
-      if (!updateFn) {
-        throw new Error('updateFn is not provided');
-      }
-      await updateFn(id, values);
-    },
-    [updateFn],
-  );
-
-  const deleteOne = useCallback(
-    async (id: number): Promise<void> => {
-      if (!deleteFn) {
-        throw new Error('deleteFn is not provided');
-      }
-      await deleteFn(id);
-    },
-    [deleteFn],
-  );
-
-  // Batch operations - just execute and return results, no UI logic
-  const updateMany = useCallback(
-    async (keys: React.Key[], values: any): Promise<BatchOperationResult> => {
-      if (!updateFn) {
-        throw new Error('updateFn is not provided');
-      }
-
-      setIsUpdating(true);
-      const successIds: React.Key[] = [];
-      const failedIds: React.Key[] = [];
-
-      for (const id of keys) {
-        try {
-          await updateFn(Number(id), values);
-          successIds.push(id);
-        } catch {
-          failedIds.push(id);
-        }
-      }
-
-      setIsUpdating(false);
-
-      return {
-        successIds,
-        failedIds,
-        successCount: successIds.length,
-        failedCount: failedIds.length,
-      };
-    },
-    [updateFn],
-  );
-
-  const deleteMany = useCallback(
-    async (keys: React.Key[]): Promise<BatchOperationResult> => {
-      if (!deleteFn) {
-        throw new Error('deleteFn is not provided');
-      }
-
-      setIsDeleting(true);
-      const successIds: React.Key[] = [];
-      const failedIds: React.Key[] = [];
-
-      for (const id of keys) {
-        try {
-          await deleteFn(Number(id));
-          successIds.push(id);
-        } catch {
-          failedIds.push(id);
-        }
-      }
-
-      setIsDeleting(false);
-
-      return {
-        successIds,
-        failedIds,
-        successCount: successIds.length,
-        failedCount: failedIds.length,
-      };
-    },
-    [deleteFn],
-  );
-
-  return {
-    // Selection
-    selectedRowKeys,
-    setSelectedRowKeys,
-    rowSelection,
-    hasSelected,
-    clearSelection,
-
-    // Core operations
-    updateMany,
-    deleteMany,
-    updateOne,
-    deleteOne,
-
-    // Loading states
-    isUpdating,
-    isDeleting,
-  };
-}

package/src/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useBatchUpdate.ts

@@ -1,182 +0,0 @@
-import { useState, useCallback } from 'react';
-import { notification } from 'antd';
-
-export interface BatchUpdateResult {
-  successIds: React.Key[];
-  failedIds: React.Key[];
-  successCount: number;
-  failedCount: number;
-}
-
-export interface UseBatchUpdateConfig {
-  resourceName: string;
-  apiUrl: string;
-  requestHeaders?: () => Record<string, string>;
-  /** Called after all updates complete (regardless of success/failure) */
-  onComplete?: (result: BatchUpdateResult) => void;
-  /** Called only when at least one update succeeds */
-  onSuccess?: (result: BatchUpdateResult) => void;
-  /** Called only when at least one update fails */
-  onError?: (result: BatchUpdateResult) => void;
-  /** i18n translation function */
-  t?: (key: string, defaultValue?: string) => string;
-  /** Whether to show notification (default: true) */
-  showNotification?: boolean;
-  /** Custom notification handler - if provided, replaces default notification */
-  customNotification?: (result: BatchUpdateResult) => void;
-  /** Custom update function - if provided, replaces default fetch */
-  customUpdateFn?: (id: number, values: any) => Promise<void>;
-}
-
-export interface UseBatchUpdateResult {
-  /** Update selected items and return failed IDs */
-  updateSelectedItems: (
-    selectedKeys: React.Key[],
-    values: any,
-  ) => Promise<React.Key[]>;
-  /** Update a single item */
-  updateOne: (id: number, values: any) => Promise<void>;
-  /** Loading state */
-  updateManyIsLoading: boolean;
-}
-
-/**
- * Hook for batch updating selected items
- *
- * @example
- * // Basic usage
- * const { updateSelectedItems, updateManyIsLoading } = useBatchUpdate({
- *   resourceName: 'audit',
- *   apiUrl: '/api',
- * });
- *
- * @example
- * // With custom notification
- * const { updateSelectedItems } = useBatchUpdate({
- *   resourceName: 'audit',
- *   apiUrl: '/api',
- *   showNotification: false,
- *   onComplete: (result) => {
- *     myCustomNotify(`Updated ${result.successCount} items`);
- *   },
- * });
- *
- * @example
- * // With custom update function
- * const { updateSelectedItems } = useBatchUpdate({
- *   resourceName: 'audit',
- *   apiUrl: '/api',
- *   customUpdateFn: async (id, values) => {
- *     await myApi.updateAudit(id, values);
- *   },
- * });
- */
-export function useBatchUpdate({
-  resourceName,
-  apiUrl,
-  requestHeaders,
-  onComplete,
-  onSuccess,
-  onError,
-  t = (key, defaultValue) => defaultValue || key,
-  showNotification = true,
-  customNotification,
-  customUpdateFn,
-}: UseBatchUpdateConfig): UseBatchUpdateResult {
-  const [updateManyIsLoading, setUpdateManyIsLoading] = useState(false);
-
-  const updateOne = useCallback(
-    async (id: number, values: any): Promise<void> => {
-      if (customUpdateFn) {
-        return customUpdateFn(id, values);
-      }
-
-      const url = `${apiUrl}/${resourceName}/updateUnique/${id}`;
-      const response = await fetch(url, {
-        method: 'PATCH',
-        headers: {
-          'Content-Type': 'application/json;charset=utf-8',
-          Accept: 'application/json',
-          ...(requestHeaders?.() || {}),
-        },
-        body: JSON.stringify(values),
-      });
-
-      if (!response.ok) {
-        throw new Error(`Update failed for id ${id}`);
-      }
-    },
-    [apiUrl, resourceName, requestHeaders, customUpdateFn],
-  );
-
-  const updateSelectedItems = useCallback(
-    async (selectedKeys: React.Key[], values: any): Promise<React.Key[]> => {
-      setUpdateManyIsLoading(true);
-
-      const successIds: React.Key[] = [];
-      const failedIds: React.Key[] = [];
-
-      for (const id of selectedKeys) {
-        try {
-          await updateOne(Number(id), values);
-          successIds.push(id);
-        } catch {
-          failedIds.push(id);
-        }
-      }
-
-      setUpdateManyIsLoading(false);
-
-      const result: BatchUpdateResult = {
-        successIds,
-        failedIds,
-        successCount: successIds.length,
-        failedCount: failedIds.length,
-      };
-
-      // Callbacks
-      onComplete?.(result);
-      if (result.successCount > 0) {
-        onSuccess?.(result);
-      }
-      if (result.failedCount > 0) {
-        onError?.(result);
-      }
-
-      // Notification
-      if (customNotification) {
-        customNotification(result);
-      } else if (showNotification) {
-        const message = t(
-          'batch.updateResult',
-          `Update success: ${result.successCount}, failed: ${result.failedCount}`,
-        );
-
-        if (result.failedCount === selectedKeys.length) {
-          notification.error({ message });
-        } else if (result.failedCount > 0) {
-          notification.warning({ message });
-        } else {
-          notification.success({ message });
-        }
-      }
-
-      return failedIds;
-    },
-    [
-      updateOne,
-      onComplete,
-      onSuccess,
-      onError,
-      t,
-      showNotification,
-      customNotification,
-    ],
-  );
-
-  return {
-    updateSelectedItems,
-    updateOne,
-    updateManyIsLoading,
-  };
-}