abp

1
using Microsoft.AspNetCore.Extensions.DependencyInjection;
2
using Microsoft.Extensions.DependencyInjection.Extensions;
3
using Microsoft.OpenApi.Models;
4
using MyCompanyName.MyProjectName.Data;
5
using MyCompanyName.MyProjectName.Localization;
6
using MyCompanyName.MyProjectName.Menus;
7
using OpenIddict.Validation.AspNetCore;
8
using Volo.Abp;
9
using Volo.Abp.Account;
10
using Volo.Abp.Account.Web;
11
using Volo.Abp.AspNetCore.Mvc;
12
using Volo.Abp.AspNetCore.Mvc.Localization;
13
using Volo.Abp.AspNetCore.Mvc.UI.Bundling;
14
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite;
15
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite.Bundling;
16
using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
17
using Volo.Abp.AspNetCore.Serilog;
18
using Volo.Abp.AuditLogging.MongoDB;
19
using Volo.Abp.Autofac;
20
using Volo.Abp.AutoMapper;
21
using Volo.Abp.MongoDB;
22
using Volo.Abp.Emailing;
23
using Volo.Abp.FeatureManagement;
24
using Volo.Abp.FeatureManagement.MongoDB;
25
using Volo.Abp.Identity;
26
using Volo.Abp.Identity.MongoDB;
27
using Volo.Abp.Identity.Web;
28
using Volo.Abp.Localization;
29
using Volo.Abp.Localization.ExceptionHandling;
30
using Volo.Abp.Modularity;
31
using Volo.Abp.MultiTenancy;
32
using Volo.Abp.OpenIddict.MongoDB;
33
using Volo.Abp.PermissionManagement;
34
using Volo.Abp.PermissionManagement.MongoDB;
35
using Volo.Abp.PermissionManagement.HttpApi;
36
using Volo.Abp.PermissionManagement.Identity;
37
using Volo.Abp.PermissionManagement.OpenIddict;
38
using Volo.Abp.SettingManagement;
39
using Volo.Abp.SettingManagement.MongoDB;
40
using Volo.Abp.SettingManagement.Web;
41
using Volo.Abp.Swashbuckle;
42
using Volo.Abp.TenantManagement;
43
using Volo.Abp.TenantManagement.MongoDB;
44
using Volo.Abp.TenantManagement.Web;
45
using Volo.Abp.OpenIddict;
46
using Volo.Abp.Security.Claims;
47
using Volo.Abp.UI.Navigation;
48
using Volo.Abp.UI.Navigation.Urls;
49
using Volo.Abp.Uow;
50
using Volo.Abp.Validation.Localization;
51
using Volo.Abp.VirtualFileSystem;
52

53
namespace MyCompanyName.MyProjectName;
54

55
[DependsOn(
56
    // ABP Framework packages
57
    typeof(AbpAspNetCoreMvcModule),
58
    typeof(AbpAutofacModule),
59
    typeof(AbpAutoMapperModule),
60
    typeof(AbpSwashbuckleModule),
61
    typeof(AbpAspNetCoreSerilogModule),
62
    typeof(AbpAspNetCoreMvcUiLeptonXLiteThemeModule),
63

64
    // Account module packages
65
    typeof(AbpAccountApplicationModule),
66
    typeof(AbpAccountHttpApiModule),
67
    typeof(AbpAccountWebOpenIddictModule),
68

69
    // Identity module packages
70
    typeof(AbpPermissionManagementDomainIdentityModule),
71
    typeof(AbpPermissionManagementDomainOpenIddictModule),
72
    typeof(AbpIdentityApplicationModule),
73
    typeof(AbpIdentityHttpApiModule),
74
    typeof(AbpIdentityMongoDbModule),
75
    typeof(AbpOpenIddictMongoDbModule),
76
    typeof(AbpIdentityWebModule),
77

78
    // Audit logging module packages
79
    typeof(AbpAuditLoggingMongoDbModule),
80

81
    // Permission Management module packages
82
    typeof(AbpPermissionManagementApplicationModule),
83
    typeof(AbpPermissionManagementHttpApiModule),
84
    typeof(AbpPermissionManagementMongoDbModule),
85

86
    // Tenant Management module packages
87
    typeof(AbpTenantManagementApplicationModule),
88
    typeof(AbpTenantManagementHttpApiModule),
89
    typeof(AbpTenantManagementMongoDbModule),
90
    typeof(AbpTenantManagementWebModule),
91

92
    // Feature Management module packages
93
    typeof(AbpFeatureManagementApplicationModule),
94
    typeof(AbpFeatureManagementMongoDbModule),
95
    typeof(AbpFeatureManagementHttpApiModule),
96
    typeof(AbpFeatureManagementWebModule),
97

98
    // Setting Management module packages
99
    typeof(AbpSettingManagementApplicationModule),
100
    typeof(AbpSettingManagementMongoDbModule),
101
    typeof(AbpSettingManagementHttpApiModule),
102
    typeof(AbpSettingManagementWebModule)
103
)]
104
public class MyProjectNameModule : AbpModule
105
{
106
    /* Single point to enable/disable multi-tenancy */
107
    public const bool IsMultiTenant = true;
108

109
    public override void PreConfigureServices(ServiceConfigurationContext context)
110
    {
111
        var hostingEnvironment = context.Services.GetHostingEnvironment();
112
        var configuration = context.Services.GetConfiguration();
113

114
        context.Services.PreConfigure<AbpMvcDataAnnotationsLocalizationOptions>(options =>
115
        {
116
            options.AddAssemblyResource(
117
                typeof(MyProjectNameResource)
118
            );
119
        });
120

121
        PreConfigure<OpenIddictBuilder>(builder =>
122
        {
123
            builder.AddValidation(options =>
124
            {
125
                options.AddAudiences("MyProjectName");
126
                options.UseLocalServer();
127
                options.UseAspNetCore();
128
            });
129
        });
130

131
        if (!hostingEnvironment.IsDevelopment())
132
        {
133
            PreConfigure<AbpOpenIddictAspNetCoreOptions>(options =>
134
            {
135
                options.AddDevelopmentEncryptionAndSigningCertificate = false;
136
            });
137

138
            PreConfigure<OpenIddictServerBuilder>(serverBuilder =>
139
            {
140
                serverBuilder.AddProductionEncryptionAndSigningCertificate("openiddict.pfx", "00000000-0000-0000-0000-000000000000");
141
            });
142
        }
143
        
144
        MyProjectNameGlobalFeatureConfigurator.Configure();
145
        MyProjectNameModuleExtensionConfigurator.Configure();
146
    }
147

148
    public override void ConfigureServices(ServiceConfigurationContext context)
149
    {
150
        var hostingEnvironment = context.Services.GetHostingEnvironment();
151
        var configuration = context.Services.GetConfiguration();
152

153
        if (hostingEnvironment.IsDevelopment())
154
        {
155
            context.Services.Replace(ServiceDescriptor.Singleton<IEmailSender, NullEmailSender>());
156
        }
157

158
        ConfigureAuthentication(context);
159
        ConfigureMultiTenancy();
160
        ConfigureUrls(configuration);
161
        ConfigureBundles();
162
        ConfigureAutoMapper(context);
163
        ConfigureSwagger(context.Services);
164
        ConfigureNavigationServices();
165
        ConfigureAutoApiControllers();
166
        ConfigureVirtualFiles(hostingEnvironment);
167
        ConfigureLocalization();
168
        ConfigureMongoDB(context);
169
    }
170

171
    private void ConfigureAuthentication(ServiceConfigurationContext context)
172
    {
173
        context.Services.ForwardIdentityAuthenticationForBearer(OpenIddictValidationAspNetCoreDefaults.AuthenticationScheme);
174
        context.Services.Configure<AbpClaimsPrincipalFactoryOptions>(options =>
175
        {
176
            options.IsDynamicClaimsEnabled = true;
177
        });
178
    }
179

180
    private void ConfigureMultiTenancy()
181
    {
182
        Configure<AbpMultiTenancyOptions>(options =>
183
        {
184
            options.IsEnabled = IsMultiTenant;
185
        });
186
    }
187

188
    private void ConfigureUrls(IConfiguration configuration)
189
    {
190
        Configure<AppUrlOptions>(options =>
191
        {
192
            options.Applications["MVC"].RootUrl = configuration["App:SelfUrl"];
193
        });
194
    }
195

196
    private void ConfigureBundles()
197
    {
198
        Configure<AbpBundlingOptions>(options =>
199
        {
200
            options.StyleBundles.Configure(
201
                LeptonXLiteThemeBundles.Styles.Global,
202
                bundle =>
203
                {
204
                    bundle.AddFiles("/global-styles.css");
205
                }
206
            );
207
        });
208
    }
209

210
    private void ConfigureLocalization()
211
    {
212
        Configure<AbpLocalizationOptions>(options =>
213
        {
214
            options.Resources
215
                .Add<MyProjectNameResource>("en")
216
                .AddBaseTypes(typeof(AbpValidationResource))
217
                .AddVirtualJson("/Localization/MyProjectName");
218

219
            options.DefaultResourceType = typeof(MyProjectNameResource);
220

221
            options.Languages.Add(new LanguageInfo("en", "en", "English"));
222
            options.Languages.Add(new LanguageInfo("tr", "tr", "Türkçe"));
223
            options.Languages.Add(new LanguageInfo("ar", "ar", "العربية"));
224
            options.Languages.Add(new LanguageInfo("cs", "cs", "Čeština"));
225
            options.Languages.Add(new LanguageInfo("en-GB", "en-GB", "English (UK)"));
226
            options.Languages.Add(new LanguageInfo("hu", "hu", "Magyar"));
227
            options.Languages.Add(new LanguageInfo("fi", "fi", "Finnish"));
228
            options.Languages.Add(new LanguageInfo("fr", "fr", "Français"));
229
            options.Languages.Add(new LanguageInfo("hi", "hi", "Hindi"));
230
            options.Languages.Add(new LanguageInfo("is", "is", "Icelandic"));
231
            options.Languages.Add(new LanguageInfo("it", "it", "Italiano"));
232
            options.Languages.Add(new LanguageInfo("pt-BR", "pt-BR", "Português"));
233
            options.Languages.Add(new LanguageInfo("ro-RO", "ro-RO", "Română"));
234
            options.Languages.Add(new LanguageInfo("ru", "ru", "Русский"));
235
            options.Languages.Add(new LanguageInfo("sk", "sk", "Slovak"));
236
            options.Languages.Add(new LanguageInfo("zh-Hans", "zh-Hans", "简体中文"));
237
            options.Languages.Add(new LanguageInfo("zh-Hant", "zh-Hant", "繁體中文"));
238
            options.Languages.Add(new LanguageInfo("de-DE", "de-DE", "Deutsch"));
239
            options.Languages.Add(new LanguageInfo("es", "es", "Español"));
240
            options.Languages.Add(new LanguageInfo("el", "el", "Ελληνικά"));
241
        });
242

243
        Configure<AbpExceptionLocalizationOptions>(options =>
244
        {
245
            options.MapCodeNamespace("MyProjectName", typeof(MyProjectNameResource));
246
        });
247
    }
248

249
    private void ConfigureVirtualFiles(IWebHostEnvironment hostingEnvironment)
250
    {
251
        Configure<AbpVirtualFileSystemOptions>(options =>
252
        {
253
            options.FileSets.AddEmbedded<MyProjectNameModule>();
254
            if (hostingEnvironment.IsDevelopment())
255
            {
256
                /* Using physical files in development, so we don't need to recompile on changes */
257
                options.FileSets.ReplaceEmbeddedByPhysical<MyProjectNameModule>(hostingEnvironment.ContentRootPath);
258
            }
259
        });
260
    }
261

262
    private void ConfigureNavigationServices()
263
    {
264
        Configure<AbpNavigationOptions>(options =>
265
        {
266
            options.MenuContributors.Add(new MyProjectNameMenuContributor());
267
        });
268
    }
269

270
    private void ConfigureAutoApiControllers()
271
    {
272
        Configure<AbpAspNetCoreMvcOptions>(options =>
273
        {
274
            options.ConventionalControllers.Create(typeof(MyProjectNameModule).Assembly);
275
        });
276
    }
277

278
    private void ConfigureSwagger(IServiceCollection services)
279
    {
280
        services.AddAbpSwaggerGen(
281
            options =>
282
            {
283
                options.SwaggerDoc("v1", new OpenApiInfo { Title = "MyProjectName API", Version = "v1" });
284
                options.DocInclusionPredicate((docName, description) => true);
285
                options.CustomSchemaIds(type => type.FullName);
286
            }
287
        );
288
    }
289

290
    private void ConfigureAutoMapper(ServiceConfigurationContext context)
291
    {
292
        context.Services.AddAutoMapperObjectMapper<MyProjectNameModule>();
293
        Configure<AbpAutoMapperOptions>(options =>
294
        {
295
            /* Uncomment `validate: true` if you want to enable the Configuration Validation feature.
296
             * See AutoMapper's documentation to learn what it is:
297
             * https://docs.automapper.org/en/stable/Configuration-validation.html
298
             */
299
            options.AddMaps<MyProjectNameModule>(/* validate: true */);
300
        });
301
    }
302

303
    private void ConfigureMongoDB(ServiceConfigurationContext context)
304
    {
305
        context.Services.AddMongoDbContext<MyProjectNameDbContext>(options =>
306
        {
307
            options.AddDefaultRepositories();
308
        });
309

310
        Configure<AbpUnitOfWorkDefaultOptions>(options =>
311
        {
312
            options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled;
313
        });
314
    }
315

316

317
    public override void OnApplicationInitialization(ApplicationInitializationContext context)
318
    {
319
        var app = context.GetApplicationBuilder();
320
        var env = context.GetEnvironment();
321

322
        if (env.IsDevelopment())
323
        {
324
            app.UseDeveloperExceptionPage();
325
        }
326

327
        app.UseAbpRequestLocalization();
328

329
        if (!env.IsDevelopment())
330
        {
331
            app.UseErrorPage();
332
        }
333

334
        app.UseCorrelationId();
335
        app.UseStaticFiles();
336
        app.UseRouting();
337
        app.UseAuthentication();
338
        app.UseAbpOpenIddictValidation();
339

340
        if (IsMultiTenant)
341
        {
342
            app.UseMultiTenancy();
343
        }
344

345
        app.UseUnitOfWork();
346
        app.UseDynamicClaims();
347
        app.UseAuthorization();
348

349
        app.UseSwagger();
350
        app.UseAbpSwaggerUI(options =>
351
        {
352
            options.SwaggerEndpoint("/swagger/v1/swagger.json", "MyProjectName API");
353
        });
354

355
        app.UseAuditing();
356
        app.UseAbpSerilogEnrichers();
357
        app.UseConfiguredEndpoints();
358
    }
359
}
360