English | 简体中文



😃 A simple and practical CMS implemented by ASP.NET Core

This project began as a personal interest after seeing Python and Node.js versions of Lin CMS and the community's lin-cms-tp5.

This is an ASP.NET Core implementation of the Lin CMS backend, paired with a Vue.js frontend. It includes permissions, dictionary items, articles, comments and likes, notifications, tags, and other Juejin-style features.

Lin CMS is a content management system framework distilled from the Lin team’s project experience. It helps developers build CMS applications more efficiently. For the frontend, visit the frontend repository.

• Backend API on Gitee https://gitee.com/igeekfan/lin-cms-dotnetcore
• Backend API on GitHub https://github.com/luoyunchong/lin-cms-dotnetcore
• Admin UI https://github.com/luoyunchong/lin-cms-vue
• User-facing UI https://github.com/luoyunchong/lin-cms-vvlog

• Legacy deployment and third-party sign-in notes

• https://igeekfan.cn/dotnetcore/lin-cms/

• API Swagger
• User-facing lin-cms-vvlog
• Administrator interface: lin-cms-vue

Demo sign-in details are listed in the Chinese README.

• The original open-source frontend is extended with articles, tags, comments, user and tag following, and technology channels. A plugin mechanism was planned but is not yet available. See the module design for details.

Lin CMS has several distinctive design goals:

Lin provides both backend services and a corresponding frontend.

Traditional websites often render pages on the server using template technologies such as Razor.

Server-side rendering can support SEO well, but SEO is less important for an internal CMS administration system.

A practical question is who should implement server-rendered pages: frontend developers may not know server-side template languages, while backend developers may not specialize in page development. Separating the layers lets frontend developers use Vue, JavaScript, and CSS, while backend developers focus on the API.

The project also favors the experience provided by a single-page application.

Lin includes common CMS capabilities such as user management, permissions, and logging, allowing developers to focus on their application’s business features.

For more information, see the Lin CMS documentation.

In production, set Authentication:JwtBearer:SecurityKey in appsettings.Production.json, or provide Authentication__JwtBearer__SecurityKey through a protected environment variable or secret manager. Use a unique cryptographically random key of at least 64 characters for each deployment; do not commit it to Git. If absent in development or testing, the application generates a key and writes it to appsettings.json in the working directory. In production it writes to appsettings.Production.json and reuses it on later starts. The application refuses to start if the key is too short or still uses the repository’s old default. PowerShell can generate a key and set an environment variable for the current process:

$jwtKeyBytes = New-Object byte[] 64
[System.Security.Cryptography.RandomNumberGenerator]::Fill($jwtKeyBytes)
$env:Authentication__JwtBearer__SecurityKey = [Convert]::ToBase64String($jwtKeyBytes)

Persist the generated value in appsettings.Production.json or a secret manager. All instances in one deployment must share the same key; do not regenerate it on every restart. If the configuration file is tracked by Git, revert the locally generated change or exclude it from deployment changes to avoid committing the key. When using run.sh, provide JWT_SIGNING_KEY from a protected deployment environment; the script passes it to the container. If omitted, the app uses the mounted appsettings.Production.json and writes a local key file if configuration is still missing. Deployments that used the publicly known default key must rotate it and restart every instance. Existing access tokens will become invalid and users must sign in again. JWT validation also checks the user’s current status and loads current roles and groups from the database. Disabled or deleted accounts cannot continue using old tokens.

Because Lin separates frontend and backend, familiarity with C# and Vue is required.

The backend is built on .NET. Familiarity with MVC, Web API, filters, or .NET Framework MVC will help you get started.

• Database：ORM:FreeSql+DataBase:MySQL5.6/MsSqlServer/Oracle/Sqlite/PostgreSQL
• ASP.NET Core + WebAPI + RESTful
• Object mapping：AutoMapper
• JSON Web Tokens:JWT
• API documentation：Swagger(Swashbuckle.AspNetCore)
  • RapiDoc(RapiDoc)
  • Knife4jUI(Knife4jUI)
• Serialization：Newtonsoft.Json
• Testing：Xunit
• Logging Serilog
• Dependency injectionAutoFac
• General extension methods Z.ExtensionMethods
• Cloud storage: Qiniu Cloud MQiniu.Core
• Distributed transactions、EventBus：DotNeteCore.CAP
• GitHub OAuth loginAspNet.Security.OAuth.GitHub
• QQ OAuth loginAspNet.Security.OAuth.QQ
• Gitee OAuth loginAspNet.Security.OAuth.Gitee
• Docker
• Azure DevOps
• GitHub Action

• DDD(Domain-Driven Design)Domain-driven design
• Logging (logging)
• DevOps(CI/CD,automated builds)
• Database Migrations（automated database migrations)
• Authentication(authentication)
• Authorization（authorization）
• Separation of Concerns（separation of concerns）
• Repository Pattern（repository pattern）
• SOLID Principles（single responsibility）
• Clean Code（clean code）

• src
  • LinCms.Web：API（ASP.NET Core)
  • LinCms.Application:application services
  • LinCms.Application.Contracts:DTO,data transfer objects，application service interfaces
  • LinCms.Infrastructure:infrastructure and persistence
  • LinCms.Core:application core: entities, common operations, AOP extensions, pagination, dependency interfaces, time extensions, current-user information, exceptions, and value objects
• test

Frontend development requires familiarity with Vue, ES6, axios, Element UI, webpack, Vuex, Vue Router, and related tools.

• .NET Core搬砖队(lin-cms-dotnetcore) QQ group number: 762828442

Search WeChat for: dotNET搬砖队

https://github.com/luoyunchong/lin-cms-dotnetcore/wiki/Changelog-English