Progress

src/controllers/customer.js

@@ -1,17 +1,13 @@
-const { PrismaClientKnownRequestError } = require("@prisma/client")
-const { createCustomerDb } = require('../domains/customer.js')
+const { PrismaClientKnownRequestError } = require("@prisma/client");
+const { createCustomerDb, updateCustomerDb } = require('../domains/customer.js');
 
 const createCustomer = async (req, res) => {
-  const {
-    name,
-    phone,
-    email
-  } = req.body
+  const { name, phone, email } = req.body;
 
   if (!name || !phone || !email) {
     return res.status(400).json({
       error: "Missing fields in request body"
-    })
+    });
   }
 
   // Try-catch is a very common way to handle errors in JavaScript.
@@ -22,9 +18,9 @@ const createCustomer = async (req, res) => {
   // instead of the Prisma error being thrown (and the app potentially crashing) we exit the
   // `try` block (bypassing the `res.status` code) and enter the `catch` block.
   try {
-    const createdCustomer = await createCustomerDb(name, phone, email)
+    const createdCustomer = await createCustomerDb(name, phone, email);
 
-    res.status(201).json({ customer: createdCustomer })
+    res.status(201).json({ customer: createdCustomer });
   } catch (e) {
     // In this catch block, we are able to specify how different Prisma errors are handled.
     // Prisma throws errors with its own codes. P2002 is the error code for
@@ -35,14 +31,48 @@ const createCustomer = async (req, res) => {
     // HTTP error codes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses
     if (e instanceof PrismaClientKnownRequestError) {
       if (e.code === "P2002") {
-        return res.status(409).json({ error: "A customer with the provided email already exists" })
+        return res.status(409).json({ error: "A customer with the provided email already exists" });
       }
     }
 
-    res.status(500).json({ error: e.message })
+    // Log the error for debugging purposes
+    console.error('Error creating customer:', e);
+
+    res.status(500).json({ error: e.message });
+  }
+};
+
+const updateCustomer = async (req, res) => {
+  const { id } = req.params;
+  const { name, phone, email } = req.body;
+
+  if (!name && !phone && !email) {
+    return res.status(400).json({
+      error: "At least one field must be provided to update"
+    });
+  }
+
+  try {
+    const updatedCustomer = await updateCustomerDb(id, { name, phone, email });
+
+    if (!updatedCustomer) {
+      return res.status(404).json({ error: "Customer not found" });
+    }
+
+    res.status(201).json({ customer: updatedCustomer });
+  } catch (e) {
+    // Log the error for debugging purposes
+    console.error('Error updating customer:', e);
+
+    if (e instanceof PrismaClientKnownRequestError) {
+      return res.status(400).json({ error: 'A known error occurred while updating the customer.' });
+    }
+
+    res.status(500).json({ error: e.message });
   }
-}
+};
 
 module.exports = {
-  createCustomer
-}
+  createCustomer,
+  updateCustomer
+};

src/controllers/movie.js

@@ -0,0 +1,93 @@
+const { PrismaClient } = require("@prisma/client"); //import PrismaClient!
+const prisma = new PrismaClient(); //saved as Prisma
+
+//Getting all the movies
+const getMovies = async (req, res) => {
+  try {
+    const movies = await prisma.movie.findMany({
+      include: {
+        screenings: true,
+      },
+    });
+    res.status(200).json({ movies });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+};
+
+//creating movies
+const createMovie = async (req, res) => {
+  const { title, runtimeMins } = req.body;
+
+  if (!title || !runtimeMins) {
+    return res.status(400).json({ error: "Missing fields in request body" });
+  }
+
+  try {
+    const newMovie = await prisma.movie.create({
+      data: {
+        title,
+        runtimeMins,
+      },
+      include: {
+        screenings: true,
+      },
+    });
+    res.status(201).json({ movie: newMovie });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+};
+
+// Getting the moovies by Id
+const getMovieById = async (req, res) => {
+  const { id } = req.params;
+
+  try {
+    const movie = await prisma.movie.findUnique({
+      where: { id: Number(id) },
+      include: {
+        screenings: true,
+      },
+    });
+
+    if (!movie) {
+      return res.status(404).json({ error: "Movie not found" });
+    }
+
+    res.status(200).json({ movie });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+};
+
+//Updating
+const updateMovieById = async (req, res) => {
+  const { id } = req.params;
+  const { title, runtimeMins } = req.body;
+
+  try {
+    const updatedMovie = await prisma.movie.update({
+      where: { id: Number(id) },
+      data: {
+        title,
+        runtimeMins,
+      },
+      include: {
+        screenings: true,
+      },
+    });
+
+    res.status(201).json({ movie: updatedMovie });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+};
+
+//Exporting
+module.exports = {
+  getMovies,
+  createMovie,
+  getMovieById,
+  updateMovieById,
+};

src/controllers/screen.js

@@ -0,0 +1,21 @@
+// src/controllers/screen.js
+const { createScreenDb } = require('../domains/screen');
+
+const createScreen = async (req, res) => {
+    const { number } = req.body;
+
+    if (!number) {
+        return res.status(400).json({ error: "Number field is required" });
+    }
+
+    try {
+        const createdScreen = await createScreenDb(number);
+        res.status(201).json({ screen: createdScreen });
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+};
+
+module.exports = {
+    createScreen,
+};

src/domains/customer.js

@@ -1,26 +1,46 @@
-const prisma = require('../utils/prisma')
+const { PrismaClient } = require("@prisma/client");
+const prisma = new PrismaClient();
 
-/**
- * This will create a Customer AND create a new Contact, then automatically relate them with each other
- * @tutorial https://www.prisma.io/docs/concepts/components/prisma-client/relation-queries#create-a-related-record
- */
-const createCustomerDb = async (name, phone, email) => await prisma.customer.create({
-  data: {
-    name,
-    contact: {
-      create: {
-        phone,
-        email
+const createCustomerDb = async (name, phone, email) => {
+  return prisma.customer.create({
+    data: {
+      name,
+      contact: {
+        create: {
+          phone,
+          email
+        }
       }
+    },
+    include: {
+      contact: true
     }
-  },
-  // We add an `include` outside of the `data` object to make sure the new contact is returned in the result
-  // This is like doing RETURNING in SQL
-  include: {
-    contact: true
+  });
+};
+
+const updateCustomerDb = async (id, data) => {
+  const updateData = {};
+
+  if (data.name) updateData.name = data.name;
+  if (data.phone || data.email) {
+    updateData.contact = {
+      update: {}
+    };
+
+    if (data.phone) updateData.contact.update.phone = data.phone;
+    if (data.email) updateData.contact.update.email = data.email;
   }
-})
+
+  return prisma.customer.update({
+    where: { id: Number(id) },
+    data: updateData,
+    include: {
+      contact: true
+    }
+  });
+};
 
 module.exports = {
-  createCustomerDb
-}
+  createCustomerDb,
+  updateCustomerDb
+};