api/src/db/schema.ts

@@ -1,7 +1,5 @@
-import { integer, text, sqliteTable, sqliteView } from "drizzle-orm/sqlite-core";
-import { eq, sql } from "drizzle-orm";
+import { integer, text, sqliteTable } from "drizzle-orm/sqlite-core";
 
-// Tables
 export const attraction = sqliteTable('attraction', {
     id: integer().primaryKey({ autoIncrement: true }),
     name: text().notNull(),
@@ -25,7 +23,7 @@ export const logbook = sqliteTable('logbook', {
     realWaittime: integer()
 })
 
-export const notificationMethod = sqliteTable('notification_method', {
+export const notificationMethod = sqliteTable('notification', {
     id: integer().primaryKey({ autoIncrement: true }),
     webhookUrl: text().notNull(),
     shownName: text().notNull(),
@@ -44,24 +42,4 @@ export const user = sqliteTable('user', {
     id: integer().primaryKey({ autoIncrement: true }),
     username: text().notNull(),
     isActive: integer({ mode: 'boolean' }).default(false)
-})
-
-// Views
-export const subscribedThemeparks = sqliteView('subscribed_themeparks').as((qb) =>
-    qb.selectDistinct({
-        apiName: sql<string>`themepark.api_name`.as('api_name')
-    }).from(attractionNotification)
-    .innerJoin(attraction, eq(attractionNotification.attractionId, attraction.id))
-    .innerJoin(themepark, eq(attraction.themeparkId, themepark.id))
-);
-
-export const attractionSubscriptions = sqliteView('attraction_subscriptions').as((qb) =>
-    qb.selectDistinct({
-        attractionApiCode: sql<string>`attraction.api_code`.as('attraction_api_code'),
-        themeparkApiName: sql<string>`themepark.api_name`.as('themepark_api_name'),
-        webhookUrl: sql<string>`notification_method.webhook_url`.as('webhook_url')
-    }).from(attractionNotification)
-    .innerJoin(attraction, eq(attractionNotification.attractionId, attraction.id))
-    .innerJoin(themepark, eq(attraction.themeparkId, themepark.id))
-    .innerJoin(notificationMethod, eq(attractionNotification.notificationMethodId, notificationMethod.id))
-);
+})

api/src/jobs/update-attraction-list.ts

@@ -1,22 +1,62 @@
 import { getDbEnv } from '../db/client'
 import { attraction, themepark } from '../db/schema'
 import { inArray } from 'drizzle-orm'
-import { Attraction } from '../types/attraction'
-import { ThemeparkSelect } from '../types/themepark'
+import httpRequest from '../lib/http-request'
 import asyncBatchJob from '../lib/async-batch-job'
-import fetchAttractions from '../lib/fetch-attractions'
 
-type ThemeparkAPI = Pick<ThemeparkSelect, "apiName" | "id">;
+interface AttractionImport {
+    code: string,
+    name: string,
+}
+
+interface AttractionType {
+    name: string,
+    apiCode: string,
+    themeparkId: number
+}
+
+interface Themepark {
+    apiName: string,
+    id: number
+}
+
+/**
+ * Fetching the attractions from a specified park
+ * @param park API Code for request themepark
+ * @param endpoint Endpoint where to fetch data from (default: https://api.wartezeiten.app/v1/parks)
+ * @param lang Language used for API request
+ * @returns Interface with attraction code & name
+ */
+async function fetchAttractions(
+    park: string,
+    endpoint: string = "https://api.wartezeiten.app/v1/parks",
+    lang: string = 'de'
+): Promise<AttractionImport[]>{
+    try{
+        const headers = {
+            'language':lang,
+            'park':park
+        };
+
+        const result = await httpRequest<AttractionImport[]>(endpoint, {
+            headers: headers
+        });
+        return result;
+    }
+    catch(e){
+        throw new Error(`Failed to fetch attractions: ${e}`);
+    }
+}
 
 /**
  * Return an object of all themeparks saved in the database
  * @param env DB Connection
  * @returns Object of themeparks with api name & id from internal DB
  */
-async function getThemeparks(env: Env): Promise<ThemeparkAPI[]>{
+async function getThemeparks(env: Env): Promise<Themepark[]>{
     try{
         const db = getDbEnv(env);
-        const themeparks: ThemeparkAPI[] = await db.select({
+        const themeparks: Themepark[] = await db.select({
             apiName: themepark.apiName,
             id: themepark.id
         }).from(themepark);
@@ -34,13 +74,13 @@ async function getThemeparks(env: Env): Promise<ThemeparkAPI[]>{
  * @param parks Object of themeparks to get attractions from
  * @returns Object of attractions
  */
-async function getAttractionsByParks(env: Env, parks: ThemeparkAPI[]): Promise<Attraction[]>{
+async function getAttractionsByParks(env: Env, parks: Themepark[]): Promise<AttractionType[]>{
     try{
         const db = getDbEnv(env);
 
         const parkIds: number[] = parks.map(p => p.id);
 
-        const attractions: Attraction[] = await db.select({
+        const attractions: AttractionType[] = await db.select({
             name: attraction.name,
             apiCode: attraction.apiCode,
             themeparkId: attraction.themeparkId
@@ -60,7 +100,7 @@ async function getAttractionsByParks(env: Env, parks: ThemeparkAPI[]): Promise<A
  * @param env DB Connection
  * @param parks Object of the themeparks from which the attractions have to be imported
  */
-async function importAttractionsByParks(env: Env, parks: ThemeparkAPI[]): Promise<void>{
+async function importAttractionsByParks(env: Env, parks: Themepark[]): Promise<void>{
     try{
         const db = getDbEnv(env);
         

api/src/lib/fetch-attractions.ts

@@ -1,30 +0,0 @@
-import { AttractionImport } from '../types/attraction'
-import httpRequest from '../lib/http-request'
-
-/**
- * Fetching the attractions from a specified park
- * @param park API Code for request themepark
- * @param endpoint Endpoint where to fetch data from (default: https://api.wartezeiten.app/v1/parks)
- * @param lang Language used for API request
- * @returns Interface with attraction code & name
- */
-export default async function fetchAttractions(
-    park: string,
-    endpoint: string = "https://api.wartezeiten.app/v1/waitingtimes",
-    lang: string = 'de'
-): Promise<AttractionImport[]>{
-    try{
-        const headers = {
-            'language':lang,
-            'park':park
-        };
-
-        const result = await httpRequest<AttractionImport[]>(endpoint, {
-            headers: headers
-        });
-        return result;
-    }
-    catch(e){
-        throw new Error(`Failed to fetch attractions: ${e}`);
-    }
-}

api/src/types/attraction-subscriptions.ts

@@ -1,3 +0,0 @@
-import { attractionSubscriptions } from '../db/schema';
-
-export type AttractionSubscription = typeof attractionSubscriptions.$inferSelect;

api/src/types/attraction.ts

@@ -2,21 +2,4 @@ import { type InferSelectModel, type InferInsertModel } from 'drizzle-orm';
 import { attraction } from '../db/schema';
 
 export type Attraction = InferInsertModel<typeof attraction>
-export type AttractionSelect = InferSelectModel<typeof attraction>
-
-// API Response format
-export interface AttractionImport {
-    code: string,
-    name: string,
-    waitingtime: number,
-    status: "opened" | "virtualqueue" | "maintenance" | "closedice" | "closedweather" | "closed"
-}
-
-// Waittime comparison
-export interface AttractionChanges {
-    apiCode: string,
-    name: string,
-    waittime: number,
-    hasChanged: boolean,
-    increased: boolean
-}
+export type AttractionSelect = InferSelectModel<typeof attraction>

api/src/types/subscribed-themeparks.ts

@@ -1,3 +0,0 @@
-import { subscribedThemeparks } from '../db/schema';
-
-export type SubscribedThemeparks = typeof subscribedThemeparks.$inferSelect;