NewLife.Cube Documentation

NewLife.Cube organizes its core entities into two primary libraries:

Membership Library (User & Permissions)

Handles identity, access control, and organizational structure:

• User: User accounts
• Role: User roles
• Menu: Navigation and permission items
• Department: Organizational departments
• Area: Geographic areas
• Log: System logs (supports sharding)
• UserToken: Authentication tokens
• UserConnect: Third-party login bindings
• UserOnline: Online status tracking
• UserStat: User statistics

Cube Library (System Management)

Handles application infrastructure and system-wide settings:

• App: Application systems
• AppModule: Application plugins
• Attachment: File attachments
• CronJob: Scheduled tasks
• OAuthConfig: OAuth configurations
• OAuthLog: OAuth activity logs
• AccessRule: Access control rules
• Tenant: Multi-tenancy management
• TenantUser: Tenant-specific user mappings

NewLife.Cube is a Web rapid development platform built on ASP.NET Core. It provides a complete infrastructure for building administrative back-office systems, focusing on the principle of "Convention over Configuration."

Core Capabilities:

• User & Permission Management: Full RBAC (Role-Based Access Control) system including users, roles, menus, and permissions.
• Generic Data Management: Automatic CRUD (Create, Read, Update, Delete) operations for entities, including auto-generated lists, forms, and detail pages.
• System Management: Built-in support for logs, configurations, dictionaries, and scheduled tasks.
• Extensibility: Support for theme/skin switching, OAuth login, and data-level permissions.
• High Performance: Designed to handle massive datasets (up to 10 billion rows) using XCode ORM features like automatic sharding, read/write splitting, and second-level caching.

Cube-Cube contains core management pages for the Cube system. The available modules and their primary routes are:

The @newlifex/cube-vue framework provides several built-in capabilities for building enterprise applications:

• Layout System: Uses MainLayout (sidebar + content area). You can customize it via dependency injection using LayoutKey.
• State Management: Provides UserStore for user state and MenuStore for menu state. Access them via useUserStore() and useMenuStore().
• Routing System: Supports dynamic routing and micro-frontend architectures, with routes dynamically generated from backend menu data.
• API Requests: An Axios wrapper that includes automatic Token handling, 401 error processing, and error notifications. Import it via import request from '@newlifex/cube-vue/core/utils/request'.
• Internationalization (i18n): Powered by Vue I18n with support for dynamic switching. Use intl.get('key').d('default_value') to retrieve translations.
• Page Overriding: Uses a Section mechanism. You can override framework components by creating Vue files with uppercase names in the views/ directory.
• BUILD_ Configuration Injection: Allows injecting variables into index.html during production builds. Use the ${BUILD_XXX} syntax within config.production.ts.

The NewLife.Cube (API-based/Third Generation) architecture provides a decoupled frontend-backend system. Developers can verify the following core capabilities for building applications:

Core API Capabilities

• Dynamic Field Rendering: Use the GetFields API to retrieve metadata for the current page, allowing the frontend to render fields dynamically.
• Chart Data: Implement the OnGetChartData virtual method in the backend to provide data for ECharts rendering in the frontend.
• Authentication Configuration: Use the /Auth/LoginConfig endpoint to retrieve dynamic login configurations, which can be integrated into Pinia stores (Vue) or similar state management.
• Module Loading: Implement the IModule interface to enable automatic scanning and loading of plugins.

Frontend Framework Support

• Vue Support: Provided via NewLife.Cube.Vue (based on QuickVue). Supports dynamic field type mapping, search, sorting, permissions, hyperlinks, and form states. Includes import/export (5 formats) and batch operations.
• React Support: Provided via NewLife.Cube.React (based on CubeAntd). Features the DynamicPage component which integrates ProTable, CRUD, search, sorting, and pagination with automatic route adaptation.

Deployment and Routing

• Embedded Static Files: Uses CubeEmbeddedFileProvider to read static resources directly from assemblies.
• SPA Routing: Both VueService and ReactService implement SPA fallback routing to ensure that page refreshes do not result in 404 errors (non-file requests are redirected to index.html).

The frontend project follows a standard Vue 3 structure organized as follows:

• src/api/: API calling layer (reuses @cube/api-core)
• src/components/: Reusable UI components
• src/layouts/: Layout components for different page structures
• src/router/: Routing configurations
• src/stores/: Pinia state management stores
• src/views/: Page-level view components
• src/App.vue: Root component
• src/main.ts: Application entry point
• index.html: HTML template
• vite.config.ts: Vite configuration
• tsconfig.json: TypeScript configuration
• package.json: Project dependencies and scripts

web/
├── src/
│   ├── api/          # API 调用层（复用 @cube/api-core）
│   ├── components/   # 组件
│   ├── layouts/      # 布局组件
│   ├── router/       # 路由配置
│   ├── stores/       # Pinia 状态管理
│   ├── views/        # 页面视图
│   ├── App.vue
│   └── main.ts
├── index.html
├── vite.config.ts
├── tsconfig.json
└── package.json

NewLife.Cube is organized into several functional layers and modules that provide the foundation for rapid application development:

Infrastructure Layer

• BASE (Base Services): Provides unified response protocols, declarative permission annotations, modular plugins, and data protection.
• AUTH (User Authentication): Supports multiple authentication methods including passwords, MFA (Multi-Factor Authentication), verification codes, and external authentication with security risk control.
• PERM (Permission Management): A Role-Based Access Control (RBAC) system managing users, roles, menus, departments, and data permissions. It supports multi-tenancy and delegated proxying.
• OAUTH (Unified Authentication): Manages OAuth third-party logins and SSO (Single Sign-On), including OAuth configuration, logs, and user binding.

Core Engine

• DATA (Data Management): The central engine that automatically generates standard CRUD management interfaces once entities are defined. It uses field metadata to drive frontend rendering.

Supporting & Value-Added Services

• SYS (System Management): Includes configuration, auditing, jobs, value sets, file management, regions, and attachments.
• NOTI (Message Notification): Unified management and sending of email, SMS, and in-app notifications.
• AI (AI Services): An abstraction layer for Large Language Models (LLMs) providing log summarization, security inspections, and AI-driven data insights.

Presentation Layer

• MVC (MVC Views): Server-side rendered Razor views with support for multiple themes like Tabler, LayuiAdmin, and Metronic.
• SPA (SPA Frontends): WebAPI-driven frontend skins for frameworks like Vue, React, NaiveUI, and Angular.