feat: add translations from tmdb (#38)

* add

* add

* season name overlap

* change type to extendeduserentry

.gitignore

···
 
 cli/dist
 migration/__pycache__
-migration/connections.json
+migration/connections.json
+migration/apiKey

app/(app)/dashboard/page.tsx

···
 import { Dialog, DialogContent } from '@/components/ui/dialog';
 import { UserEntryCardObject } from '@/components/userEntryCard';
 import { api } from '@/trpc/react';
-import { Entry, User, UserEntry, UserList } from '@prisma/client';
+import { Entry, UserList } from '@prisma/client';
 import { useQuery } from '@tanstack/react-query';
 import { Loader2 } from 'lucide-react';
 import { useEffect, useRef, useState } from 'react';
 import { toast } from 'sonner';
 import { SidebarButtons } from '../_components/sidebar';
 import { FilterView } from './_components/FilterView';
-import { useDashboardStore } from './state';
+import { ExtendedUserEntry, useDashboardStore } from './state';
 
 const Page = () => {
   const { data, isPending: dataIsPending } = api.dashboard.get.useQuery();
···
 const Dashboard = ({
   userEntries: originalUserEntries,
 }: {
-  userEntries: (UserEntry & { entry: Entry } & { user: User })[];
+  userEntries: ExtendedUserEntry[];
   topCompletedNotCompleted: Entry[];
   topRatedNotCompleted: Entry[];
 }) => {

app/(app)/dashboard/state.ts

···
 import {
   Category,
   Entry,
+  EntryAlternativeTitle,
+  EntryTranslation,
   User,
   UserEntry,
   UserEntryStatus,
···
 import { create } from 'zustand';
 
 export type FilterStyle = 'rating' | 'az' | 'completed' | 'updated';
-export type ExtendedUserEntry = UserEntry & { entry: Entry } & { user: User };
+export type ExtendedUserEntry = UserEntry & {
+  entry: Entry & { translations: EntryTranslation[] };
+} & { user: User };
 
 type DashboardStore = {
   filterStatus: UserEntryStatus | 'all';

app/(app)/users/[username]/_components/diary.ts

···
+import { getUserTitleFromEntry } from '@/server/api/routers/dashboard';
+import { validateSessionToken } from '@/server/auth/validateSession';
 import prisma from '@/server/db';
 
 export type Diary = Record<
···
 >;
 
 export const getUserDiary = async (userId: number): Promise<Diary> => {
+  const authUser = await validateSessionToken();
   const userEntries = await prisma.userEntry.findMany({
     where: {
       userId,
···
     },
     take: 10,
     include: {
-      entry: true,
+      entry: {
+        include: {
+          translations: {
+            where: {
+              language: {
+                id: authUser
+                  ? (authUser.showMediaMetaInId ?? undefined)
+                  : undefined,
+                iso_639_1: !authUser ? 'en' : undefined,
+              },
+            },
+          },
+        },
+      },
     },
   });
 
···
       diary[monthMinusYear] = [];
     }
     diary[monthMinusYear]!.push({
-      title: userEntry.entry.originalTitle,
+      title: getUserTitleFromEntry(userEntry.entry),
       day: userEntry.watchedAt!.getDate(),
     });
   });

app/(app)/users/[username]/_components/serverUserEntryTitle.tsx

···
+import { getUserTitleFromEntryId } from '@/server/api/routers/dashboard';
+
+export const ServerEntryTitleForUser = async ({
+  entryId,
+}: {
+  entryId: number;
+}) => {
+  const title = await getUserTitleFromEntryId(entryId);
+  return title;
+};

app/(app)/users/[username]/_components/sidebar.tsx

···
-'use client';
-
-import { useMediaQuery } from 'usehooks-ts';
 import SmallRating from '@/components/smallRating';
 import { Entry, User, UserEntry, UserFollow } from '@prisma/client';
 import { cn } from '@/lib/utils';
···
 import { Calendar } from 'lucide-react';
 import { Progress } from '@/components/ui/progress';
 import { Fragment } from 'react';
+import { ServerEntryTitleForUser } from './serverUserEntryTitle';
 
 export const ProfileSidebar = ({
   profileUser,
···
   return (
     <div className={cn('flex flex-col gap-6', className)}>
       <div className="flex flex-col gap-4">
-        <div className="border-b-base-200 flex justify-between border-b pb-2 text-lg font-medium">
+        <div className="flex justify-between border-b border-b-base-200 pb-2 text-lg font-medium">
           Watchlist
-          <span className="text-base-500 ms-auto">
+          <span className="ms-auto text-base-500">
             {
               profileUser.userEntries.filter(e => e.status === 'planning')
                 .length
···
         {profileUser.userEntries.filter(e => e.status === 'watching').length >
           0 && (
           <div className="flex flex-col gap-4">
-            <div className="border-b-base-200 flex w-full justify-between border-b pb-2 text-lg font-medium">
+            <div className="flex w-full justify-between border-b border-b-base-200 pb-2 text-lg font-medium">
               In Progress
-              <span className="text-base-500 ms-auto">
+              <span className="ms-auto text-base-500">
                 {
                   profileUser.userEntries.filter(e => e.status === 'watching')
                     .length
···
               .filter(e => e.status === 'watching')
               .map(entry => (
                 <div className="flex flex-col gap-1.5" key={entry.id}>
-                  {entry.entry.originalTitle}
+                  <ServerEntryTitleForUser entryId={entry.entry.id} />
                   <Progress
                     value={(entry.progress / entry.entry.length) * 100}
                   />
···
         )}
       </div>
       <div className="flex flex-col items-center gap-4 lg:items-start">
-        <div className="border-b-base-200 flex w-full justify-between border-b pb-2 text-lg font-medium">
+        <div className="flex w-full justify-between border-b border-b-base-200 pb-2 text-lg font-medium">
           Ratings
-          <span className="text-base-500 ms-auto">{totalRatings}</span>
+          <span className="ms-auto text-base-500">{totalRatings}</span>
         </div>
         <div className="flex w-full flex-row items-end justify-between gap-2 2xl:w-[250px]">
           <SmallRating rating={20} className="pb-1" />
-          <div className="border-b-base-200 flex w-[135px] flex-row items-end gap-0.5 border-b pb-1">
+          <div className="flex w-[135px] flex-row items-end gap-0.5 border-b border-b-base-200 pb-1">
             {ratings.map((ratingPercentage, idx) => (
               <div
                 key={idx}
-                className="bg-base-300 w-full"
+                className="w-full bg-base-300"
                 style={{ height: 110 * ratingPercentage }}
               ></div>
             ))}
···
               Daily streak hasn't been updated
             </div>
           )}
-        <div className="border-b-base-200 flex w-full justify-between border-b pb-2 text-lg font-medium">
+        <div className="flex w-full justify-between border-b border-b-base-200 pb-2 text-lg font-medium">
           Diary
-          <span className="text-base-500 ms-auto">
+          <span className="ms-auto text-base-500">
             {profileUser.dailyStreakLength} Day Streak
           </span>
         </div>

app/(app)/users/[username]/page.tsx

···
 import { ProfileHeader } from './_components/header';
 import { ProfileSidebar } from './_components/sidebar';
 import { Stats } from './_components/stats';
+import { getUserTitleFromEntry } from '@/server/api/routers/dashboard';
+import { ServerEntryTitleForUser } from './_components/serverUserEntryTitle';
 
 const Profile404 = async () => {
   const user = await validateSessionToken();
···
           watchedAt: true,
           entry: {
             select: {
+              id: true,
               originalTitle: true,
               posterPath: true,
               length: true,
···
     select: {
       notes: false,
       rating: true,
-      entry: true,
+      entry: {
+        select: {
+          originalTitle: true,
+          posterPath: true,
+          releaseDate: true,
+          category: true,
+          translations: {
+            where: {
+              language: {
+                id: user ? (user.showMediaMetaInId ?? undefined) : undefined,
+                iso_639_1: !user ? 'en' : undefined,
+              },
+            },
+          },
+        },
+      },
     },
   });
 
···
                       <UserEntryCard
                         key={`userEntry-${idx}`}
                         {...{
-                          title: userEntry.entry.originalTitle,
+                          title: getUserTitleFromEntry(userEntry.entry as any),
                           backgroundImage: userEntry.entry.posterPath,
                           releaseDate: userEntry.entry.releaseDate,
                           rating: userEntry.rating,
···
                       <UserEntryCard
                         key={`userEntry-${idx}`}
                         {...{
-                          title: userEntry.entry.originalTitle,
+                          title: getUserTitleFromEntry(userEntry.entry as any),
                           backgroundImage: userEntry.entry.posterPath,
                           releaseDate: userEntry.entry.releaseDate,
                           rating: userEntry.rating,
···
                         <div className="flex h-full flex-col justify-center gap-3 pb-3 2xl:border-b-0 2xl:pb-0">
                           <div className="space-x-3">
                             <span className="text-lg font-semibold 2xl:text-2xl">
-                              {activity.entry.originalTitle}
+                              <ServerEntryTitleForUser
+                                entryId={activity.entry.id}
+                              />
                             </span>
                             <span className="text-sm font-medium text-base-500">
                               {activity.entry.releaseDate.getFullYear()}

app/(guest)/page.tsx

···
 } from '@/components/ui/card';
 import UserEntryCard, { UserEntryCardObject } from '@/components/userEntryCard';
 import prisma from '@/server/db';
-import { Entry } from '@prisma/client';
+import { Entry, EntryAlternativeTitle } from '@prisma/client';
 import { ExtendedUserEntry } from '../(app)/dashboard/state';
 
 const Page = async () => {
   const user = await validateSessionToken();
 
+  const getEnglishTitles = async (entryId: number) => {
+    return await prisma.entryTranslation.findMany({
+      where: {
+        entryId: parseInt(entryId.toString()),
+        language: {
+          iso_639_1: 'en',
+        },
+      },
+    });
+  };
+
   const randomMovie = (
     (await prisma.$queryRawUnsafe(
       `SELECT * FROM Entry WHERE category = "Movie" ORDER BY RAND() LIMIT 1;`
     )) as Entry[]
   )[0] as Entry;
 
+  const movieTitles = await getEnglishTitles(randomMovie.id);
+
   const randomSeries = (
     (await prisma.$queryRawUnsafe(
       `SELECT * FROM Entry WHERE category = "Series" ORDER BY RAND() LIMIT 1;`
     )) as Entry[]
   )[0] as Entry;
 
+  const seriesTitles = await getEnglishTitles(randomSeries.id);
+
   const randomBook = (
     (await prisma.$queryRawUnsafe(
       `SELECT * FROM Entry WHERE category = "Book" ORDER BY RAND() LIMIT 1;`
     )) as Entry[]
   )[0] as Entry;
+  const bookTitles = await getEnglishTitles(randomBook.id);
 
   return (
     <div className="flex w-full flex-col items-center bg-white">
···
             <CardContent className="grid grid-cols-3 gap-3 lg:gap-6">
               {randomMovie && (
                 <UserEntryCardObject
-                  userEntry={{ entry: randomMovie } as ExtendedUserEntry}
+                  userEntry={
+                    {
+                      entry: {
+                        ...randomMovie,
+                        translations: movieTitles,
+                      },
+                    } as ExtendedUserEntry
+                  }
                 />
               )}
               {randomBook && (
                 <UserEntryCardObject
-                  userEntry={{ entry: randomBook } as ExtendedUserEntry}
+                  userEntry={
+                    {
+                      entry: {
+                        ...randomBook,
+                        translations: bookTitles,
+                      },
+                    } as ExtendedUserEntry
+                  }
                 />
               )}
               {randomSeries && (
                 <UserEntryCardObject
-                  userEntry={{ entry: randomSeries } as ExtendedUserEntry}
+                  userEntry={
+                    {
+                      entry: {
+                        ...randomSeries,
+                        translations: seriesTitles,
+                      },
+                    } as ExtendedUserEntry
+                  }
                 />
               )}
             </CardContent>

app/_components/SettingsContext.tsx

···
+'use client';
+
+import { Language, Theme } from '@prisma/client';
+import { createContext, useContext } from 'react';
+
+export type Settings = {
+  theme: Theme;
+  showMediaMetaIn: Language;
+};
+const SettingsContext = createContext<Settings | null>(null);
+
+export function SettingsProvider({
+  settings,
+  children,
+}: {
+  settings: Settings;
+  children: React.ReactNode;
+}) {
+  return (
+    <SettingsContext.Provider value={settings}>
+      {children}
+    </SettingsContext.Provider>
+  );
+}
+
+export function useSettings() {
+  const context = useContext(SettingsContext);
+  if (!context) {
+    throw new Error('useTheme must be used within a ThemeProvider');
+  }
+  return context;
+}

app/_components/ThemeContext.tsx

···
-'use client';
-
-import { Theme } from '@prisma/client';
-import { createContext, useContext } from 'react';
-
-const ThemeContext = createContext<Theme | null>(null);
-
-export function ThemeProvider({
-  theme,
-  children,
-}: {
-  theme: Theme;
-  children: React.ReactNode;
-}) {
-  return (
-    <ThemeContext.Provider value={theme}>{children}</ThemeContext.Provider>
-  );
-}
-
-export function useTheme() {
-  const context = useContext(ThemeContext);
-  if (!context) {
-    throw new Error('useTheme must be used within a ThemeProvider');
-  }
-  return context;
-}

app/_components/settings.ts

···
+import prisma from '@/server/db';
+import { Settings } from './SettingsContext';
+
+import { validateSessionToken } from '@/server/auth/validateSession';
+import { Language } from '@prisma/client';
+
+export const getTheme = async () => {
+  const user = await validateSessionToken();
+  return user ? user.theme : 'neutral';
+};
+
+export const getUserShowMediaIn = async () => {
+  const user = await validateSessionToken();
+  let language: Language;
+  if (user && user.showMediaMetaInId) {
+    language = (await prisma.language.findFirst({
+      where: {
+        id: user.showMediaMetaInId,
+      },
+    }))!;
+  } else {
+    // Default to english
+    language = (await prisma.language.findFirst({
+      where: {
+        iso_639_1: 'en',
+      },
+    }))!;
+  }
+  return language;
+};
+
+export const getSettings = async () => {
+  return {
+    theme: await getTheme(),
+    showMediaMetaIn: await getUserShowMediaIn(),
+  } satisfies Settings;
+};

app/_components/theme.ts

···
-import { validateSessionToken } from '@/server/auth/validateSession';
-
-export const getTheme = async () => {
-  const user = await validateSessionToken();
-  return user ? user.theme : 'neutral';
-};

app/api/import/movie/route.ts

···
     `https://api.themoviedb.org/3/movie/${id}/alternative_titles?language=en-US`,
     options
   );
+  const translations = await axios.get(
+    `https://api.themoviedb.org/3/movie/${id}/translations?language=en-US`,
+    options
+  );
   const credits = await axios.get(
     `https://api.themoviedb.org/3/movie/${id}/credits?language=en-US`,
     options
···
   }
 
   data['alternative_titles'] = altTitles.data['titles'];
+  data['translations'] = translations.data['translations'];
   data['cast'] = creditsData['cast'];
   data['crew'] = creditsData['crew'];
   data['watch_providers'] = watchProviders.data['results'];
···
     const existingCollection = await prisma.collection.findFirst({
       where: {
         foreignId: data.belongs_to_collection.id.toString(),
+        category: 'Movie',
       },
     });
 
···
           })
         )?.id!,
         title: alternativeTitle.title,
+      },
+    });
+  }
+
+  for (const translation of data.translations) {
+    await prisma.entryTranslation.create({
+      data: {
+        entryId: entry.id!,
+        countryId: (
+          await prisma.country.findFirst({
+            where: {
+              iso_3166_1: translation.iso_3166_1,
+            },
+          })
+        )?.id!,
+        languageId: (
+          await prisma.language.findFirst({
+            where: {
+              iso_639_1: translation.iso_639_1,
+            },
+          })
+        )?.id!,
+        name: translation.name,
+        overview: translation.overview,
+        homepage: translation.homepage,
+        tagline: translation.tagline,
       },
     });
   }

app/api/import/series/route.ts

···
     `https://api.themoviedb.org/3/tv/${id}/alternative_titles?language=en-US`,
     options
   );
+  const translations = await axios.get(
+    `https://api.themoviedb.org/3/tv/${id}/translations?language=en-US`,
+    options
+  );
   const watchProviders = await axios.get(
     `https://api.themoviedb.org/3/tv/${id}/watch/providers?language=en-US`,
     options
···
   }
 
   data['alternative_titles'] = altTitles.data['results'];
+  data['translations'] = translations.data['translations'];
   data['watch_providers'] = watchProviders.data['results'];
 
   for (var i = 0; i < data.seasons.length; i++) {
···
 
   let entry = await prisma.entry.findFirst({
     where: {
-      foreignId: data.id.toString(),
       category: 'Series',
+      collection: {
+        foreignId: data.id.toString(),
+      },
     },
   });
 
···
   const existingCollection = await prisma.collection.findFirst({
     where: {
       foreignId: data.id.toString(),
+      category: 'Series',
     },
   });
 
···
   for (const season of data.seasons) {
     const existingEntry = await prisma.entry.findFirst({
       where: {
-        foreignId: season.id.toString(),
+        foreignId: season.season_number.toString(),
+        collection: {
+          foreignId: data.id.toString(),
+        },
+        category: 'Series',
       },
     });
 
···
     entry = await prisma.entry.create({
       data: {
         originalTitle: `${data.original_name}: ${season.name}`,
-        foreignId: season.id.toString(),
+        foreignId: season.season_number.toString(),
         collectionId,
         posterPath: 'https://image.tmdb.org/t/p/original/' + season.poster_path,
         tagline: data.tagline,
···
       },
     });
 
-    if (firstSeason === undefined) {
+    if (season.season_number == 1) {
       firstSeason = entry;
     }
 
···
         },
       });
     }
+  }
+
+  for (const translation of data.translations) {
+    await prisma.entryTranslation.create({
+      data: {
+        entryId: entry!.id!,
+        countryId: (
+          await prisma.country.findFirst({
+            where: {
+              iso_3166_1: translation.iso_3166_1,
+            },
+          })
+        )?.id!,
+        languageId: (
+          await prisma.language.findFirst({
+            where: {
+              iso_639_1: translation.iso_639_1,
+            },
+          })
+        )?.id!,
+        name: translation.name,
+        overview: translation.overview,
+        homepage: translation.homepage,
+        tagline: translation.tagline,
+      },
+    });
   }
 
   return Response.json({

app/api/migration/fix_fid/route.ts

···
+import { validateSessionToken } from '@/server/auth/validateSession';
+import prisma from '@/server/db';
+import axios from 'axios';
+import { NextRequest } from 'next/server';
+
+export const GET = async (req: NextRequest) => {
+  const user = await validateSessionToken();
+  if (!user) {
+    return;
+  }
+
+  if (process.env.NODE_ENV !== 'development') {
+    return new Response('Not dev', {
+      status: 400,
+    });
+  }
+
+  const options = {
+    headers: {
+      accept: 'application/json',
+      Authorization: `Bearer ${process.env.TMDB_ACCESS_TOKEN}`,
+    },
+  };
+
+  let ignore: number[] = [];
+  const entries = await prisma.entry.findMany({
+    include: {
+      collection: true,
+    },
+  });
+  for (const entry of entries) {
+    console.log('\n----------');
+    if (entry.category !== 'Series') {
+      console.log('Skipped non series');
+      continue;
+    }
+
+    console.log('Processing series');
+
+    const seasons = (
+      await axios.get(
+        `https://api.themoviedb.org/3/tv/${entry.collection?.foreignId}?language=en-US`,
+        options
+      )
+    ).data['seasons'];
+
+    for (const season of seasons) {
+      const seasonEntry = await prisma.entry.findFirst({
+        where: {
+          foreignId: season['id'].toString(),
+        },
+      });
+
+      if (!seasonEntry) {
+        continue;
+        return new Response('issue ' + JSON.stringify(season), {
+          status: 200,
+        });
+      }
+
+      if (ignore.includes(seasonEntry['id'])) {
+        continue;
+      }
+
+      console.log(season);
+
+      await prisma.entry.updateMany({
+        where: {
+          foreignId: season['id'].toString(),
+        },
+        data: {
+          foreignId: season['season_number'].toString(),
+        },
+      });
+
+      ignore.push(seasonEntry['id']);
+    }
+  }
+
+  return new Response('Finish', {
+    status: 200,
+  });
+};

app/api/migration/translations/route.ts

···
+import { validateSessionToken } from '@/server/auth/validateSession';
+import prisma from '@/server/db';
+import axios from 'axios';
+import { Pi } from 'lucide-react';
+import { NextRequest } from 'next/server';
+
+export const GET = async (req: NextRequest) => {
+  const user = await validateSessionToken();
+  if (!user) {
+    return;
+  }
+
+  if (process.env.NODE_ENV !== 'development') {
+    return new Response('Not dev', {
+      status: 400,
+    });
+  }
+
+  const options = {
+    headers: {
+      accept: 'application/json',
+      Authorization: `Bearer ${process.env.TMDB_ACCESS_TOKEN}`,
+    },
+  };
+
+  const langHr = await prisma.language.findFirst({
+    where: {
+      iso_639_1: 'hr',
+    },
+  });
+  if (!langHr) {
+    await prisma.language.create({
+      data: {
+        name: 'Croatian',
+        iso_639_1: 'hr',
+        iso_639_2: 'hrv',
+      },
+    });
+  }
+
+  const langZh = await prisma.language.findFirst({
+    where: {
+      iso_639_1: 'zh',
+    },
+  });
+  if (!langZh) {
+    await prisma.language.create({
+      data: {
+        name: 'Chinese',
+        iso_639_1: 'zh',
+        iso_639_2: 'chi',
+      },
+    });
+  }
+
+  const langSr = await prisma.language.findFirst({
+    where: {
+      iso_639_1: 'sr',
+    },
+  });
+  if (!langSr) {
+    await prisma.language.create({
+      data: {
+        name: 'Serbian',
+        iso_639_1: 'sr',
+        iso_639_2: 'srp',
+      },
+    });
+  }
+
+  const langBs = await prisma.language.findFirst({
+    where: {
+      iso_639_1: 'bs',
+    },
+  });
+  if (!langBs) {
+    await prisma.language.create({
+      data: {
+        name: 'Bosnian',
+        iso_639_1: 'bs',
+        iso_639_2: 'bos',
+      },
+    });
+  }
+
+  await prisma.entryTranslation.deleteMany();
+  console.log(`asd ${(await prisma.entryTranslation.findMany()).length}`);
+
+  const entries = await prisma.entry.findMany({
+    include: {
+      collection: true,
+    },
+  });
+
+  for (const entry of entries) {
+    if (entry.category === 'Book') {
+      continue;
+    }
+    console.log('\n------');
+    console.log(entry.id);
+
+    let url = '';
+    if (entry.category === 'Series') {
+      url = `https://api.themoviedb.org/3/tv/${entry.collection?.foreignId}/season/${entry.foreignId}/translations?language=en-US`;
+    } else {
+      url = `https://api.themoviedb.org/3/movie/${entry.foreignId}/translations?language=en-US`;
+    }
+
+    console.log(url);
+    let translations;
+    try {
+      translations = (await axios.get(url, options)).data['translations'];
+    } catch {
+      console.log('request failed');
+      continue;
+    }
+
+    for (const translation of translations) {
+      console.log(translation['iso_639_1']);
+      if (translation['iso_639_1'] === 'sh') {
+        continue;
+      }
+      const language = await prisma.language.findFirst({
+        where: {
+          iso_639_1: translation['iso_639_1'],
+        },
+      });
+
+      const country = await prisma.country.findFirst({
+        where: {
+          iso_3166_1: translation['iso_3166_1'],
+        },
+      });
+
+      let collectionTranslation = undefined;
+      if (entry.category === 'Series') {
+        collectionTranslation = (
+          (
+            await axios.get(
+              `https://api.themoviedb.org/3/tv/${entry.collection?.foreignId}/translations?language=en-US`,
+              options
+            )
+          ).data['translations'] as any[]
+        ).find(e => e.iso_639_1 === translation.iso_639_1);
+      }
+
+      const translationExists = await prisma.entryTranslation.findFirst({
+        where: {
+          entryId: entry.id,
+          name: translation.name,
+          languageId: language!.id,
+        },
+      });
+
+      if (translationExists) {
+        continue;
+      }
+
+      let title = '';
+      if (entry.category === 'Series') {
+        if (!collectionTranslation.data.name) {
+          console.log(`No name for collection ${entry.id} ${translation.name}`);
+          continue;
+        }
+
+        let season = translation.data.name
+          ? translation.data.name
+          : parseInt(entry.foreignId) > 0
+            ? 'Season ' + entry.foreignId
+            : 'Specials';
+
+        title =
+          collectionTranslation.data.name +
+          (season === collectionTranslation.data.name ? '' : `: ${season}`);
+      } else if (translation.data.title) {
+        title = translation.data.title;
+      } else {
+        console.log(`No name for ${entry.id} ${translation.name}`);
+        continue;
+      }
+
+      await prisma.entryTranslation.create({
+        data: {
+          entryId: entry.id,
+          languageId: language!.id,
+          countryId: country ? country.id : undefined,
+          name: title,
+          overview:
+            entry.category === 'Series'
+              ? (collectionTranslation.overview ?? '')
+              : (translation.overview ?? ''),
+          tagline:
+            entry.category === 'Series'
+              ? (collectionTranslation.tagline ?? '')
+              : (translation.tagline ?? ''),
+          homepage:
+            entry.category === 'Series'
+              ? (collectionTranslation.overview ?? '')
+              : (translation.overview ?? ''),
+        },
+      });
+
+      console.log(`Finished ${entry.id} ${title} in ${language?.iso_639_1}`);
+    }
+  }
+};

app/auth/layout.tsx

···
 import { redirect } from 'next/navigation';
 import { ReactNode } from 'react';
 import { Toaster } from 'sonner';
-import { getTheme } from '../_components/theme';
+import { getTheme } from '../_components/settings';
 
 const Layout = async ({ children }: { children: ReactNode }) => {
   const theme = await getTheme();

app/layout.tsx

···
 import '@/styles/themes.css';
 import { TRPCReactProvider } from '@/trpc/react';
 import { Metadata, Viewport } from 'next';
-import { ThemeProvider } from './_components/ThemeContext';
-import { getTheme } from './_components/theme';
+import { SettingsProvider } from './_components/SettingsContext';
 import Providers from './providers';
+import { getSettings } from './_components/settings';
 
 export default async function RootLayout({
   children,
 }: {
   children: React.ReactNode;
 }) {
-  const theme = await getTheme();
+  const settings = await getSettings();
 
   return (
     <TRPCReactProvider>
-      <ThemeProvider theme={theme}>
+      <SettingsProvider settings={settings}>
         <Providers>{children}</Providers>
-      </ThemeProvider>
+      </SettingsProvider>
     </TRPCReactProvider>
   );
 }

components/islands/settings.tsx

···
 import { useAuthUser } from '@/app/(app)/_components/AuthUserContext';
-import { useTheme } from '@/app/_components/ThemeContext';
+import { useSettings } from '@/app/_components/SettingsContext';
 import { capitalizeFirst } from '@/lib/capitalizeFirst';
 import { colors } from '@/lib/colors';
 import { api } from '@/trpc/react';
-import { Theme } from '@prisma/client';
+import { Language, Theme } from '@prisma/client';
 import { Sun } from 'lucide-react';
 import { useRouter } from 'next/navigation';
 import { useEffect, useState } from 'react';
···
 import { Card, CardContent } from '../ui/card';
 import { Label } from '../ui/label';
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../ui/select';
+import { toast } from 'sonner';
 
 const Settings = () => {
-  const selectedTheme_ = useTheme();
+  const originalSettings = useSettings();
   const [selectedTheme, setSelectedTheme] = useState<Theme>();
+  const [selectedShowMediaMetaIn, setSelectedShowMediaMetaIn] =
+    useState<Language>();
 
   const router = useRouter();
   const setTheme = api.settings.setTheme.useMutation({
     onSuccess: () => {
+      toast.success(`Set theme to ${selectedTheme}`);
       router.refresh();
     },
   });
+  const setShowMediaMetaIn = api.settings.setShowMediaMetaIn.useMutation({
+    onSuccess: () => {
+      toast.success(
+        `Set show media meta to ${selectedShowMediaMetaIn ? selectedShowMediaMetaIn.name : ''}`
+      );
+      router.refresh();
+    },
+  });
+
+  const languages = api.settings.getLanguages.useQuery();
 
   useEffect(() => {
-    setSelectedTheme(selectedTheme_);
+    setSelectedTheme(originalSettings.theme);
+    setSelectedShowMediaMetaIn(originalSettings.showMediaMetaIn);
   }, []);
 
   const user = useAuthUser();
···
           Appearance
         </div>
         <Card>
-          <CardContent className="flex items-center justify-between p-2 ps-4">
-            <div className="whitespace-nowrap text-sm font-medium text-base-600">
-              Theme
+          <CardContent className="divide-y divide-base-100 p-0 pe-2 ps-4">
+            <div className="flex items-center justify-between py-2">
+              <div className="whitespace-nowrap text-sm font-medium text-base-600">
+                Theme
+              </div>
+              <div className="w-fit">
+                <Select
+                  value={selectedTheme}
+                  onValueChange={theme => {
+                    setSelectedTheme(theme as Theme);
+                    setTheme.mutate({ theme });
+                  }}
+                >
+                  <SelectTrigger>
+                    {selectedTheme ? (
+                      <ThemeComponent theme={selectedTheme} />
+                    ) : (
+                      'No theme selected'
+                    )}
+                  </SelectTrigger>
+                  <SelectContent>
+                    {Object.keys(Theme).map(theme => (
+                      <SelectItem
+                        key={theme}
+                        value={theme}
+                        className="cursor-pointer hover:bg-base-400"
+                      >
+                        <ThemeComponent theme={theme} />
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
             </div>
-            <div className="w-fit">
-              <Select
-                value={selectedTheme}
-                onValueChange={theme => {
-                  setSelectedTheme(theme as Theme);
-                  setTheme.mutate({ theme });
-                }}
-              >
-                <SelectTrigger>
-                  {selectedTheme ? (
-                    <ThemeComponent theme={selectedTheme} />
-                  ) : (
-                    'No theme selected'
-                  )}
-                </SelectTrigger>
-                <SelectContent>
-                  {Object.keys(Theme).map(theme => (
-                    <SelectItem
-                      key={theme}
-                      value={theme}
-                      className="cursor-pointer hover:bg-base-400"
-                    >
-                      <ThemeComponent theme={theme} />
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
+            <div className="flex items-center justify-between py-2">
+              <div className="whitespace-nowrap text-sm font-medium text-base-600">
+                Show media meda in
+              </div>
+              <div className="w-fit">
+                <Select
+                  value={
+                    selectedShowMediaMetaIn
+                      ? selectedShowMediaMetaIn.iso_639_2!
+                      : ''
+                  }
+                  onValueChange={iso_639_2 => {
+                    setSelectedShowMediaMetaIn(
+                      languages.data!.find(e => e.iso_639_2 === iso_639_2)
+                    );
+                    setShowMediaMetaIn.mutate({ iso_639_2: iso_639_2 });
+                  }}
+                >
+                  <SelectTrigger>
+                    {selectedShowMediaMetaIn
+                      ? selectedShowMediaMetaIn.name
+                      : 'No language selected'}
+                  </SelectTrigger>
+                  <SelectContent>
+                    {languages.data &&
+                      languages.data
+                        .sort((a, b) => a.name.localeCompare(b.name))
+                        .map(language => (
+                          <SelectItem
+                            key={language.id}
+                            value={language.iso_639_2!}
+                            className="cursor-pointer hover:bg-base-400"
+                          >
+                            {language.name}
+                          </SelectItem>
+                        ))}
+                  </SelectContent>
+                </Select>
+              </div>
             </div>
           </CardContent>
         </Card>

components/layouts/base.tsx

···
-import { getTheme } from '@/app/_components/theme';
+import { getTheme } from '@/app/_components/settings';
 import { cn } from '@/lib/utils';
 import React, { ReactNode } from 'react';
 

components/layouts/sidebar.tsx

···
-import { getTheme } from '@/app/_components/theme';
+import { getTheme } from '@/app/_components/settings';
 import { cn } from '@/lib/utils';
 import React, { ReactNode } from 'react';
 import BaseLayout from './base';

components/modifyUserEntry.tsx

···
 } from './ui/dialog';
 import { Label } from './ui/label';
 import { DateTimePicker } from './ui/date-time-picker';
+import { api } from '@/trpc/react';
 
 const ModifyUserEntry = ({
   userEntry,
···
   setUserEntry,
   removeUserEntry: removeUserEntryClient,
 }: {
-  userEntry: UserEntry & { user: User } & { entry: Entry };
+  userEntry: ExtendedUserEntry;
   userLists: UserList[];
   userListsWithEntry: UserList[];
   refetchUserLists: () => Promise<void>;
···
     saveUserEntry,
     {}
   );
+
+  const utils = api.useUtils();
+  useEffect(() => {
+    if (saveUserEntryState.message) {
+      utils.dashboard.invalidate();
+    }
+  }, [saveUserEntryState]);
   const [removeUserEntryState, removeUserEntryAction] = useFormState(
     removeUserEntry,
     {}

components/userEntryCard.tsx

···
 } & HTMLProps<HTMLDivElement>) => (
   <UserEntryCard
     {...{
-      title: userEntry.entry.originalTitle,
+      title:
+        userEntry.entry.translations.length !== 0
+          ? userEntry.entry.translations[0]!.name
+          : userEntry.entry.originalTitle,
       backgroundImage: userEntry.entry.posterPath,
       releaseDate: userEntry.entry.releaseDate,
       category: userEntry.entry.category,

components/userEntryExternal.tsx

···
   openOverride,
   setUserEntry,
 }: {
-  userEntry: UserEntry & { user: User } & { entry: Entry };
+  userEntry: ExtendedUserEntry;
   openOverride?:
     | [open: boolean, setOpen: Dispatch<SetStateAction<boolean>>]
     | undefined;

migration/fix_series_foreign_id.py

···
+import mysql.connector
+import requests
+import json
+import sys
+import time
+
+apiKey = input("apikey:")
+
+db = mysql.connector.connect(
+    host="mysql",
+    user="root",
+    password="prisma",
+    database="database"
+)
+
+cursor = db.cursor(buffered=True, dictionary=True)
+cursor2 = db.cursor(buffered=True, dictionary=True)
+cursor3 = db.cursor(buffered=True, dictionary=True)
+
+SERIES_CATEGORY = 1
+MOVIE_CATEGORY = 2
+BOOK_CATEGORY = 3
+
+# cursor.execute(f"SELECT * FROM Entry WHERE foreignId = 293342")
+# print(cursor.fetchone())
+
+ignore = []
+cursor.execute(f"SELECT * FROM Entry")
+entries = cursor.fetchall()
+# cursor.close()
+for entry in entries:
+    print("\n------------------------")
+    if(entry["category"] != "Series"):
+        print("Skipped non series")
+        continue
+    print("Processing series")
+
+    cursor.execute(f"SELECT * FROM Collection WHERE id = {entry['collectionId']}")
+    collection = cursor.fetchone()
+    # cursor.close()
+    print(collection)
+
+    seasons = json.loads(requests.get(f"https://api.themoviedb.org/3/tv/{collection['foreignId']}?language=en-US", headers={
+        "Authorization": f"Bearer {apiKey}"
+    }).content)["seasons"]
+
+    for season in seasons:
+        cursor2.execute("SELECT * FROM Entry WHERE foreignId = %s", (str(season['id']),))
+        season_entry = cursor2.fetchone()
+        print(season_entry)
+        print(cursor2.statement)
+
+        if season_entry is None:
+            print(season)
+            print("issue")
+            time.sleep(2)
+            continue
+
+        if season_entry["id"] in ignore:
+            continue
+
+        print(season)
+        print(season_entry)
+
+        cursor3.execute(
+            "UPDATE Entry SET foreignId = %s WHERE foreignId = %s",
+            (str(season['season_number']), str(season['id']))
+        )
+
+        ignore.append(season_entry["id"])
+
+
+db.commit()

migration/populate_translations.py

···
+import mysql.connector    
+import requests
+import json
+import sys
+
+apiKey = input("apikey:")
+
+db = mysql.connector.connect(
+    host="mysql",
+    user="root",
+    password="prisma",
+    database="database"
+)
+
+cursor = db.cursor(buffered=True, dictionary=True)
+cursor2 = db.cursor(buffered=True, dictionary=True)
+
+SERIES_CATEGORY = 1
+MOVIE_CATEGORY = 2
+BOOK_CATEGORY = 3
+
+cursor.execute(f"SELECT * FROM Entry")
+entries = cursor.fetchall()
+for entry in entries:
+    print("\n------------------------")
+    if(entry["category"] == "Book"):
+        print("Skipped book")
+        continue
+    
+    cursor.execute(f"SELECT * FROM Collection WHERE id = '{entry['collectionId']}'")
+    collection = cursor.fetchone()
+    print(collection)
+    
+    if(entry['category'] == 'Movie'):
+        url = f"https://api.themoviedb.org/3/movie/{entry['foreignId']}/translations?language=en-US"
+    else:
+        url = f"https://api.themoviedb.org/3/tv/{entry['foreignId']}/translations?language=en-US"
+    print(url)
+    print(entry)
+    translations = json.loads(requests.get(url, headers={
+        "Authorization": f"Bearer {apiKey}"
+    }).content)["translations"]
+    print(translations)
+    
+    for translation in translations:
+        cursor.execute(f"SELECT * FROM Language WHERE iso_639_1 = '{translation['iso_639_1']}'")
+        language = cursor.fetchone()
+        print(language["name"])
+        cursor.execute(f"SELECT * FROM Country WHERE iso_3166_1 = '{translation['iso_3166_1']}'")
+        country = cursor.fetchone()
+        print(country["name"])
+        
+    
+    print(entry["id"])

prisma/schema.prisma

···
 generator client {
-    provider      = "prisma-client-js"
-    binaryTargets = ["native", "debian-openssl-3.0.x", "linux-musl-openssl-3.0.x"]
+  provider      = "prisma-client-js"
+  binaryTargets = ["native", "debian-openssl-3.0.x", "linux-musl-openssl-3.0.x"]
 }
 
 datasource db {
-    provider = "mysql"
-    url      = env("DATABASE_URL")
+  provider = "mysql"
+  url      = env("DATABASE_URL")
 }
 
 enum RatingStyle {
-    stars
-    range
+  stars
+  range
 }
 
 enum Theme {
-    slate
-    gray
-    zinc
-    neutral
-    stone
-    red
-    orange
-    amber
-    yellow
-    lime
-    green
-    emerald
-    teal
-    cyan
-    sky
-    blue
-    indigo
-    violet
-    purple
-    fuchsia
-    pink
-    rose
+  slate
+  gray
+  zinc
+  neutral
+  stone
+  red
+  orange
+  amber
+  yellow
+  lime
+  green
+  emerald
+  teal
+  cyan
+  sky
+  blue
+  indigo
+  violet
+  purple
+  fuchsia
+  pink
+  rose
 }
 
 model User {
-    id          Int         @id @default(autoincrement()) @db.UnsignedInt
-    username    String      @unique
-    email       String      @unique
-    password    String      @db.VarChar(64)
-    sessions    Session[]
-    ratingStyle RatingStyle @default(stars)
-    theme       Theme       @default(neutral)
+  id                Int         @id @default(autoincrement()) @db.UnsignedInt
+  username          String      @unique
+  email             String      @unique
+  password          String      @db.VarChar(64)
+  sessions          Session[]
+  ratingStyle       RatingStyle @default(stars)
+  theme             Theme       @default(neutral)
+  showMediaMetaInId Int?        @db.UnsignedInt
+  showMediaMetaIn   Language?   @relation("showMediaMetaInIn", fields: [showMediaMetaInId], references: [id])
 
-    dailyStreakStarted DateTime @default(now())
-    dailyStreakUpdated DateTime @default(now())
-    dailyStreakLength  Int      @default(0) @db.SmallInt
-    dailyStreakLongest Int      @default(0) @db.SmallInt
+  dailyStreakStarted DateTime @default(now())
+  dailyStreakUpdated DateTime @default(now())
+  dailyStreakLength  Int      @default(0) @db.SmallInt
+  dailyStreakLongest Int      @default(0) @db.SmallInt
 
-    invitedById Int?   @db.UnsignedInt
-    invitedBy   User?  @relation("Invite", fields: [invitedById], references: [id])
-    invitees    User[] @relation("Invite")
+  invitedById Int?   @db.UnsignedInt
+  invitedBy   User?  @relation("Invite", fields: [invitedById], references: [id])
+  invitees    User[] @relation("Invite")
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 
-    following       UserFollow[]         @relation("follower")
-    followers       UserFollow[]         @relation("followee")
-    userEntries     UserEntry[]
-    activity        UserActivity[]
-    forgotPasswords UserForgotPassword[]
-    lists           UserList[]
+  following       UserFollow[]         @relation("follower")
+  followers       UserFollow[]         @relation("followee")
+  userEntries     UserEntry[]
+  activity        UserActivity[]
+  forgotPasswords UserForgotPassword[]
+  lists           UserList[]
 }
 
 enum Activity {
-    statusUpdate
-    reviewed
-    rewatch
-    completeReview
+  statusUpdate
+  reviewed
+  rewatch
+  completeReview
 }
 
 model UserActivity {
-    id Int @id @default(autoincrement()) @db.UnsignedInt
+  id Int @id @default(autoincrement()) @db.UnsignedInt
 
-    userId         Int      @db.UnsignedInt
-    user           User     @relation(fields: [userId], references: [id], onDelete: Cascade)
-    entryId        Int      @db.UnsignedInt
-    entry          Entry    @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    type           Activity
-    additionalData String
+  userId         Int      @db.UnsignedInt
+  user           User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  entryId        Int      @db.UnsignedInt
+  entry          Entry    @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  type           Activity
+  additionalData String
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model UserFollow {
-    id Int @id @default(autoincrement()) @db.UnsignedInt
+  id Int @id @default(autoincrement()) @db.UnsignedInt
 
-    userId   Int  @db.UnsignedInt
-    user     User @relation("follower", fields: [userId], references: [id], onDelete: Cascade)
-    followId Int  @db.UnsignedInt
-    follow   User @relation("followee", fields: [followId], references: [id], onDelete: Cascade)
+  userId   Int  @db.UnsignedInt
+  user     User @relation("follower", fields: [userId], references: [id], onDelete: Cascade)
+  followId Int  @db.UnsignedInt
+  follow   User @relation("followee", fields: [followId], references: [id], onDelete: Cascade)
 
-    isFollowing Boolean
+  isFollowing Boolean
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 enum UserEntryStatus {
-    planning
-    watching
-    dnf
-    paused
-    completed
+  planning
+  watching
+  dnf
+  paused
+  completed
 }
 
 model UserEntry {
-    id        Int             @id @default(autoincrement()) @db.UnsignedInt
-    userId    Int             @db.UnsignedInt
-    user      User            @relation(fields: [userId], references: [id], onDelete: Cascade)
-    entryId   Int             @db.UnsignedInt
-    entry     Entry           @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    rating    Int             @db.SmallInt
-    notes     String          @db.Text
-    watchedAt DateTime?
-    status    UserEntryStatus @default(planning)
-    progress  Int             @db.UnsignedSmallInt
-    createdAt DateTime        @default(now())
-    updatedAt DateTime        @default(now()) @updatedAt
+  id        Int             @id @default(autoincrement()) @db.UnsignedInt
+  userId    Int             @db.UnsignedInt
+  user      User            @relation(fields: [userId], references: [id], onDelete: Cascade)
+  entryId   Int             @db.UnsignedInt
+  entry     Entry           @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  rating    Int             @db.SmallInt
+  notes     String          @db.Text
+  watchedAt DateTime?
+  status    UserEntryStatus @default(planning)
+  progress  Int             @db.UnsignedSmallInt
+  createdAt DateTime        @default(now())
+  updatedAt DateTime        @default(now()) @updatedAt
 }
 
 enum UserListType {
-    ordered
-    unordered
+  ordered
+  unordered
 }
 
 model UserList {
-    id          Int             @id @default(autoincrement()) @db.UnsignedInt
-    userId      Int             @db.UnsignedInt
-    user        User            @relation(fields: [userId], references: [id], onDelete: Cascade)
-    name        String
-    description String          @default("") @db.VarChar(256)
-    type        UserListType
-    entries     UserListEntry[]
-    createdAt   DateTime        @default(now())
-    updatedAt   DateTime        @default(now()) @updatedAt
+  id          Int             @id @default(autoincrement()) @db.UnsignedInt
+  userId      Int             @db.UnsignedInt
+  user        User            @relation(fields: [userId], references: [id], onDelete: Cascade)
+  name        String
+  description String          @default("") @db.VarChar(256)
+  type        UserListType
+  entries     UserListEntry[]
+  createdAt   DateTime        @default(now())
+  updatedAt   DateTime        @default(now()) @updatedAt
 }
 
 model UserListEntry {
-    id        Int      @id @default(autoincrement()) @db.UnsignedInt
-    entryId   Int      @db.UnsignedInt
-    entry     Entry    @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    listId    Int      @db.UnsignedInt
-    list      UserList @relation(fields: [listId], references: [id], onDelete: Cascade)
-    order     Int
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  id        Int      @id @default(autoincrement()) @db.UnsignedInt
+  entryId   Int      @db.UnsignedInt
+  entry     Entry    @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  listId    Int      @db.UnsignedInt
+  list      UserList @relation(fields: [listId], references: [id], onDelete: Cascade)
+  order     Int
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Session {
-    id        Int       @id @default(autoincrement()) @db.UnsignedInt
-    token     String    @db.VarChar(64)
-    user      User      @relation(fields: [userId], references: [id], onDelete: Cascade)
-    userId    Int       @db.UnsignedInt
-    expiry    DateTime?
-    ipAddress String
-    userAgent String
-    createdAt DateTime  @default(now())
-    updatedAt DateTime  @default(now()) @updatedAt
+  id        Int       @id @default(autoincrement()) @db.UnsignedInt
+  token     String    @db.VarChar(64)
+  user      User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  userId    Int       @db.UnsignedInt
+  expiry    DateTime?
+  ipAddress String
+  userAgent String
+  createdAt DateTime  @default(now())
+  updatedAt DateTime  @default(now()) @updatedAt
 }
 
 model Company {
-    id                       Int                      @id @default(autoincrement()) @db.UnsignedInt
-    name                     String
-    logo                     String?
-    countryId                Int                      @db.UnsignedInt
-    country                  Country                  @relation(fields: [countryId], references: [id], onDelete: Cascade)
-    foreignId                String
-    entryProductionCompanies EntryProductionCompany[]
+  id                       Int                      @id @default(autoincrement()) @db.UnsignedInt
+  name                     String
+  logo                     String?
+  countryId                Int                      @db.UnsignedInt
+  country                  Country                  @relation(fields: [countryId], references: [id], onDelete: Cascade)
+  foreignId                String
+  entryProductionCompanies EntryProductionCompany[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Country {
-    id                     Int                      @id @default(autoincrement()) @db.UnsignedInt
-    name                   String                   @unique
-    iso_3166_1             String                   @unique @db.VarChar(6)
-    companies              Company[]
-    productionCountries    EntryProductionCountry[]
-    entryWatchProviders    EntryWatchProvider[]
-    entryAlternativeTitles EntryAlternativeTitle[]
+  id                     Int                      @id @default(autoincrement()) @db.UnsignedInt
+  name                   String                   @unique
+  iso_3166_1             String                   @unique @db.VarChar(6)
+  companies              Company[]
+  productionCountries    EntryProductionCountry[]
+  entryWatchProviders    EntryWatchProvider[]
+  entryAlternativeTitles EntryAlternativeTitle[]
+  entryTranslation       EntryTranslation[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Language {
-    id                     Int                     @id @default(autoincrement()) @db.UnsignedInt
-    name                   String
-    iso_639_1              String?                 @db.VarChar(2)
-    iso_639_2              String                  @db.VarChar(3)
-    spokenLanguages        EntrySpokenLanguage[]
-    entryAlternativeTitles EntryAlternativeTitle[]
+  id                     Int                     @id @default(autoincrement()) @db.UnsignedInt
+  name                   String
+  iso_639_1              String?                 @db.VarChar(2)
+  iso_639_2              String                  @db.VarChar(3)
+  spokenLanguages        EntrySpokenLanguage[]
+  entryAlternativeTitles EntryAlternativeTitle[]
+  entryTranslations      EntryTranslation[]
+  userShowMediaMetaIn    User[]                  @relation("showMediaMetaInIn")
+  entryOriginalLanguages Entry[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
-    Entry     Entry[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Person {
-    id          Int         @id @default(autoincrement()) @db.UnsignedInt
-    name        String
-    foreignId   String
-    gender      Int         @db.TinyInt
-    profilePath String?
-    memberCasts EntryCast[]
-    memberCrews EntryCrew[]
+  id          Int         @id @default(autoincrement()) @db.UnsignedInt
+  name        String
+  foreignId   String
+  gender      Int         @db.TinyInt
+  profilePath String?
+  memberCasts EntryCast[]
+  memberCrews EntryCrew[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Genre {
-    id        Int          @id @default(autoincrement()) @db.UnsignedInt
-    name      String
-    foreignId String
-    entries   EntryGenre[]
+  id        Int          @id @default(autoincrement()) @db.UnsignedInt
+  name      String
+  foreignId String
+  entries   EntryGenre[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model WatchProvider {
-    id        Int                  @id @default(autoincrement()) @db.UnsignedInt
-    name      String
-    foreignId String
-    logoPath  String
-    entries   EntryWatchProvider[]
+  id        Int                  @id @default(autoincrement()) @db.UnsignedInt
+  name      String
+  foreignId String
+  logoPath  String
+  entries   EntryWatchProvider[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Department {
-    id   Int         @id @default(autoincrement()) @db.UnsignedInt
-    name String
-    crew EntryCrew[]
+  id   Int         @id @default(autoincrement()) @db.UnsignedInt
+  name String
+  crew EntryCrew[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Job {
-    id   Int         @id @default(autoincrement()) @db.UnsignedInt
-    name String
-    crew EntryCrew[]
+  id   Int         @id @default(autoincrement()) @db.UnsignedInt
+  name String
+  crew EntryCrew[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model EntryProductionCompany {
-    id        Int     @id @default(autoincrement()) @db.UnsignedInt
-    entryId   Int     @db.UnsignedInt
-    entry     Entry   @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    companyId Int     @db.UnsignedInt
-    company   Company @relation(fields: [companyId], references: [id], onDelete: Cascade)
+  id        Int     @id @default(autoincrement()) @db.UnsignedInt
+  entryId   Int     @db.UnsignedInt
+  entry     Entry   @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  companyId Int     @db.UnsignedInt
+  company   Company @relation(fields: [companyId], references: [id], onDelete: Cascade)
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model EntryProductionCountry {
-    id        Int     @id @default(autoincrement()) @db.UnsignedInt
-    entryId   Int     @db.UnsignedInt
-    entry     Entry   @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    countryId Int     @db.UnsignedInt
-    country   Country @relation(fields: [countryId], references: [id], onDelete: Cascade)
+  id        Int     @id @default(autoincrement()) @db.UnsignedInt
+  entryId   Int     @db.UnsignedInt
+  entry     Entry   @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  countryId Int     @db.UnsignedInt
+  country   Country @relation(fields: [countryId], references: [id], onDelete: Cascade)
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model EntrySpokenLanguage {
-    id         Int      @id @default(autoincrement()) @db.UnsignedInt
-    entryId    Int      @db.UnsignedInt
-    entry      Entry    @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    languageId Int      @db.UnsignedInt
-    language   Language @relation(fields: [languageId], references: [id], onDelete: Cascade)
+  id         Int      @id @default(autoincrement()) @db.UnsignedInt
+  entryId    Int      @db.UnsignedInt
+  entry      Entry    @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  languageId Int      @db.UnsignedInt
+  language   Language @relation(fields: [languageId], references: [id], onDelete: Cascade)
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model EntryAlternativeTitle {
-    id         Int       @id @default(autoincrement()) @db.UnsignedInt
-    entryId    Int       @db.UnsignedInt
-    entry      Entry     @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    countryId  Int?      @db.UnsignedInt
-    country    Country?  @relation(fields: [countryId], references: [id], onDelete: Cascade)
-    languageId Int?      @db.UnsignedInt
-    language   Language? @relation(fields: [languageId], references: [id], onDelete: Cascade)
-    title      String
+  id         Int       @id @default(autoincrement()) @db.UnsignedInt
+  entryId    Int       @db.UnsignedInt
+  entry      Entry     @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  countryId  Int?      @db.UnsignedInt
+  country    Country?  @relation(fields: [countryId], references: [id], onDelete: Cascade)
+  languageId Int?      @db.UnsignedInt
+  language   Language? @relation(fields: [languageId], references: [id], onDelete: Cascade)
+  title      String
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 
-    @@index([title])
+  @@index([title])
+}
+
+model EntryTranslation {
+  id         Int       @id @default(autoincrement()) @db.UnsignedInt
+  entryId    Int       @db.UnsignedInt
+  entry      Entry     @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  countryId  Int?      @db.UnsignedInt
+  country    Country?  @relation(fields: [countryId], references: [id], onDelete: Cascade)
+  languageId Int?      @db.UnsignedInt
+  language   Language? @relation(fields: [languageId], references: [id], onDelete: Cascade)
+  name       String
+  overview   String
+  homepage   String
+  tagline    String
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
+
+  @@index([name])
 }
 
 model EntryCast {
-    id        Int    @id @default(autoincrement()) @db.UnsignedInt
-    entryId   Int    @db.UnsignedInt
-    entry     Entry  @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    personId  Int    @db.UnsignedInt
-    person    Person @relation(fields: [personId], references: [id], onDelete: Cascade)
-    character String
+  id        Int    @id @default(autoincrement()) @db.UnsignedInt
+  entryId   Int    @db.UnsignedInt
+  entry     Entry  @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  personId  Int    @db.UnsignedInt
+  person    Person @relation(fields: [personId], references: [id], onDelete: Cascade)
+  character String
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model EntryCrew {
-    id           Int        @id @default(autoincrement()) @db.UnsignedInt
-    entryId      Int        @db.UnsignedInt
-    entry        Entry      @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    personId     Int        @db.UnsignedInt
-    person       Person     @relation(fields: [personId], references: [id], onDelete: Cascade)
-    departmentId Int        @db.UnsignedInt
-    department   Department @relation(fields: [departmentId], references: [id], onDelete: Cascade)
-    jobId        Int        @db.UnsignedInt
-    job          Job        @relation(fields: [jobId], references: [id], onDelete: Cascade)
+  id           Int        @id @default(autoincrement()) @db.UnsignedInt
+  entryId      Int        @db.UnsignedInt
+  entry        Entry      @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  personId     Int        @db.UnsignedInt
+  person       Person     @relation(fields: [personId], references: [id], onDelete: Cascade)
+  departmentId Int        @db.UnsignedInt
+  department   Department @relation(fields: [departmentId], references: [id], onDelete: Cascade)
+  jobId        Int        @db.UnsignedInt
+  job          Job        @relation(fields: [jobId], references: [id], onDelete: Cascade)
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model EntryGenre {
-    id      Int   @id @default(autoincrement()) @db.UnsignedInt
-    entryId Int   @db.UnsignedInt
-    entry   Entry @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    genreId Int   @db.UnsignedInt
-    genre   Genre @relation(fields: [genreId], references: [id], onDelete: Cascade)
+  id      Int   @id @default(autoincrement()) @db.UnsignedInt
+  entryId Int   @db.UnsignedInt
+  entry   Entry @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  genreId Int   @db.UnsignedInt
+  genre   Genre @relation(fields: [genreId], references: [id], onDelete: Cascade)
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 enum WatchProviderType {
-    buy
-    rent
-    flatrate
+  buy
+  rent
+  flatrate
 }
 
 model EntryWatchProvider {
-    id              Int               @id @default(autoincrement()) @db.UnsignedInt
-    entryId         Int               @db.UnsignedInt
-    entry           Entry             @relation(fields: [entryId], references: [id], onDelete: Cascade)
-    watchProviderId Int               @db.UnsignedInt
-    watchProvider   WatchProvider     @relation(fields: [watchProviderId], references: [id], onDelete: Cascade)
-    countryId       Int               @db.UnsignedInt
-    country         Country           @relation(fields: [countryId], references: [id], onDelete: Cascade)
-    type            WatchProviderType
+  id              Int               @id @default(autoincrement()) @db.UnsignedInt
+  entryId         Int               @db.UnsignedInt
+  entry           Entry             @relation(fields: [entryId], references: [id], onDelete: Cascade)
+  watchProviderId Int               @db.UnsignedInt
+  watchProvider   WatchProvider     @relation(fields: [watchProviderId], references: [id], onDelete: Cascade)
+  countryId       Int               @db.UnsignedInt
+  country         Country           @relation(fields: [countryId], references: [id], onDelete: Cascade)
+  type            WatchProviderType
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 enum Category {
-    Series
-    Movie
-    Book
+  Series
+  Movie
+  Book
 }
 
 model Collection {
-    id           Int      @id @default(autoincrement()) @db.UnsignedInt
-    name         String
-    foreignId    String
-    posterPath   String
-    backdropPath String
-    category     Category
-    entries      Entry[]
+  id           Int      @id @default(autoincrement()) @db.UnsignedInt
+  name         String
+  foreignId    String
+  posterPath   String
+  backdropPath String
+  category     Category
+  entries      Entry[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }
 
 model Entry {
-    id                 Int         @id @default(autoincrement()) @db.UnsignedInt
-    collectionId       Int?        @db.UnsignedInt
-    collection         Collection? @relation(fields: [collectionId], references: [id], onDelete: Cascade)
-    category           Category
-    originalLanguageId Int         @db.UnsignedInt
-    originalLanguage   Language    @relation(fields: [originalLanguageId], references: [id], onDelete: Cascade)
-    foreignId          String
-    posterPath         String
-    tagline            String      @db.Text
-    originalTitle      String
-    overview           String      @db.Text
-    backdropPath       String
-    releaseDate        DateTime
-    length             Int         @db.UnsignedSmallInt
+  id                 Int         @id @default(autoincrement()) @db.UnsignedInt
+  collectionId       Int?        @db.UnsignedInt
+  collection         Collection? @relation(fields: [collectionId], references: [id], onDelete: Cascade)
+  category           Category
+  originalLanguageId Int         @db.UnsignedInt
+  originalLanguage   Language    @relation(fields: [originalLanguageId], references: [id], onDelete: Cascade)
+  foreignId          String
+  posterPath         String
+  tagline            String      @db.Text
+  originalTitle      String
+  overview           String      @db.Text
+  backdropPath       String
+  releaseDate        DateTime
+  length             Int         @db.UnsignedSmallInt
 
-    productionCompanies EntryProductionCompany[]
-    productionCountries EntryProductionCountry[]
-    spokenLanguage      EntrySpokenLanguage[]
-    alternativeTitles   EntryAlternativeTitle[]
-    cast                EntryCast[]
-    crew                EntryCrew[]
-    genres              EntryGenre[]
-    watchProviders      EntryWatchProvider[]
-    userEntries         UserEntry[]
-    userActivity        UserActivity[]
-    userListEntries     UserListEntry[]
+  productionCompanies EntryProductionCompany[]
+  productionCountries EntryProductionCountry[]
+  spokenLanguage      EntrySpokenLanguage[]
+  alternativeTitles   EntryAlternativeTitle[]
+  translations        EntryTranslation[]
+  cast                EntryCast[]
+  crew                EntryCrew[]
+  genres              EntryGenre[]
+  watchProviders      EntryWatchProvider[]
+  userEntries         UserEntry[]
+  userActivity        UserActivity[]
+  userListEntries     UserListEntry[]
 
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 
-    @@index([originalTitle])
+  @@index([originalTitle])
 }
 
 model UserForgotPassword {
-    id        String   @id @db.VarChar(36)
-    userId    Int      @db.UnsignedInt
-    user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
-    used      Boolean
-    createdAt DateTime @default(now())
-    updatedAt DateTime @default(now()) @updatedAt
+  id        String   @id @db.VarChar(36)
+  userId    Int      @db.UnsignedInt
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  used      Boolean
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
 }

server/api/routers/dashboard.ts

···
 import { protectedProcedure } from '../trpc';
 import { unstable_cache } from 'next/cache';
 import prisma from '@/server/db';
+import { validateSessionToken } from '@/server/auth/validateSession';
+import { Entry, EntryTranslation } from '@prisma/client';
+
+export const getUserTitleFromEntryId = async (entryId: number) => {
+  const user = await validateSessionToken();
+  const entry = await prisma.entry.findFirst({
+    where: {
+      id: entryId,
+    },
+    include: {
+      translations: {
+        where: {
+          language: {
+            id: user ? (user.showMediaMetaInId ?? undefined) : undefined,
+            iso_639_1: !user ? 'en' : undefined,
+          },
+        },
+      },
+    },
+  });
+  if (!entry) {
+    return null;
+  }
+
+  return getUserTitleFromEntry(entry);
+};
+
+export const getUserTitleFromEntry = (
+  entry: Entry & { translations: EntryTranslation[] }
+) => {
+  return entry.translations.length !== 0
+    ? entry.translations[0]!.name
+    : entry.originalTitle;
+};
 
 const getTop3RatedNotCompleted = unstable_cache(
   async (userId: number) => {
···
             userEntries: {
               where: {
                 userId: ctx.user.id,
+              },
+            },
+            translations: {
+              where: {
+                languageId: ctx.user.showMediaMetaInId,
               },
             },
           },

server/api/routers/settings.ts

···
 import { Theme } from '@prisma/client';
 import z from 'zod';
 import { protectedProcedure } from '../trpc';
+import { TRPCError } from '@trpc/server';
 
 export const settingsRouter = createTRPCRouter({
   setTheme: protectedProcedure
···
         },
       });
     }),
+  setShowMediaMetaIn: protectedProcedure
+    .input(
+      z.object({
+        iso_639_2: z.string(),
+      })
+    )
+    .mutation(async ({ input, ctx }) => {
+      const language = await prisma.language.findFirst({
+        where: {
+          iso_639_2: input.iso_639_2,
+        },
+      });
+      if (!language) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'Invalid iso_639_2 code',
+        });
+      }
+      await prisma.user.update({
+        data: {
+          showMediaMetaInId: language.id,
+        },
+        where: {
+          id: ctx.user.id,
+        },
+      });
+    }),
+  getLanguages: protectedProcedure.query(async () => {
+    return await prisma.language.findMany();
+  }),
 });