Merge upstream main into account chart click fix

CHANGELOG.md

@@ -5,6 +5,86 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 3.11.0 - 2026-06-14
+
+### Added
+
+- Added support for a click handler in the page tabs component
+
+### Changed
+
+- Improved the styling of the tabs across various dialogs
+- Improved the styling of the page tabs component on desktop
+- Enabled the _Bull Dashboard_ tab in the admin control panel (experimental)
+- Migrated the settings dialog to customize the rule thresholds of the _X-ray_ page from `ngModel` to form control
+- Improved the language localization for Spanish (`es`)
+- Upgraded `bull-board` from version `7.1.5` to `7.2.1`
+- Upgraded `date-fns` from version `4.1.0` to `4.4.0`
+
+### Fixed
+
+- Improved the loading state when customizing the rule thresholds on the _X-ray_ page
+
+## 3.10.0 - 2026-06-13
+
+### Changed
+
+- Improved the dynamic numerical precision for various values in the account detail dialog on mobile
+- Improved the dynamic numerical precision for various values in the holding detail dialog on mobile
+- Improved the account name display in the activities table
+- Optimized the endpoint `GET api/v1/portfolio/holding/:dataSource/:symbol` by improving the processing of the historical market data
+
+### Fixed
+
+- Fixed an issue in the import dividends dialog
+- Fixed an issue where certain symbols were incorrectly identified as currencies in various data providers
+- Fixed the last request date in the users table of the admin control panel
+
+## 3.9.0 - 2026-06-12
+
+### Added
+
+- Extended the _Public API_ with the endpoint to update the asset profile data (`PATCH api/v1/asset-profiles/:dataSource/:symbol`) (experimental)
+- Added support for a dedicated _OpenRouter_ model for the `web_fetch` tool in the `FetchService`
+
+### Changed
+
+- Prefilled the form in the account balance management with the current cash balance
+- Disabled the selection of future dates in the account balance management
+- Grouped commodities and cryptocurrencies into the unknown bucket of the allocations by continent, country, currency, market and sector charts on the allocations page
+- Moved the support for specific calendar year date ranges (`2025`, `2024`, `2023`, etc.) in the assistant from experimental to general availability
+- Migrated various components from `NgStyle` to style bindings
+- Improved the language localization for Korean (`ko`)
+
+### Fixed
+
+- Grouped activities without an account into the unknown bucket of the allocations by account and platform charts on the allocations page
+
+## 3.8.0 - 2026-06-07
+
+### Added
+
+- Added an automatic refresh every 30 seconds to the users table in the admin control panel
+
+### Changed
+
+- Harmonized the sector names across the data providers
+- Localized the country names
+- Localized the sector names
+- Centralized the asset profile override logic for manual adjustments
+- Improved the styling in the user detail dialog of the admin control panel’s users section
+- Prevented the deletion of asset profiles that are currently in use
+- Ensured market data is correctly removed when an asset profile with no remaining activities is deleted
+- Refactored the backend logging to use the instance-based `Logger`
+- Improved the language localization for German (`de`)
+- Improved the language localization for Ukrainian (`uk`)
+
+### Fixed
+
+- Prevented the floating action button from overlapping the paginator on mobile
+- Fixed an issue where the asset profile override (asset class and asset sub class) was not applied to the data enhancers when gathering asset profiles
+- Fixed a layout issue in the asset profile dialog of the admin control panel by truncating long titles
+
 ## 3.7.0 - 2026-06-02
 
 ### Added

README.md

@@ -302,6 +302,58 @@ Grant access of type _Public_ in the _Access_ tab of _My Ghostfolio_.
 }
 ```
 
+### Update Asset Profile Data (experimental)
+
+#### Prerequisites
+
+[Bearer Token](#authorization-bearer-token) for authorization with admin role
+
+#### Request
+
+`PATCH http://localhost:3333/api/v1/asset-profiles/<INSERT_DATA_SOURCE>/<INSERT_SYMBOL>`
+
+#### Body
+
+```
+{
+  "countries": [
+    {
+      "code": "US",
+      "weight": 1
+    }
+  ],
+  "sectors": [
+    {
+      "name": "Technology",
+      "weight": 1
+    }
+  ]
+}
+```
+
+| Field       | Type               | Description                                                            |
+| ----------- | ------------------ | ---------------------------------------------------------------------- |
+| `countries` | `array` (optional) | Countries with `code` (`ISO 3166-1 alpha-2`) and `weight` (`0` to `1`) |
+| `holdings`  | `array` (optional) | Holdings with `name` and `weight` (`0` to `1`)                         |
+| `sectors`   | `array` (optional) | Sectors with `name` and `weight` (`0` to `1`)                          |
+
+#### Response
+
+##### Success
+
+`200 OK`
+
+##### Error
+
+`404 Not Found`
+
+```
+{
+  "error": "Not Found",
+  "message": "Could not find the asset profile for MSFT (YAHOO)"
+}
+```
+
 ## Community Projects
 
 Discover a variety of community projects for Ghostfolio: https://github.com/topics/ghostfolio

apps/api/src/app/activities/activities.module.ts

@@ -6,9 +6,11 @@ import { RedactValuesInResponseModule } from '@ghostfolio/api/interceptors/redac
 import { TransformDataSourceInRequestModule } from '@ghostfolio/api/interceptors/transform-data-source-in-request/transform-data-source-in-request.module';
 import { TransformDataSourceInResponseModule } from '@ghostfolio/api/interceptors/transform-data-source-in-response/transform-data-source-in-response.module';
 import { ApiModule } from '@ghostfolio/api/services/api/api.module';
+import { BenchmarkModule } from '@ghostfolio/api/services/benchmark/benchmark.module';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
 import { ImpersonationModule } from '@ghostfolio/api/services/impersonation/impersonation.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data/market-data.module';
 import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
 import { DataGatheringQueueModule } from '@ghostfolio/api/services/queues/data-gathering/data-gathering.module';
 import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.module';
@@ -23,11 +25,13 @@ import { ActivitiesService } from './activities.service';
   exports: [ActivitiesService],
   imports: [
     ApiModule,
+    BenchmarkModule,
     CacheModule,
     DataGatheringQueueModule,
     DataProviderModule,
     ExchangeRateDataModule,
     ImpersonationModule,
+    MarketDataModule,
     PrismaModule,
     RedactValuesInResponseModule,
     RedisCacheModule,

apps/api/src/app/activities/activities.service.ts

@@ -4,8 +4,10 @@ import { CashDetails } from '@ghostfolio/api/app/account/interfaces/cash-details
 import { AssetProfileChangedEvent } from '@ghostfolio/api/events/asset-profile-changed.event';
 import { PortfolioChangedEvent } from '@ghostfolio/api/events/portfolio-changed.event';
 import { LogPerformance } from '@ghostfolio/api/interceptors/performance-logging/performance-logging.interceptor';
+import { BenchmarkService } from '@ghostfolio/api/services/benchmark/benchmark.service';
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data/market-data.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
 import { DataGatheringService } from '@ghostfolio/api/services/queues/data-gathering/data-gathering.service';
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
@@ -16,7 +18,10 @@ import {
   ghostfolioPrefix,
   TAG_ID_EXCLUDE_FROM_ANALYSIS
 } from '@ghostfolio/common/config';
-import { getAssetProfileIdentifier } from '@ghostfolio/common/helper';
+import {
+  canDeleteAssetProfile,
+  getAssetProfileIdentifier
+} from '@ghostfolio/common/helper';
 import {
   ActivitiesResponse,
   Activity,
@@ -48,10 +53,12 @@ export class ActivitiesService {
   public constructor(
     private readonly accountBalanceService: AccountBalanceService,
     private readonly accountService: AccountService,
+    private readonly benchmarkService: BenchmarkService,
     private readonly dataGatheringService: DataGatheringService,
     private readonly dataProviderService: DataProviderService,
     private readonly eventEmitter: EventEmitter2,
     private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly marketDataService: MarketDataService,
     private readonly prismaService: PrismaService,
     private readonly symbolProfileService: SymbolProfileService
   ) {}
@@ -262,7 +269,26 @@ export class ActivitiesService {
         activity.symbolProfileId
       ]);
 
-    if (symbolProfile.activitiesCount === 0) {
+    const benchmarkAssetProfiles =
+      await this.benchmarkService.getBenchmarkAssetProfiles();
+
+    const isBenchmark = benchmarkAssetProfiles.some(({ id }) => {
+      return id === symbolProfile.id;
+    });
+
+    if (
+      canDeleteAssetProfile({
+        isBenchmark,
+        activitiesCount: symbolProfile.activitiesCount,
+        symbol: symbolProfile.symbol,
+        watchedByCount: symbolProfile.watchedByCount
+      })
+    ) {
+      await this.marketDataService.deleteMany({
+        dataSource: symbolProfile.dataSource,
+        symbol: symbolProfile.symbol
+      });
+
       await this.symbolProfileService.deleteById(activity.symbolProfileId);
     }
 
@@ -308,8 +334,31 @@ export class ActivitiesService {
         })
       );
 
-    for (const { activitiesCount, id } of symbolProfiles) {
+    const benchmarkAssetProfiles =
-      if (activitiesCount === 0) {
+      await this.benchmarkService.getBenchmarkAssetProfiles();
+
+    for (const {
+      activitiesCount,
+      dataSource,
+      id,
+      symbol,
+      watchedByCount
+    } of symbolProfiles) {
+      const isBenchmark = benchmarkAssetProfiles.some(
+        (benchmarkAssetProfile) => {
+          return benchmarkAssetProfile.id === id;
+        }
+      );
+
+      if (
+        canDeleteAssetProfile({
+          activitiesCount,
+          isBenchmark,
+          symbol,
+          watchedByCount
+        })
+      ) {
+        await this.marketDataService.deleteMany({ dataSource, symbol });
         await this.symbolProfileService.deleteById(id);
       }
     }

apps/api/src/app/admin/admin.controller.ts

@@ -2,9 +2,11 @@ import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorat
 import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
 import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request/transform-data-source-in-request.interceptor';
 import { ApiService } from '@ghostfolio/api/services/api/api.service';
+import { BenchmarkService } from '@ghostfolio/api/services/benchmark/benchmark.service';
 import { ManualService } from '@ghostfolio/api/services/data-provider/manual/manual.service';
 import { DemoService } from '@ghostfolio/api/services/demo/demo.service';
 import { DataGatheringService } from '@ghostfolio/api/services/queues/data-gathering/data-gathering.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
 import { getIntervalFromDateRange } from '@ghostfolio/common/calculation-helper';
 import {
   DATA_GATHERING_QUEUE_PRIORITY_HIGH,
@@ -16,7 +18,10 @@ import {
   UpdateAssetProfileDto,
   UpdatePropertyDto
 } from '@ghostfolio/common/dtos';
-import { getAssetProfileIdentifier } from '@ghostfolio/common/helper';
+import {
+  canDeleteAssetProfile,
+  getAssetProfileIdentifier
+} from '@ghostfolio/common/helper';
 import {
   AdminData,
   AdminMarketData,
@@ -58,13 +63,17 @@ import { AdminService } from './admin.service';
 
 @Controller('admin')
 export class AdminController {
+  private readonly logger = new Logger(AdminController.name);
+
   public constructor(
     private readonly adminService: AdminService,
     private readonly apiService: ApiService,
+    private readonly benchmarkService: BenchmarkService,
     private readonly dataGatheringService: DataGatheringService,
     private readonly demoService: DemoService,
     private readonly manualService: ManualService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
+    @Inject(REQUEST) private readonly request: RequestWithUser,
+    private readonly symbolProfileService: SymbolProfileService
   ) {}
 
   @Get()
@@ -260,7 +269,7 @@ export class AdminController {
         `Could not parse the market price for ${symbol} (${dataSource})`
       );
     } catch (error) {
-      Logger.error(error, 'AdminController');
+      this.logger.error(error);
 
       throw new HttpException(error.message, StatusCodes.BAD_REQUEST);
     }
@@ -288,6 +297,33 @@ export class AdminController {
     @Param('dataSource') dataSource: DataSource,
     @Param('symbol') symbol: string
   ): Promise<void> {
+    const [assetProfile] = await this.symbolProfileService.getSymbolProfiles([
+      { dataSource, symbol }
+    ]);
+
+    if (assetProfile) {
+      const benchmarkAssetProfiles =
+        await this.benchmarkService.getBenchmarkAssetProfiles();
+
+      const isBenchmark = benchmarkAssetProfiles.some(({ id }) => {
+        return id === assetProfile.id;
+      });
+
+      if (
+        !canDeleteAssetProfile({
+          isBenchmark,
+          activitiesCount: assetProfile.activitiesCount,
+          symbol: assetProfile.symbol,
+          watchedByCount: assetProfile.watchedByCount
+        })
+      ) {
+        throw new HttpException(
+          getReasonPhrase(StatusCodes.FORBIDDEN),
+          StatusCodes.FORBIDDEN
+        );
+      }
+    }
+
     return this.adminService.deleteProfileData({ dataSource, symbol });
   }
 

apps/api/src/app/admin/admin.service.ts

@@ -14,6 +14,7 @@ import {
   PROPERTY_IS_USER_SIGNUP_ENABLED
 } from '@ghostfolio/common/config';
 import {
+  applyAssetProfileOverrides,
   getAssetProfileIdentifier,
   getCurrencyFromSymbol,
   isCurrency
@@ -29,7 +30,6 @@ import {
   EnhancedSymbolProfile,
   Filter
 } from '@ghostfolio/common/interfaces';
-import { Sector } from '@ghostfolio/common/interfaces/sector.interface';
 import { MarketDataPreset } from '@ghostfolio/common/types';
 
 import {
@@ -349,87 +349,61 @@ export class AdminService {
     }
 
     let marketData: AdminMarketDataItem[] = await Promise.all(
-      assetProfiles.map(
+      assetProfiles.map(async (assetProfile) => {
-        async ({
+        const {
           _count,
           activities,
-          assetClass,
-          assetSubClass,
           comment,
-          countries,
           currency,
           dataSource,
           id,
           isActive,
           isUsedByUsersWithSubscription,
-          name,
+          symbol
-          sectors,
+        } = assetProfile;
-          symbol,
-          SymbolProfileOverrides
-        }) => {
-          let countriesCount = countries ? Object.keys(countries).length : 0;
 
-          const lastMarketPrice = lastMarketPriceMap.get(
+        const { assetClass, assetSubClass, countries, name, sectors } =
-            getAssetProfileIdentifier({ dataSource, symbol })
+          applyAssetProfileOverrides(
+            assetProfile,
+            assetProfile.SymbolProfileOverrides
           );
 
-          const marketDataItemCount =
+        const countriesCount = countries ? Object.keys(countries).length : 0;
-            marketDataItems.find((marketDataItem) => {
-              return (
-                marketDataItem.dataSource === dataSource &&
-                marketDataItem.symbol === symbol
-              );
-            })?._count ?? 0;
-
-          let sectorsCount = sectors ? Object.keys(sectors).length : 0;
-
-          if (SymbolProfileOverrides) {
-            assetClass = SymbolProfileOverrides.assetClass ?? assetClass;
-            assetSubClass =
-              SymbolProfileOverrides.assetSubClass ?? assetSubClass;
-
-            if (
-              (SymbolProfileOverrides.countries as unknown as Prisma.JsonArray)
-                ?.length > 0
-            ) {
-              countriesCount = (
-                SymbolProfileOverrides.countries as unknown as Prisma.JsonArray
-              ).length;
-            }
 
-            name = SymbolProfileOverrides.name ?? name;
+        const lastMarketPrice = lastMarketPriceMap.get(
+          getAssetProfileIdentifier({ dataSource, symbol })
+        );
 
-            if (
+        const marketDataItemCount =
-              (SymbolProfileOverrides.sectors as unknown as Sector[])?.length >
+          marketDataItems.find((marketDataItem) => {
-              0
+            return (
-            ) {
+              marketDataItem.dataSource === dataSource &&
-              sectorsCount = (
+              marketDataItem.symbol === symbol
-                SymbolProfileOverrides.sectors as unknown as Prisma.JsonArray
+            );
-              ).length;
+          })?._count ?? 0;
-            }
-          }
 
-          return {
+        const sectorsCount = sectors ? Object.keys(sectors).length : 0;
-            assetClass,
+
-            assetSubClass,
+        return {
-            comment,
+          assetClass,
-            countriesCount,
+          assetSubClass,
-            currency,
+          comment,
-            dataSource,
+          countriesCount,
-            id,
+          currency,
-            isActive,
+          dataSource,
-            lastMarketPrice,
+          id,
-            marketDataItemCount,
+          isActive,
-            name,
+          lastMarketPrice,
-            sectorsCount,
+          marketDataItemCount,
-            symbol,
+          name,
-            activitiesCount: _count.activities,
+          sectorsCount,
-            date: activities?.[0]?.date,
+          symbol,
-            isUsedByUsersWithSubscription: await isUsedByUsersWithSubscription,
+          activitiesCount: _count.activities,
-            watchedByCount: _count.watchedBy
+          date: activities?.[0]?.date,
-          };
+          isUsedByUsersWithSubscription: await isUsedByUsersWithSubscription,
-        }
+          watchedByCount: _count.watchedBy
-      )
+        };
+      })
     );
 
     if (presetId) {
@@ -619,6 +593,7 @@ export class AdminService {
         assetClass: assetClass as AssetClass,
         assetSubClass: assetSubClass as AssetSubClass,
         countries: countries as Prisma.JsonArray,
+        holdings: holdings as Prisma.JsonArray,
         name: name as string,
         sectors: sectors as Prisma.JsonArray,
         url: url as string
@@ -628,21 +603,14 @@ export class AdminService {
         comment,
         currency,
         dataSource,
-        holdings,
         isActive,
         scraperConfiguration,
         symbol,
         symbolMapping,
-        ...(dataSource === 'MANUAL'
+        ...this.symbolProfileService.getAssetProfileUpdateInput(
-          ? { assetClass, assetSubClass, countries, name, sectors, url }
+          { dataSource, symbol },
-          : {
+          symbolProfileOverrides
-              SymbolProfileOverrides: {
+        )
-                upsert: {
-                  create: symbolProfileOverrides,
-                  update: symbolProfileOverrides
-                }
-              }
-            })
       };
 
       await this.symbolProfileService.updateSymbolProfile(
@@ -882,7 +850,7 @@ export class AdminService {
             activityCount: true,
             country: true,
             dataProviderGhostfolioDailyRequests: true,
-            updatedAt: true
+            lastRequestAt: true
           }
         },
         createdAt: true,
@@ -928,7 +896,7 @@ export class AdminService {
           activityCount: _count.activities || 0,
           country: analytics?.country,
           dailyApiRequests: analytics?.dataProviderGhostfolioDailyRequests || 0,
-          lastActivity: analytics?.updatedAt
+          lastActivity: analytics?.lastRequestAt
         };
       }
     );

apps/api/src/app/app.module.ts

@@ -38,6 +38,7 @@ import { AuthModule } from './auth/auth.module';
 import { CacheModule } from './cache/cache.module';
 import { AiModule } from './endpoints/ai/ai.module';
 import { ApiKeysModule } from './endpoints/api-keys/api-keys.module';
+import { AssetProfilesModule } from './endpoints/asset-profiles/asset-profiles.module';
 import { AssetsModule } from './endpoints/assets/assets.module';
 import { BenchmarksModule } from './endpoints/benchmarks/benchmarks.module';
 import { GhostfolioModule } from './endpoints/data-providers/ghostfolio/ghostfolio.module';
@@ -69,6 +70,7 @@ import { UserModule } from './user/user.module';
     ActivitiesModule,
     AiModule,
     ApiKeysModule,
+    AssetProfilesModule,
     AssetModule,
     AssetsModule,
     AuthDeviceModule,

apps/api/src/app/auth/auth.module.ts

@@ -50,6 +50,8 @@ import { OidcStrategy } from './oidc.strategy';
         configurationService: ConfigurationService,
         fetchService: FetchService
       ) => {
+        const logger = new Logger('OidcStrategy');
+
         const isOidcEnabled = configurationService.get(
           'ENABLE_FEATURE_AUTH_OIDC'
         );
@@ -101,7 +103,7 @@ import { OidcStrategy } from './oidc.strategy';
             tokenURL = manualTokenUrl || config.token_endpoint;
             userInfoURL = manualUserInfoUrl || config.userinfo_endpoint;
           } catch (error) {
-            Logger.error(error, 'OidcStrategy');
+            logger.error(error);
             throw new Error('Failed to fetch OIDC configuration from issuer');
           }
         }

apps/api/src/app/auth/google.strategy.ts

@@ -10,6 +10,8 @@ import { AuthService } from './auth.service';
 
 @Injectable()
 export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
+  private readonly logger = new Logger(GoogleStrategy.name);
+
   public constructor(
     private readonly authService: AuthService,
     configurationService: ConfigurationService
@@ -40,7 +42,7 @@ export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
 
       done(null, { jwt });
     } catch (error) {
-      Logger.error(error, 'GoogleStrategy');
+      this.logger.error(error);
       done(error, false);
     }
   }

apps/api/src/app/auth/oidc.strategy.ts

@@ -15,6 +15,8 @@ import { OidcStateStore } from './oidc-state.store';
 
 @Injectable()
 export class OidcStrategy extends PassportStrategy(Strategy, 'oidc') {
+  private readonly logger = new Logger(OidcStrategy.name);
+
   private static readonly stateStore = new OidcStateStore();
 
   public constructor(
@@ -52,9 +54,8 @@ export class OidcStrategy extends PassportStrategy(Strategy, 'oidc') {
       });
 
       if (!thirdPartyId) {
-        Logger.error(
+        this.logger.error(
-          `Missing subject identifier in OIDC response from ${issuer}`,
+          `Missing subject identifier in OIDC response from ${issuer}`
-          'OidcStrategy'
         );
 
         throw new Error('Missing subject identifier in OIDC response');
@@ -62,7 +63,7 @@ export class OidcStrategy extends PassportStrategy(Strategy, 'oidc') {
 
       return { jwt };
     } catch (error) {
-      Logger.error(error, 'OidcStrategy');
+      this.logger.error(error);
       throw error;
     }
   }

apps/api/src/app/auth/web-auth.service.ts

@@ -33,6 +33,8 @@ import ms from 'ms';
 
 @Injectable()
 export class WebAuthService {
+  private readonly logger = new Logger(WebAuthService.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly deviceService: AuthDeviceService,
@@ -103,7 +105,7 @@ export class WebAuthService {
 
       verification = await verifyRegistrationResponse(opts);
     } catch (error) {
-      Logger.error(error, 'WebAuthService');
+      this.logger.error(error);
       throw new InternalServerErrorException(error.message);
     }
 
@@ -210,7 +212,7 @@ export class WebAuthService {
 
       verification = await verifyAuthenticationResponse(opts);
     } catch (error) {
-      Logger.error(error, 'WebAuthService');
+      this.logger.error(error);
       throw new InternalServerErrorException({ error: error.message });
     }
 

apps/api/src/app/endpoints/asset-profiles/asset-profiles.controller.ts

@@ -0,0 +1,51 @@
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { UpdateAssetProfileDataDto } from '@ghostfolio/common/dtos';
+import { EnhancedSymbolProfile } from '@ghostfolio/common/interfaces';
+import { permissions } from '@ghostfolio/common/permissions';
+import { RequestWithUser } from '@ghostfolio/common/types';
+
+import {
+  Body,
+  Controller,
+  HttpException,
+  Inject,
+  Param,
+  Patch,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { DataSource } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { AssetProfilesService } from './asset-profiles.service';
+
+@Controller('asset-profiles')
+export class AssetProfilesController {
+  public constructor(
+    private readonly assetProfilesService: AssetProfilesService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @HasPermission(permissions.accessAdminControl)
+  @Patch(':dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async updateAssetProfileData(
+    @Body() assetProfileData: UpdateAssetProfileDataDto,
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<EnhancedSymbolProfile> {
+    if (!this.request.user.settings.settings.isExperimentalFeatures) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
+      );
+    }
+
+    return this.assetProfilesService.updateAssetProfileData(
+      { dataSource, symbol },
+      assetProfileData
+    );
+  }
+}

apps/api/src/app/endpoints/asset-profiles/asset-profiles.module.ts

@@ -0,0 +1,13 @@
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.module';
+
+import { Module } from '@nestjs/common';
+
+import { AssetProfilesController } from './asset-profiles.controller';
+import { AssetProfilesService } from './asset-profiles.service';
+
+@Module({
+  controllers: [AssetProfilesController],
+  imports: [SymbolProfileModule],
+  providers: [AssetProfilesService]
+})
+export class AssetProfilesModule {}

apps/api/src/app/endpoints/asset-profiles/asset-profiles.service.ts

@@ -0,0 +1,90 @@
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import { UpdateAssetProfileDataDto } from '@ghostfolio/common/dtos';
+import {
+  AssetProfileIdentifier,
+  EnhancedSymbolProfile
+} from '@ghostfolio/common/interfaces';
+
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+
+@Injectable()
+export class AssetProfilesService {
+  public constructor(
+    private readonly symbolProfileService: SymbolProfileService
+  ) {}
+
+  public async updateAssetProfileData(
+    { dataSource, symbol }: AssetProfileIdentifier,
+    assetProfileData: UpdateAssetProfileDataDto
+  ): Promise<EnhancedSymbolProfile> {
+    const notFoundMessage = `Could not find the asset profile for ${symbol} (${dataSource})`;
+
+    const data = this.getAssetProfileDataUpdate(assetProfileData);
+
+    if (Object.keys(data).length > 0) {
+      try {
+        await this.symbolProfileService.updateSymbolProfile(
+          {
+            dataSource,
+            symbol
+          },
+          this.symbolProfileService.getAssetProfileUpdateInput(
+            { dataSource, symbol },
+            data
+          )
+        );
+      } catch (error) {
+        if (
+          error instanceof Prisma.PrismaClientKnownRequestError &&
+          error.code === 'P2025'
+        ) {
+          throw new NotFoundException(notFoundMessage);
+        }
+
+        throw error;
+      }
+    }
+
+    const [assetProfile] = await this.symbolProfileService.getSymbolProfiles([
+      {
+        dataSource,
+        symbol
+      }
+    ]);
+
+    if (!assetProfile) {
+      throw new NotFoundException(notFoundMessage);
+    }
+
+    return assetProfile;
+  }
+
+  private getAssetProfileDataUpdate({
+    countries,
+    holdings,
+    sectors
+  }: UpdateAssetProfileDataDto): Pick<
+    Prisma.SymbolProfileUpdateInput,
+    'countries' | 'holdings' | 'sectors'
+  > {
+    const data: Pick<
+      Prisma.SymbolProfileUpdateInput,
+      'countries' | 'holdings' | 'sectors'
+    > = {};
+
+    if (countries !== undefined) {
+      data.countries = countries as Prisma.JsonArray;
+    }
+
+    if (holdings !== undefined) {
+      data.holdings = holdings as Prisma.JsonArray;
+    }
+
+    if (sectors !== undefined) {
+      data.sectors = sectors as Prisma.JsonArray;
+    }
+
+    return data;
+  }
+}

apps/api/src/app/endpoints/benchmarks/benchmarks.service.ts

@@ -17,6 +17,8 @@ import { isNumber } from 'lodash';
 
 @Injectable()
 export class BenchmarksService {
+  private readonly logger = new Logger(BenchmarksService.name);
+
   public constructor(
     private readonly benchmarkService: BenchmarkService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
@@ -96,12 +98,11 @@ export class BenchmarksService {
     })?.marketPrice;
 
     if (!marketPriceAtStartDate) {
-      Logger.error(
+      this.logger.error(
         `No historical market data has been found for ${symbol} (${dataSource}) at ${format(
           startDate,
           DATE_FORMAT
-        )}`,
+        )}`
-        'BenchmarkService'
       );
 
       return { marketData };

apps/api/src/app/endpoints/data-providers/ghostfolio/ghostfolio.service.ts

@@ -34,6 +34,8 @@ import { Big } from 'big.js';
 
 @Injectable()
 export class GhostfolioService {
+  private readonly logger = new Logger(GhostfolioService.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly dataProviderService: DataProviderService,
@@ -99,7 +101,7 @@ export class GhostfolioService {
 
       return result;
     } catch (error) {
-      Logger.error(error, 'GhostfolioService');
+      this.logger.error(error);
 
       throw error;
     }
@@ -141,7 +143,7 @@ export class GhostfolioService {
 
       return result;
     } catch (error) {
-      Logger.error(error, 'GhostfolioService');
+      this.logger.error(error);
 
       throw error;
     }
@@ -183,7 +185,7 @@ export class GhostfolioService {
 
       return result;
     } catch (error) {
-      Logger.error(error, 'GhostfolioService');
+      this.logger.error(error);
 
       throw error;
     }
@@ -271,7 +273,7 @@ export class GhostfolioService {
 
       return results;
     } catch (error) {
-      Logger.error(error, 'GhostfolioService');
+      this.logger.error(error);
 
       throw error;
     }
@@ -348,7 +350,7 @@ export class GhostfolioService {
 
       return results;
     } catch (error) {
-      Logger.error(error, 'GhostfolioService');
+      this.logger.error(error);
 
       throw error;
     }

apps/api/src/app/health/health.controller.ts

@@ -24,6 +24,8 @@ import { HealthService } from './health.service';
 
 @Controller('health')
 export class HealthController {
+  private readonly logger = new Logger(HealthController.name);
+
   public constructor(
     private readonly aiService: AiService,
     private readonly healthService: HealthService
@@ -61,7 +63,7 @@ export class HealthController {
           .json({ status: getReasonPhrase(StatusCodes.OK) });
       }
     } catch (error) {
-      Logger.error(error, 'HealthController');
+      this.logger.error(error);
     }
 
     return response

apps/api/src/app/import/import.controller.ts

@@ -31,6 +31,8 @@ import { ImportService } from './import.service';
 
 @Controller('import')
 export class ImportController {
+  private readonly logger = new Logger(ImportController.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly importService: ImportService,
@@ -81,7 +83,7 @@ export class ImportController {
 
       return { activities };
     } catch (error) {
-      Logger.error(error, ImportController);
+      this.logger.error(error);
 
       throw new HttpException(
         {

apps/api/src/app/portfolio/calculator/portfolio-calculator.ts

@@ -62,6 +62,8 @@ import { isNumber, sortBy, sum, uniqBy } from 'lodash';
 export abstract class PortfolioCalculator {
   protected static readonly ENABLE_LOGGING = false;
 
+  protected readonly logger = new Logger(PortfolioCalculator.name);
+
   protected accountBalanceItems: HistoricalDataItem[];
   protected activities: PortfolioOrder[];
 
@@ -1119,12 +1121,11 @@ export abstract class PortfolioCalculator {
     if (cachedPortfolioSnapshot) {
       this.snapshot = cachedPortfolioSnapshot;
 
-      Logger.debug(
+      this.logger.debug(
         `Fetched portfolio snapshot from cache in ${(
           (performance.now() - startTimeTotal) /
           1000
-        ).toFixed(3)} seconds`,
+        ).toFixed(3)} seconds`
-        'PortfolioCalculator'
       );
 
       if (isCachedPortfolioSnapshotExpired) {

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-cash.spec.ts

@@ -116,10 +116,12 @@ describe('PortfolioCalculator', () => {
       accountBalanceService,
       accountService,
       null,
+      null,
       dataProviderService,
       null,
       exchangeRateDataService,
       null,
+      null,
       null
     );
 

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator.ts

@@ -11,7 +11,6 @@ import { PortfolioSnapshot, TimelinePosition } from '@ghostfolio/common/models';
 import { DateRange } from '@ghostfolio/common/types';
 import { PerformanceCalculationType } from '@ghostfolio/common/types/performance-calculation-type.type';
 
-import { Logger } from '@nestjs/common';
 import { Big } from 'big.js';
 import {
   addMilliseconds,
@@ -96,9 +95,8 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
             currentPosition.timeWeightedInvestmentWithCurrencyEffect
           );
       } else if (!currentPosition.quantity.eq(0)) {
-        Logger.warn(
+        this.logger.warn(
-          `Missing historical market data for ${currentPosition.symbol} (${currentPosition.dataSource})`,
+          `Missing historical market data for ${currentPosition.symbol} (${currentPosition.dataSource})`
-          'PortfolioCalculator'
         );
 
         hasErrors = true;

apps/api/src/app/portfolio/portfolio.service.spec.ts

@@ -9,6 +9,7 @@ import { DataProviderService } from '@ghostfolio/api/services/data-provider/data
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
 import { ImpersonationService } from '@ghostfolio/api/services/impersonation/impersonation.service';
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import { UNKNOWN_KEY } from '@ghostfolio/common/config';
 import { parseDate } from '@ghostfolio/common/helper';
 
 import { Account, DataSource } from '@prisma/client';
@@ -59,10 +60,12 @@ describe('PortfolioService', () => {
       null,
       accountService,
       null,
+      null,
       dataProviderService,
       null,
       exchangeRateDataService,
       null,
+      null,
       null
     );
 
@@ -106,6 +109,67 @@ describe('PortfolioService', () => {
     );
   });
 
+  describe('getAggregatedMarkets', () => {
+    const getAggregatedMarkets = (holdings: object) => {
+      return (
+        portfolioService as unknown as {
+          getAggregatedMarkets: (aHoldings: object) => {
+            markets: Record<
+              string,
+              { valueInBaseCurrency: number; valueInPercentage: number }
+            >;
+            marketsAdvanced: Record<string, { valueInBaseCurrency: number }>;
+          };
+        }
+      ).getAggregatedMarkets(holdings);
+    };
+
+    it('should distribute holdings with countries to their market and route holdings without countries (e.g. commodities, cryptocurrencies) to the unknown bucket', () => {
+      const holdings = {
+        'GC=F': {
+          // Gold
+          assetProfile: { countries: [] },
+          markets: { developedMarkets: 0, emergingMarkets: 0, otherMarkets: 0 },
+          marketsAdvanced: {
+            asiaPacific: 0,
+            emergingMarkets: 0,
+            europe: 0,
+            japan: 0,
+            northAmerica: 0,
+            otherMarkets: 0
+          },
+          valueInBaseCurrency: 500
+        },
+        MSFT: {
+          assetProfile: { countries: [{ code: 'US', weight: 1 }] },
+          markets: { developedMarkets: 1, emergingMarkets: 0, otherMarkets: 0 },
+          marketsAdvanced: {
+            asiaPacific: 0,
+            emergingMarkets: 0,
+            europe: 0,
+            japan: 0,
+            northAmerica: 1,
+            otherMarkets: 0
+          },
+          valueInBaseCurrency: 1000
+        }
+      };
+
+      const { markets, marketsAdvanced } = getAggregatedMarkets(holdings);
+
+      expect(markets.developedMarkets.valueInBaseCurrency).toBe(1000);
+      expect(markets[UNKNOWN_KEY].valueInBaseCurrency).toBe(500);
+
+      expect(markets.developedMarkets.valueInPercentage).toBeCloseTo(
+        1000 / 1500
+      );
+      expect(markets[UNKNOWN_KEY].valueInPercentage).toBeCloseTo(500 / 1500);
+
+      expect(marketsAdvanced.northAmerica.valueInBaseCurrency).toBe(1000);
+      expect(marketsAdvanced[UNKNOWN_KEY].valueInBaseCurrency).toBe(500);
+    });
+  });
+
   describe('getCashSymbolProfiles', () => {
     it('should use the exchange-rate data source so the symbol-profile join in getDetails matches the calculator positions', () => {
       jest
@@ -269,4 +333,96 @@ describe('PortfolioService', () => {
       expect(holdings['USD'].assetProfile.symbol).toBe('USD');
     });
   });
+
+  describe('getValueOfAccountsAndPlatforms', () => {
+    const getValueOfAccountsAndPlatforms = (args: object) => {
+      return (
+        portfolioService as unknown as {
+          getValueOfAccountsAndPlatforms: (aArgs: object) => Promise<{
+            accounts: Record<string, { valueInBaseCurrency: number }>;
+            platforms: Record<string, { valueInBaseCurrency: number }>;
+          }>;
+        }
+      ).getValueOfAccountsAndPlatforms(args);
+    };
+
+    const account = {
+      balance: 100,
+      currency: 'USD',
+      id: randomUUID(),
+      isExcluded: false,
+      name: 'Account 1',
+      platform: { name: 'Platform 1' },
+      platformId: randomUUID()
+    };
+
+    beforeEach(() => {
+      jest
+        .spyOn(accountService, 'getAccounts')
+        .mockResolvedValue([account] as unknown as Account[]);
+
+      jest
+        .spyOn(exchangeRateDataService, 'toCurrency')
+        .mockImplementation((aValue) => aValue);
+    });
+
+    it('should group activities without an account into the unknown bucket of accounts and platforms', async () => {
+      const { accounts, platforms } = await getValueOfAccountsAndPlatforms({
+        activities: [
+          {
+            account,
+            accountId: account.id,
+            quantity: 1,
+            SymbolProfile: { symbol: 'AAPL' },
+            type: 'BUY'
+          },
+          {
+            account: null,
+            accountId: null,
+            quantity: 2,
+            SymbolProfile: { symbol: 'BABA' },
+            type: 'BUY'
+          }
+        ],
+        filters: [],
+        portfolioItemsNow: {
+          AAPL: { marketPriceInBaseCurrency: 10 },
+          BABA: { marketPriceInBaseCurrency: 20 }
+        },
+        userCurrency: 'USD',
+        userId: userDummyData.id
+      });
+
+      // 100 (balance) + 1 * 10 (activity)
+      expect(accounts[account.id].valueInBaseCurrency).toBe(110);
+      expect(platforms[account.platformId].valueInBaseCurrency).toBe(110);
+
+      // 2 * 20 (activity without an account)
+      expect(accounts[UNKNOWN_KEY].valueInBaseCurrency).toBe(40);
+      expect(platforms[UNKNOWN_KEY].valueInBaseCurrency).toBe(40);
+    });
+
+    it('should not create an unknown bucket when every activity has an account', async () => {
+      const { accounts, platforms } = await getValueOfAccountsAndPlatforms({
+        activities: [
+          {
+            account,
+            accountId: account.id,
+            quantity: 1,
+            SymbolProfile: { symbol: 'AAPL' },
+            type: 'BUY'
+          }
+        ],
+        filters: [],
+        portfolioItemsNow: {
+          AAPL: { marketPriceInBaseCurrency: 10 }
+        },
+        userCurrency: 'USD',
+        userId: userDummyData.id
+      });
+
+      expect(accounts[UNKNOWN_KEY]).toBeUndefined();
+      expect(platforms[UNKNOWN_KEY]).toBeUndefined();
+    });
+  });
 });

apps/api/src/app/portfolio/portfolio.service.ts

@@ -108,6 +108,8 @@ const europeMarkets = require('../../assets/countries/europe-markets.json');
 
 @Injectable()
 export class PortfolioService {
+  private readonly logger = new Logger(PortfolioService.name);
+
   public constructor(
     private readonly accountBalanceService: AccountBalanceService,
     private readonly accountService: AccountService,
@@ -619,9 +621,8 @@ export class PortfolioService {
         symbolProfileMap[getAssetProfileIdentifier({ dataSource, symbol })];
 
       if (!assetProfile) {
-        Logger.warn(
+        this.logger.warn(
-          `Asset profile not found for ${symbol} (${dataSource})`,
+          `Asset profile not found for ${symbol} (${dataSource})`
-          'PortfolioService'
         );
 
         continue;
@@ -1452,31 +1453,29 @@ export class PortfolioService {
     for (const [, position] of Object.entries(holdings)) {
       const value = position.valueInBaseCurrency;
 
-      if (position.assetProfile.assetClass !== AssetClass.LIQUIDITY) {
+      if (position.assetProfile.countries.length > 0) {
-        if (position.assetProfile.countries.length > 0) {
+        markets.developedMarkets.valueInBaseCurrency +=
-          markets.developedMarkets.valueInBaseCurrency +=
+          position.markets.developedMarkets * value;
-            position.markets.developedMarkets * value;
+        markets.emergingMarkets.valueInBaseCurrency +=
-          markets.emergingMarkets.valueInBaseCurrency +=
+          position.markets.emergingMarkets * value;
-            position.markets.emergingMarkets * value;
+        markets.otherMarkets.valueInBaseCurrency +=
-          markets.otherMarkets.valueInBaseCurrency +=
+          position.markets.otherMarkets * value;
-            position.markets.otherMarkets * value;
+
-
+        marketsAdvanced.asiaPacific.valueInBaseCurrency +=
-          marketsAdvanced.asiaPacific.valueInBaseCurrency +=
+          position.marketsAdvanced.asiaPacific * value;
-            position.marketsAdvanced.asiaPacific * value;
+        marketsAdvanced.emergingMarkets.valueInBaseCurrency +=
-          marketsAdvanced.emergingMarkets.valueInBaseCurrency +=
+          position.marketsAdvanced.emergingMarkets * value;
-            position.marketsAdvanced.emergingMarkets * value;
+        marketsAdvanced.europe.valueInBaseCurrency +=
-          marketsAdvanced.europe.valueInBaseCurrency +=
+          position.marketsAdvanced.europe * value;
-            position.marketsAdvanced.europe * value;
+        marketsAdvanced.japan.valueInBaseCurrency +=
-          marketsAdvanced.japan.valueInBaseCurrency +=
+          position.marketsAdvanced.japan * value;
-            position.marketsAdvanced.japan * value;
+        marketsAdvanced.northAmerica.valueInBaseCurrency +=
-          marketsAdvanced.northAmerica.valueInBaseCurrency +=
+          position.marketsAdvanced.northAmerica * value;
-            position.marketsAdvanced.northAmerica * value;
+        marketsAdvanced.otherMarkets.valueInBaseCurrency +=
-          marketsAdvanced.otherMarkets.valueInBaseCurrency +=
+          position.marketsAdvanced.otherMarkets * value;
-            position.marketsAdvanced.otherMarkets * value;
+      } else {
-        } else {
+        markets[UNKNOWN_KEY].valueInBaseCurrency += value;
-          markets[UNKNOWN_KEY].valueInBaseCurrency += value;
+        marketsAdvanced[UNKNOWN_KEY].valueInBaseCurrency += value;
-          marketsAdvanced[UNKNOWN_KEY].valueInBaseCurrency += value;
-        }
       }
     }
 
@@ -2162,40 +2161,44 @@ export class PortfolioService {
       return withExcludedAccounts || account.isExcluded === false;
     });
 
-    for (const account of currentAccounts) {
+    // Iterate over the accounts plus a null entry to group activities without
+    // an account into the unknown bucket
+    for (const account of [...currentAccounts, null]) {
       const ordersByAccount = activities.filter(({ accountId }) => {
-        return accountId === account.id;
+        return account ? accountId === account.id : !accountId;
       });
 
-      accounts[account.id] = {
+      if (account) {
-        balance: account.balance,
+        accounts[account.id] = {
-        currency: account.currency,
-        name: account.name,
-        valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
-          account.balance,
-          account.currency,
-          userCurrency
-        )
-      };
-
-      if (platforms[account.platformId || UNKNOWN_KEY]?.valueInBaseCurrency) {
-        platforms[account.platformId || UNKNOWN_KEY].valueInBaseCurrency +=
-          this.exchangeRateDataService.toCurrency(
-            account.balance,
-            account.currency,
-            userCurrency
-          );
-      } else {
-        platforms[account.platformId || UNKNOWN_KEY] = {
           balance: account.balance,
           currency: account.currency,
-          name: account.platform?.name,
+          name: account.name,
           valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
             account.balance,
             account.currency,
             userCurrency
           )
         };
+
+        if (platforms[account.platformId || UNKNOWN_KEY]?.valueInBaseCurrency) {
+          platforms[account.platformId || UNKNOWN_KEY].valueInBaseCurrency +=
+            this.exchangeRateDataService.toCurrency(
+              account.balance,
+              account.currency,
+              userCurrency
+            );
+        } else {
+          platforms[account.platformId || UNKNOWN_KEY] = {
+            balance: account.balance,
+            currency: account.currency,
+            name: account.platform?.name,
+            valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+              account.balance,
+              account.currency,
+              userCurrency
+            )
+          };
+        }
       }
 
       for (const {

apps/api/src/app/redis-cache/redis-cache.service.ts

@@ -10,6 +10,8 @@ import { createHash, randomUUID } from 'node:crypto';
 
 @Injectable()
 export class RedisCacheService {
+  private readonly logger = new Logger(RedisCacheService.name);
+
   private client: Keyv;
 
   public constructor(
@@ -27,7 +29,7 @@ export class RedisCacheService {
     };
 
     this.client.on('error', (error) => {
-      Logger.error(error, 'RedisCacheService');
+      this.logger.error(error);
     });
   }
 
@@ -101,7 +103,7 @@ export class RedisCacheService {
 
       return true;
     } catch (error) {
-      Logger.error(error?.message, 'RedisCacheService');
+      this.logger.error(error?.message);
 
       return false;
     } finally {

apps/api/src/app/subscription/subscription.controller.ts

@@ -33,6 +33,8 @@ import { SubscriptionService } from './subscription.service';
 
 @Controller('subscription')
 export class SubscriptionController {
+  private readonly logger = new Logger(SubscriptionController.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly propertyService: PropertyService,
@@ -80,9 +82,8 @@ export class SubscriptionController {
       value: JSON.stringify(coupons)
     });
 
-    Logger.log(
+    this.logger.log(
-      `Subscription for user '${this.request.user.id}' has been created with a coupon for ${coupon.duration}`,
+      `Subscription for user '${this.request.user.id}' has been created with a coupon for ${coupon.duration}`
-      'SubscriptionController'
     );
 
     return {
@@ -101,9 +102,8 @@ export class SubscriptionController {
     );
 
     if (userId) {
-      Logger.log(
+      this.logger.log(
-        `Subscription for user '${userId}' has been created via Stripe`,
+        `Subscription for user '${userId}' has been created via Stripe`
-        'SubscriptionController'
       );
     }
 
@@ -126,7 +126,7 @@ export class SubscriptionController {
         user: this.request.user
       });
     } catch (error) {
-      Logger.error(error, 'SubscriptionController');
+      this.logger.error(error);
 
       throw new HttpException(
         getReasonPhrase(StatusCodes.BAD_REQUEST),

apps/api/src/app/subscription/subscription.service.ts

@@ -24,6 +24,8 @@ import Stripe from 'stripe';
 
 @Injectable()
 export class SubscriptionService {
+  private readonly logger = new Logger(SubscriptionService.name);
+
   private stripe: Stripe;
 
   public constructor(
@@ -166,9 +168,8 @@ export class SubscriptionService {
           error instanceof Prisma.PrismaClientKnownRequestError &&
           error.code === 'P2002'
         ) {
-          Logger.log(
+          this.logger.log(
-            `Stripe Checkout Session '${session.id}' has already been redeemed`,
+            `Stripe Checkout Session '${session.id}' has already been redeemed`
-            'SubscriptionService'
           );
         } else {
           throw error;
@@ -177,7 +178,7 @@ export class SubscriptionService {
 
       return session.client_reference_id;
     } catch (error) {
-      Logger.error(error, 'SubscriptionService');
+      this.logger.error(error);
     }
   }
 

apps/api/src/app/symbol/symbol.service.ts

@@ -15,6 +15,8 @@ import { format, subDays } from 'date-fns';
 
 @Injectable()
 export class SymbolService {
+  private readonly logger = new Logger(SymbolService.name);
+
   public constructor(
     private readonly dataProviderService: DataProviderService,
     private readonly marketDataService: MarketDataService
@@ -119,7 +121,7 @@ export class SymbolService {
       results.items = items;
       return results;
     } catch (error) {
-      Logger.error(error, 'SymbolService');
+      this.logger.error(error);
 
       throw error;
     }

apps/api/src/events/asset-profile-changed.listener.ts

@@ -15,6 +15,8 @@ import { AssetProfileChangedEvent } from './asset-profile-changed.event';
 
 @Injectable()
 export class AssetProfileChangedListener {
+  private readonly logger = new Logger(AssetProfileChangedListener.name);
+
   private static readonly DEBOUNCE_DELAY = ms('5 seconds');
 
   private debounceTimers = new Map<string, NodeJS.Timeout>();
@@ -67,10 +69,7 @@ export class AssetProfileChangedListener {
     dataSource: DataSource;
     symbol: string;
   }) {
-    Logger.log(
+    this.logger.log(`Asset profile of ${symbol} (${dataSource}) has changed`);
-      `Asset profile of ${symbol} (${dataSource}) has changed`,
-      'AssetProfileChangedListener'
-    );
 
     if (
       this.configurationService.get(
@@ -84,10 +83,7 @@ export class AssetProfileChangedListener {
     const existingCurrencies = this.exchangeRateDataService.getCurrencies();
 
     if (!existingCurrencies.includes(currency)) {
-      Logger.log(
+      this.logger.log(`New currency ${currency} has been detected`);
-        `New currency ${currency} has been detected`,
-        'AssetProfileChangedListener'
-      );
 
       await this.exchangeRateDataService.initialize();
     }

apps/api/src/events/portfolio-changed.listener.ts

@@ -8,6 +8,8 @@ import { PortfolioChangedEvent } from './portfolio-changed.event';
 
 @Injectable()
 export class PortfolioChangedListener {
+  private readonly logger = new Logger(PortfolioChangedListener.name);
+
   private static readonly DEBOUNCE_DELAY = ms('5 seconds');
 
   private debounceTimers = new Map<string, NodeJS.Timeout>();
@@ -35,10 +37,7 @@ export class PortfolioChangedListener {
   }
 
   private async processPortfolioChanged({ userId }: { userId: string }) {
-    Logger.log(
+    this.logger.log(`Portfolio of user '${userId}' has changed`);
-      `Portfolio of user '${userId}' has changed`,
-      'PortfolioChangedListener'
-    );
 
     await this.redisCacheService.removePortfolioSnapshotsByUserId({ userId });
   }

apps/api/src/helper/country.helper.ts

@@ -0,0 +1,17 @@
+import { countries } from 'countries-list';
+
+export function getCountryCodeByName({
+  aliases = {},
+  name
+}: {
+  aliases?: Record<string, string>;
+  name: string;
+}): string {
+  for (const [code, country] of Object.entries(countries)) {
+    if (country.name === name || country.name === aliases[name]) {
+      return code;
+    }
+  }
+
+  return undefined;
+}

apps/api/src/helper/sector.helper.ts

@@ -0,0 +1,28 @@
+import { SECTORS } from '@ghostfolio/common/config';
+import { SectorName } from '@ghostfolio/common/types';
+
+import { Logger } from '@nestjs/common';
+
+export function getSectorName({
+  aliases = {},
+  name
+}: {
+  aliases?: Record<string, SectorName>;
+  name: string;
+}): SectorName {
+  if (aliases[name]) {
+    return aliases[name];
+  }
+
+  if ((SECTORS as readonly string[]).includes(name)) {
+    return name as SectorName;
+  }
+
+  if (name) {
+    const logger = new Logger('getSectorName');
+
+    logger.warn(`Could not map the sector "${name}" to the ontology`);
+  }
+
+  return 'Other';
+}

apps/api/src/interceptors/performance-logging/performance-logging.service.ts

@@ -2,6 +2,8 @@ import { Injectable, Logger } from '@nestjs/common';
 
 @Injectable()
 export class PerformanceLoggingService {
+  private readonly logger = new Logger(PerformanceLoggingService.name);
+
   public logPerformance({
     className,
     methodName,
@@ -13,7 +15,7 @@ export class PerformanceLoggingService {
   }) {
     const endTime = performance.now();
 
-    Logger.debug(
+    this.logger.debug(
       `Completed execution of ${methodName}() in ${((endTime - startTime) / 1000).toFixed(3)} seconds`,
       className
     );

apps/api/src/main.ts

@@ -23,6 +23,8 @@ import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
 import { AppModule } from './app/app.module';
 import { environment } from './environments/environment';
 
+const logger = new Logger('Bootstrap');
+
 async function bootstrap() {
   // Respect HTTP_PROXY / HTTPS_PROXY / NO_PROXY for outbound HTTP requests
   setGlobalDispatcher(new EnvHttpProxyAgent());
@@ -114,20 +116,20 @@ async function bootstrap() {
       address = `${host}:${addressObject.port}`;
     }
 
-    Logger.log(`Listening at http://${address}`);
+    logger.log(`Listening at http://${address}`);
-    Logger.log('');
+    logger.log('');
   });
 }
 
 function logLogo() {
-  Logger.log('   ________               __  ____      ___');
+  logger.log('   ________               __  ____      ___');
-  Logger.log('  / ____/ /_  ____  _____/ /_/ __/___  / (_)___');
+  logger.log('  / ____/ /_  ____  _____/ /_/ __/___  / (_)___');
-  Logger.log(' / / __/ __ \\/ __ \\/ ___/ __/ /_/ __ \\/ / / __ \\');
+  logger.log(' / / __/ __ \\/ __ \\/ ___/ __/ /_/ __ \\/ / / __ \\');
-  Logger.log('/ /_/ / / / / /_/ (__  ) /_/ __/ /_/ / / / /_/ /');
+  logger.log('/ /_/ / / / / /_/ (__  ) /_/ __/ /_/ / / / /_/ /');
-  Logger.log(
+  logger.log(
     `\\____/_/ /_/\\____/____/\\__/_/  \\____/_/_/\\____/ ${environment.version}`
   );
-  Logger.log('');
+  logger.log('');
 }
 
 bootstrap();

apps/api/src/middlewares/html-template.middleware.ts

@@ -92,6 +92,8 @@ const locales = {
 
 @Injectable()
 export class HtmlTemplateMiddleware implements NestMiddleware {
+  private readonly logger = new Logger(HtmlTemplateMiddleware.name);
+
   private indexHtmlMap: { [languageCode: string]: string } = {};
 
   public constructor(private readonly i18nService: I18nService) {
@@ -107,11 +109,7 @@ export class HtmlTemplateMiddleware implements NestMiddleware {
         {}
       );
     } catch (error) {
-      Logger.error(
+      this.logger.error('Failed to initialize index HTML map', error);
-        'Failed to initialize index HTML map',
-        error,
-        'HTMLTemplateMiddleware'
-      );
     }
   }
 

apps/api/src/services/benchmark/benchmark.service.ts

@@ -28,6 +28,8 @@ import { BenchmarkValue } from './interfaces/benchmark-value.interface';
 
 @Injectable()
 export class BenchmarkService {
+  private readonly logger = new Logger(BenchmarkService.name);
+
   private readonly CACHE_KEY_BENCHMARKS = 'BENCHMARKS';
 
   public constructor(
@@ -87,7 +89,7 @@ export class BenchmarkService {
         const { benchmarks, expiration }: BenchmarkValue =
           JSON.parse(cachedBenchmarkValue);
 
-        Logger.debug('Fetched benchmarks from cache', 'BenchmarkService');
+        this.logger.debug('Fetched benchmarks from cache');
 
         if (isAfter(new Date(), new Date(expiration))) {
           this.calculateAndCacheBenchmarks({
@@ -227,7 +229,7 @@ export class BenchmarkService {
   private async calculateAndCacheBenchmarks({
     enableSharing = false
   }): Promise<BenchmarkResponse['benchmarks']> {
-    Logger.debug('Calculate benchmarks', 'BenchmarkService');
+    this.logger.debug('Calculate benchmarks');
 
     const benchmarkAssetProfiles = await this.getBenchmarkAssetProfiles({
       enableSharing

apps/api/src/services/configuration/configuration.service.ts

@@ -30,7 +30,6 @@ export class ConfigurationService {
       API_KEY_FINANCIAL_MODELING_PREP: str({ default: '' }),
       API_KEY_OPEN_FIGI: str({ default: '' }),
       API_KEY_RAPID_API: str({ default: '' }),
-      BULL_BOARD_IS_READ_ONLY: bool({ default: true }),
       CACHE_QUOTES_TTL: num({ default: ms('1 minute') }),
       CACHE_TTL: num({ default: CACHE_TTL_NO_CACHE }),
       DATA_SOURCE_EXCHANGE_RATES: str({ default: DataSource.YAHOO }),

apps/api/src/services/data-provider/coingecko/coingecko.service.ts

@@ -29,6 +29,8 @@ import { format, fromUnixTime, getUnixTime } from 'date-fns';
 
 @Injectable()
 export class CoinGeckoService implements DataProviderInterface, OnModuleInit {
+  private readonly logger = new Logger(CoinGeckoService.name);
+
   private apiUrl: string;
   private headers: HeadersInit = {};
 
@@ -88,7 +90,7 @@ export class CoinGeckoService implements DataProviderInterface, OnModuleInit {
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'CoinGeckoService');
+      this.logger.error(message);
     }
 
     return response;
@@ -214,7 +216,7 @@ export class CoinGeckoService implements DataProviderInterface, OnModuleInit {
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'CoinGeckoService');
+      this.logger.error(message);
     }
 
     return response;
@@ -262,7 +264,7 @@ export class CoinGeckoService implements DataProviderInterface, OnModuleInit {
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'CoinGeckoService');
+      this.logger.error(message);
     }
 
     return { items };

apps/api/src/services/data-provider/data-enhancer/trackinsight/trackinsight.service.ts

@@ -1,13 +1,15 @@
+import { getCountryCodeByName } from '@ghostfolio/api/helper/country.helper';
+import { getSectorName } from '@ghostfolio/api/helper/sector.helper';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
 import { DataEnhancerInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-enhancer.interface';
 import { FetchService } from '@ghostfolio/api/services/fetch/fetch.service';
 import { Holding } from '@ghostfolio/common/interfaces';
 import { Country } from '@ghostfolio/common/interfaces/country.interface';
 import { Sector } from '@ghostfolio/common/interfaces/sector.interface';
+import { SectorName } from '@ghostfolio/common/types';
 
 import { Injectable, Logger } from '@nestjs/common';
 import { SymbolProfile } from '@prisma/client';
-import { countries } from 'countries-list';
 
 @Injectable()
 export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
@@ -17,13 +19,17 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
     USA: 'United States'
   };
   private static holdingsWeightTreshold = 0.85;
-  private static sectorsMapping = {
+  private static sectorsMapping: Record<string, SectorName> = {
     'Consumer Discretionary': 'Consumer Cyclical',
-    'Consumer Defensive': 'Consumer Staples',
+    'Consumer Staples': 'Consumer Defensive',
+    Financials: 'Financial Services',
     'Health Care': 'Healthcare',
-    'Information Technology': 'Technology'
+    'Information Technology': 'Technology',
+    Materials: 'Basic Materials'
   };
 
+  private readonly logger = new Logger(TrackinsightDataEnhancerService.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly fetchService: FetchService
@@ -115,21 +121,11 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
       for (const [name, value] of Object.entries<any>(
         holdings?.countries ?? {}
       )) {
-        let countryCode: string;
-
-        for (const [code, country] of Object.entries(countries)) {
-          if (
-            country.name === name ||
-            country.name ===
-              TrackinsightDataEnhancerService.countriesMapping[name]
-          ) {
-            countryCode = code;
-            break;
-          }
-        }
-
         response.countries.push({
-          code: countryCode,
+          code: getCountryCodeByName({
+            name,
+            aliases: TrackinsightDataEnhancerService.countriesMapping
+          }),
           weight: value.weight
         });
       }
@@ -163,7 +159,10 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
         holdings?.sectors ?? {}
       )) {
         response.sectors.push({
-          name: TrackinsightDataEnhancerService.sectorsMapping[name] ?? name,
+          name: getSectorName({
+            name,
+            aliases: TrackinsightDataEnhancerService.sectorsMapping
+          }),
           weight: value.weight
         });
       }
@@ -209,9 +208,8 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
         return undefined;
       })
       .catch(({ message }) => {
-        Logger.error(
+        this.logger.error(
-          `Failed to search Trackinsight symbol for ${symbol} (${message})`,
+          `Failed to search Trackinsight symbol for ${symbol} (${message})`
-          'TrackinsightDataEnhancerService'
         );
 
         return undefined;

apps/api/src/services/data-provider/data-enhancer/yahoo-finance/yahoo-finance.service.ts

@@ -1,12 +1,13 @@
+import { getSectorName } from '@ghostfolio/api/helper/sector.helper';
 import { CryptocurrencyService } from '@ghostfolio/api/services/cryptocurrency/cryptocurrency.service';
 import { AssetProfileDelistedError } from '@ghostfolio/api/services/data-provider/errors/asset-profile-delisted.error';
 import { DataEnhancerInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-enhancer.interface';
 import {
   DEFAULT_CURRENCY,
-  REPLACE_NAME_PARTS,
+  REPLACE_NAME_PARTS
-  UNKNOWN_KEY
 } from '@ghostfolio/common/config';
-import { isCurrency } from '@ghostfolio/common/helper';
+import { isCurrencySymbol } from '@ghostfolio/common/helper';
+import { SectorName } from '@ghostfolio/common/types';
 
 import { Injectable, Logger } from '@nestjs/common';
 import {
@@ -23,6 +24,22 @@ import type { Price } from 'yahoo-finance2/esm/src/modules/quoteSummary-iface';
 
 @Injectable()
 export class YahooFinanceDataEnhancerService implements DataEnhancerInterface {
+  private static sectorsMapping: Record<string, SectorName> = {
+    basic_materials: 'Basic Materials',
+    communication_services: 'Communication Services',
+    consumer_cyclical: 'Consumer Cyclical',
+    consumer_defensive: 'Consumer Defensive',
+    energy: 'Energy',
+    financial_services: 'Financial Services',
+    healthcare: 'Healthcare',
+    industrials: 'Industrials',
+    realestate: 'Real Estate',
+    technology: 'Technology',
+    utilities: 'Utilities'
+  };
+
+  private readonly logger = new Logger(YahooFinanceDataEnhancerService.name);
+
   private readonly yahooFinance = new YahooFinance({
     suppressNotices: ['yahooSurvey']
   });
@@ -56,31 +73,21 @@ export class YahooFinanceDataEnhancerService implements DataEnhancerInterface {
    *                  DOGEUSD -> DOGE-USD
    */
   public convertToYahooFinanceSymbol(aSymbol: string) {
-    if (
+    if (isCurrencySymbol(aSymbol)) {
-      aSymbol.includes(DEFAULT_CURRENCY) &&
+      return `${aSymbol}=X`;
-      aSymbol.length > DEFAULT_CURRENCY.length
+    } else if (
+      this.cryptocurrencyService.isCryptocurrency(
+        aSymbol.replace(new RegExp(`-${DEFAULT_CURRENCY}$`), DEFAULT_CURRENCY)
+      )
     ) {
-      if (
+      // Add a dash before the last three characters
-        isCurrency(
+      // BTCUSD  -> BTC-USD
-          aSymbol.substring(0, aSymbol.length - DEFAULT_CURRENCY.length)
+      // DOGEUSD -> DOGE-USD
-        ) &&
+      // SOL1USD -> SOL1-USD
-        isCurrency(aSymbol.substring(aSymbol.length - DEFAULT_CURRENCY.length))
+      return aSymbol.replace(
-      ) {
+        new RegExp(`-?${DEFAULT_CURRENCY}$`),
-        return `${aSymbol}=X`;
+        `-${DEFAULT_CURRENCY}`
-      } else if (
+      );
-        this.cryptocurrencyService.isCryptocurrency(
-          aSymbol.replace(new RegExp(`-${DEFAULT_CURRENCY}$`), DEFAULT_CURRENCY)
-        )
-      ) {
-        // Add a dash before the last three characters
-        // BTCUSD  -> BTC-USD
-        // DOGEUSD -> DOGE-USD
-        // SOL1USD -> SOL1-USD
-        return aSymbol.replace(
-          new RegExp(`-?${DEFAULT_CURRENCY}$`),
-          `-${DEFAULT_CURRENCY}`
-        );
-      }
     }
 
     return aSymbol;
@@ -123,7 +130,7 @@ export class YahooFinanceDataEnhancerService implements DataEnhancerInterface {
         response.url = url;
       }
     } catch (error) {
-      Logger.error(error, 'YahooFinanceDataEnhancerService');
+      this.logger.error(error);
     }
 
     return response;
@@ -222,7 +229,10 @@ export class YahooFinanceDataEnhancerService implements DataEnhancerInterface {
           .flatMap((sectorWeighting) => {
             return Object.entries(sectorWeighting).map(([sector, weight]) => {
               return {
-                name: this.parseSector(sector),
+                name: getSectorName({
+                  aliases: YahooFinanceDataEnhancerService.sectorsMapping,
+                  name: sector
+                }),
                 weight: weight as number
               };
             });
@@ -266,7 +276,7 @@ export class YahooFinanceDataEnhancerService implements DataEnhancerInterface {
           `No data found, ${aSymbol} (${this.getName()}) may be delisted`
         );
       } else {
-        Logger.error(error, 'YahooFinanceService');
+        this.logger.error(error);
       }
     }
 
@@ -329,46 +339,4 @@ export class YahooFinanceDataEnhancerService implements DataEnhancerInterface {
 
     return { assetClass, assetSubClass };
   }
-
-  private parseSector(aString: string) {
-    let sector = UNKNOWN_KEY;
-
-    switch (aString) {
-      case 'basic_materials':
-        sector = 'Basic Materials';
-        break;
-      case 'communication_services':
-        sector = 'Communication Services';
-        break;
-      case 'consumer_cyclical':
-        sector = 'Consumer Cyclical';
-        break;
-      case 'consumer_defensive':
-        sector = 'Consumer Staples';
-        break;
-      case 'energy':
-        sector = 'Energy';
-        break;
-      case 'financial_services':
-        sector = 'Financial Services';
-        break;
-      case 'healthcare':
-        sector = 'Healthcare';
-        break;
-      case 'industrials':
-        sector = 'Industrials';
-        break;
-      case 'realestate':
-        sector = 'Real Estate';
-        break;
-      case 'technology':
-        sector = 'Technology';
-        break;
-      case 'utilities':
-        sector = 'Utilities';
-        break;
-    }
-
-    return sector;
-  }
 }

apps/api/src/services/data-provider/data-provider.service.ts

@@ -41,6 +41,8 @@ import { AssetProfileInvalidError } from './errors/asset-profile-invalid.error';
 
 @Injectable()
 export class DataProviderService implements OnModuleInit {
+  private readonly logger = new Logger(DataProviderService.name);
+
   private dataProviderMapping: { [dataProviderName: string]: string };
 
   public constructor(
@@ -129,7 +131,7 @@ export class DataProviderService implements OnModuleInit {
         );
       }
     } catch (error) {
-      Logger.error(error, 'DataProviderService');
+      this.logger.error(error);
 
       throw error;
     }
@@ -383,15 +385,16 @@ export class DataProviderService implements OnModuleInit {
       response = marketDataByGranularity.reduce((r, marketData) => {
         const { date, marketPrice, symbol } = marketData;
 
-        r[symbol] = {
+        if (!r[symbol]) {
-          ...(r[symbol] || {}),
+          r[symbol] = {};
-          [format(new Date(date), DATE_FORMAT)]: { marketPrice }
+        }
-        };
+
+        r[symbol][format(new Date(date), DATE_FORMAT)] = { marketPrice };
 
         return r;
       }, {});
     } catch (error) {
-      Logger.error(error, 'DataProviderService');
+      this.logger.error(error);
     } finally {
       return response;
     }
@@ -503,7 +506,7 @@ export class DataProviderService implements OnModuleInit {
         result[symbol] = data;
       }
     } catch (error) {
-      Logger.error(error, 'DataProviderService');
+      this.logger.error(error);
 
       throw error;
     }
@@ -567,13 +570,12 @@ export class DataProviderService implements OnModuleInit {
     const numberOfItemsInCache = Object.keys(response)?.length;
 
     if (numberOfItemsInCache) {
-      Logger.debug(
+      this.logger.debug(
         `Fetched ${numberOfItemsInCache} quote${
           numberOfItemsInCache > 1 ? 's' : ''
         } from cache in ${((performance.now() - startTimeTotal) / 1000).toFixed(
           3
-        )} seconds`,
+        )} seconds`
-        'DataProviderService'
       );
     }
 
@@ -684,14 +686,13 @@ export class DataProviderService implements OnModuleInit {
               }
             }
 
-            Logger.debug(
+            this.logger.debug(
               `Fetched ${symbolsChunk.length} quote${
                 symbolsChunk.length > 1 ? 's' : ''
               } from ${dataSource} in ${(
                 (performance.now() - startTimeDataSource) /
                 1000
-              ).toFixed(3)} seconds`,
+              ).toFixed(3)} seconds`
-              'DataProviderService'
             );
 
             try {
@@ -722,15 +723,18 @@ export class DataProviderService implements OnModuleInit {
 
     await Promise.all(promises);
 
-    Logger.debug('--------------------------------------------------------');
+    this.logger.debug(
-    Logger.debug(
+      '--------------------------------------------------------'
+    );
+    this.logger.debug(
       `Fetched ${items.length} quote${items.length > 1 ? 's' : ''} in ${(
         (performance.now() - startTimeTotal) /
         1000
-      ).toFixed(3)} seconds`,
+      ).toFixed(3)} seconds`
-      'DataProviderService'
+    );
+    this.logger.debug(
+      '========================================================'
     );
-    Logger.debug('========================================================');
 
     return response;
   }

apps/api/src/services/data-provider/eod-historical-data/eod-historical-data.service.ts

@@ -13,7 +13,7 @@ import {
   DEFAULT_CURRENCY,
   REPLACE_NAME_PARTS
 } from '@ghostfolio/common/config';
-import { DATE_FORMAT, isCurrency } from '@ghostfolio/common/helper';
+import { DATE_FORMAT, isCurrencySymbol } from '@ghostfolio/common/helper';
 import {
   DataProviderHistoricalResponse,
   DataProviderInfo,
@@ -37,6 +37,8 @@ import { isNumber } from 'lodash';
 export class EodHistoricalDataService
   implements DataProviderInterface, OnModuleInit
 {
+  private readonly logger = new Logger(EodHistoricalDataService.name);
+
   private apiKey: string;
   private readonly URL = 'https://eodhistoricaldata.com/api';
 
@@ -127,12 +129,11 @@ export class EodHistoricalDataService
 
       return response;
     } catch (error) {
-      Logger.error(
+      this.logger.error(
         `Could not get dividends for ${symbol} (${this.getName()}) from ${format(
           from,
           DATE_FORMAT
-        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`,
+        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`
-        'EodHistoricalDataService'
       );
 
       return {};
@@ -172,9 +173,8 @@ export class EodHistoricalDataService
               marketPrice: adjusted_close
             };
           } else {
-            Logger.error(
+            this.logger.error(
-              `Could not get historical market data for ${symbol} (${this.getName()}) at ${date}`,
+              `Could not get historical market data for ${symbol} (${this.getName()}) at ${date}`
-              'EodHistoricalDataService'
             );
           }
 
@@ -292,9 +292,8 @@ export class EodHistoricalDataService
             dataSource: this.getName()
           };
         } else {
-          Logger.error(
+          this.logger.error(
-            `Could not get quote for ${this.convertFromEodSymbol(code)} (${this.getName()})`,
+            `Could not get quote for ${this.convertFromEodSymbol(code)} (${this.getName()})`
-            'EodHistoricalDataService'
           );
         }
       }
@@ -311,7 +310,7 @@ export class EodHistoricalDataService
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'EodHistoricalDataService');
+      this.logger.error(message);
     }
 
     return {};
@@ -383,20 +382,11 @@ export class EodHistoricalDataService
    * Currency:  USDCHF  -> USDCHF.FOREX
    */
   private convertToEodSymbol(aSymbol: string) {
-    if (
+    if (isCurrencySymbol(aSymbol)) {
-      aSymbol.startsWith(DEFAULT_CURRENCY) &&
+      let symbol = aSymbol;
-      aSymbol.length > DEFAULT_CURRENCY.length
+      symbol = symbol.replace('GBp', 'GBX');
-    ) {
-      if (
-        isCurrency(
-          aSymbol.substring(0, aSymbol.length - DEFAULT_CURRENCY.length)
-        )
-      ) {
-        let symbol = aSymbol;
-        symbol = symbol.replace('GBp', 'GBX');
 
-        return `${symbol}.FOREX`;
+      return `${symbol}.FOREX`;
-      }
     }
 
     return aSymbol;
@@ -465,7 +455,7 @@ export class EodHistoricalDataService
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'EodHistoricalDataService');
+      this.logger.error(message);
     }
 
     return searchResult;

apps/api/src/services/data-provider/financial-modeling-prep/financial-modeling-prep.service.ts

@@ -1,3 +1,4 @@
+import { getCountryCodeByName } from '@ghostfolio/api/helper/country.helper';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
 import { CryptocurrencyService } from '@ghostfolio/api/services/cryptocurrency/cryptocurrency.service';
 import { AssetProfileDelistedError } from '@ghostfolio/api/services/data-provider/errors/asset-profile-delisted.error';
@@ -15,7 +16,11 @@ import {
   DEFAULT_CURRENCY,
   REPLACE_NAME_PARTS
 } from '@ghostfolio/common/config';
-import { DATE_FORMAT, isCurrency, parseDate } from '@ghostfolio/common/helper';
+import {
+  DATE_FORMAT,
+  isCurrencySymbol,
+  parseDate
+} from '@ghostfolio/common/helper';
 import {
   DataProviderHistoricalResponse,
   DataProviderInfo,
@@ -33,7 +38,6 @@ import {
   SymbolProfile
 } from '@prisma/client';
 import { isISIN } from 'class-validator';
-import { countries } from 'countries-list';
 import {
   addDays,
   addYears,
@@ -55,6 +59,8 @@ export class FinancialModelingPrepService
     'Taiwan (Province of China)': 'Taiwan'
   };
 
+  private readonly logger = new Logger(FinancialModelingPrepService.name);
+
   private apiKey: string;
 
   public constructor(
@@ -84,9 +90,7 @@ export class FinancialModelingPrepService
     };
 
     try {
-      if (
+      if (isCurrencySymbol(symbol)) {
-        isCurrency(symbol.substring(0, symbol.length - DEFAULT_CURRENCY.length))
-      ) {
         response.assetClass = AssetClass.LIQUIDITY;
         response.assetSubClass = AssetSubClass.CASH;
         response.currency = symbol.substring(
@@ -163,21 +167,11 @@ export class FinancialModelingPrepService
               return countryName.toLowerCase() !== 'other';
             })
             .map(({ country: countryName, weightPercentage }) => {
-              let countryCode: string;
-
-              for (const [code, country] of Object.entries(countries)) {
-                if (
-                  country.name === countryName ||
-                  country.name ===
-                    FinancialModelingPrepService.countriesMapping[countryName]
-                ) {
-                  countryCode = code;
-                  break;
-                }
-              }
-
               return {
-                code: countryCode,
+                code: getCountryCodeByName({
+                  aliases: FinancialModelingPrepService.countriesMapping,
+                  name: countryName
+                }),
                 weight: parseFloat(weightPercentage.slice(0, -1)) / 100
               };
             });
@@ -265,7 +259,7 @@ export class FinancialModelingPrepService
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'FinancialModelingPrepService');
+      this.logger.error(message);
     }
 
     return response;
@@ -325,12 +319,11 @@ export class FinancialModelingPrepService
 
       return response;
     } catch (error) {
-      Logger.error(
+      this.logger.error(
         `Could not get dividends for ${symbol} (${this.getName()}) from ${format(
           from,
           DATE_FORMAT
-        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`,
+        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`
-        'FinancialModelingPrepService'
       );
 
       return {};
@@ -491,11 +484,7 @@ export class FinancialModelingPrepService
       for (const { price, symbol } of quotes) {
         let marketState: MarketState = 'delayed';
 
-        if (
+        if (isCurrencySymbol(symbol)) {
-          isCurrency(
-            symbol.substring(0, symbol.length - DEFAULT_CURRENCY.length)
-          )
-        ) {
           marketState = 'open';
         }
 
@@ -518,7 +507,7 @@ export class FinancialModelingPrepService
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'FinancialModelingPrepService');
+      this.logger.error(message);
     }
 
     return response;
@@ -638,7 +627,7 @@ export class FinancialModelingPrepService
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'FinancialModelingPrepService');
+      this.logger.error(message);
     }
 
     return { items };

apps/api/src/services/data-provider/ghostfolio/ghostfolio.service.ts

@@ -33,6 +33,8 @@ import { StatusCodes } from 'http-status-codes';
 
 @Injectable()
 export class GhostfolioService implements DataProviderInterface {
+  private readonly logger = new Logger(GhostfolioService.name);
+
   private readonly URL = environment.production
     ? 'https://ghostfol.io/api'
     : `${this.configurationService.get('ROOT_URL')}/api`;
@@ -89,7 +91,7 @@ export class GhostfolioService implements DataProviderInterface {
           'RequestError: The API key is invalid. Please update it in the Settings section of the Admin Control panel.';
       }
 
-      Logger.error(message, 'GhostfolioService');
+      this.logger.error(message);
     }
 
     return assetProfile;
@@ -154,7 +156,7 @@ export class GhostfolioService implements DataProviderInterface {
           'RequestError: The API key is invalid. Please update it in the Settings section of the Admin Control panel.';
       }
 
-      Logger.error(message, 'GhostfolioService');
+      this.logger.error(message);
     }
 
     return dividends;
@@ -211,7 +213,7 @@ export class GhostfolioService implements DataProviderInterface {
           'RequestError: The API key is invalid. Please update it in the Settings section of the Admin Control panel.';
       }
 
-      Logger.error(error.message, 'GhostfolioService');
+      this.logger.error(error.message);
 
       throw new Error(
         `Could not get historical market data for ${symbol} (${this.getName()}) from ${format(
@@ -283,7 +285,7 @@ export class GhostfolioService implements DataProviderInterface {
           'RequestError: The API key is invalid. Please update it in the Settings section of the Admin Control panel.';
       }
 
-      Logger.error(message, 'GhostfolioService');
+      this.logger.error(message);
     }
 
     return quotes;
@@ -338,7 +340,7 @@ export class GhostfolioService implements DataProviderInterface {
           'RequestError: The API key is invalid. Please update it in the Settings section of the Admin Control panel.';
       }
 
-      Logger.error(message, 'GhostfolioService');
+      this.logger.error(message);
     }
 
     return searchResult;

apps/api/src/services/data-provider/google-sheets/google-sheets.service.ts

@@ -24,6 +24,8 @@ import { GoogleSpreadsheet } from 'google-spreadsheet';
 
 @Injectable()
 export class GoogleSheetsService implements DataProviderInterface {
+  private readonly logger = new Logger(GoogleSheetsService.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly prismaService: PrismaService,
@@ -144,7 +146,7 @@ export class GoogleSheetsService implements DataProviderInterface {
 
       return response;
     } catch (error) {
-      Logger.error(error, 'GoogleSheetsService');
+      this.logger.error(error);
     }
 
     return {};

apps/api/src/services/data-provider/manual/manual.service.ts

@@ -31,6 +31,8 @@ import { addDays, format, isBefore } from 'date-fns';
 
 @Injectable()
 export class ManualService implements DataProviderInterface {
+  private readonly logger = new Logger(ManualService.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly fetchService: FetchService,
@@ -181,9 +183,8 @@ export class ManualService implements DataProviderInterface {
               });
               return { marketPrice, symbol };
             } catch (error) {
-              Logger.error(
+              this.logger.error(
-                `Could not get quote for ${symbol} (${this.getName()}): [${error.name}] ${error.message}`,
+                `Could not get quote for ${symbol} (${this.getName()}): [${error.name}] ${error.message}`
-                'ManualService'
               );
               return { symbol, marketPrice: undefined };
             }
@@ -216,7 +217,7 @@ export class ManualService implements DataProviderInterface {
 
       return response;
     } catch (error) {
-      Logger.error(error, 'ManualService');
+      this.logger.error(error);
     }
 
     return {};

apps/api/src/services/data-provider/rapid-api/rapid-api.service.ts

@@ -26,6 +26,8 @@ import { format } from 'date-fns';
 
 @Injectable()
 export class RapidApiService implements DataProviderInterface {
+  private readonly logger = new Logger(RapidApiService.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly fetchService: FetchService
@@ -122,7 +124,7 @@ export class RapidApiService implements DataProviderInterface {
         };
       }
     } catch (error) {
-      Logger.error(error, 'RapidApiService');
+      this.logger.error(error);
     }
 
     return {};
@@ -167,7 +169,7 @@ export class RapidApiService implements DataProviderInterface {
         ).toFixed(3)} seconds`;
       }
 
-      Logger.error(message, 'RapidApiService');
+      this.logger.error(message);
 
       return undefined;
     }

apps/api/src/services/data-provider/yahoo-finance/yahoo-finance.service.ts

@@ -41,6 +41,8 @@ import { SearchQuoteNonYahoo } from 'yahoo-finance2/esm/src/modules/search';
 
 @Injectable()
 export class YahooFinanceService implements DataProviderInterface {
+  private readonly logger = new Logger(YahooFinanceService.name);
+
   private readonly yahooFinance = new YahooFinance({
     suppressNotices: ['yahooSurvey']
   });
@@ -105,12 +107,11 @@ export class YahooFinanceService implements DataProviderInterface {
 
       return response;
     } catch (error) {
-      Logger.error(
+      this.logger.error(
         `Could not get dividends for ${symbol} (${this.getName()}) from ${format(
           from,
           DATE_FORMAT
-        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`,
+        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`
-        'YahooFinanceService'
       );
 
       return {};
@@ -198,12 +199,9 @@ export class YahooFinanceService implements DataProviderInterface {
       try {
         quotes = await this.yahooFinance.quote(yahooFinanceSymbols);
       } catch (error) {
-        Logger.error(error, 'YahooFinanceService');
+        this.logger.error(error);
 
-        Logger.warn(
+        this.logger.warn('Fallback to yahooFinance.quoteSummary()');
-          'Fallback to yahooFinance.quoteSummary()',
-          'YahooFinanceService'
-        );
 
         quotes = await this.getQuotesWithQuoteSummary(yahooFinanceSymbols);
       }
@@ -229,7 +227,7 @@ export class YahooFinanceService implements DataProviderInterface {
 
       return response;
     } catch (error) {
-      Logger.error(error, 'YahooFinanceService');
+      this.logger.error(error);
 
       return {};
     }
@@ -334,7 +332,7 @@ export class YahooFinanceService implements DataProviderInterface {
         });
       }
     } catch (error) {
-      Logger.error(error, 'YahooFinanceService');
+      this.logger.error(error);
     }
 
     return { items };
@@ -365,10 +363,7 @@ export class YahooFinanceService implements DataProviderInterface {
       .filter(
         (result): result is PromiseFulfilledResult<QuoteSummaryResult> => {
           if (result.status === 'rejected') {
-            Logger.error(
+            this.logger.error(`Could not get quote summary: ${result.reason}`);
-              `Could not get quote summary: ${result.reason}`,
-              'YahooFinanceService'
-            );
 
             return false;
           }

apps/api/src/services/exchange-rate-data/exchange-rate-data.service.ts

@@ -30,6 +30,8 @@ import { ExchangeRatesByCurrency } from './interfaces/exchange-rate-data.interfa
 
 @Injectable()
 export class ExchangeRateDataService {
+  private readonly logger = new Logger(ExchangeRateDataService.name);
+
   private currencies: string[] = [];
   private currencyPairs: DataGatheringItem[] = [];
   private derivedCurrencyFactors: { [currencyPair: string]: number } = {};
@@ -110,9 +112,8 @@ export class ExchangeRateDataService {
             previousExchangeRate;
 
           if (currency === DEFAULT_CURRENCY && isBefore(date, new Date())) {
-            Logger.error(
+            this.logger.error(
-              `No exchange rate has been found for ${currency}${targetCurrency} at ${dateString}`,
+              `No exchange rate has been found for ${currency}${targetCurrency} at ${dateString}`
-              'ExchangeRateDataService'
             );
           }
         } else {
@@ -253,9 +254,8 @@ export class ExchangeRateDataService {
     }
 
     // Fallback with error, if currencies are not available
-    Logger.error(
+    this.logger.error(
-      `No exchange rate has been found for ${aFromCurrency}${aToCurrency}`,
+      `No exchange rate has been found for ${aFromCurrency}${aToCurrency}`
-      'ExchangeRateDataService'
     );
 
     return aValue;
@@ -341,12 +341,11 @@ export class ExchangeRateDataService {
       return factor * aValue;
     }
 
-    Logger.error(
+    this.logger.error(
       `No exchange rate has been found for ${aFromCurrency}${aToCurrency} at ${format(
         aDate,
         DATE_FORMAT
-      )}`,
+      )}`
-      'ExchangeRateDataService'
     );
 
     return undefined;
@@ -483,7 +482,7 @@ export class ExchangeRateDataService {
             errorMessage = `${errorMessage} and ${DEFAULT_CURRENCY}${currencyTo}`;
           }
 
-          Logger.error(`${errorMessage}.`, 'ExchangeRateDataService');
+          this.logger.error(`${errorMessage}.`);
         }
       }
     }

apps/api/src/services/fetch/fetch.service.ts

@@ -3,6 +3,7 @@ import { PropertyService } from '@ghostfolio/api/services/property/property.serv
 import {
   PROPERTY_API_KEY_OPENROUTER,
   PROPERTY_OPENROUTER_MODEL,
+  PROPERTY_OPENROUTER_MODEL_WEB_FETCH,
   PROPERTY_WEB_FETCH_ROUTES
 } from '@ghostfolio/common/config';
 
@@ -15,6 +16,8 @@ import { WebFetchRoute } from './interfaces/web-fetch-route.interface';
 
 @Injectable()
 export class FetchService implements OnModuleInit {
+  private readonly logger = new Logger(FetchService.name);
+
   private static readonly REDACTED_QUERY_PARAM_NAMES = ['apikey', 'api_token'];
   private static readonly WEB_FETCH_TIMEOUT = ms('30 seconds');
 
@@ -39,7 +42,7 @@ export class FetchService implements OnModuleInit {
     const url = input instanceof Request ? input.url : input.toString();
     const urlRedacted = this.redactUrl(url);
 
-    Logger.debug(`${method} ${urlRedacted}`, 'FetchService');
+    this.logger.debug(`${method} ${urlRedacted}`);
 
     if (method === 'GET') {
       const webFetchRoute = this.getMatchingWebFetchRoute(url);
@@ -60,15 +63,11 @@ export class FetchService implements OnModuleInit {
       return await globalThis.fetch(input, init);
     } catch (error) {
       if (error instanceof Error) {
-        Logger.error(
+        this.logger.error(
-          `${method} ${urlRedacted} failed: [${error.name}] ${error.message}`,
+          `${method} ${urlRedacted} failed: [${error.name}] ${error.message}`
-          'FetchService'
         );
       } else {
-        Logger.error(
+        this.logger.error(`${method} ${urlRedacted} failed: ${String(error)}`);
-          `${method} ${urlRedacted} failed: ${String(error)}`,
-          'FetchService'
-        );
       }
 
       throw error;
@@ -82,12 +81,18 @@ export class FetchService implements OnModuleInit {
     url: string;
     webFetchRoute: WebFetchRoute;
   }) {
-    const [openRouterApiKey, openRouterModel] = await Promise.all([
+    const [openRouterApiKey, openRouterModel, openRouterModelWebFetch] =
-      this.propertyService.getByKey<string>(PROPERTY_API_KEY_OPENROUTER),
+      await Promise.all([
-      this.propertyService.getByKey<string>(PROPERTY_OPENROUTER_MODEL)
+        this.propertyService.getByKey<string>(PROPERTY_API_KEY_OPENROUTER),
-    ]);
+        this.propertyService.getByKey<string>(PROPERTY_OPENROUTER_MODEL),
-
+        this.propertyService.getByKey<string>(
-    if (!openRouterApiKey || !openRouterModel) {
+          PROPERTY_OPENROUTER_MODEL_WEB_FETCH
+        )
+      ]);
+
+    const model = openRouterModelWebFetch || openRouterModel;
+
+    if (!model || !openRouterApiKey) {
       return undefined;
     }
 
@@ -95,7 +100,7 @@ export class FetchService implements OnModuleInit {
       const openRouterService = createOpenRouter({ apiKey: openRouterApiKey });
 
       const { sources, text } = await generateText({
-        model: openRouterService.chat(openRouterModel),
+        model: openRouterService.chat(model),
         prompt: [
           'You have access to a web_fetch tool. You MUST call it to retrieve the URL below, do not answer from prior knowledge.',
           'Return the fetched response body exactly as received: raw body only, no commentary, no Markdown, and no code fences.',
@@ -145,10 +150,7 @@ export class FetchService implements OnModuleInit {
           }
         }
 
-        Logger.debug(
+        this.logger.debug(`Routed ${this.redactUrl(url)} via web fetch tool`);
-          `Routed ${this.redactUrl(url)} via web fetch tool`,
-          'FetchService'
-        );
 
         return new Response(body, {
           headers: webFetchRoute.responseContentType
@@ -159,11 +161,10 @@ export class FetchService implements OnModuleInit {
 
       return undefined;
     } catch (error) {
-      Logger.error(
+      this.logger.error(
         `Web fetch tool failed for ${this.redactUrl(url)}: ${
           error instanceof Error ? error.message : String(error)
-        }`,
+        }`
-        'FetchService'
       );
 
       return undefined;

apps/api/src/services/i18n/i18n.service.ts

@@ -7,6 +7,8 @@ import { join } from 'node:path';
 
 @Injectable()
 export class I18nService implements OnModuleInit {
+  private readonly logger = new Logger(I18nService.name);
+
   private localesPath = join(__dirname, 'assets', 'locales');
   private translations: { [locale: string]: cheerio.CheerioAPI } = {};
 
@@ -26,7 +28,7 @@ export class I18nService implements OnModuleInit {
     const $ = this.translations[languageCode];
 
     if (!$) {
-      Logger.warn(`Translation not found for locale '${languageCode}'`);
+      this.logger.warn(`Translation not found for locale '${languageCode}'`);
     }
 
     let translatedText = $(
@@ -36,7 +38,7 @@ export class I18nService implements OnModuleInit {
     ).text();
 
     if (!translatedText) {
-      Logger.warn(
+      this.logger.warn(
         `Translation not found for id '${id}' in locale '${languageCode}'`
       );
     }
@@ -60,7 +62,7 @@ export class I18nService implements OnModuleInit {
           this.parseXml(xmlData);
       }
     } catch (error) {
-      Logger.error(error, 'I18nService');
+      this.logger.error(error);
     }
   }
 

apps/api/src/services/interfaces/environment.interface.ts

@@ -10,7 +10,6 @@ export interface Environment extends CleanedEnvAccessors {
   API_KEY_FINANCIAL_MODELING_PREP: string;
   API_KEY_OPEN_FIGI: string;
   API_KEY_RAPID_API: string;
-  BULL_BOARD_IS_READ_ONLY: boolean;
   CACHE_QUOTES_TTL: number;
   CACHE_TTL: number;
   DATA_SOURCE_EXCHANGE_RATES: string;

apps/api/src/services/prisma/prisma.service.ts

@@ -14,6 +14,8 @@ export class PrismaService
   extends PrismaClient
   implements OnModuleInit, OnModuleDestroy
 {
+  private readonly logger = new Logger(PrismaService.name);
+
   public constructor(configService: ConfigService) {
     const adapter = new PrismaPg({
       connectionString: configService.get<string>('DATABASE_URL')
@@ -43,7 +45,7 @@ export class PrismaService
     try {
       await this.$connect();
     } catch (error) {
-      Logger.error(error, 'PrismaService');
+      this.logger.error(error);
     }
   }
 

apps/api/src/services/queues/data-gathering/data-gathering.module.ts

@@ -23,8 +23,7 @@ import { DataGatheringProcessor } from './data-gathering.processor';
       adapter: BullAdapter,
       name: DATA_GATHERING_QUEUE,
       options: {
-        displayName: 'Data Gathering',
+        displayName: 'Data Gathering'
-        readOnlyMode: process.env.BULL_BOARD_IS_READ_ONLY !== 'false'
       }
     }),
     BullModule.registerQueue({

apps/api/src/services/queues/data-gathering/data-gathering.processor.ts

@@ -32,6 +32,8 @@ import { DataGatheringService } from './data-gathering.service';
 @Injectable()
 @Processor(DATA_GATHERING_QUEUE)
 export class DataGatheringProcessor {
+  private readonly logger = new Logger(DataGatheringProcessor.name);
+
   public constructor(
     private readonly dataGatheringService: DataGatheringService,
     private readonly dataProviderService: DataProviderService,
@@ -51,16 +53,14 @@ export class DataGatheringProcessor {
     const { dataSource, symbol } = job.data;
 
     try {
-      Logger.log(
+      this.logger.log(
-        `Asset profile data gathering has been started for ${symbol} (${dataSource})`,
+        `Asset profile data gathering has been started for ${symbol} (${dataSource})`
-        `DataGatheringProcessor (${GATHER_ASSET_PROFILE_PROCESS_JOB_NAME})`
       );
 
       await this.dataGatheringService.gatherAssetProfiles([job.data]);
 
-      Logger.log(
+      this.logger.log(
-        `Asset profile data gathering has been completed for ${symbol} (${dataSource})`,
+        `Asset profile data gathering has been completed for ${symbol} (${dataSource})`
-        `DataGatheringProcessor (${GATHER_ASSET_PROFILE_PROCESS_JOB_NAME})`
       );
     } catch (error) {
       if (error instanceof AssetProfileDelistedError) {
@@ -74,18 +74,14 @@ export class DataGatheringProcessor {
           }
         );
 
-        Logger.log(
+        this.logger.log(
-          `Asset profile data gathering has been discarded for ${symbol} (${dataSource})`,
+          `Asset profile data gathering has been discarded for ${symbol} (${dataSource})`
-          `DataGatheringProcessor (${GATHER_ASSET_PROFILE_PROCESS_JOB_NAME})`
         );
 
         return job.discard();
       }
 
-      Logger.error(
+      this.logger.error(error);
-        error,
-        `DataGatheringProcessor (${GATHER_ASSET_PROFILE_PROCESS_JOB_NAME})`
-      );
 
       throw error;
     }
@@ -105,12 +101,11 @@ export class DataGatheringProcessor {
     try {
       let currentDate = parseISO(date as unknown as string);
 
-      Logger.log(
+      this.logger.log(
         `Historical market data gathering has been started for ${symbol} (${dataSource}) at ${format(
           currentDate,
           DATE_FORMAT
-        )}${force ? ' (forced update)' : ''}`,
+        )}${force ? ' (forced update)' : ''}`
-        `DataGatheringProcessor (${GATHER_HISTORICAL_MARKET_DATA_PROCESS_JOB_NAME})`
       );
 
       const historicalData = await this.dataProviderService.getHistoricalRaw({
@@ -167,12 +162,11 @@ export class DataGatheringProcessor {
         await this.marketDataService.updateMany({ data });
       }
 
-      Logger.log(
+      this.logger.log(
         `Historical market data gathering has been completed for ${symbol} (${dataSource}) at ${format(
           currentDate,
           DATE_FORMAT
-        )}`,
+        )}`
-        `DataGatheringProcessor (${GATHER_HISTORICAL_MARKET_DATA_PROCESS_JOB_NAME})`
       );
     } catch (error) {
       if (error instanceof AssetProfileDelistedError) {
@@ -186,18 +180,14 @@ export class DataGatheringProcessor {
           }
         );
 
-        Logger.log(
+        this.logger.log(
-          `Historical market data gathering has been discarded for ${symbol} (${dataSource})`,
+          `Historical market data gathering has been discarded for ${symbol} (${dataSource})`
-          `DataGatheringProcessor (${GATHER_HISTORICAL_MARKET_DATA_PROCESS_JOB_NAME})`
         );
 
         return job.discard();
       }
 
-      Logger.error(
+      this.logger.error(error);
-        error,
-        `DataGatheringProcessor (${GATHER_HISTORICAL_MARKET_DATA_PROCESS_JOB_NAME})`
-      );
 
       throw error;
     }

apps/api/src/services/queues/data-gathering/data-gathering.service.ts

@@ -34,6 +34,8 @@ import ms, { StringValue } from 'ms';
 
 @Injectable()
 export class DataGatheringService {
+  private readonly logger = new Logger(DataGatheringService.name);
+
   public constructor(
     @Inject('DataEnhancers')
     private readonly dataEnhancers: DataEnhancerInterface[],
@@ -145,7 +147,7 @@ export class DataGatheringService {
         });
       }
     } catch (error) {
-      Logger.error(error, 'DataGatheringService');
+      this.logger.error(error);
     } finally {
       return undefined;
     }
@@ -176,30 +178,42 @@ export class DataGatheringService {
     );
 
     for (const [symbol, assetProfile] of Object.entries(assetProfiles)) {
-      const symbolMapping = symbolProfiles.find((symbolProfile) => {
+      const symbolProfile = symbolProfiles.find(
-        return symbolProfile.symbol === symbol;
+        ({ symbol: symbolProfileSymbol }) => {
-      })?.symbolMapping;
+          return symbolProfileSymbol === symbol;
+        }
+      );
+
+      const symbolMapping = symbolProfile?.symbolMapping;
+
+      let enhancedAssetProfile = symbolProfile
+        ? {
+            ...assetProfile,
+            assetClass: symbolProfile.assetClass ?? assetProfile.assetClass,
+            assetSubClass:
+              symbolProfile.assetSubClass ?? assetProfile.assetSubClass
+          }
+        : assetProfile;
 
       for (const dataEnhancer of this.dataEnhancers) {
         try {
-          assetProfiles[symbol] = await dataEnhancer.enhance({
+          enhancedAssetProfile = await dataEnhancer.enhance({
-            response: assetProfile,
+            response: enhancedAssetProfile,
             symbol: symbolMapping?.[dataEnhancer.getName()] ?? symbol
           });
         } catch (error) {
-          Logger.error(
+          this.logger.error(
             `Failed to enhance data for ${symbol} (${
               assetProfile.dataSource
             }) by ${dataEnhancer.getName()}`,
-            error,
+            error
-            'DataGatheringService'
           );
         }
       }
 
+      const { assetClass, assetSubClass } = assetProfile;
+
       const {
-        assetClass,
-        assetSubClass,
         countries,
         currency,
         cusip,
@@ -212,7 +226,7 @@ export class DataGatheringService {
         name,
         sectors,
         url
-      } = assetProfile;
+      } = enhancedAssetProfile;
 
       try {
         await this.prismaService.symbolProfile.upsert({
@@ -256,11 +270,7 @@ export class DataGatheringService {
           }
         });
       } catch (error) {
-        Logger.error(
+        this.logger.error(`${symbol}: ${error?.meta?.cause}`, error);
-          `${symbol}: ${error?.meta?.cause}`,
-          error,
-          'DataGatheringService'
-        );
 
         if (assetProfileIdentifiers.length === 1) {
           throw error;

apps/api/src/services/queues/portfolio-snapshot/portfolio-snapshot.module.ts

@@ -29,8 +29,7 @@ import { PortfolioSnapshotProcessor } from './portfolio-snapshot.processor';
       adapter: BullAdapter,
       name: PORTFOLIO_SNAPSHOT_COMPUTATION_QUEUE,
       options: {
-        displayName: 'Portfolio Snapshot Computation',
+        displayName: 'Portfolio Snapshot Computation'
-        readOnlyMode: process.env.BULL_BOARD_IS_READ_ONLY !== 'false'
       }
     }),
     BullModule.registerQueue({

apps/api/src/services/queues/portfolio-snapshot/portfolio-snapshot.processor.ts

@@ -21,6 +21,8 @@ import { PortfolioSnapshotQueueJob } from './interfaces/portfolio-snapshot-queue
 @Injectable()
 @Processor(PORTFOLIO_SNAPSHOT_COMPUTATION_QUEUE)
 export class PortfolioSnapshotProcessor {
+  private readonly logger = new Logger(PortfolioSnapshotProcessor.name);
+
   public constructor(
     private readonly accountBalanceService: AccountBalanceService,
     private readonly activitiesService: ActivitiesService,
@@ -41,9 +43,8 @@ export class PortfolioSnapshotProcessor {
     try {
       const startTime = performance.now();
 
-      Logger.log(
+      this.logger.log(
-        `Portfolio snapshot calculation of user '${job.data.userId}' has been started`,
+        `Portfolio snapshot calculation of user '${job.data.userId}' has been started`
-        `PortfolioSnapshotProcessor (${PORTFOLIO_SNAPSHOT_PROCESS_JOB_NAME})`
       );
 
       const { activities } =
@@ -72,12 +73,11 @@ export class PortfolioSnapshotProcessor {
 
       const snapshot = await portfolioCalculator.computeSnapshot();
 
-      Logger.log(
+      this.logger.log(
         `Portfolio snapshot calculation of user '${job.data.userId}' has been completed in ${(
           (performance.now() - startTime) /
           1000
-        ).toFixed(3)} seconds`,
+        ).toFixed(3)} seconds`
-        `PortfolioSnapshotProcessor (${PORTFOLIO_SNAPSHOT_PROCESS_JOB_NAME})`
       );
 
       const expiration = addMilliseconds(
@@ -101,10 +101,7 @@ export class PortfolioSnapshotProcessor {
 
       return snapshot;
     } catch (error) {
-      Logger.error(
+      this.logger.error(error);
-        error,
-        `PortfolioSnapshotProcessor (${PORTFOLIO_SNAPSHOT_PROCESS_JOB_NAME})`
-      );
 
       throw new Error(error);
     }

apps/api/src/services/queues/statistics-gathering/statistics-gathering.module.ts

@@ -20,8 +20,7 @@ import { StatisticsGatheringService } from './statistics-gathering.service';
             adapter: BullAdapter,
             name: STATISTICS_GATHERING_QUEUE,
             options: {
-              displayName: 'Statistics Gathering',
+              displayName: 'Statistics Gathering'
-              readOnlyMode: process.env.BULL_BOARD_IS_READ_ONLY !== 'false'
             }
           })
         ]

apps/api/src/services/queues/statistics-gathering/statistics-gathering.processor.ts

@@ -27,6 +27,8 @@ import { format, subDays } from 'date-fns';
 @Injectable()
 @Processor(STATISTICS_GATHERING_QUEUE)
 export class StatisticsGatheringProcessor {
+  private readonly logger = new Logger(StatisticsGatheringProcessor.name);
+
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly fetchService: FetchService,
@@ -35,10 +37,7 @@ export class StatisticsGatheringProcessor {
 
   @Process(GATHER_STATISTICS_DOCKER_HUB_PULLS_PROCESS_JOB_NAME)
   public async gatherDockerHubPullsStatistics() {
-    Logger.log(
+    this.logger.log('Docker Hub pulls statistics gathering has been started');
-      'Docker Hub pulls statistics gathering has been started',
-      'StatisticsGatheringProcessor'
-    );
 
     const dockerHubPulls = await this.countDockerHubPulls();
 
@@ -47,17 +46,13 @@ export class StatisticsGatheringProcessor {
       value: String(dockerHubPulls)
     });
 
-    Logger.log(
+    this.logger.log('Docker Hub pulls statistics gathering has been completed');
-      'Docker Hub pulls statistics gathering has been completed',
-      'StatisticsGatheringProcessor'
-    );
   }
 
   @Process(GATHER_STATISTICS_GITHUB_CONTRIBUTORS_PROCESS_JOB_NAME)
   public async gatherGitHubContributorsStatistics() {
-    Logger.log(
+    this.logger.log(
-      'GitHub contributors statistics gathering has been started',
+      'GitHub contributors statistics gathering has been started'
-      'StatisticsGatheringProcessor'
     );
 
     const gitHubContributors = await this.countGitHubContributors();
@@ -67,18 +62,14 @@ export class StatisticsGatheringProcessor {
       value: String(gitHubContributors)
     });
 
-    Logger.log(
+    this.logger.log(
-      'GitHub contributors statistics gathering has been completed',
+      'GitHub contributors statistics gathering has been completed'
-      'StatisticsGatheringProcessor'
     );
   }
 
   @Process(GATHER_STATISTICS_GITHUB_STARGAZERS_PROCESS_JOB_NAME)
   public async gatherGitHubStargazersStatistics() {
-    Logger.log(
+    this.logger.log('GitHub stargazers statistics gathering has been started');
-      'GitHub stargazers statistics gathering has been started',
-      'StatisticsGatheringProcessor'
-    );
 
     const gitHubStargazers = await this.countGitHubStargazers();
 
@@ -87,9 +78,8 @@ export class StatisticsGatheringProcessor {
       value: String(gitHubStargazers)
     });
 
-    Logger.log(
+    this.logger.log(
-      'GitHub stargazers statistics gathering has been completed',
+      'GitHub stargazers statistics gathering has been completed'
-      'StatisticsGatheringProcessor'
     );
   }
 
@@ -100,18 +90,14 @@ export class StatisticsGatheringProcessor {
     );
 
     if (!monitorId) {
-      Logger.log(
+      this.logger.log(
-        `Uptime statistics gathering has been skipped as no ${PROPERTY_BETTER_UPTIME_MONITOR_ID} is configured`,
+        `Uptime statistics gathering has been skipped as no ${PROPERTY_BETTER_UPTIME_MONITOR_ID} is configured`
-        'StatisticsGatheringProcessor'
       );
 
       return;
     }
 
-    Logger.log(
+    this.logger.log('Uptime statistics gathering has been started');
-      'Uptime statistics gathering has been started',
-      'StatisticsGatheringProcessor'
-    );
 
     const uptime = await this.getUptime(monitorId);
 
@@ -120,10 +106,7 @@ export class StatisticsGatheringProcessor {
       value: String(uptime)
     });
 
-    Logger.log(
+    this.logger.log('Uptime statistics gathering has been completed');
-      'Uptime statistics gathering has been completed',
-      'StatisticsGatheringProcessor'
-    );
   }
 
   private async countDockerHubPulls(): Promise<number> {
@@ -139,7 +122,7 @@ export class StatisticsGatheringProcessor {
 
       return pull_count;
     } catch (error) {
-      Logger.error(error, 'StatisticsGatheringProcessor - DockerHub');
+      this.logger.error(error);
 
       throw error;
     }
@@ -169,7 +152,7 @@ export class StatisticsGatheringProcessor {
         value
       });
     } catch (error) {
-      Logger.error(error, 'StatisticsGatheringProcessor - GitHub');
+      this.logger.error(error);
 
       throw error;
     }
@@ -188,7 +171,7 @@ export class StatisticsGatheringProcessor {
 
       return stargazers_count;
     } catch (error) {
-      Logger.error(error, 'StatisticsGatheringProcessor - GitHub');
+      this.logger.error(error);
 
       throw error;
     }
@@ -217,7 +200,7 @@ export class StatisticsGatheringProcessor {
 
       return data.attributes.availability / 100;
     } catch (error) {
-      Logger.error(error, 'StatisticsGatheringProcessor - Better Stack');
+      this.logger.error(error);
 
       throw error;
     }

apps/api/src/services/symbol-profile/symbol-profile.service.ts

@@ -1,5 +1,6 @@
 import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
 import { UNKNOWN_KEY } from '@ghostfolio/common/config';
+import { applyAssetProfileOverrides } from '@ghostfolio/common/helper';
 import {
   AssetProfileIdentifier,
   EnhancedSymbolProfile,
@@ -10,7 +11,12 @@ import { Country } from '@ghostfolio/common/interfaces/country.interface';
 import { Sector } from '@ghostfolio/common/interfaces/sector.interface';
 
 import { Injectable } from '@nestjs/common';
-import { Prisma, SymbolProfile, SymbolProfileOverrides } from '@prisma/client';
+import {
+  DataSource,
+  Prisma,
+  SymbolProfile,
+  SymbolProfileOverrides
+} from '@prisma/client';
 import { continents, countries } from 'countries-list';
 
 @Injectable()
@@ -70,6 +76,26 @@ export class SymbolProfileService {
     });
   }
 
+  public getAssetProfileUpdateInput(
+    { dataSource }: AssetProfileIdentifier,
+    data: Prisma.SymbolProfileUpdateInput
+  ): Prisma.SymbolProfileUpdateInput {
+    if (dataSource === DataSource.MANUAL) {
+      return data;
+    }
+
+    return {
+      SymbolProfileOverrides: {
+        upsert: {
+          create:
+            data as Prisma.SymbolProfileOverridesCreateWithoutSymbolProfileInput,
+          update:
+            data as Prisma.SymbolProfileOverridesUpdateWithoutSymbolProfileInput
+        }
+      }
+    };
+  }
+
   public async getSymbolProfiles(
     aAssetProfileIdentifiers: AssetProfileIdentifier[]
   ): Promise<EnhancedSymbolProfile[]> {
@@ -192,21 +218,28 @@ export class SymbolProfileService {
     })[]
   ): EnhancedSymbolProfile[] {
     return symbolProfiles.map((symbolProfile) => {
+      const symbolProfileWithOverrides = applyAssetProfileOverrides(
+        symbolProfile,
+        symbolProfile.SymbolProfileOverrides
+      );
+
       const item = {
-        ...symbolProfile,
+        ...symbolProfileWithOverrides,
         activitiesCount: 0,
         countries: this.getCountries(
-          symbolProfile?.countries as unknown as Prisma.JsonArray
+          symbolProfileWithOverrides?.countries as unknown as Prisma.JsonArray
         ),
         dateOfFirstActivity: undefined as Date,
         holdings: this.getHoldings(
-          symbolProfile?.holdings as unknown as Prisma.JsonArray
+          symbolProfileWithOverrides?.holdings as unknown as Prisma.JsonArray
+        ),
+        scraperConfiguration: this.getScraperConfiguration(
+          symbolProfileWithOverrides
         ),
-        scraperConfiguration: this.getScraperConfiguration(symbolProfile),
         sectors: this.getSectors(
-          symbolProfile?.sectors as unknown as Prisma.JsonArray
+          symbolProfileWithOverrides?.sectors as unknown as Prisma.JsonArray
         ),
-        symbolMapping: this.getSymbolMapping(symbolProfile),
+        symbolMapping: this.getSymbolMapping(symbolProfileWithOverrides),
         watchedByCount: 0
       };
 
@@ -217,45 +250,7 @@ export class SymbolProfileService {
       item.dateOfFirstActivity = symbolProfile.activities?.[0]?.date;
       delete item.activities;
 
-      if (item.SymbolProfileOverrides) {
+      delete item.SymbolProfileOverrides;
-        item.assetClass =
-          item.SymbolProfileOverrides.assetClass ?? item.assetClass;
-        item.assetSubClass =
-          item.SymbolProfileOverrides.assetSubClass ?? item.assetSubClass;
-
-        if (
-          (item.SymbolProfileOverrides.countries as unknown as Prisma.JsonArray)
-            ?.length > 0
-        ) {
-          item.countries = this.getCountries(
-            item.SymbolProfileOverrides.countries as unknown as Prisma.JsonArray
-          );
-        }
-
-        if (
-          (item.SymbolProfileOverrides.holdings as unknown as Holding[])
-            ?.length > 0
-        ) {
-          item.holdings = this.getHoldings(
-            item.SymbolProfileOverrides.holdings as unknown as Prisma.JsonArray
-          );
-        }
-
-        item.name = item.SymbolProfileOverrides.name ?? item.name;
-
-        if (
-          (item.SymbolProfileOverrides.sectors as unknown as Sector[])?.length >
-          0
-        ) {
-          item.sectors = this.getSectors(
-            item.SymbolProfileOverrides.sectors as unknown as Prisma.JsonArray
-          );
-        }
-
-        item.url = item.SymbolProfileOverrides.url ?? item.url;
-
-        delete item.SymbolProfileOverrides;
-      }
 
       return item;
     });

apps/api/src/services/twitter-bot/twitter-bot.service.ts

@@ -16,6 +16,8 @@ import { TwitterApi, TwitterApiReadWrite } from 'twitter-api-v2';
 
 @Injectable()
 export class TwitterBotService implements OnModuleInit {
+  private readonly logger = new Logger(TwitterBotService.name);
+
   private twitterClient: TwitterApiReadWrite;
 
   public constructor(
@@ -71,13 +73,12 @@ export class TwitterBotService implements OnModuleInit {
         const { data: createdTweet } =
           await this.twitterClient.v2.tweet(status);
 
-        Logger.log(
+        this.logger.log(
-          `Fear & Greed Index has been posted: https://x.com/ghostfolio_/status/${createdTweet.id}`,
+          `Fear & Greed Index has been posted: https://x.com/ghostfolio_/status/${createdTweet.id}`
-          'TwitterBotService'
         );
       }
     } catch (error) {
-      Logger.error(error, 'TwitterBotService');
+      this.logger.error(error);
     }
   }
 

apps/client/src/app/components/account-detail-dialog/account-detail-dialog.component.ts

@@ -3,7 +3,7 @@ import { UserService } from '@ghostfolio/client/services/user/user.service';
 import {
   DEFAULT_DATE_RANGE,
   DEFAULT_PAGE_SIZE,
-  NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+  NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
 } from '@ghostfolio/common/config';
 import { CreateAccountBalanceDto } from '@ghostfolio/common/dtos';
 import { DATE_FORMAT, downloadAsFile } from '@ghostfolio/common/helper';
@@ -245,7 +245,7 @@ export class GfAccountDetailDialogComponent implements OnInit {
           this.balance = balance;
 
           if (
-            this.balance >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES &&
+            this.balance >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES &&
             this.data.deviceType === 'mobile'
           ) {
             this.balancePrecision = 0;
@@ -257,7 +257,7 @@ export class GfAccountDetailDialogComponent implements OnInit {
           if (
             this.data.deviceType === 'mobile' &&
             this.dividendInBaseCurrency >=
-              NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+              NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.dividendInBaseCurrencyPrecision = 0;
           }
@@ -267,7 +267,7 @@ export class GfAccountDetailDialogComponent implements OnInit {
 
             if (
               this.data.deviceType === 'mobile' &&
-              this.equity >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+              this.equity >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
             ) {
               this.equityPrecision = 0;
             }
@@ -280,7 +280,7 @@ export class GfAccountDetailDialogComponent implements OnInit {
           if (
             this.data.deviceType === 'mobile' &&
             this.interestInBaseCurrency >=
-              NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+              NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.interestInBaseCurrencyPrecision = 0;
           }

apps/client/src/app/components/account-detail-dialog/account-detail-dialog.html

@@ -148,6 +148,7 @@
           [accountBalances]="accountBalances"
           [accountCurrency]="currency"
           [accountId]="data.accountId"
+          [currentBalance]="balance"
           [locale]="user?.settings?.locale"
           [showActions]="
             !data.hasImpersonationId &&

apps/client/src/app/components/admin-jobs/admin-jobs.component.ts

@@ -1,8 +1,5 @@
-import { TokenStorageService } from '@ghostfolio/client/services/token-storage.service';
 import { UserService } from '@ghostfolio/client/services/user/user.service';
 import {
-  BULL_BOARD_COOKIE_NAME,
-  BULL_BOARD_ROUTE,
   DATA_GATHERING_QUEUE_PRIORITY_HIGH,
   DATA_GATHERING_QUEUE_PRIORITY_LOW,
   DATA_GATHERING_QUEUE_PRIORITY_MEDIUM,
@@ -10,7 +7,6 @@ import {
 } from '@ghostfolio/common/config';
 import { getDateWithTimeFormatString } from '@ghostfolio/common/helper';
 import { AdminJobs, User } from '@ghostfolio/common/interfaces';
-import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import { NotificationService } from '@ghostfolio/ui/notifications';
 import { AdminService } from '@ghostfolio/ui/services';
 
@@ -106,7 +102,6 @@ export class GfAdminJobsComponent implements OnInit {
     'actions'
   ];
 
-  protected hasPermissionToAccessBullBoard = false;
   protected isLoading = false;
   protected readonly statusFilterOptions = QUEUE_JOB_STATUS_LIST;
 
@@ -116,7 +111,6 @@ export class GfAdminJobsComponent implements OnInit {
   private readonly changeDetectorRef = inject(ChangeDetectorRef);
   private readonly destroyRef = inject(DestroyRef);
   private readonly notificationService = inject(NotificationService);
-  private readonly tokenStorageService = inject(TokenStorageService);
   private readonly userService = inject(UserService);
 
   public constructor() {
@@ -129,11 +123,6 @@ export class GfAdminJobsComponent implements OnInit {
           this.defaultDateTimeFormat = getDateWithTimeFormatString(
             this.user.settings.locale
           );
-
-          this.hasPermissionToAccessBullBoard = hasPermission(
-            this.user.permissions,
-            permissions.accessAdminControlBullBoard
-          );
         }
       });
 
@@ -193,18 +182,6 @@ export class GfAdminJobsComponent implements OnInit {
       });
   }
 
-  protected onOpenBullBoard() {
-    const token = this.tokenStorageService.getToken();
-
-    document.cookie = [
-      `${BULL_BOARD_COOKIE_NAME}=${encodeURIComponent(token)}`,
-      'path=/',
-      'SameSite=Strict'
-    ].join('; ');
-
-    window.open(BULL_BOARD_ROUTE, '_blank');
-  }
-
   protected onViewData(aData: AdminJobs['jobs'][0]['data']) {
     this.notificationService.alert({
       title: JSON.stringify(aData, null, '  ')

apps/client/src/app/components/admin-jobs/admin-jobs.html

@@ -1,15 +1,6 @@
 <div class="container">
   <div class="row">
     <div class="col">
-      @if (hasPermissionToAccessBullBoard) {
-        <div class="d-flex justify-content-end mb-3">
-          <button mat-stroked-button (click)="onOpenBullBoard()">
-            <span><ng-container i18n>Overview</ng-container></span>
-            <ion-icon class="ml-2" name="open-outline" />
-          </button>
-        </div>
-      }
-
       <form class="align-items-center d-flex" [formGroup]="filterForm">
         <mat-form-field appearance="outline" class="w-100 without-hint">
           <mat-select formControlName="status">

apps/client/src/app/components/admin-market-data/asset-profile-dialog/asset-profile-dialog.component.scss

@@ -14,4 +14,8 @@
       top: 0;
     }
   }
+
+  .mat-mdc-dialog-title {
+    padding-right: 0.5rem !important;
+  }
 }

apps/client/src/app/components/admin-market-data/asset-profile-dialog/asset-profile-dialog.component.ts

@@ -8,6 +8,7 @@ import { UpdateAssetProfileDto } from '@ghostfolio/common/dtos';
 import {
   canDeleteAssetProfile,
   DATE_FORMAT,
+  getCountryName,
   getCurrencyFromSymbol,
   isCurrency
 } from '@ghostfolio/common/helper';
@@ -224,6 +225,7 @@ export class GfAssetProfileDialogComponent implements OnInit {
       value: 'max'
     }
   ];
+  protected readonly getCountryName = getCountryName;
   protected historicalDataItems: LineChartItem[];
   protected isBenchmark = false;
   protected isDataGatheringEnabled: boolean;
@@ -246,6 +248,8 @@ export class GfAssetProfileDialogComponent implements OnInit {
     [name: string]: { name: string; value: number };
   };
 
+  protected readonly translate = translate;
+
   protected user: User;
 
   private benchmarks: Partial<SymbolProfile>[];
@@ -367,9 +371,9 @@ export class GfAssetProfileDialogComponent implements OnInit {
           this.assetProfile?.countries &&
           this.assetProfile.countries.length > 0
         ) {
-          for (const { code, name, weight } of this.assetProfile.countries) {
+          for (const { code, weight } of this.assetProfile.countries) {
             this.countries[code] = {
-              name,
+              name: getCountryName({ code, locale: this.data.locale }),
               value: weight
             };
           }
@@ -381,7 +385,7 @@ export class GfAssetProfileDialogComponent implements OnInit {
         ) {
           for (const { name, weight } of this.assetProfile.sectors) {
             this.sectors[name] = {
-              name,
+              name: translate(name),
               value: weight
             };
           }

apps/client/src/app/components/admin-market-data/asset-profile-dialog/asset-profile-dialog.html

@@ -1,10 +1,10 @@
 <div class="d-flex flex-column h-100">
-  <div class="d-flex mb-3">
+  <div class="align-items-center d-flex mb-3" mat-dialog-title>
-    <h1 class="flex-grow-1 m-0" mat-dialog-title>
+    <span class="flex-grow-1 text-truncate">{{
-      <span>{{ assetProfile?.name ?? data.symbol }}</span>
+      assetProfile?.name ?? data.symbol
-    </h1>
+    }}</span>
     <button
-      class="mx-1 no-min-width px-2"
+      class="ml-1 no-min-width px-2"
       mat-button
       type="button"
       [matMenuTriggerFor]="assetProfileActionsMenu"
@@ -258,7 +258,7 @@
                       i18n
                       size="medium"
                       [locale]="data.locale"
-                      [value]="assetProfile?.sectors[0].name"
+                      [value]="translate(assetProfile?.sectors[0].name)"
                       >Sector</gf-value
                     >
                   </div>
@@ -269,7 +269,12 @@
                       i18n
                       size="medium"
                       [locale]="data.locale"
-                      [value]="assetProfile?.countries[0].name"
+                      [value]="
+                        getCountryName({
+                          code: assetProfile?.countries[0].code,
+                          locale: data.locale
+                        })
+                      "
                       >Country</gf-value
                     >
                   </div>

apps/client/src/app/components/admin-users/admin-users.component.ts

@@ -59,8 +59,10 @@ import {
   personOutline,
   trashOutline
 } from 'ionicons/icons';
+import ms from 'ms';
 import { DeviceDetectorService } from 'ngx-device-detector';
 import { NgxSkeletonLoaderModule } from 'ngx-skeleton-loader';
+import { interval } from 'rxjs';
 import { switchMap, tap } from 'rxjs/operators';
 
 @Component({
@@ -184,6 +186,15 @@ export class GfAdminUsersComponent implements OnInit {
 
   public ngOnInit() {
     this.fetchUsers();
+
+    interval(ms('30 seconds'))
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe(() => {
+        this.fetchUsers({
+          pageIndex: this.paginator().pageIndex,
+          showLoading: false
+        });
+      });
   }
 
   protected formatDistanceToNow(aDateString: string) {
@@ -267,8 +278,13 @@ export class GfAdminUsersComponent implements OnInit {
     );
   }
 
-  private fetchUsers({ pageIndex }: { pageIndex: number } = { pageIndex: 0 }) {
+  private fetchUsers({
-    this.isLoading = true;
+    pageIndex = 0,
+    showLoading = true
+  }: { pageIndex?: number; showLoading?: boolean } = {}) {
+    if (showLoading) {
+      this.isLoading = true;
+    }
 
     if (pageIndex === 0 && this.paginator()) {
       this.paginator().pageIndex = 0;
@@ -281,7 +297,7 @@ export class GfAdminUsersComponent implements OnInit {
       })
       .pipe(takeUntilDestroyed(this.destroyRef))
       .subscribe(({ count, users }) => {
-        this.dataSource = new MatTableDataSource(users);
+        this.dataSource.data = users;
         this.totalItems = count;
 
         this.isLoading = false;

apps/client/src/app/components/benchmark-comparator/benchmark-comparator.component.html

@@ -53,6 +53,6 @@
   <canvas
     #chartCanvas
     class="h-100"
-    [ngStyle]="{ display: isLoading() ? 'none' : 'block' }"
+    [style.display]="isLoading() ? 'none' : 'block'"
   ></canvas>
 </div>

apps/client/src/app/components/benchmark-comparator/benchmark-comparator.component.ts

@@ -17,7 +17,6 @@ import { ColorScheme } from '@ghostfolio/common/types';
 import { registerChartConfiguration } from '@ghostfolio/ui/chart';
 import { GfPremiumIndicatorComponent } from '@ghostfolio/ui/premium-indicator';
 
-import { CommonModule } from '@angular/common';
 import {
   ChangeDetectionStrategy,
   Component,
@@ -53,7 +52,6 @@ import { NgxSkeletonLoaderModule } from 'ngx-skeleton-loader';
 @Component({
   changeDetection: ChangeDetectionStrategy.OnPush,
   imports: [
-    CommonModule,
     FormsModule,
     GfPremiumIndicatorComponent,
     IonIcon,

apps/client/src/app/components/holding-detail-dialog/holding-detail-dialog.component.ts

@@ -2,11 +2,14 @@ import { UserService } from '@ghostfolio/client/services/user/user.service';
 import {
   DEFAULT_PAGE_SIZE,
   NUMERICAL_PRECISION_THRESHOLD_3_FIGURES,
-  NUMERICAL_PRECISION_THRESHOLD_5_FIGURES,
+  NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
-  NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
 } from '@ghostfolio/common/config';
 import { CreateOrderDto } from '@ghostfolio/common/dtos';
-import { DATE_FORMAT, downloadAsFile } from '@ghostfolio/common/helper';
+import {
+  DATE_FORMAT,
+  downloadAsFile,
+  getCountryName
+} from '@ghostfolio/common/helper';
 import {
   Activity,
   DataProviderInfo,
@@ -121,6 +124,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
   public dividendInBaseCurrencyPrecision = 2;
   public dividendYieldPercentWithCurrencyEffect: number;
   public feeInBaseCurrency: number;
+  public getCountryName = getCountryName;
   public hasPermissionToCreateOwnTag: boolean;
   public hasPermissionToReadMarketDataOfOwnAssetProfile: boolean;
   public historicalDataItems: LineChartItem[];
@@ -157,6 +161,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
   public SymbolProfile: EnhancedSymbolProfile;
   public tags: Tag[];
   public tagsAvailable: Tag[];
+  public translate = translate;
   public user: User;
   public value: number;
 
@@ -276,7 +281,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
           this.averagePrice = averagePrice;
 
           if (
-            this.averagePrice >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES &&
+            this.averagePrice >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES &&
             this.data.deviceType === 'mobile'
           ) {
             this.averagePricePrecision = 0;
@@ -291,7 +296,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
           if (
             this.data.deviceType === 'mobile' &&
             this.dividendInBaseCurrency >=
-              NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+              NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.dividendInBaseCurrencyPrecision = 0;
           }
@@ -329,7 +334,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
           if (
             this.data.deviceType === 'mobile' &&
             this.investmentInBaseCurrencyWithCurrencyEffect >=
-              NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+              NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.investmentInBaseCurrencyWithCurrencyEffectPrecision = 0;
           }
@@ -339,7 +344,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
 
           if (
             this.data.deviceType === 'mobile' &&
-            this.marketPriceMax >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+            this.marketPriceMax >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.marketPriceMaxPrecision = 0;
           }
@@ -348,14 +353,14 @@ export class GfHoldingDetailDialogComponent implements OnInit {
 
           if (
             this.data.deviceType === 'mobile' &&
-            this.marketPriceMin >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+            this.marketPriceMin >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.marketPriceMinPrecision = 0;
           }
 
           if (
             this.data.deviceType === 'mobile' &&
-            this.marketPrice >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+            this.marketPrice >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.marketPricePrecision = 0;
           }
@@ -364,7 +369,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
 
           if (
             this.data.deviceType === 'mobile' &&
-            this.netPerformance >= NUMERICAL_PRECISION_THRESHOLD_6_FIGURES
+            this.netPerformance >= NUMERICAL_PRECISION_THRESHOLD_5_FIGURES
           ) {
             this.netPerformancePrecision = 0;
           }
@@ -433,7 +438,10 @@ export class GfHoldingDetailDialogComponent implements OnInit {
           if (SymbolProfile?.countries?.length > 0) {
             for (const country of SymbolProfile.countries) {
               this.countries[country.code] = {
-                name: country.name,
+                name: getCountryName({
+                  code: country.code,
+                  locale: this.data.locale
+                }),
                 value: country.weight
               };
             }
@@ -442,7 +450,7 @@ export class GfHoldingDetailDialogComponent implements OnInit {
           if (SymbolProfile?.sectors?.length > 0) {
             for (const sector of SymbolProfile.sectors) {
               this.sectors[sector.name] = {
-                name: sector.name,
+                name: translate(sector.name),
                 value: sector.weight
               };
             }

apps/client/src/app/components/holding-detail-dialog/holding-detail-dialog.html

@@ -262,7 +262,7 @@
                     i18n
                     size="medium"
                     [locale]="data.locale"
-                    [value]="SymbolProfile.sectors[0].name"
+                    [value]="translate(SymbolProfile.sectors[0].name)"
                     >Sector</gf-value
                   >
                 </div>
@@ -272,7 +272,12 @@
                       i18n
                       size="medium"
                       [locale]="data.locale"
-                      [value]="SymbolProfile.countries[0].name"
+                      [value]="
+                        getCountryName({
+                          code: SymbolProfile.countries[0].code,
+                          locale: data.locale
+                        })
+                      "
                       >Country</gf-value
                     >
                   </div>

apps/client/src/app/components/investment-chart/investment-chart.component.html

@@ -10,5 +10,5 @@
 <canvas
   #chartCanvas
   class="h-100"
-  [ngStyle]="{ display: isLoading ? 'none' : 'block' }"
+  [style.display]="isLoading ? 'none' : 'block'"
 ></canvas>

apps/client/src/app/components/investment-chart/investment-chart.component.ts

@@ -16,7 +16,6 @@ import { InvestmentItem } from '@ghostfolio/common/interfaces/investment-item.in
 import { ColorScheme, GroupBy } from '@ghostfolio/common/types';
 import { registerChartConfiguration } from '@ghostfolio/ui/chart';
 
-import { CommonModule } from '@angular/common';
 import {
   ChangeDetectionStrategy,
   Component,
@@ -49,7 +48,7 @@ import { NgxSkeletonLoaderModule } from 'ngx-skeleton-loader';
 
 @Component({
   changeDetection: ChangeDetectionStrategy.OnPush,
-  imports: [CommonModule, NgxSkeletonLoaderModule],
+  imports: [NgxSkeletonLoaderModule],
   selector: 'gf-investment-chart',
   styleUrls: ['./investment-chart.component.scss'],
   templateUrl: './investment-chart.component.html'

apps/client/src/app/components/rule/rule-settings-dialog/rule-settings-dialog.component.ts

@@ -1,8 +1,7 @@
-import { XRayRulesSettings } from '@ghostfolio/common/interfaces';
 import { GfValueComponent } from '@ghostfolio/ui/value';
 
-import { Component, Inject } from '@angular/core';
+import { ChangeDetectionStrategy, Component, Inject } from '@angular/core';
-import { FormsModule } from '@angular/forms';
+import { FormBuilder, FormGroup, ReactiveFormsModule } from '@angular/forms';
 import { MatButtonModule } from '@angular/material/button';
 import {
   MAT_DIALOG_DATA,
@@ -14,22 +13,37 @@ import { MatSliderModule } from '@angular/material/slider';
 import { RuleSettingsDialogParams } from './interfaces/interfaces';
 
 @Component({
+  changeDetection: ChangeDetectionStrategy.OnPush,
   imports: [
-    FormsModule,
     GfValueComponent,
     MatButtonModule,
     MatDialogModule,
-    MatSliderModule
+    MatSliderModule,
+    ReactiveFormsModule
   ],
   selector: 'gf-rule-settings-dialog',
   styleUrls: ['./rule-settings-dialog.scss'],
   templateUrl: './rule-settings-dialog.html'
 })
 export class GfRuleSettingsDialogComponent {
-  public settings: XRayRulesSettings['AccountClusterRiskCurrentInvestment'];
+  public settingsForm: FormGroup;
 
   public constructor(
     @Inject(MAT_DIALOG_DATA) public data: RuleSettingsDialogParams,
-    public dialogRef: MatDialogRef<GfRuleSettingsDialogComponent>
+    public dialogRef: MatDialogRef<GfRuleSettingsDialogComponent>,
-  ) {}
+    private formBuilder: FormBuilder
+  ) {
+    this.settingsForm = this.formBuilder.group({
+      thresholdMax: [this.data.settings.thresholdMax],
+      thresholdMin: [this.data.settings.thresholdMin]
+    });
+  }
+
+  public onSubmit() {
+    this.dialogRef.close({
+      ...this.data.settings,
+      thresholdMax: this.settingsForm.get('thresholdMax')?.value,
+      thresholdMin: this.settingsForm.get('thresholdMin')?.value
+    });
+  }
 }

apps/client/src/app/components/rule/rule-settings-dialog/rule-settings-dialog.html

@@ -1,132 +1,142 @@
 <div mat-dialog-title>{{ data.categoryName }} › {{ data.rule.name }}</div>
 
-<div class="py-3" mat-dialog-content>
+<form
-  @if (
+  class="d-flex flex-column h-100"
-    data.rule.configuration.thresholdMin && data.rule.configuration.thresholdMax
+  [formGroup]="settingsForm"
-  ) {
+  (ngSubmit)="onSubmit()"
-    <div class="w-100">
+>
-      <h6 class="d-flex mb-0">
+  <div class="py-3" mat-dialog-content>
-        <ng-container i18n>Threshold range</ng-container>:
+    @if (
-        <gf-value
+      data.rule.configuration.thresholdMin &&
-          class="ml-1"
+      data.rule.configuration.thresholdMax
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+    ) {
-          [locale]="data.locale"
+      <div class="w-100">
-          [precision]="2"
+        <h6 class="d-flex mb-0">
-          [value]="data.settings.thresholdMin"
+          <ng-container i18n>Threshold range</ng-container>:
-        />
+          <gf-value
-        <span class="mx-1">-</span>
+            class="ml-1"
-        <gf-value
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="settingsForm.get('thresholdMin').value"
-          [value]="data.settings.thresholdMax"
+          />
-        />
+          <span class="mx-1">-</span>
-      </h6>
+          <gf-value
-      <div class="align-items-center d-flex w-100">
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-        <gf-value
+            [locale]="data.locale"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [precision]="2"
-          [locale]="data.locale"
+            [value]="settingsForm.get('thresholdMax').value"
-          [precision]="2"
+          />
-          [value]="data.rule.configuration.threshold.min"
+        </h6>
-        />
+        <div class="align-items-center d-flex w-100">
-        <mat-slider
+          <gf-value
-          class="flex-grow-1"
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [max]="data.rule.configuration.threshold.max"
+            [locale]="data.locale"
-          [min]="data.rule.configuration.threshold.min"
+            [precision]="2"
-          [step]="data.rule.configuration.threshold.step"
+            [value]="data.rule.configuration.threshold.min"
-        >
+          />
-          <input matSliderStartThumb [(ngModel)]="data.settings.thresholdMin" />
+          <mat-slider
-          <input matSliderEndThumb [(ngModel)]="data.settings.thresholdMax" />
+            class="flex-grow-1"
-        </mat-slider>
+            [max]="data.rule.configuration.threshold.max"
-        <gf-value
+            [min]="data.rule.configuration.threshold.min"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [step]="data.rule.configuration.threshold.step"
-          [locale]="data.locale"
+          >
-          [precision]="2"
+            <input formControlName="thresholdMin" matSliderStartThumb />
-          [value]="data.rule.configuration.threshold.max"
+            <input formControlName="thresholdMax" matSliderEndThumb />
-        />
+          </mat-slider>
+          <gf-value
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
+            [precision]="2"
+            [value]="data.rule.configuration.threshold.max"
+          />
+        </div>
       </div>
-    </div>
+    } @else {
-  } @else {
+      <div class="w-100" [class.d-none]="!data.rule.configuration.thresholdMin">
-    <div class="w-100" [class.d-none]="!data.rule.configuration.thresholdMin">
+        <h6 class="d-flex mb-0">
-      <h6 class="d-flex mb-0">
+          <ng-container i18n>Threshold Min</ng-container>:
-        <ng-container i18n>Threshold Min</ng-container>:
+          <gf-value
-        <gf-value
+            class="ml-1"
-          class="ml-1"
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="settingsForm.get('thresholdMin').value"
-          [value]="data.settings.thresholdMin"
+          />
-        />
+        </h6>
-      </h6>
+        <div class="align-items-center d-flex w-100">
-      <div class="align-items-center d-flex w-100">
+          <gf-value
-        <gf-value
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="data.rule.configuration.threshold.min"
-          [value]="data.rule.configuration.threshold.min"
+          />
-        />
+          <mat-slider
-        <mat-slider
+            class="flex-grow-1"
-          class="flex-grow-1"
+            name="thresholdMin"
-          name="thresholdMin"
+            [max]="data.rule.configuration.threshold.max"
-          [max]="data.rule.configuration.threshold.max"
+            [min]="data.rule.configuration.threshold.min"
-          [min]="data.rule.configuration.threshold.min"
+            [step]="data.rule.configuration.threshold.step"
-          [step]="data.rule.configuration.threshold.step"
+          >
-        >
+            <input formControlName="thresholdMin" matSliderThumb />
-          <input matSliderThumb [(ngModel)]="data.settings.thresholdMin" />
+          </mat-slider>
-        </mat-slider>
+          <gf-value
-        <gf-value
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="data.rule.configuration.threshold.max"
-          [value]="data.rule.configuration.threshold.max"
+          />
-        />
+        </div>
       </div>
-    </div>
+      <div class="w-100" [class.d-none]="!data.rule.configuration.thresholdMax">
-    <div class="w-100" [class.d-none]="!data.rule.configuration.thresholdMax">
+        <h6 class="d-flex mb-0">
-      <h6 class="d-flex mb-0">
+          <ng-container i18n>Threshold Max</ng-container>:
-        <ng-container i18n>Threshold Max</ng-container>:
+          <gf-value
-        <gf-value
+            class="ml-1"
-          class="ml-1"
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="settingsForm.get('thresholdMax').value"
-          [value]="data.settings.thresholdMax"
+          />
-        />
+        </h6>
-      </h6>
+        <div class="align-items-center d-flex w-100">
-      <div class="align-items-center d-flex w-100">
+          <gf-value
-        <gf-value
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="data.rule.configuration.threshold.min"
-          [value]="data.rule.configuration.threshold.min"
+          />
-        />
+          <mat-slider
-        <mat-slider
+            class="flex-grow-1"
-          class="flex-grow-1"
+            name="thresholdMax"
-          name="thresholdMax"
+            [max]="data.rule.configuration.threshold.max"
-          [max]="data.rule.configuration.threshold.max"
+            [min]="data.rule.configuration.threshold.min"
-          [min]="data.rule.configuration.threshold.min"
+            [step]="data.rule.configuration.threshold.step"
-          [step]="data.rule.configuration.threshold.step"
+          >
-        >
+            <input formControlName="thresholdMax" matSliderThumb />
-          <input matSliderThumb [(ngModel)]="data.settings.thresholdMax" />
+          </mat-slider>
-        </mat-slider>
+          <gf-value
-        <gf-value
+            [isPercent]="data.rule.configuration.threshold.unit === '%'"
-          [isPercent]="data.rule.configuration.threshold.unit === '%'"
+            [locale]="data.locale"
-          [locale]="data.locale"
+            [precision]="2"
-          [precision]="2"
+            [value]="data.rule.configuration.threshold.max"
-          [value]="data.rule.configuration.threshold.max"
+          />
-        />
+        </div>
       </div>
-    </div>
+    }
-  }
+  </div>
-</div>
 
-<div align="end" mat-dialog-actions>
+  <div align="end" mat-dialog-actions>
-  <button i18n mat-button (click)="dialogRef.close()">Close</button>
+    <button mat-button type="button" (click)="dialogRef.close()">
-  <button
+      <ng-container i18n>Close</ng-container>
-    color="primary"
+    </button>
-    mat-flat-button
+    <button
-    (click)="dialogRef.close(data.settings)"
+      color="primary"
-  >
+      mat-flat-button
-    <ng-container i18n>Save</ng-container>
+      type="submit"
-  </button>
+      [disabled]="!settingsForm.dirty"
-</div>
+    >
+      <ng-container i18n>Save</ng-container>
+    </button>
+  </div>
+</form>

apps/client/src/app/components/rules/rules.component.html

@@ -3,9 +3,7 @@
     <div class="col">
       @if (isLoading) {
         <gf-rule [isLoading]="true" />
-      }
+      } @else if (rules) {
-
-      @if (rules !== null && rules !== undefined) {
         @for (rule of rules; track rule.key) {
           <gf-rule
             [categoryName]="categoryName"

apps/client/src/app/components/user-detail-dialog/user-detail-dialog.component.scss

@@ -4,4 +4,8 @@
   .mat-mdc-dialog-content {
     max-height: unset;
   }
+
+  .mat-mdc-dialog-title {
+    padding-right: 0.5rem !important;
+  }
 }

apps/client/src/app/components/user-detail-dialog/user-detail-dialog.html

@@ -1,6 +1,6 @@
-<div class="d-flex justify-content-end">
+<div class="align-items-center d-flex justify-content-end" mat-dialog-title>
   <button
-    class="mx-1 no-min-width px-2"
+    class="ml-1 no-min-width px-2"
     mat-button
     type="button"
     [matMenuTriggerFor]="userDetailActionsMenu"

apps/client/src/app/pages/admin/admin-page.component.ts

@@ -1,10 +1,19 @@
+import { TokenStorageService } from '@ghostfolio/client/services/token-storage.service';
+import { UserService } from '@ghostfolio/client/services/user/user.service';
+import {
+  BULL_BOARD_COOKIE_NAME,
+  BULL_BOARD_ROUTE
+} from '@ghostfolio/common/config';
+import { User } from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import { internalRoutes } from '@ghostfolio/common/routes/routes';
 import {
   GfPageTabsComponent,
   TabConfiguration
 } from '@ghostfolio/ui/page-tabs';
 
-import { Component, OnInit } from '@angular/core';
+import { Component, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { addIcons } from 'ionicons';
 import {
   flashOutline,
@@ -21,10 +30,23 @@ import {
   styleUrls: ['./admin-page.scss'],
   templateUrl: './admin-page.html'
 })
-export class AdminPageComponent implements OnInit {
+export class AdminPageComponent {
   public tabs: TabConfiguration[] = [];
 
+  private user: User;
+
+  private readonly tokenStorageService = inject(TokenStorageService);
+  private readonly userService = inject(UserService);
+
   public constructor() {
+    this.userService.stateChanged
+      .pipe(takeUntilDestroyed())
+      .subscribe((state) => {
+        this.user = state?.user;
+
+        this.initializeTabs();
+      });
+
     addIcons({
       flashOutline,
       peopleOutline,
@@ -34,7 +56,12 @@ export class AdminPageComponent implements OnInit {
     });
   }
 
-  public ngOnInit() {
+  private initializeTabs() {
+    const hasPermissionToAccessBullBoard = hasPermission(
+      this.user?.permissions,
+      permissions.accessAdminControlBullBoard
+    );
+
     this.tabs = [
       {
         iconName: 'reader-outline',
@@ -51,11 +78,19 @@ export class AdminPageComponent implements OnInit {
         label: internalRoutes.adminControl.subRoutes.marketData.title,
         routerLink: internalRoutes.adminControl.subRoutes.marketData.routerLink
       },
-      {
+      hasPermissionToAccessBullBoard
-        iconName: 'flash-outline',
+        ? {
-        label: internalRoutes.adminControl.subRoutes.jobs.title,
+            iconName: 'flash-outline',
-        routerLink: internalRoutes.adminControl.subRoutes.jobs.routerLink
+            label: $localize`Job Queue`,
-      },
+            onClick: () => {
+              this.onOpenBullBoard();
+            }
+          }
+        : {
+            iconName: 'flash-outline',
+            label: internalRoutes.adminControl.subRoutes.jobs.title,
+            routerLink: internalRoutes.adminControl.subRoutes.jobs.routerLink
+          },
       {
         iconName: 'people-outline',
         label: internalRoutes.adminControl.subRoutes.users.title,
@@ -63,4 +98,16 @@ export class AdminPageComponent implements OnInit {
       }
     ];
   }
+
+  private onOpenBullBoard() {
+    const token = this.tokenStorageService.getToken();
+
+    document.cookie = [
+      `${BULL_BOARD_COOKIE_NAME}=${encodeURIComponent(token)}`,
+      'path=/',
+      'SameSite=Strict'
+    ].join('; ');
+
+    window.open(BULL_BOARD_ROUTE, '_blank');
+  }
 }

apps/client/src/app/pages/portfolio/activities/activities-page.html

@@ -1,5 +1,5 @@
 <div class="container">
-  <div class="mb-3 row">
+  <div class="row">
     <div class="col">
       <h1 class="d-none d-sm-block h3 mb-3 text-center" i18n>Activities</h1>
       <gf-activities-table

apps/client/src/app/pages/portfolio/activities/import-activities-dialog/import-activities-dialog.html

@@ -32,15 +32,18 @@
               <mat-label i18n>Holding</mat-label>
               <mat-select formControlName="assetProfileIdentifier">
                 <mat-select-trigger>{{
-                  assetProfileForm.get('assetProfileIdentifier')?.value?.name
+                  assetProfileForm.get('assetProfileIdentifier')?.value
+                    ?.assetProfile?.name
                 }}</mat-select-trigger>
                 @for (holding of holdings; track holding) {
                   <mat-option
                     class="line-height-1"
                     [value]="{
-                      dataSource: holding.assetProfile.dataSource,
+                      assetProfile: {
-                      name: holding.assetProfile.name,
+                        dataSource: holding.assetProfile.dataSource,
-                      symbol: holding.assetProfile.symbol
+                        name: holding.assetProfile.name,
+                        symbol: holding.assetProfile.symbol
+                      }
                     }"
                   >
                     <span

apps/client/src/app/pages/portfolio/allocations/allocations-page.component.ts

@@ -3,7 +3,7 @@ import { AccountDetailDialogParams } from '@ghostfolio/client/components/account
 import { ImpersonationStorageService } from '@ghostfolio/client/services/impersonation-storage.service';
 import { UserService } from '@ghostfolio/client/services/user/user.service';
 import { MAX_TOP_HOLDINGS, UNKNOWN_KEY } from '@ghostfolio/common/config';
-import { prettifySymbol } from '@ghostfolio/common/helper';
+import { getCountryName, prettifySymbol } from '@ghostfolio/common/helper';
 import {
   AssetProfileIdentifier,
   HoldingWithParents,
@@ -201,6 +201,26 @@ export class GfAllocationsPageComponent implements OnInit {
     }
   }
 
+  private extractCurrency({
+    assetClass,
+    assetSubClass,
+    currency
+  }: {
+    assetClass: PortfolioPosition['assetProfile']['assetClass'];
+    assetSubClass: PortfolioPosition['assetProfile']['assetSubClass'];
+    currency?: PortfolioPosition['assetProfile']['currency'];
+  }) {
+    if (
+      assetClass === AssetClass.COMMODITY ||
+      assetSubClass === AssetSubClass.CRYPTOCURRENCY
+    ) {
+      // Commodities and cryptocurrencies have no meaningful currency exposure
+      return UNKNOWN_KEY;
+    }
+
+    return currency;
+  }
+
   private extractEtfProvider({
     assetSubClass,
     name
@@ -339,7 +359,7 @@ export class GfAllocationsPageComponent implements OnInit {
           position.assetProfile.assetSubClass || (UNKNOWN_KEY as AssetSubClass),
         assetSubClassLabel:
           position.assetProfile.assetSubClassLabel || UNKNOWN_KEY,
-        currency: position.assetProfile.currency,
+        currency: this.extractCurrency(position.assetProfile),
         etfProvider: this.extractEtfProvider({
           assetSubClass: position.assetProfile.assetSubClass,
           name: position.assetProfile.name
@@ -348,116 +368,117 @@ export class GfAllocationsPageComponent implements OnInit {
         name: position.assetProfile.name
       };
 
-      if (position.assetProfile.assetClass !== AssetClass.LIQUIDITY) {
+      // Prepare analysis data by continents, countries, holdings and sectors
-        // Prepare analysis data by continents, countries, holdings and sectors except for liquidity
+
-
+      if (position.assetProfile.countries.length > 0) {
-        if (position.assetProfile.countries.length > 0) {
+        for (const country of position.assetProfile.countries) {
-          for (const country of position.assetProfile.countries) {
+          const { code, continent, weight } = country;
-            const { code, continent, name, weight } = country;
+
-
+          if (this.continents[continent]?.value) {
-            if (this.continents[continent]?.value) {
+            this.continents[continent].value +=
-              this.continents[continent].value +=
+              weight *
+              (isNumber(position.valueInBaseCurrency)
+                ? position.valueInBaseCurrency
+                : position.valueInPercentage);
+          } else {
+            this.continents[continent] = {
+              name: translate(continent),
+              value:
                 weight *
                 (isNumber(position.valueInBaseCurrency)
-                  ? position.valueInBaseCurrency
+                  ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-                  : position.valueInPercentage);
+                  : this.portfolioDetails.holdings[symbol].valueInPercentage)
-            } else {
+            };
-              this.continents[continent] = {
+          }
-                name: continent,
+
-                value:
+          if (this.countries[code]?.value) {
-                  weight *
+            this.countries[code].value +=
-                  (isNumber(position.valueInBaseCurrency)
+              weight *
-                    ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
+              (isNumber(position.valueInBaseCurrency)
-                    : this.portfolioDetails.holdings[symbol].valueInPercentage)
+                ? position.valueInBaseCurrency
-              };
+                : position.valueInPercentage);
-            }
+          } else {
-
+            this.countries[code] = {
-            if (this.countries[code]?.value) {
+              name: getCountryName({
-              this.countries[code].value +=
+                code,
+                locale: this.user?.settings?.locale
+              }),
+              value:
                 weight *
                 (isNumber(position.valueInBaseCurrency)
-                  ? position.valueInBaseCurrency
+                  ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-                  : position.valueInPercentage);
+                  : this.portfolioDetails.holdings[symbol].valueInPercentage)
-            } else {
+            };
-              this.countries[code] = {
-                name,
-                value:
-                  weight *
-                  (isNumber(position.valueInBaseCurrency)
-                    ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-                    : this.portfolioDetails.holdings[symbol].valueInPercentage)
-              };
-            }
           }
-        } else {
-          this.continents[UNKNOWN_KEY].value += isNumber(
-            position.valueInBaseCurrency
-          )
-            ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-            : this.portfolioDetails.holdings[symbol].valueInPercentage;
-
-          this.countries[UNKNOWN_KEY].value += isNumber(
-            position.valueInBaseCurrency
-          )
-            ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-            : this.portfolioDetails.holdings[symbol].valueInPercentage;
         }
+      } else {
+        this.continents[UNKNOWN_KEY].value += isNumber(
+          position.valueInBaseCurrency
+        )
+          ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
+          : this.portfolioDetails.holdings[symbol].valueInPercentage;
+
+        this.countries[UNKNOWN_KEY].value += isNumber(
+          position.valueInBaseCurrency
+        )
+          ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
+          : this.portfolioDetails.holdings[symbol].valueInPercentage;
+      }
 
-        if (position.assetProfile.holdings.length > 0) {
+      if (position.assetProfile.holdings.length > 0) {
-          for (const {
+        for (const {
-            allocationInPercentage,
+          allocationInPercentage,
-            name,
+          name,
-            valueInBaseCurrency
+          valueInBaseCurrency
-          } of position.assetProfile.holdings) {
+        } of position.assetProfile.holdings) {
-            const normalizedAssetName = this.normalizeAssetName(name);
+          const normalizedAssetName = this.normalizeAssetName(name);
-
+
-            if (this.topHoldingsMap[normalizedAssetName]?.value) {
+          if (this.topHoldingsMap[normalizedAssetName]?.value) {
-              this.topHoldingsMap[normalizedAssetName].value += isNumber(
+            this.topHoldingsMap[normalizedAssetName].value += isNumber(
-                valueInBaseCurrency
+              valueInBaseCurrency
-              )
+            )
+              ? valueInBaseCurrency
+              : allocationInPercentage *
+                this.portfolioDetails.holdings[symbol].valueInPercentage;
+          } else {
+            this.topHoldingsMap[normalizedAssetName] = {
+              name,
+              value: isNumber(valueInBaseCurrency)
                 ? valueInBaseCurrency
                 : allocationInPercentage *
-                  this.portfolioDetails.holdings[symbol].valueInPercentage;
+                  this.portfolioDetails.holdings[symbol].valueInPercentage
-            } else {
+            };
-              this.topHoldingsMap[normalizedAssetName] = {
-                name,
-                value: isNumber(valueInBaseCurrency)
-                  ? valueInBaseCurrency
-                  : allocationInPercentage *
-                    this.portfolioDetails.holdings[symbol].valueInPercentage
-              };
-            }
           }
         }
+      }
 
-        if (position.assetProfile.sectors.length > 0) {
+      if (position.assetProfile.sectors.length > 0) {
-          for (const sector of position.assetProfile.sectors) {
+        for (const sector of position.assetProfile.sectors) {
-            const { name, weight } = sector;
+          const { name, weight } = sector;
-
+
-            if (this.sectors[name]?.value) {
+          if (this.sectors[name]?.value) {
-              this.sectors[name].value +=
+            this.sectors[name].value +=
+              weight *
+              (isNumber(position.valueInBaseCurrency)
+                ? position.valueInBaseCurrency
+                : position.valueInPercentage);
+          } else {
+            this.sectors[name] = {
+              name: translate(name),
+              value:
                 weight *
                 (isNumber(position.valueInBaseCurrency)
-                  ? position.valueInBaseCurrency
+                  ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-                  : position.valueInPercentage);
+                  : this.portfolioDetails.holdings[symbol].valueInPercentage)
-            } else {
+            };
-              this.sectors[name] = {
-                name,
-                value:
-                  weight *
-                  (isNumber(position.valueInBaseCurrency)
-                    ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-                    : this.portfolioDetails.holdings[symbol].valueInPercentage)
-              };
-            }
           }
-        } else {
-          this.sectors[UNKNOWN_KEY].value += isNumber(
-            position.valueInBaseCurrency
-          )
-            ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
-            : this.portfolioDetails.holdings[symbol].valueInPercentage;
         }
+      } else {
+        this.sectors[UNKNOWN_KEY].value += isNumber(
+          position.valueInBaseCurrency
+        )
+          ? this.portfolioDetails.holdings[symbol].valueInBaseCurrency
+          : this.portfolioDetails.holdings[symbol].valueInPercentage;
       }
 
       if (this.holdings[symbol].assetSubClass === 'ETF') {

apps/client/src/app/pages/portfolio/fire/fire-page.component.ts

@@ -12,7 +12,7 @@ import { GfPremiumIndicatorComponent } from '@ghostfolio/ui/premium-indicator';
 import { DataService } from '@ghostfolio/ui/services';
 import { GfValueComponent } from '@ghostfolio/ui/value';
 
-import { CommonModule, NgStyle } from '@angular/common';
+import { CommonModule } from '@angular/common';
 import {
   ChangeDetectorRef,
   Component,
@@ -35,7 +35,6 @@ import { NgxSkeletonLoaderModule } from 'ngx-skeleton-loader';
     GfFireCalculatorComponent,
     GfPremiumIndicatorComponent,
     GfValueComponent,
-    NgStyle,
     NgxSkeletonLoaderModule,
     ReactiveFormsModule
   ],

apps/client/src/app/pages/portfolio/fire/fire-page.html

@@ -19,14 +19,15 @@
             !hasImpersonationId && hasPermissionToUpdateUserSettings
           "
           [locale]="user?.settings?.locale"
-          [ngStyle]="{
-            opacity: user?.subscription?.type === 'Basic' ? '0.67' : 'initial',
-            'pointer-events':
-              user?.subscription?.type === 'Basic' ? 'none' : 'initial'
-          }"
           [projectedTotalAmount]="user?.settings?.projectedTotalAmount"
           [retirementDate]="user?.settings?.retirementDate"
           [savingsRate]="user?.settings?.savingsRate"
+          [style.opacity]="
+            user?.subscription?.type === 'Basic' ? '0.67' : 'initial'
+          "
+          [style.pointer-events]="
+            user?.subscription?.type === 'Basic' ? 'none' : 'initial'
+          "
           (annualInterestRateChanged)="onAnnualInterestRateChange($event)"
           (calculationCompleted)="onCalculationComplete($event)"
           (projectedTotalAmountChanged)="onProjectedTotalAmountChange($event)"

apps/client/src/app/pages/public/public-page.component.ts

@@ -1,5 +1,5 @@
 import { UNKNOWN_KEY } from '@ghostfolio/common/config';
-import { prettifySymbol } from '@ghostfolio/common/helper';
+import { getCountryName, prettifySymbol } from '@ghostfolio/common/helper';
 import {
   InfoItem,
   PortfolioPosition,
@@ -9,6 +9,7 @@ import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import { Market } from '@ghostfolio/common/types';
 import { GfActivitiesTableComponent } from '@ghostfolio/ui/activities-table/activities-table.component';
 import { GfHoldingsTableComponent } from '@ghostfolio/ui/holdings-table/holdings-table.component';
+import { translate } from '@ghostfolio/ui/i18n';
 import { GfPortfolioProportionChartComponent } from '@ghostfolio/ui/portfolio-proportion-chart/portfolio-proportion-chart.component';
 import { DataService } from '@ghostfolio/ui/services';
 import { GfValueComponent } from '@ghostfolio/ui/value';
@@ -185,14 +186,14 @@ export class GfPublicPageComponent implements OnInit {
 
         if (position.assetProfile.countries.length > 0) {
           for (const country of position.assetProfile.countries) {
-            const { code, continent, name, weight } = country;
+            const { code, continent, weight } = country;
 
             if (this.continents[continent]?.value) {
               this.continents[continent].value +=
                 weight * (position.valueInBaseCurrency ?? 0);
             } else {
               this.continents[continent] = {
-                name: continent,
+                name: translate(continent),
                 value:
                   weight *
                   (this.publicPortfolioDetails.holdings[symbol]
@@ -205,7 +206,7 @@ export class GfPublicPageComponent implements OnInit {
                 weight * (position.valueInBaseCurrency ?? 0);
             } else {
               this.countries[code] = {
-                name,
+                name: getCountryName({ code }),
                 value:
                   weight *
                   (this.publicPortfolioDetails.holdings[symbol]
@@ -232,7 +233,7 @@ export class GfPublicPageComponent implements OnInit {
                 weight * (position.valueInBaseCurrency ?? 0);
             } else {
               this.sectors[name] = {
-                name,
+                name: translate(name),
                 value:
                   weight *
                   (this.publicPortfolioDetails.holdings[symbol]

apps/client/src/app/pages/resources/personal-finance-tools/product-page.component.ts

@@ -1,3 +1,4 @@
+import { getCountryName } from '@ghostfolio/common/helper';
 import { Product } from '@ghostfolio/common/interfaces';
 import { personalFinanceTools } from '@ghostfolio/common/personal-finance-tools';
 import { publicRoutes } from '@ghostfolio/common/routes/routes';
@@ -32,6 +33,7 @@ export class GfProductPageComponent implements OnInit {
   ) {}
 
   public ngOnInit() {
+    const locale = document.documentElement.lang;
     const { subscriptionOffer } = this.dataService.fetchInfo();
 
     this.price = subscriptionOffer?.price;
@@ -55,18 +57,23 @@ export class GfProductPageComponent implements OnInit {
         'Türkçe'
       ],
       name: 'Ghostfolio',
-      origin: $localize`Switzerland`,
+      origin: getCountryName({ locale, code: 'CH' }),
       regions: [$localize`Global`],
       slogan: 'Open Source Wealth Management',
       useAnonymously: true
     };
 
-    this.product2 = personalFinanceTools.find(({ key }) => {
+    this.product2 = {
-      return key === this.route.snapshot.data['key'];
+      ...personalFinanceTools.find(({ key }) => {
-    });
+        return key === this.route.snapshot.data['key'];
+      })
+    };
 
     if (this.product2.origin) {
-      this.product2.origin = translate(this.product2.origin);
+      this.product2.origin = getCountryName({
+        locale,
+        code: this.product2.origin
+      });
     }
 
     if (this.product2.regions) {