Add installation notes for modules

modules/account/src/Volo.Abp.Account.Installer/InstallationNotes.md

@@ -0,0 +1,64 @@
+# Installation Notes for Account Module
+
+Account module implements the basic authentication features like login, register, forgot password and account management.
+
+This module is based on [Microsoft's Identity library](https://docs.microsoft.com/en-us/aspnet/core/security/authentication/identity?view=aspnetcore-6.0&tabs=visual-studio) and the [Identity Module](https://docs.abp.io/en/abp/latest/modules/identity). It has [IdentityServer](https://docs.abp.io/en/abp/latest/modules/identity-server) integration (based on the [IdentityServer Module](https://docs.abp.io/en/abp/latest/modules/identity-server)) and [OpenIddict](https://github.com/openiddict) integration (based on the [Openiddict Module](https://docs.abp.io/en/abp/latest/modules/openiddict)) to provide single sign-on, access control and other advanced authentication features.
+
+## Required Dependencies
+
+The Account module depends on the following modules:
+- Identity Module
+- Either OpenIddict Module or IdentityServer Module (for single sign-on capabilities)
+
+## Installation Steps
+
+The Account module is pre-installed in the ABP startup templates. If you need to manually install it, follow these steps:
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.Account.Application`
+   - `Volo.Abp.Account.HttpApi`
+   - `Volo.Abp.Account.Web` (for MVC UI)
+   - `Volo.Abp.Account.Blazor` (for MVC UI)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpAccountApplicationModule),
+    typeof(AbpAccountHttpApiModule),
+    typeof(AbpAccountEntityFrameworkCoreModule),
+    typeof(AbpAccountWebModule) // For MVC UI
+    typeof(AbpAccountBlazorModule ) // For BLAZOR UI
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+3. For OpenIddict integration, add the `Volo.Abp.Account.Web.OpenIddict` package and its module dependency:
+
+```csharp
+[DependsOn(
+    // Other dependencies
+    typeof(AbpAccountWebOpenIddictModule)
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+4. For IdentityServer integration, add the `Volo.Abp.Account.Web.IdentityServer` package and its module dependency:
+
+```csharp
+[DependsOn(
+    // Other dependencies
+    typeof(AbpAccountWebIdentityServerModule)
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Account Module documentation](https://abp.io/docs/latest/Modules/Account). 

modules/audit-logging/src/Volo.Abp.AuditLogging.Installer/InstallationNotes.md

@@ -0,0 +1,66 @@
+# Installation Notes for Audit Logging Module
+
+The ABP Audit Logging module provides automatic audit logging for web requests, service methods, and entity changes. It helps you track user activities and changes in your application.
+
+This module is part of the ABP Framework and provides comprehensive audit logging capabilities including entity history tracking, exception logging, and user activity monitoring.
+
+## Installation Steps
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.AuditLogging.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.AuditLogging.MongoDB` (for MongoDB)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpAuditLoggingEntityFrameworkCoreModule) // For EF Core
+    typeof(AbpAuditLoggingMongoDbModule) // For MongoDB
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, further configuration is needed in the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.AuditLogging.EntityFrameworkCore;
+
+//...
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureAuditLogging();
+    
+    //...
+}
+```
+
+Also, you will need to create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_AuditLogging
+dotnet ef database update
+```
+
+Configure the audit logging middleware in your `OnApplicationInitialization` method:
+
+```csharp
+public override void OnApplicationInitialization(ApplicationInitializationContext context)
+{
+    var app = context.GetApplicationBuilder();
+    
+    app.UseAuditing(); // Enable audit logging middleware
+    
+    //...
+}
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Audit Logging documentation](https://abp.io/docs/latest/framework/infrastructure/audit-logging).

modules/background-jobs/src/Volo.Abp.BackgroundJobs.Installer/InstallationNotes.md

@@ -0,0 +1,56 @@
+# Installation Notes for Background Jobs Module
+
+Background jobs are used to queue some tasks to be executed in the background. You may need background jobs for several reasons. Here are some examples:
+
+- To perform **long-running tasks** without having the users wait. For example, a user presses a 'report' button to start a long-running reporting job. You add this job to the **queue** and send the report's result to your user via email when it's completed.
+- To create **re-trying** and **persistent tasks** to **guarantee** that a code will be **successfully executed**. For example, you can send emails in a background job to overcome **temporary failures** and **guarantee** that it eventually will be sent. That way users do not wait while sending emails.
+
+Background jobs are **persistent** that means they will be **re-tried** and **executed** later even if your application crashes.
+
+## Installation Steps
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.BackgroundJobs.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.BackgroundJobs.MongoDB` (for MongoDB)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpBackgroundJobsDomainModule),
+    typeof(AbpBackgroundJobsDomainSharedModule),
+    typeof(AbpBackgroundJobsEntityFrameworkCoreModule) // For EF Core
+    // OR typeof(AbpBackgroundJobsMongoDbModule) // For MongoDB
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, further configuration is needed in the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.BackgroundJobs.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureBackgroundJobs();
+    
+    //...
+}
+```
+
+Also, you will need to create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_BackgroundJobs
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Background Jobs documentation](https://abp.io/docs/latest/framework/infrastructure/background-jobs). 

modules/basic-theme/src/Volo.Abp.AspNetCore.Mvc.UI.Theme.Basic.Installer/InstallationNotes.md

@@ -0,0 +1,31 @@
+# Installation Notes for Basic Theme Module (MVC)
+
+The Basic Theme is a theme implementation for the ASP.NET Core MVC / Razor Pages UI. It is a minimalist theme that doesn't add any styling on top of the plain [Bootstrap](https://getbootstrap.com/). You can take the Basic Theme as the base theme and build your own theme or styling on top of it. See the Customization section.
+
+The Basic Theme has RTL (Right-to-Left language) support.
+
+If you are looking for a professional, enterprise ready theme, you can check the [Lepton Theme](https://abp.io/themes), which is a part of the ABP.
+
+See the [Theming document](https://github.com/abpframework/abp/blob/rel-9.1/docs/en/framework/ui/mvc-razor-pages/theming.md) to learn about themes.
+
+## Installation Steps
+
+The Basic Theme module is pre-installed in the ABP MVC startup templates. If you need to manually install it, follow these steps:
+
+1. Add the following NuGet package to your project:
+   - `Volo.Abp.AspNetCore.Mvc.UI.Theme.Basic`
+
+2. Add the following module dependency to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpAspNetCoreMvcUiThemeBasicModule)
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Basic Theme documentation](https://abp.io/docs/latest/framework/ui/mvc-razor-pages/basic-theme).

modules/basic-theme/src/Volo.Abp.BasicTheme.Installer/InstallationNotes.md

@@ -0,0 +1,41 @@
+# Installation Notes for Basic Theme Module (Blazor)
+
+The Basic Theme is a theme implementation for the Blazor UI. It is a minimalist theme that doesn't add any styling on top of the plain [Bootstrap](https://getbootstrap.com/). You can take the Basic Theme as the base theme and build your own theme or styling on top of it. See the Customization section.
+
+## Installation Steps
+
+The Basic Theme module is pre-installed in the ABP Blazor startup templates. If you need to manually install it, follow these steps:
+
+1. Add the following NuGet packages to your project based on your Blazor hosting model:
+
+   **For Blazor Server:**
+   - `Volo.Abp.AspNetCore.Components.Server.BasicTheme`
+
+   **For Blazor WebAssembly:**
+   - `Volo.Abp.AspNetCore.Components.WebAssembly.BasicTheme`
+
+2. Add the following module dependencies to your module class:
+
+   **For Blazor Server:**
+   ```csharp
+   [DependsOn(
+       typeof(AbpAspNetCoreComponentsServerBasicThemeModule),
+   )]
+   public class YourModule : AbpModule
+   {
+   }
+   ```
+
+   **For Blazor WebAssembly:**
+   ```csharp
+   [DependsOn(
+       typeof(AbpAspNetCoreComponentsWebAssemblyBasicThemeModule),
+   )]
+   public class YourModule : AbpModule
+   {
+   }
+   ```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Blazor UI Basic Theme documentation](https://abp.io/docs/latest/framework/ui/blazor/basic-theme?UI=BlazorServer). 

modules/blob-storing-database/src/Volo.Abp.BlobStoring.Database.Installer/InstallationNotes.md

@@ -0,0 +1,64 @@
+# Installation Notes for Blob Storing Database Module
+
+It is typical to store file contents in an application and read these file contents on need. Not only files, but you may also need to save various types of large binary objects, a.k.a. [BLOBs](https://en.wikipedia.org/wiki/Binary_large_object), into a storage. For example, you may want to save user profile pictures.
+
+A BLOB is a typically byte array. There are various places to store a BLOB item; storing in the local file system, in a shared database or on the [Azure BLOB storage](https://azure.microsoft.com/en-us/products/storage/blobs/) can be options.
+
+The ABP provides an abstraction to work with BLOBs and provides some pre-built storage providers that you can easily integrate to. Having such an abstraction has some benefits;
+
+You can easily integrate to your favorite BLOB storage provides with a few lines of configuration.
+You can then easily change your BLOB storage without changing your application code.
+If you want to create reusable application modules, you don't need to make assumption about how the BLOBs are stored.
+ABP BLOB Storage system is also compatible to other ABP features like multi-tenancy.
+
+## Required Dependencies
+
+The Blob Storing Database module depends on the following ABP modules:
+- ABP BlobStoring module
+
+## Installation Steps
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.BlobStoring.Database.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.BlobStoring.Database.MongoDB` (for MongoDB)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpBlobStoringDatabaseEntityFrameworkCoreModule) // Or AbpBlobStoringDatabaseMongoDBModule
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## Database Integration
+
+### EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, add the following configuration to the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.BlobStoring.Database.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureBlobStoring();
+    
+    // ... other configurations
+}
+```
+
+Then create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_BlobStoring
+dotnet ef database update
+```
+
+## 6. **Documentation**
+
+For detailed information and usage instructions, please visit the [BLOB Storing documentation](https://abp.io/docs/latest/framework/infrastructure/blob-storing). 

modules/blogging/src/Volo.Blogging.Installer/InstallationNotes.md

@@ -0,0 +1,77 @@
+# Installation Notes for Blogging Module
+
+The ABP Blogging module provides a simple blogging system for ABP applications. It allows you to create and manage blogs, posts, tags, and comments. The module includes both a public interface for readers and an admin interface for content management.
+
+Key features of the Blogging module:
+- Multiple blog support
+- Post management with rich text editing
+- Commenting functionality
+- Social media sharing
+- Admin interface for content management
+
+## Required Dependencies
+
+The Blogging module depends on the following ABP modules:
+- ABP Blob Storing module (for media management)
+
+## Installation Steps
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Blogging.Application`
+   - `Volo.Blogging.HttpApi`
+   - `Volo.Blogging.EntityFrameworkCore` (for EF Core)
+   - `Volo.Blogging.MongoDB` (for MongoDB)
+   - `Volo.Blogging.Web` (for MVC UI)
+
+     // Admin UI
+   - `Volo.Blogging.Admin.Application`
+   - `Volo.Blogging.Admin.HttpApi`
+   - `Volo.Blogging.Admin.Web` (for MVC UI)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    // Other dependencies
+    typeof(BloggingApplicationModule),
+    typeof(BloggingHttpApiModule),
+    typeof(BloggingEntityFrameworkCoreModule), // For EF Core
+    typeof(BloggingMongoDbModule) // For MongoDB
+    typeof(BloggingWebModule) // For MVC UI
+    // Admin UI
+    typeof(BloggingAdminApplicationModule),
+    typeof(BloggingAdminHttpApiModule),
+    typeof(BloggingAdminWebModule) // For MVC UI
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+### EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, add the following configuration to the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Blogging.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureBlogging();
+    
+    // ... other configurations
+}
+```
+
+Then create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_Blogging
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Blogging Module documentation](https://abp.io/docs/latest/Modules/Cms-Kit/Blogging). 

modules/cms-kit/src/Volo.CmsKit.Installer/InstallationNotes.md

@@ -0,0 +1,94 @@
+# Installation Notes for CMS Kit Module
+
+The ABP CMS Kit module provides a set of reusable Content Management System (CMS) features for your ABP-based applications. It offers ready-to-use UI components and APIs for common content management requirements.
+
+This module is part of the ABP Framework and provides features like comments, ratings, tags, blogs, and more to help you build content-rich applications.
+
+## Required Dependencies
+
+The CMS Kit module depends on the following modules:
+- Blob Storing module (for media management)
+
+## Installation Steps
+
+You can manually add the required NuGet packages:
+
+1. Add the following NuGet packages to your project:
+   - `Volo.CmsKit.Public.Application` (for public features)
+   - `Volo.CmsKit.Public.HttpApi` (for public API)
+   - `Volo.CmsKit.Public.Web` (for public UI)
+   - `Volo.CmsKit.EntityFrameworkCore` (for EF Core)
+   - `Volo.CmsKit.MongoDB` (for MongoDB)
+   // admin
+   - `Volo.CmsKit.Admin.Application` (for admin features)
+   - `Volo.CmsKit.Admin.HttpApi` (for admin API)
+   - `Volo.CmsKit.Admin.Web` (for admin UI)
+
+
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(CmsKitAdminApplicationModule), // For admin features
+    typeof(CmsKitPublicApplicationModule), // For public features
+    typeof(CmsKitAdminHttpApiModule), // For admin API
+    typeof(CmsKitPublicHttpApiModule), // For public API
+    typeof(CmsKitAdminWebModule), // For admin UI
+    typeof(CmsKitPublicWebModule), // For public UI
+    typeof(CmsKitEntityFrameworkCoreModule) // For EF Core
+    // OR typeof(CmsKitMongoDbModule) // For MongoDB
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+### EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, further configuration is needed in the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.CmsKit.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureCmsKit();
+    
+    //...
+}
+```
+
+Also, you will need to create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_CmsKit
+dotnet ef database update
+```
+
+## Feature Management
+
+By default, all CMS Kit features are disabled. You need to enable the features you want to use in your application. Open the `GlobalFeatureConfigurator` class in the `Domain.Shared` project and add the following code to the `Configure` method:
+
+```csharp
+GlobalFeatureManager.Instance.Modules.CmsKit(cmsKit =>
+{
+    // Enable all features
+    cmsKit.EnableAll();
+    
+    // Or enable specific features
+    // cmsKit.Comments.Enable();
+    // cmsKit.Tags.Enable();
+    // cmsKit.Ratings.Enable();
+    // cmsKit.Reactions.Enable();
+    // cmsKit.Blogs.Enable();
+    // cmsKit.Pages.Enable();
+    // cmsKit.MediaDescriptors.Enable();
+});
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [CMS Kit documentation](https://abp.io/docs/latest/modules/cms-kit). 

modules/docs/src/Volo.Docs.Installer/InstallationNotes.md

@@ -0,0 +1,71 @@
+# Installation Notes for Docs Module
+
+The ABP Docs module provides a complete documentation system for ABP applications. It allows you to create, manage, and publish documentation from various sources like GitHub, GitLab, or local file system. The module includes both a public interface for readers and an admin interface for documentation management.
+
+Key features of the Docs module:
+- Multiple documentation projects support
+- Version control integration
+- Markdown support
+- Navigation generation
+- Full-text search
+- Multi-language support
+- Admin interface for documentation management
+
+## Installation Steps
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Docs.Application`
+   - `Volo.Docs.HttpApi`
+   - `Volo.Docs.Web` (for MVC UI)
+   - `Volo.Docs.EntityFrameworkCore` (for EF Core)
+   - `Volo.Docs.MongoDB` (for MongoDB)
+
+   For the admin UI:
+   - `Volo.Docs.Admin.Application`
+   - `Volo.Docs.Admin.HttpApi`
+   - `Volo.Docs.Admin.Web`
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(DocsApplicationModule),
+    typeof(DocsHttpApiModule),
+    typeof(DocsWebModule), // For MVC UI
+    typeof(DocsEntityFrameworkCoreModule), // Or DocsMongoDbModule
+    typeof(DocsAdminApplicationModule),
+    typeof(DocsAdminHttpApiModule),
+    typeof(DocsAdminWebModule)
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, add the following configuration to the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Docs.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureDocs();
+    
+    // ... other configurations
+}
+```
+
+Then create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_Docs
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Docs Module documentation](https://abp.io/docs/latest/Modules/Docs). 

modules/feature-management/src/Volo.Abp.FeatureManagement.Installer/InstallationNotes.md

@@ -0,0 +1,64 @@
+# Installation Notes for Feature Management Module
+
+The Feature Management module provides a way to define and manage features in an ABP application. Features are used to enable or disable specific functionalities of an application based on different conditions, such as tenant subscription levels or user preferences.
+
+Key capabilities of the Feature Management module:
+- Define features with different value types (boolean, numeric, etc.)
+- Group features by providers (tenant, edition, etc.)
+- Manage feature values through a user interface
+- Check feature status in your application code
+
+## NuGet Packages
+
+The following NuGet packages are required for the Feature Management module:
+- `Volo.Abp.FeatureManagement.Application`
+- `Volo.Abp.FeatureManagement.HttpApi`
+- `Volo.Abp.FeatureManagement.EntityFrameworkCore` (for EF Core)
+- `Volo.Abp.FeatureManagement.MongoDB` (for MongoDB)
+- `Volo.Abp.FeatureManagement.Web` (for MVC UI)
+- `Volo.Abp.FeatureManagement.Blazor.Server` (for Blazor Server UI)
+- `Volo.Abp.FeatureManagement.Blazor.WebAssembly` (for Blazor WebAssembly UI)
+
+## Module Dependencies
+
+```csharp
+[DependsOn(
+    typeof(AbpFeatureManagementApplicationModule),
+    typeof(AbpFeatureManagementHttpApiModule),
+    typeof(AbpFeatureManagementEntityFrameworkCoreModule), // Or AbpFeatureManagementMongoDbModule
+    typeof(AbpFeatureManagementWebModule), // For MVC UI
+    // typeof(AbpFeatureManagementBlazorWebAssemblyModule), // For Blazor WebAssembly UI
+    // typeof(AbpFeatureManagementBlazorServerModule) // For Blazor Server UI
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, add the following configuration to the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.FeatureManagement.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureFeatureManagement();
+    
+    // ... other configurations
+}
+```
+
+Then create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_FeatureManagement
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Feature Management Module documentation](https://abp.io/docs/latest/Modules/Feature-Management). 

modules/identity/src/Volo.Abp.Identity.Installer/InstallationNotes.md

@@ -0,0 +1,67 @@
+# Installation Notes for Identity Module
+
+The ABP Identity module provides user and role management functionality for your ABP-based applications. It is built on Microsoft's Identity library and extends it with additional features like organization units and claims management.
+
+This module is part of the ABP Framework and provides the core identity management capabilities needed by most business applications.
+
+## Installation Steps
+
+The Identity module is pre-installed in the ABP startup templates. If you need to manually install it, follow these steps:
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.Identity.Application`
+   - `Volo.Abp.Identity.HttpApi`
+   - `Volo.Abp.Identity.Web` (for MVC UI)
+   - `Volo.Abp.Identity.Blazor.Server` (for Blazor Server UI)
+   - `Volo.Abp.Identity.Blazor.WebAssembly` (for Blazor Web Assembly UI)
+   - `Volo.Abp.Identity.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.Identity.MongoDB` (for MongoDB)
+   - `Volo.Abp.PermissionManagement.Domain.Identity` (for permission management)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpIdentityApplicationModule),
+    typeof(AbpIdentityHttpApiModule),
+    typeof(AbpIdentityWebModule), // For MVC UI
+    typeof(AbpIdentityBlazorServerModule), // For Blazor Server UI
+    typeof(AbpIdentityBlazorWebAssemblyModule), // For Blazor Web Assembly UI
+    typeof(AbpIdentityEntityFrameworkCoreModule) // For EF Core
+    typeof(AbpPermissionManagementDomainIdentityModule) // For permission management
+    // OR typeof(AbpIdentityMongoDbModule) // For MongoDB
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, further configuration is needed in the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.Identity.EntityFrameworkCore;
+
+//...
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureIdentity();
+    
+    //...
+}
+```
+
+Also, you will need to create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_Identity
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Identity module documentation](https://abp.io/docs/latest/modules/identity). 

modules/openiddict/src/Volo.Abp.OpenIddict.Installer/InstallationNotes.md

@@ -0,0 +1,111 @@
+# Installation Notes for OpenIddict Module
+
+The OpenIddict module is an authentication module for the ABP Framework that provides OAuth 2.0 and OpenID Connect server capabilities. It is built on the OpenIddict library and provides a complete solution for implementing authentication and authorization in your ABP applications.
+
+Key features of the OpenIddict module:
+- OAuth 2.0 and OpenID Connect server implementation
+- Token generation and validation
+- Authorization code, implicit, client credentials, and resource owner password flows
+- JWT and reference token support
+- Client application management
+- Scope management
+- Integration with ABP's permission system
+
+## Required Dependencies
+
+The OpenIddict module depends on the following ABP modules:
+- ABP Identity module (for user management)
+
+## Installation Steps
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.OpenIddict.Domain`
+   - `Volo.Abp.OpenIddict.Domain.Shared`
+   - `Volo.Abp.OpenIddict.AspNetCore`
+   - `Volo.Abp.OpenIddict.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.OpenIddict.MongoDB` (for MongoDB)
+   - `Volo.Abp.PermissionManagement.Domain.Identity` (for permission management)
+   - `Volo.Abp.PermissionManagement.Domain.OpenIddict` (for permission management)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpAccountWebOpenIddictModule),
+    typeof(AbpOpenIddictEntityFrameworkCoreModule), // Or AbpOpenIddictMongoDbModule
+    typeof(AbpPermissionManagementDomainIdentityModule), // For permission management
+    typeof(AbpPermissionManagementDomainOpenIddictModule) // For permission management
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+### Database Integration
+
+#### EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, add the following configuration to the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.OpenIddict.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureIdentity();
+    builder.ConfigureOpenIddict();
+    
+    // ... other configurations
+}
+```
+
+Then create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_OpenIddict
+dotnet ef database update
+```
+
+## Configuration
+
+Configure the OpenIddict module in your module's `ConfigureServices` method:
+
+```csharp
+public override void PreConfigureServices(ServiceConfigurationContext context)
+{
+        PreConfigure<OpenIddictBuilder>(builder =>
+        {
+            builder.AddValidation(options =>
+            {
+                options.AddAudiences("AbpSolution134");
+                options.UseLocalServer();
+                options.UseAspNetCore();
+            });
+        });
+
+        if (!hostingEnvironment.IsDevelopment())
+        {
+            PreConfigure<AbpOpenIddictAspNetCoreOptions>(options =>
+            {
+                options.AddDevelopmentEncryptionAndSigningCertificate = false;
+            });
+
+            PreConfigure<OpenIddictServerBuilder>(serverBuilder =>
+            {
+                serverBuilder.AddProductionEncryptionAndSigningCertificate("openiddict.pfx", configuration["AuthServer:CertificatePassPhrase"]!);
+            });
+        }
+
+        context.Services.ForwardIdentityAuthenticationForBearer(OpenIddictValidationAspNetCoreDefaults.AuthenticationScheme);
+        context.Services.Configure<AbpClaimsPrincipalFactoryOptions>(options =>
+        {
+            options.IsDynamicClaimsEnabled = true;
+        });
+}
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [OpenIddict Module documentation](https://abp.io/docs/latest/Modules/OpenIddict). 

modules/permission-management/src/Volo.Abp.PermissionManagement.Installer/InstallationNotes.md

@@ -0,0 +1,63 @@
+# Installation Notes for Permission Management Module
+
+The ABP Permission Management module provides infrastructure to persist and manage permissions in your ABP-based applications. It allows you to grant permissions to users, roles, or other entities.
+
+This module is part of the ABP Framework and provides the core permission management functionality needed by most business applications.
+
+## Installation Steps
+
+The Permission Management module is pre-installed in the ABP startup templates. If you need to manually install it, follow these steps:
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.PermissionManagement.Application`
+   - `Volo.Abp.PermissionManagement.HttpApi`
+   - `Volo.Abp.PermissionManagement.Web` (for MVC UI)
+   - `Volo.Abp.PermissionManagement.Blazor.Server` (for Blazor Server UI)
+   - `Volo.Abp.PermissionManagement.Blazor.WebAssembly` (for Blazor Web Assembly UI)
+   - `Volo.Abp.PermissionManagement.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.PermissionManagement.MongoDB` (for MongoDB)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpPermissionManagementApplicationModule),
+    typeof(AbpPermissionManagementHttpApiModule),
+    typeof(AbpPermissionManagementWebModule), // For MVC UI
+    typeof(AbpPermissionManagementBlazorServerModule), // For Blazor Server UI
+    typeof(AbpPermissionManagementBlazorWebAssemblyModule), // For Blazor Web Assembly UI
+    typeof(AbpPermissionManagementEntityFrameworkCoreModule) // For EF Core
+    typeof(AbpPermissionManagementMongoDbModule) // For MongoDB
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+### EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, further configuration is needed in the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigurePermissionManagement();
+    
+    //...
+}
+```
+
+Also, you will need to create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_PermissionManagement
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Permission Management module documentation](https://abp.io/docs/latest/modules/permission-management). 

modules/setting-management/src/Volo.Abp.SettingManagement.Installer/InstallationNotes.md

@@ -0,0 +1,67 @@
+# Installation Notes for Setting Management Module
+
+The Setting Management module provides a way to store and manage settings in an ABP application. Settings are used to store application, tenant, or user-specific configuration values that can be changed at runtime. The module includes both a UI for setting management and an API for programmatic setting management.
+
+Key features of the Setting Management module:
+- Store and retrieve settings
+- Multi-level setting management (global, tenant, user)
+- Setting management UI
+- Extensible setting provider system
+- Multi-tenancy support
+- Integration with other ABP modules
+
+## NuGet Packages
+
+The following NuGet packages are required for the Setting Management module:
+- `Volo.Abp.SettingManagement.Application`
+- `Volo.Abp.SettingManagement.HttpApi`
+- `Volo.Abp.SettingManagement.EntityFrameworkCore` (for EF Core)
+- `Volo.Abp.SettingManagement.MongoDB` (for MongoDB)
+- `Volo.Abp.SettingManagement.Web` (for MVC UI)
+- `Volo.Abp.SettingManagement.Blazor.Server` (for Blazor Server UI)
+- `Volo.Abp.SettingManagement.Blazor.WebAssembly` (for Blazor WebAssembly UI)
+
+## Module Dependencies
+
+```csharp
+[DependsOn(
+    typeof(AbpSettingManagementApplicationModule),
+    typeof(AbpSettingManagementHttpApiModule),
+    typeof(AbpSettingManagementEntityFrameworkCoreModule),
+    typeof(AbpSettingManagementMongoDbModule), // If using MongoDB
+    typeof(AbpSettingManagementWebModule), // For MVC UI
+    typeof(AbpSettingManagementBlazorServerModule), // For Blazor Server UI
+    typeof(AbpSettingManagementBlazorWebAssemblyModule) // For Blazor WebAssembly UI
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+## EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, add the following configuration to the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.SettingManagement.EntityFrameworkCore;
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureSettingManagement();
+    
+    // ... other configurations
+}
+```
+
+Then create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_SettingManagement
+dotnet ef database update
+```
+
+## 6. **Documentation**
+
+For detailed information and usage instructions, please visit the [Setting Management Module documentation](https://abp.io/docs/latest/Modules/Setting-Management). 

modules/tenant-management/src/Volo.Abp.TenantManagement.Installer/InstallationNotes.md

@@ -0,0 +1,65 @@
+# Installation Notes for Tenant Management Module
+
+The ABP Tenant Management module provides multi-tenancy features for your ABP-based applications. It implements the `ITenantStore` interface and provides UI to manage tenants and their features.
+
+This module is part of the ABP Framework and provides the core functionality needed to build multi-tenant (SaaS) applications.
+
+## Installation Steps
+
+The Tenant Management module is pre-installed in the ABP startup templates. If you need to manually install it, follow these steps:
+
+1. Add the following NuGet packages to your project:
+   - `Volo.Abp.TenantManagement.Application`
+   - `Volo.Abp.TenantManagement.HttpApi`
+   - `Volo.Abp.TenantManagement.EntityFrameworkCore` (for EF Core)
+   - `Volo.Abp.TenantManagement.MongoDB` (for MongoDB)
+   - `Volo.Abp.TenantManagement.Web` (for MVC UI)
+   - `Volo.Abp.TenantManagement.Blazor.Server` (for Blazor Server UI)
+   - `Volo.Abp.TenantManagement.Blazor.WebAssembly` (for Blazor Web Assembly UI)
+
+2. Add the following module dependencies to your module class:
+
+```csharp
+[DependsOn(
+    typeof(AbpTenantManagementApplicationModule),
+    typeof(AbpTenantManagementHttpApiModule),
+    typeof(AbpTenantManagementEntityFrameworkCoreModule) // For EF Core
+    typeof(AbpTenantManagementMongoDbModule) // For MongoDB
+    typeof(AbpTenantManagementWebModule), // For MVC UI
+    typeof(AbpTenantManagementBlazorServerModule), // For Blazor Server UI
+    typeof(AbpTenantManagementBlazorWebAssemblyModule) // For Blazor Web Assembly UI
+)]
+public class YourModule : AbpModule
+{
+}
+```
+
+### EntityFramework Core Configuration
+
+For `EntityFrameworkCore`, further configuration is needed in the `OnModelCreating` method of your `DbContext` class:
+
+```csharp
+using Volo.Abp.TenantManagement.EntityFrameworkCore;
+
+//...
+
+protected override void OnModelCreating(ModelBuilder builder)
+{
+    base.OnModelCreating(builder);
+
+    builder.ConfigureTenantManagement();
+    
+    //...
+}
+```
+
+Also, you will need to create a new migration and apply it to the database:
+
+```bash
+dotnet ef migrations add Added_TenantManagement
+dotnet ef database update
+```
+
+## Documentation
+
+For detailed information and usage instructions, please visit the [Tenant Management module documentation](https://abp.io/docs/latest/modules/tenant-management).