Merge branch 'dev' into dogan/4299

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

@@ -583,7 +583,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",
@@ -987,6 +987,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 license@abp.io explaining the situation, and we will then make the appropriate allocation in our system.",
     "RefundPolicy": "Do you have a refund policy?",
@@ -1838,8 +1840,8 @@
     "Raffle_Page_Title": "Raffle - {0}",
     "Raffle_Page_Description": "Participate in ABP raffles and stand a chance to win exciting prizes, engaging with the ABP Community.",
     "Docs_Page_Title": "ABP Documentation",
-    "Docs_Page_Description": "Dive into ABP's latest documentation. Find guides, API references, and best practices to help you effectively build and manage modern web apps with ABP",
-    "Videos_Page_Title": "{0} - Video Post | ABP.IO",
+    "Docs_Page_Description": "Access comprehensive guides and API references in the ABP Documentation, aiding in development and troubleshooting.",
+    "Videos_Page_Title": "{0} - Video Post",
     "AskQuestionsOnSupport": "You can ask questions on ABP Support.",
     "MicroserviceApplicationExplanation1": "Creates a distributed solution.",
     "MicroserviceApplicationExplanation2": "Recommended for large teams to create complex and scalable systems.",
@@ -1857,6 +1859,7 @@
     "NewsletterDeleteSubscriptionDescription": "<div style=\"line-height: 24px; text-align: justify;\"><span style=\"color:#000000;\">This is a confirmation that you have unsubscribed from the following email categories:<ul><li><strong>Promotional Offers:</strong>Discounts, seasonal campaigns, etc.</li><li><strong>Events:</strong>Community Talks, Webinars, ABP DOTNET Conference, etc.</li><li><strong>Release Notes:</strong>ABP Platform releases, new products, etc.</li><li><strong>Newsletter:</strong>Blog posts, community news, etc.</li></ul><br>Please note that you will still receive important transactional emails related to your account.</span></div>",
     "NewsletterEmailFooterTemplateDeleteSubscription": "<a style=\"color: #007bff;\" href=\"{0}\" data-root=\"{1}\">If you change your mind, you're always welcome to resubscribe!</a>",
     "GenerateQuote" : "Generate Quote" ,
-    "GeneratePriceQuote" : "Generate a Price Quote"
+    "GeneratePriceQuote": "Generate a Price Quote",
+    "Qa:QuestionPageTitle": "Support"
   }
 }

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/Community-Articles/2024-09-24-Angular-Difference-Btw-Promise-Observable/post.md

@@ -0,0 +1,124 @@
+# Difference Between "Promise" and "Observable" in Angular
+
+In this article, I will mention the differences between `Promise` and `Observable` . They are used in TypeScript (Angular) for handling async operations but have different use cases and behaviors. Let's see these six differences...
+
+![Cover](cover.png)
+
+
+
+## 1. Eager or Lazy Evaluation
+
+- **Promise**: A `promise` is **eager**! This means that as soon as a  `promise` is created, it executes the operation, like initiating immediately an HTTP request. **You can't control the execution start time; it begins right away!**
+
+- **Observable:** An `observable` is a **lazy** operation! It doesn't start executing until you subscribe to it. This allows you to define an `observable` without triggering the actual operation until it's needed.
+
+  
+
+## 2. Handling Value Count
+
+- **Promise:** A `promise` is designed to **handle a single async value**. Once the operation completes, it either resolves with a value or rejects with an error, and that's it! You can't emit multiple values with a single `promise`.
+
+- **Observable:** An `observable` **can emit multiple values** over time. It can have several values, and it can continue to do so until it either completes or errors out. So `observable` is ideal for event streams or data streams.
+
+  
+
+## 3. Cancellablity
+
+- **Promise:** Once a `promise` is created and the operation has started**, you cannot cancel it!** The `promise` will resolve or reject eventually, and   there's no way to stop it from being executed.
+
+- **Observable:** An `observable` **can be canceled**. If you unsubscribe from an `observable`, it stops emitting values and can clean up any resources like canceling an ongoing HTTP request. This makes `observable` more flexible in scenarios where you need to abort an operation.
+
+  
+
+## 4. Chaining and Composition
+
+- **Promise:** It **supports chaining** using `.then()` for handling the result and `.catch()` for handling errors. This is straightforward but can become complex for more advanced scenarios.
+
+- **Observable:** It **supports powerful operators** like `map`, `filter`, `merge`, `switchMap`. This allows for complex composition and transformation of data streams and makes it suitable for handling complex async scenarios.
+
+  
+
+## 5. Error Handling:
+
+- **Promise:** Error handling in `promise` is done usually using `.catch()`. However, **if an error occurs**, the `promise` will reject, and **the chain will stop**.
+
+- **Observable:** It has more **robust error-handling mechanisms**. You can handle errors using operators like `catchError` and decide whether to recover, continue or retry the process. It can also be completed successfully after an error is handled.
+
+  
+
+## 6. Built-In or RxJS
+
+- **Promise:** It’s a **built-in feature of JavaScript** and a part of the ECMAScript. Almost all **browsers support it**.
+- **Observable:** It’s **not a built-in feature of JavaScript**. In Angular, it’s provided by the `RxJS` library.
+
+
+
+---
+
+
+
+## Use Cases
+
+**Promise:**
+
+- Simple async operations that return a single result, like fetching data from a Web API.
+- Scenarios where you don’t need to cancel the operation.
+- Handling a single event or action.
+
+**Observable:**
+
+- Operations that might emit multiple values over time, such as `WebSocket` connections, user input events, or real-time data streams.
+- When you need the ability to cancel the operation.
+- Complex async flows require composition, transformation, or error handling.
+
+
+
+---
+
+
+
+## Examples
+
+### Promise Example
+
+```javascript
+const myPromise = new Promise((resolve, reject) => {
+  setTimeout(() => {
+    resolve('Promise is resolved!');
+  }, 1000);
+});
+
+myPromise.then(value => console.log(value)).catch(error => console.error(error));
+```
+
+### Observable Example
+
+```javascript
+import { Observable } from 'rxjs';
+
+const myObservable = new Observable(observer => {
+  setTimeout(() => {
+    observer.next('Value-1 retrieved!');
+    observer.next('Value-2 retrieved!');
+    observer.complete(); // No more values after this
+  }, 1000);
+});
+
+const subscription = myObservable.subscribe({
+  next: value => console.log(value),
+  error: error => console.error(error),
+  complete: () => console.log('Observable finished!')
+});
+
+/* 
+  You can unsubscribe to cancel the observable as below:
+  subscription.unsubscribe();
+*/
+```
+
+
+
+## Summary
+
+- **A promise** is simple and suitable for operations that return a single value or need to handle a single event. It’s eager and can’t be canceled.
+- **An observable** is more flexible, especially for handling multiple values over time, allowing for complex data manipulation, and providing the ability to cancel operations. It supports lazy operations via `RxJS`.

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)

docs/en/framework/ui/angular/modal.md

@@ -195,6 +195,59 @@ The modal with form looks like this:
 
 **`options`** is an input typed [NgbModalOptions](https://ng-bootstrap.github.io/#/components/modal/api#NgbModalOptions). It is configuration for the `ng-bootstrap` modal.
 
+
+**Examples:**
+
+- `animation`: This is an NgbModalOption property of type *boolean*. It controls whether the modal opens and closes with an animation. By default, it is set to true, meaning that the modal will have a smooth transition when it opens and closes. Setting it to false will disable these animations.
+
+```js
+import { Component } from '@angular/core';
+import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
+
+@Component({
+  selector: 'ngbd-modal-options',
+  ...})
+
+export class NgbdModalOptions {
+  modalService = inject(NgbModal);
+  animationModal(content) {
+    this.modalService.open(content, { animation: true });
+  }
+}
+```
+
+       The result of this configuration would be like this:
+
+![Modal example result](./images/animation-true.gif)
+
+       On the contrary, if we set it as false:
+
+![Modal example result](./images/animation-false.gif)
+
+
+- `fullscreen`: This is an NgbModalOption property of type *boolean or string*. When set to `true`, the element will expand to cover the entire screen, hiding all other interface elements. When set to `false`, the element remains in its regular size and position within the page.
+
+```js
+import { Component } from '@angular/core';
+import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
+
+@Component({
+ selector: 'ngbd-modal-options',
+ ...})
+
+export class NgbdModalOptions {
+ modalService = inject(NgbModal);
+ fullscreenModal(content) {
+   this.modalService.open(content, { fullscreen: true });
+ }
+}
+
+```
+
+       If `fullscreen: true`:
+
+![Modal example result](./images/fullscreen-true.png)
+
 #### suppressUnsavedChangesWarning
 
 ```js

docs/en/guides/migrating-from-open-source.md

@@ -1,6 +1,6 @@
 # Migrating from Open Source Templates
 
-ABP Studio provides a way for users, who already started the development before purchasing a license, to auto-upgrade their solutions with Pro modules. You can use this functionality through ABP Studio UI or ABP Studio CLI:
+[ABP Studio](https://abp.io/studio) provides a way for the users who already started the development before purchasing a license to auto-upgrade their solutions with Pro modules. You can use this functionality through ABP Studio UI or ABP Studio CLI:
 
 * A new button labeled `Upgrade to Pro` will be visible if you have a license but the current solution is created with open-source (free) license.
 

docs/en/solution-templates/microservice/adding-new-microservices.md

@@ -34,6 +34,11 @@ Select the database provider and click the `Create` button.
 
 ![create-new-module-db-provider](images/create-new-module-db-provider.png)
 
+When you create a new microservice, you can choose to enable integration with the current solution. If you check *Enable integration*, the new microservice is added to the solution, and the necessary configurations are made automatically, so no manual configuration is needed. If you uncheck the *Enable integration* option, you will need to manually configure the new microservice. You can follow the steps in this documentation, starting from the [Configuring the appsettings.json](#configuring-the-appsettingsjson) section.
+
+
+![create-new-microservice-nolayers-enable-integration](images/create-new-microservice-nolayers-enable-integration.png)
+
 The new microservice is created and added to the solution. You can see the new microservice in the `services` folder.
 
 ![product-microservice](images/product-microservice.png)

docs/en/solution-templates/microservice/how-to-use-with-abp-suite.md

@@ -0,0 +1,19 @@
+# Microservice Solution: How to use with ABP Suite
+
+ABP Suite provides a visual solution designer, code generators, and other tools to make your development process easier and faster.
+
+You can open ABP Suite from ABP Studio by using the **ABP Suite** -> **Open** toolbar menu item, or by right-clicking on the desired module and selecting the **ABP Suite** menu item.
+
+![abp-suite-context-menu](images/abp-suite-context-menu.png)
+
+It opens the ABP Suite in a built-in browser window. You can also access the suite by visiting `http://localhost:3000` through your browser. From there, you can visually design your solution and generate code. In this example, we create a **Product** entity.
+
+![abp-suite-product-entity](images/abp-suite-product-entity.png)
+
+After clicking **Save and generate** for the entity in ABP Suite, use **Run** -> **Build & Restart** in the [Solution Runner](../../studio/running-applications.md#start) to apply the changes.
+
+To confirm, visit the Swagger UI to verify that the necessary API endpoints and services have been created.
+
+![abp-suite-product-services](images/abp-suite-product-services.png)
+
+> Currently, you can't generate UI code with ABP Suite for microservice solutions. This feature will be added in future releases.

docs/en/solution-templates/microservice/index.md

@@ -44,3 +44,4 @@ ABP Studio provides pre-architected and production-ready templates to jump start
   * [Adding new API gateways](adding-new-api-gateways.md)
   * [Mono-repo vs multiple repository approaches](mono-repo-vs-multiple-repository-approaches.md)
   * [Authoring unit and integration tests](authoring-unit-and-integration-tests.md)
+  * [How to use with ABP Suite](how-to-use-with-abp-suite.md)

docs/en/studio/kubernetes.md

@@ -25,6 +25,11 @@ The *Kubernetes* panel is available only in the [business and enterprise](https:
 * [Docker Desktop](https://www.docker.com/products/docker-desktop) (Enable Kubernetes option if not working with a real cluster)
 * [NGINX Ingress Controller](https://kubernetes.github.io/ingress-nginx/deploy)
 * [mkcert](https://www.ibm.com/docs/en/fsmmn?topic=commands-mkcert)
+  * When you are installing the `mkcert` to allow ABP Studio to generate certificates for you, please ensure that `mkcert` is installed on the **Trusted Certificate Store** by running the following command (on **Windows**, this command must be executed with *Administrator* priviliges):
+
+    ```bash
+    mkcert -install
+    ```
 
 ## Profile
 
@@ -145,9 +150,9 @@ Upon disconnection from the cluster, we clean up the hosts file, excluding ingre
 
 ![disconnect](./images/kubernetes/disconnect.png)
 
-> When you list the services in the Kubernetes cluster with the `kubectl get svc` command, you should see the *abp-wg-easy* and *abp-wg-easy-vpn* services. After a while, if the *EXTERNAL-IP* is still *pending*, then it can't connect to the cluster. This could be caused by if you try to install the WireGuard VPN to a Docker Desktop Kubernetes cluster more than once. You can delete the previous WireGuard VPN by running the `helm uninstall abp-wg-easy` command in the previous namespace.
+> When you list the services in the Kubernetes cluster with the `kubectl get svc` command, you should see the *abp-wg-easy* and *abp-wg-easy-vpn* services. Each WireGuard installation has a unique port number for the related services. If you have multiple WireGuard installations for different Kubernetes profiles or solutions, you can see the port numbers in the *PORT(S)* field when you list them with the `kubectl get svc` command.
 
-> Connecting to the Kubernetes cluster is limited to one instance of ABP Studio at a time. Trying to connect with another instance simultaneously won't work as expected.
+> Connecting to the Kubernetes cluster is limited to one instance of ABP Studio at the same time. Trying to connect with another instance simultaneously won't work as expected.
 
 ### Intercept a Service
 

docs/en/studio/release-notes.md

@@ -2,6 +2,20 @@
 
 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. 
 
+## 0.8.3 (2024-09-24)
+
+* Allowed to set Execution Order (or dependency) from Solution Runner
+* Added Icons for the Solution Runner's Context Menu
+* Fixed MongoDB database issues for the Microservice Template
+* Allowed parallel running for background tasks
+
+## 0.8.2 (2024-09-19)
+
+* Fixed WireGuard connection random port bug
+* Automated steps after microservice solution creation
+* Fixed unusable options/features for Trial License
+* Fixed blazor-server single-layer template
+
 ## 0.8.1 (2024-09-12)
 
 * Fixed MySQL connection problem for nolayers template

docs/en/studio/solution-explorer.md

@@ -47,6 +47,8 @@ It is the main solution that you can open with ABP Studio, an ABP solution can c
 - `Open With`
   - `Terminal`: Opens the terminal in the solution directory.
   - `Explorer`: Opens the file explorer in the solution directory.
+- `Solution Configuration`: You can see the project creation options in this menu. It opens the *Solution Configuration* window.
+- `Open Readme`: Opens the README file in the solution if available. If there is no README file, this option will not be visible.
 
 ## Folder
 
@@ -143,6 +145,10 @@ You can choose the database provider for your microservice module. Select one of
 
 ![create-new-microservice-nolayers-database-provider](./images/solution-explorer/create-new-microservice-nolayers-database-provider.png)
 
+When you create a microservice, you must edit some [configurations](../solution-templates/microservice/adding-new-microservices.md#configuring-the-appsettingsjson). If you select the *Enable integration* option, it automatically configures the required settings for the microservice to work with the gateway, web, and other modules.
+
+![create-new-microservice-nolayers-enable-integration](./images/solution-explorer/create-new-microservice-nolayers-enable-integration.png)
+
 After creating the *Microservice (service-nolayers)* module, it will be added to the solution, and you should see the following structure in the solution explorer.
 
 ![created-new-microservice-nolayers](./images/solution-explorer/created-new-microservice-nolayers.png)
@@ -157,7 +163,7 @@ ABP modules have their own file extension `.abpmdl`, and they are located in the
 
 ### Difference Between ABP Module Template and ABP Studio Module Approach
 
-In ABP, creating a module solution using the [CLI](../cli/index.md) results in a solution with numerous projects, some of which may not be necessary for a specific use case. The ABP Studio module approach differs from the ABP module template, offering greater flexibility. With ABP Studio, we can create a module containing only the required projects; for example, an empty module with only the `Domain` and `Application` projects. In this approach, the term [Package](./concepts.md#package) is used for module projects.
+In ABP, creating a module solution using the [old CLI](../cli/differences-between-old-and-new-cli.md) results in a solution with numerous projects, some of which may not be necessary for a specific use case. The ABP Studio new module approach differs from the ABP old module template, offering greater flexibility. With ABP Studio, we can create a module containing only the required projects; for example, an empty module with only the `Domain` and `Application` projects. In this approach, the term [Package](./concepts.md#package) is used for module projects.
 
 Furthermore, it's important to mention that we can create not just DDD-principled modules. The [Modularity](../framework/architecture/modularity/basics.md) document clarifies the difference between *Framework* and *Application* modules. Basically, every C# project refers to the `Volo.Abp.Core` package and defines the *Module* class as an ABP Class Library. We have the option to develop an infrastructure module using only the *ABP Class Library* packages and provide a module reference to other modules.
 

docs/en/studio/version-compatibility.md

@@ -4,7 +4,7 @@ This document provides an overview of the compatibility between various versions
 
 | **ABP Studio Version** | **ABP Version**           |
 |------------------------|---------------------------|
-| 0.8.1                  | 8.3.0                     |
+| 0.8.1 to 0.8.3         | 8.3.0                     |
 | 0.8.0                  | 8.2.3                     |
 | 0.7.8 - 0.7.9          | 8.2.2                     |
 | 0.7.4 to 0.7.7         | 8.2.1                     |

docs/en/tutorials/index.md

@@ -1,6 +1,7 @@
-## ABP Tutorials
+# ABP Tutorials
 
-The following guides explains how to build ABP based applications:
+The following introductory tutorials explain how to build applications based on the ABP platform:
 
 * [TODO Application](todo/index.md): This is a single-part, quick-start tutorial to build a simple application with ABP. Start with this tutorial if you want to quickly understand how ABP works.
-* [Book Store Application](book-store/overview.md): This is a multi-part, complete tutorial to build a bookstore application with ABP. Start with this tutorial if you want to create a layered solution with ABP and apply DDD best practices.
+* [Book Store Application](book-store/index.md): This is a multi-part, complete tutorial to build a bookstore application with ABP. Start with this tutorial if you want to create a layered solution with ABP and apply DDD best practices.
+* [Modular Monolith Application](modular-crm/index.md): This is a multi-part tutorial that demonstrates how to create application modules, compose and communicate them to build a monolith modular web application.