Error after OpenIddict Migration #4588

11 Answer(s)

• 

  0

  onurpicakci created 2 years ago

  Hi, can you check the configurations and module dependencies in the webModule of your application? The error seems to be related to this.

  Save Cancel
• 

  0

  kfrancis@clinicalsupportsystems.com created 2 years ago

  [DependsOn(
      typeof(CabMDHttpApiModule),
      typeof(CabMDHttpApiClientModule),
      typeof(AbpAspNetCoreAuthenticationOpenIdConnectModule),
      typeof(AbpAspNetCoreMvcClientModule),
      typeof(AbpAutofacModule),
      typeof(AbpCachingStackExchangeRedisModule),
      typeof(AbpFeatureManagementWebModule),
      typeof(AbpAccountAdminWebModule),
      typeof(AbpHttpClientIdentityModelWebModule),
      typeof(AbpIdentityWebModule),
      typeof(AbpAuditLoggingWebModule),
      typeof(AbpAspNetCoreMvcUiLeptonXThemeModule),
      typeof(SaasHostWebModule),
      typeof(AbpOpenIddictProWebModule),
      typeof(LanguageManagementWebModule),
      typeof(TextTemplateManagementWebModule),
      typeof(AbpSwashbuckleModule),
      typeof(AbpAspNetCoreSerilogModule),
      typeof(AbpPaymentPayuWebModule),
      typeof(AbpPaymentTwoCheckoutWebModule),
      typeof(AbpPaymentWebModule),
      typeof(FileManagementWebModule),
      typeof(DocsWebModule),
      typeof(CabMDReportingModule),
      typeof(CmsKitProWebModule),
      typeof(AbpBlobStoringModule),
      typeof(AbpTextTemplatingScribanModule)
  )]
  

  Save Cancel
• 

  0

  liangshiwei created 2 years ago

  Support Team Fullstack Developer

  Hi,

  We have an example you can check: https://github.com/abpframework/abp-samples/tree/master/Ids2OpenId

  BTW, can you share the full logs?(webapp & authserver)

  Save Cancel
• 

  0

  kfrancis@clinicalsupportsystems.com created 2 years ago

  Yea, I followed the example I think along with the migration docs.

  That project isn't using LeptonX, which we are.

  Here are the Log files you asked for.

  Save Cancel
• 

  0

  kfrancis@clinicalsupportsystems.com created 2 years ago

  Here's the auth module def:

  DependsOn(
          typeof(AbpAutofacModule),
          typeof(AbpCachingStackExchangeRedisModule),
          typeof(AbpAspNetCoreSerilogModule),
          typeof(AbpAccountPublicWebOpenIddictModule),
          typeof(AbpAspNetCoreMvcUiLeptonXThemeModule),
          typeof(AbpAccountPublicApplicationModule),
          typeof(AbpDistributedLockingModule),
          typeof(CabMDEntityFrameworkCoreModule)
          )]
      public class CabMDAuthServerModule : AbpModule
      {
          private static X509Certificate2 GetSigningCertificate(IConfiguration configuration)
          {
              // try thumbprint first, most secure
              // Note: You need to make sure WEBSITE_LOAD_CERTIFICATES={thumbprint} is on the Azure settings or
              // the cert won't be found. See: https://learn.microsoft.com/en-us/azure/app-service/configure-ssl-certificate-in-code
              var certThumbprint = configuration.GetValue<string>("SigningCertificate:Thumbprint") ?? string.Empty;
              if (!string.IsNullOrEmpty(configuration.GetValue<string>("SigningCertificate:Thumbprint")))
              {
                  using var certStore = new X509Store(StoreName.My, StoreLocation.CurrentUser);
                  var validOnly = false;
                  certStore.Open(OpenFlags.ReadOnly);
  
                  var certCollection = certStore.Certificates.Find(
                                              X509FindType.FindByThumbprint,
                                              certThumbprint,
                                              validOnly);
  
                  // Get the first cert with the thumbprint
                  var cert = certCollection.OfType<X509Certificate2>().FirstOrDefault();
  
                  if (cert is null)
                      throw new Exception($"Certificate with thumbprint {certThumbprint} was not found");
  
                  // Use certificate
                  return cert;
              }
              else
              {
                  // try a physical file as fallback, less secure as we need to provide password and the file is static
                  var certPath = configuration.GetValue<string>("SigningCertificate:Path");
                  if (!string.IsNullOrEmpty(certPath) && File.Exists(certPath))
                  {
                      return new X509Certificate2(certPath, configuration.GetValue<string>("SigningCertificate:Password"));
                  }
                  else
                  {
                      throw new Exception($"Certificate with SigningCertificate:Path '{certPath}' was not found");
                  }
              }
          }
  
          public override void PreConfigureServices(ServiceConfigurationContext context)
          {
              var hostingEnvironment = context.Services.GetHostingEnvironment();
              var configuration = context.Services.GetConfiguration();
  
              PreConfigure<OpenIddictBuilder>(builder =>
              {
                  builder.AddValidation(options =>
                  {
                      options.AddAudiences("CabMD");
                      options.UseLocalServer();
                      options.UseAspNetCore();
                  });
              });
  
              if (!hostingEnvironment.IsDevelopment())
              {
                  PreConfigure<AbpOpenIddictAspNetCoreOptions>(options =>
                  {
                      options.AddDevelopmentEncryptionAndSigningCertificate = false;
                  });
  
                  PreConfigure<OpenIddictServerBuilder>(builder =>
                  {
                      builder.AddSigningCertificate(GetSigningCertificate(configuration));
                      builder.AddEncryptionCertificate(GetSigningCertificate(configuration));
                      builder.SetIssuer(new Uri(configuration["AuthServer:Authority"]));
                  });
              }
          }
  
          public override void ConfigureServices(ServiceConfigurationContext context)
          {
              var hostingEnvironment = context.Services.GetHostingEnvironment();
              var configuration = context.Services.GetConfiguration();
  
              if (!Convert.ToBoolean(configuration["App:DisablePII"]))
              {
                  Microsoft.IdentityModel.Logging.IdentityModelEventSource.ShowPII = true;
              }
  
              if (!Convert.ToBoolean(configuration["AuthServer:RequireHttpsMetadata"]))
              {
                  Configure<OpenIddictServerAspNetCoreOptions>(options =>
                  {
                      options.DisableTransportSecurityRequirement = true;
                  });
              }
  
              context.Services.ForwardIdentityAuthenticationForBearer(OpenIddictValidationAspNetCoreDefaults.AuthenticationScheme);
  
              Configure<AbpLocalizationOptions>(options =>
              {
                  options.Resources
                      .Get<CabMDResource>()
                      .AddBaseTypes(
                          typeof(AbpUiResource)
                      );
              });
  
              Configure<AbpBundlingOptions>(options =>
              {
                  options.StyleBundles.Configure(
                      LeptonXThemeBundles.Styles.Global,
                      bundle =>
                      {
                          bundle.AddFiles("/global-styles.css");
                      }
                  );
              });
  
              Configure<AbpAuditingOptions>(options =>
              {
                  //options.IsEnabledForGetRequests = true;
                  options.ApplicationName = "AuthServer";
              });
  
              if (hostingEnvironment.IsDevelopment())
              {
                  Configure<AbpVirtualFileSystemOptions>(options =>
                  {
                      options.FileSets.ReplaceEmbeddedByPhysical<CabMDDomainSharedModule>(Path.Combine(hostingEnvironment.ContentRootPath, string.Format("..{0}CabMD.Domain.Shared", Path.DirectorySeparatorChar)));
                      options.FileSets.ReplaceEmbeddedByPhysical<CabMDDomainModule>(Path.Combine(hostingEnvironment.ContentRootPath, string.Format("..{0}CabMD.Domain", Path.DirectorySeparatorChar)));
                  });
              }
  
              Configure<AppUrlOptions>(options =>
              {
                  options.Applications["MVC"].RootUrl = configuration["App:SelfUrl"];
                  options.RedirectAllowedUrls.AddRange(configuration["App:RedirectAllowedUrls"].Split(','));
              });
  
              Configure<AbpBackgroundJobOptions>(options =>
              {
                  options.IsJobExecutionEnabled = false;
              });
  
              Configure<AbpDistributedCacheOptions>(options =>
              {
                  options.KeyPrefix = "CabMD:";
              });
  
              var dataProtectionBuilder = context.Services.AddDataProtection().SetApplicationName("CabMD");
              if (!hostingEnvironment.IsDevelopment())
              {
                  var redis = ConnectionMultiplexer.Connect(configuration["Redis:Configuration"]);
                  dataProtectionBuilder.PersistKeysToStackExchangeRedis(redis, "CabMD-Protection-Keys");
              }
  
              context.Services.AddSingleton<IDistributedLockProvider>(sp =>
              {
                  var connection = ConnectionMultiplexer
                      .Connect(configuration["Redis:Configuration"]);
                  return new RedisDistributedSynchronizationProvider(connection.GetDatabase());
              });
  
              context.Services.AddCors(options =>
              {
                  options.AddDefaultPolicy(builder =>
                  {
                      builder
                          .WithOrigins(
                              configuration["App:CorsOrigins"]
                                  .Split(",", StringSplitOptions.RemoveEmptyEntries)
                                  .Select(o => o.RemovePostFix("/"))
                                  .ToArray()
                          )
                          .WithAbpExposedHeaders()
                          .SetIsOriginAllowedToAllowWildcardSubdomains()
                          .AllowAnyHeader()
                          .AllowAnyMethod()
                          .AllowCredentials();
                  });
              });
  
              context.Services.AddAuthentication()
                  .AddGoogle(GoogleDefaults.AuthenticationScheme, _ => { })
                  .WithDynamicOptions<GoogleOptions, GoogleHandler>(
                      GoogleDefaults.AuthenticationScheme,
                      options =>
                      {
                          options.WithProperty(x => x.ClientId);
                          options.WithProperty(x => x.ClientSecret, isSecret: true);
                      }
                  )
                  .AddMicrosoftAccount(MicrosoftAccountDefaults.AuthenticationScheme, options =>
                  {
                      //Personal Microsoft accounts as an example.
                      options.AuthorizationEndpoint = "https://login.microsoftonline.com/consumers/oauth2/v2.0/authorize";
                      options.TokenEndpoint = "https://login.microsoftonline.com/consumers/oauth2/v2.0/token";
                  })
                  .WithDynamicOptions<MicrosoftAccountOptions, MicrosoftAccountHandler>(
                      MicrosoftAccountDefaults.AuthenticationScheme,
                      options =>
                      {
                          options.WithProperty(x => x.ClientId);
                          options.WithProperty(x => x.ClientSecret, isSecret: true);
                      }
                  )
                  .AddTwitter(TwitterDefaults.AuthenticationScheme, options => options.RetrieveUserDetails = true)
                  .WithDynamicOptions<TwitterOptions, TwitterHandler>(
                      TwitterDefaults.AuthenticationScheme,
                      options =>
                      {
                          options.WithProperty(x => x.ConsumerKey);
                          options.WithProperty(x => x.ConsumerSecret, isSecret: true);
                      }
                  );
  
              context.Services.Configure<AbpAccountOptions>(options =>
              {
                  options.TenantAdminUserName = "admin";
                  options.ImpersonationTenantPermission = SaasHostPermissions.Tenants.Impersonation;
                  options.ImpersonationUserPermission = IdentityPermissions.Users.Impersonation;
              });
  
              Configure<LeptonXThemeOptions>(options =>
              {
                  options.DefaultStyle = LeptonXStyleNames.System;
              });
          }
  
          public override void OnApplicationInitialization(ApplicationInitializationContext context)
          {
              var app = context.GetApplicationBuilder();
              var env = context.GetEnvironment();
  
              if (env.IsDevelopment())
              {
                  app.UseDeveloperExceptionPage();
              }
  
              app.UseAbpRequestLocalization();
  
              if (!env.IsDevelopment())
              {
                  app.UseErrorPage();
                  app.UseHsts();
                  app.UseHttpsRedirection();
              }
  
              app.UseCorrelationId();
              app.UseStaticFiles();
              app.UseRouting();
              app.UseCors();
              app.UseAuthentication();
              app.UseAbpOpenIddictValidation();
  
              if (MultiTenancyConsts.IsEnabled)
              {
                  app.UseMultiTenancy();
              }
  
              app.UseUnitOfWork();
              app.UseAuthorization();
  
              app.UseAuditing();
              app.UseAbpSerilogEnrichers();
              app.UseConfiguredEndpoints();
  
              if (!env.IsDevelopment())
              {
                  app.Use((httpContext, next) =>
                  {
                      httpContext.Request.Scheme = "https";
                      return next();
                  });
              }
          }
      }
  

  Save Cancel
• 

  0

  kfrancis@clinicalsupportsystems.com created 2 years ago

  Here's the web module def:

  [DependsOn(
      typeof(CabMDHttpApiModule),
      typeof(CabMDHttpApiClientModule),
      typeof(AbpAspNetCoreAuthenticationOpenIdConnectModule),
      typeof(AbpAspNetCoreMvcClientModule),
      typeof(AbpAutofacModule),
      typeof(AbpCachingStackExchangeRedisModule),
      typeof(AbpFeatureManagementWebModule),
      typeof(AbpAccountAdminWebModule),
      typeof(AbpHttpClientIdentityModelWebModule),
      typeof(AbpIdentityWebModule),
      typeof(AbpAuditLoggingWebModule),
      typeof(AbpAspNetCoreMvcUiLeptonXThemeModule),
      typeof(SaasHostWebModule),
      typeof(AbpOpenIddictProWebModule),
      typeof(LanguageManagementWebModule),
      typeof(TextTemplateManagementWebModule),
      typeof(AbpSwashbuckleModule),
      typeof(AbpAspNetCoreSerilogModule),
      typeof(AbpPaymentPayuWebModule),
      typeof(AbpPaymentTwoCheckoutWebModule),
      typeof(AbpPaymentWebModule),
      typeof(FileManagementWebModule),
      typeof(DocsWebModule),
      typeof(CabMDReportingModule),
      typeof(CmsKitProWebModule),
      typeof(AbpBlobStoringModule),
      typeof(AbpTextTemplatingScribanModule)
  )]
  public class CabMDWebModule : AbpModule
  {
      public override void ConfigureServices(ServiceConfigurationContext context)
      {
          var hostingEnvironment = context.Services.GetHostingEnvironment();
          var configuration = context.Services.GetConfiguration();
  
          ConfigureBundles();
          ConfigurePages();
          ConfigureCache();
          ConfigureRedis(context, configuration, hostingEnvironment);
          ConfigureUrls(configuration);
          ConfigureAuthentication(context, configuration);
          ConfigureAutoMapper();
          ConfigureVirtualFileSystem(hostingEnvironment);
          ConfigureNavigationServices(configuration);
          ConfigureSwaggerServices(context.Services);
          ConfigureMultiTenancy();
          ConfigureBackgroundJobs(context, configuration);
          ConfigurePayment();
          ConfigureKendo(context.Services);
          ConfigureReporting(context, configuration);
          ConfigurePwnedPasswords(context.Services);
          ConfigureMiniProfiler(configuration, context.Services);
          ConfigureJsonSerialization();
          ConfigureBlobStorage();
          ConfigureLayoutChanges(configuration);
          //ConfigureHealthChecks(context, configuration);
      }
  
      public override void OnApplicationInitialization(ApplicationInitializationContext context)
      {
          var app = context.GetApplicationBuilder();
          var env = context.GetEnvironment();
  
          if (env.IsDevelopment())
          {
              app.UseDeveloperExceptionPage();
          }
  
          app.UseAbpRequestLocalization();
  
          if (!env.IsDevelopment())
          {
              app.UseErrorPage();
          }
          app.UseCors("TelerikReportingCorsPolicy");
  
          app.UseStaticFiles();
          app.UseRouting();
          app.UseAuthentication();
  
          if (MultiTenancyConsts.IsEnabled)
          {
              app.UseMultiTenancy();
          }
  
          app.UseAuthorization();
          if (bool.Parse(context.GetConfiguration()["App:EnableMiniProfiler"]))
          {
              app.UseMiniProfiler();
          }
  
          if (BackgroundJobConsts.IsEnabled)
          {
              app.UseHangfireDashboard("/hangfire", new DashboardOptions
              {
                  AsyncAuthorization = new[] { new AbpHangfireAuthorizationFilter() }
              });
          }
  
          app.UseSwagger();
          app.UseAbpSwaggerUI(options =>
          {
              options.SwaggerEndpoint("/swagger/v1/swagger.json", "CabMD API");
          });
          app.UseAuditing();
          app.UseAbpSerilogEnrichers();
          app.UseConfiguredEndpoints();
      }
  
      public override void PreConfigureServices(ServiceConfigurationContext context)
      {
          context.Services.PreConfigure<AbpMvcDataAnnotationsLocalizationOptions>(options =>
          {
              options.AddAssemblyResource(
                  typeof(CabMDResource),
                  typeof(CabMDDomainSharedModule).Assembly,
                  typeof(CabMDApplicationContractsModule).Assembly,
                  typeof(CabMDWebModule).Assembly
              );
          });
      }
  
      private static void ConfigureAuthentication(ServiceConfigurationContext context, IConfiguration configuration)
      {
          context.Services.AddAuthentication(options =>
              {
                  options.DefaultScheme = "Cookies";
                  options.DefaultChallengeScheme = "oidc";
              })
              .AddCookie("Cookies", options =>
              {
                  options.ExpireTimeSpan = TimeSpan.FromDays(365);
              })
              .AddAbpOpenIdConnect("oidc", options =>
              {
                  options.Authority = configuration["AuthServer:Authority"];
                  options.RequireHttpsMetadata = Convert.ToBoolean(configuration["AuthServer:RequireHttpsMetadata"]); ;
                  options.ResponseType = OpenIdConnectResponseType.CodeIdToken;
  
                  options.ClientId = configuration["AuthServer:ClientId"];
                  options.ClientSecret = configuration["AuthServer:ClientSecret"];
  
                  options.UsePkce = true; // Add this line
                  options.SaveTokens = true;
                  options.GetClaimsFromUserInfoEndpoint = true;
  
                  options.Scope.Add("roles");
                  options.Scope.Add("email");
                  options.Scope.Add("phone");
                  options.Scope.Add("CabMD");
              });
      }
  
      private static void ConfigureHealthChecks(ServiceConfigurationContext context, IConfiguration configuration)
      {
          if (configuration.GetValue("HealthChecks:HealthChecksEnabled", false))
          {
              context.Services.AddCabHealthChecks(configuration.GetConnectionString("Default"));
          }
      }
  
      private static void ConfigureKendo(IServiceCollection services)
      {
          services.AddKendo();
      }
  
      private static void ConfigureMiniProfiler(IConfiguration configuration, IServiceCollection services)
      {
          if (configuration.GetValue("App:EnableMiniProfiler", false))
          {
              services.AddMiniProfiler(options =>
              {
                  options.RouteBasePath = "/mp";
                  options.SqlFormatter = new StackExchange.Profiling.SqlFormatters.VerboseSqlServerFormatter();
                  options.IgnoredPaths.Add("/elmah");
                  options.IgnoredPaths.Add(".less");
                  options.TrackConnectionOpenClose = false;
                  options.PopupShowTimeWithChildren = true;
                  options.Storage = new RedisStorage(configuration["Redis:Configuration"]);
              }).AddEntityFramework();
          }
      }
  
      /// <summary>
      /// Adds the PwnedPasswords client in DI so we can check during user registration
      /// </summary>
      /// <param name="services"></param>
      private static void ConfigurePwnedPasswords(IServiceCollection services)
      {
          // see: https://blog.elmah.io/avoid-password-reuse-with-pwned-passwords-and-asp-net-core/
  
          services.AddPwnedPasswordHttpClient(minimumFrequencyToConsiderPwned: 1)
              .AddTransientHttpErrorPolicy(p => p.RetryAsync(3))
              .AddPolicyHandler(Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(2)));
      }
  
      private static void ConfigureRedis(
          ServiceConfigurationContext context,
          IConfiguration configuration,
          IWebHostEnvironment hostingEnvironment)
      {
          var dataProtectionBuilder = context.Services.AddDataProtection().SetApplicationName("CabMD");
          if (!hostingEnvironment.IsDevelopment())
          {
              var redis = ConnectionMultiplexer.Connect(configuration["Redis:Configuration"]);
              dataProtectionBuilder.PersistKeysToStackExchangeRedis(redis, "CabMD-Protection-Keys");
          }
  
          context.Services.AddSingleton<IDistributedLockProvider>(sp =>
          {
              var connection = ConnectionMultiplexer
                  .Connect(configuration["Redis:Configuration"]);
              return new RedisDistributedSynchronizationProvider(connection.GetDatabase());
          });
      }
  
      private static void ConfigureReporting(ServiceConfigurationContext context, IConfiguration configuration)
      {
          context.Services.Configure<IISServerOptions>(options => { options.AllowSynchronousIO = true; });
          context.Services.AddScoped<IReportSourceResolver, CabMDReportSourceResolver>();
          context.Services.AddSingleton<IReportServiceConfiguration>(sp =>
              new ReportServiceConfiguration
              {
                  ReportingEngineConfiguration = configuration,
                  HostAppId = "ReportingCore3App",
                  Storage = new FileStorage(),
                  ReportSourceResolver = sp.GetRequiredService<IReportSourceResolver>()
              });
          context.Services.AddCors(o => o.AddPolicy("TelerikReportingCorsPolicy", builder =>
          {
              builder.AllowAnyOrigin()
              .AllowAnyMethod()
              .AllowAnyHeader();
          }));
          context.Services.AddControllers().AddNewtonsoftJson(opt =>
          {
              opt.SerializerSettings.ContractResolver = new ApiHeaderJsonContractResolver(new ApiHeaderJsonNamingStrategyOptions
              {
                  DefaultStrategy = new PascalCaseNamingStrategy(),
                  HeaderName = "json-naming-strategy",
                  HttpContextAccessorProvider = context.Services.BuildServiceProvider().GetService<IHttpContextAccessor>,
                  NamingStrategies = new Dictionary<string, NamingStrategy>
                  {
                      {"camelcase", new CamelCaseNamingStrategy() },
                      {"snakecase", new SnakeCaseNamingStrategy() },
                      {"pascalcase", new PascalCaseNamingStrategy() }
                  }
              }, context.Services.BuildServiceProvider().GetService<IMemoryCache>);
          }).AddJsonOptions(options =>
          {
          });
          context.Services.AddRazorPages().AddNewtonsoftJson();
      }
  
      private static void ConfigureSwaggerServices(IServiceCollection services)
      {
          services.AddSwaggerGen(
              options =>
              {
                  options.SwaggerDoc("v1", new OpenApiInfo { Title = "CabMD API", Version = "v1" });
                  options.DocInclusionPredicate((docName, description) => true);
                  options.CustomSchemaIds(type => type.FullName);
              }
          );
      }
  
      private void ConfigureAutoMapper()
      {
          Configure<AbpAutoMapperOptions>(options =>
          {
              options.AddMaps<CabMDWebModule>();
          });
      }
  
      private void ConfigureBackgroundJobs(ServiceConfigurationContext context, IConfiguration configuration)
      {
          Configure<AbpBackgroundJobOptions>(options => options.IsJobExecutionEnabled = BackgroundJobConsts.IsEnabled);
          Configure<AbpBackgroundWorkerOptions>(options => options.IsEnabled = BackgroundJobConsts.IsEnabled);
  
          if (BackgroundJobConsts.IsEnabled)
          {
              context.Services.AddHangfire(config =>
              {
                  config.UseSqlServerStorage(configuration.GetConnectionString("Default"));
              });
              context.Services.AddHangfireServer();
          }
      }
  
      private void ConfigureBlobStorage()
      {
          Configure<AbpBlobStoringOptions>(options =>
          {
              options.Containers.ConfigureDefault(container =>
              {
                  container.UseDatabase();
              });
          });
      }
  
      private void ConfigureBundles()
      {
          Configure<AbpBundlingOptions>(options =>
          {
              options.StyleBundles.Configure(
                  LeptonXThemeBundles.Styles.Global,
                  bundle =>
                  {
                      bundle.AddFiles("/global-styles.css");
                  }
              );
          });
      }
  
      private void ConfigureCache()
      {
          Configure<AbpDistributedCacheOptions>(options =>
          {
              options.KeyPrefix = "CabMD:";
          });
      }
  
      private void ConfigureJsonSerialization()
      {
          Configure<AbpJsonOptions>(options =>
          {
              //options.UseHybridSerializer = false;
          });
          Configure<AbpSystemTextJsonSerializerOptions>(options =>
          {
              ////options.JsonSerializerOptions.Converters.Add(new JsonNonStringKeyDictionaryConverterFactory());
              //options.JsonSerializerOptions.Converters.Add(new DiagnosticCodes.Diagnostic_Code.Diagnostic_CodeSystemTextJsonConverter());
              //options.JsonSerializerOptions.Converters.Add(new MasterNumbers.Master_Number.Master_NumberSystemTextJsonConverter());
              //options.JsonSerializerOptions.Converters.Add(new CabMD.Patients.Province_Code.Province_CodeSystemTextJsonConverter());
              CabMDJsonSerializationOptions.SetConverters(options.JsonSerializerOptions);
          });
          //Configure<AbpNewtonsoftJsonSerializerOptions>(options =>
          //{
          //    options.Converters.Add<AbpJsonIsoDateTimeConverter>();
          //});
      }
  
      private void ConfigureLayoutChanges(IConfiguration configuration)
      {
          Configure<AbpBundlingOptions>(options =>
          {
              options.StyleBundles.Configure(LeptonXThemeBundles.Styles.Global,
                  bundle =>
                  {
                      bundle.AddContributors(typeof(KendoStyleContributor));
                  });
              options
                  .StyleBundles
                  .Get(StandardBundles.Styles.Global)
                  .Contributors.Remove<FontAwesomeStyleContributor>(); // Do this so we can use pro kit
          });
  
          Configure<AbpLayoutHookOptions>(options =>
          {
              options.Add(
                  LayoutHooks.Head.Last, //The hook name
                  typeof(KendoViewComponent) //The component to add
              );
  
              options.Add(LayoutHooks.Body.Last, typeof(KendoDeferredViewComponent));
  
              options.Add(
                  LayoutHooks.Head.Last, //The hook name
                  typeof(FontAwesomeViewComponent) // Add the pro kit
              );
  
              if (configuration.GetValue<bool>("Intercom:Enabled", false))
              {
                  options.Add(
                      LayoutHooks.Head.First,
                      typeof(IntercomViewComponent));
              }
  
              if (configuration.GetValue<bool>("App:EnableMiniProfiler", false))
              {
                  options.Add(
                      LayoutHooks.Body.Last,
                      typeof(MiniProfilerViewComponent));
              }
          });
      }
  
      private void ConfigureMultiTenancy()
      {
          Configure<AbpMultiTenancyOptions>(options => { options.IsEnabled = MultiTenancyConsts.IsEnabled; });
      }
  
      private void ConfigureNavigationServices(IConfiguration configuration)
      {
          Configure<AbpNavigationOptions>(options =>
          {
              options.MenuContributors.Add(new CabMDMenuContributor(configuration));
          });
  
          Configure<AbpToolbarOptions>(options =>
          {
              options.Contributors.Add(new CabMDToolbarContributor());
          });
      }
  
      private void ConfigurePages()
      {
          Configure<RazorPagesOptions>(options =>
          {
              options.Conventions.AuthorizePage("/HostDashboard", CabMDPermissions.Dashboard.Host);
              options.Conventions.AuthorizePage("/TenantDashboard", CabMDPermissions.Dashboard.Tenant);
              options.Conventions.AuthorizePage("/Plans/Index", CabMDPermissions.Plans.Default);
              options.Conventions.AuthorizePage("/CareProviders/Index", CabMDPermissions.CareProviders.Default);
              options.Conventions.AuthorizePage("/MasterNumbers/Index", CabMDPermissions.MasterNumbers.Default);
              options.Conventions.AuthorizePage("/DiagnosticCodes/Index", CabMDPermissions.DiagnosticCodes.Default);
              options.Conventions.AuthorizePage("/Services/Index", CabMDPermissions.Services.Default);
          });
  
          Configure<RouteOptions>(options =>
          {
              options.ConstraintMap.Add("claimstate", typeof(ClaimStateConstraint));
              options.ConstraintMap.Add("patientid", typeof(PatientIdConstraint));
          });
      }
  }
  

  Save Cancel
• 

  0

  liangshiwei created 2 years ago

  Support Team Fullstack Developer

  Hi,

  You can try to add Volo.Abp.Account.Pro.Public.Web.Impersonation package to the Web project.

  And add typeof(AbpAccountPublicWebImpersonationModule) to the Web module class.

  Save Cancel
• 

  0

  liangshiwei created 2 years ago

  Support Team Fullstack Developer

  Add AccountController to the Web project

  public class AccountController : AbpAccountImpersonationChallengeAccountController
  {
  
  }
  
  

  Save Cancel
• 

  0

  kfrancis@clinicalsupportsystems.com created 2 years ago

  No change.

  Save Cancel
• 

  0

  liangshiwei created 2 years ago

  Support Team Fullstack Developer

  Hi,

  Can you share a project that can reproduce the problem? shiwei.liang@volosoft.com I will check it. thanks.

  Save Cancel
• 

  0

  kfrancis@clinicalsupportsystems.com created 2 years ago

  Just in case others find this thread, the issue for us was that we still had some packages from before our Lepton to LeptonX migration - Volo.Abp.LeptonTheme.*. Once we removed those six packages, it started working normally.

  Save Cancel