@goplusvn/core 0.1.0 → 0.1.1

package/src/system/components/settings/settings-search.tsx

@@ -0,0 +1,71 @@
+"use client";
+
+import * as React from "react";
+import { Search, Command } from "lucide-react";
+import { cn } from "../../../utils";
+import { Input } from "../../../ui/primitives/input";
+
+interface SettingsSearchProps {
+  value: string;
+  onChange: (value: string) => void;
+  onKeyDown?: (e: React.KeyboardEvent) => void;
+  className?: string;
+  resultCount?: number;
+}
+
+export function SettingsSearch({
+  value,
+  onChange,
+  onKeyDown,
+  className,
+  resultCount,
+}: SettingsSearchProps) {
+  const inputRef = React.useRef<HTMLInputElement>(null);
+
+  // Global keyboard shortcut (Cmd+K / Ctrl+K)
+  React.useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+        e.preventDefault();
+        inputRef.current?.focus();
+      }
+      if (e.key === "Escape" && document.activeElement === inputRef.current) {
+        inputRef.current?.blur();
+        onChange("");
+      }
+    };
+
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [onChange]);
+
+  return (
+    <div className={cn("relative", className)}>
+      <div className="relative">
+        <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+        <Input
+          ref={inputRef}
+          type="text"
+          placeholder="Tìm kiếm cấu hình..."
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          onKeyDown={onKeyDown}
+          className={cn(
+            "pl-9 pr-20 h-11 bg-muted/50 border-0 focus-visible:bg-background focus-visible:ring-1",
+            "placeholder:text-muted-foreground/60 text-sm",
+          )}
+        />
+        <div className="absolute right-3 top-1/2 -translate-y-1/2 flex items-center gap-1">
+          {resultCount !== undefined && value && (
+            <span className="text-xs text-muted-foreground mr-2">
+              {resultCount} kết quả
+            </span>
+          )}
+          <kbd className="hidden sm:inline-flex items-center gap-0.5 px-1.5 py-0.5 text-[10px] font-medium text-muted-foreground bg-muted rounded border">
+            <Command className="h-2.5 w-2.5" />K
+          </kbd>
+        </div>
+      </div>
+    </div>
+  );
+}

package/src/system/components/settings/settings-section.tsx

@@ -0,0 +1,74 @@
+"use client";
+
+import * as React from "react";
+import { ChevronDown } from "lucide-react";
+import { cn } from "../../../utils";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "../../../ui/data-display/collapsible";
+
+interface SettingsSectionProps {
+  id: string;
+  title: string;
+  description?: string;
+  count?: number;
+  defaultOpen?: boolean;
+  children: React.ReactNode;
+  className?: string;
+}
+
+export function SettingsSection({
+  id,
+  title,
+  description,
+  count,
+  defaultOpen = true,
+  children,
+  className,
+}: SettingsSectionProps) {
+  const [isOpen, setIsOpen] = React.useState(defaultOpen);
+
+  return (
+    <Collapsible
+      open={isOpen}
+      onOpenChange={setIsOpen}
+      className={cn("space-y-3", className)}
+    >
+      <div id={`section-${id}`} className="scroll-mt-20">
+        <CollapsibleTrigger asChild>
+          <button className="flex items-center gap-2 w-full group text-left">
+            <ChevronDown
+              className={cn(
+                "h-4 w-4 text-muted-foreground transition-transform duration-200",
+                !isOpen && "-rotate-90",
+              )}
+            />
+            <div className="flex-1 flex items-center justify-between">
+              <div>
+                <h3 className="text-sm font-semibold text-foreground group-hover:text-primary transition-colors">
+                  {title}
+                </h3>
+                {description && (
+                  <p className="text-xs text-muted-foreground mt-0.5">
+                    {description}
+                  </p>
+                )}
+              </div>
+              {count !== undefined && (
+                <span className="text-xs text-muted-foreground bg-muted px-2 py-0.5 rounded-full">
+                  {count}
+                </span>
+              )}
+            </div>
+          </button>
+        </CollapsibleTrigger>
+      </div>
+
+      <CollapsibleContent className="space-y-2">
+        <div className="ml-6 space-y-1 border-l pl-4">{children}</div>
+      </CollapsibleContent>
+    </Collapsible>
+  );
+}

package/src/system/components/settings/settings-sidebar.tsx

@@ -0,0 +1,81 @@
+"use client";
+
+import * as React from "react";
+import {
+  Settings,
+  TrendingUp,
+  Plug,
+  Bell,
+  Shield,
+  Bot,
+  Palette,
+  Wrench,
+} from "lucide-react";
+import { cn } from "../../../utils";
+import type { SettingGroup } from "../../types";
+
+interface SettingsSidebarProps {
+  groups: SettingGroup[];
+  activeGroup: string;
+  onGroupChange: (groupId: string) => void;
+  className?: string;
+}
+
+const iconMap: Record<string, React.ComponentType<{ className?: string }>> = {
+  Settings,
+  TrendingUp,
+  Plug,
+  Bell,
+  Shield,
+  Bot,
+  Palette,
+  Wrench,
+};
+
+export function SettingsSidebar({
+  groups,
+  activeGroup,
+  onGroupChange,
+  className,
+}: SettingsSidebarProps) {
+  return (
+    <nav className={cn("w-64 shrink-0", className)}>
+      <div className="sticky top-6 space-y-1">
+        {groups.map((group) => {
+          const Icon = iconMap[group.icon] || Settings;
+          const isActive = activeGroup === group.id;
+
+          return (
+            <button
+              key={group.id}
+              onClick={() => onGroupChange(group.id)}
+              className={cn(
+                "w-full flex items-center gap-3 px-3 py-2.5 rounded-lg text-left transition-all duration-200",
+                "hover:bg-accent/50",
+                isActive &&
+                  "bg-primary/10 text-primary font-medium border-l-2 border-primary",
+              )}
+            >
+              <Icon
+                className={cn(
+                  "h-4 w-4 shrink-0",
+                  isActive ? "text-primary" : "text-muted-foreground",
+                )}
+              />
+              <div className="flex-1 min-w-0">
+                <p
+                  className={cn(
+                    "text-sm truncate",
+                    !isActive && "text-foreground/80",
+                  )}
+                >
+                  {group.label}
+                </p>
+              </div>
+            </button>
+          );
+        })}
+      </div>
+    </nav>
+  );
+}

package/src/system/constants.ts

@@ -0,0 +1,3 @@
+export const STATUS_ACTIVE = "active";
+export const STATUS_INACTIVE = "inactive";
+export const STATUS_VALUES = [STATUS_ACTIVE, STATUS_INACTIVE] as const;

package/src/system/index.ts

@@ -0,0 +1,150 @@
+// @goerp/core/system
+// Module registry, manifest loader, and core system utilities
+
+export interface ModuleManifest {
+  /** Unique module identifier */
+  name: string;
+  /** Semantic version */
+  version: string;
+  /** Module category (e.g., 'Supply Chain', 'HR', 'Sales') */
+  category?: string;
+  /** Human-readable description */
+  description?: string;
+  /** Module dependencies */
+  depends?: string[];
+  /** Entities registered by this module */
+  entities?: string[];
+  /** Navigation items */
+  navigation?: NavigationItem[];
+  /** Permissions defined by this module */
+  permissions?: string[];
+  /** Feature flags */
+  features?: Record<string, FeatureConfig>;
+}
+
+export interface NavigationItem {
+  label: string;
+  icon?: string;
+  path?: string;
+  children?: NavigationItem[];
+  permission?: string;
+}
+
+export interface FeatureConfig {
+  enabled: boolean;
+  component?: React.ComponentType<any>;
+}
+
+/**
+ * Module Registry - Central registry for all modules
+ */
+class ModuleRegistry {
+  private modules = new Map<string, ModuleManifest>();
+  private initialized = false;
+
+  /**
+   * Register a module with the registry
+   */
+  register(manifest: ModuleManifest): void {
+    if (this.modules.has(manifest.name)) {
+      console.warn(
+        `Module "${manifest.name}" is already registered. Skipping.`,
+      );
+      return;
+    }
+
+    // Validate dependencies
+    if (manifest.depends) {
+      for (const dep of manifest.depends) {
+        if (dep !== "@goerp/core" && !this.modules.has(dep)) {
+          console.warn(
+            `Module "${manifest.name}" depends on "${dep}" which is not registered yet.`,
+          );
+        }
+      }
+    }
+
+    this.modules.set(manifest.name, manifest);
+  }
+
+  /**
+   * Get all registered modules
+   */
+  getModules(): ModuleManifest[] {
+    return Array.from(this.modules.values());
+  }
+
+  /**
+   * Get a specific module by name
+   */
+  getModule(name: string): ModuleManifest | undefined {
+    return this.modules.get(name);
+  }
+
+  /**
+   * Get combined navigation from all modules
+   */
+  getNavigation(): NavigationItem[] {
+    const items: NavigationItem[] = [];
+    for (const manifest of this.modules.values()) {
+      if (manifest.navigation) {
+        items.push(...manifest.navigation);
+      }
+    }
+    return items;
+  }
+
+  /**
+   * Get all permissions from all modules
+   */
+  getPermissions(): string[] {
+    const permissions: string[] = [];
+    for (const manifest of this.modules.values()) {
+      if (manifest.permissions) {
+        permissions.push(...manifest.permissions);
+      }
+    }
+    return permissions;
+  }
+
+  /**
+   * Get all entities from all modules
+   */
+  getEntities(): string[] {
+    const entities: string[] = [];
+    for (const manifest of this.modules.values()) {
+      if (manifest.entities) {
+        entities.push(...manifest.entities);
+      }
+    }
+    return entities;
+  }
+
+  /**
+   * Check if registry is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  /**
+   * Mark registry as initialized
+   */
+  markInitialized(): void {
+    this.initialized = true;
+  }
+
+  /**
+   * Clear all registered modules (useful for testing)
+   */
+  clear(): void {
+    this.modules.clear();
+    this.initialized = false;
+  }
+}
+
+// Singleton registry instance
+export const registry = new ModuleRegistry();
+
+// Export types
+export type { ModuleRegistry };

package/src/system/job-manager.ts

@@ -0,0 +1,176 @@
+export interface Job {
+  id: string;
+  name: string;
+  description?: string;
+  status: "running" | "stopped" | "failed";
+  lastRun?: Date;
+  nextRun?: Date;
+  schedule?: string; // cron expression or description
+}
+
+export interface JobLog {
+  id: string;
+  jobId: string;
+  level: "info" | "warning" | "error";
+  message: string;
+  timestamp: Date;
+}
+
+/**
+ * JobManager - manages background jobs and their logs
+ */
+class JobManagerImpl {
+  private jobs: Map<string, Job> = new Map();
+  private logs: JobLog[] = [];
+  private timers: Map<string, NodeJS.Timeout> = new Map();
+
+  constructor() {
+    // Initialize with demonstrable jobs
+    this.addJob({
+      id: "data-sync",
+      name: "Data Synchronization",
+      description: "Syncs data with external ERP systems",
+      status: "stopped",
+      schedule: "Every 15 minutes",
+    });
+
+    this.addJob({
+      id: "email-notifications",
+      name: "Email Notifications",
+      description: "Sends queued email notifications",
+      status: "stopped",
+      schedule: "Every 1 minute",
+    });
+
+    this.addJob({
+      id: "backup-daily",
+      name: "Daily Backup",
+      description: "Performs full database backup",
+      status: "stopped",
+      schedule: "Daily at 00:00",
+    });
+    this.addJob({
+      id: "cache-cleanup",
+      name: "Cache Cleanup",
+      description: "Removes expired cache entries",
+      status: "stopped",
+      schedule: "Every hour",
+    });
+
+    this.addJob({
+      id: "zalo-price-sync",
+      name: "Zalo Price Sync",
+      description: "Syncs silver price to Zalo groups",
+      status: "stopped",
+      schedule: "Every 30 minutes",
+    });
+  }
+
+  private addJob(job: Job) {
+    this.jobs.set(job.id, job);
+  }
+
+  getJobs(): Job[] {
+    return Array.from(this.jobs.values());
+  }
+
+  getJob(id: string): Job | undefined {
+    return this.jobs.get(id);
+  }
+
+  startJob(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job || job.status === "running") return false;
+
+    job.status = "running";
+    job.lastRun = new Date();
+
+    this.log(id, "info", `Job "${job.name}" started manually.`);
+
+    // Simulate job activity
+    const timer = setInterval(() => {
+      this.log(id, "info", `Job "${job.name}" is processing items...`);
+
+      // Randomly log warnings or simulated work
+      if (Math.random() > 0.8) {
+        this.log(
+          id,
+          "warning",
+          `Job "${job.name}" encountered minor issue processing batch.`,
+        );
+      }
+    }, 8000); // Log every 8 seconds
+
+    this.timers.set(id, timer);
+    return true;
+  }
+
+  stopJob(id: string): boolean {
+    const job = this.jobs.get(id);
+    if (!job || job.status !== "running") return false;
+
+    job.status = "stopped";
+
+    const timer = this.timers.get(id);
+    if (timer) {
+      clearInterval(timer);
+      this.timers.delete(id);
+    }
+
+    this.log(id, "info", `Job "${job.name}" stopped manually.`);
+    return true;
+  }
+
+  log(jobId: string, level: "info" | "warning" | "error", message: string) {
+    const log: JobLog = {
+      id: crypto.randomUUID(),
+      jobId,
+      level,
+      message,
+      timestamp: new Date(),
+    };
+    this.logs.unshift(log);
+
+    // Keep logs size manageable
+    if (this.logs.length > 2000) {
+      this.logs = this.logs.slice(0, 2000);
+    }
+  }
+
+  updateJob(
+    id: string,
+    updates: Partial<Pick<Job, "schedule" | "description">>,
+  ): boolean {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+
+    if (updates.schedule !== undefined) job.schedule = updates.schedule;
+    if (updates.description !== undefined)
+      job.description = updates.description;
+
+    this.log(id, "info", `Job config updated: ${JSON.stringify(updates)}`);
+    return true;
+  }
+
+  getLogs(jobId?: string, date?: Date): JobLog[] {
+    let filtered = this.logs;
+
+    if (jobId) {
+      filtered = filtered.filter((l) => l.jobId === jobId);
+    }
+
+    if (date) {
+      // Simple day matching
+      filtered = filtered.filter(
+        (l) =>
+          l.timestamp.getDate() === date.getDate() &&
+          l.timestamp.getMonth() === date.getMonth() &&
+          l.timestamp.getFullYear() === date.getFullYear(),
+      );
+    }
+
+    return filtered;
+  }
+}
+
+export const jobManager = new JobManagerImpl();