LMES Development Guide

LMES is an out-of-the-box Manufacturing Execution System designed with a modular plugin architecture. Your development team can fully autonomously perform secondary business development, quickly responding to business needs and truly realizing autonomous and controllable digital manufacturing management.

---

Why Choose LMES?

Value for Enterprises

• Reduce Total Cost: Standard functions out-of-the-box, controllable customization costs.
• Autonomous Control: Business logic is controlled by the internal enterprise team, fast response speed.
• Flexible Extension: Modular architecture supports on-demand customization without affecting core functions.
• Quick Launch: Standard functions ready to use, short customization cycle (2-4 weeks to get started).

Value for Development Teams

• Low Learning Cost: Based on mainstream technology stack (.NET 6.0 + ABP + Vue3), no need to learn niche frameworks.
• High Development Efficiency: Complete code templates and scaffolding, create standard plugins in 30 minutes.
• Comprehensive Documentation: Complete documentation system from entry to mastery, supporting autonomous learning loop.
• Clear Architecture: DDD layered architecture + plugin-based design, easy to understand and maintain.

---

Suitable for Which Enterprises?

Applicable Scenarios

1. Have Development Team: Technical team with .NET or frontend development capabilities.
2. Personalized Business Needs: Need to customize functions according to special process flows.
3. Pursue Long-term Value: Hope to build an autonomous and controllable MES system.
4. Value Data Security: Need full control over system and data.

Developer Requirements

Basic Requirements

Role	Essential Skills	Work Experience	Learning Cycle
Backend Developer	C# + .NET Core + EF Core + MySQL	1-2 years .NET dev experience	2-3 weeks to start, 1-2 months to master
Frontend Developer	Vue3 + TypeScript + Webpack/Vite	1+ year frontend dev experience	1-2 weeks to start, 3-4 weeks to master
Full Stack Developer	All skills above	2+ years dev experience	3-4 weeks to start, 2-3 months to master

Skill Explanation:

• Backend Developer: Needs familiarity with relational database design, RESTful API development, asynchronous programming.
• Frontend Developer: Needs mastery of component-based development, state management, HTTP request handling.
• Full Stack Developer: Needs understanding of frontend-backend interaction, interface design, data flow.

Bonus Points

• Familiar with ABP framework or DDD architecture design.
• Experience in developing enterprise systems like MES/ERP.
• Understanding of manufacturing business processes and process management.
• Experience in modular or plugin-based architecture development.

Learning Suggestions

• Novice Developers: Recommended to learn ABP framework basics and DDD concepts first, then proceed with secondary development.
• Experienced Developers: Can start directly from templates, learning system architecture while doing.
• Team Configuration: Recommended to equip at least 1 senior developer as technical lead.

Note: LMES is designed based on enterprise-level architecture, requiring developers to have a certain technical foundation. Comprehensive documentation and code templates can reduce learning costs but cannot replace necessary technical accumulation.

---

Learning Path (Select by Role)

Path A: Backend Developer

Goal: Capable of developing business logic, database design, API interfaces.

Detailed learning guide please refer to: Backend Component Development Documentation

Learning Focus:

• DDD architecture and ABP framework basics
• Using dotnet new cms-ddd to create plugins
• Database design and EF Core operations
• Domain events, workflow integration, database sharding

Learning Outcome: Capable of independently developing complete business module backends.

---

Path B: Frontend Developer

Goal: Capable of developing production dashboards, data entry forms, report pages.

Detailed learning guide please refer to: Frontend Component Development Documentation

Learning Focus:

• CMS platform UI framework
• Using lmes-cli to generate components
• API calls and data binding
• Dynamic menus, permission control, multi-language

Learning Outcome: Capable of independently developing 80% of frontend business requirements.

---

Path C: Full Stack Developer

Goal: End-to-end delivery of complete functions.

Suggested Order: Learn Backend (Path A) first → Then learn Frontend (Path B) → Frontend-Backend Integration.

Time Investment: 6-8 weeks to reach proficiency.

---

III. Development Specification Essentials

Core Principles

1. Template First Principle

• Frontend: Use lmes-cli to create component templates.
• Backend: Use dotnet new cms-ddd to create DDD plugin templates.
• Advantage: Standardization, rapid development, built-in best practices.

2. Component Design Three Elements

Component Abstraction (Stable Interface)

// Naming Convention
CMS.Plugin.[ComponentName].Abstractions
// Publish as NuGet package (.nupkg)

Component Implementation (Concrete Function)

// Naming Convention
CMS.Plugin.[ComponentName]
// Publish as CMS plugin package (.cmsplugs)

Component Options (Configuration Management)

// appsettings.json configuration example
{
  "OrderManagementOptions": {
    "ActiveState": "0",    // 0=Disabled, 1=Enabled
    "FinishMode": "1",     // 0=Manual Finish, 1=Auto Finish
    "ProductionMode": "1"   // 0=Manual Production, 1=Auto Production
  }
}

3. Decoupling Strategy

• Abstraction Decoupling: Components interact via abstract interfaces.
• Event Bus: Use domain events to achieve eventual consistency.
• API Proxy: WebApiClient handles HTTP service calls.

4. Database Specification

• Master-Slave Table Naming: Underscore separation (scms_worksections → scms_worksection_processparameters).
• Data Separation: Production data and configuration data stored separately.

5. Quality Assurance

• Code Review: Establish CodeReview culture.
• Unit Testing: Ensure code quality.
• Documentation Requirements: Design documents submitted with source code.

Practical Suggestions

1. Start from Templates: Don't reinvent the wheel.
2. Design Before Develop: Output design documents before coding.
3. Leverage ABP Framework: Fully utilize out-of-the-box features.
4. Keep Interfaces Stable: Abstract interfaces avoid frequent changes.
5. Focus on Code Quality: Strictly conduct CodeReview.

Remember: Following specifications makes development simpler and maintenance easier!