@goplusvn/core 0.1.0 → 0.1.2

package/src/system/schemas/system-category.schema.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { STATUS_ACTIVE, STATUS_INACTIVE, STATUS_VALUES } from "../constants";
+
+/**
+ * System Category Validation Schema
+ */
+export const systemCategorySchema = z.object({
+  code: z
+    .string()
+    .min(1, "Mã danh mục là bắt buộc")
+    .max(50, "Mã danh mục tối đa 50 ký tự")
+    .trim(),
+
+  name: z
+    .string()
+    .min(1, "Tên danh mục là bắt buộc")
+    .max(200, "Tên danh mục tối đa 200 ký tự")
+    .trim(),
+
+  groupCode: z
+    .string()
+    .min(1, "Mã nhóm danh mục là bắt buộc")
+    .max(50, "Mã nhóm danh mục tối đa 50 ký tự"),
+
+  description: z
+    .string()
+    .max(1000, "Mô tả tối đa 1000 ký tự")
+    .optional()
+    .or(z.literal(""))
+    .transform((val) => val || ""),
+
+  status: z.preprocess((val) => {
+    // Support boolean from switch field
+    if (typeof val === "boolean") {
+      return val ? STATUS_ACTIVE : STATUS_INACTIVE;
+    }
+    // Support legacy Active/Inactive
+    if (val === "Active" || val === "Inactive") {
+      return val === "Active" ? STATUS_ACTIVE : STATUS_INACTIVE;
+    }
+    return val;
+  }, z.enum(STATUS_VALUES).default(STATUS_ACTIVE)),
+
+  order: z
+    .number()
+    .int("Thứ tự phải là số nguyên")
+    .min(0, "Thứ tự phải >= 0")
+    .optional(),
+});
+
+export type SystemCategoryInput = z.infer<typeof systemCategorySchema>;
+export const systemCategoryUpdateSchema = systemCategorySchema.partial();
+export const systemCategoryBulkSchema = z.object({
+  ids: z.array(z.string()).min(1, "Phải chọn ít nhất 1 danh mục"),
+  action: z.enum(["delete", "activate", "deactivate"]),
+});

package/src/system/services/settings-service.ts

@@ -0,0 +1,127 @@
+const db: any = { systemConfig: { findUnique: async () => null, upsert: async () => null } }; // Mocked for build
+
+import { cache } from "react";
+import { revalidateTag, unstable_cache } from "next/cache";
+
+export interface AuditSettings {
+  retentionDays: number;
+  enabledResources: string[];
+}
+
+export interface NotificationSettings {
+  retentionDays: number;
+  channels: {
+    email: boolean;
+    inApp: boolean;
+    telegram: boolean;
+  };
+}
+
+export interface SalesRulesSettings {
+  /** Require payment before creating order for orders below this threshold (VND) */
+  paymentRequiredThreshold: number;
+  /** Enable/disable the payment threshold rule */
+  paymentThresholdEnabled: boolean;
+  /** Required customer fields for invoice/contract creation */
+  requiredCustomerFields: string[];
+}
+
+const DEFAULT_AUDIT_SETTINGS: AuditSettings = {
+  retentionDays: 90,
+  enabledResources: ["*"],
+};
+
+const DEFAULT_NOTIFICATION_SETTINGS: NotificationSettings = {
+  retentionDays: 30,
+  channels: {
+    email: true,
+    inApp: true,
+    telegram: false,
+  },
+};
+
+const DEFAULT_SALES_RULES_SETTINGS: SalesRulesSettings = {
+  paymentRequiredThreshold: 10000000, // 10 million VND
+  paymentThresholdEnabled: true,
+  requiredCustomerFields: ["name", "phone", "idNumber"],
+};
+
+/**
+ * Settings Service for System Configuration
+ */
+export class SettingsService {
+  /** Get all settings cached */
+  static async getSettings<T>(key: string, defaultValue: T): Promise<T> {
+    return unstable_cache(
+      async () => {
+        const config = await db.systemConfig.findUnique({
+          where: { key },
+        });
+
+        if (!config?.value) return defaultValue;
+
+        try {
+          return JSON.parse(config.value) as T;
+        } catch {
+          return defaultValue;
+        }
+      },
+      [`system-settings-${key}`],
+      { tags: ["system-settings"] },
+    )();
+  }
+
+  static async getAuditSettings(): Promise<AuditSettings> {
+    return this.getSettings("audit", DEFAULT_AUDIT_SETTINGS);
+  }
+
+  static async getNotificationSettings(): Promise<NotificationSettings> {
+    return this.getSettings("notifications", DEFAULT_NOTIFICATION_SETTINGS);
+  }
+
+  static async getSalesRulesSettings(): Promise<SalesRulesSettings> {
+    return this.getSettings("sales-rules", DEFAULT_SALES_RULES_SETTINGS);
+  }
+
+  static async saveSettings<T>(
+    key: string,
+    value: T,
+    category = "general",
+  ): Promise<void> {
+    await db.systemConfig.upsert({
+      where: { key },
+      update: {
+        value: JSON.stringify(value),
+        updatedAt: new Date(),
+        updatedBy: "system", // TODO: Get user from session context if possible or pass it
+      },
+      create: {
+        key,
+        value: JSON.stringify(value),
+        type: "json",
+        category,
+        createdBy: "system",
+        updatedBy: "system",
+        updatedAt: new Date(),
+      },
+    });
+
+    revalidateTag("system-settings", "max");
+  }
+
+  static async saveAuditSettings(settings: AuditSettings): Promise<void> {
+    await this.saveSettings("audit", settings, "audit");
+  }
+
+  static async saveNotificationSettings(
+    settings: NotificationSettings,
+  ): Promise<void> {
+    await this.saveSettings("notifications", settings, "notifications");
+  }
+
+  static async saveSalesRulesSettings(
+    settings: SalesRulesSettings,
+  ): Promise<void> {
+    await this.saveSettings("sales-rules", settings, "sales");
+  }
+}

package/src/system/services/system-category-service.ts

@@ -0,0 +1,63 @@
+export interface SystemCategoryPrismaClient {
+  systemCategoryGroup: any;
+  systemCategory: any;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type SystemCategoryGroupFilters = any;
+
+/**
+ * Get system category groups data with pagination and filtering
+ * Shared function for both API route and Server Component
+ *
+ * @param db - The tenant-specific Prisma Client instance
+ * @param params - Filter and pagination parameters
+ */
+export async function getSystemCategoryGroupsData(
+  db: SystemCategoryPrismaClient,
+  params: SystemCategoryGroupFilters = {},
+) {
+  const { page = 1, pageSize = 10, search, status } = params;
+
+  const where = {
+    AND: [
+      search
+        ? {
+            OR: [
+              { code: { contains: search, mode: "insensitive" as const } },
+              { name: { contains: search, mode: "insensitive" as const } },
+              {
+                description: { contains: search, mode: "insensitive" as const },
+              },
+            ],
+          }
+        : {},
+      status && status !== "all" ? { status } : {},
+    ],
+  };
+
+  const [total, items] = await Promise.all([
+    db.systemCategoryGroup.count({ where }),
+    db.systemCategoryGroup.findMany({
+      where,
+      orderBy: { updatedAt: "desc" },
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+    }),
+  ]);
+
+  // Transform Prisma items to SystemCategoryGroup type format
+  const transformedItems = items.map((item: any) => ({
+    id: item.id,
+    code: item.code,
+    name: item.name,
+    description: item.description,
+    status: item.status,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString(),
+    createdBy: item.createdBy || undefined,
+    updatedBy: item.updatedBy || undefined,
+  }));
+
+  return { total, page, pageSize, items: transformedItems };
+}

package/src/system/types.ts

@@ -0,0 +1,45 @@
+export interface SystemCategoryGroup {
+  id: string;
+  code: string;
+  name: string;
+  description: string | null;
+  status: string;
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: string | null;
+  updatedBy?: string | null;
+}
+
+export interface SystemCategory {
+  id: string;
+  code: string;
+  name: string;
+  groupCode: string;
+  description: string | null;
+  status: string;
+  order: number | null;
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: string | null;
+  updatedBy?: string | null;
+}
+
+export interface SettingConfig {
+  id: string;
+  key: string;
+  value: string;
+  type: string;
+  category: string;
+  description?: string | null;
+  isEncrypted: boolean;
+  isReadOnly: boolean;
+  status: string;
+}
+
+export interface SettingGroup {
+  id: string;
+  label: string;
+  icon: string;
+  description: string;
+  categories: string[];
+}