Activities of "AI-Bot"

  1. Solution Based on your screenshots and symptoms there are two separate issues:

A) AuthServer discovery shows HTTP endpoints (Angular rejects them) B) ABP Studio interception cannot reach cluster services (timeouts to Postgres/Redis via WireGuard)

Fix A – make discovery document fully HTTPS behind ingress/reverse proxy

  • Ensure the AuthServer publishes HTTPS URLs in the discovery document, even if Kestrel listens on HTTP behind an ingress. Add both settings below:
    • App settings: "AuthServer": { "Authority": "https://your-auth-host", "RequireHttpsMetadata": true }
    • Module configuration (set issuer and relax OpenIddict transport only if you must run plain HTTP internally):
public override void PreConfigureServices(ServiceConfigurationContext context)
  {
      var configuration = context.Services.GetConfiguration();

      PreConfigure<OpenIddictServerBuilder>(builder =>
      {
          builder.SetIssuer(new Uri(configuration["AuthServer:Authority"]!));
      });
  }

  public override void ConfigureServices(ServiceConfigurationContext context)
  {
      var env = context.Services.GetHostingEnvironment();
      var configuration = context.Services.GetConfiguration();

      if (!env.IsDevelopment())
      {
          // Honor X-Forwarded-* to build correct HTTPS URLs and cookies
          context.Services.Configure<ForwardedHeadersOptions>(o =>
          {
              o.ForwardedHeaders = ForwardedHeaders.XForwardedFor
                                 | ForwardedHeaders.XForwardedProto
                                 | ForwardedHeaders.XForwardedHost;
              o.KnownNetworks.Clear();
              o.KnownProxies.Clear();
          });
      }

      // If you cannot keep RequireHttpsMetadata=true, add this to avoid OpenIddict rejecting HTTP (not recommended for production):
      if (!configuration.GetValue<bool>("AuthServer:RequireHttpsMetadata"))
      {
          Configure<OpenIddictServerAspNetCoreOptions>(options =>
          {
              options.DisableTransportSecurityRequirement = true;
          });
      }
  }

  public override void OnApplicationInitialization(ApplicationInitializationContext context)
  {
      var app = context.GetApplicationBuilder();
      var env = context.GetEnvironment();

      if (!env.IsDevelopment())
      {
          app.UseForwardedHeaders();
      }

      // Optional hard override if your proxy doesn’t forward scheme correctly:
      // app.Use((ctx, next) => { ctx.Request.Scheme = "https"; return next(); });

      app.UseRouting();
      app.UseAuthentication();
      app.UseAuthorization();
      app.UseConfiguredEndpoints();
  }
  • In your ingress/reverse proxy (nginx/ingress controller) forward these headers:
    • X-Forwarded-Proto $scheme
    • X-Forwarded-Host $host
    • X-Forwarded-For $proxy_add_x_forwarded_for
    • Host $host
  • Seed/ensure RedirectAllowedUrls, CorsOrigins and clients use the same public https origin as Authority.
  • Verify the discovery document now shows https for all endpoints and jwks_uri.

Fix B – ABP Studio interception timeouts to in-cluster services

  • ABP Studio’s tunnel relies on:
    • The VPN client connected (abp-wg-easy and abp-studio-proxy pods healthy)
    • Local hosts file entries for service DNS names
    • The cluster allowing access to ClusterIP services via the VPN CIDR
  • Checklist:
    • Confirm “Connected” state in Studio and abp-wg-easy-vpn + abp-studio-proxy pods are Running.
    • Ensure your OS hosts file contains the entries Studio added (your screenshot shows them). Do not override them with other entries.
    • Verify your local machine can resolve and ping ClusterIP addresses (e.g., nslookup fauna-ai-staging-postgresql then ping that IP). If ICMP is blocked, test TCP:
      • Test DB: psql or tcp ping via PowerShell: Test-NetConnection fauna-ai-staging-postgresql -Port 5432
      • Test Redis: Test-NetConnection fauna-ai-stagingovh-redis -Port 6379
    • If these time out:
      • Check your cluster network policies: allow traffic from the WireGuard VPN CIDR to service ClusterIPs/ports (5432, 6379, etc.).
      • Check firewall rules on the cluster nodes for the VPN interface.
      • Ensure no corporate VPN/split-tunnel is overriding the ABP WireGuard route to the cluster CIDR.
    • When intercepting a service, start your local service with Kestrel (not IIS Express) and let Studio inject environment variables so it uses in-cluster connection strings and Redis.
    • If you see “Authorization failed! Given policy has not granted.” while debugging intercepted apps, run the create-tls-secret.ps1 in etc/helm and restart the app.

Notes specific to Angular and GW

  • Angular strict discovery validation requires all discovery URLs be https. After applying Fix A, Angular should stop rejecting the endpoints.
  • Make sure all microservices/gateway use ForwardedHeaders and that their RemoteServices.BaseUrl, AuthServer.Authority, and SelfUrl point to public https hosts (not internal service names) when serving browser traffic via the gateway.
  • For 127.0.0.1 client IPs in logs, enable ForwardedHeaders in every service/app so ABP can read the real client IP from X-Forwarded-For.
  1. Sources
  • ABP Studio – Kubernetes interception (includes TLS secret note and interception behavior)
    • https://abp.io/docs/latest/studio/kubernetes
  • Community thread (OpenIddict HTTPS behind proxy; issuer/authority and forwarded headers patterns)
    • https://abp.io/support/questions/4338
  • Community article: Kubernetes tunnel and interception with ABP Studio (explains VPN, hosts entries, interception)
    • https://abp.io/community/articles/h11utnq8

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution
  • Root cause

    • In Blazor Server, the “_framework” folder is part of the static web assets (Blazor runtime files) served by ASP.NET Core from the published output. If your Docker image doesn’t contain the published output of the Blazor Server project at the correct path and/or the container serves a different working directory, the “_framework” files won’t be found, causing login/UI to fail.
  • Fix: publish and copy the correct output into the runtime image

    1. Publish the Blazor Server project for Release inside the Docker build and copy the publish directory into the final image:
# Build & publish
  FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
  WORKDIR /src
  COPY . .
  RUN dotnet restore
  RUN dotnet publish ./src/YourCompany.YourApp.Blazor/YourCompany.YourApp.Blazor.csproj -c Release -o /app/publish

  # Runtime
  FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS final
  WORKDIR /app
  COPY --from=build /app/publish .
  ENTRYPOINT ["dotnet", "YourCompany.YourApp.Blazor.dll"]
  • Important: Ensure the DLL name matches your Blazor Server project DLL.
  • Do not copy bin/… directly unless it’s the publish folder. The publish folder must include the static web assets used to serve “_framework”.
  1. If you already publish outside Docker, copy the exact publish directory:
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS final
  WORKDIR /app
  COPY ./src/YourCompany.YourApp.Blazor/bin/Release/net10.0/publish/ .
  ENTRYPOINT ["dotnet", "YourCompany.YourApp.Blazor.dll"]
  • Verify that the path exists locally and contains the “_framework” under wwwroot/_framework or in static web assets folders included by the publish output.

  • Additional checks

    • Ensure you run dotnet publish (not just build). Publish produces the static web assets and manifest required for Blazor.
    • Make sure the container’s WORKDIR matches where you copied the publish output, and you are starting the correct DLL.
    • If you front the container with Nginx/Apache, confirm static files are not blocked and requests to “/_framework/*” are forwarded to Kestrel or served by the same app container without being intercepted.
    • If you turned on trimming (PublishTrimmed) or single-file publish, try disabling trimming for Blazor Server or ensure proper trim settings—aggressive trimming can remove files needed by the Blazor runtime.
  • ABP-specific note

    • The ABP Blazor Server app in a tiered solution is a single web app hosting both UI and the OpenIddict server by default. Use a multi-stage Dockerfile and copy from the publish output as shown above. ABP’s sample Dockerfile for Blazor Server also assumes copying from bin/Release/net10.0/publish into the aspnet base image.
  1. Sources
  • ASP.NET Core Blazor static files fundamentals (how Blazor serves “_framework”):
    • https://learn.microsoft.com/aspnet/core/blazor/fundamentals/static-files
  • ABP layered solution deployment to Docker (Blazor Server sample Dockerfile and steps):
    • https://abp.io/docs/10.0//solution-templates/layered-web-application/deployment/deployment-docker-compose
  • ABP v10 migration and .NET 10 note:
    • https://abp.io/docs/10.0//release-info/migration-guides/abp-10-0

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

Answer
  1. Solution
  • What’s happening:

    • In an ABP solution with MVC UI (cookies as the default auth scheme), API endpoints challenge unauthenticated requests with a redirect to the login page. A non-browser client (like your Next.js app) must call those endpoints with a valid Bearer access token obtained from your SSO provider (OpenIddict/IdentityServer in ABP). If the request has no Bearer token (or the API is not configured to accept it), you’ll see 401 or an HTML login response.
  • End-to-end steps to call protected APIs from your Next.js app using the SSO token:

    1. Ensure your backend accepts JWT Bearer tokens on the API
    • In your HttpApi.Host module, configure JWT bearer authentication. ABP templates already do this, but verify that the AddJwtBearer config is present and the API resource scopes include your application’s scope.
    • If your Next.js app will access the backend from a different origin, add that origin to CORS.
    1. Register your Next.js client in IdentityServer/OpenIddict
    • Add a public SPA client using the authorization_code flow with PKCE, redirect URIs for your Next.js app, and proper CORS origins. This is done in IdentityServerDataSeedContributor (or OpenIddict seed) and appsettings (DbMigrator).
    • Typical settings:
      • Grant types: authorization_code
      • RequireClientSecret: false
      • RedirectUris: https://your-next-app.com/callback
      • PostLogoutRedirectUris: https://your-next-app.com
      • AllowedCorsOrigins: https://your-next-app.com
      • Scopes: openid profile email role phone address and your API scope (e.g., YourAppName)
      • Add offline_access if you need refresh tokens.
    1. Authenticate in Next.js and get the access token
    • Use an OIDC library that supports Code + PKCE in Next.js (e.g., next-auth with an OIDC provider, or a low-level OIDC client). After the callback completes, you will have an access_token.
    1. Attach the access token to API requests
    • From Next.js (on the server or client), include: Authorization: Bearer {access_token}
    • Example with fetch: const res = await fetch(${process.env.NEXT_PUBLIC_API_URL}/api/identity/my-profile, { headers: { Authorization: Bearer ${accessToken}, 'Accept-Language': 'en', // optional 'Abp-TenantId': tenantId ?? '' // if you use multi-tenancy and need to target a tenant } }); if (res.status === 401) { // handle re-auth or token refresh }
    1. Handle 401 vs. login redirects
    • Cookies scheme redirects to login for browser requests. When calling from your Next.js code via fetch/axios with Bearer tokens, you’ll see 401 on invalid/expired tokens (not the HTML login) as long as you don’t rely on cookie auth for those calls.
    • If you still get redirected HTML, ensure:
      • You are not sending the MVC cookie along with the API call.
      • You are targeting the HttpApi.Host URL (not the MVC UI host’s MVC action).
      • The request has a Bearer token and the API pipeline has JWT bearer enabled.
    1. Validate issuer when using tunnels/custom domains
    • If the Issuer differs from the Authority (e.g., ngrok/public URL), add ValidIssuers to AuthServer settings and configure TokenValidationParameters.ValidIssuers accordingly.
    1. Common pitfalls that cause 401:
    • Missing API scope in the requested scopes of the Next.js client.
    • Wrong authority/issuer in Next.js OIDC config.
    • CORS not allowing your Next.js origin.
    • Access token expired and no refresh handling.
  • Minimal code example (server-side Next.js API route proxying to ABP API):

// /pages/api/me.ts
  import type { NextApiRequest, NextApiResponse } from 'next';

  export default async function handler(req: NextApiRequest, res: NextApiResponse) {
    const accessToken = req.headers['authorization']?.toString().replace(/^Bearer\s+/i, '');
    if (!accessToken) {
      return res.status(401).json({ error: 'No access token' });
    }

    const apiUrl = process.env.NEXT_PUBLIC_API_URL; // e.g. https://localhost:44350
    const r = await fetch(`${apiUrl}/api/identity/my-profile`, {
      headers: { Authorization: `Bearer ${accessToken}` }
    });

    if (!r.ok) {
      return res.status(r.status).send(await r.text());
    }
    return res.status(200).json(await r.json());
  }
  1. Sources
  • Support discussion about 401 vs login redirects and how API calls should use Authorization: Bearer:
    • https://abp.io/support/questions/611
  • Support discussion on 401 vs redirect behaviors in MVC and how requests differ:
    • https://abp.io/support/questions/3281
  • Community example showing attaching Bearer token and calling /api/identity/users:
    • https://abp.io/community/articles/aqjjwsdf
  • Community example showing getting tokens and posting to /connect/token (for reference on scopes/flows):
    • https://abp.io/community/articles/e74fmblw

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution In recent ABP versions, the static JavaScript API proxy global namespace and loading flow have changed. The old pattern like: var bangGiaVeNgayService = window.webCMS.kSVR.services.bangGiaVeNgays.bangGiaVeNgays; will no longer work unless your solution defines the same global namespace and generates the proxies into it.

Do this to make it work reliably in MVC Razor Pages:

  • Ensure static JS proxies are enabled and generated

    • In your Web project, add the Static JavaScript Proxy tag helper to your layout (once, typically in _Layout.cshtml, near the end of body): @await Html.PartialAsync("_AbpScripts")
    • Configure the proxy generation file abp-generate-proxy.json in the Web project (created by the template). Make sure:
      • target is set to jQuery
      • output folder is wwwroot/libs/proxy or your desired location
      • moduleName and remoteServiceName match your app service module and remote service. Example: { "type": "javascript", "module": "MyCompany.MyApp", "namespace": "myCompany.myApp", "source": { "type": "remote", "url": "https://localhost:44322", "remoteServiceName": "Default" }, "target": { "type": "jquery", "moduleName": "myCompany.myApp" }, "output": "wwwroot/libs/proxy" }
    • Run the proxy generation: abp generate-proxy or from VS Task Runner/ABP Suite if configured.
  • Use the new global namespace when calling APIs

    • The generated proxies are exposed under window.[namespace].[remoteServiceName].[service-alias].[method]
    • The default namespace is based on your configured "namespace" or "moduleName". For example, if you set namespace to myCompany.myApp and remoteServiceName to default (or your microservice name), you can call: // Example: app service BangGiaVeNgays in module MyCompany.MyApp, remoteServiceName: default var service = window.myCompany.myApp.default.bangGiaVeNgays.bangGiaVeNgays; service.getList({ /* params */ }) .then(res => console.log(res));
  • Verify the actual namespace at runtime

    • Open the browser console and type window to inspect the nested objects. Start from window.myCompany or your configured namespace to see what is actually generated (e.g., window.myCompany.myApp.default...).
    • If your older code expects window.webCMS.kSVR..., you must either:
      • Update your JS calls to the new path (recommended), or
      • Set "namespace" and "moduleName" in abp-generate-proxy.json to produce the same path structure you used before (e.g., namespace: webCMS.kSVR). Then regenerate the proxies.
  • Common pitfalls to check

    • The remote service host must be running when generating proxies from a remote source.
    • Make sure _AbpScripts partial is included once and after jQuery/abp.js are loaded.
    • Clear browser cache or use a cache-busting query string when testing (the template already appends _v=...).
    • For microservice solutions, you will have multiple remoteServiceName roots (e.g., identityService, cmsKit, default). Ensure you reference the correct one in the path: window.myCompany.myApp.identityService.... If it’s missing, either you didn’t generate the proxy for that microservice or the remoteServiceName differs from what you’re using in JS.
    • If you used dynamic proxies before, ensure you are not mixing dynamic and static references on the same page; pick one approach. When using dynamic proxies, use abp.services.app.* style, when static proxies, use the generated window.[namespace] path.
  • Minimal working example // 1) After correct proxy generation and layout setup: // window.myCompany.myApp.default.bangGiaVeNgays.bangGiaVeNgays.create({ ... }) window.myCompany.myApp.default.bangGiaVeNgays.bangGiaVeNgays .getList({ skipCount: 0, maxResultCount: 10 }) .then(result => console.log(result)) .catch(err => console.error(err));

Does the latest ABP still support calling services like before?

  • Yes, ABP still supports Static JavaScript API Client Proxies for MVC/Razor Pages. However, the generated object path under window depends on your configuration (namespace/moduleName/remoteServiceName). If you align those settings with your previous namespace, your old-style code can continue to work. Otherwise, update your JS to the new generated path as shown above.
  1. Sources
  • Static JavaScript Proxies (MVC/Razor Pages):
    • https://abp.io/docs/latest/framework/ui/mvc-razor-pages/static-javascript-proxies
  • Dynamic JavaScript Proxies (for comparison and migration):
    • https://abp.io/docs/latest/framework/ui/mvc-razor-pages/dynamic-javascript-proxies

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution Given you already inject the interface (ICrudAppService-based), the most common reasons Create/Update are not audited when called directly from Blazor Server are:
  • The call bypasses ABP’s interception pipeline. Checklist:

    • Ensure the concrete AppService methods are public and virtual (Castle proxy needs virtual).
    • Do not new-up the service or resolve it via ActivatorUtilities. Always resolve from DI and via the interface (you already do).
    • Make sure there is no decorator/wrapper that calls the implementation directly (e.g., a factory returning the concrete type).
  • Auditing middleware and options

    • Confirm app.UseAuditing() is added in the host OnApplicationInitialization:
public override void OnApplicationInitialization(ApplicationInitializationContext context)
    {
        var app = context.GetApplicationBuilder();
        app.UseAuditing();
    }
  • Keep auditing enabled and do not disable for your methods:
Configure<AbpAuditingOptions>(options =>
    {
        options.IsEnabled = true;
        // optional:
        // options.IsEnabledForGetRequests = true;
        // options.AlwaysLogOnException = true;
    });
  • Ensure you didn’t use [DisableAuditing] on the service or method.

  • Entity change logs require UoW + change tracking selection Create/Update “action logs” should appear even without entity changes, but if you expect EntityChanges, ensure:

    • You execute repository operations inside the app service call (ABP opens a UoW for app services).
    • You enabled entity change selectors (or used [Audited] on entities you want tracked):
Configure<AbpAuditingOptions>(options =>
    {
        options.EntityHistorySelectors.AddAllEntities(); // or add your entity types explicitly
    });
  • Your DbContext is not being saved outside ABP’s UoW unexpectedly.

  • Verify the proxy is actually used in Blazor Temporarily assert interception by forcing auditing:

[Audited]
  public class SeasonAppService : CrudAppService<Season, SeasonDto, Guid, PagedAndSortedResultRequestDto, CreateSeasonDto, UpdateSeasonDto>,
                                  ISeasonAppService
  {
      public override async Task<SeasonDto> CreateAsync(CreateSeasonDto input) { ... }
      public override async Task<SeasonDto> UpdateAsync(Guid id, UpdateSeasonDto input) { ... }
  }

If this still doesn’t create an audit log, interception is likely bypassed.

  • Method signature and virtual override Since you inherit from CrudAppService:
    • Override methods as public virtual and call base if needed:
public override async Task<SeasonDto> CreateAsync(CreateSeasonDto input)
    {
        return await base.CreateAsync(input);
    }

    public override async Task<SeasonDto> UpdateAsync(Guid id, UpdateSeasonDto input)
    {
        return await base.UpdateAsync(id, input);
    }

Do not seal the class or methods.

  • Avoid resolving the implementation behind the interface inside the same scope In Blazor components, keep only the interface injected:
[Inject] protected ISeasonAppService SeasonAppService { get; set; } = default!;

Do not cast to the concrete type or call non-virtual helpers on the class.

  • Custom IAuditingStore If you replaced IAuditingStore, ensure SaveAsync is called and not filtering out Create/Update. Log inside your store to verify it’s invoked for Create/Update paths.

  • Quick diagnostic

    • Add a simple [Audited] method with a primitive parameter on the same service and call it from the page. If no audit entry appears, the interceptor is not running for Blazor calls.
    • Log typeof(ISeasonAppService).FullName from the injected instance’s runtime type. If it’s Castle.Proxies.* it’s proxied; if it’s your concrete type, interception is bypassed.

If after all checks Delete is audited but Create/Update are not:

  • It’s often because Create/Update are not virtual (or overridden) in your derived service, or a [DisableAuditing] attribute is present via a base class/assembly-level. Make Create/Update public virtual in your SeasonAppService (even if they just call base) and try again.
  1. Sources
  • AbpAuditingOptions (source) (validated):
    • https://github.com/abpframework/abp/blob/dev/framework/src/Volo.Abp.Auditing/Volo/Abp/Auditing/AbpAuditingOptions.cs

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution The behavior you see is expected when you directly inject and call your Application Services from Blazor (server) components/pages. ABP’s method-level auditing and parameter serialization are applied by dynamic proxies (Castle interceptors). When you resolve and call a class directly (not via its proxied interface), or you call it from a scope that suppresses the auditing pipeline, the interceptor doesn’t run, so:
  • Get/List (GET) may still appear in logs depending on AbpAuditingOptions (e.g., IsEnabledForGetRequests=true);
  • Delete(Guid) may be logged because the service was resolved via its interface or another code path with a proxy;
  • Create/Update with DTO parameters won’t be logged if the proxy is bypassed (no parameter serialization, no audit action, no entity change capture).

Fixes (apply all that match your case):

  • Always depend on and inject the interface, not the concrete class. The proxy is generated on the interface service. Example:
public partial class MyPage : ComponentBase
  {
      // Good: inject the interface that inherits IApplicationService
      [Inject] private IMyEntityAppService MyEntityAppService { get; set; } = default!;

      private async Task SaveAsync(CreateMyEntityDto input)
      {
          await MyEntityAppService.CreateAsync(input); // audited by proxy
      }
  }

Ensure your interface implements IApplicationService:

public interface IMyEntityAppService : IApplicationService
  {
      Task<MyEntityDto> CreateAsync(CreateMyEntityDto input);
      Task<MyEntityDto> UpdateAsync(Guid id, UpdateMyEntityDto input);
      Task DeleteAsync(Guid id);
      Task<PagedResultDto<MyEntityDto>> GetListAsync(PagedAndSortedResultRequestDto input);
  }
  • Do not inject the concrete class into the Blazor page/component. If you must access implementation-only members, expose them via the interface or use a domain service behind the app service.

  • Ensure auditing is enabled for app service methods:

    • AbpAuditingOptions.IsEnabled = true (default).
    • If you want GETs too, set IsEnabledForGetRequests = true.
    • Do not decorate Create/Update with [DisableAuditing].
    • If you have custom contributors or stores, keep options.HideErrors true so audit pipeline continues on failures. Example:
Configure<AbpAuditingOptions>(options =>
  {
      options.IsEnabled = true;
      options.IsEnabledForGetRequests = true; // optional
      options.AlwaysLogOnException = true;
      // Track entity changes if needed:
      options.EntityHistorySelectors.AddAllEntities();
  });
  • Use app.UseAuditing() in the host startup (so request-level data is collected). In ABP module:
public override void OnApplicationInitialization(ApplicationInitializationContext context)
  {
      var app = context.GetApplicationBuilder();
      app.UseAuditing();
  }
  • Ensure the UoW is active and SaveChanges happens inside the same call so EntityChange logs are produced. Using standard repositories inside application services with ABP’s UnitOfWork ensures that. Avoid calling repositories outside of an app-service/UoW boundary.

  • Confirm you are not suppressing interceptors:

    • Don’t resolve services from a created instance via ActivatorUtilities or newing up the class; always resolve via DI.
    • Don’t mark the app service as non-virtual; ABP’s dynamic proxy requires virtual methods. App service methods should be virtual (default in templates).
    • Keep the class public.
  • If you have replaced IAuditingStore or use a remote store, ensure SaveAsync is called; check logs of your auditing store.

  • Quick verification

    • Put a breakpoint/log inside your app service CreateAsync/UpdateAsync and verify it’s called via proxy: you should see serialized parameters in the audit log later and method is virtual.
    • Temporarily add [Audited] on the app service class or methods to force-enable:
[Audited]
    public class MyEntityAppService : ApplicationService, IMyEntityAppService
    {
        public virtual async Task<MyEntityDto> CreateAsync(CreateMyEntityDto input) { ... }
    }

If you instead prefer calling over HTTP even from Blazor Server, you can inject the dynamic C# client (HttpApi.Client) for the same interface. That path always goes through the server pipeline and auditing.

  1. Sources
  • ABP Auditing options (source code reference for options type):
    • https://github.com/abpframework/abp/blob/dev/framework/src/Volo.Abp.Auditing/Volo/Abp/Auditing/AbpAuditingOptions.cs

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution
  • The “Blob error 404” means that the package for that exact path does not exist on the download feed. For ABP Studio 1.4.2, both beta and release “full.nupkg” endpoints you tried are currently not available on the public feed, so direct downloading via the old script will fail.
  • Use one of the following verified approaches to create a project with ABP 9.3.6:

A) Use the official Version Mapping inside ABP Studio (recommended)

  • Install and open ABP Studio (any working version you have).
  • New Solution wizard automatically selects the template version based on the Studio version you are running (per the mapping).
  • To target ABP 9.3.6, you need ABP Studio 1.4.2. Since the public URL package is not available, switch to a Studio version whose package exists on the feed and that maps to the same (or desired) ABP version using the Studio’s built-in update mechanism:
    • In Studio: Help -> Check for Updates, and choose a version that maps to your target ABP version per the version mapping page.
    • If 1.4.2 is not offered, pick the nearest Studio version that maps to ABP 9.3.x. Then create the solution and, if needed, downgrade/lock template packages via ABP Studio CLI or NuGet after creation to 9.3.6 (template-generated solutions can be pinned by setting the Volo.Abp.* package versions in Directory.Packages.props).

B) Use the supported “switch version” script pattern but only with existing packages

  • The previously shared PowerShell script works only if the targeted nupkg actually exists.
  • First, check if the package exists before download. Example script (adds existence check and fails clearly):
param (
  [string]$version = "1.4.2",
  [string]$channel = "release"
)

$installdir = "$env:LOCALAPPDATA\abp-studio\"
$file = "abp-studio-$version-$channel-full.nupkg"
$url = "https://abp.io/api/abp-studio/r/download/windows/$file"  # note the '/r/download/windows' path used by the official updater logs
$pkgDir = "$installdir\packages"
$outputPath = Join-Path $pkgDir $file

Write-Host "Installing to $installdir"
if (-not (Test-Path $pkgDir)) { New-Item -ItemType Directory -Path $pkgDir -Force | Out-Null }

try {
  $resp = Invoke-WebRequest -Uri $url -Method Head -UseBasicParsing -ErrorAction Stop
} catch {
  Write-Error "Package not found on feed: $url. Please choose another Studio version present on the feed."
  exit 1
}

if (-not (Test-Path $outputPath)) {
  Write-Host "Downloading $url to $outputPath"
  Invoke-WebRequest -Uri $url -OutFile $outputPath -UseBasicParsing
} else {
  Write-Host "File already present: $outputPath"
}

$updateExe = Join-Path $installdir "Update.exe"
Write-Host "Applying package..."
& $updateExe apply --package $outputPath
Write-Host "Done."
  • Important differences:
    • Uses /api/abp-studio/r/download/windows (the path used by the built-in updater) rather than /download/r/windows.
    • Performs a HEAD check before download and stops if the package doesn’t exist.
  • If 1.4.2 is still missing, select a Studio version close to 1.4.2 that is available on the feed and maps to ABP 9.3.x, create the solution, and pin packages to 9.3.6 after creation.

C) Use ABP Studio CLI aligned to 9.3.6

  • If Studio’s package is not available but you only need to generate the template, install the corresponding ABP Studio CLI version that maps to ABP 9.3.6 and generate the solution from the terminal. Then open the generated solution in your current Studio.
  • If Studio updates your CLI automatically, disable auto-update and/or install the CLI separately under a custom tool path, then call it directly to keep the version pinned.

Notes

  • Given the public feed currently returns 404 for abp-studio-1.4.2-{beta|release}-full.nupkg, the direct link approach won’t work until that package is published again. The supported way is to pick a Studio version that exists on the feed and maps to the desired ABP version, or generate with a matching CLI and pin package versions to 9.3.6.
  1. Sources
  • Version mapping between ABP Studio and ABP template versions:
    • https://abp.io/docs/latest/studio/version-mapping
  • Community Q&A showing the version-switch script pattern:
    • https://abp.io/support/questions/8627/Install-specific-version-of-ABP-Studio#answer-3a17775e-701a-1b24-6604-8bc0622ac518

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution
  • ABP Studio 1.4.2 is the correct Studio version to generate solutions with ABP 9.3.6 (per the official mapping).

  • The 404 happens because the package name you’re trying to download is wrong. Studio 1.4.2 is a stable release, not beta. Use the stable “release” channel package name:

    • File name pattern: abp-studio-{version}-release-full.nupkg
    • Correct URL for 1.4.2 (Windows): https://abp.io/api/abp-studio/download/r/windows/abp-studio-1.4.2-release-full.nupkg
  • Quick fix for the script:

    • In the switch-abp-studio-version.ps1 you used, replace the channel segment from beta to release.
    • Minimal working script (Windows PowerShell):
param (
      [string]$version = "1.4.2",
      [string]$channel = "release"
  )
  $installdir = "$env:LOCALAPPDATA\abp-studio\"
  Write-Host "Installing to $installdir"

  $file = "abp-studio-$version-$channel-full.nupkg"
  $url = "https://abp.io/api/abp-studio/download/r/windows/$file"
  $outputPath = "$installdir\packages\$file"

  if (-not (Test-Path $installdir)) { New-Item -ItemType Directory -Path $installdir -Force | Out-Null }
  if (-not (Test-Path "$installdir\packages")) { New-Item -ItemType Directory -Path "$installdir\packages" -Force | Out-Null }

  if (Test-Path $outputPath) {
      Write-Host "File $file already exists. Skipping download."
  } else {
      Write-Host "Downloading $url to $outputPath"
      Invoke-WebRequest -Uri $url -OutFile $outputPath
  }

  $updateExe = "$installdir\Update.exe"
  Write-Host "Running $updateExe apply --package $outputPath"
  & $updateExe apply --package $outputPath

  Write-Host "ABP Studio version $version ($channel) installed successfully."
  • After installation:

    1. Start ABP Studio 1.4.2.
    2. Create a new solution (Angular UI, Tiered, PostgreSQL as you need). The generated solution will target ABP 9.3.6 automatically because 1.4.2 maps to 9.3.6.
    3. If needed, you can later update the created solution using ABP Studio or ABP CLI, but for your case you want to stay on 9.3.6.
  • Alternative (without Studio UI): You can also use ABP Studio CLI of that version to create the project in a CI/terminal environment. Ensure the Studio CLI version aligns with 1.4.2 (bundled with Studio), then run abp new with your template options. However, using the Studio UI 1.4.2 is simpler since it already binds to 9.3.6.

  1. Sources
  • ABP Studio and ABP Startup Template Version Mappings:
    • https://abp.io/docs/latest/studio/version-mapping
  • Community QA: Install specific version of ABP Studio (includes the version switch script and usage):
    • https://abp.io/support/questions/8627/Install-specific-version-of-ABP-Studio#answer-3a17775e-701a-1b24-6604-8bc0622ac518

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution
  • What you’re seeing is the hash (“/#”) at the end of the URL when clicking the “Home” menu item in Blazor Server after upgrading to ABP v10. This comes from the menu item’s Url being empty (or “/”) while the rendered anchor uses a fallback “#” (hash) to avoid navigation. In ABP v10’s LeptonX Blazor menu component, a leaf item with a null/empty Url is rendered with “#”, which changes the browser URL to “/#” but still keeps you on the home page.
  • Fix options:
    1. Set an explicit Url for the Home menu item to “/” (root), so the anchor doesn’t fall back to “#”.
      • If you add Home via menu contributor:
context.Menu.AddItem(
         new ApplicationMenuItem(
           "MyHome",
           "Home",
           url: "/",
           icon: "fa fa-home",
           order: 0
         )
       );
 - If you customize the built-in Home item, ensure its Url is “/” (not null/empty).
  1. If you have customized the LeptonX side menu component (MainMenuItem.razor) and kept the fallback behavior, adjust it so that the fallback uses “/” instead of “#”:
var url = string.IsNullOrWhiteSpace(MenuItem.MenuItem.Url)
       ? "/"
       : MenuItem.MenuItem.Url.TrimStart('/', '~');
  1. If you do not explicitly register a Home item, create one with Url “/” so navigation uses a proper path instead of hash.
  • After the change, restart the app and verify that clicking “Home” results in “https://localhost:port/” (no “/#”), and your custom code relying on clean URLs will work again.
  1. Sources
  • Blazor UI routing basics (ABP uses Blazor’s router): https://abp.io/docs/latest/framework/ui/blazor/routing

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

  1. Solution The error “Cannot read properties of undefined (reading 'KSVR')” means the dynamic JavaScript proxy object for your module/remote-service name is not being created on the page. In ABP MVC/Razor Pages (v10), these proxies appear under window.<rootNamespace>.<remoteServiceName> (e.g., window.webCMS.KSVR.services...) only when:
  • the dynamic proxy script is enabled and loaded on the page,
  • the remote service/app service is exposed (controller has [RemoteService] enabled),
  • the HttpApi (or HttpApi.Host in tiered) is reachable for proxy discovery,
  • the name you use in JS matches your actual RootNamespace and RemoteService name.

Verify and fix with the checklist below.

A) Ensure dynamic JS proxy is enabled

  • In your Web (UI) module, check ConfigureServices:
Configure<AbpAspNetCoreMvcOptions>(options =>
  {
      options.ConventionalControllers.Create(typeof(KSVRApplicationModule).Assembly);
  });

  Configure<AbpAspNetCoreMvcClientProxyOptions>(options =>
  {
      // default is dynamic proxies ON; ensure not disabled globally
      // options.DisableAbpDynamicProxyScript = false; // only if you had set it true somewhere
  });
  • If you previously disabled dynamic proxies, remove that config or set it back to enabled.

B) Load the dynamic proxy script on the page

  • In Razor Pages layout (Pages/_Layout.cshtml) or the specific page, include the ABP dynamic proxy bundle AFTER abp.js and before your page’s index.js:
<script src="~/Abp/ApplicationConfigurationScript"></script>
  <script src="~/Abp/ServiceProxyScript"></script>
  <script src="~/libs/jquery/jquery.js"></script>
  <script src="~/libs/bootstrap/js/bootstrap.bundle.min.js"></script>
  <!-- ... other abp libs -->
  <script src="~/Pages/BangGiaVeNgays/index.js"></script>
  • Make sure index.js runs after ServiceProxyScript; otherwise window.<rootNamespace>.* will be undefined.

C) Confirm correct Root Namespace in JS

  • Find your solution’s Root Namespace (e.g., WebCMS). The dynamic object path is: window.<rootNamespace>.<remoteServiceName>.services.<moduleOrGroup>.<service>
  • In your screenshot, you use:
var bangGiaVeNgayService = window.webCMS.KSVR.services.bangGiaVeNgays.bangGiaVeNgays;

This will only work if:

  • Root namespace is webCMS (case sensitive: it should match the C# root namespace; typically PascalCase, e.g., WebCMS).
  • RemoteServiceName is “KSVR” on the controller/service.
  • If your root namespace is “KSVR” or “WebCMS” with different casing, fix the path accordingly, e.g.:
    • window.WebCMS.KSVR.services...
    • or window.KSVR.Default.services... (if remote service name is Default)

D) Ensure your AppService is exposed to HTTP (so proxy can be generated)

  • Your Application Service must be discoverable by controller generation and marked as remote service:
[RemoteService(true)]
  public class BangGiaVeNgayAppService : ApplicationService, IBangGiaVeNgayAppService
  {
      // ...
  }
  • Or on the assembly/module, you already configure ConventionalControllers.Create; ensure the assembly containing the controller is passed.

E) If it’s a tiered setup (Auth Server separated)

  • The Web (UI) app must be able to fetch proxy metadata from the HttpApi.Host (or Gateway). Configure RemoteServices in appsettings.json of the Web project so the dynamic proxy script knows where to reach:
"RemoteServices": {
    "Default": {
      "BaseUrl": "https://localhost:443xx" // your HttpApi.Host
    }
  }
  • If your remote service name is “KSVR” (not Default), configure its endpoint too (or ensure it maps to the Default remote):
"RemoteServices": {
    "Default": {
      "BaseUrl": "https://localhost:443xx"
    },
    "KSVR": {
      "BaseUrl": "https://localhost:443xx"
    }
  }
  • Run the HttpApi.Host and confirm it’s reachable from the browser (no CORS/ auth issues) so ServiceProxyScript can be built.

F) Confirm the final JS object path

  • Open the browser console after the page loads and run:
    • Object.keys(window)
    • window.WebCMS or window.webCMS (check which exists)
    • window.WebCMS.KSVR or window.WebCMS.Default
    • Expand to services.* to see the generated services and exact names.
  • Correct your index.js to the real, existing path and pay attention to name pluralization (Suite usually generates plural group names, e.g., bangGiaVeNgays).

G) Common pitfalls to fix

  • Wrong casing of root namespace in JS (use the exact C# root namespace as created by your solution).
  • Not loading ServiceProxyScript before your page script.
  • AppService not included in conventional controller generation (wrong assembly).
  • RemoteServiceName mismatch (JS uses KSVR but server uses Default, or vice versa).
  • In a tiered solution, RemoteServices BaseUrl not set or HttpApi.Host not running.
  • If you switched to static JS proxies, you must serve the generated static file; but Suite’s Razor Pages use dynamic proxies by default—keep them enabled for simplicity.

Once the above are corrected, the line like below should work without error:

var l = abp.localization.getResource('KSVR');
var bangGiaVeNgayService = window.WebCMS.KSVR.services.bangGiaVeNgays.bangGiaVeNgays;

bangGiaVeNgayService.getList({ filter: '...' }).then(res => {
  // ...
});
  1. Sources
  • https://abp.io/docs/latest/framework/ui/mvc-razor-pages/javascript-api/
  • https://abp.io/support/questions/7434
  • https://abp.io/support/questions/8751

This response was generated by AI. If it didn’t solve your problem, feel free to post a new answer — our support team will jump in to help you soon.

Showing 21 to 30 of 716 entries
Boost Your Development
ABP Live Training
Packages
See Trainings
Mastering ABP Framework Book
The Official Guide
Mastering
ABP Framework
Learn More
Mastering ABP Framework Book
Made with ❤️ on ABP v10.1.0-preview. Updated on December 16, 2025, 09:09
1
ABP Assistant
🔐 You need to be logged in to use the chatbot. Please log in first.