Update v3.9.1 - Merged Beta to Main (#44)v3.9.1

* commit

* update db

* Update v3.9.1-beta-v3.1

* Update v3.9.1

1 files changed, 175 insertions, 142 deletions

diff --git a/prisma/user.js b/prisma/user.js
index 04222d5..8c436a5 100644
--- a/prisma/user.js
+++ b/prisma/user.js
@@ -1,157 +1,183 @@
-// import { prisma } from "../lib/prisma";
-import { PrismaClient } from "@prisma/client";
-const prisma = new PrismaClient();
+// import { PrismaClient } from "@prisma/client";
+// const prisma = new PrismaClient();
+
+import { prisma } from "../lib/prisma";
 
 export const createUser = async (name, setting) => {
-  const checkUser = await prisma.userProfile.findUnique({
-    where: {
-      name: name,
-    },
-  });
-  if (!checkUser) {
-    const user = await prisma.userProfile.create({
-      data: {
+  try {
+    const checkUser = await prisma.userProfile.findUnique({
+      where: {
         name: name,
-        setting,
       },
     });
+    if (!checkUser) {
+      const user = await prisma.userProfile.create({
+        data: {
+          name: name,
+        },
+      });
 
-    return user;
-  } else {
-    return null;
+      return user;
+    } else {
+      return null;
+    }
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error creating user");
   }
 };
 
 export const updateUser = async (name, anime) => {
-  const checkAnime = await prisma.watchListItem.findUnique({
-    where: {
-      title: anime.title,
-      userProfileId: name,
-    },
-  });
-  if (checkAnime) {
-    const checkEpisode = await prisma.watchListEpisode.findUnique({
+  try {
+    const checkAnime = await prisma.watchListItem.findUnique({
       where: {
-        url: anime.id,
+        title: anime.title,
+        userProfileId: name,
       },
     });
-    if (checkEpisode) {
-      return null;
-    } else {
-      const user = await prisma.watchListItem.update({
+    if (checkAnime) {
+      const checkEpisode = await prisma.watchListEpisode.findUnique({
         where: {
-          title: anime.title,
-          userProfileId: name,
+          url: anime.id,
         },
       });
-    }
-  } else {
-    const user = await prisma.userProfile.update({
-      where: { name: name },
-      data: {
-        watchList: {
-          create: {
+      if (checkEpisode) {
+        return null;
+      } else {
+        const user = await prisma.watchListItem.update({
+          where: {
             title: anime.title,
-            episodes: {
-              create: {
-                url: anime.id,
+            userProfileId: name,
+          },
+        });
+      }
+    } else {
+      const user = await prisma.userProfile.update({
+        where: { name: name },
+        data: {
+          watchList: {
+            create: {
+              title: anime.title,
+              episodes: {
+                create: {
+                  url: anime.id,
+                },
               },
             },
           },
         },
-      },
-      include: {
-        watchList: true,
-      },
-    });
+        include: {
+          watchList: true,
+        },
+      });
 
-    return user;
+      return user;
+    }
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error updating user");
   }
 };
 
 export const getUser = async (name) => {
-  if (!name) {
-    const user = await prisma.userProfile.findMany({
-      include: {
-        WatchListEpisode: true,
-      },
-    });
-    return user;
-  } else {
-    const user = await prisma.userProfile.findFirst({
-      where: {
-        name: name,
-      },
-      include: {
-        WatchListEpisode: {
-          orderBy: {
-            createdDate: "desc",
+  try {
+    if (!name) {
+      const user = await prisma.userProfile.findMany({
+        include: {
+          WatchListEpisode: true,
+        },
+      });
+      return user;
+    } else {
+      const user = await prisma.userProfile.findFirst({
+        where: {
+          name: name,
+        },
+        include: {
+          WatchListEpisode: {
+            orderBy: {
+              createdDate: "desc",
+            },
           },
         },
-      },
-    });
-    return user;
+      });
+      return user;
+    }
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error getting user");
   }
 };
 
 export const deleteUser = async (name) => {
-  const user = await prisma.userProfile.delete({
-    where: {
-      name: name,
-    },
-  });
-  return user;
+  try {
+    const user = await prisma.userProfile.delete({
+      where: {
+        name: name,
+      },
+    });
+    return user;
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error deleting user");
+  }
 };
 
 export const createList = async (name, id, title) => {
-  const checkEpisode = await prisma.watchListEpisode.findFirst({
-    where: {
-      userProfileId: name,
-      watchId: id,
-    },
-  });
-  if (checkEpisode) {
-    return null;
-  } else {
-    const episode = await prisma.userProfile.update({
-      where: { name: name },
-      data: {
-        WatchListEpisode: {
-          create: [
-            {
-              watchId: id,
-            },
-          ],
-        },
-      },
-      include: {
-        WatchListEpisode: true,
+  try {
+    const checkEpisode = await prisma.watchListEpisode.findFirst({
+      where: {
+        userProfileId: name,
+        watchId: id,
       },
     });
-    return episode;
+    if (checkEpisode) {
+      return null;
+    } else {
+      const episode = await prisma.userProfile.update({
+        where: { name: name },
+        data: {
+          WatchListEpisode: {
+            create: [
+              {
+                watchId: id,
+              },
+            ],
+          },
+        },
+        include: {
+          WatchListEpisode: true,
+        },
+      });
+      return episode;
+    }
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error creating list");
   }
 };
 
 export const getEpisode = async (name, id) => {
-  console.log({ name, id });
-  const episode = await prisma.watchListEpisode.findMany({
-    // where: {
-    //   AND: [{ userProfileId: name }, { watchId: id }],
-    // },
-    where: {
-      AND: [
-        {
-          userProfileId: name,
-        },
-        {
-          watchId: {
-            equals: id,
+  try {
+    const episode = await prisma.watchListEpisode.findMany({
+      where: {
+        AND: [
+          {
+            userProfileId: name,
           },
-        },
-      ],
-    },
-  });
-  return episode;
+          {
+            watchId: {
+              equals: id,
+            },
+          },
+        ],
+      },
+    });
+    return episode;
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error getting episode");
+  }
 };
 
 export const updateUserEpisode = async ({
@@ -166,38 +192,45 @@ export const updateUserEpisode = async ({
   aniTitle,
   provider,
 }) => {
-  const user = await prisma.watchListEpisode.updateMany({
-    where: {
-      userProfileId: name,
-      watchId: watchId,
-    },
-    data: {
-      title: title,
-      aniTitle: aniTitle,
-      image: image,
-      aniId: id,
-      provider: provider,
-      duration: duration,
-      episode: number,
-      timeWatched: timeWatched,
-      createdDate: new Date(),
-    },
-  });
-
-  // const user = name;
+  try {
+    const user = await prisma.watchListEpisode.updateMany({
+      where: {
+        userProfileId: name,
+        watchId: watchId,
+      },
+      data: {
+        title: title,
+        aniTitle: aniTitle,
+        image: image,
+        aniId: id,
+        provider: provider,
+        duration: duration,
+        episode: number,
+        timeWatched: timeWatched,
+        createdDate: new Date(),
+      },
+    });
 
-  return user;
+    return user;
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error updating user episode");
+  }
 };
 
 export const updateTimeWatched = async (id, timeWatched) => {
-  const user = await prisma.watchListEpisode.update({
-    where: {
-      id: id,
-      // userProfileId: name,
-    },
-    data: {
-      timeWatched: timeWatched,
-    },
-  });
-  return user;
+  try {
+    const user = await prisma.watchListEpisode.update({
+      where: {
+        id: id,
+      },
+      data: {
+        timeWatched: timeWatched,
+      },
+    });
+    return user;
+  } catch (error) {
+    console.error(error);
+    throw new Error("Error updating time watched");
+  }
 };