@gadmin2n/schematics 0.0.64 → 0.0.65

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/audit/edit.tsx

@@ -0,0 +1,122 @@
+
+import {
+  FieldDataType,
+  handleInitialValues,
+  handleOnFinish,
+  ModelType,
+  produceModel,
+} from "@gadmin2n/react-common";
+import { Edit, ListButton, RefreshButton, useFileUploadState, useForm } from "@refinedev/antd";
+import { Form } from "antd";
+import { IResourceComponentsProps, useApiUrl, useParsed, useTranslate } from "@refinedev/core";
+import { getFormItem, onFormValuesChange } from "../../helpers";
+import React, { useContext, useState } from "react";
+
+import { modelsMap, modelsEnum } from "../../generated/models.index";
+import {
+  auditFormConfig as formConfig,
+  auditFormPrismaSelect as formPrismaSelect,
+} from "../../generated/props/audit/config";
+import {
+  auditModel,
+  useRelation,
+} from "../../generated/props/audit/model";
+import { Audit } from "../../generated/types/prisma.types";
+import { AuditForm as transformClass } from "../../generated/props/audit/form.validator";
+import { BusinessContext } from 'components/contexts/business';
+
+export const AuditEdit: React.FC<IResourceComponentsProps> = () => {
+  const resourceName = "audit";
+  const t = useTranslate();
+  
+
+  const [[fields, model]] = useState(() => {
+    const model: ModelType = produceModel(
+      auditModel,
+      {
+        // all formItem attrs surport, https://ant.design/components/form#formitem
+        // description : { component : <MDEditor data-color-mode="light" /> },
+        // status : { normalize : (value: any) => value ? "1" : "0" },
+        // cron: {validator: { validator: runCronValidator },},
+      },
+      transformClass
+    );
+
+    const fields: FieldDataType[] = formConfig.fields
+      .map((fieldName: string) => model[fieldName])
+      .filter((field: FieldDataType) => field);
+
+    return [fields, model] as const;
+  });
+
+  const { formProps, saveButtonProps, onFinish, form } =
+    useForm<Audit>({
+      meta: { select: formPrismaSelect},
+    });
+  formProps.initialValues = handleInitialValues(
+    formProps.initialValues || {},
+    fields
+  );
+
+  const apiUrl = useApiUrl();
+  const { isLoading, onChange } = useFileUploadState();
+
+  const relationSelectProps = useRelation(modelsMap);
+
+  return (
+    <Edit
+      saveButtonProps={{
+        ...saveButtonProps,
+        disabled: isLoading,
+      }}
+      headerButtons={
+        <>
+          <ListButton />
+          <RefreshButton
+            meta={{ select: formPrismaSelect}}
+          />
+        </>
+      }
+    >
+      <Form
+        {...formProps}
+        validateTrigger="onBlur"
+        onFinish={(values) => {
+          onFinish(
+            handleOnFinish(
+              {
+                ...values,
+                
+                id: undefined,
+              },
+              fields,
+              "edit"
+            )
+          );
+        }}
+        layout="vertical"
+        form={form}
+        onValuesChange={onFormValuesChange(
+          form,
+          formConfig.reaction,
+        )}
+      >
+        {fields.map((field) => {
+          return getFormItem(
+            field,
+            resourceName,
+            t,
+            form,
+            formConfig.reaction,
+            modelsEnum,
+            model,
+            apiUrl,
+            relationSelectProps,
+            onChange
+          );
+        })}
+      </Form>
+    </Edit>
+  );
+};
+  

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/audit/index.ts

@@ -0,0 +1,8 @@
+export * from './list';
+
+// Stub exports for generated/resources.tsx compatibility (gadmin2 generated imports)
+const EmptyComponent = () => null;
+export const AuditCreate = EmptyComponent;
+export const AuditEdit = EmptyComponent;
+export const AuditList = EmptyComponent;
+export const AuditShow = EmptyComponent;

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/audit/index.tsx

@@ -0,0 +1,6 @@
+
+export * from "./list";
+export * from "./create";
+export * from "./edit";
+export * from "./show";
+  

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/audit/list.tsx

@@ -0,0 +1,213 @@
+import {
+  DateField,
+  FilterDropdown,
+  getDefaultSortOrder,
+  List,
+  rangePickerFilterMapper,
+  useTable,
+} from "@refinedev/antd";
+import { getDefaultFilter, HttpError } from "@refinedev/core";
+
+import { SearchOutlined } from "@ant-design/icons";
+import {
+  DatePicker,
+  Input,
+  Radio,
+  Space,
+  Table,
+  Tag,
+  type TagProps,
+} from "antd";
+
+import { CustomAvatar, PaginationTotal } from "components";
+import { AuditLogActionEnum, auditLogActionOptions } from "enums";
+import { AuditLog } from "types";
+
+import { ActionCell } from "./components/action-cell";
+import { LIST_CONTENT_PROPS } from "constants/layout";
+
+
+const getActionColor = (action: string): TagProps["color"] => {
+  switch (action) {
+    case AuditLogActionEnum.create:
+      return "green";
+    case AuditLogActionEnum.update:
+      return "cyan";
+    case AuditLogActionEnum.delete:
+      return "red";
+    default:
+      return "default";
+  }
+};
+
+export const AuditLogPage = () => {
+  const { tableProps, filters, sorters } = useTable<
+    AuditLog,
+    HttpError,
+    Partial<AuditLog>
+  >({
+    resource: "audit",
+    pagination: {
+      pageSize: 20,
+    },
+    filters: {
+      initial: [
+        { field: "authorName", operator: "contains", value: "" },
+        { field: "resource", operator: "contains", value: "" },
+        { field: "timestamp", value: undefined as any, operator: "between" },
+      ],
+    },
+    sorters: {
+      initial: [{ field: "id", order: "desc" }],
+    },
+  });
+
+  // fix for ant design filter dropdown contains operator
+  filters.map((filter) => {
+    if (filter.operator === "contains" && Array.isArray(filter.value)) {
+      filter.value = filter.value.join(",");
+    }
+  });
+
+  return (
+    <div className="page-container">
+      <List breadcrumb={false} canCreate={false} contentProps={LIST_CONTENT_PROPS}>
+        <Table
+          className="audit-log-table"
+          {...tableProps}
+          rowKey="id"
+          scroll={{ x: true }}
+          pagination={{
+            ...tableProps.pagination,
+            showTotal: (total) => (
+              <PaginationTotal total={total} entityName="audit logs" />
+            ),
+          }}
+        >
+          <Table.Column
+            dataIndex="authorName"
+            title="User"
+            width="15%"
+            filterIcon={<SearchOutlined />}
+            render={(_, record: AuditLog) => {
+              return (
+                <Space>
+                  <CustomAvatar
+                    src={`https://rhrc.woa.com/photo/150/${record.authorName}.png`}
+                    name={record.authorName}
+                  />
+                  {record.authorName || "N/A"}
+                </Space>
+              );
+            }}
+            filterDropdown={(props) => (
+              <FilterDropdown
+                {...(props as any)}
+                clearFilters={() => {
+                  props.setSelectedKeys([]);
+                  props.confirm?.();
+                }}
+              >
+                <Input />
+              </FilterDropdown>
+            )}
+            defaultFilteredValue={getDefaultFilter(
+              "authorName",
+              filters,
+              "contains"
+            )}
+          />
+          <Table.Column
+            dataIndex="action"
+            title="Action"
+            render={(_, record: AuditLog) => {
+              return (
+                <Space>
+                  <Tag color={getActionColor(record.action)}>
+                    {
+                      auditLogActionOptions.find(
+                        (option) => option.value === record.action
+                      )?.label
+                    }
+                  </Tag>
+                </Space>
+              );
+            }}
+            filterDropdown={(props) => (
+              <FilterDropdown
+                {...(props as any)}
+                clearFilters={() => {
+                  props.setSelectedKeys([]);
+                  props.confirm?.();
+                }}
+              >
+                <Radio.Group>
+                  {auditLogActionOptions.map((option) => (
+                    <Radio key={option.value} value={option.value}>
+                      {option.label}
+                    </Radio>
+                  ))}
+                </Radio.Group>
+              </FilterDropdown>
+            )}
+            defaultFilteredValue={getDefaultFilter("action", filters, "eq")}
+          />
+          <Table.Column
+            dataIndex="resource"
+            title="Entity"
+            filterIcon={<SearchOutlined />}
+            filterDropdown={props => (
+              <FilterDropdown
+                {...(props as any)}
+                clearFilters={() => {
+                  props.setSelectedKeys([]);
+                  props.confirm?.();
+                }}
+              >
+                <Input />
+              </FilterDropdown>
+            )}
+            defaultFilteredValue={getDefaultFilter("resource", filters, "contains")}
+          />
+          <Table.Column dataIndex="resourceId" title="Entity ID" />
+          <Table.Column
+            dataIndex="data"
+            title="Changes"
+            render={(_, record: AuditLog) => <ActionCell record={record} />}
+          />
+          <Table.Column
+            dataIndex="timestamp"
+            title="Date & Time"
+            width="15%"
+            render={(value) => (
+              <DateField
+                style={{ verticalAlign: "middle" }}
+                value={value}
+                format="YYYY-MM-DD hh:mm:ss"
+              />
+            )}
+            filterDropdown={(props) => (
+              <FilterDropdown
+                {...(props as any)}
+                mapValue={rangePickerFilterMapper}
+                clearFilters={() => {
+                  props.setSelectedKeys([]);
+                  props.confirm?.();
+                }}
+              >
+                <DatePicker.RangePicker />
+              </FilterDropdown>
+            )}
+            sorter
+            defaultFilteredValue={getDefaultFilter(
+              "timestamp",
+              filters,
+              "between"
+            )}
+            defaultSortOrder={getDefaultSortOrder("timestamp", sorters)}
+          />
+        </Table>
+      </List>
+    </div>
+  );
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/audit/show.tsx

@@ -0,0 +1,61 @@
+
+import { ModelType, getColumns, produceModel } from "@gadmin2n/react-common";
+import { CloneButton, DeleteButton, EditButton, ListButton, RefreshButton, Show } from "@refinedev/antd";
+import { IResourceComponentsProps, useShow, useTranslate } from "@refinedev/core";
+import React, { useState } from "react";
+import { getShowField } from "../../helpers";
+import type { Audit } from "../../generated/types/prisma.types"; //'.prisma/client/index';
+import {
+  auditShowConfig as showConfig,
+  auditShowPrismaSelect as showPrismaSelect,
+} from "../../generated/props/audit/config";
+import { auditModel } from "../../generated/props/audit/model";
+import { modelsMap } from "generated/models.index";
+
+export const AuditShow: React.FC<IResourceComponentsProps> = () => {
+  const resourceName = "audit";
+  const t = useTranslate();
+  
+  const { queryResult } = useShow<Audit>({
+    meta: { select: showPrismaSelect},
+  });
+  const { data, isLoading } = queryResult;
+  const record = data?.data;
+
+  const [[fields, model]] = useState(() => {
+    const model: ModelType = produceModel(auditModel, {
+      // status: { render: xxxxx }
+    });
+
+    // getColumns is a function that returns an array of fields
+    const fields = getColumns("Audit", showConfig.fields, {
+      ...modelsMap,
+      Audit: { model, meta: modelsMap["Audit"].meta },
+    });
+
+    return [fields, model] as const;
+  });
+
+  return (
+    <Show
+      isLoading={isLoading}
+      headerButtons={
+        <>
+          <ListButton/>
+          <EditButton recordItemId={record?.id} />
+          <CloneButton recordItemId={record?.id} />
+          <DeleteButton recordItemId={record?.id} />
+          <RefreshButton
+            recordItemId={record?.id}
+            meta={{ select: showPrismaSelect}}
+          />
+        </>
+      }
+    >
+      {fields.map((field: any) => {
+        return getShowField(field, resourceName, record, t, model, modelsMap);
+      })}
+    </Show>
+  );
+};
+

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/page/Components/AssignRolesModal.tsx

@@ -0,0 +1,168 @@
+import React, { useEffect, useMemo, useState } from "react";
+import { Checkbox, Modal, Spin, message } from "antd";
+import { customRequest } from "helpers/login";
+
+interface Role {
+  id: number;
+  name: string;
+  description?: string;
+}
+
+interface RolePage {
+  roleId: number;
+  pageId: number;
+}
+
+interface AssignRolesModalProps {
+  pageId: number;
+  pageName: string;
+  open: boolean;
+  onClose: () => void;
+  onSuccess: () => void;
+}
+
+export const AssignRolesModal: React.FC<AssignRolesModalProps> = ({
+  pageId,
+  pageName,
+  open,
+  onClose,
+  onSuccess,
+}) => {
+  const [roles, setRoles] = useState<Role[]>([]);
+  const [rolePages, setRolePages] = useState<RolePage[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [selectedRoleIds, setSelectedRoleIds] = useState<number[]>([]);
+
+  // Fetch all roles and rolePages when modal opens
+  useEffect(() => {
+    if (!open) return;
+
+    const fetchData = async () => {
+      setLoading(true);
+      try {
+        const [rolesRes, rolePagesRes] = await Promise.all([
+          customRequest<any>("role/findMany", "post"),
+          customRequest<any>("rolePages/findMany", "post"),
+        ]);
+        const rolesData: Role[] = Array.isArray(rolesRes?.data) ? rolesRes.data : [];
+        const rolePagesData: RolePage[] = Array.isArray(rolePagesRes?.data)
+          ? rolePagesRes.data
+          : [];
+        setRoles(rolesData);
+        setRolePages(rolePagesData);
+      } catch (error) {
+        console.error("Failed to fetch data:", error);
+        message.error("Failed to load roles data");
+      }
+      setLoading(false);
+    };
+
+    fetchData();
+  }, [open]);
+
+  // Role IDs that already have this page assigned
+  const existingRoleIds = useMemo(() => {
+    return rolePages
+      .filter((rp) => rp.pageId === pageId)
+      .map((rp) => rp.roleId);
+  }, [rolePages, pageId]);
+
+  // Initialize selected roles when data loads
+  useEffect(() => {
+    setSelectedRoleIds(existingRoleIds);
+  }, [existingRoleIds]);
+
+  // Build a map: roleId -> all pageIds for that role
+  const rolePageIdsMap = useMemo(() => {
+    const map: Record<number, number[]> = {};
+    for (const rp of rolePages) {
+      if (!map[rp.roleId]) {
+        map[rp.roleId] = [];
+      }
+      if (!map[rp.roleId].includes(rp.pageId)) {
+        map[rp.roleId].push(rp.pageId);
+      }
+    }
+    return map;
+  }, [rolePages]);
+
+  const handleSave = async () => {
+    // Find newly added role IDs (not in existingRoleIds)
+    const newRoleIds = selectedRoleIds.filter((id) => !existingRoleIds.includes(id));
+
+    if (newRoleIds.length === 0) {
+      message.info("No new roles selected");
+      onClose();
+      return;
+    }
+
+    setSaving(true);
+    try {
+      const updatePromises = newRoleIds.map((roleId) => {
+        const currentPageIds = rolePageIdsMap[roleId] || [];
+        const updatedPageIds = [...currentPageIds, pageId];
+        return customRequest(`role/updateUnique/${roleId}`, "PATCH", {
+          pageIds: updatedPageIds,
+        });
+      });
+
+      await Promise.all(updatePromises);
+      message.success(`Successfully assigned ${newRoleIds.length} role(s) to page "${pageName}"`);
+      onSuccess();
+    } catch (error) {
+      console.error("Failed to assign roles:", error);
+      message.error("Failed to assign some roles. Please try again.");
+    }
+    setSaving(false);
+  };
+
+  return (
+    <Modal
+      title={`Assign Roles to Page: ${pageName}`}
+      open={open}
+      onCancel={onClose}
+      onOk={handleSave}
+      okText="Save"
+      confirmLoading={saving}
+      width={560}
+    >
+      <Spin spinning={loading}>
+        {existingRoleIds.length > 0 && (
+          <div style={{ marginBottom: 12, color: "#666" }}>
+            Currently <strong>{existingRoleIds.length}</strong> role(s) can access this page
+          </div>
+        )}
+        <div style={{ maxHeight: 400, overflow: "auto" }}>
+          <Checkbox.Group
+            value={selectedRoleIds}
+            onChange={(values) => setSelectedRoleIds(values as number[])}
+            style={{ display: "flex", flexDirection: "column", gap: 8 }}
+          >
+            {[...roles]
+              .sort((a, b) => {
+                const aExisting = existingRoleIds.includes(a.id);
+                const bExisting = existingRoleIds.includes(b.id);
+                if (aExisting !== bExisting) return aExisting ? -1 : 1;
+                return 0;
+              })
+              .map((role) => {
+                const isExisting = existingRoleIds.includes(role.id);
+                return (
+                  <Checkbox key={role.id} value={role.id} disabled={isExisting}>
+                    <span style={{ fontWeight: 500 }}>{role.name}</span>
+                    {role.description && (
+                      <span style={{ color: "#999", marginLeft: 8 }}>{role.description}</span>
+                    )}
+                  </Checkbox>
+                );
+              })}
+          </Checkbox.Group>
+          {!loading && roles.length === 0 && (
+            <span style={{ color: "#999" }}>No roles available</span>
+          )}
+        </div>
+      </Spin>
+    </Modal>
+  );
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/page/Components/CreatePageModal.tsx

@@ -0,0 +1,42 @@
+import React from "react";
+
+import { PageFormModal } from "./PageFormModal";
+import type { PageMenuTreeNode, ResourceDefinition } from "../types";
+
+interface CreatePageModalProps {
+  onModalClose: () => void;
+  onPageCreationSuccess?: () => void;
+  parentPageTreeOptions?: PageMenuTreeNode[];
+  allAvailableResources?: ResourceDefinition[];
+  allPagesData?: any[];
+  defaultParentId?: number | null;
+  defaultPathPrefix?: string;
+}
+
+export const CreatePageModal: React.FC<CreatePageModalProps> = ({
+  onModalClose,
+  onPageCreationSuccess,
+  parentPageTreeOptions,
+  allAvailableResources,
+  allPagesData,
+  defaultParentId,
+  defaultPathPrefix,
+}) => {
+  const handlePageCreationMutationSuccess = () => {
+    onPageCreationSuccess?.();
+    onModalClose?.();
+  };
+
+  return (
+    <PageFormModal
+      formActionType="create"
+      onModalCancel={onModalClose}
+      onFormSubmitSuccess={handlePageCreationMutationSuccess}
+      parentPageTreeOptions={parentPageTreeOptions}
+      allAvailableResources={allAvailableResources}
+      allPagesData={allPagesData}
+      defaultParentId={defaultParentId}
+      defaultPathPrefix={defaultPathPrefix}
+    />
+  );
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/page/Components/EditPageModal.tsx

@@ -0,0 +1,42 @@
+import React from "react";
+
+import { PageFormModal } from "./PageFormModal";
+import type { PageMenuTreeNode, PageResourceAssignment, ResourceDefinition } from "../types";
+
+interface EditPageModalProps {
+  pageIdToEdit?: number;
+  onModalClose: () => void;
+  onPageEditSuccess?: () => void;
+  parentPageTreeOptions?: PageMenuTreeNode[];
+  allAvailableResources?: ResourceDefinition[];
+  currentPageResourceAssignments?: PageResourceAssignment[];
+  allPagesData?: any[];
+}
+
+export const EditPageModal: React.FC<EditPageModalProps> = ({
+  pageIdToEdit,
+  onModalClose,
+  onPageEditSuccess,
+  parentPageTreeOptions,
+  allAvailableResources,
+  currentPageResourceAssignments,
+  allPagesData,
+}) => {
+  const handlePageEditMutationSuccess = () => {
+    onPageEditSuccess?.();
+    onModalClose();
+  };
+
+  return (
+    <PageFormModal
+      formActionType="edit"
+      editingPageId={pageIdToEdit}
+      onModalCancel={onModalClose}
+      onFormSubmitSuccess={handlePageEditMutationSuccess}
+      parentPageTreeOptions={parentPageTreeOptions}
+      allAvailableResources={allAvailableResources}
+      currentResourceAssignments={currentPageResourceAssignments}
+      allPagesData={allPagesData}
+    />
+  );
+};