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 MyCompanyName.MyProjectName;
9
using MyCompanyName.MyProjectName.Components;
10
using MyCompanyName.MyProjectName.MultiTenancy;
11
using OpenIddict.Validation.AspNetCore;
12
using Volo.Abp;
13
using Volo.Abp.Account;
14
using Volo.Abp.Account.Web;
15
using Volo.Abp.AspNetCore.Components.WebAssembly.WebApp;
16
using Volo.Abp.AspNetCore.MultiTenancy;
17
using Volo.Abp.AspNetCore.Mvc;
18
using Volo.Abp.AspNetCore.Mvc.Localization;
19
using Volo.Abp.AspNetCore.Mvc.UI.Bundling;
20
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite;
21
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite.Bundling;
22
using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
23
using Volo.Abp.AspNetCore.Serilog;
24
using Volo.Abp.AuditLogging.EntityFrameworkCore;
25
using Volo.Abp.Autofac;
26
using Volo.Abp.AutoMapper;
27
using Volo.Abp.Emailing;
28
using Volo.Abp.EntityFrameworkCore;
29
using Volo.Abp.EntityFrameworkCore.SqlServer;
30
using Volo.Abp.FeatureManagement;
31
using Volo.Abp.FeatureManagement.EntityFrameworkCore;
32
using Volo.Abp.Identity;
33
using Volo.Abp.Identity.EntityFrameworkCore;
34
using Volo.Abp.Modularity;
35
using Volo.Abp.MultiTenancy;
36
using Volo.Abp.OpenIddict.EntityFrameworkCore;
37
using Volo.Abp.PermissionManagement;
38
using Volo.Abp.PermissionManagement.EntityFrameworkCore;
39
using Volo.Abp.PermissionManagement.HttpApi;
40
using Volo.Abp.PermissionManagement.Identity;
41
using Volo.Abp.PermissionManagement.OpenIddict;
42
using Volo.Abp.SettingManagement;
43
using Volo.Abp.SettingManagement.EntityFrameworkCore;
44
using Volo.Abp.Swashbuckle;
45
using Volo.Abp.TenantManagement;
46
using Volo.Abp.TenantManagement.EntityFrameworkCore;
47
using Volo.Abp.OpenIddict;
48
using Volo.Abp.Security.Claims;
49
using Volo.Abp.UI.Navigation.Urls;
50
using Volo.Abp.Uow;
51
using Volo.Abp.VirtualFileSystem;
52

53
namespace MyCompanyName.MyProjectName;
54

55
[DependsOn(
56

57
    typeof(MyProjectNameContractsModule),
58

59
    // ABP Framework packages
60
    typeof(AbpAspNetCoreMvcModule),
61
    typeof(AbpAspNetCoreMultiTenancyModule),
62
    typeof(AbpAutofacModule),
63
    typeof(AbpAutoMapperModule),
64
    typeof(AbpEntityFrameworkCoreSqlServerModule),
65
    typeof(AbpAspNetCoreMvcUiLeptonXLiteThemeModule),
66
    typeof(AbpSwashbuckleModule),
67
    typeof(AbpAspNetCoreSerilogModule),
68

69
    // Account module packages
70
    typeof(AbpAccountApplicationModule),
71
    typeof(AbpAccountHttpApiModule),
72
    typeof(AbpAccountWebOpenIddictModule),
73

74
    // Identity module packages
75
    typeof(AbpPermissionManagementDomainIdentityModule),
76
    typeof(AbpPermissionManagementDomainOpenIddictModule),
77
    typeof(AbpIdentityApplicationModule),
78
    typeof(AbpIdentityHttpApiModule),
79
    typeof(AbpIdentityEntityFrameworkCoreModule),
80
    typeof(AbpOpenIddictEntityFrameworkCoreModule),
81

82
    // Audit logging module packages
83
    typeof(AbpAuditLoggingEntityFrameworkCoreModule),
84

85
    // Permission Management module packages
86
    typeof(AbpPermissionManagementApplicationModule),
87
    typeof(AbpPermissionManagementHttpApiModule),
88
    typeof(AbpPermissionManagementEntityFrameworkCoreModule),
89

90
    // Tenant Management module packages
91
    typeof(AbpTenantManagementApplicationModule),
92
    typeof(AbpTenantManagementHttpApiModule),
93
    typeof(AbpTenantManagementEntityFrameworkCoreModule),
94

95
    // Feature Management module packages
96
    typeof(AbpFeatureManagementApplicationModule),
97
    typeof(AbpFeatureManagementEntityFrameworkCoreModule),
98
    typeof(AbpFeatureManagementHttpApiModule),
99

100
    // Setting Management module packages
101
    typeof(AbpSettingManagementApplicationModule),
102
    typeof(AbpSettingManagementEntityFrameworkCoreModule),
103
    typeof(AbpSettingManagementHttpApiModule)
104
)]
105
public class MyProjectNameHostModule : AbpModule
106
{
107
        public override void PreConfigureServices(ServiceConfigurationContext context)
108
        {
109
            var hostingEnvironment = context.Services.GetHostingEnvironment();
110
            var configuration = context.Services.GetConfiguration();
111

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

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

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

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

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

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

155
            // Add services to the container.
156
            context.Services.AddRazorComponents()
157
                .AddInteractiveWebAssemblyComponents();
158

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

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

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

192
        private void ConfigureMultiTenancy()
193
        {
194
            Configure<AbpMultiTenancyOptions>(options =>
195
            {
196
                options.IsEnabled = MultiTenancyConsts.IsEnabled;
197
            });
198
        }
199

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

209
        private void ConfigureVirtualFiles(IWebHostEnvironment hostingEnvironment)
210
        {
211
            Configure<AbpVirtualFileSystemOptions>(options =>
212
            {
213
                options.FileSets.AddEmbedded<MyProjectNameHostModule>();
214
                if (hostingEnvironment.IsDevelopment())
215
                {
216
                    /* Using physical files in development, so we don't need to recompile on changes */
217
                    options.FileSets.ReplaceEmbeddedByPhysical<MyProjectNameHostModule>(hostingEnvironment.ContentRootPath);
218
                }
219
            });
220
        }
221

222
        private void ConfigureAutoApiControllers()
223
        {
224
            Configure<AbpAspNetCoreMvcOptions>(options =>
225
            {
226
                options.ConventionalControllers.Create(typeof(MyProjectNameHostModule).Assembly);
227
            });
228
        }
229

230
        private void ConfigureSwagger(IServiceCollection services, IConfiguration configuration)
231
        {
232
            services.AddAbpSwaggerGenWithOAuth(
233
                configuration["AuthServer:Authority"]!,
234
                new Dictionary<string, string>
235
                {
236
                        {"MyProjectName", "MyProjectName API"}
237
                },
238
                options =>
239
                {
240
                    options.SwaggerDoc("v1", new OpenApiInfo { Title = "MyProjectName API", Version = "v1" });
241
                    options.DocInclusionPredicate((docName, description) => true);
242
                    options.CustomSchemaIds(type => type.FullName);
243
                });
244
        }
245

246
        private void ConfigureAutoMapper(ServiceConfigurationContext context)
247
        {
248
            context.Services.AddAutoMapperObjectMapper<MyProjectNameHostModule>();
249
            Configure<AbpAutoMapperOptions>(options =>
250
            {
251
                /* Uncomment `validate: true` if you want to enable the Configuration Validation feature.
252
                 * See AutoMapper's documentation to learn what it is:
253
                 * https://docs.automapper.org/en/stable/Configuration-validation.html
254
                 */
255
                options.AddMaps<MyProjectNameHostModule>(/* validate: true */);
256
            });
257
        }
258

259
        private void ConfigureCors(ServiceConfigurationContext context, IConfiguration configuration)
260
        {
261
            context.Services.AddCors(options =>
262
            {
263
                options.AddDefaultPolicy(builder =>
264
                {
265
                    builder
266
                        .WithOrigins(
267
                            configuration["App:CorsOrigins"]?
268
                                .Split(",", StringSplitOptions.RemoveEmptyEntries)
269
                                .Select(o => o.RemovePostFix("/"))
270
                                .ToArray() ?? Array.Empty<string>()
271
                        )
272
                        .WithAbpExposedHeaders()
273
                        .SetIsOriginAllowedToAllowWildcardSubdomains()
274
                        .AllowAnyHeader()
275
                        .AllowAnyMethod()
276
                        .AllowCredentials();
277
                });
278
            });
279
        }
280

281
        private void ConfigureDataProtection(ServiceConfigurationContext context)
282
        {
283
            context.Services.AddDataProtection().SetApplicationName("MyProjectName");
284
        }
285

286
        private void ConfigureEfCore(ServiceConfigurationContext context)
287
        {
288
            context.Services.AddAbpDbContext<MyProjectNameDbContext>(options =>
289
            {
290
                /* You can remove "includeAllEntities: true" to create
291
                 * default repositories only for aggregate roots
292
                 * Documentation: https://docs.abp.io/en/abp/latest/Entity-Framework-Core#add-default-repositories
293
                 */
294
                options.AddDefaultRepositories(includeAllEntities: true);
295
            });
296

297
            Configure<AbpDbContextOptions>(options =>
298
            {
299
                options.Configure(configurationContext =>
300
                {
301
                    configurationContext.UseSqlServer();
302
                });
303
            });
304

305
            //<TEMPLATE-REMOVE IF-NOT='dbms:SQLite'>
306
            Configure<AbpUnitOfWorkDefaultOptions>(options =>
307
            {
308
                options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled;
309
            });
310
            //</TEMPLATE-REMOVE>
311
        }
312

313
        public override void OnApplicationInitialization(ApplicationInitializationContext context)
314
        {
315
            var app = context.GetApplicationBuilder();
316
            var env = context.GetEnvironment();
317

318
            if (env.IsDevelopment())
319
            {
320
                app.UseWebAssemblyDebugging();
321
                app.UseDeveloperExceptionPage();
322
            }
323

324
            app.UseAbpRequestLocalization();
325

326
            if (!env.IsDevelopment())
327
            {
328
                app.UseErrorPage();
329
            }
330

331
            app.UseCorrelationId();
332
            app.UseBlazorFrameworkFiles();
333
            app.UseStaticFiles();
334
            app.UseRouting();
335
            app.UseCors();
336
            app.UseAuthentication();
337
            app.UseAbpOpenIddictValidation();
338

339
            if (MultiTenancyConsts.IsEnabled)
340
            {
341
                app.UseMultiTenancy();
342
            }
343

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

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

354
                var configuration = context.GetConfiguration();
355
                options.OAuthClientId(configuration["AuthServer:SwaggerClientId"]);
356
                options.OAuthScopes("MyProjectName");
357
            });
358

359
            app.UseAuditing();
360
            app.UseAbpSerilogEnrichers();
361
            app.UseConfiguredEndpoints(builder =>
362
            {
363
                builder.MapRazorComponents<App>()
364
                    .AddInteractiveWebAssemblyRenderMode()
365
                    .AddAdditionalAssemblies(WebAppAdditionalAssembliesHelper.GetAssemblies<MyProjectNameBlazorModule>());
366
            });
367
        }
368
}
369