diff --git a/abp_io/AbpIoLocalization/AbpIoLocalization/Base/Localization/Resources/en.json b/abp_io/AbpIoLocalization/AbpIoLocalization/Base/Localization/Resources/en.json
index 35c4766f8b..7cccf12cde 100644
--- a/abp_io/AbpIoLocalization/AbpIoLocalization/Base/Localization/Resources/en.json
+++ b/abp_io/AbpIoLocalization/AbpIoLocalization/Base/Localization/Resources/en.json
@@ -228,7 +228,9 @@
"Articles": "Articles",
"Organizations": "Organizations",
"ManageAccount": "Manage Account",
+ "MyManageAccount": "My Account",
"CommunityProfile": "Community Profile",
+ "MyCommunityProfile": "My Community Profile",
"BlogProfile": "Blog Profile",
"Tickets": "Tickets",
"Raffles": "Raffles",
@@ -248,13 +250,25 @@
"NewsletterDefinition": "Blog posts, community news, etc.",
"OrganizationOverview": "Organization Overview",
"EmailPreferences": "Email Preferences",
+ "MyEmailPreferences": "My Email Preferences",
"VideoCourses": "Essential Videos",
"DoYouAgreePrivacyPolicy": "By clicking Subscribe button you agree to the Terms & Conditions and Privacy Policy.",
"AbpConferenceDescription": "ABP Conference is a virtual event for .NET developers to learn and connect with the community.",
"Mobile": "Mobile",
"MetaTwitterCard": "summary_large_image",
"IPAddress": "IP Address",
+ "MyReferrals": "My Referrals",
"LicenseBanner:InfoText": "Your license will expire in {0} days.",
- "LicenseBanner:CallToAction": "Please extend your license."
+ "LicenseBanner:CallToAction": "Please extend your license.",
+ "Referral.CreatorUserIdIsRequired": "Creator user ID is required.",
+ "Referral.TargetEmailIsRequired": "Target email is required.",
+ "Referral.TargetEmailAlreadyExists": "A referral link for this email address already exists.",
+ "Referral.MaxLinkLimitExceeded": "You have reached the maximum limit of {Limit} active referral links.",
+ "Referral.LinkNotFound": "Referral link not found.",
+ "Referral.LinkNotFoundOrNotOwned": "Referral link not found or you don't have permission to access it.",
+ "Referral.CannotDeleteUsedLink": "You cannot delete a referral link that has already been used.",
+ "LinkCopiedToClipboard": "Link copied to clipboard",
+ "AreYouSureToDeleteReferralLink": "Are you sure you want to delete this referral link?",
+ "DefaultErrorMessage": "An error occurred."
}
}
\ No newline at end of file
diff --git a/docs/en/Blog-Posts/2025-10-23-ABP-is-Sponsoring-DotNET-Conf-2025/post.md b/docs/en/Blog-Posts/2025-10-23-ABP-is-Sponsoring-DotNET-Conf-2025/post.md
new file mode 100644
index 0000000000..6f546ee392
--- /dev/null
+++ b/docs/en/Blog-Posts/2025-10-23-ABP-is-Sponsoring-DotNET-Conf-2025/post.md
@@ -0,0 +1,20 @@
+### ABP is Sponsoring .NET Conf 2025\!
+
+We are very excited to announce that **ABP is a proud sponsor of .NET Conf 2025\!** This year marks the 15th online conference, celebrating the launch of .NET 10 and bringing together the global .NET community for three days\!
+
+Mark your calendar for **November 11th-13th** because you do not want to miss the biggest .NET virtual event of the year\!
+
+### About .NET Conf
+
+.NET Conference has always been **a free, virtual event, creating a world-class, engaging experience for developers** across the globe. This year, the conference is bigger than ever, drawing over 100 thousand live viewers and sponsoring hundreds of local community events worldwide\!
+
+### What to Expect
+
+**The .NET 10 Launch:** The event kicks off with the official release and deep-dive into the newest features of .NET 10\.
+
+**Three Days of Live Content:** Over the course of the event you'll get a wide selection of live sessions featuring speakers from the community and members of the .NET team.
+
+### Chance to Win a License\!
+
+As a proud sponsor, ABP is giving back to the community\! We are giving away one **ABP Personal License for a full year** to a lucky attendee of .NET Conf 2025\! To enter for a chance to win, simply register for the event [**here.**](https://www.dotnetconf.net/)
+
diff --git a/docs/en/Blog-Posts/2025-11-02-Repository-Pattern-in-the-Aspnetcore/post.md b/docs/en/Blog-Posts/2025-11-02-Repository-Pattern-in-the-Aspnetcore/post.md
new file mode 100644
index 0000000000..d1692471aa
--- /dev/null
+++ b/docs/en/Blog-Posts/2025-11-02-Repository-Pattern-in-the-Aspnetcore/post.md
@@ -0,0 +1,277 @@
+# Repository Pattern in the ASP.NET Core
+
+If you’ve built a .NET app with a database, you’ve likely used Entity Framework, Dapper, or ADO.NET. They’re useful tools; still, when they live inside your business logic or controllers, the code can become harder to keep tidy and to test.
+
+That’s where the **Repository Pattern** comes in.
+
+At its core, the Repository Pattern acts as a **middle layer between your domain and data access logic**. It abstracts the way you store and retrieve data, giving your application a clean separation of concerns:
+
+* **Separation of Concerns:** Business logic doesn’t depend on the database.
+* **Easier Testing:** You can replace the repository with a fake or mock during unit tests.
+* **Flexibility:** You can switch data sources (e.g., from SQL to MongoDB) without touching business logic.
+
+Let’s see how this works with a simple example.
+
+## A Simple Example with Product Repository
+
+Imagine we’re building a small e-commerce app. We’ll start by defining a repository interface for managing products.
+
+You can find the complete sample code in this GitHub repository:
+
+https://github.com/m-aliozkaya/RepositoryPattern
+
+### Domain model and context
+
+We start with a single entity and a matching `DbContext`.
+
+`Product.cs`
+
+```csharp
+using System.ComponentModel.DataAnnotations;
+
+namespace RepositoryPattern.Web.Models;
+
+public class Product
+{
+ public int Id { get; set; }
+
+ [Required, StringLength(64)]
+ public string Name { get; set; } = string.Empty;
+
+ [Range(0, double.MaxValue)]
+ public decimal Price { get; set; }
+
+ [StringLength(256)]
+ public string? Description { get; set; }
+
+ public int Stock { get; set; }
+}
+```
+
+`"AppDbContext.cs`
+
+```csharp
+using Microsoft.EntityFrameworkCore;
+using RepositoryPattern.Web.Models;
+
+namespace RepositoryPattern.Web.Data;
+
+public class AppDbContext(DbContextOptions options) : DbContext(options)
+{
+ public DbSet Products => Set();
+}
+```
+
+### Generic repository contract and base class
+
+All entities share the same CRUD needs, so we define a generic interface and an EF Core implementation.
+
+`Repositories/IRepository.cs`
+
+```csharp
+using System.Linq.Expressions;
+
+namespace RepositoryPattern.Web.Repositories;
+
+public interface IRepository where TEntity : class
+{
+ Task GetByIdAsync(int id, CancellationToken cancellationToken = default);
+ Task> GetAllAsync(CancellationToken cancellationToken = default);
+ Task> GetListAsync(Expression> predicate, CancellationToken cancellationToken = default);
+ Task AddAsync(TEntity entity, CancellationToken cancellationToken = default);
+ Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
+ Task DeleteAsync(int id, CancellationToken cancellationToken = default);
+}
+```
+
+`Repositories/EfRepository.cs`
+
+```csharp
+using Microsoft.EntityFrameworkCore;
+using RepositoryPattern.Web.Data;
+
+namespace RepositoryPattern.Web.Repositories;
+
+public class EfRepository(AppDbContext context) : IRepository
+ where TEntity : class
+{
+ protected readonly AppDbContext Context = context;
+
+ public virtual async Task GetByIdAsync(int id, CancellationToken cancellationToken = default)
+ => await Context.Set().FindAsync([id], cancellationToken);
+
+ public virtual async Task> GetAllAsync(CancellationToken cancellationToken = default)
+ => await Context.Set().AsNoTracking().ToListAsync(cancellationToken);
+
+ public virtual async Task> GetListAsync(
+ System.Linq.Expressions.Expression> predicate,
+ CancellationToken cancellationToken = default)
+ => await Context.Set()
+ .AsNoTracking()
+ .Where(predicate)
+ .ToListAsync(cancellationToken);
+
+ public virtual async Task AddAsync(TEntity entity, CancellationToken cancellationToken = default)
+ {
+ await Context.Set().AddAsync(entity, cancellationToken);
+ await Context.SaveChangesAsync(cancellationToken);
+ }
+
+ public virtual async Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
+ {
+ Context.Set().Update(entity);
+ await Context.SaveChangesAsync(cancellationToken);
+ }
+
+ public virtual async Task DeleteAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var entity = await GetByIdAsync(id, cancellationToken);
+ if (entity is null)
+ {
+ return;
+ }
+
+ Context.Set().Remove(entity);
+ await Context.SaveChangesAsync(cancellationToken);
+ }
+}
+```
+
+Reads use `AsNoTracking()` to avoid tracking overhead, while write methods call `SaveChangesAsync` to keep the sample straightforward.
+
+### Product-specific repository
+
+Products need one extra query: list the items that are almost out of stock. We extend the generic repository with a dedicated interface and implementation.
+
+`Repositories/IProductRepository.cs`
+
+```csharp
+using RepositoryPattern.Web.Models;
+
+namespace RepositoryPattern.Web.Repositories;
+
+public interface IProductRepository : IRepository
+{
+ Task> GetLowStockProductsAsync(int threshold, CancellationToken cancellationToken = default);
+}
+```
+
+`Repositories/ProductRepository.cs`
+
+```csharp
+using Microsoft.EntityFrameworkCore;
+using RepositoryPattern.Web.Data;
+using RepositoryPattern.Web.Models;
+
+namespace RepositoryPattern.Web.Repositories;
+
+public class ProductRepository(AppDbContext context) : EfRepository(context), IProductRepository
+{
+ public Task> GetLowStockProductsAsync(int threshold, CancellationToken cancellationToken = default) =>
+ Context.Products
+ .AsNoTracking()
+ .Where(product => product.Stock <= threshold)
+ .OrderBy(product => product.Stock)
+ .ToListAsync(cancellationToken);
+}
+```
+
+### 🧩 A Note on Unit of Work
+
+The Repository Pattern is often used together with the **Unit of Work** pattern to manage transactions efficiently.
+
+> 💡 *If you want to dive deeper into the Unit of Work pattern, check out our separate blog post dedicated to that topic. https://abp.io/community/articles/lv4v2tyf
+
+### Service layer and controller
+
+Controllers depend on a service, and the service depends on the repository. That keeps HTTP logic and data logic separate.
+
+`Services/ProductService.cs`
+
+```csharp
+using RepositoryPattern.Web.Models;
+using RepositoryPattern.Web.Repositories;
+
+namespace RepositoryPattern.Web.Services;
+
+public class ProductService(IProductRepository productRepository)
+{
+ private readonly IProductRepository _productRepository = productRepository;
+
+ public Task> GetProductsAsync(CancellationToken cancellationToken = default) =>
+ _productRepository.GetAllAsync(cancellationToken);
+
+ public Task> GetLowStockAsync(int threshold, CancellationToken cancellationToken = default) =>
+ _productRepository.GetLowStockProductsAsync(threshold, cancellationToken);
+
+ public Task GetByIdAsync(int id, CancellationToken cancellationToken = default) =>
+ _productRepository.GetByIdAsync(id, cancellationToken);
+
+ public Task CreateAsync(Product product, CancellationToken cancellationToken = default) =>
+ _productRepository.AddAsync(product, cancellationToken);
+
+ public Task UpdateAsync(Product product, CancellationToken cancellationToken = default) =>
+ _productRepository.UpdateAsync(product, cancellationToken);
+
+ public Task DeleteAsync(int id, CancellationToken cancellationToken = default) =>
+ _productRepository.DeleteAsync(id, cancellationToken);
+}
+```
+
+`Controllers/ProductsController.cs`
+
+```csharp
+using Microsoft.AspNetCore.Mvc;
+using RepositoryPattern.Web.Models;
+using RepositoryPattern.Web.Services;
+
+namespace RepositoryPattern.Web.Controllers;
+
+public class ProductsController(ProductService productService) : Controller
+{
+ private readonly ProductService _productService = productService;
+
+ public async Task Index(CancellationToken cancellationToken)
+ {
+ const int lowStockThreshold = 5;
+ var products = await _productService.GetProductsAsync(cancellationToken);
+ var lowStock = await _productService.GetLowStockAsync(lowStockThreshold, cancellationToken);
+
+ return View(new ProductListViewModel(products, lowStock, lowStockThreshold));
+ }
+
+ // remaining CRUD actions call through ProductService in the same way
+}
+```
+
+The controller never reaches for `AppDbContext`. Every operation travels through the service, which keeps tests simple and makes future refactors easier.
+
+### Dependency registration and seeding
+
+The last step is wiring everything up in `Program.cs`.
+
+```csharp
+builder.Services.AddDbContext(options =>
+ options.UseInMemoryDatabase("ProductsDb"));
+builder.Services.AddScoped(typeof(IRepository<>), typeof(EfRepository<>));
+builder.Services.AddScoped();
+builder.Services.AddScoped();
+```
+
+The sample also seeds three products so the list page shows data on first run.
+
+Run the site with:
+
+```powershell
+dotnet run --project RepositoryPattern.Web
+```
+
+## How ABP approaches the same idea
+
+ABP includes generic repositories by default (`IRepository`), so you often skip writing the implementation layer shown above. You inject the interface into an application service, call methods like `InsertAsync` or `CountAsync`, and ABP’s Unit of Work handles the transaction. When you need custom queries, you can still derive from `EfCoreRepository` and add them.
+
+For more details, check out the official ABP documentation on repositories: https://abp.io/docs/latest/framework/architecture/domain-driven-design/repositories
+
+### Closing note
+
+This setup keeps data access tidy without being heavy. Start with the generic repository, add small extensions per entity, pass everything through services, and register the dependencies once. Whether you hand-code it or let ABP supply the repository, the structure stays the same and your controllers remain clean.
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/POST.md b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/POST.md
new file mode 100644
index 0000000000..e6c0eb4601
--- /dev/null
+++ b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/POST.md
@@ -0,0 +1,88 @@
+# 5 Things You Should Keep in Mind When Deploying to a Clustered Environment
+
+Let’s be honest — moving from a single server to a cluster sounds simple on paper.
+You just add a few more machines, right?
+In practice, it’s the moment when small architectural mistakes start to grow legs.
+Below are a few things that experienced engineers usually double-check before pressing that “Deploy” button.
+
+---
+
+## 1️⃣ Managing State the Right Way
+
+Each request in a cluster might hit a different machine.
+If your application keeps user sessions or cache in memory, that data probably won’t exist on the next node.
+That’s why many teams decide to push state out of the app itself.
+
+
+
+**A few real-world tips:**
+- Keep sessions in **Redis** or something similar instead of local memory.
+- Design endpoints so they don’t rely on earlier requests.
+- Don’t assume the same server will handle two requests in a row — it rarely does.
+
+---
+
+## 2️⃣ Shared Files and Where to Put Them
+
+Uploading files to local disk? That’s going to hurt in a cluster.
+Other nodes can’t reach those files, and you’ll spend hours wondering why images disappear.
+
+
+
+**Better habits:**
+- Push uploads to **S3**, **Azure Blob**, or **Google Cloud Storage**.
+- Send logs to a shared location instead of writing to local files.
+- Keep environment configs in a central place so each node starts with the same settings.
+
+---
+
+## 3️⃣ Database Connections Aren’t Free
+
+Every node opens its own database connections.
+Ten nodes with twenty connections each — that’s already two hundred open sessions.
+The database might not love that.
+
+
+
+**What helps:**
+- Put a cap on your connection pools.
+- Avoid keeping transactions open for too long.
+- Tune indexes and queries before scaling horizontally.
+
+---
+
+## 4️⃣ Logging and Observability Matter More Than You Think
+
+When something breaks in a distributed system, it’s never obvious which server was responsible.
+That’s why observability isn’t optional anymore.
+
+
+
+**Consider this:**
+- Stream logs to **ELK**, **Datadog**, or **Grafana Loki**.
+- Add a **trace ID** to every incoming request and propagate it across services.
+- Watch key metrics with **Prometheus** and visualize them in Grafana dashboards.
+
+---
+
+## 5️⃣ Background Jobs and Message Queues
+
+If more than one node runs the same job, you might process the same data twice — or delete something by mistake.
+You don’t want that kind of excitement in production.
+
+
+
+**A few precautions:**
+- Use a **distributed lock** or **leader election** system.
+- Make jobs **idempotent**, so running them twice doesn’t break data.
+- Centralize queue consumers or use a proper task scheduler.
+
+---
+
+## Wrapping Up
+
+Deploying to a cluster isn’t only about scaling up — it’s about staying stable when you do.
+Systems that handle state, logging, and background work correctly tend to age gracefully.
+Everything else eventually learns the hard way.
+
+> A cluster doesn’t fix design flaws — it magnifies them.
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/all.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/all.png
new file mode 100644
index 0000000000..71cbe984c4
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/all.png differ
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/background.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/background.png
new file mode 100644
index 0000000000..4d802e409d
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/background.png differ
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/cover-image.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/cover-image.png
new file mode 100644
index 0000000000..be4c03fda0
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/cover-image.png differ
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/database.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/database.png
new file mode 100644
index 0000000000..4a54b6f031
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/database.png differ
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/dev-to.md b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/dev-to.md
new file mode 100644
index 0000000000..d6df7eea53
--- /dev/null
+++ b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/dev-to.md
@@ -0,0 +1,27 @@
+# 5 Things You Should Keep in Mind When Deploying to a Clustered Environment
+
+Let’s be honest — moving from a single server to a cluster sounds simple on paper.
+You just add a few more machines, right?
+In practice, it’s the moment when small architectural mistakes start to grow legs.
+Below are a few things that experienced engineers usually double-check before pressing that “Deploy” button.
+
+---
+
+## 1️⃣ Managing State the Right Way
+---
+
+## 2️⃣ Shared Files and Where to Put Them
+---
+
+## 3️⃣ Database Connections Aren’t Free
+---
+
+## 4️⃣ Logging and Observability Matter More Than You Think
+---
+
+## 5️⃣ Background Jobs and Message Queues
+---
+
+
+
+👉 Read the full guide here: [5 Things You Should Keep in Mind When Deploying to a Clustered Environment](https://abp.io/community/articles/)
\ No newline at end of file
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/logging.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/logging.png
new file mode 100644
index 0000000000..c3100a672a
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/logging.png differ
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/shared.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/shared.png
new file mode 100644
index 0000000000..0331ce4a6a
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/shared.png differ
diff --git a/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/stateless.png b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/stateless.png
new file mode 100644
index 0000000000..6b12c03db8
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-17-5-Things-Deploy-Clustered-Environment/stateless.png differ
diff --git a/docs/en/Community-Articles/2025-10-20-The-ASP-DotNET-Core-Dependency-Injection System/post.md b/docs/en/Community-Articles/2025-10-20-The-ASP-DotNET-Core-Dependency-Injection System/post.md
index ccb1c38cbc..0a3959b44f 100644
--- a/docs/en/Community-Articles/2025-10-20-The-ASP-DotNET-Core-Dependency-Injection System/post.md
+++ b/docs/en/Community-Articles/2025-10-20-The-ASP-DotNET-Core-Dependency-Injection System/post.md
@@ -1135,6 +1135,8 @@ builder.Services.AddHostedService();
This pattern ensures that each run of the worker uses a new `DbContext`, preventing problems such as memory leaks or stale data.
+> While this example uses a simple `Task.Delay` loop within the `BackgroundService`, a robust pattern for managing decoupled background tasks involves an in memory queue. You can learn how to build this system by following this guide: [How to Build an In Memory Background Job Queue in ASP.NET Core From Scratch](https://abp.io/community/articles/how-to-build-an-in-memory-background-job-queue-in-asp.net-core-from-scratch-pai2zmtr).
+
## Conclusion
Understanding the **ASP.NET Core Dependency Injection** framework is essential for any .NET developer. By understanding the built in IoC container, choosing the right service lifecycles, and opting for explicit constructor injection, you can create modular, testable, and maintainable applications.
@@ -1169,4 +1171,4 @@ The transition from legacy, fragmented DI environments to a unified, performant,
- [IHttpClientFactory with .NET](https://learn.microsoft.com/en-us/dotnet/core/extensions/httpclient-factory)
- [Keyed Services DI Container](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-9.0#keyed-services)
- [Use Scoped Services Within a Scoped Service](https://learn.microsoft.com/en-us/dotnet/core/extensions/scoped-service)
-- [Scrutor](https://github.com/khellang/Scrutor)
\ No newline at end of file
+- [Scrutor](https://github.com/khellang/Scrutor)
diff --git a/docs/en/Community-Articles/2025-10-31-Exceptions-vs-Return-Codes/Cover.png b/docs/en/Community-Articles/2025-10-31-Exceptions-vs-Return-Codes/Cover.png
new file mode 100644
index 0000000000..01f7ec061c
Binary files /dev/null and b/docs/en/Community-Articles/2025-10-31-Exceptions-vs-Return-Codes/Cover.png differ
diff --git a/docs/en/Community-Articles/2025-10-31-Exceptions-vs-Return-Codes/Post.md b/docs/en/Community-Articles/2025-10-31-Exceptions-vs-Return-Codes/Post.md
new file mode 100644
index 0000000000..3cfbd146b0
--- /dev/null
+++ b/docs/en/Community-Articles/2025-10-31-Exceptions-vs-Return-Codes/Post.md
@@ -0,0 +1,98 @@
+# **Return Code vs Exceptions: Which One is Better?**
+
+Alright, so this debate pops up every few months on dev subreddits and forums
+
+> *Should you use return codes or exceptions for error handling?*
+
+And honestly, there’s no %100 right answer here! Both have pros/cons, and depending on the language or context, one might make more sense than the other. Let’s see...
+
+------
+
+## 1. Return Codes --- Said to be "Old School Way" ---
+
+Return codes (like `0` for success, `-1` for failure, etc.) are the OG method. You mostly see them everywhere in C and C++.
+They’re super explicit, the function literally *returns* the result of the operation.
+
+### ➕ Advantages of returning codes:
+
+- You *always* know when something went wrong
+- No hidden control flow — what you see is what you get
+- Usually faster (no stack unwinding, no exception overhead)
+- Easy to use in systems programming, embedded stuff, or performance-critical code
+
+### ➖ Disadvantages of returning codes:
+
+- It’s easy to forget to check the return value (and boom, silent failure 😬)
+- Makes code noisy... Everry function call followed by `if (result != SUCCESS)` gets annoying
+- No stack trace or context unless you manually build one
+
+**For example:**
+
+```csharp
+try
+{
+ await SendEmailAsync();
+}
+catch (Exception e)
+{
+ Log.Exception(e.ToString());
+ return -1;
+}
+```
+
+Looks fine… until you forget one of those `if` conditions somewhere.
+
+------
+
+## 2. Exceptions --- The Fancy & Modern Way ---
+
+Exceptions came in later, mostly with higher-level languages like Java, C#, and Python.
+The idea is that you *throw* an error and handle it *somewhere else*.
+
+### ➕ Advantages of throwing exceptions:
+
+- Cleaner code... You can focus on the happy path and handle errors separately
+- Can carry detailed info (stack traces, messages, inner exceptions...)
+- Easier to handle complex error propagation
+
+### ➖ Disadvantages of throwing exceptions:
+
+- Hidden control flow — you don’t always see what might throw
+- Performance hit (esp. in tight loops or low-level systems)
+- Overused in some codebases (“everything throws everything”)
+
+**Example:**
+
+```csharp
+try
+{
+ await SendEmailAsync();
+}
+catch (Exception e)
+{
+ Log.Exception(e.ToString());
+ throw e;
+}
+```
+
+Way cleaner, but if `SendEmailAsync()` is deep in your call stack and it fails, it can be tricky to know exactly what went wrong unless you log properly.
+
+------
+
+### And Which One’s Better? ⚖️
+
+Depends on what you’re building.
+
+- **Low-level systems, drivers, real-time stuff 👉 Return codes.** Performance and control matter more.
+- **Application-level, business logic, or high-level APIs 👉 Exceptions.** Cleaner and easier to maintain.
+
+And honestly, mixing both sometimes makes sense.
+For example, you can use return codes internally and exceptions at the boundary of your API to surface meaningful errors to the user.
+
+------
+
+### Conclusion
+
+Return codes = simple, explicit, but messy.t
+Exceptions = clean, powerful, but can bite you.
+Use what fits your project and your team’s sanity level 😅.
\ No newline at end of file
diff --git a/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/bento.png b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/bento.png
new file mode 100644
index 0000000000..bb16a71259
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/bento.png differ
diff --git a/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/dark-mode.png b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/dark-mode.png
new file mode 100644
index 0000000000..612a786a71
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/dark-mode.png differ
diff --git a/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/large.png b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/large.png
new file mode 100644
index 0000000000..544214db08
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/large.png differ
diff --git a/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/post.md b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/post.md
new file mode 100644
index 0000000000..e0f9ec3b5f
--- /dev/null
+++ b/docs/en/Community-Articles/2025-11-05-UI-UX-Trends-That-Will-Shape-2026/post.md
@@ -0,0 +1,112 @@
+# UI & UX Trends That Will Shape 2026
+
+Cinematic, gamified, high-wow-factor websites with scroll-to-play videos or scroll-to-tell stories are wonderful to experience, but you won't find these trends in this article. If you're interested in design trends directly related to the software world, such as **performance**, **accessibility**, **understandability**, and **efficiency**, grab a cup of coffee and enjoy.
+
+As we approach the end of 2025, I'd like to share with you the most important user interface and user experience design trends that have become more of a **toolkit** than a trend, and that continue to evolve and become a part of our lives. I predict we'll see a lot of them in 2026\.
+
+## 1\. Simplicity and Speed
+
+Designing understandable and readable applications is becoming far more important than designing in line with trends and fashion. In the software and business world, preferences are shifting more and more toward the **right design** over the cool design. As designers developing a product whose direct target audience is software developers, we design our products for the designers' enjoyment, but for the **end user's ease of use**.
+
+Users no longer care so much about the flashiness of a website. True converts are primarily interested in your product, service, or content. What truly matters to them is how easily and quickly they can access the information they're looking for.
+
+More users, more sales, better promotion, and a higher conversion rate... The elements that serve these goals are optimized solutions and thoughtful details in our designs, more than visual displays.
+
+If the "loading" icon appears too often on your digital product, you might not be doing it right. If you fail to optimize speed, the temporary effect of visual displays won't be enough to convert potential users into customers. Remember, the moment people start waiting, you've lost at least half of them.
+
+## 2\. Dark Mode \- Still, and Forever
+
+
+Dark Mode is no longer an option; it's a **standard**. It's become a necessity, not a choice, especially for users who spend hours staring at screens and are accustomed to dark themes in code editors and terminals. However, the approach to dark mode isn't simply about inverting colors; it's much deeper than that. The key is managing contrast and depth.
+
+The layer hierarchy established in a light-colored design doesn't lose its impact when switched to dark mode. The colors, shadows, highlights, and contrasting elements used to create an **easily perceivable hierarchy** should be carefully considered for each mode. Our [LeptonX theme](https://leptontheme.com/)'s Light, Dark, Semi-dark, and System modes offer valuable insights you might want to explore.
+
+You might also want to take a look at the dark and light modes we designed with these elements in mind in [ABP Studio](https://abp.io/get-started) and the [ABP.io Documents page](https://abp.io/docs/latest/).
+
+## 3\. Bento Grid \- A Timeless Trend
+
+
+People don't read your website; they **scan** it.
+
+Bento Grid, an indispensable trend for designers looking to manage their attention, looks set to remain a staple in 2026, just as it was in 2025\. No designer should ignore the fact that many tech giants, especially Apple and Samsung, are still using bento grids on their websites. The bento grid appears not only on websites but also in operating systems, VR headset interfaces, game console interfaces, and game designs.
+
+The golden rule is **contrast** and **balance**.
+
+The attractiveness and effectiveness of bento designs depend on certain factors you should consider when implementing them. If you ignore these rules, even with a proven method like bento, you can still alienate users.
+
+The bento grid is one of the best ways to display different types of content inclusively. When used correctly, it's also a great way to manipulate reading order, guiding the user's eye. Improper contrast and hierarchy can also create a negative experience. Designers should use this to guide the reader's eye: "Read here first, then read here."
+
+When creating a bento, you inherently have to sacrifice some of your "whitespace." This design has many elements for the user to focus on, and it actually strays from our first point, "Simplicity". Bento design, whose boundaries are drawn from the outset and independent of content, requires care not to include more or less than what is necessary. Too much content makes it boring; too little content makes it very close to meaningless.
+
+Bento grids should aim for a balanced design by using both simple text and sophisticated visuals. This visual can be an illustration, a video that starts playing when hovered over, a static image, or a large title. Only one or two cards on the screen at a time should have attention.
+
+## 4\. Larger Fonts, High Readability
+
+
+Large fonts have been a trend for several years, and it seems web designers are becoming more and more bold. The increasing preference for larger fonts every year is a sign that this trend will continue into 2026\. This trend is about more than just using large font sizes in headlines.
+
+Creating a cohesive typographic scale and proper line height and letter spacing are critical elements to consider when creating this trend. As the font size increases, line height should decrease, and the space between letters should be narrower.
+
+The browser default font size, which we used to see in body text and paragraphs and has now become standard, is 16 pixels. In the last few years, we've started seeing body font sizes of 17 or 18 pixels more frequently. The increasing importance of readability every year makes this more common. Font sizes in rem values, rather than px, provide the most efficient results.
+
+## 5\. Micro Animations
+
+Unless you're a web design agency designing a website to impress potential clients, you should avoid excessive changes, including excessive image changes during scrolling, and scroll direction changes. There's still room for oversized images and scroll animations. But be sure to create the visuals yourself.
+
+The trend I'm talking about here is **micro animations**, not macro ones. Small movements, not large ones.
+
+The animation approach of 2025 is **functional** and **performance-sensitive**.
+
+Microanimations exist to provide immediate feedback to the user. Instant feedback, like a button's shadow increasing when hovered over, a button's slight collapse when clicked, or a "Save" icon changing to a "Confirm" icon when saving data, keeps your designs alive.
+
+We see the real impact of the micro-animation trend in static, non-action visuals. The use of non-button elements in your designs, accentuated by micro-movements such as scrolling or hovering, seems poised to continue to create macro effects in 2026\.
+
+## 6\. Real Images and Human-like Touches
+
+People quickly spot a fake. It's very difficult to convince a user who visits your website for the first time and doesn't trust you. **First impressions** matter.
+
+Real photographs, actual product screenshots, and brand-specific illustrations will continue to be among the elements we want to see in **trust-focused** designs in 2026\.
+
+In addition to flawless work done by AI, vivid, real-life visuals, accompanied by deliberate imperfections, hand-drawn details, or designed products that convey the message, "A human made this site\!", will continue to feel warmer and more welcoming.
+
+The human touch is evident not only in the visuals but also in your **content and text**.
+
+In 2026, you'll need more **human-like touches** that will make your design stand out among the thousands of similar websites rapidly generated by AI.
+
+## 7\. Accessibility \- No Longer an Option, But a Legal and Ethical Obligation
+
+Accessibility, once considered a nice-to-do thing in recent years, is now becoming a **necessity** in 2026 and beyond. Global regulations like the European Accessibility Act require all digital products to comply with WCAG standards.
+
+All design and software improvements you make to ensure end users can fully perform their tasks in your products, regardless of their temporary or permanent disabilities, should be viewed as ethical and commercial requirements, not as a requirement to comply with these standards.
+
+The foundation of accessibility in design is to use semantic HTML for screen readers, provide full keyboard control of all interactive elements, and clearly communicate the roles of complex components to the development team.
+
+## 8\. Intentional Friction
+
+Steve Krug, the father of UX design, started the trend of designing everything at a hyper-usable level with his book "Don't Make Me Think." As web designers, we've embraced this idea so much that all we care about is getting the user to their destination in the shortest possible scenario and as quickly as possible. This has required so many understandability measures that, after a while, it's starting to feel like fooling the user.
+
+In recent years, designers have started looking for ways to make things a little more challenging, rather than just getting the user to the result.
+
+When the end user visits your website, tries to understand exactly what it is at first glance, struggles a bit, and, after a little effort, becomes familiar with how your world works, they'll be more inclined to consider themselves a part of it.
+
+This has nothing to do with anti-usability. This philosophy is called Intentional Friction.
+
+This isn't a flaw; it's the pinnacle of error prevention. It's a step to prevent errors from occurring on autopilot and respects the user's ability to understand complex systems. Examples include reviewing the order summary or manually typing the project name when deleting a project on GitHub.
+
+## Bonus: Where Does Artificial Intelligence Fit In?
+
+Artificial intelligence will be an infrastructure in 2026, not a trend.
+
+As designers, we should leverage AI not to paint us a picture, but to make workflows more intelligent. In my opinion, this is the best use case for AI.
+
+AI can learn user behavior and adapt the interface accordingly. Real-time A/B testing can save us time by conducting a real-time content review. The ability to actively use AI in any area that allows you to accelerate your progress will take you a step further in your career.
+
+Since your users are always human, **don't be too eager** to incorporate AI-generated visuals into your design. Unless you're creating and selling a ready-made theme, you should **avoid** AI-generated visuals, random bento grids, and randomly generated content.
+
+You should definitely incorporate AI into your work for new content, new ideas, personal and professional development, and insights that will take your design a step further. But just as you don't design your website for designers to like, the same applies to AI. Humans, not robots, will experience your website. **AI-assisted**, not AI-generated, designs with a human touch are the trend I most expect seeing in 2026\.
+
+## Conclusion
+
+In the end, it's all fundamentally about respect for the user and their time. In 2026, our success as designers and developers will be measured not by how "cool" we are, but by how "efficient" and "reliable" a world we build for our users.
+
+Thank you for your time.
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/cover-image.png b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/cover-image.png
new file mode 100644
index 0000000000..5ee2f50934
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/cover-image.png differ
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/abp-structure.png b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/abp-structure.png
new file mode 100644
index 0000000000..5c5639839c
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/abp-structure.png differ
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/ddd-layers.png b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/ddd-layers.png
new file mode 100644
index 0000000000..7307f1cbab
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/ddd-layers.png differ
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/money-transfer.png b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/money-transfer.png
new file mode 100644
index 0000000000..2ebf3b4fef
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/money-transfer.png differ
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/service-comparison.png b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/service-comparison.png
new file mode 100644
index 0000000000..498a438502
Binary files /dev/null and b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/images/service-comparison.png differ
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/post.md b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/post.md
new file mode 100644
index 0000000000..7eca19a652
--- /dev/null
+++ b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/post.md
@@ -0,0 +1,592 @@
+# What is That Domain Service in DDD for .NET Developers?
+
+When you start applying **Domain-Driven Design (DDD)** in your .NET projects, you'll quickly meet some core building blocks: **Entities**, **Value Objects**, **Aggregates**, and finally… **Domain Services**.
+
+But what exactly *is* a Domain Service, and when should you use one?
+
+Let's break it down with practical examples and ABP Framework implementation patterns.
+
+---
+
+
+
+## The Core Idea of Domain Services
+
+A **Domain Service** represents **a domain concept that doesn't naturally belong to a single Entity or Value Object**, but still belongs to the **domain layer** - *not* to the application or infrastructure.
+
+In short:
+
+> If your business logic doesn't fit into a single Entity, but still expresses a business rule, that's a good candidate for a Domain Service.
+
+
+
+---
+
+## Example: Money Transfer Between Accounts
+
+Imagine a simple **banking system** where you can transfer money between accounts.
+
+```csharp
+public class Account : AggregateRoot
+{
+ public decimal Balance { get; private set; }
+
+ // Domain model should be created in a valid state.
+ public Account(decimal openingBalance = 0m)
+ {
+ if (openingBalance < 0)
+ throw new BusinessException("Opening balance cannot be negative.");
+ Balance = openingBalance;
+ }
+
+ public void Withdraw(decimal amount)
+ {
+ if (amount <= 0)
+ throw new BusinessException("Withdrawal amount must be positive.");
+ if (Balance < amount)
+ throw new BusinessException("Insufficient balance.");
+ Balance -= amount;
+ }
+
+ public void Deposit(decimal amount)
+ {
+ if (amount <= 0)
+ throw new BusinessException("Deposit amount must be positive.");
+ Balance += amount;
+ }
+}
+```
+
+> In a richer domain you might introduce a `Money` value object (amount + currency + rounding rules) instead of a raw `decimal` for stronger invariants.
+
+---
+
+## Implementing a Domain Service
+
+
+
+```csharp
+public class MoneyTransferManager : DomainService
+{
+ public void Transfer(Account from, Account to, decimal amount)
+ {
+ if (from is null) throw new ArgumentNullException(nameof(from));
+ if (to is null) throw new ArgumentNullException(nameof(to));
+ if (ReferenceEquals(from, to))
+ throw new BusinessException("Cannot transfer to the same account.");
+ if (amount <= 0)
+ throw new BusinessException("Transfer amount must be positive.");
+
+ from.Withdraw(amount);
+ to.Deposit(amount);
+ }
+}
+```
+
+> **Naming Convention**: ABP suggests using the `Manager` or `Service` suffix for domain services. We typically use `Manager` suffix (e.g., `IssueManager`, `OrderManager`).
+
+> **Note**: This is a synchronous domain operation. The domain service focuses purely on business rules without infrastructure concerns like database access or event publishing. For cross-cutting concerns, use Application Service layer or domain events.
+
+---
+
+## Domain Service vs. Application Service
+
+Here's a quick comparison:
+
+
+
+| Layer | Responsibility | Example |
+| ----------------------- | -------------------------------------------------------------------------------- | ---------------------------- |
+| **Domain Service** | Pure business rule spanning entities/aggregates | `MoneyTransferManager` |
+| **Application Service** | Orchestrates use cases, handles repositories, transactions, external systems | `BankAppService` |
+
+---
+
+## The Application Service Layer
+
+An **Application Service** orchestrates the domain logic and handles infrastructure concerns:
+
+
+
+```csharp
+public class BankAppService : ApplicationService
+{
+ private readonly IRepository _accountRepository;
+ private readonly MoneyTransferManager _moneyTransferManager;
+
+ public BankAppService(
+ IRepository accountRepository,
+ MoneyTransferManager moneyTransferManager)
+ {
+ _accountRepository = accountRepository;
+ _moneyTransferManager = moneyTransferManager;
+ }
+
+ public async Task TransferAsync(Guid fromId, Guid toId, decimal amount)
+ {
+ var from = await _accountRepository.GetAsync(fromId);
+ var to = await _accountRepository.GetAsync(toId);
+
+ _moneyTransferManager.Transfer(from, to, amount);
+
+ await _accountRepository.UpdateAsync(from);
+ await _accountRepository.UpdateAsync(to);
+ }
+}
+```
+
+> **Note**: Domain services are automatically registered to Dependency Injection with a **Transient** lifetime when inheriting from `DomainService`.
+
+---
+
+## Benefits of ABP's DomainService Base Class
+
+The `DomainService` base class gives you access to:
+
+- **Localization** (`IStringLocalizer L`) - Multi-language support for error messages
+- **Logging** (`ILogger Logger`) - Built-in logger for tracking operations
+- **Local Event Bus** (`ILocalEventBus LocalEventBus`) - Publish local domain events
+- **Distributed Event Bus** (`IDistributedEventBus DistributedEventBus`) - Publish distributed events
+- **GUID Generator** (`IGuidGenerator GuidGenerator`) - Sequential GUID generation for better database performance
+- **Clock** (`IClock Clock`) - Abstraction for date/time operations
+
+### Example with ABP Features
+
+> **Important**: While domain services *can* publish domain events using the event bus, they should remain focused on business rules. Consider whether event publishing belongs in the domain service or the application service based on your consistency boundaries.
+
+```csharp
+public class MoneyTransferredEvent
+{
+ public Guid FromAccountId { get; set; }
+ public Guid ToAccountId { get; set; }
+ public decimal Amount { get; set; }
+}
+
+public class MoneyTransferManager : DomainService
+{
+ public async Task TransferAsync(Account from, Account to, decimal amount)
+ {
+ if (from is null) throw new ArgumentNullException(nameof(from));
+ if (to is null) throw new ArgumentNullException(nameof(to));
+ if (ReferenceEquals(from, to))
+ throw new BusinessException(L["SameAccountTransferNotAllowed"]);
+ if (amount <= 0)
+ throw new BusinessException(L["InvalidTransferAmount"]);
+
+ // Log the operation
+ Logger.LogInformation(
+ "Transferring {Amount} from {From} to {To}", amount, from.Id, to.Id);
+
+ from.Withdraw(amount);
+ to.Deposit(amount);
+
+ // Publish local event for further policies (limits, notifications, audit, etc.)
+ await LocalEventBus.PublishAsync(
+ new MoneyTransferredEvent
+ {
+ FromAccountId = from.Id,
+ ToAccountId = to.Id,
+ Amount = amount
+ }
+ );
+ }
+}
+```
+
+> **Local Events**: By default, event handlers are executed within the same Unit of Work. If an event handler throws an exception, the database transaction is rolled back, ensuring consistency.
+
+---
+
+## Best Practices
+
+### 1. Keep Domain Services Pure and Focused on Business Rules
+
+Domain services should only contain business logic. They should not be responsible for application-level concerns like database transactions, authorization, or fetching entities from a repository.
+
+```csharp
+// Good ✅ Pure rule: receives aggregates already loaded.
+public class MoneyTransferManager : DomainService
+{
+ public void Transfer(Account from, Account to, decimal amount)
+ {
+ // Business rules and coordination
+ from.Withdraw(amount);
+ to.Deposit(amount);
+ }
+}
+
+// Bad ❌ Mixing application and domain concerns.
+// This logic belongs in an Application Service.
+public class MoneyTransferManager : DomainService
+{
+ private readonly IRepository _accountRepository;
+
+ public MoneyTransferManager(IRepository accountRepository)
+ {
+ _accountRepository = accountRepository;
+ }
+
+ public async Task TransferAsync(Guid fromId, Guid toId, decimal amount)
+ {
+ // Don't fetch entities inside a domain service.
+ var from = await _accountRepository.GetAsync(fromId);
+ var to = await _accountRepository.GetAsync(toId);
+
+ from.Withdraw(amount);
+ to.Deposit(amount);
+ }
+}
+```
+
+### 2. Leverage Entity Methods First
+
+Always prefer encapsulating business logic within an entity's methods when the logic belongs to a single aggregate. A domain service should only be used when a business rule spans multiple aggregates.
+
+```csharp
+// Good ✅ - Internal state change belongs in the entity
+public class Account : AggregateRoot
+{
+ public decimal Balance { get; private set; }
+
+ public void Withdraw(decimal amount)
+ {
+ if (Balance < amount)
+ throw new BusinessException("Insufficient balance");
+ Balance -= amount;
+ }
+}
+
+// Use Domain Service only when logic spans multiple aggregates
+public class MoneyTransferManager : DomainService
+{
+ public void Transfer(Account from, Account to, decimal amount)
+ {
+ from.Withdraw(amount); // Delegates to entity
+ to.Deposit(amount); // Delegates to entity
+ }
+}
+```
+
+### 3. Prefer Domain Services over Anemic Entities
+
+Avoid placing business logic that coordinates multiple entities directly into an application service. This leads to an "Anemic Domain Model," where entities are just data bags and the business logic is scattered in application services.
+
+```csharp
+// Bad ❌ - Business logic is in the Application Service (Anemic Domain)
+public class BankAppService : ApplicationService
+{
+ public async Task TransferAsync(Guid fromId, Guid toId, decimal amount)
+ {
+ var from = await _accountRepository.GetAsync(fromId);
+ var to = await _accountRepository.GetAsync(toId);
+
+ // This is domain logic and should be in a Domain Service
+ if (ReferenceEquals(from, to))
+ throw new BusinessException("Cannot transfer to the same account.");
+ if (amount <= 0)
+ throw new BusinessException("Transfer amount must be positive.");
+
+ from.Withdraw(amount);
+ to.Deposit(amount);
+ }
+}
+```
+
+### 4. Use Meaningful Names
+
+ABP recommends naming domain services with a `Manager` or `Service` suffix based on the business concept they represent.
+
+```csharp
+// Good ✅
+MoneyTransferManager
+OrderManager
+IssueManager
+InventoryAllocationService
+
+// Bad ❌
+AccountHelper
+OrderProcessor
+```
+
+---
+
+## Advanced Example: Order Processing with Inventory Check
+
+Here's a more complex scenario showing domain service interaction with domain abstractions:
+
+```csharp
+// Domain abstraction - defines contract but implementation is in infrastructure
+public interface IInventoryChecker : IDomainService
+{
+ Task IsAvailableAsync(Guid productId, int quantity);
+}
+
+public class OrderManager : DomainService
+{
+ private readonly IInventoryChecker _inventoryChecker;
+
+ public OrderManager(IInventoryChecker inventoryChecker)
+ {
+ _inventoryChecker = inventoryChecker;
+ }
+
+ // Validates and coordinates order processing with inventory
+ public async Task ProcessAsync(Order order, Inventory inventory)
+ {
+ // First pass: validate availability using domain abstraction
+ foreach (var item in order.Items)
+ {
+ if (!await _inventoryChecker.IsAvailableAsync(item.ProductId, item.Quantity))
+ {
+ throw new BusinessException(
+ L["InsufficientInventory", item.ProductId]);
+ }
+ }
+
+ // Second pass: perform reservations
+ foreach (var item in order.Items)
+ {
+ inventory.Reserve(item.ProductId, item.Quantity);
+ }
+
+ order.SetStatus(OrderStatus.Processing);
+ }
+}
+```
+
+> **Domain Abstractions**: The `IInventoryChecker` interface is a domain service contract. Its implementation can be in the infrastructure layer, but the contract belongs to the domain. This keeps the domain layer independent of infrastructure details while still allowing complex validations.
+
+> **Caution**: Always perform validation and action atomically within a single transaction to avoid race conditions (TOCTOU - Time Of Check Time Of Use).
+
+> **Transaction Boundaries**: When a domain service coordinates multiple aggregates, ensure the Application Service wraps the operation in a Unit of Work to maintain consistency. ABP's `[UnitOfWork]` attribute or Application Services' built-in UoW handling ensures this automatically.
+
+---
+
+## Common Pitfalls and How to Avoid Them
+
+### 1. Bloated Domain Services
+Don't let domain services become "god objects" that do everything. Keep them focused on a single business concept.
+
+```csharp
+// Bad ❌ - Too many responsibilities
+public class AccountManager : DomainService
+{
+ public void Transfer(Account from, Account to, decimal amount) { }
+ public void CalculateInterest(Account account) { }
+ public void GenerateStatement(Account account) { }
+ public void ValidateAddress(Account account) { }
+ public void SendNotification(Account account) { }
+}
+
+// Good ✅ - Split by business concept
+public class MoneyTransferManager : DomainService
+{
+ public void Transfer(Account from, Account to, decimal amount) { }
+}
+
+public class InterestCalculationManager : DomainService
+{
+ public void Calculate(Account account) { }
+}
+```
+
+### 2. Circular Dependencies Between Aggregates
+When domain services coordinate multiple aggregates, be careful about creating circular dependencies.
+
+```csharp
+// Consider using Domain Events instead of direct coupling
+public class OrderManager : DomainService
+{
+ public async Task ProcessAsync(Order order)
+ {
+ order.SetStatus(OrderStatus.Processing);
+
+ // Instead of directly modifying Customer aggregate here,
+ // publish an event that CustomerManager can handle
+ await LocalEventBus.PublishAsync(new OrderProcessedEvent
+ {
+ OrderId = order.Id,
+ CustomerId = order.CustomerId
+ });
+ }
+}
+```
+
+### 3. Confusing Domain Service with Domain Event Handlers
+Domain services orchestrate business operations. Domain event handlers react to state changes. Don't mix them.
+
+```csharp
+// Domain Service - Orchestrates business logic
+public class MoneyTransferManager : DomainService
+{
+ public async Task TransferAsync(Account from, Account to, decimal amount)
+ {
+ from.Withdraw(amount);
+ to.Deposit(amount);
+ await LocalEventBus.PublishAsync(
+ new MoneyTransferredEvent
+ {
+ FromAccountId = from.Id,
+ ToAccountId = to.Id,
+ Amount = amount
+ }
+ );
+ }
+}
+
+// Domain Event Handler - Reacts to domain events
+public class MoneyTransferredEventHandler :
+ ILocalEventHandler,
+ ITransientDependency
+{
+ public async Task HandleEventAsync(MoneyTransferredEvent eventData)
+ {
+ // Send notification, update analytics, etc.
+ }
+}
+```
+
+---
+
+## Testing Domain Services
+
+Domain services are easy to test because they have minimal dependencies:
+
+```csharp
+public class MoneyTransferManager_Tests
+{
+ [Fact]
+ public void Should_Transfer_Money_Between_Accounts()
+ {
+ // Arrange
+ var fromAccount = new Account(1000m);
+ var toAccount = new Account(500m);
+ var manager = new MoneyTransferManager();
+
+ // Act
+ manager.Transfer(fromAccount, toAccount, 200m);
+
+ // Assert
+ fromAccount.Balance.ShouldBe(800m);
+ toAccount.Balance.ShouldBe(700m);
+ }
+
+ [Fact]
+ public void Should_Throw_When_Insufficient_Balance()
+ {
+ var fromAccount = new Account(100m);
+ var toAccount = new Account(500m);
+ var manager = new MoneyTransferManager();
+
+ Should.Throw(() =>
+ manager.Transfer(fromAccount, toAccount, 200m));
+ }
+
+ [Fact]
+ public void Should_Throw_When_Amount_Is_NonPositive()
+ {
+ var fromAccount = new Account(100m);
+ var toAccount = new Account(100m);
+ var manager = new MoneyTransferManager();
+
+ Should.Throw(() =>
+ manager.Transfer(fromAccount, toAccount, 0m));
+ Should.Throw(() =>
+ manager.Transfer(fromAccount, toAccount, -5m));
+ }
+
+ [Fact]
+ public void Should_Throw_When_Same_Account()
+ {
+ var account = new Account(100m);
+ var manager = new MoneyTransferManager();
+
+ Should.Throw(() =>
+ manager.Transfer(account, account, 10m));
+ }
+}
+```
+
+### Integration Testing with ABP Test Infrastructure
+
+```csharp
+public class MoneyTransferManager_IntegrationTests : BankingDomainTestBase
+{
+ private readonly MoneyTransferManager _transferManager;
+ private readonly IRepository _accountRepository;
+
+ public MoneyTransferManager_IntegrationTests()
+ {
+ _transferManager = GetRequiredService();
+ _accountRepository = GetRequiredService>();
+ }
+
+ [Fact]
+ public async Task Should_Transfer_And_Persist_Changes()
+ {
+ // Arrange
+ var fromAccount = new Account(1000m);
+ var toAccount = new Account(500m);
+
+ await _accountRepository.InsertAsync(fromAccount);
+ await _accountRepository.InsertAsync(toAccount);
+ await UnitOfWorkManager.Current.SaveChangesAsync();
+
+ // Act
+ await _transferManager.TransferAsync(fromAccount, toAccount, 200m);
+ await UnitOfWorkManager.Current.SaveChangesAsync();
+
+ // Assert
+ var updatedFrom = await _accountRepository.GetAsync(fromAccount.Id);
+ var updatedTo = await _accountRepository.GetAsync(toAccount.Id);
+
+ updatedFrom.Balance.ShouldBe(800m);
+ updatedTo.Balance.ShouldBe(700m);
+ }
+}
+```
+
+---
+
+## When NOT to Use a Domain Service
+
+Not every operation needs a domain service. Avoid over-engineering:
+
+1. **Simple CRUD Operations**: Use Application Services directly
+2. **Single Aggregate Operations**: Use Entity methods
+3. **Infrastructure Concerns**: Use Infrastructure Services
+4. **Application Workflow**: Use Application Services
+
+```csharp
+// Don't create a domain service for this ❌
+public class AccountBalanceReader : DomainService
+{
+ public decimal GetBalance(Account account) => account.Balance;
+}
+
+// Just use the property directly ✅
+var balance = account.Balance;
+```
+
+---
+
+## Summary
+- **Domain Services** are domain-level, not application-level
+- They encapsulate **business logic that doesn't belong to a single entity**
+- They keep your **entities clean** and **business logic consistent**
+- In ABP, inherit from `DomainService` to get built-in features
+- Keep them **focused**, **pure**, and **testable**
+
+---
+
+## Final Thoughts
+
+Next time you're writing a business rule that doesn't clearly belong to an entity, ask yourself:
+
+> "Is this a Domain Service?"
+
+If it's pure domain logic that coordinates multiple entities or implements a business rule, **put it in the domain layer** - your future self (and your team) will thank you.
+
+Domain Services are a powerful tool in your DDD toolkit. Use them wisely to keep your domain model clean, expressive, and maintainable.
+
+---
diff --git a/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/summary.md b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/summary.md
new file mode 100644
index 0000000000..a047be4def
--- /dev/null
+++ b/docs/en/Community-Articles/2025-11-08-what-is-that-domain-service-in-ddd-for-net-developers/summary.md
@@ -0,0 +1 @@
+Learn what Domain Services are in Domain-Driven Design and when to use them in .NET projects. This practical guide covers the difference between Domain and Application Services, features real-world examples including money transfers and order processing, and shows how ABP Framework's DomainService base class simplifies implementation with built-in localization, logging, and event publishing.
diff --git a/docs/en/aspect-oriented-programming.md b/docs/en/aspect-oriented-programming.md
deleted file mode 100644
index c578f1e89c..0000000000
--- a/docs/en/aspect-oriented-programming.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Dynamic Proxying / Interceptors
-
-This document is planned to be written later.
\ No newline at end of file
diff --git a/docs/en/cli/index.md b/docs/en/cli/index.md
index 99a79aabb9..7decaa658c 100644
--- a/docs/en/cli/index.md
+++ b/docs/en/cli/index.md
@@ -358,7 +358,7 @@ Note that this command can upgrade your solution from a previous version, and al
* `--solution-name` or `-sn`: Specify the solution name. Search `*.sln` files in the directory by default.
* `--check-all`: Check the new version of each package separately. Default is `false`.
* `--version` or `-v`: Specifies the version to use for update. If not specified, latest version is used.
-* * `--leptonx-version` or `-lv`: Specifies the LeptonX version to use for update. If not specified, latest version or the version that is compatible with `--version` argument is used.
+* `--leptonx-version` or `-lv`: Specifies the LeptonX version to use for update. If not specified, latest version or the version that is compatible with `--version` argument is used.
### clean
diff --git a/docs/en/framework/data/entity-framework-core/index.md b/docs/en/framework/data/entity-framework-core/index.md
index 208baeefda..418c040565 100644
--- a/docs/en/framework/data/entity-framework-core/index.md
+++ b/docs/en/framework/data/entity-framework-core/index.md
@@ -146,7 +146,7 @@ Configure(options =>
});
````
-Add actions for the `ConfigureConventions` and `OnModelCreating` methods of the `DbContext` as shown below:
+Add actions for the `ConfigureConventions`, `OnModelCreating` and `OnConfiguring` methods of the `DbContext` as shown below:
````csharp
Configure(options =>
@@ -170,6 +170,15 @@ Configure(options =>
{
// This action is called for OnModelCreating method of specific DbContext.
});
+
+ options.ConfigureDefaultOnConfiguring((dbContext, optionsBuilder) =>
+ {
+ // This action is called for OnConfiguring method of all DbContexts.
+ });
+ options.ConfigureOnConfiguring((dbContext, optionsBuilder) =>
+ {
+ // This action is called for OnConfiguring method of specific DbContext.
+ });
});
````
diff --git a/docs/en/framework/data/entity-framework-core/migrations.md b/docs/en/framework/data/entity-framework-core/migrations.md
index 173fc32d4b..da87cfd26c 100644
--- a/docs/en/framework/data/entity-framework-core/migrations.md
+++ b/docs/en/framework/data/entity-framework-core/migrations.md
@@ -80,15 +80,15 @@ Every module uses its **own databases tables**. For example, the [Identity Modul
Since it is allowed to share a single database by all modules (it is the default configuration), a module typically uses a **table name prefix** to group its own tables.
-The fundamental modules, like [Identity](../../../modules/identity.md), [Tenant Management](../../../modules/tenant-management.md) and [Audit Logs](../../../modules/audit-logging.md), use the `Abp` prefix, while some other modules use their own prefixes. [Identity Server](../../../modules/identity-server.md) module uses the `IdentityServer` prefix for example.
+The fundamental modules, like [Identity](../../../modules/identity.md), [Tenant Management](../../../modules/tenant-management.md) and [Audit Logs](../../../modules/audit-logging.md), use the `Abp` prefix, while some other modules use their own prefixes. [OpenIddict](../../../modules/openiddict.md) module uses the `OpenIddict` prefix for example.
If you want, you can **change the database table name prefix** for a module for your application. Example:
````csharp
-Volo.Abp.IdentityServer.AbpIdentityServerDbProperties.DbTablePrefix = "Ids";
+Volo.Abp.OpenIddict.AbpOpenIddictDbProperties.DbTablePrefix = "Auth";
````
-This code changes the prefix of the [Identity Server](../../../modules/identity-server.md) module. Write this code **at the very beginning** in your application.
+This code changes the prefix of the [OpenIddict](../../../modules/openiddict.md) module. Write this code **at the very beginning** in your application.
> Every module also defines `DbSchema` property (near to `DbTablePrefix`), so you can set it for the databases support the schema usage.
diff --git a/docs/en/framework/data/entity-framework-core/mysql.md b/docs/en/framework/data/entity-framework-core/mysql.md
index 65bc1cb3b1..f5254e2419 100644
--- a/docs/en/framework/data/entity-framework-core/mysql.md
+++ b/docs/en/framework/data/entity-framework-core/mysql.md
@@ -32,11 +32,22 @@ Find `UseSqlServer()` calls in your solution. Check the following files:
Alternatively, you can use the [Pomelo.EntityFrameworkCore.MySql](https://www.nuget.org/packages/Pomelo.EntityFrameworkCore.MySql) provider. Replace the [Volo.Abp.EntityFrameworkCore.MySQL](https://www.nuget.org/packages/Volo.Abp.EntityFrameworkCore.MySQL) package with the [Volo.Abp.EntityFrameworkCore.MySQL.Pomelo](https://www.nuget.org/packages/Volo.Abp.EntityFrameworkCore.MySQL.Pomelo) package in your `.EntityFrameworkCore` project.
-Find ***YourProjectName*EntityFrameworkCoreModule** class inside the `.EntityFrameworkCore` project, replace `typeof(AbpEntityFrameworkCoreMySQLModule)` with `typeof(AbpEntityFrameworkCoreMySQLPomeloModule)` in the `DependsOn` attribute.
+To complete the switch to the Pomelo Provider, you'll need to update your module dependencies. To do that, find ***YourProjectName*EntityFrameworkCoreModule** class inside the `.EntityFrameworkCore` project, replace `typeof(AbpEntityFrameworkCoreMySQLModule)` with `typeof(AbpEntityFrameworkCoreMySQLPomeloModule)` in the `DependsOn` attribute.
-> Depending on your solution structure, you may find more code files need to be changed.
+Also, if you are switching from a provider other than ABP's MySQL provider, you need to call the `UseMySQL` method in the relevant places, as described in the next section.
+
+### UseMySQL()
+
+Find `UseSqlServer()` calls in your solution. Check the following files:
-The `UseMySQL()` method calls remain the same, no changes needed.
+* *YourProjectName*EntityFrameworkCoreModule.cs inside the `.EntityFrameworkCore` project. Replace `UseSqlServer()` with `UseMySql()`.
+* *YourProjectName*DbContextFactory.cs inside the `.EntityFrameworkCore` project. Replace `UseSqlServer()` with `UseMySql()`.
+
+You also need to specify the `ServerVersion`. See https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/wiki/Configuration-Options#server-version for more details.
+
+`UseMySql(configuration.GetConnectionString("Default"), ServerVersion.AutoDetect(configuration.GetConnectionString("Default")));` or `UseMySql(configuration.GetConnectionString("Default"), new MySqlServerVersion(new Version(8, 4, 6)));`
+
+> Depending on your solution structure, you may find more code files need to be changed.
## Change the Connection Strings
diff --git a/docs/en/framework/fundamentals/authorization.md b/docs/en/framework/fundamentals/authorization.md
index 0dae7bbf13..1a104ef420 100644
--- a/docs/en/framework/fundamentals/authorization.md
+++ b/docs/en/framework/fundamentals/authorization.md
@@ -466,14 +466,7 @@ public static class CurrentUserExtensions
}
```
-> If you use Identity Server please add your claims to `RequestedClaims` of `AbpClaimsServiceOptions`.
-
-```csharp
-Configure(options =>
-{
- options.RequestedClaims.AddRange(new[]{ "SocialSecurityNumber" });
-});
-```
+> If you use OpenIddict please see [Updating Claims in Access Token and ID Token](../../modules/openiddict#updating-claims-in-access_token-and-id_token).
## See Also
diff --git a/docs/en/modules/account-pro.md b/docs/en/modules/account-pro.md
index 62d7a00785..81e1177e33 100644
--- a/docs/en/modules/account-pro.md
+++ b/docs/en/modules/account-pro.md
@@ -7,7 +7,7 @@
# Account Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module implements the Login, Register, Forgot Password, Email Confirmation, Password Reset, sending and confirming Two-Factor Authentication, user lockout, switch between tenants functionalities of an application;
diff --git a/docs/en/modules/ai-management/index.md b/docs/en/modules/ai-management/index.md
index b85112efb7..c114edfdd2 100644
--- a/docs/en/modules/ai-management/index.md
+++ b/docs/en/modules/ai-management/index.md
@@ -1,3 +1,10 @@
+```json
+//[doc-seo]
+{
+ "Description": "Discover how to implement AI management in your ABP Framework application, enhancing workspace dynamics with easy installation options."
+}
+```
+
# AI Management (Pro)
> You must have an ABP Team or a higher license to use this module.
@@ -32,10 +39,10 @@ AI Management module packages are designed for various usage scenarios. Packages
### Menu Items
-AI Management module adds the following items to the "Main" menu, under the "Administration" menu item:
+AI Management module adds the following items to the "Main" menu:
-* **Workspaces**: Workspace management page.
-* **Chat**: AI chat interface for testing workspaces.
+* **AI Management**: Root menu item for AI Management module. (`AIManagement`)
+ * **Workspaces**: Workspace management page. (`AIManagement.Workspaces`)
`AIManagementMenus` class has the constants for the menu item names.
@@ -135,14 +142,15 @@ PreConfigure(options =>
Example (data seeding):
```csharp
-await _workspaceRepository.InsertAsync(new Workspace(
+var workspace = new Workspace(
name: "CustomerSupportWorkspace",
provider: "OpenAI",
modelName: "gpt-4",
- apiKey: "your-api-key",
- systemPrompt: "You are a helpful customer support assistant.",
- requiredPermissionName: "MyApp.CustomerSupport"
-));
+ apiKey: "your-api-key"
+);
+workspace.ApplicationName = ApplicationInfoAccessor.ApplicationName;
+workspace.SystemPrompt = "You are a helpful customer support assistant.";
+await _workspaceRepository.InsertAsync(workspace);
```
### Workspace Naming Rules
@@ -155,8 +163,6 @@ await _workspaceRepository.InsertAsync(new Workspace(
The AI Management module defines the following permissions:
-### Workspace Management Permissions
-
| Permission | Description | Default Granted To |
|------------|-------------|-------------------|
| `AIManagement.Workspaces` | View workspaces | Admin role |
@@ -164,11 +170,6 @@ The AI Management module defines the following permissions:
| `AIManagement.Workspaces.Update` | Edit existing workspaces | Admin role |
| `AIManagement.Workspaces.Delete` | Delete workspaces | Admin role |
-### Chat Permissions
-
-| Permission | Description | Default Granted To |
-|------------|-------------|-------------------|
-| `AIManagement.Chat` | Access chat interface | Admin role |
### Workspace-Level Permissions
@@ -184,9 +185,8 @@ var workspace = new Workspace(
```
When a workspace has a required permission:
-* Only users with that permission can access the workspace
+* Only authorized users with that permission can access the workspace endpoints
* Users without the permission will receive an authorization error
-* The workspace will not appear in the workspace selection dropdown for unauthorized users
## Usage Scenarios
diff --git a/docs/en/modules/audit-logging-pro.md b/docs/en/modules/audit-logging-pro.md
index 20f220857c..e64b39dc66 100644
--- a/docs/en/modules/audit-logging-pro.md
+++ b/docs/en/modules/audit-logging-pro.md
@@ -7,7 +7,7 @@
# Audit Logging Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module implements the Audit Logging system of an application;
diff --git a/docs/en/modules/chat.md b/docs/en/modules/chat.md
index b6932149fb..fa87a8eef6 100644
--- a/docs/en/modules/chat.md
+++ b/docs/en/modules/chat.md
@@ -7,7 +7,7 @@
# Chat Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module implements real time messaging between users for an application.
diff --git a/docs/en/modules/cms-kit-pro/contact-form.md b/docs/en/modules/cms-kit-pro/contact-form.md
index 6cdb08a569..eafa4b80b3 100644
--- a/docs/en/modules/cms-kit-pro/contact-form.md
+++ b/docs/en/modules/cms-kit-pro/contact-form.md
@@ -7,7 +7,7 @@
# CMS Kit Pro: Contact Management
-> You must have an ABP Team or a higher license to use CMS Kit Pro module's features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use CMS Kit Pro module's features.
CMS Kit provides a widget to create a contact form on your website.
diff --git a/docs/en/modules/cms-kit-pro/faq.md b/docs/en/modules/cms-kit-pro/faq.md
index 78ec252d17..23d90d9705 100644
--- a/docs/en/modules/cms-kit-pro/faq.md
+++ b/docs/en/modules/cms-kit-pro/faq.md
@@ -7,7 +7,7 @@
# CMS Kit Pro: FAQ System
-> You must have an ABP Team or a higher license to use CMS Kit Pro module's features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use CMS Kit Pro module's features.
The CMS kit provides a **FAQ** system to allow users to create, edit and delete FAQ's. Here is a screenshot of the FAQ widget:
diff --git a/docs/en/modules/cms-kit-pro/index.md b/docs/en/modules/cms-kit-pro/index.md
index 8a29db2d63..b7ce2f03d4 100644
--- a/docs/en/modules/cms-kit-pro/index.md
+++ b/docs/en/modules/cms-kit-pro/index.md
@@ -7,7 +7,7 @@
# CMS Kit Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module extends the [open-source CMS Kit module](../cms-kit) and adds additional CMS (Content Management System) capabilities to your application.
diff --git a/docs/en/modules/cms-kit-pro/newsletter.md b/docs/en/modules/cms-kit-pro/newsletter.md
index 84cc2ee34c..3097011658 100644
--- a/docs/en/modules/cms-kit-pro/newsletter.md
+++ b/docs/en/modules/cms-kit-pro/newsletter.md
@@ -7,7 +7,7 @@
# CMS Kit Pro: Newsletter System
-> You must have an ABP Team or a higher license to use CMS Kit Pro module's features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use CMS Kit Pro module's features.
CMS Kit provides a **newsletter** system to allow users to subscribe to newsletters. Here a screenshot of the newsletter subscription widget:
diff --git a/docs/en/modules/cms-kit-pro/page-feedback.md b/docs/en/modules/cms-kit-pro/page-feedback.md
index ac2278d893..559ed98a3a 100644
--- a/docs/en/modules/cms-kit-pro/page-feedback.md
+++ b/docs/en/modules/cms-kit-pro/page-feedback.md
@@ -7,7 +7,7 @@
# CMS Kit Pro: Page Feedback System
-> You must have an ABP Team or a higher license to use CMS Kit Pro module's features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use CMS Kit Pro module's features.
The CMS Kit Pro module provides a comprehensive **Page Feedback** system that enables you to collect valuable user feedback about your website pages. This system allows visitors to quickly rate their experience and provide comments, helping you understand user satisfaction and identify areas for improvement.
diff --git a/docs/en/modules/cms-kit-pro/poll.md b/docs/en/modules/cms-kit-pro/poll.md
index f10baf080e..dfee545219 100644
--- a/docs/en/modules/cms-kit-pro/poll.md
+++ b/docs/en/modules/cms-kit-pro/poll.md
@@ -7,7 +7,7 @@
# CMS Kit Pro: Poll System
-> You must have an ABP Team or a higher license to use CMS Kit Pro module's features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use CMS Kit Pro module's features.
CMS Kit provides a **poll** system to allow users to create, edit and delete polls. Here is a screenshot of the poll widget:
diff --git a/docs/en/modules/cms-kit-pro/url-forwarding.md b/docs/en/modules/cms-kit-pro/url-forwarding.md
index cd164ebba0..2a1b639cab 100644
--- a/docs/en/modules/cms-kit-pro/url-forwarding.md
+++ b/docs/en/modules/cms-kit-pro/url-forwarding.md
@@ -7,7 +7,7 @@
# CMS Kit Pro: URL Forwarding System
-> You must have an ABP Team or a higher license to use CMS Kit Pro module's features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use CMS Kit Pro module's features.
CMS Kit provides a **URL forwarding** system to create URLs that redirect to other pages or external websites.
diff --git a/docs/en/modules/cms-kit/dynamic-widget.md b/docs/en/modules/cms-kit/dynamic-widget.md
index 8644f7cd63..f0646cc00f 100644
--- a/docs/en/modules/cms-kit/dynamic-widget.md
+++ b/docs/en/modules/cms-kit/dynamic-widget.md
@@ -124,21 +124,26 @@ In this image, after choosing your widget (on the other case, it changes automat
You can edit this output manually if do any wrong coding for that (wrong value or typo) you won't see the widget, even so, your page will be viewed successfully.
-## Options
-To configure the widget, you should define the below code in YourModule.cs
+## Options
+
+To add content widgets, you should configure the `CmsKitContentWidgetOptions` in your module's `ConfigureServices` method:
```csharp
Configure(options =>
{
options.AddWidget(widgetType: "Today", widgetName: "CmsToday", parameterWidgetName: "Format");
+
+ // Alternatively, you can add a widget conditionally based on a global feature being enabled
+ options.AddWidgetIfFeatureEnabled(typeof(PagesFeature), "Today", "CmsToday", "Format");
});
```
-Let's look at these parameters in detail
-* `widgetType` is used for end-user and more readable names. The following bold word represents widgetType.
-[Widget Type="**Today**" Format="yyyy-dd-mm HH:mm:ss"].
+The `CmsKitContentWidgetOptions` provides two methods for registering widgets:
-* `widgetName` is used for your widget name used in code for the name of the `ViewComponent`.
+- **AddWidget:** Registers a widget that will be available in the content editor. It accepts the following parameters:
+ - `widgetType` (required): A user-friendly name for the widget that appears in the widget selection dropdown and is used in content markup. For example, in `[Widget Type="Today"]`, `"Today"` is the `widgetType`.
+ - `widgetName` (required): The name of the `ViewComponent` that will be rendered. This must match the `Name` attribute of your `ViewComponent` (e.g., `[ViewComponent(Name = "CmsToday")]`).
+ - `parameterWidgetName` (optional): The name of the parameter widget that will be displayed in the "Add Widget" modal to collect parameter values from users. This is only required when your widget needs parameters.
-* `parameterWidgetName` is used the for editor component side to see on the `Add Widget` modal.
-After choosing the widget type from listbox (now just defined `Format`) and renders this widget automatically. It's required only to see UI once using parameters
\ No newline at end of file
+- **AddWidgetIfFeatureEnabled:** Registers a widget conditionally, only if a specified [global feature](../../framework/infrastructure/global-features.md) is enabled. It accepts the same parameters as `AddWidget`, plus an additional first parameter:
+ - `featureType` (required): The type of the global feature that must be enabled for the widget to be available (e.g., `typeof(PagesFeature)`).
\ No newline at end of file
diff --git a/docs/en/modules/file-management.md b/docs/en/modules/file-management.md
index 5725af4297..e0cb3225f1 100644
--- a/docs/en/modules/file-management.md
+++ b/docs/en/modules/file-management.md
@@ -7,7 +7,7 @@
# File Management Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module is used to upload, download and organize files in a hierarchical folder structure. It is also compatible to multi-tenancy and you can determine total size limit for your tenants.
diff --git a/docs/en/modules/forms.md b/docs/en/modules/forms.md
index f903cc471b..f2456b792b 100644
--- a/docs/en/modules/forms.md
+++ b/docs/en/modules/forms.md
@@ -7,7 +7,7 @@
# Forms Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module allows you to create questionnaires to gather information. The forms module can store responses as they come in and you can export the data to a CSV file. You can share your form with others with your form unique link. You can request authentication or allow anonymous reply. It is similar to the Google Form application. Usage area is quite wide, you can create surveys, manage event registrations, collect email addresses for a newsletter, create a quiz, and even receive an order request.
diff --git a/docs/en/modules/gdpr.md b/docs/en/modules/gdpr.md
index f797a3b713..0a0bd7fb09 100644
--- a/docs/en/modules/gdpr.md
+++ b/docs/en/modules/gdpr.md
@@ -7,7 +7,7 @@
# GDPR Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module allows users to download and delete their personal data collected by the application.
diff --git a/docs/en/modules/identity-pro.md b/docs/en/modules/identity-pro.md
index f23b9e801a..17c077c5c4 100644
--- a/docs/en/modules/identity-pro.md
+++ b/docs/en/modules/identity-pro.md
@@ -7,7 +7,7 @@
# Identity Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module implements the User and Role system of an application;
diff --git a/docs/en/modules/identity-server-pro.md b/docs/en/modules/identity-server-pro.md
index 66e16fcb71..48ead33082 100644
--- a/docs/en/modules/identity-server-pro.md
+++ b/docs/en/modules/identity-server-pro.md
@@ -7,7 +7,7 @@
# Identity Server Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module provides integration and management functionality for Identity Server;
diff --git a/docs/en/modules/identity/idap.md b/docs/en/modules/identity/idap.md
index cf4c8fbcaa..c01bc630ef 100644
--- a/docs/en/modules/identity/idap.md
+++ b/docs/en/modules/identity/idap.md
@@ -9,13 +9,13 @@
## Introduction
-> You must have an ABP Team or a higher license to use this module & its features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module & its features.
The Identity PRO module has built-in `LdapExternalLoginProvider` and `OpenLdapManager` services. It implements LDAP authentication and gets user info for [external login](https://github.com/abpframework/abp/issues/4977).
The cross-platform [LdapForNet](https://www.nuget.org/packages/LdapForNet/) library is used for Windows LDAP authentication. See [LdapForNet GitHub repository](https://github.com/flamencist/ldap4net) for more information.
-> You must have an ABP Team or a higher license to use this module & its features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module & its features.
## How to enable LDAP external login?
diff --git a/docs/en/modules/identity/import-external-users.md b/docs/en/modules/identity/import-external-users.md
index 562515ceee..00c8e4b824 100644
--- a/docs/en/modules/identity/import-external-users.md
+++ b/docs/en/modules/identity/import-external-users.md
@@ -9,7 +9,7 @@
## Introduction
-> You must have an ABP Team or a higher license to use this module & its features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module & its features.
The Identity PRO module has built-in `LdapExternalLoginProvider` and `OAuthExternalLoginProvider` services. They not only support external login but also import users.
diff --git a/docs/en/modules/identity/oauth-login.md b/docs/en/modules/identity/oauth-login.md
index f628ec8c7b..b36e35cfc1 100644
--- a/docs/en/modules/identity/oauth-login.md
+++ b/docs/en/modules/identity/oauth-login.md
@@ -9,7 +9,7 @@
## Introduction
-> You must have an ABP Team or a higher license to use this module & its features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module & its features.
The Identity PRO module has built-in `OAuthExternalLoginProvider` service. It implements OAuth Resource Owner Password authentication and gets user info for [external login](https://github.com/abpframework/abp/issues/4977).
diff --git a/docs/en/modules/identity/periodic-password-change.md b/docs/en/modules/identity/periodic-password-change.md
index 4367ee88bb..2a5acf9634 100644
--- a/docs/en/modules/identity/periodic-password-change.md
+++ b/docs/en/modules/identity/periodic-password-change.md
@@ -9,7 +9,7 @@
## Introduction
-> You must have an ABP Team or a higher license to use this module & its features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module & its features.
The Identity PRO module has a built-in password aging function.
diff --git a/docs/en/modules/identity/two-factor-authentication.md b/docs/en/modules/identity/two-factor-authentication.md
index 2acab6ec53..1ac4b5dd75 100644
--- a/docs/en/modules/identity/two-factor-authentication.md
+++ b/docs/en/modules/identity/two-factor-authentication.md
@@ -7,7 +7,7 @@
# Two Factor Authentication
-> You must have an ABP Team or a higher license to use this module & its features.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module & its features.
Two-factor authentication (**2FA**) is a specific type of multi-factor authentication (MFA) that requires the authenticating party to produce two separate identifying factors to verify your identity. The first factor is something you know "**username & password**" and the second factor is something you have "**mobile device or email**" to verify authentication requests. 2FA protects against phishing, social engineering and password brute-force attacks and secures your logins from attackers exploiting weak or stolen credentials.
diff --git a/docs/en/modules/language-management.md b/docs/en/modules/language-management.md
index 8ac9e6088e..a4c2968c2b 100644
--- a/docs/en/modules/language-management.md
+++ b/docs/en/modules/language-management.md
@@ -7,7 +7,7 @@
# Language Management Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module implements the Language management system of an application;
diff --git a/docs/en/modules/openiddict-pro.md b/docs/en/modules/openiddict-pro.md
index 5b681f6461..f531f65531 100644
--- a/docs/en/modules/openiddict-pro.md
+++ b/docs/en/modules/openiddict-pro.md
@@ -7,7 +7,7 @@
# OpenIddict Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module provides integration and management functionality for the OpenIddict library;
diff --git a/docs/en/modules/payment-custom-gateway.md b/docs/en/modules/payment-custom-gateway.md
index a17a225e09..df142f7a8c 100644
--- a/docs/en/modules/payment-custom-gateway.md
+++ b/docs/en/modules/payment-custom-gateway.md
@@ -7,7 +7,7 @@
# Creating a Custom Payment Gateway
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This document explains creating custom a payment gateway that's different than the existing ones in the [Payment Module](payment#packages).
diff --git a/docs/en/modules/payment.md b/docs/en/modules/payment.md
index b0d976b758..29654a2d42 100644
--- a/docs/en/modules/payment.md
+++ b/docs/en/modules/payment.md
@@ -7,7 +7,7 @@
# Payment Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
Payment module implements payment gateway integration of an application. It provides one time payment and recurring payment options.
diff --git a/docs/en/modules/saas.md b/docs/en/modules/saas.md
index d6faa4dbcb..cf88cf716a 100644
--- a/docs/en/modules/saas.md
+++ b/docs/en/modules/saas.md
@@ -7,7 +7,7 @@
# SaaS Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module is used to manage your tenants and editions in multi-tenant applications;
diff --git a/docs/en/modules/text-template-management.md b/docs/en/modules/text-template-management.md
index c0e19a0523..fa62ee7470 100644
--- a/docs/en/modules/text-template-management.md
+++ b/docs/en/modules/text-template-management.md
@@ -7,7 +7,7 @@
# Text Template Management Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
This module is used to store and edit template contents for [the text templating system](../framework/infrastructure/text-templating/index.md) of the ABP. So, you may need to understand it to better understand the purpose of this module.
diff --git a/docs/en/modules/twilio-sms.md b/docs/en/modules/twilio-sms.md
index 6ea6c7e93f..63ed91a148 100644
--- a/docs/en/modules/twilio-sms.md
+++ b/docs/en/modules/twilio-sms.md
@@ -7,7 +7,7 @@
# Twilio SMS Module (Pro)
-> You must have an ABP Team or a higher license to use this module.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this module.
[Twilio](https://www.twilio.com) is a cloud communication provider that makes it easy to send and receive SMS. ABP Twilio SMS module implements the SMS sending feature of `ISmsSender` interface with Twilio.
diff --git a/docs/en/release-info/migration-guides/abp-10-0.md b/docs/en/release-info/migration-guides/abp-10-0.md
index c4b46a1edd..f1ad4e0397 100644
--- a/docs/en/release-info/migration-guides/abp-10-0.md
+++ b/docs/en/release-info/migration-guides/abp-10-0.md
@@ -1,3 +1,10 @@
+```json
+//[doc-seo]
+{
+ "Description": "Upgrade your ABP solutions from v9.x to v10.0 with this comprehensive migration guide, ensuring compatibility and new features with .NET 10.0."
+}
+```
+
# ABP Version 10.0 Migration Guide
This document is a guide for upgrading ABP v9.x solutions to ABP v10.0. There are some changes in this version that may affect your applications, please read it carefully and apply the necessary changes to your application.
@@ -21,6 +28,10 @@ We removed the Razor Runtime Compilation support since it is obsolete and replac
If you want to keep using it, you can add [Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation](https://www.nuget.org/packages/Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation) package to your project and configure it manually.
```csharp
+using Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.AspNetCore.VirtualFileSystem;
+
public override void ConfigureServices(ServiceConfigurationContext context)
{
if (context.Services.GetHostingEnvironment().IsDevelopment())
diff --git a/docs/en/solution-templates/layered-web-application/mobile-applications.md b/docs/en/solution-templates/layered-web-application/mobile-applications.md
index 5d3c1385f4..553064284f 100644
--- a/docs/en/solution-templates/layered-web-application/mobile-applications.md
+++ b/docs/en/solution-templates/layered-web-application/mobile-applications.md
@@ -21,7 +21,7 @@
}
```
-> You must have an ABP Team or a higher license to be able to create a mobile application project with ABP Studio.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to be able to create a mobile application project with ABP Studio.
Mobile applications are an essential part of modern software solutions. They provide a user-friendly interface to the end-users and allow them to access the system from anywhere. ABP Studio allows you to create mobile applications for your layered solution. You can create a new mobile application project, configure it, and run it on your device.
diff --git a/docs/en/studio/release-notes.md b/docs/en/studio/release-notes.md
index b0627a887e..c3f57deaaf 100644
--- a/docs/en/studio/release-notes.md
+++ b/docs/en/studio/release-notes.md
@@ -9,6 +9,41 @@
This document contains **brief release notes** for each ABP Studio release. Release notes only include **major features** and **visible enhancements**. Therefore, they don't include all the development done in the related version.
+## 1.4.2 (2025-10-30)
+
+* Upgraded template dependencies for ABP Framework and LeptonX. (targeting ABP `9.3.6`)
+* AI Assistant is now enabled for all customers.
+* Fixed CLI default language problem during solution creation.
+* Improved task auto-start logic and notification handling.
+* Fixed Angular localization function inputs.
+* Set default mobile frameworks to **None** in the UI.
+* Disallowed dots (.) in module names of microservice sub-templates.
+* Solution Runner: show vertical scrollbar when needed and disable the Properties window while the app is running.
+
+## 1.4.1 (2025-10-16)
+
+* Fixed AI Assistant chat problems.
+* Added custom steps if built with CLI.
+* Fixed Release configuration builds.
+
+## 1.4.0 (2025-10-15)
+
+* The **Task Panel** has been introduced, providing a centralized place to manage and monitor background operations.
+* Added **CLI application properties** window, making it easier to configure and manage command-line tool settings directly within the Studio UI.
+* Added suggestion modal for building after creating service/web/gateway module.
+* Fixed mismatching hosts file record namespace problem.
+* Allow selecting `Default Profile` in Solution Runner.
+* Refactored Angular scripts.
+* Fixed: tools not browsable in Solution Runner with Aspire after Kubernetes deployment.
+
+## 1.3.3 (2025-10-06)
+
+* Upgraded template dependencies for ABP Framework and LeptonX. (targeting ABP `9.3.5`)
+* Fixed welcome page tutorial links.
+* Improved error handling during Helm chart installation and custom command execution.
+* Fixed microservice problems.
+* Fixed connection string problems.
+
## 1.3.2 (2025-09-25)
* Enhanced AI Assistant with bug fixes and improvements.
diff --git a/docs/en/studio/version-mapping.md b/docs/en/studio/version-mapping.md
index 6bd879f2ab..ba51cfb17d 100644
--- a/docs/en/studio/version-mapping.md
+++ b/docs/en/studio/version-mapping.md
@@ -11,6 +11,8 @@ This document provides a general overview of the relationship between various ve
| **ABP Studio Version** | **ABP Version of Startup Template** |
|------------------------|---------------------------|
+| 1.4.2 | 9.3.6 |
+| 1.3.3 to 1.4.1 | 9.3.5 |
| 1.3.0 - 1.3.2 | 9.3.4 |
| 1.2.2 | 9.3.2 |
| 1.2.1 | 9.3.1 |
diff --git a/docs/en/suite/index.md b/docs/en/suite/index.md
index 20005ecb21..b1c8d43fa7 100644
--- a/docs/en/suite/index.md
+++ b/docs/en/suite/index.md
@@ -17,7 +17,7 @@
}
````
-> You must have an ABP Team or a higher license to use the ABP Suite.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use the ABP Suite.
ABP Suite is a complementary tool to the ABP Platform. ABP Suite allows you to build web pages in a matter of minutes.
diff --git a/docs/en/tutorials/mobile/index.md b/docs/en/tutorials/mobile/index.md
index 4a487f84bc..20767b9f1d 100644
--- a/docs/en/tutorials/mobile/index.md
+++ b/docs/en/tutorials/mobile/index.md
@@ -7,7 +7,7 @@
# Mobile Application Development Tutorial: Book Store Application
-> You must have an ABP Team or a higher license to be able to create a mobile application.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to be able to create a mobile application.
Mobile application development tutorials are designed for developers who have completed [the web development part of the tutorial](../book-store/index.md) and wish to continue building the mobile version of the application.
diff --git a/docs/en/tutorials/mobile/maui/index.md b/docs/en/tutorials/mobile/maui/index.md
index fcd337f141..b1599021ba 100644
--- a/docs/en/tutorials/mobile/maui/index.md
+++ b/docs/en/tutorials/mobile/maui/index.md
@@ -9,7 +9,7 @@
## About This Tutorial
-> You must have an ABP Team or a higher license to be able to create a mobile application.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to be able to create a mobile application.
This tutorial assumes that you have completed the [Web Application Development tutorial](../../book-store/part-01.md) and built an ABP based application named `Acme.BookStore` with [MAUI](../../../get-started/maui.md) as the mobile option. Therefore, if you haven't completed the [Web Application Development tutorial](../../book-store/part-01.md), you either need to complete it or download the source code from down below and follow this tutorial.
diff --git a/docs/en/tutorials/mobile/react-native/index.md b/docs/en/tutorials/mobile/react-native/index.md
index 5b43df18e6..3bfeb245c5 100644
--- a/docs/en/tutorials/mobile/react-native/index.md
+++ b/docs/en/tutorials/mobile/react-native/index.md
@@ -11,7 +11,7 @@ React Native mobile option is *available for* ***Team*** *or higher licenses*. T
## About This Tutorial
-> You must have an ABP Team or a higher license to be able to create a mobile application.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to be able to create a mobile application.
- This tutorial assumes that you have completed the [Web Application Development tutorial](../../book-store/part-01.md) and built an ABP based application named `Acme.BookStore` with [React Native](../../../framework/ui/react-native) as the mobile option. Therefore, if you haven't completed the [Web Application Development tutorial](../../book-store/part-01.md), you either need to complete it or download the source code from down below and follow this tutorial.
- In this tutorial, we will only focus on the UI side of the `Acme.BookStore` application and will implement the CRUD operations.
diff --git a/docs/en/ui-themes/lepton-x/index.md b/docs/en/ui-themes/lepton-x/index.md
index 6cac738f69..e61c14b4af 100644
--- a/docs/en/ui-themes/lepton-x/index.md
+++ b/docs/en/ui-themes/lepton-x/index.md
@@ -7,7 +7,7 @@
# LeptonX Theme Module
-> You must have an ABP Team or a higher license to use this theme.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this theme.
The LeptonX Theme is a professional theme for the ABP.
diff --git a/docs/en/ui-themes/lepton/customizing-lepton-theme.md b/docs/en/ui-themes/lepton/customizing-lepton-theme.md
index 0bc29eb6a6..eb8c36ed2b 100644
--- a/docs/en/ui-themes/lepton/customizing-lepton-theme.md
+++ b/docs/en/ui-themes/lepton/customizing-lepton-theme.md
@@ -45,9 +45,16 @@ export const appConfig: ApplicationConfig = {
Import your style file to `src/style.scss`
-```css
+```scss
+/* style.scss */
+@import 'your-custom-style';
+```
+
+or
+
+```scss
/* style.scss */
-import 'your-custom-style';
+@use 'your-custom-style';
```
Or add your style file to the `styles` arrays which in `angular.json` file
diff --git a/docs/en/ui-themes/lepton/index.md b/docs/en/ui-themes/lepton/index.md
index 3a61bcde1c..535c1975fb 100644
--- a/docs/en/ui-themes/lepton/index.md
+++ b/docs/en/ui-themes/lepton/index.md
@@ -7,7 +7,7 @@
# Lepton Theme Module
-> You must have an ABP Team or a higher license to use this theme.
+> You must have an [ABP Team or a higher license](https://abp.io/pricing) to use this theme.
The Lepton Theme is a professional theme for the ABP.
diff --git a/framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/IPermissionDefinitionContext.cs b/framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/IPermissionDefinitionContext.cs
index c58c266e3f..7ff890bac7 100644
--- a/framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/IPermissionDefinitionContext.cs
+++ b/framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/IPermissionDefinitionContext.cs
@@ -1,13 +1,10 @@
using System;
-using JetBrains.Annotations;
using Volo.Abp.Localization;
namespace Volo.Abp.Authorization.Permissions;
public interface IPermissionDefinitionContext
{
- //TODO: Add Get methods to find and modify a permission or group.
-
IServiceProvider ServiceProvider { get; }
///
@@ -16,11 +13,11 @@ public interface IPermissionDefinitionContext
///
/// Name of the group
///
- PermissionGroupDefinition GetGroup([NotNull] string name);
+ PermissionGroupDefinition GetGroup(string name);
///
/// Tries to get a pre-defined permission group.
- /// Returns null if can not find the given group.
+ /// Returns null if it cannot find the given group.
///
/// Name of the group
///
@@ -33,7 +30,7 @@ public interface IPermissionDefinitionContext
/// Localized display name of the group
///
PermissionGroupDefinition AddGroup(
- [NotNull] string name,
+ string name,
ILocalizableString? displayName = null);
///
@@ -44,9 +41,9 @@ public interface IPermissionDefinitionContext
void RemoveGroup(string name);
///
- /// Tries to get a pre-defined permission group.
- /// Returns null if can not find the given group.
- /// Name of the group
+ /// Tries to get a pre-defined permission from all defined groups.
+ /// Returns null if it cannot find the given permission.
+ /// Name of the permission
///
- PermissionDefinition? GetPermissionOrNull([NotNull] string name);
+ PermissionDefinition? GetPermissionOrNull(string name);
}
diff --git a/framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationBase.cs b/framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationBase.cs
index 6811e2a9a1..8965b865d1 100644
--- a/framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationBase.cs
+++ b/framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationBase.cs
@@ -185,8 +185,7 @@ public abstract class AbpApplicationBase : IAbpApplication
{
try
{
- using var scope = ServiceProvider.CreateScope();
- var logger = scope.ServiceProvider.GetRequiredService>();
+ var logger = Services.GetInitLogger();
logger.LogException(ex, LogLevel.Trace);
}
catch
diff --git a/framework/src/Volo.Abp.Core/Volo/Abp/Internal/Telemetry/Activity/Providers/TelemetryActivityEventBuilder.cs b/framework/src/Volo.Abp.Core/Volo/Abp/Internal/Telemetry/Activity/Providers/TelemetryActivityEventBuilder.cs
index 201ac8c3b6..09c0c28430 100644
--- a/framework/src/Volo.Abp.Core/Volo/Abp/Internal/Telemetry/Activity/Providers/TelemetryActivityEventBuilder.cs
+++ b/framework/src/Volo.Abp.Core/Volo/Abp/Internal/Telemetry/Activity/Providers/TelemetryActivityEventBuilder.cs
@@ -8,7 +8,7 @@ using Volo.Abp.Internal.Telemetry.Constants;
namespace Volo.Abp.Internal.Telemetry.Activity.Providers;
-public class TelemetryActivityEventBuilder : ITelemetryActivityEventBuilder, ISingletonDependency
+public class TelemetryActivityEventBuilder : ITelemetryActivityEventBuilder, ITransientDependency
{
private readonly List _activityEnrichers;
@@ -31,7 +31,7 @@ public class TelemetryActivityEventBuilder : ITelemetryActivityEventBuilder, ISi
{
//ignored
}
-
+
if (context.IsTerminated)
{
return null;
@@ -40,10 +40,10 @@ public class TelemetryActivityEventBuilder : ITelemetryActivityEventBuilder, ISi
return context.Current;
}
-
+
private static bool FilterEnricher(ITelemetryActivityEventEnricher enricher)
{
- return ProxyHelper.GetUnProxiedType(enricher).Assembly.FullName!.StartsWith(TelemetryConsts.VoloNameSpaceFilter) &&
+ return ProxyHelper.GetUnProxiedType(enricher).Assembly.FullName!.StartsWith(TelemetryConsts.VoloNameSpaceFilter) &&
enricher is not IHasParentTelemetryActivityEventEnricher;
}
-}
\ No newline at end of file
+}
diff --git a/framework/src/Volo.Abp.EntityFrameworkCore.MySQL/Volo/Abp/EntityFrameworkCore/AbpDbContextConfigurationContextMySQLExtensions.cs b/framework/src/Volo.Abp.EntityFrameworkCore.MySQL/Volo/Abp/EntityFrameworkCore/AbpDbContextConfigurationContextMySQLExtensions.cs
index b869109a80..f04f8fd4f3 100644
--- a/framework/src/Volo.Abp.EntityFrameworkCore.MySQL/Volo/Abp/EntityFrameworkCore/AbpDbContextConfigurationContextMySQLExtensions.cs
+++ b/framework/src/Volo.Abp.EntityFrameworkCore.MySQL/Volo/Abp/EntityFrameworkCore/AbpDbContextConfigurationContextMySQLExtensions.cs
@@ -13,11 +13,19 @@ public static class AbpDbContextConfigurationContextMySQLExtensions
{
if (context.ExistingConnection != null)
{
- return context.DbContextOptions.UseMySQL(context.ExistingConnection, mySQLOptionsAction);
+ return context.DbContextOptions.UseMySQL(context.ExistingConnection, optionsBuilder =>
+ {
+ optionsBuilder.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
+ mySQLOptionsAction?.Invoke(optionsBuilder);
+ });
}
else
{
- return context.DbContextOptions.UseMySQL(context.ConnectionString, mySQLOptionsAction);
+ return context.DbContextOptions.UseMySQL(context.ConnectionString, optionsBuilder =>
+ {
+ optionsBuilder.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
+ mySQLOptionsAction?.Invoke(optionsBuilder);
+ });
}
}
}
diff --git a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContext.cs b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContext.cs
index c661799837..9243d4680e 100644
--- a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContext.cs
+++ b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContext.cs
@@ -117,6 +117,17 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
{
optionsBuilder.ConfigureWarnings(c => c.Ignore(RelationalEventId.PendingModelChangesWarning));
base.OnConfiguring(optionsBuilder);
+
+ if (LazyServiceProvider == null || Options == null)
+ {
+ return;
+ }
+
+ Options.Value.DefaultOnConfiguringAction?.Invoke(this, optionsBuilder);
+ foreach (var onConfiguringAction in Options.Value.OnConfiguringActions.GetOrDefault(typeof(TDbContext)) ?? [])
+ {
+ onConfiguringAction.As>().Invoke(this, optionsBuilder);
+ }
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
@@ -276,7 +287,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
if (EntityChangeOptions.Value.PublishEntityUpdatedEventWhenNavigationChanges)
{
var ignoredEntity = EntityChangeOptions.Value.IgnoredNavigationEntitySelectors.Any(selector => selector.Predicate(entityEntry.Entity.GetType()));
- var onlyForeignKeyModifiedEntity = entityEntry.State == EntityState.Modified && entityEntry.Properties.Where(x => x.IsModified).All(x => x.Metadata.IsForeignKey());
+ var onlyForeignKeyModifiedEntity = entityEntry.State == EntityState.Modified && IsOnlyForeignKeysModified(entityEntry);
if ((entityEntry.State == EntityState.Unchanged && ignoredEntity) || onlyForeignKeyModifiedEntity && ignoredEntity)
{
continue;
@@ -300,7 +311,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
}
else if (entityEntry.Properties.Any(x => x.IsModified && (x.Metadata.ValueGenerated == ValueGenerated.Never || x.Metadata.ValueGenerated == ValueGenerated.OnAdd)))
{
- if (entityEntry.Properties.Where(x => x.IsModified).All(x => x.Metadata.IsForeignKey()))
+ if (IsOnlyForeignKeysModified(entityEntry))
{
// Skip `PublishEntityDeletedEvent/PublishEntityUpdatedEvent` if only foreign keys have changed.
break;
@@ -436,13 +447,13 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
case EntityState.Modified:
if (entry.Properties.Any(x => x.IsModified && (x.Metadata.ValueGenerated == ValueGenerated.Never || x.Metadata.ValueGenerated == ValueGenerated.OnAdd)))
{
- var modifiedProperties = entry.Properties.Where(x => x.IsModified).ToList();
- if (modifiedProperties.All(x => x.Metadata.IsForeignKey()))
+ if (IsOnlyForeignKeysModified(entry))
{
// Skip `PublishEntityDeletedEvent/PublishEntityUpdatedEvent` if only foreign keys have changed.
break;
}
+ var modifiedProperties = entry.Properties.Where(x => x.IsModified).ToList();
var disableAuditingAttributes = modifiedProperties.Select(x => x.Metadata.PropertyInfo?.GetCustomAttribute()).ToList();
if (disableAuditingAttributes.Any(x => x == null || x.UpdateModificationProps))
{
@@ -489,6 +500,12 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
}
}
+ protected virtual bool IsOnlyForeignKeysModified(EntityEntry entry)
+ {
+ return entry.Properties.Where(x => x.IsModified).All(x => x.Metadata.IsForeignKey() &&
+ (x.CurrentValue == null || x.OriginalValue?.ToString() == x.CurrentValue?.ToString()));
+ }
+
protected virtual void HandlePropertiesBeforeSave()
{
var entries = ChangeTracker.Entries().ToList();
@@ -798,7 +815,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
modelBuilder,
mutableEntityType
);
-
+
entityTypeBuilder.ConfigureByConvention();
ConfigureGlobalFilters(modelBuilder, mutableEntityType, entityTypeBuilder);
@@ -815,7 +832,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
protected virtual void ConfigureGlobalFilters(
ModelBuilder modelBuilder,
- IMutableEntityType mutableEntityType,
+ IMutableEntityType mutableEntityType,
EntityTypeBuilder entityTypeBuilder)
where TEntity : class
{
@@ -846,7 +863,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
{
return;
}
-
+
foreach (var property in mutableEntityType.GetProperties().
Where(property => property.PropertyInfo != null &&
@@ -858,7 +875,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
modelBuilder,
mutableEntityType
);
-
+
entityTypeBuilder
.Property(property.Name)
.HasConversion(property.ClrType == typeof(DateTime)
@@ -868,7 +885,7 @@ public abstract class AbpDbContext : DbContext, IAbpEfCoreDbContext,
}
protected virtual void ConfigureValueGenerated(
- ModelBuilder modelBuilder,
+ ModelBuilder modelBuilder,
IMutableEntityType mutableEntityType)
where TEntity : class
{
diff --git a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContextOptions.cs b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContextOptions.cs
index acde97340b..a179bb3ee8 100644
--- a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContextOptions.cs
+++ b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/AbpDbContextOptions.cs
@@ -26,8 +26,12 @@ public class AbpDbContextOptions
internal Dictionary> ConventionActions { get; }
internal Action? DefaultOnModelCreatingAction { get; set; }
+
+ internal Action? DefaultOnConfiguringAction { get; set; }
internal Dictionary> OnModelCreatingActions { get; }
+
+ internal Dictionary> OnConfiguringActions { get; }
public AbpDbContextOptions()
{
@@ -37,6 +41,7 @@ public class AbpDbContextOptions
DbContextReplacements = new Dictionary();
ConventionActions = new Dictionary>();
OnModelCreatingActions = new Dictionary>();
+ OnConfiguringActions = new Dictionary>();
}
public void PreConfigure([NotNull] Action action)
@@ -84,6 +89,13 @@ public class AbpDbContextOptions
DefaultOnModelCreatingAction = action;
}
+
+ public void ConfigureDefaultOnConfiguring([NotNull] Action action)
+ {
+ Check.NotNull(action, nameof(action));
+
+ DefaultOnConfiguringAction = action;
+ }
public void ConfigureOnModelCreating([NotNull] Action action)
where TDbContext : AbpDbContext
@@ -102,6 +114,24 @@ public class AbpDbContextOptions
actions.Add(action);
}
+
+ public void ConfigureOnConfiguring([NotNull] Action action)
+ where TDbContext : AbpDbContext
+ {
+ Check.NotNull(action, nameof(action));
+
+ var actions = OnConfiguringActions.GetOrDefault(typeof(TDbContext));
+ if (actions == null)
+ {
+ OnConfiguringActions[typeof(TDbContext)] = new List