Merge branch 'dev' into doc/microservice-suite-usage

# Conflicts:
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/banner.png
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/boat-trip.jpg
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/collage-moscow.jpg
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/general-collage.jpg
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/halil-talk.jpg
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/my-talk-2.png
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/my-talk-pro-pictures.jpg
#	docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/my-talk.png

abp_io/AbpIoLocalization/AbpIoLocalization/Www/Localization/Resources/en.json

@@ -578,7 +578,7 @@
     "CreatePostCoverInfo1": "<i class='bi bi-dot'></i> Accepted file types : <strong>JPEG, JPG, PNG</strong>",
     "CreatePostCoverInfo2": "<i class='bi bi-dot'></i> Max file size : <strong>1 MB</strong>",
     "CreatePostCoverInfo3": "<i class='bi bi-dot'></i> Image proportion : <strong>16:9</strong>",
-    "CreatePostCoverInfo4": "<i class='bi bi-dot'></i> <a href='https://abp.io/assets/example-post-image.png'> Download a sample cover image </a>",
+    "CreatePostCoverInfo4": "<i class='bi bi-dot'></i> <a href='/assets/example-post-image.png' download> Download a sample cover image </a>",
     "ThisExtensionIsNotAllowed": "This extension is not allowed.",
     "TheFileIsTooLarge": "The file is too large.",
     "GoToThePost": "Go to the Post",
@@ -977,6 +977,8 @@
     "UISupportExplanation": "ABP Framework itself is UI framework agnostic and can work with any UI framework. However, startup templates, module UIs and themes were not implemented for all UI frameworks. Check out the <a href=\"{0}\">Getting Started document</a> for the up-to-date list of UI options.",
     "MicroserviceSupport": "Does it support the microservice architecture?",
     "WhereCanIDownloadSourceCode": "Where can I download the source-code?",
+    "HowCanIUpgradeMyProjectToCommercialTemplate": "How can I upgrade my open-source project to the commercial PRO templates?",
+    "HowCanIUpgradeMyProjectToCommercialExplanation": "You can check out our documentation at <a href=\"{0}\">Migrating from open source templates</a> to upgrade your open-source projects to the paid PRO templates.",
     "ComputerLimitation": "How many computers can a developer login when developing ABP?",
     "ComputerLimitationExplanation": "We specifically permit <strong>{0} computers</strong> per individual/licensed developer. Whenever there is a need for a developer to develop ABP based products on a third machine, an e-mail should be sent to [email protected] explaining the situation, and we will then make the appropriate allocation in our system.",
     "RefundPolicy": "Do you have a refund policy?",

docs/en/Blog-Posts/2024-09-17-My-Impressions-at-DotNext-2024-Conference/post.md

@@ -0,0 +1,87 @@
+# DotNext 2024 Conference: A Speaker’s Impressions
+
+![banner](banner.png)
+
+Last week, I had the chance of being a speaker at **DotNext 2024** in Moscow. [JUG Ru Group](https://jugru.org/en/) is arranging the DotNext Conferences since [2014](https://dotnext.ru/archive/). It's a specific conference for .NET developers held at the [MonArch Moscow Hotel](https://www.moscowmonarch.com/) on 10, 11 September 2024. This event brought together over **600 developers on-site, 200 developers online**, with around **35 speakers** delivering more than **30 talks**, making it one of the largest gatherings of the .NET community in Russia. 
+
+![Atmosphere-1](general-1.png)
+
+---
+
+
+
+## Key Highlights & Popular Sessions
+
+One of the standout aspects of the conference was its strong technical focus, particularly on deep-dive .NET topics. Talks covered subjects like **low-level optimizations**, architecture, performance, and platform internals. 
+
+The conference started with Sergei Benzenko's talk "What's New in .NET 9". There are important topics like ".NET Aspire in Action", "AI-Driven Software Development", "DDD and Strategic Design" and "OAuth 2.0 User-Managed Access in ASP.NET Core with Keycloak". 
+
+![DotNext 2024 Speakers](speakers.png)
+
+There were two international speakers: me and Halil Ibrahim Kalkan from ABP Core Team.  Halil's topic was **Implementing Domain-Driven Design as a Pragmatic Developer**. In his session, he gave practical real world examples of bad and best practices of DDD development. 
+
+![halil-talk](halil-talk.jpg)
+
+
+---
+
+
+
+## My Talk
+
+My presentation topic was **Building Multi-Tenant ASP.NET Core Applications** was part of this technical deep dive, and I was thrilled to see so much interest in scalable multi-tenant solutions.  I generally talked about meta data in SaaS development and explained how to identify the active tenant, how to isolate the data in the same database, how to set `TenantId` automatically for new entities, how to select DB connection for the active tenant, how to change the active tenant when needed, how to disable multi-tenancy temporarily, how to handle database migrations and lastly feature system. These features are major multi-tenancy features, and you'll learn how they are implemented in an open-source web app framework.
+
+![My Talk](my-talk.png)
+
+![my-talk-2](C:\Users\alper\OneDrive\Desktop\DotNext 2024 Photos\article\my-talk-2.png)
+
+- My presentation 🌐https://github.com/ebicoglu/presentations/tree/main.
+
+- My conf profile🌐 https://dotnext.ru/en/persons/cbe6e4b2cc214a47bfc3752cdb0b1f88/
+
+
+![My Talk Photos](my-talk-pro-pictures.jpg)
+
+---
+
+
+
+## Venue and Atmosphere
+
+The MonArch Moscow Hotel provided a great venue, combining spacious halls for sessions with cozy areas for networking. There were also afterparty events, which added a fun, informal touch to the otherwise highly technical environment. The setup allowed plenty of opportunities for spontaneous discussions with attendees and experts, both during and after the sessions.
+
+![Atmoshpere-4](general-collage.jpg)
+
+
+---
+
+
+
+## Boat Tour on Moscow River
+
+After the conference ended, the organizing team took all the speakers on a boat tour on the Moscow River. It was a great open buffet dinner in a nice boat. We had a chance to chat with other speakers. 
+
+![Boat Trip](boat-trip.jpg)
+
+---
+
+
+
+## Networking and Community
+
+DotNext 2024 provided an excellent platform for connecting with fellow developers and industry leaders. In addition to presentations, there were plenty of opportunities to interact with other participants, including representatives from Microsoft, Volosoft, and local Russian tech giants like Ozon and beeline. The exhibition hall was filled with partner stands, including those from PVS-Studio, Kontur, Eremex and OzonTech which offered interactive displays and demos.
+
+---
+
+
+
+## Conclusion
+
+Overall, DotNext 2024 lived up to its reputation as a key event for .NET developers. From highly technical talks to networking opportunities, it was a fantastic experience, and I came away with new insights into both the technical and community aspects of the .NET ecosystem. If you’re a .NET developer looking to stay ahead in your field, DotNext is definitely a conference worth attending!
+
+Looking forward to come again!
+
+
+Lastly, I took some beautiful photos of Moscow, here are a few...
+
+![Moscow Pictures](collage-moscow.jpg)

docs/en/Community-Articles/2024-08-28-Understanding-AOT-vs-JIT/POST.md

@@ -1,6 +1,6 @@
 
 
-![book](images/book.jpg)
+![book](images/cover.png)
 
 Ahead-of-Time (AOT) compilation and Just-in-Time (JIT) compilation are two different methods for compiling Angular applications. Here's a breakdown of the differences between them:
 

docs/en/Community-Articles/2024-09-18-Blazor-9-New-Features/post.md

@@ -0,0 +1,149 @@
+# ASP.NET Core Blazor 9.0 New Features Summary 🆕
+
+In this article, I'll highlight .NET 9's Blazor updates and important features for ASP.NET Core 9.0. These features are based on the latest .NET 9 Preview 7. 
+
+![Cover](cover.png)
+
+## .NET MAUI Blazor Hybrid App and Web App solution template
+
+There's a new solution template to create .**NET MAUI native** and **Blazor web client** apps. This new template allows to choose a Blazor interactive render mode, it uses a shared Razor class library to maintain the UI's Razor components.
+
+For more info:
+
+* [learn.microsoft.com > maui blazor web app tutorial](https://learn.microsoft.com/en-us/aspnet/core/blazor/hybrid/tutorials/maui-blazor-web-app?view=aspnetcore-9.0)
+* [reddit.com/r/Blazor/comments/1dabyzk/net_8_blazor_hybrid_maui_app_web_hosting/](https://www.reddit.com/r/Blazor/comments/1dabyzk/net_8_blazor_hybrid_maui_app_web_hosting/)
+
+
+
+## A new middleware: `MapStaticAssets` 
+
+This new middleware optimizes the delivery of static assets in any ASP.NET Core app, also for Blazor. Basically it compresses assets via [Gzip](https://datatracker.ietf.org/doc/html/rfc1952), [fingerprints](https://developer.mozilla.org/docs/Glossary/Fingerprinting) for all assets at build time with a Base64 and removes caches when Visual Studio Hot Reload (development time) is in action.
+
+For more info:
+
+* [learn.microsoft.com > optimizing static web assets](https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-9.0?view=aspnetcore-8.0#optimizing-static-web-asset-delivery)
+* [learn.microsoft.com > fundamentals of static files](https://learn.microsoft.com/en-us/aspnet/core/blazor/fundamentals/static-files?view=aspnetcore-9.0#static-asset-middleware)
+
+
+
+##  Simplifying the process of querying component states at runtime
+
+1. Finding the component's current execution location: This can be especially helpful for component performance optimization and debugging. 
+2. Verifying whether the component is operating in a dynamic environment by checking: This can be useful for parts whose actions vary according to how their surroundings interact.
+3. Obtaining the render mode allocated to the component: Comprehending the render mode can aid in enhancing the rendering procedure and augmenting the component's general efficiency.
+
+For more info:
+
+* [learn.microsoft.com > detect rendering location interactivity & render mode runtime](https://learn.microsoft.com/en-us/aspnet/core/blazor/components/render-modes?view=aspnetcore-9.0#detect-rendering-location-interactivity-and-assigned-render-mode-at-runtime)
+
+
+
+## Detecting component's location, interactivity support and render mode
+
+The `ComponentBase.RendererInfo` and `ComponentBase.AssignedRenderMode`  now allows to detect the following actions:
+
+* `RendererInfo.Name` returns the location where the component is executing
+* `RendererInfo.IsInteractive` indicates if the component supports interactivity at the time of rendering. 
+* `ComponentBase.AssignedRenderMode` exposes the component's assigned render mode
+
+
+
+## Better server-side reconnection 
+
+* When the previous app is disconnected and the user navigates to this app, or browser put this app in sleep mode, Blazor runs reconnection mechanism.
+
+* When reconnection is not successful because your server killed connection, it automatically makes a full page refresh.
+
+* With the new below config, you can adjust your reconnection retry time:
+
+  * ```csharp
+    Blazor.start({
+      circuit: {
+        reconnectionOptions: {
+          retryIntervalMilliseconds: (previousAttempts, maxRetries) => 
+            previousAttempts >= maxRetries ? null : previousAttempts * 1000
+        },
+      },
+    });
+    ```
+
+
+
+## Simple serialization for authentication
+
+The new APIs in ASP.NET make it easier to add authentication to existing Blazor Web Apps. These APIs, now part of the Blazor Web App project template, allow authentication state to be serialized on the server and deserialized in the browser, simplifying the process of integrating authentication. This removes the need for developers to manually implement or copy complex code, especially when using WebAssembly-based interactivity.
+
+For more info:
+
+- [learn.microsoft.com > blazor Identity UI individual accounts](https://learn.microsoft.com/en-us/aspnet/core/blazor/security/server/?view=aspnetcore-9.0#blazor-identity-ui-individual-accounts)
+- [learn.microsoft.com > manage authentication state](https://learn.microsoft.com/en-us/aspnet/core/blazor/security/server/?view=aspnetcore-9.0#manage-authentication-state-in-blazor-web-apps)
+
+
+
+## Easily add static server-side rendering pages
+
+With .NET 9, adding static server-side rendering (SSR) pages to globally interactive Blazor Web Apps has become simpler. The new `[ExcludeFromInteractiveRouting]` attribute allows developers to mark specific Razor component pages that require static SSR, such as those relying on HTTP cookies and the request/response cycle. Pages annotated with this attribute exit interactive routing and trigger a full-page reload, while non-annotated pages default to interactive rendering modes like `InteractiveServer`. This approach enables flexibility between static and interactive rendering depending on the page's requirements.
+
+For more info:
+
+* [learn.microsoft.com > render-modes](https://learn.microsoft.com/en-us/aspnet/core/blazor/components/render-modes?view=aspnetcore-9.0#static-ssr-pages-in-a-globally-interactive-app)
+
+
+
+## Constructor Injection in Razor Components
+
+Razor components support constructor injection, allowing services like `NavigationManager` to be injected directly into a component's constructor. This can be used to manage navigation actions, such as redirecting the user upon an event like a button click.
+
+For more info:
+
+* [learn.microsoft.com> dependency-injection](https://learn.microsoft.com/en-us/aspnet/core/blazor/fundamentals/dependency-injection?view=aspnetcore-9.0#request-a-service-in-a-component)
+
+
+
+## Configuring WebSocket Compression and Frame-Ancestors CSP in Interactive Server Components
+
+By default, Interactive Server components enable WebSocket compression and set a `frame-ancestors` Content Security Policy (CSP) to `self`, restricting embedding the app in `<iframe>`. Besides, compression can be disabled to improve security by setting `ConfigureWebSocketOptions` to null, though this may reduce performance. To prevent embedding the app in any `iframe` while maintaining WebSocket compression, set the `ContentSecurityFrameAncestorsPolicy` to 'none'.
+
+For more info:
+
+- [learn.microsoft.com > websocket compression](https://learn.microsoft.com/en-us/aspnet/core/blazor/fundamentals/signalr?view=aspnetcore-9.0#websocket-compression-for-interactive-server-components)
+- [learn.microsoft.com > interactive server-side rendering when compression enabled](https://learn.microsoft.com/en-us/aspnet/core/blazor/security/server/interactive-server-side-rendering?view=aspnetcore-9.0#interactive-server-components-with-websocket-compression-enabled)
+
+
+
+## Tracking Composition State with `KeyboardEventArgs.IsComposing`
+
+The new `KeyboardEventArgs.IsComposing` property indicates whether a keyboard event is part of a composition session, which is essential for properly handling international character input methods.
+
+
+
+## Configuring Row Overscan in `QuickGrid` with new `OverscanCount` parameter
+
+The `QuickGrid` component now includes an `OverscanCount` property, which controls how many extra rows are rendered before and after the visible area when virtualization is enabled. By default, `OverscanCount` is set to **3**, but it can be adjusted as below to **5**.
+
+```html
+<QuickGrid ItemsProvider="itemsProvider" Virtualize="true" OverscanCount="5">...</QuickGrid>
+```
+
+
+
+## Range Input Support in `InputNumber<TValue>` Component
+
+The `InputNumber<TValue>` component now supports the `type="range"` [attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range), allowing for range inputs like sliders or dials. This feature supports model binding and form validation, offering a more interactive way to input numerical data compared to the traditional text box.
+
+```html
+<EditForm>
+     <InputNumber @bind-Value="Model.ProductCount" max="999" min="1" step="1" type="range" />
+</EditForm>
+
+@code {
+    public class MyModel
+    {
+        [Required, Range(minimum: 1, maximum: 999)]
+        public int ProductCount { get; set; }
+    }
+}
+```
+
+
+

docs/en/docs-nav.json

@@ -50,7 +50,7 @@
           "path": "tutorials"
         },
         {
-          "text": "TODO application",
+          "text": "TODO Application",
           "items": [
             {
               "text": "Overview",
@@ -67,7 +67,7 @@
           ]
         },
         {
-          "text": "Book Store application",
+          "text": "Book Store Application",
           "items": [
             {
               "text": "Overview",
@@ -115,6 +115,47 @@
             }
           ]
         },
+        {
+          "text": "Modular Monolith Application",
+          "items": [
+            {
+              "text": "Overview",
+              "path": "tutorials/modular-crm/index.md"
+            },
+            {
+              "text": "1: Creating the initial solution",
+              "path": "tutorials/modular-crm/part-01.md"
+            },
+            {
+              "text": "2: Creating the initial Products module",
+              "path": "tutorials/modular-crm/part-02.md"
+            },
+            {
+              "text": "3: Building the Products module",
+              "path": "tutorials/modular-crm/part-03.md"
+            },
+            {
+              "text": "4: Creating the initial Ordering module",
+              "path": "tutorials/modular-crm/part-04.md"
+            },
+            {
+              "text": "5: Building the Ordering module",
+              "path": "tutorials/modular-crm/part-05.md"
+            },
+            {
+              "text": "6: Integrating the modules: Implementing Integration Services",
+              "path": "tutorials/modular-crm/part-06.md"
+            },
+            {
+              "text": "7: Integrating the modules: Communication via Messages (Events)",
+              "path": "tutorials/modular-crm/part-07.md"
+            },
+            {
+              "text": "8: Integrating the modules: Joining the Products and Orders Data",
+              "path": "tutorials/modular-crm/part-08.md"
+            }
+          ]
+        },
         {
           "text": "Community Articles",
           "path": "https://abp.io/community"

docs/en/framework/architecture/best-practices/index.md

@@ -1,7 +1,5 @@
 # Module Development Best Practices & Conventions
 
-### Introduction
-
 This document describes the **best practices** and **conventions** for those who want to develop **modules** that satisfy the following specifications:
 
 * Develop modules that conform to the **Domain Driven Design** patterns & best practices.
@@ -10,7 +8,7 @@ This document describes the **best practices** and **conventions** for those who
 
 Also, this guide is mostly usable for general **application development**.
 
-### Guides
+## The Guides
 
 * Overall
   * [Module Architecture](./module-architecture.md)