MIM-537: Get residence data by rental id (#311)

* add residence by rental id route

* type updates

* add tests for new route

Author: momentiris

src/adapters/property-base-adapter/generated/api-types.ts

@@ -210,6 +210,62 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/residences/rental-id/{rentalId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a residence by rental ID
+         * @description Returns a residence with the specified rental ID
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The rental ID of the residence */
+                    rentalId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successfully retrieved the residence */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetResidenceByRentalIdResponse"];
+                    };
+                };
+                /** @description Residence not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/residences/{id}": {
         parameters: {
             query?: never;
@@ -1342,6 +1398,95 @@ export interface components {
             disableQuantitiesBelowCompany: number;
             timestamp: string;
         };
+        ResidenceByRentalId: {
+            id: string;
+            code: string;
+            name: string | null;
+            accessibility: {
+                wheelchairAccessible: boolean;
+                elevator: boolean;
+            };
+            features: {
+                hygieneFacility: string | null;
+            };
+            entrance: string | null;
+            deleted: boolean;
+            type: {
+                code: string;
+                name: string | null;
+                roomCount: number | null;
+                kitchen: number;
+            };
+            rentalInformation: {
+                apartmentNumber: string | null;
+                rentalId: string | null;
+                type: {
+                    code: string;
+                    name: string | null;
+                };
+            } | null;
+            property: {
+                id: string | null;
+                name: string | null;
+                code: string | null;
+            };
+            building: {
+                id: string | null;
+                name: string | null;
+                code: string | null;
+            };
+            areaSize: number | null;
+        };
+        GetResidenceByRentalIdResponse: {
+            content: {
+                id: string;
+                code: string;
+                name: string | null;
+                accessibility: {
+                    wheelchairAccessible: boolean;
+                    elevator: boolean;
+                };
+                features: {
+                    hygieneFacility: string | null;
+                };
+                entrance: string | null;
+                deleted: boolean;
+                type: {
+                    code: string;
+                    name: string | null;
+                    roomCount: number | null;
+                    kitchen: number;
+                };
+                rentalInformation: {
+                    apartmentNumber: string | null;
+                    rentalId: string | null;
+                    type: {
+                        code: string;
+                        name: string | null;
+                    };
+                } | null;
+                property: {
+                    id: string | null;
+                    name: string | null;
+                    code: string | null;
+                };
+                building: {
+                    id: string | null;
+                    name: string | null;
+                    code: string | null;
+                };
+                areaSize: number | null;
+            };
+            _links: {
+                self: {
+                    href: string;
+                };
+                link: {
+                    href: string;
+                    templated: boolean;
+                };
+            };
+        };
     };
     responses: never;
     parameters: never;

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

@@ -199,6 +199,39 @@ export async function getResidenceDetails(
   }
 }
 
+type GetResidenceByRentalIdResponse =
+  components['schemas']['GetResidenceByRentalIdResponse']['content']
+
+export async function getResidenceByRentalId(
+  rentalId: string
+): Promise<
+  AdapterResult<GetResidenceByRentalIdResponse, 'not-found' | 'unknown'>
+> {
+  try {
+    const fetchResponse = await client().GET(
+      '/residences/rental-id/{rentalId}',
+      {
+        params: { path: { rentalId: rentalId } },
+      }
+    )
+
+    if (fetchResponse.data?.content) {
+      return { ok: true, data: fetchResponse.data.content }
+    }
+
+    if (fetchResponse.response.status === 404) {
+      return { ok: false, err: 'not-found' }
+    }
+
+    throw new Error(
+      `Unexpected response status: ${fetchResponse.response.status}`
+    )
+  } catch (err) {
+    logger.error({ err }, 'property-base-adapter.getResidenceByRentalId')
+    return { ok: false, err: 'unknown' }
+  }
+}
+
 type GetStaircasesResponse = components['schemas']['Staircase'][]
 
 export async function getStaircases(

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

@@ -189,6 +189,60 @@ describe('property-base-adapter', () => {
     })
   })
 
+  describe('getResidenceByRentalId', () => {
+    it('returns err if request fails', async () => {
+      const residenceDetailsMock = factory.residenceByRentalIdDetails.build()
+
+      mockServer.use(
+        http.get(
+          `${config.propertyBaseService.url}/residences/rental-id/1234`,
+          () => new HttpResponse(null, { status: 500 })
+        )
+      )
+
+      const result = await propertyBaseAdapter.getResidenceByRentalId('1234')
+
+      expect(result.ok).toBe(false)
+      if (!result.ok) expect(result.err).toBe('unknown')
+    })
+
+    it('returns not-found if residence is not found', async () => {
+      mockServer.use(
+        http.get(
+          `${config.propertyBaseService.url}/residences/rental-id/1234`,
+          () => new HttpResponse(null, { status: 404 })
+        )
+      )
+
+      const result = await propertyBaseAdapter.getResidenceByRentalId('1234')
+
+      expect(result.ok).toBe(false)
+      if (!result.ok) expect(result.err).toBe('not-found')
+    })
+
+    it('returns residence', async () => {
+      const residenceDetailsMock = factory.residenceByRentalIdDetails.build()
+      mockServer.use(
+        http.get(
+          `${config.propertyBaseService.url}/residences/rental-id/1234`,
+          () =>
+            HttpResponse.json(
+              {
+                content: residenceDetailsMock,
+              },
+              { status: 200 }
+            )
+        )
+      )
+
+      const result = await propertyBaseAdapter.getResidenceByRentalId('1234')
+
+      expect(result).toMatchObject({
+        ok: true,
+        data: residenceDetailsMock,
+      })
+    })
+  })
   describe('getResidenceDetails', () => {
     it('returns err if request fails', async () => {
       const residenceDetailsMock = factory.residenceDetails.build()

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

@@ -7,6 +7,7 @@ import { logger, generateRouteMetadata } from 'onecore-utilities'
 import { registerSchema } from '../../utils/openapi'
 import * as schemas from './schemas'
 import { calculateResidenceStatus } from './calculate-residence-status'
+import { z } from 'zod'
 
 /**
  * @swagger
@@ -30,6 +31,10 @@ export const routes = (router: KoaRouter) => {
   registerSchema('ResidenceDetails', schemas.ResidenceDetailsSchema)
   registerSchema('Staircase', schemas.StaircaseSchema)
   registerSchema('Room', schemas.RoomSchema)
+  registerSchema(
+    'ResidenceByRentalIdDetails',
+    schemas.ResidenceByRentalIdSchema
+  )
 
   /**
    * @swagger
@@ -341,6 +346,81 @@ export const routes = (router: KoaRouter) => {
     }
   })
 
+  /**
+   * @swagger
+   * /propertyBase/residence/rental-id/{rentalId}:
+   *   get:
+   *     summary: Get residence data by residence rental id
+   *     tags:
+   *       - Property base Service
+   *     description: Retrieves residence data by residence rental id
+   *     parameters:
+   *       - in: path
+   *         name: rentalId
+   *         required: true
+   *         schema:
+   *           type: string
+   *         description: Rental id for the residence to fetch
+   *     responses:
+   *       '200':
+   *         description: Successfully retrieved residence.
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 content:
+   *                   $ref: '#/components/schemas/ResidenceByRentalIdDetails'
+   *       '404':
+   *         description: Residence not found
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 error:
+   *                   type: string
+   *                   example: Residence not found
+   *       '500':
+   *         description: Internal server error. Failed to retrieve residence data.
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 error:
+   *                   type: string
+   *                   example: Internal server error
+   *     security:
+   *       - bearerAuth: []
+   */
+  router.get('(.*)/propertyBase/residence/rental-id/:rentalId', async (ctx) => {
+    const metadata = generateRouteMetadata(ctx)
+    const { rentalId } = ctx.params
+
+    const getResidence =
+      await propertyBaseAdapter.getResidenceByRentalId(rentalId)
+
+    if (!getResidence.ok) {
+      if (getResidence.err === 'not-found') {
+        ctx.status = 404
+        ctx.body = { error: 'Residence not found', ...metadata }
+        return
+      }
+
+      logger.error(getResidence.err, 'Internal server error', metadata)
+      ctx.status = 500
+      ctx.body = { error: 'Internal server error', ...metadata }
+      return
+    }
+
+    ctx.status = 200
+    ctx.body = {
+      content: getResidence.data satisfies schemas.ResidenceByRentalIdDetails,
+      ...metadata,
+    }
+  })
+
   /**
    * @swagger
    * /propertyBase/residence/{residenceId}: