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.MongoDB;
25
using Volo.Abp.Autofac;
26
using Volo.Abp.AutoMapper;
27
using Volo.Abp.Emailing;
28
using Volo.Abp.FeatureManagement;
29
using Volo.Abp.FeatureManagement.MongoDB;
30
using Volo.Abp.Identity;
31
using Volo.Abp.Identity.MongoDB;
32
using Volo.Abp.Modularity;
33
using Volo.Abp.MultiTenancy;
34
using Volo.Abp.OpenIddict.MongoDB;
35
using Volo.Abp.PermissionManagement;
36
using Volo.Abp.PermissionManagement.MongoDB;
37
using Volo.Abp.PermissionManagement.HttpApi;
38
using Volo.Abp.PermissionManagement.Identity;
39
using Volo.Abp.PermissionManagement.OpenIddict;
40
using Volo.Abp.SettingManagement;
41
using Volo.Abp.SettingManagement.MongoDB;
42
using Volo.Abp.Swashbuckle;
43
using Volo.Abp.TenantManagement;
44
using Volo.Abp.TenantManagement.MongoDB;
45
using Volo.Abp.OpenIddict;
46
using Volo.Abp.Security.Claims;
47
using Volo.Abp.UI.Navigation.Urls;
48
using Volo.Abp.Uow;
49
using Volo.Abp.VirtualFileSystem;
50

51
namespace MyCompanyName.MyProjectName;
52

53
[DependsOn(
54

55
    typeof(MyProjectNameContractsModule),
56

57
    // ABP Framework packages
58
    typeof(AbpAspNetCoreMvcModule),
59
    typeof(AbpAspNetCoreMultiTenancyModule),
60
    typeof(AbpAutofacModule),
61
    typeof(AbpAutoMapperModule),
62
    typeof(AbpAspNetCoreMvcUiLeptonXLiteThemeModule),
63
    typeof(AbpSwashbuckleModule),
64
    typeof(AbpAspNetCoreSerilogModule),
65

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

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

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

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

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

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

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

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

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

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

133
                PreConfigure<OpenIddictServerBuilder>(serverBuilder =>
134
                {
135
                    serverBuilder.AddProductionEncryptionAndSigningCertificate("openiddict.pfx", "00000000-0000-0000-0000-000000000000");
136
                });
137
            }
138
        }
139

140
        public override void ConfigureServices(ServiceConfigurationContext context)
141
        {
142
            var hostingEnvironment = context.Services.GetHostingEnvironment();
143
            var configuration = context.Services.GetConfiguration();
144

145
            if (hostingEnvironment.IsDevelopment())
146
            {
147
                context.Services.Replace(ServiceDescriptor.Singleton<IEmailSender, NullEmailSender>());
148
            }
149

150
            // Add services to the container.
151
            context.Services.AddRazorComponents()
152
                .AddInteractiveWebAssemblyComponents();
153

154
            ConfigureAuthentication(context);
155
            ConfigureBundles();
156
            ConfigureMultiTenancy();
157
            ConfigureUrls(configuration);
158
            ConfigureAutoMapper(context);
159
            ConfigureSwagger(context.Services, configuration);
160
            ConfigureAutoApiControllers();
161
            ConfigureVirtualFiles(hostingEnvironment);
162
            ConfigureCors(context, configuration);
163
            ConfigureDataProtection(context);
164
            ConfigureMongoDB(context);
165
        }
166

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

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

187
        private void ConfigureMultiTenancy()
188
        {
189
            Configure<AbpMultiTenancyOptions>(options =>
190
            {
191
                options.IsEnabled = MultiTenancyConsts.IsEnabled;
192
            });
193
        }
194

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

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

217
        private void ConfigureAutoApiControllers()
218
        {
219
            Configure<AbpAspNetCoreMvcOptions>(options =>
220
            {
221
                options.ConventionalControllers.Create(typeof(MyProjectNameHostModule).Assembly);
222
            });
223
        }
224

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

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

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

276
        private void ConfigureDataProtection(ServiceConfigurationContext context)
277
        {
278
            context.Services.AddDataProtection().SetApplicationName("MyProjectName");
279
        }
280

281
        private void ConfigureMongoDB(ServiceConfigurationContext context)
282
        {
283
            context.Services.AddMongoDbContext<MyProjectNameDbContext>(options =>
284
            {
285
                options.AddDefaultRepositories();
286
            });
287

288
            Configure<AbpUnitOfWorkDefaultOptions>(options =>
289
            {
290
                options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled;
291
            });
292
        }
293

294
        public override void OnApplicationInitialization(ApplicationInitializationContext context)
295
        {
296
            var app = context.GetApplicationBuilder();
297
            var env = context.GetEnvironment();
298

299
            if (env.IsDevelopment())
300
            {
301
                app.UseWebAssemblyDebugging();
302
                app.UseDeveloperExceptionPage();
303
            }
304

305
            app.UseAbpRequestLocalization();
306

307
            if (!env.IsDevelopment())
308
            {
309
                app.UseErrorPage();
310
            }
311

312
            app.UseCorrelationId();
313
            app.UseBlazorFrameworkFiles();
314
            app.UseStaticFiles();
315
            app.UseRouting();
316
            app.UseCors();
317
            app.UseAuthentication();
318
            app.UseAbpOpenIddictValidation();
319

320
            if (MultiTenancyConsts.IsEnabled)
321
            {
322
                app.UseMultiTenancy();
323
            }
324

325
            app.UseUnitOfWork();
326
            app.UseDynamicClaims();
327
            app.UseAntiforgery();
328
            app.UseAuthorization();
329

330
            app.UseSwagger();
331
            app.UseAbpSwaggerUI(options =>
332
            {
333
                options.SwaggerEndpoint("/swagger/v1/swagger.json", "MyProjectName API");
334

335
                var configuration = context.GetConfiguration();
336
                options.OAuthClientId(configuration["AuthServer:SwaggerClientId"]);
337
                options.OAuthScopes("MyProjectName");
338
            });
339

340
            app.UseAuditing();
341
            app.UseAbpSerilogEnrichers();
342
            app.UseConfiguredEndpoints();
343
            app.UseConfiguredEndpoints(builder =>
344
            {
345
                builder.MapRazorComponents<App>()
346
                    .AddInteractiveWebAssemblyRenderMode()
347
                    .AddAdditionalAssemblies(WebAppAdditionalAssembliesHelper.GetAssemblies<MyProjectNameBlazorModule>());
348
            });
349
        }
350
}
351