Gg/three tier continue

app/data/buildPriceRepo.ts

@@ -0,0 +1,23 @@
+import prisma from "./db";
+
+const getBuildPriceByHouseType = async (houseType: string): Promise<number> => {
+  try {
+    const { priceMid: buildPrice } = await prisma.buildPrices.findFirstOrThrow({
+      where: {
+        houseType: { equals: houseType },
+      },
+      select: { priceMid: true },
+    });
+
+    // Cast to string as 'not: null' clause in Prisma query does not type narrow
+    return buildPrice as number;
+  } catch (error) {
+    throw new Error(
+      `Data error: Unable to get buildPrice for houseType ${houseType}`
+    );
+  }
+};
+
+export const buildPriceRepo = {
+  getBuildPriceByHouseType,
+};

app/data/gasBillRepo.ts

@@ -0,0 +1,21 @@
+import prisma from "./db";
+
+const getGasBillByITL3 = async (itl: string): Promise<number> => {
+    try {
+        const { bill } = await prisma.gasBills.findFirstOrThrow({
+            where: {
+                itl: { startsWith: itl.substring(0, 3) },
+            },
+            select: { bill: true },
+        });
+
+        return bill as number;
+    } catch (error) {
+        throw Error(`Data error: Unable to find gas_bills_2020 for itl3 ${itl}`);
+    }
+};
+
+export const gasBillRepo = {
+    getGasBillByITL3,
+  };
+

app/data/gdhiRepo.ts

@@ -1,15 +1,13 @@
 import prisma from "./db";
 
-const getGDHI2020ByITL3 = async (
-  itl3: string
-): Promise<number> => {
+const getGDHI2020ByITL3 = async (itl3: string): Promise<number> => {
   try {
     const { gdhi2020 } = await prisma.gDHI.findFirstOrThrow({
       where: {
         AND: {
           itl3: { equals: itl3 },
           // TODO: Add `NOT NULL` constraint to column
-          gdhi2020: { not: null }
+          gdhi2020: { not: null },
         },
       },
       select: { gdhi2020: true },
@@ -23,4 +21,5 @@ const getGDHI2020ByITL3 = async (
 
 export const gdhiRepo = {
   getGDHI2020ByITL3,
-}
+};
+

app/data/hpiRepo.ts

@@ -0,0 +1,26 @@
+import prisma from "./db";
+
+const getHPIByITL3 = async (itl3: string): Promise<number> => {
+    try {
+        const { 
+            _avg: { hpi2020: averageHpi },
+        } = await prisma.hPI.aggregate({
+            where: {
+                itl3: {
+                endsWith: itl3,
+                },
+            },
+            _avg: {
+                hpi2020: true,
+            },
+        });
+        return averageHpi as number;
+    } catch (error) {
+        throw Error(`Data error: Unable to find hpi2020 for itl3 ${itl3}`);
+    }
+};
+
+export const hpi2020Repo = {
+    getHPIByITL3,
+  };
+

app/data/itlRepo.ts

@@ -19,10 +19,14 @@ const getItl3ByPostcodeDistrict = async (
     // Cast to string as 'not: null' clause in Prisma query does not type narrow
     return itl3 as string;
   } catch (error) {
-    throw new Error(`Data error: Unable get get itl3 for postcode district ${postcodeDistrict}`);
+    throw new Error(
+      `Data error: Unable get get itl3 for postcode district ${postcodeDistrict}`
+    );
+
   }
 };
 
 export const itlRepo = {
   getItl3ByPostcodeDistrict,
-}
+};
+

app/data/pricesPaidRepo.ts

@@ -0,0 +1,115 @@
+import prisma from "./db";
+
+const MINIMUM_NUMBER_OF_POSTCODES = 30;
+
+interface pricesPaidParams {
+  averagePrice: number;
+  numberOfTransactions: number;
+  granularityPostcode: string;
+}
+const getPricesPaidByPostcodeAndHouseType = async (
+  postcodeDistrict: string,
+  postcodeArea: string,
+  postcodeSector: string,
+  houseType: string
+): Promise<pricesPaidParams> => {
+  try {
+    // create the progressive queries
+    let numberOfTransactions; // declare the variable for numbers of transactions retrieved
+    let granularityPostcode; // declare the granularity of the postcode
+    let averagePrice;
+
+    const pricesPaidSector = await prisma.pricesPaid.aggregate({
+      where: {
+        propertyType: {
+          equals: houseType,
+        },
+        postcode: {
+          startsWith: postcodeSector,
+        },
+      },
+      _count: {
+        id: true,
+      },
+      _avg: {
+        price: true,
+      },
+    });
+
+    const numberPerSector = pricesPaidSector._count.id;
+    const isMinMetBySector = numberPerSector >= MINIMUM_NUMBER_OF_POSTCODES;
+
+    if (!isMinMetBySector) {
+      const pricesPaidDistrict = await prisma.pricesPaid.aggregate({
+        where: {
+          propertyType: {
+            equals: houseType,
+          },
+          postcode: {
+            startsWith: postcodeDistrict,
+          },
+        },
+        _count: {
+          id: true,
+        },
+        _avg: {
+          price: true,
+        },
+      });
+
+      const numberPerDistrict = pricesPaidDistrict._count.id;
+      const isMinMetByDistrict =
+        numberPerDistrict >= MINIMUM_NUMBER_OF_POSTCODES;
+
+      if (!isMinMetByDistrict) {
+        const pricesPaidArea = await prisma.pricesPaid.aggregate({
+          where: {
+            propertyType: {
+              equals: houseType,
+            },
+            postcode: {
+              startsWith: postcodeArea,
+            },
+          },
+          _count: {
+            id: true,
+          },
+          _avg: {
+            price: true,
+          },
+        });
+        const numberPerArea = pricesPaidArea._count.id;
+        numberOfTransactions = numberPerArea; // check the granularity
+        granularityPostcode = postcodeArea; // granularity of the postcode when performing the average price search
+        averagePrice = pricesPaidArea._avg.price;
+      } else {
+        numberOfTransactions = numberPerDistrict; // check the granularity
+        granularityPostcode = postcodeDistrict; // granularity of the postcode
+        averagePrice = pricesPaidDistrict._avg.price;
+      }
+    } else {
+      numberOfTransactions = numberPerSector; // check the granularity
+      granularityPostcode = postcodeSector; // granularity of the postcode
+      averagePrice = pricesPaidSector._avg.price;
+    }
+
+    if (averagePrice === null) {
+      throw new Error("Unable to calculate average price");
+    }
+
+    // Cast to string as 'not: null' clause in Prisma query does not type narrow
+    return {
+      averagePrice,
+      numberOfTransactions,
+      granularityPostcode,
+    } as pricesPaidParams;
+  } catch (error) {
+    throw new Error(
+      `Data error: Unable to get pricesPaid for postcode district ${postcodeDistrict} and houseType ${houseType}`
+    );
+  }
+};
+
+export const pricesPaidRepo = {
+  getPricesPaidByPostcodeAndHouseType,
+};

app/data/rentRepo.ts

@@ -0,0 +1,24 @@
+import prisma from "./db";
+
+const getRentByITL3 = async (itl3: string): Promise<number | null> => {
+    try {
+        const result = await prisma.rent.aggregate({
+            where: {
+                itl3: { equals: itl3 },
+            },
+            _avg: {
+                monthlyMeanRent: true,
+            },
+        });
+
+        const monthlyMeanRent = result._avg.monthlyMeanRent;
+
+        return monthlyMeanRent;
+    } catch (error) {
+        throw new Error(`Data error: Unable to find monthlyMeanRent for itl3 ${itl3}`);
+    }
+};
+
+export const rentRepo = {
+    getRentByITL3,
+};

app/data/socialRentAdjustmentsRepo.ts

@@ -0,0 +1,37 @@
+import prisma from "./db";
+
+export type socialRentAdjustmentTypes = {
+  year: string;
+  inflation: string;
+  additional: string;
+  total: string;
+}[];
+
+const getSocialRentAdjustments = async (): Promise<socialRentAdjustmentTypes> => {
+    try {
+        const result = await prisma.socialRentAdjustments.findMany({
+            select: {
+                year: true,
+                inflation: true,
+                additional: true,
+                total: true,
+            }
+        });
+
+        const socialRentAdjustments: socialRentAdjustmentTypes = result.map(item => ({
+            year: item.year || '',
+            inflation: item.inflation?.toString() || '',
+            additional: item.additional?.toString() || '',
+            total: item.total?.toString() || '',
+        }));
+
+        return socialRentAdjustments;
+
+    } catch (error) {
+        throw new Error(`Data error: Unable to find socialRentAdjustments`);
+    }
+};
+
+export const socialRentAdjustmentsRepo = {
+    getSocialRentAdjustments,
+};

app/data/socialRentEarningsRepo.ts

@@ -0,0 +1,31 @@
+import prisma from "./db";
+
+const getSocialRentEarningsByITL3 = async (itl3: string): Promise<number> => {
+    try {
+        const result = await prisma.socialRent.aggregate({ 
+            where: {
+              itl3: {
+                startsWith: itl3.substring(0, 3),
+              },
+            },
+            _avg: {
+              earningsPerWeek: true,
+            },
+          });
+
+        const monthlyMeanRent = result._avg.earningsPerWeek;
+
+        if (monthlyMeanRent === null) {
+            throw new Error(`No data found for itl3 ${itl3}`);
+        }
+
+        return monthlyMeanRent;
+
+    } catch (error) {
+        throw Error(`Data error: Unable to find earningsPerWeek for itl3 ${itl3}`);
+    }
+};
+
+export const socialRentEarningsRepo = {
+    getSocialRentEarningsByITL3,
+};

app/services/buildPriceService.ts

@@ -0,0 +1,9 @@
+import { buildPriceRepo } from "../data/buildPriceRepo";
+
+const getBuildPriceByHouseType = async (houseType: string) => {
+  return await buildPriceRepo.getBuildPriceByHouseType(houseType);
+};
+
+export const buildPriceService = {
+  getBuildPriceByHouseType,
+};