Schema updates/menu.get

apps/server/src/functions/hello/handler.ts

@@ -2,9 +2,10 @@ import {
   awsLambdaRequestHandler,
   CreateAWSLambdaContextOptions,
 } from "@trpc/server/adapters/aws-lambda";
-import { appRouter, createTRPCContext } from "@acme/api";
 import { APIGatewayProxyEventV2 } from "aws-lambda";
 
+import { appRouter, createTRPCContext } from "@acme/api";
+
 const createContext = ({
   event,
   context,
@@ -20,15 +21,4 @@ export const handler = awsLambdaRequestHandler({
   createContext,
 });
 
-// const handler = async (event) => {
-//   const res = await axios.get("https://jsonplaceholder.typicode.com/todos/1");
-//   return {
-//     statusCode: 200,
-//     body: JSON.stringify({
-//       message: `Hello ${"hello"} !`,
-//       data: res.data,
-//     }),
-//   };
-// };
-
 export const main = handler;

packages/api/package.json

@@ -14,6 +14,8 @@
     "@acme/tsconfig": "workspace:^",
     "@acme/validators": "workspace:^",
     "@trpc/server": "11.0.0-next-beta.236",
+    "@zotmeal/utils": "workspace:^",
+    "jest": "^29.7.0",
     "superjson": "2.2.1",
     "zod": "^3.22.4"
   },

packages/api/src/router/menu.test.ts

@@ -0,0 +1,5 @@
+import { it } from "@jest/globals";
+
+it("fail on invalid menu params", () => {
+  console.log("testing");
+});

packages/api/src/router/menu.ts

@@ -1,20 +1,89 @@
 import axios from "axios";
-
 import { createTRPCRouter, publicProcedure } from "../trpc";
+import { MenuPeriod } from '@acme/db';
+import {z} from "zod";
 
-export const menuRouter = createTRPCRouter({
-  get: publicProcedure.query(({ ctx }) => {
+// https://uci.campusdish.com/api/menu/GetMenus?locationId=3314&periodId=49&date=1/19/2024
+
+// const locations = Object.values(LocationNames).map((name) => name.toString());
+
+// enum RestaurantName {
+//   brandywine,
+//   anteatery
+// }
+
+// const locations = ["a", "b", "c"] as const;
+
+
+const GetMenuSchema = z.object({
+  date: z.string().regex(RegExp("/^\d{2}\/\d{2}\/\d{4}$/")),
+  period: z.nativeEnum(MenuPeriod),
+  restaurant: z.string()
+})
+
+
+const getMenuProcedure = publicProcedure 
+  .input(GetMenuSchema)
+  .query(({ ctx, input }) => {
     const _ = ctx;
     // get a menu
 
+    const {date, period, restaurant} = input;
+
+    const {db} = ctx;
+
+    // date
+
+    const restaurantModel = db.restaurant.findFirst({
+      where: {
+        name: restaurant
+      },
+      include: {
+        stations: false,
+        menu: false,
+      }
+    });
+    if (restaurantModel === null) {
+      return 
+
+    }
+
+
+
+    // get the rstaurant with this name
+
+
+
+    db.menu.findUnique({where: {
+      date: date,
+      period: period,
+      restaurant: location
+    }})
+
     // get it from prisma
     // if not there, call parse procedure
-  }),
+})
+
+
+
+
+import { parse } from "../../../utils/parse";
+import { CampusDishResponseSchema, ParsedResponseSchema } from "@acme/validators";
+
+export const menuRouter = createTRPCRouter({
+  get: ,
   hello: publicProcedure.query(async ({ ctx }) => {
     const res = await axios.get("https://jsonplaceholder.typicode.com/todos/1");
     console.log(res.data);
     console.log("hello");
     const _ = ctx;
     return "hello";
   }),
+  parse: publicProcedure.query(async ({ ctx }) => {
+    const res = await axios.get("https://uci.campusdish.com/api/menu/GetMenus?locationId=3314&periodId=49&date=1/19/2024");
+    const validated = CampusDishResponseSchema.parse(res.data);
+    const parsed = ParsedResponseSchema.parse(parse(validated));
+    const _ = ctx;
+    return parsed;
+  }),
 });

packages/db/prisma/schema.prisma

@@ -26,35 +26,35 @@ model Restaurant {
   Menu     Menu[]
 }
 
-
 model Station {
   id           String     @id
   name         String
   restaurant   Restaurant @relation(fields: [restaurantId], references: [id])
   restaurantId String
-  dishes       Dish[] 
+  dishes       Dish[]
   menu         Menu       @relation(fields: [menuId], references: [id])
   menuId       String
 }
 
 enum MenuPeriod {
-    BREAKFAST
-    BRUNCH
-    LUNCH
-    DINNER
-    LATENIGHT
+  breakfast
+  brunch
+  lunch
+  dinner
+  latenight
 }
 
 model Menu {
-  id           String      @id
-  period MenuPeriod
+  id           String     @id
+  period       MenuPeriod
   date         DateTime
-  start DateTime
-  end DateTime
-  restaurant   Restaurant  @relation(fields: [restaurantId], references: [id])
+  start        DateTime
+  end          DateTime
+  restaurant   Restaurant @relation(fields: [restaurantId], references: [id])
   restaurantId String
   stations     Station[]
 }
+
 model DietRestriction {
   id                String   @id
   containsFish      Boolean?
@@ -97,4 +97,4 @@ model NutritionInfo {
   saturatedFat       String?
   dish               Dish    @relation(fields: [dishId], references: [id])
   dishId             String  @unique
-}
+}

packages/utils/README.md

@@ -0,0 +1 @@
+# `@zotmeal/utils`

packages/utils/constants.ts

@@ -0,0 +1,4 @@
+export const LocationNames = {
+  "3314": "Brandywine",
+  "3056": "Anteatery",
+};

packages/utils/index.ts

@@ -0,0 +1 @@
+export * from "./constants";

packages/utils/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@zotmeal/utils",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "echo 'Add dev script here'",
+    "build": "echo 'Add build script here'",
+    "test": "echo 'Add test script here'",
+    "lint": "echo 'Add lint script here'"
+  },
+  "dependencies": {
+    "@acme/tsconfig": "workspace:^",
+    "@acme/validators": "workspace:^"
+  }
+}

packages/utils/parse.ts

@@ -0,0 +1,53 @@
+import { CampusDishResponse } from "@acme/validators";
+
+import { LocationNames } from "./constants";
+
+export function parse(data: CampusDishResponse) {
+  const uniqueStations = new Set<string>();
+  data.Menu.MenuStations.forEach((menuStation) => {
+    uniqueStations.add(
+      JSON.stringify({
+        station_id: menuStation.StationId,
+        restaurant_id: data.LocationId,
+        name: menuStation.Name,
+      }),
+    );
+  });
+  const stations = Array.from(uniqueStations).map((station) =>
+    JSON.parse(station),
+  );
+  const parsed = {
+    restaurant: {
+      restaurant_id: data.LocationId,
+      restaurant_name:
+        LocationNames[data.LocationId as keyof typeof LocationNames],
+    },
+    stations,
+    dishes: data.Menu.MenuProducts.map((menuProduct) => ({
+      id: menuProduct.Product.ProductId,
+      station_id: menuProduct.StationId,
+      name: menuProduct.Product.MarketingName,
+      description: menuProduct.Product.ShortDescription,
+      dietary_restriction_info: {
+        id: menuProduct.Product.ProductId,
+        contains_eggs: menuProduct.Product.ContainsEggs,
+        contains_fish: menuProduct.Product.ContainsFish,
+        contains_milk: menuProduct.Product.ContainsMilk,
+        contains_peanuts: menuProduct.Product.ContainsPeanuts,
+        contains_shellfish: menuProduct.Product.ContainsShellfish,
+        contains_soy: menuProduct.Product.ContainsSoy,
+        contains_tree_nuts: menuProduct.Product.ContainsTreeNuts,
+        contains_wheat: menuProduct.Product.ContainsWheat,
+        contains_sesame: menuProduct.Product.ContainsSesame,
+        is_gluten_free: menuProduct.Product.IsGlutenFree,
+        is_halal: menuProduct.Product.IsHalal,
+        is_kosher: menuProduct.Product.IsKosher,
+        is_locally_grown: menuProduct.Product.IsLocallyGrown,
+        is_organic: menuProduct.Product.IsOrganic,
+        is_vegan: menuProduct.Product.IsVegan,
+        is_vegetarian: menuProduct.Product.IsVegetarian,
+      },
+    })),
+  };
+  return parsed;
+}

packages/utils/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["@acme/tsconfig/base.json"],
+  "exclude": ["node_modules"]
+}

packages/validators/src/index.ts

@@ -5,3 +5,89 @@ export const CreatePostSchema = z.object({
   content: z.string().min(1),
 });
 
+export const GetMenuSchema = z.object({});
+
+const MenuStationSchema = z.object({
+  StationId: z.string().min(1),
+  Name: z.string().min(1),
+});
+
+const MenuProductSchema = z.object({
+  StationId: z.string().min(1),
+  Product: z.object({
+    ProductId: z.string().min(1),
+    MarketingName: z.string().min(1),
+    ShortDescription: z.string(),
+    ContainsEggs: z.boolean().nullable(),
+    ContainsFish: z.boolean().nullable(),
+    ContainsMilk: z.boolean().nullable(),
+    ContainsPeanuts: z.boolean().nullable(),
+    ContainsShellfish: z.boolean().nullable(),
+    ContainsSoy: z.boolean().nullable(),
+    ContainsTreeNuts: z.boolean().nullable(),
+    ContainsWheat: z.boolean().nullable(),
+    ContainsSesame: z.boolean().nullable(),
+    IsGlutenFree: z.boolean().nullable(),
+    IsHalal: z.boolean().nullable(),
+    IsKosher: z.boolean().nullable(),
+    IsLocallyGrown: z.boolean().nullable(),
+    IsOrganic: z.boolean().nullable(),
+    IsVegan: z.boolean().nullable(),
+    IsVegetarian: z.boolean().nullable(),
+  }),
+});
+
+export const CampusDishResponseSchema = z.object({
+  LocationId: z.string(),
+  Menu: z.object({
+    MenuStations: z.array(MenuStationSchema),
+    MenuProducts: z.array(MenuProductSchema),
+  }),
+});
+
+export type CampusDishResponse = z.infer<typeof CampusDishResponseSchema>;
+
+export const DietaryRestrictionInfoSchema = z.object({
+  id: z.string(),
+  contains_eggs: z.boolean().nullable(),
+  contains_fish: z.boolean().nullable(),
+  contains_milk: z.boolean().nullable(),
+  contains_peanuts: z.boolean().nullable(),
+  contains_shellfish: z.boolean().nullable(),
+  contains_soy: z.boolean().nullable(),
+  contains_tree_nuts: z.boolean().nullable(),
+  contains_wheat: z.boolean().nullable(),
+  contains_sesame: z.boolean().nullable(),
+  is_gluten_free: z.boolean().nullable(),
+  is_halal: z.boolean().nullable(),
+  is_kosher: z.boolean().nullable(),
+  is_locally_grown: z.boolean().nullable(),
+  is_organic: z.boolean().nullable(),
+  is_vegan: z.boolean().nullable(),
+  is_vegetarian: z.boolean().nullable(),
+});
+
+export const DishSchema = z.object({
+  id: z.string(),
+  station_id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  dietary_restriction_info: DietaryRestrictionInfoSchema,
+});
+
+export const RestaurantSchema = z.object({
+  restaurant_id: z.string(),
+  restaurant_name: z.string(),
+});
+
+export const StationSchema = z.object({
+  station_id: z.string(),
+  restaurant_id: z.string(),
+  name: z.string(),
+});
+
+export const ParsedResponseSchema = z.object({
+  restaurant: RestaurantSchema,
+  stations: z.array(StationSchema),
+  dishes: z.array(DishSchema),
+});

packages/validators/src/menu.ts

@@ -1,3 +1 @@
-import { z } from "zod";
 
-export const GetMenuSchema = z.object({});