abp

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

52
namespace MyCompanyName.MyProjectName;
53

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

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

70
    // Identity module packages
71
    typeof(AbpPermissionManagementDomainIdentityModule),
72
    typeof(AbpPermissionManagementDomainOpenIddictModule),
73
    typeof(AbpIdentityApplicationModule),
74
    typeof(AbpIdentityHttpApiModule),
75
    typeof(AbpIdentityEntityFrameworkCoreModule),
76
    typeof(AbpOpenIddictEntityFrameworkCoreModule),
77

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

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

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

91
    // Feature Management module packages
92
    typeof(AbpFeatureManagementApplicationModule),
93
    typeof(AbpFeatureManagementEntityFrameworkCoreModule),
94
    typeof(AbpFeatureManagementHttpApiModule),
95

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

106
    public override void PreConfigureServices(ServiceConfigurationContext context)
107
    {
108
        var hostingEnvironment = context.Services.GetHostingEnvironment();
109
        var configuration = context.Services.GetConfiguration();
110

111
        context.Services.PreConfigure<AbpMvcDataAnnotationsLocalizationOptions>(options =>
112
        {
113
            options.AddAssemblyResource(
114
                typeof(MyProjectNameResource)
115
            );
116
        });
117

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

128
        if (!hostingEnvironment.IsDevelopment())
129
        {
130
            PreConfigure<AbpOpenIddictAspNetCoreOptions>(options =>
131
            {
132
                options.AddDevelopmentEncryptionAndSigningCertificate = false;
133
            });
134

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

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

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

156
        ConfigureAuthentication(context);
157
        ConfigureBundles();
158
        ConfigureMultiTenancy();
159
        ConfigureUrls(configuration);
160
        ConfigureAutoMapper(context);
161
        ConfigureSwagger(context.Services, configuration);
162
        ConfigureAutoApiControllers();
163
        ConfigureVirtualFiles(hostingEnvironment);
164
        ConfigureLocalization();
165
        ConfigureCors(context, configuration);
166
        ConfigureDataProtection(context);
167
        ConfigureEfCore(context);
168
    }
169

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

179
    private void ConfigureBundles()
180
    {
181
        Configure<AbpBundlingOptions>(options =>
182
        {
183
            options.StyleBundles.Configure(
184
                LeptonXLiteThemeBundles.Styles.Global,
185
                bundle => { bundle.AddFiles("/global-styles.css"); }
186
            );
187
        });
188
    }
189

190
    private void ConfigureMultiTenancy()
191
    {
192
        Configure<AbpMultiTenancyOptions>(options =>
193
        {
194
            options.IsEnabled = IsMultiTenant;
195
        });
196
    }
197

198
    private void ConfigureUrls(IConfiguration configuration)
199
    {
200
        Configure<AppUrlOptions>(options =>
201
        {
202
            options.Applications["MVC"].RootUrl = configuration["App:SelfUrl"];
203
            options.RedirectAllowedUrls.AddRange(configuration["App:RedirectAllowedUrls"]?.Split(',') ?? Array.Empty<string>());
204

205
            options.Applications["Angular"].RootUrl = configuration["App:ClientUrl"];
206
            options.Applications["Angular"].Urls[AccountUrlNames.PasswordReset] = "account/reset-password";
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 ConfigureAutoApiControllers()
263
    {
264
        Configure<AbpAspNetCoreMvcOptions>(options =>
265
        {
266
            options.ConventionalControllers.Create(typeof(MyProjectNameModule).Assembly);
267
        });
268
    }
269

270
    private void ConfigureSwagger(IServiceCollection services, IConfiguration configuration)
271
    {
272
        services.AddAbpSwaggerGenWithOAuth(
273
            configuration["AuthServer:Authority"]!,
274
            new Dictionary<string, string>
275
            {
276
                    {"MyProjectName", "MyProjectName API"}
277
            },
278
            options =>
279
            {
280
                options.SwaggerDoc("v1", new OpenApiInfo { Title = "MyProjectName API", Version = "v1" });
281
                options.DocInclusionPredicate((docName, description) => true);
282
                options.CustomSchemaIds(type => type.FullName);
283
            });
284
    }
285

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

299
    private void ConfigureCors(ServiceConfigurationContext context, IConfiguration configuration)
300
    {
301
        context.Services.AddCors(options =>
302
        {
303
            options.AddDefaultPolicy(builder =>
304
            {
305
                builder
306
                    .WithOrigins(
307
                        configuration["App:CorsOrigins"]?
308
                            .Split(",", StringSplitOptions.RemoveEmptyEntries)
309
                            .Select(o => o.RemovePostFix("/"))
310
                            .ToArray() ?? Array.Empty<string>()
311
                    )
312
                    .WithAbpExposedHeaders()
313
                    .SetIsOriginAllowedToAllowWildcardSubdomains()
314
                    .AllowAnyHeader()
315
                    .AllowAnyMethod()
316
                    .AllowCredentials();
317
            });
318
        });
319
    }
320

321
    private void ConfigureDataProtection(ServiceConfigurationContext context)
322
    {
323
        context.Services.AddDataProtection().SetApplicationName("MyProjectName");
324
    }
325

326
    private void ConfigureEfCore(ServiceConfigurationContext context)
327
    {
328
        context.Services.AddAbpDbContext<MyProjectNameDbContext>(options =>
329
        {
330
            /* You can remove "includeAllEntities: true" to create
331
             * default repositories only for aggregate roots
332
             * Documentation: https://docs.abp.io/en/abp/latest/Entity-Framework-Core#add-default-repositories
333
             */
334
            options.AddDefaultRepositories(includeAllEntities: true);
335
        });
336

337
        Configure<AbpDbContextOptions>(options =>
338
        {
339
            options.Configure(configurationContext =>
340
            {
341
                configurationContext.UseSqlServer();
342
            });
343
        });
344

345
        //<TEMPLATE-REMOVE IF-NOT='dbms:SQLite'>
346
        Configure<AbpUnitOfWorkDefaultOptions>(options =>
347
        {
348
            options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled;
349
        });
350
        //</TEMPLATE-REMOVE>
351
    }
352

353
    public override void OnApplicationInitialization(ApplicationInitializationContext context)
354
    {
355
        var app = context.GetApplicationBuilder();
356
        var env = context.GetEnvironment();
357

358
        if (env.IsDevelopment())
359
        {
360
            app.UseDeveloperExceptionPage();
361
        }
362

363
        app.UseAbpRequestLocalization();
364

365
        if (!env.IsDevelopment())
366
        {
367
            app.UseErrorPage();
368
        }
369

370
        app.UseCorrelationId();
371
        app.UseStaticFiles();
372
        app.UseRouting();
373
        app.UseCors();
374
        app.UseAuthentication();
375
        app.UseAbpOpenIddictValidation();
376

377
        if (IsMultiTenant)
378
        {
379
            app.UseMultiTenancy();
380
        }
381

382
        app.UseUnitOfWork();
383
        app.UseDynamicClaims();
384
        app.UseAuthorization();
385

386
        app.UseSwagger();
387
        app.UseAbpSwaggerUI(options =>
388
        {
389
            options.SwaggerEndpoint("/swagger/v1/swagger.json", "MyProjectName API");
390

391
            var configuration = context.GetConfiguration();
392
            options.OAuthClientId(configuration["AuthServer:SwaggerClientId"]);
393
            options.OAuthScopes("MyProjectName");
394
        });
395

396
        app.UseAuditing();
397
        app.UseAbpSerilogEnrichers();
398
        app.UseConfiguredEndpoints();
399
    }
400
}
401