Hw05 avatars

app.js

@@ -1,25 +1,54 @@
-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 mongoose = require('mongoose');
+const path = require('path');
+// const dotenv = require('dotenv');
+// dotenv.config();
 
-const contactsRouter = require('./routes/api/contacts')
+require('dotenv').config();
+// console.log(process.env.JWT_SECRET);
 
-const app = express()
+const contactsRouter = require('./routes/api/contacts');
+const usersRouter = require('./routes/api/users');
+const app = express();
 
-const formatsLogger = app.get('env') === 'development' ? 'dev' : 'short'
+const formatsLogger = app.get('env') === 'development' ? 'dev' : 'short';
+app.use(logger(formatsLogger));
+app.use(cors());
+app.use(express.json());
 
-app.use(logger(formatsLogger))
-app.use(cors())
-app.use(express.json())
+app.use('/avatars', express.static(path.join(__dirname, 'public/avatars')));
 
-app.use('/api/contacts', contactsRouter)
+app.use('/api/contacts', contactsRouter);
+app.use('/api/users', usersRouter);
 
 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 })
-})
-
-module.exports = app
+  res.status(500).json({ message: err.message });
+});
+
+const startServer = async () => {
+  try {
+    await mongoose.connect(process.env.MONGO_URI, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log('Database connection successful');
+
+    const PORT = process.env.PORT || 5000;
+    app.listen(PORT, () => {
+      console.log(`Server running. Use our API on port: ${PORT}`);
+    });
+  } catch (error) {
+    console.error(`Database connection error: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+startServer();
+
+module.exports = app;

controllers/contactsController.js

@@ -0,0 +1,118 @@
+const Joi = require('joi');
+const Contact = require('../models/contacts');
+
+const contactSchema = Joi.object({
+  name: Joi.string().min(3).required(),
+  email: Joi.string().email().required(),
+  phone: Joi.string().pattern(/^\d{3}-\d{3}-\d{4}$/).required(),
+});
+
+exports.listContacts = async (req, res) => {
+  try {
+    const allContacts = await Contact.find();
+    res.status(200).json(allContacts);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getById = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const contact = await Contact.findById(id);
+    if (contact) {
+      res.status(200).json(contact);
+    } else {
+      res.status(404).json({ message: "Not found" });
+    }
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.addContact = async (req, res) => {
+  try {
+    const { error } = contactSchema.validate(req.body, { abortEarly: false });
+    if (error) {
+      return res.status(400).json({ message: error.details.map(e => e.message).join(', ') });
+    }
+    const { name, email, phone } = req.body;
+    const newContact = await Contact.create({ name, email, phone });
+    res.status(201).json(newContact);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.removeContact = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const removed = await Contact.findByIdAndRemove(id);
+    if (removed) {
+      res.status(200).json({ message: "contact deleted" });
+    } else {
+      res.status(404).json({ message: "Not found" });
+    }
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.updateContact = async (req, res) => {
+  try {
+    if (Object.keys(req.body).length === 0) {
+      return res.status(400).json({ message: "missing fields" });
+    }
+    const { error } = contactSchema.validate(req.body, { abortEarly: false });
+    if (error) {
+      return res.status(400).json({ message: error.details.map(e => e.message).join(', ') });
+    }
+    const { id } = req.params;
+    const { name, email, phone } = req.body;
+    const updatedContact = await Contact.findByIdAndUpdate(id, { name, email, phone }, { new: true });
+    if (updatedContact) {
+      res.status(200).json(updatedContact);
+    } else {
+      res.status(404).json({ message: "Not found" });
+    }
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.updateStatusContact = async (contactId, body) => {
+  if (typeof body.favorite !== 'boolean') {
+    throw new Error("Field 'favorite' must be a boolean");
+  }
+
+  const updatedContact = await Contact.findByIdAndUpdate(
+    contactId,
+    { favorite: body.favorite },
+    { new: true }
+  );
+
+  if (!updatedContact) {
+    throw new Error("Not found");
+  }
+
+  return updatedContact;
+};
+
+exports.updateFavoriteStatus = async (req, res) => {
+  const { contactId } = req.params;
+  const { favorite } = req.body;
+
+  if (favorite === undefined) {
+    return res.status(400).json({ message: "missing field favorite" });
+  }
+
+  try {
+    const updatedContact = await exports.updateStatusContact(contactId, req.body);
+    res.status(200).json(updatedContact);
+  } catch (err) {
+    if (err.message === "Not found") {
+      return res.status(404).json({ message: "Not found" });
+    }
+    res.status(500).json({ message: err.message });
+  }
+};

controllers/usersController.js

@@ -0,0 +1,159 @@
+const Joi = require('joi');
+const User = require('../models/user');
+const bcrypt = require('bcryptjs');
+const gravatar = require('gravatar');
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs/promises');
+const sharp = require('sharp');
+
+const userSchema = Joi.object({
+  email: Joi.string().email().required(),
+  password: Joi.string().min(6).required(),
+});
+
+const tmpDir = path.join(__dirname, '../tmp');
+const avatarsDir = path.join(__dirname, '../public/avatars');
+
+const storage = multer.diskStorage({
+  destination: tmpDir,
+  filename: (req, file, cb) => {
+    const uniqueName = `${Date.now()}-${file.originalname}`;
+    cb(null, uniqueName);
+  },
+});
+
+const upload = multer({ storage });
+
+async function deleteFileWithDelay(filePath) {
+  try {
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    await fs.unlink(filePath);
+    console.log('File deleted successfully');
+  } catch (error) {
+    console.error('Error deleting file:', error);
+  }
+}
+
+exports.uploadMiddleware = upload.single('avatar');
+
+exports.updateAvatar = async (req, res) => {
+  console.log("User in request:", req.user);
+
+  if (!req.user) {
+    return res.status(401).json({ message: "Not authorized" });
+  }
+
+  console.log("File received:", req.file);
+  if (!req.file) {
+    return res.status(400).json({ message: "No file uploaded" });
+  }
+
+  const { path: tempPath, originalname } = req.file;
+  const { id } = req.user;
+  console.log("User ID:", id);
+
+  try {
+    const avatarName = `${id}-${originalname}`;
+    const avatarPath = path.join(avatarsDir, avatarName);
+
+    console.log("Processing image...");
+
+    await sharp(tempPath)
+      .resize(250, 250)
+      .toFile(avatarPath);
+
+    await deleteFileWithDelay(tempPath);
+
+    const avatarURL = `/avatars/${avatarName}`;
+    console.log("Avatar updated:", avatarURL);
+
+    const updatedUser = await User.findByIdAndUpdate(id, { avatarURL }, { new: true });
+
+    res.json({
+      avatarURL,
+      user: {
+        email: updatedUser.email,
+        subscription: updatedUser.subscription,
+        avatarURL: updatedUser.avatarURL,
+      }
+    });
+  } catch (error) {
+    console.error("Error updating avatar:", error);
+    await deleteFileWithDelay(tempPath).catch(() => {});
+    res.status(500).json({ message: `Failed to process the avatar: ${error.message}` });
+  }
+};
+
+exports.signup = async (req, res) => {
+  try {
+    const { error } = userSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ message: error.details[0].message });
+    }
+
+    const { email, password } = req.body;
+
+    const existingUser = await User.findOne({ email });
+    if (existingUser) {
+      return res.status(409).json({ message: 'Email in use' });
+    }
+
+    const avatarURL = gravatar.url(email, { s: '250', d: 'retro' }, true);
+    const user = new User({ email, password, avatarURL });
+    const token = user.generateAuthToken();
+
+    user.token = token;
+    await user.save();
+
+    res.status(201).json({
+      user: { email: user.email, subscription: user.subscription, avatarURL: user.avatarURL },
+      token,
+    });
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};
+
+exports.login = async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    const { error } = userSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ message: error.details[0].message });
+    }
+
+    const user = await User.findOne({ email });
+    if (!user || !(await bcrypt.compare(password, user.password))) {
+      return res.status(401).json({ message: 'Email or password is wrong' });
+    }
+
+    const token = user.generateAuthToken();
+
+    user.token = token;
+    await user.save();
+
+    res.status(200).json({
+      token,
+      user: { email: user.email, subscription: user.subscription, avatarURL: user.avatarURL },
+    });
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};
+
+exports.getCurrent = async (req, res) => {
+  try {
+    const user = req.user;
+    res.status(200).json({
+      email: user.email,
+      subscription: user.subscription,
+      avatarURL: user.avatarURL,
+    });
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};
+
+exports.uploadMiddleware = upload.single('avatar');

db.js

@@ -0,0 +1,16 @@
+const mongoose = require('mongoose');
+
+const connectDB = async () => {
+  try {
+    await mongoose.connect(process.env.MONGO_URI, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log('Database connection successful');
+  } catch (error) {
+    console.error(`Database connection error: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = connectDB;