@gadmin2n/schematics 0.0.70 → 0.0.71

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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,193 @@
+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

@@ -0,0 +1,182 @@
+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,
+  };
+}