abp

1
using Blazorise.Bootstrap5;
2
using Blazorise.Icons.FontAwesome;
3
using Microsoft.AspNetCore.Extensions.DependencyInjection;
4
using Microsoft.Extensions.DependencyInjection.Extensions;
5
using Microsoft.Extensions.Options;
6
using Microsoft.OpenApi.Models;
7
using MyCompanyName.MyProjectName.Blazor.Server.Mongo.Components;
8
using MyCompanyName.MyProjectName.Data;
9
using MyCompanyName.MyProjectName.Localization;
10
using MyCompanyName.MyProjectName.Menus;
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.Web;
16
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite;
17
using Volo.Abp.AspNetCore.Components.Server.LeptonXLiteTheme;
18
using Volo.Abp.AspNetCore.Components.Server.LeptonXLiteTheme.Bundling;
19
using Volo.Abp.AspNetCore.Mvc.UI.Theme.LeptonXLite.Bundling;
20
using Volo.Abp.AspNetCore.Components.Web.Theming.Routing;
21
using Volo.Abp.AspNetCore.Mvc;
22
using Volo.Abp.AspNetCore.Mvc.Localization;
23
using Volo.Abp.AspNetCore.Mvc.UI.Bundling;
24
using Volo.Abp.AspNetCore.Serilog;
25
using Volo.Abp.AuditLogging.MongoDB;
26
using Volo.Abp.Autofac;
27
using Volo.Abp.AutoMapper;
28
using Volo.Abp.MongoDB;
29
using Volo.Abp.Emailing;
30
using Volo.Abp.FeatureManagement;
31
using Volo.Abp.FeatureManagement.Blazor.Server;
32
using Volo.Abp.FeatureManagement.MongoDB;
33
using Volo.Abp.Identity;
34
using Volo.Abp.Identity.Blazor.Server;
35
using Volo.Abp.Identity.MongoDB;
36
using Volo.Abp.Localization;
37
using Volo.Abp.Localization.ExceptionHandling;
38
using Volo.Abp.Modularity;
39
using Volo.Abp.OpenIddict.MongoDB;
40
using Volo.Abp.PermissionManagement;
41
using Volo.Abp.PermissionManagement.MongoDB;
42
using Volo.Abp.PermissionManagement.HttpApi;
43
using Volo.Abp.PermissionManagement.Identity;
44
using Volo.Abp.PermissionManagement.OpenIddict;
45
using Volo.Abp.SettingManagement;
46
using Volo.Abp.SettingManagement.Blazor.Server;
47
using Volo.Abp.SettingManagement.MongoDB;
48
using Volo.Abp.Swashbuckle;
49
using Volo.Abp.TenantManagement;
50
using Volo.Abp.TenantManagement.Blazor.Server;
51
using Volo.Abp.TenantManagement.MongoDB;
52
using Volo.Abp.OpenIddict;
53
using Volo.Abp.Security.Claims;
54
using Volo.Abp.UI.Navigation;
55
using Volo.Abp.UI.Navigation.Urls;
56
using Volo.Abp.Uow;
57
using Volo.Abp.Validation.Localization;
58
using Volo.Abp.VirtualFileSystem;
59

60
namespace MyCompanyName.MyProjectName;
61

62
[DependsOn(
63
    // ABP Framework packages
64
    typeof(AbpAspNetCoreMvcModule),
65
    typeof(AbpAutofacModule),
66
    typeof(AbpAutoMapperModule),
67
    typeof(AbpSwashbuckleModule),
68
    typeof(AbpAspNetCoreSerilogModule),
69
    typeof(AbpAspNetCoreMvcUiLeptonXLiteThemeModule),
70
    typeof(AbpAspNetCoreComponentsServerLeptonXLiteThemeModule),
71

72
    // Account module packages
73
    typeof(AbpAccountApplicationModule),
74
    typeof(AbpAccountHttpApiModule),
75
    typeof(AbpAccountWebOpenIddictModule),
76

77
    // Identity module packages
78
    typeof(AbpPermissionManagementDomainIdentityModule),
79
    typeof(AbpPermissionManagementDomainOpenIddictModule),
80
    typeof(AbpIdentityApplicationModule),
81
    typeof(AbpIdentityHttpApiModule),
82
    typeof(AbpIdentityMongoDbModule),
83
    typeof(AbpOpenIddictMongoDbModule),
84
    typeof(AbpIdentityBlazorServerModule),
85

86
    // Audit logging module packages
87
    typeof(AbpAuditLoggingMongoDbModule),
88

89
    // Permission Management module packages
90
    typeof(AbpPermissionManagementApplicationModule),
91
    typeof(AbpPermissionManagementHttpApiModule),
92
    typeof(AbpPermissionManagementMongoDbModule),
93

94
    // Tenant Management module packages
95
    typeof(AbpTenantManagementApplicationModule),
96
    typeof(AbpTenantManagementHttpApiModule),
97
    typeof(AbpTenantManagementMongoDbModule),
98
    typeof(AbpTenantManagementBlazorServerModule),
99

100
    // Feature Management module packages
101
    typeof(AbpFeatureManagementApplicationModule),
102
    typeof(AbpFeatureManagementMongoDbModule),
103
    typeof(AbpFeatureManagementHttpApiModule),
104
    typeof(AbpFeatureManagementBlazorServerModule),
105

106
    // Setting Management module packages
107
    typeof(AbpSettingManagementApplicationModule),
108
    typeof(AbpSettingManagementMongoDbModule),
109
    typeof(AbpSettingManagementHttpApiModule),
110
    typeof(AbpSettingManagementBlazorServerModule)
111
)]
112
public class MyProjectNameModule : AbpModule
113
{
114
    /* Single point to enable/disable multi-tenancy */
115
    public const bool IsMultiTenant = true;
116

117
    public override void PreConfigureServices(ServiceConfigurationContext context)
118
    {
119
        var hostingEnvironment = context.Services.GetHostingEnvironment();
120
        var configuration = context.Services.GetConfiguration();
121

122
        context.Services.PreConfigure<AbpMvcDataAnnotationsLocalizationOptions>(options =>
123
        {
124
            options.AddAssemblyResource(
125
                typeof(MyProjectNameResource),
126
                typeof(MyProjectNameModule).Assembly
127
            );
128
        });
129

130
        PreConfigure<OpenIddictBuilder>(builder =>
131
        {
132
            builder.AddValidation(options =>
133
            {
134
                options.AddAudiences("MyProjectName");
135
                options.UseLocalServer();
136
                options.UseAspNetCore();
137
            });
138
        });
139

140
        if (!hostingEnvironment.IsDevelopment())
141
        {
142
            PreConfigure<AbpOpenIddictAspNetCoreOptions>(options =>
143
            {
144
                options.AddDevelopmentEncryptionAndSigningCertificate = false;
145
            });
146

147
            PreConfigure<OpenIddictServerBuilder>(serverBuilder =>
148
            {
149
                serverBuilder.AddProductionEncryptionAndSigningCertificate("openiddict.pfx", "00000000-0000-0000-0000-000000000000");
150
            });
151
        }
152

153
        PreConfigure<AbpAspNetCoreComponentsWebOptions>(options =>
154
        {
155
            options.IsBlazorWebApp = true;
156
        });
157
        
158
        MyProjectNameGlobalFeatureConfigurator.Configure();
159
        MyProjectNameModuleExtensionConfigurator.Configure();
160
    }
161

162
    public override void ConfigureServices(ServiceConfigurationContext context)
163
    {
164
        var hostingEnvironment = context.Services.GetHostingEnvironment();
165
        var configuration = context.Services.GetConfiguration();
166

167
        if (hostingEnvironment.IsDevelopment())
168
        {
169
            context.Services.Replace(ServiceDescriptor.Singleton<IEmailSender, NullEmailSender>());
170
        }
171

172
        // Add services to the container.
173
        context.Services.AddRazorComponents()
174
            .AddInteractiveServerComponents();
175

176
        ConfigureAuthentication(context);
177
        ConfigureUrls(configuration);
178
        ConfigureBundles();
179
        ConfigureAutoMapper(context);
180
        ConfigureVirtualFiles(hostingEnvironment);
181
        ConfigureLocalizationServices();
182
        ConfigureSwaggerServices(context.Services);
183
        ConfigureNavigationServices();
184
        ConfigureAutoApiControllers();
185
        ConfigureBlazorise(context);
186
        ConfigureRouter(context);
187
        ConfigureMongoDB(context);
188
    }
189

190
    private void ConfigureAuthentication(ServiceConfigurationContext context)
191
    {
192
        context.Services.ForwardIdentityAuthenticationForBearer(OpenIddictValidationAspNetCoreDefaults.AuthenticationScheme);
193
        context.Services.Configure<AbpClaimsPrincipalFactoryOptions>(options =>
194
        {
195
            options.IsDynamicClaimsEnabled = true;
196
        });
197
    }
198

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

208
    private void ConfigureBundles()
209
    {
210
        Configure<AbpBundlingOptions>(options =>
211
        {
212
            // MVC UI
213
            options.StyleBundles.Configure(
214
                LeptonXLiteThemeBundles.Styles.Global,
215
                bundle =>
216
                {
217
                    bundle.AddFiles("/global-styles.css");
218
                }
219
            );
220

221
            //BLAZOR UI
222
            options.StyleBundles.Configure(
223
                BlazorLeptonXLiteThemeBundles.Styles.Global,
224
                bundle =>
225
                {
226
                    bundle.AddFiles("/blazor-global-styles.css");
227
                    //You can remove the following line if you don't use Blazor CSS isolation for components
228
                    bundle.AddFiles(new BundleFile("/MyCompanyName.MyProjectName.Blazor.Server.Mongo.styles.css", true));
229
                }
230
            );
231
        });
232
    }
233

234
    private void ConfigureLocalizationServices()
235
    {
236
        Configure<AbpLocalizationOptions>(options =>
237
        {
238
            options.Resources
239
                .Add<MyProjectNameResource>("en")
240
                .AddBaseTypes(typeof(AbpValidationResource))
241
                .AddVirtualJson("/Localization/MyProjectName");
242

243
            options.DefaultResourceType = typeof(MyProjectNameResource);
244

245
            options.Languages.Add(new LanguageInfo("en", "en", "English"));
246
            options.Languages.Add(new LanguageInfo("tr", "tr", "Türkçe"));
247
            options.Languages.Add(new LanguageInfo("ar", "ar", "العربية"));
248
            options.Languages.Add(new LanguageInfo("cs", "cs", "Čeština"));
249
            options.Languages.Add(new LanguageInfo("en-GB", "en-GB", "English (UK)"));
250
            options.Languages.Add(new LanguageInfo("hu", "hu", "Magyar"));
251
            options.Languages.Add(new LanguageInfo("fi", "fi", "Finnish"));
252
            options.Languages.Add(new LanguageInfo("fr", "fr", "Français"));
253
            options.Languages.Add(new LanguageInfo("hi", "hi", "Hindi"));
254
            options.Languages.Add(new LanguageInfo("is", "is", "Icelandic"));
255
            options.Languages.Add(new LanguageInfo("it", "it", "Italiano"));
256
            options.Languages.Add(new LanguageInfo("pt-BR", "pt-BR", "Português"));
257
            options.Languages.Add(new LanguageInfo("ro-RO", "ro-RO", "Română"));
258
            options.Languages.Add(new LanguageInfo("ru", "ru", "Русский"));
259
            options.Languages.Add(new LanguageInfo("sk", "sk", "Slovak"));
260
            options.Languages.Add(new LanguageInfo("zh-Hans", "zh-Hans", "简体中文"));
261
            options.Languages.Add(new LanguageInfo("zh-Hant", "zh-Hant", "繁體中文"));
262
            options.Languages.Add(new LanguageInfo("de-DE", "de-DE", "Deutsch"));
263
            options.Languages.Add(new LanguageInfo("es", "es", "Español"));
264
            options.Languages.Add(new LanguageInfo("el", "el", "Ελληνικά"));
265
        });
266

267
        Configure<AbpExceptionLocalizationOptions>(options =>
268
        {
269
            options.MapCodeNamespace("MyProjectName", typeof(MyProjectNameResource));
270
        });
271
    }
272

273
    private void ConfigureVirtualFiles(IWebHostEnvironment hostingEnvironment)
274
    {
275
        Configure<AbpVirtualFileSystemOptions>(options =>
276
        {
277
            options.FileSets.AddEmbedded<MyProjectNameModule>();
278
            if (hostingEnvironment.IsDevelopment())
279
            {
280
                /* Using physical files in development, so we don't need to recompile on changes */
281
                options.FileSets.ReplaceEmbeddedByPhysical<MyProjectNameModule>(hostingEnvironment.ContentRootPath);
282
            }
283
        });
284
    }
285

286
    private void ConfigureSwaggerServices(IServiceCollection services)
287
    {
288
        services.AddAbpSwaggerGen(
289
            options =>
290
            {
291
                options.SwaggerDoc("v1", new OpenApiInfo { Title = "MyProjectName API", Version = "v1" });
292
                options.DocInclusionPredicate((docName, description) => true);
293
                options.CustomSchemaIds(type => type.FullName);
294
            }
295
        );
296
    }
297

298
    private void ConfigureBlazorise(ServiceConfigurationContext context)
299
    {
300
        context.Services
301
            .AddBootstrap5Providers()
302
            .AddFontAwesomeIcons();
303
    }
304

305
    private void ConfigureRouter(ServiceConfigurationContext context)
306
    {
307
        Configure<AbpRouterOptions>(options =>
308
        {
309
            options.AppAssembly = typeof(MyProjectNameModule).Assembly;
310
        });
311
    }
312

313
    private void ConfigureNavigationServices()
314
    {
315
        Configure<AbpNavigationOptions>(options =>
316
        {
317
            options.MenuContributors.Add(new MyProjectNameMenuContributor());
318
        });
319
    }
320

321
    private void ConfigureAutoApiControllers()
322
    {
323
        Configure<AbpAspNetCoreMvcOptions>(options =>
324
        {
325
            options.ConventionalControllers.Create(typeof(MyProjectNameModule).Assembly);
326
        });
327
    }
328

329
    private void ConfigureAutoMapper(ServiceConfigurationContext context)
330
    {
331
        context.Services.AddAutoMapperObjectMapper<MyProjectNameModule>();
332
        Configure<AbpAutoMapperOptions>(options =>
333
        {
334
            options.AddMaps<MyProjectNameModule>();
335
        });
336
    }
337

338
    private void ConfigureMongoDB(ServiceConfigurationContext context)
339
    {
340
        context.Services.AddMongoDbContext<MyProjectNameDbContext>(options =>
341
        {
342
            options.AddDefaultRepositories();
343
        });
344

345
        Configure<AbpUnitOfWorkDefaultOptions>(options =>
346
        {
347
            options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled;
348
        });
349
    }
350

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

356
        app.UseAbpRequestLocalization();
357

358
        if (env.IsDevelopment())
359
        {
360
            app.UseDeveloperExceptionPage();
361
        }
362
        else
363
        {
364
            app.UseExceptionHandler("/Error");
365
            app.UseHsts();
366
        }
367

368
        app.UseHttpsRedirection();
369
        app.UseCorrelationId();
370
        app.UseStaticFiles();
371
        app.UseRouting();
372
        app.UseAuthentication();
373
        app.UseAbpOpenIddictValidation();
374

375
        if (IsMultiTenant)
376
        {
377
            app.UseMultiTenancy();
378
        }
379

380
        app.UseUnitOfWork();
381
        app.UseDynamicClaims();
382
        app.UseAntiforgery();
383
        app.UseAuthorization();
384

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

391
        app.UseAuditing();
392
        app.UseAbpSerilogEnrichers();
393
        app.UseConfiguredEndpoints(builder =>
394
        {
395
            builder.MapRazorComponents<App>()
396
                .AddInteractiveServerRenderMode()
397
                .AddAdditionalAssemblies(builder.ServiceProvider.GetRequiredService<IOptions<AbpRouterOptions>>().Value.AdditionalAssemblies.ToArray());
398
        });
399
    }
400
}
401