fix(license-service): check app version

libs/api/domains/license-service/src/lib/licenceService.type.ts

@@ -2,6 +2,7 @@ import { Locale } from '@island.is/shared/types'
 import { GenericLicenseError } from './dto/GenericLicenseError.dto'
 import { Payload } from './dto/Payload.dto'
 import { GenericUserLicense as GenericUserLicenseModel } from './dto/GenericUserLicense.dto'
+import { UserAgent } from '@island.is/nest/core'
 
 export interface GenericLicenseMappedPayloadResponse {
   licenseName: string
@@ -145,5 +146,6 @@ export interface GenericLicenseMapper {
   parsePayload: (
     payload: Array<unknown>,
     locale: Locale,
+    userAgent?: UserAgent,
   ) => Promise<Array<GenericLicenseMappedPayloadResponse>>
 }

libs/api/domains/license-service/src/lib/licenseService.service.ts

@@ -47,6 +47,7 @@ import {
   BarcodeService,
   TOKEN_EXPIRED_ERROR,
 } from '@island.is/services/license'
+import { UserAgent } from '@island.is/nest/core'
 
 const LOG_CATEGORY = 'license-service'
 
@@ -96,6 +97,7 @@ export class LicenseService {
     user: User,
     locale: Locale,
     { includedTypes, excludedTypes, onlyList }: GetGenericLicenseOptions = {},
+    userAgent?: UserAgent,
   ): Promise<LicenseCollection> {
     const fetchPromises = AVAILABLE_LICENSES.map(async (license) => {
       if (excludedTypes && excludedTypes.indexOf(license.type) >= 0) {
@@ -107,7 +109,7 @@ export class LicenseService {
       }
 
       if (!onlyList) {
-        return this.getLicensesOfType(user, locale, license.type)
+        return this.getLicensesOfType(user, locale, license.type, userAgent)
       }
 
       return null
@@ -140,6 +142,7 @@ export class LicenseService {
     user: User,
     locale: Locale,
     licenseType: GenericLicenseType,
+    agent?: UserAgent,
   ): Promise<LicenseTypeFetchResponse | null> {
     const licenseTypeDefinition = AVAILABLE_LICENSES.find(
       (i) => i.type === licenseType,
@@ -187,6 +190,7 @@ export class LicenseService {
     const licensesPayload = await mapper.parsePayload(
       licensesFetchResponse.data,
       locale,
+      agent,
     )
 
     const mappedLicenses: Array<GenericUserLicense> = await Promise.all(
@@ -246,11 +250,13 @@ export class LicenseService {
     locale: Locale,
     licenseType: GenericLicenseType,
     licenseId?: string,
+    agent?: UserAgent,
   ): Promise<GenericUserLicense | LicenseError | null> {
     const licensesOfType = await this.getLicensesOfType(
       user,
       locale,
       licenseType,
+      agent,
     )
 
     if (!licensesOfType) {

libs/api/domains/license-service/src/lib/mappers/firearmLicenseMapper.ts

@@ -15,22 +15,34 @@ import {
   GenericUserLicenseMetaLinksType,
 } from '../licenceService.type'
 import { FirearmLicenseDto } from '@island.is/clients/license-client'
-import { Injectable } from '@nestjs/common'
+import { Inject, Injectable } from '@nestjs/common'
 import { isDefined } from '@island.is/shared/utils'
 import { FormatMessage, IntlService } from '@island.is/cms-translations'
 import { m } from '../messages'
 import { expiryTag, formatDate } from '../utils'
 import { GenericLicenseDataField } from '../dto/GenericLicenseDataField.dto'
+import { UserAgent } from '@island.is/nest/core'
+import { enableAppCompatibilityMode } from '../utils/appCompatibilityMode'
+import { LOGGER_PROVIDER, type Logger } from '@island.is/logging'
+
+const APP_VERSION_CUTOFF = '1.4.7'
 
 @Injectable()
 export class FirearmLicensePayloadMapper implements GenericLicenseMapper {
   constructor(private readonly intlService: IntlService) {}
   async parsePayload(
     payload: Array<unknown>,
     locale: Locale = 'is',
+    userAgent?: UserAgent,
   ): Promise<Array<GenericLicenseMappedPayloadResponse>> {
     if (!payload) return Promise.resolve([])
 
+    //App version before 1.4.8 doesn't know how to handle table
+    const enableAppCompatibility = enableAppCompatibilityMode(
+      userAgent?.app?.version,
+      APP_VERSION_CUTOFF,
+    )
+
     const typedPayload = payload as Array<FirearmLicenseDto>
 
     const { formatMessage } = await this.intlService.useIntl(
@@ -99,21 +111,9 @@ export class FirearmLicensePayloadMapper implements GenericLicenseMapper {
               : null,
             properties
               ? {
-                  type: GenericLicenseDataFieldType.Group,
-                  hideFromServicePortal: true,
-                  label: formatMessage(m.firearmProperties),
-                  fields: (properties.properties ?? []).map((property) => ({
-                    type: GenericLicenseDataFieldType.Category,
-                    fields: this.parseProperties(
-                      property,
-                      formatMessage,
-                    )?.filter(isDefined),
-                  })),
-                }
-              : null,
-            properties
-              ? {
-                  type: GenericLicenseDataFieldType.Table,
+                  type: enableAppCompatibility
+                    ? GenericLicenseDataFieldType.Group
+                    : GenericLicenseDataFieldType.Table,
                   label: formatMessage(m.firearmProperties),
                   fields: (properties.properties ?? []).map((property) => ({
                     type: GenericLicenseDataFieldType.Category,

libs/api/domains/license-service/src/lib/resolvers/licenseCollection.resolver.ts

@@ -9,26 +9,32 @@ import { ApiScope } from '@island.is/auth/scopes'
 import { Audit } from '@island.is/nest/audit'
 
 import type { Locale } from '@island.is/shared/types'
-import { UseGuards } from '@nestjs/common'
+import { Inject, UseGuards } from '@nestjs/common'
 import { Args, Query, Resolver } from '@nestjs/graphql'
 import { GetGenericLicensesInput } from '../dto/GetGenericLicenses.input'
 import { LicenseService } from '../licenseService.service'
 import { LicenseCollection } from '../dto/GenericLicenseCollection.dto'
 import { GenericUserLicense } from '../dto/GenericUserLicense.dto'
+import { LOGGER_PROVIDER, type Logger } from '@island.is/logging'
+import { ParsedUserAgent, type UserAgent } from '@island.is/nest/core'
 
 @UseGuards(IdsUserGuard, ScopesGuard)
 @Scopes(ApiScope.internal, ApiScope.licenses)
 @Resolver(() => LicenseCollection)
 @Audit({ namespace: '@island.is/api/license-service' })
 export class LicenseCollectionResolver {
-  constructor(private readonly licenseServiceService: LicenseService) {}
+  constructor(
+    private readonly licenseServiceService: LicenseService,
+    @Inject(LOGGER_PROVIDER) private readonly logger: Logger,
+  ) {}
 
   @Query(() => [GenericUserLicense], {
     deprecationReason: 'Use genericLicenseCollection instead',
   })
   @Audit()
   async genericLicenses(
     @CurrentUser() user: User,
+    @ParsedUserAgent() agent: UserAgent,
     @Args('locale', { type: () => String, nullable: true })
     locale: Locale = 'is',
     @Args('input', { nullable: true }) input?: GetGenericLicensesInput,
@@ -43,6 +49,7 @@ export class LicenseCollectionResolver {
         force: input?.force,
         onlyList: input?.onlyList,
       },
+      agent,
     )
 
     return collection.licenses
@@ -54,18 +61,24 @@ export class LicenseCollectionResolver {
   @Audit()
   async genericLicenseCollection(
     @CurrentUser() user: User,
+    @ParsedUserAgent() agent: UserAgent,
     @Args('locale', { type: () => String, nullable: true })
     locale: Locale = 'is',
     @Args('input') input: GetGenericLicensesInput,
   ) {
     const licenseCollection =
-      await this.licenseServiceService.getLicenseCollection(user, locale, {
-        ...input,
-        includedTypes: input?.includedTypes ?? ['DriversLicense'],
-        excludedTypes: input?.excludedTypes,
-        force: input?.force,
-        onlyList: input?.onlyList,
-      })
+      await this.licenseServiceService.getLicenseCollection(
+        user,
+        locale,
+        {
+          ...input,
+          includedTypes: input?.includedTypes ?? ['DriversLicense'],
+          excludedTypes: input?.excludedTypes,
+          force: input?.force,
+          onlyList: input?.onlyList,
+        },
+        agent,
+      )
     return licenseCollection
   }
 }

libs/api/domains/license-service/src/lib/resolvers/userLicense.resolver.ts

@@ -15,6 +15,8 @@ import { GenericUserLicense } from '../dto/GenericUserLicense.dto'
 import { GetGenericLicenseInput } from '../dto/GetGenericLicense.input'
 import { LicenseService } from '../licenseService.service'
 import { GenericLicenseError } from '../dto/GenericLicenseError.dto'
+import { logger } from '@island.is/logging'
+import { ParsedUserAgent, type UserAgent } from '@island.is/nest/core'
 
 @UseGuards(IdsUserGuard, ScopesGuard)
 @Scopes(ApiScope.internal, ApiScope.licenses)
@@ -29,6 +31,8 @@ export class UserLicenseResolver {
   @Audit()
   async genericLicense(
     @CurrentUser() user: User,
+    @ParsedUserAgent()
+    agent: UserAgent,
     @Args('locale', { type: () => String, nullable: true })
     locale: Locale = 'is',
     @Args('input') input: GetGenericLicenseInput,
@@ -38,6 +42,7 @@ export class UserLicenseResolver {
       locale,
       input.licenseType,
       input.licenseId,
+      agent,
     )
 
     if (license instanceof GenericLicenseError) {

libs/api/domains/license-service/src/lib/utils/appCompatibilityMode.ts

@@ -0,0 +1,15 @@
+export const enableAppCompatibilityMode = (
+  version?: string,
+  versionToCompare?: string,
+): boolean => {
+  if (!version || !versionToCompare) {
+    return false
+  }
+
+  const versionComparison = version.localeCompare(versionToCompare, undefined, {
+    numeric: true,
+    sensitivity: 'base',
+  })
+
+  return versionComparison <= 0
+}