Hw05 avatars

app.js

@@ -1,25 +1,32 @@
-const express = require('express')
-const logger = require('morgan')
-const cors = require('cors')
+const express = require("express");
+const logger = require("morgan");
+const cors = require("cors");
+const connectDB = require("./config/db");
+const authRouter = require("./routes/api/auth");
 
-const contactsRouter = require('./routes/api/contacts')
+const app = express();
 
-const app = express()
+connectDB();
 
-const formatsLogger = app.get('env') === 'development' ? 'dev' : 'short'
+app.use(express.json());
+app.use(cors());
 
-app.use(logger(formatsLogger))
-app.use(cors())
-app.use(express.json())
+app.use("/users", authRouter);
+app.use("/avatars", express.static("public/avatars"));
 
-app.use('/api/contacts', contactsRouter)
+const contactsRouter = require("./routes/api/contacts");
+app.use("/api/contacts", contactsRouter);
+
+const formatsLogger = app.get("env") === "development" ? "dev" : "short";
+app.use(logger(formatsLogger));
 
 app.use((req, res) => {
-  res.status(404).json({ message: 'Not found' })
-})
+  res.status(404).json({ message: "Not found" });
+});
 
 app.use((err, req, res, next) => {
-  res.status(500).json({ message: err.message })
-})
+  console.error("Error:", err);
+  res.status(500).json({ message: err.message, data: "Internal Server Error" });
+});
 
-module.exports = app
+module.exports = app;

config/db.js

@@ -0,0 +1,15 @@
+const mongoose = require("mongoose");
+require("dotenv").config();
+
+const connectDB = async () => {
+  try {
+    const uriDb = process.env.MONGO_URI;
+    await mongoose.connect(uriDb);
+    console.log("Database connection successful");
+  } catch (err) {
+    console.error("Database connection error:", err);
+    process.exit(1);
+  }
+};
+
+module.exports = connectDB;

controllers/authController.js

@@ -0,0 +1,172 @@
+const bcrypt = require("bcryptjs");
+const User = require("../models/user");
+const jwt = require("jsonwebtoken");
+const Joi = require("joi");
+const gravatar = require("gravatar");
+const fs = require("fs/promises");
+const path = require("path");
+const Jimp = require("jimp");
+const avatarsDir = path.join(__dirname, "../public/avatars");
+
+const registerSchema = Joi.object({
+  email: Joi.string().email().required(),
+  password: Joi.string().min(6).required(),
+});
+
+const loginSchema = Joi.object({
+  email: Joi.string().email().required(),
+  password: Joi.string().min(6).required(),
+});
+
+// REJESTRACJA
+
+const register = async (req, res, next) => {
+  try {
+    const { error } = registerSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ message: error.details[0].message });
+    }
+
+    const { email, password } = req.body;
+
+    const userExists = await User.findOne({ email });
+    if (userExists) {
+      return res.status(409).json({
+        status: "error",
+        code: 409,
+        message: "Email in use",
+        data: "Conflict",
+      });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+
+    const avatarURL = gravatar.url(email, { s: "250", d: "identicon" }, true);
+
+    const newUser = await User.create({
+      email,
+      password: hashedPassword,
+      avatarURL,
+    });
+
+    res.status(201).json({
+      user: {
+        email: newUser.email,
+        subscription: newUser.subscription,
+        avatarURL,
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+// LOGOWANIE
+
+const login = async (req, res, next) => {
+  try {
+    const { email, password } = req.body;
+
+    const { error } = loginSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ message: error.details[0].message });
+    }
+
+    const user = await User.findOne({ email });
+    if (!user) {
+      return res.status(401).json({
+        status: "error",
+        code: 401,
+        message: `User ${email} doesn't exist`,
+        data: "Bad request",
+      });
+    }
+
+    const isPasswordValid = await bcrypt.compare(password, user.password);
+    if (!isPasswordValid) {
+      return res.status(401).json({
+        status: "error",
+        code: 401,
+        message: "Email or password is wrong",
+        data: "Bad request",
+      });
+    }
+
+    const payload = { id: user._id };
+    const token = jwt.sign(payload, process.env.SECRET_KEY, {
+      expiresIn: "1h",
+    });
+
+    user.token = token;
+    await user.save();
+
+    res.status(200).json({
+      status: "success",
+      code: 200,
+      data: {
+        token,
+      },
+      user: {
+        email: user.email,
+        subscription: user.subscription,
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+// WYLOGOWANIE
+
+const logout = async (req, res, next) => {
+  try {
+    const user = req.user;
+    user.token = null;
+    await user.save();
+
+    res.status(204).send();
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getCurrentUser = async (req, res) => {
+  const { email, subscription } = req.user;
+
+  res.status(200).json({
+    email,
+    subscription,
+  });
+};
+
+const updateAvatar = async (req, res, next) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ message: "No file uploaded" });
+    }
+
+    const { path: tmpPath, filename } = req.file;
+
+    const newPath = path.join(avatarsDir, filename);
+
+    const image = await Jimp.read(tmpPath);
+
+    await image.resize(250, 250).writeAsync(tmpPath);
+
+    await fs.rename(tmpPath, newPath);
+
+    const avatarURL = `/avatars/${filename}`;
+    await User.findByIdAndUpdate(req.user._id, { avatarURL });
+
+    res.json({ avatarURL });
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  register,
+  login,
+  logout,
+  getCurrentUser,
+  updateAvatar,
+};

controllers/contactsController.js

@@ -0,0 +1,134 @@
+// const fs = require("fs").promises;
+// const { nanoid } = require("nanoid");
+// const path = require("path");
+
+// const contactsPath = path.join(__dirname, "../models/contacts.json");
+
+const Contact = require("../models/contacts");
+const Joi = require("joi");
+
+const schema = Joi.object({
+  name: Joi.string().min(3).max(30).required(),
+  email: Joi.string().email().required(),
+  phone: Joi.string()
+    .pattern(/^[0-9\-()+ ]+$/)
+    .required(),
+  favorite: Joi.boolean(),
+});
+
+const listContacts = async (req, res, next) => {
+  try {
+    const contacts = await Contact.find({ owner: req.user._id });
+
+    if (contacts.length === 0) {
+      return res
+        .status(404)
+        .json({ message: "Brak kontaktów dla tego użytkownika" });
+    }
+
+    res.status(200).json(contacts);
+  } catch (error) {
+    res.status(500).json({ message: "Internal Server Error" });
+  }
+};
+
+const getContactById = async (req, res, next) => {
+  try {
+    const contact = await Contact.findById(req.params.contactId);
+    if (!contact) {
+      return res.status(404).json({ message: "Not found" });
+    }
+    res.status(200).json(contact);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const removeContact = async (req, res, next) => {
+  try {
+    const contact = await Contact.findByIdAndDelete(req.params.contactId);
+    if (!contact) {
+      return res.status(404).json({ message: "Not found" });
+    }
+    res.status(200).json({ message: "contact deleted" });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const addContact = async (req, res, next) => {
+  try {
+    const { error } = schema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ message: "missing required fields" });
+    }
+    const { name, email, phone, favorite } = req.body;
+    const owner = req.user._id;
+
+    const existingContact = await Contact.findOne({ email, phone, owner });
+    // console.log("Existing contact:", existingContact);
+    if (existingContact) {
+      return res
+        .status(409)
+        .json({ message: "Contact with this email or phone already exists." });
+    }
+
+    const newContact = await Contact.create({
+      name,
+      email,
+      phone,
+      favorite,
+      owner,
+    });
+    // console.log("New contact added:", newContact);
+
+    res.status(201).json(newContact);
+  } catch (error) {
+    // console.error("Error adding contact:", error);
+    next(error);
+  }
+};
+
+const updateContact = async (req, res, next) => {
+  try {
+    const updatedContact = await Contact.findByIdAndUpdate(
+      { _id: req.params.contactId, owner: req.user._id },
+      { new: true }
+    );
+    if (!updatedContact) {
+      return res.status(404).json({ message: "Not found" });
+    }
+    res.status(200).json(updatedContact);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const updateStatusContact = async (req, res, next) => {
+  try {
+    const { favorite = false } = req.body;
+    if (favorite === undefined) {
+      return res.status(400).json({ message: "missing field favorite" });
+    }
+    const updatedContact = await Contact.findByIdAndUpdate(
+      { _id: req.params.contactId, owner: req.user._id },
+      { favorite },
+      { new: true }
+    );
+    if (!updatedContact) {
+      return res.status(404).json({ message: "Not found" });
+    }
+    res.json(updatedContact);
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  listContacts,
+  getContactById,
+  removeContact,
+  addContact,
+  updateContact,
+  updateStatusContact,
+};