Merge pull request #41 from Bostads-AB-Mimer/feature/mim-608-hamta-byggnader-pa-fastighetskod-endpoint-i-core

MIM-608: Fetch building on property code in core

Author: simonkropp

core/src/adapters/property-base-adapter/index.ts

@@ -423,6 +423,30 @@ export async function getFacilityByRentalId(
   }
 }
 
+type GetBuildingsResponse = components['schemas']['Building'][]
+
+export async function getBuildingsByPropertyCode(
+  propertyCode: string
+): Promise<AdapterResult<GetBuildingsResponse, unknown>> {
+  try {
+    const fetchResponse = await client().GET('/buildings', {
+      params: { query: { propertyCode } },
+    })
+
+    if (fetchResponse.data?.content) {
+      return { ok: true, data: fetchResponse.data.content }
+    }
+
+    return { ok: false, err: 'unknown' }
+  } catch (err) {
+    logger.error(
+      { err },
+      '@onecore/property-adapter.getBuildingsByPropertyCode'
+    )
+    return { ok: false, err }
+  }
+}
+
 type GetMaintenanceUnitsByPropertyCodeResponse =
   components['schemas']['MaintenanceUnit'][]
 

core/src/adapters/tests/property-base-adapter.test.ts

@@ -614,6 +614,45 @@ describe('@onecore/property-adapter', () => {
     })
   })
 
+  describe('getBuildings', () => {
+    it('returns err if request fails', async () => {
+      mockServer.use(
+        http.get(
+          `${config.propertyBaseService.url}/buildings`,
+          () => new HttpResponse(null, { status: 500 })
+        )
+      )
+
+      const result =
+        await propertyBaseAdapter.getBuildingsByPropertyCode('001-001')
+
+      expect(result.ok).toBe(false)
+      if (!result.ok) expect(result.err).toBe('unknown')
+    })
+
+    it('returns buildings', async () => {
+      const buildingsMock = factory.building.buildList(3)
+      mockServer.use(
+        http.get(`${config.propertyBaseService.url}/buildings`, () =>
+          HttpResponse.json(
+            {
+              content: buildingsMock,
+            },
+            { status: 200 }
+          )
+        )
+      )
+
+      const result =
+        await propertyBaseAdapter.getBuildingsByPropertyCode('001-001')
+
+      expect(result).toMatchObject({
+        ok: true,
+        data: buildingsMock,
+      })
+    })
+  })
+
   describe('getMaintenanceUnitsByPropertyCode', () => {
     it('returns maintenance units for a property', async () => {
       const maintenanceUnitsMock = factory.maintenanceUnitInfo.buildList(3)

core/src/services/property-base-service/index.ts

@@ -122,6 +122,74 @@ export const routes = (router: KoaRouter) => {
     }
   )
 
+  /**
+   * @swagger
+   * /propertyBase/buildings/by-property-code/{propertyCode}:
+   *   get:
+   *     summary: Get buildings by property code
+   *     tags:
+   *       - Property base Service
+   *     description: Retrieves buildings by property code
+   *     parameters:
+   *       - in: path
+   *         name: propertyCode
+   *         required: true
+   *         schema:
+   *           type: string
+   *         description: The code of the property to fetch buildings for
+   *     responses:
+   *       '200':
+   *         description: Successfully retrieved buildings
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 content:
+   *                   type: array
+   *                   items:
+   *                     $ref: '#/components/schemas/Building'
+   *       '500':
+   *         description: Internal server error
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 error:
+   *                   type: string
+   *                   example: Internal server error
+   *     security:
+   *       - bearerAuth: []
+   */
+  router.get(
+    '(.*)/propertyBase/buildings/by-property-code/:propertyCode',
+    async (ctx) => {
+      const metadata = generateRouteMetadata(ctx)
+      const { propertyCode } = ctx.params
+
+      try {
+        const result =
+          await propertyBaseAdapter.getBuildingsByPropertyCode(propertyCode)
+        if (!result.ok) {
+          logger.error(result.err, 'Internal server error', metadata)
+          ctx.status = 500
+          ctx.body = { error: 'Internal server error', ...metadata }
+          return
+        }
+
+        ctx.body = {
+          content: result.data satisfies schemas.Building[],
+          ...metadata,
+        }
+      } catch (error) {
+        logger.error(error, 'Internal server error', metadata)
+        ctx.status = 500
+        ctx.body = { error: 'Internal server error', ...metadata }
+      }
+    }
+  )
+
   /**
    * @swagger
    * /propertyBase/companies:

core/src/services/property-base-service/schemas.ts

@@ -3,20 +3,20 @@ import { z } from 'zod'
 export const BuildingSchema = z.object({
   id: z.string(),
   code: z.string(),
-  name: z.string(),
+  name: z.string().nullable(),
   buildingType: z.object({
-    id: z.string(),
-    code: z.string(),
-    name: z.string(),
+    id: z.string().nullable(),
+    code: z.string().nullable(),
+    name: z.string().nullable(),
   }),
   construction: z.object({
-    constructionYear: z.number(),
-    renovationYear: z.number(),
+    constructionYear: z.number().nullable(),
+    renovationYear: z.number().nullable(),
     valueYear: z.number().nullable(),
   }),
   features: z.object({
-    heating: z.string().nullable(),
-    fireRating: z.string().nullable(),
+    heating: z.string().nullable().optional(),
+    fireRating: z.string().nullable().optional(),
   }),
   insurance: z.object({
     class: z.string().nullable(),

core/src/services/property-base-service/tests/index.test.ts

@@ -10,6 +10,7 @@ import * as leasingAdapter from '../../../adapters/leasing-adapter'
 
 import * as factory from '../../../../test/factories'
 import {
+  BuildingSchema,
   CompanySchema,
   PropertySchema,
   ResidenceSchema,
@@ -74,6 +75,41 @@ describe('@onecore/property-service', () => {
     })
   })
 
+  describe('GET /propertyBase/buildings/by-property-code/:propertyCode', () => {
+    it('returns 200 and a list of buildings', async () => {
+      const buildingsMock = factory.building.buildList(3)
+      const getBuildingsSpy = jest
+        .spyOn(propertyBaseAdapter, 'getBuildingsByPropertyCode')
+        .mockResolvedValueOnce({ ok: true, data: buildingsMock })
+
+      const res = await request(app.callback()).get(
+        '/propertyBase/buildings/by-property-code/001-001'
+      )
+
+      expect(res.status).toBe(200)
+      expect(getBuildingsSpy).toHaveBeenCalledWith('001-001')
+      expect(JSON.stringify(res.body.content)).toEqual(
+        JSON.stringify(buildingsMock)
+      )
+      expect(() =>
+        z.array(BuildingSchema).parse(res.body.content)
+      ).not.toThrow()
+    })
+
+    it('returns 500 if no buildings can be retrieved', async () => {
+      const getBuildingsSpy = jest
+        .spyOn(propertyBaseAdapter, 'getBuildingsByPropertyCode')
+        .mockResolvedValueOnce({ ok: false, err: 'unknown' })
+
+      const res = await request(app.callback()).get(
+        '/propertyBase/buildings/by-property-code/001-001'
+      )
+
+      expect(res.status).toBe(500)
+      expect(getBuildingsSpy).toHaveBeenCalledWith('001-001')
+    })
+  })
+
   describe('GET /propertyBase/companies', () => {
     it('returns 200 and a list of companies', async () => {
       const companiesMock = factory.company.buildList(3)