FINAL-PROJECT-BACK/controllers/messages.js

const MessageModel = require('../model/message');
const UserModel = require('../model/user');
const ChatModel = require('../model/chat');
const Jimp = require('jimp');
const fs = require('fs').promises;
const path = require('path');
const createFolderIsExist = require('../helpers/create-directory');
require('dotenv').config();

const listMessages = async (req, res, next) => {
	try {
		const userId = req.user.id;
		const messages = await MessageModel.getList({ owner: userId }, req.query);
		return res.json({
			status: 'success',
			code: 200,
			data: messages,
		});
	} catch (e) {
		next(e);
	}
};

const removeMessage = async (req, res, next) => {
	try {
		const id = req.params.id;
		const userId = req.user.id;
		const DIR_IMAGES = process.env.DIR_IMAGES;
		const DIR_AUDIOS = process.env.DIR_AUDIOS;
		const DIR_VIDEOS = process.env.DIR_VIDEOS;
		const DIR_FILES = process.env.DIR_FILES;
		const userMessage = await MessageModel.remove(id, userId);
		const companionMessage = await MessageModel.removeByFields(
			userId,
			userMessage.idTime,
			userMessage.companionId
		);
		if (userMessage.type !== 'text') {
			switch (userMessage.type) {
				case 'image':
					await fs.unlink(path.join(DIR_IMAGES, userMessage.message));
					break;
				case 'audio':
					await fs.unlink(path.join(DIR_AUDIOS, userMessage.message));
					break;
				case 'video':
					await fs.unlink(path.join(DIR_VIDEOS, userMessage.message));
					break;
				default:
					await fs.unlink(path.join(DIR_FILES, userMessage.message));
					break;
			}
		}
		if (userMessage && companionMessage) {
			return res.json({
				status: 'success',
				code: 200,
				data: {},
			});
		} else {
			return res.status(404).json({
				status: 'error',
				code: 404,
				data: 'Not Found',
			});
		}
	} catch (e) {
		next(e);
	}
};

const listMessagesById = async (req, res, next) => {
	try {
		const userId = req.user.id;
		const companionId = req.params.companionId;
		const messages = await MessageModel.getList(
			{ owner: userId, companionId },
			{}
		);
		return res.json({
			status: 'success',
			code: 200,
			data: messages,
		});
	} catch (e) {
		next(e);
	}
};

const sentMessage = async (req, res, next) => {
	try {
		const { id, message } = req.body;
		const idTime = Math.round(Date.now() / 1000);
		const user = req.user;
		const userId = user.id;
		const companion = await UserModel.findById(id);
		const isChat = await ChatModel.getByField(id, userId);
		const isCompanionChat = await ChatModel.getByField(userId, id);
		const { name, lastName, avatarUrl, color, number } = user;

		if (companion && isChat && isCompanionChat) {
			const newMessage = await MessageModel.add({
				message,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'text',
				idTime,
				companionId: id,
				owner: userId,
			});
			await MessageModel.add({
				message,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'text',
				idTime,
				companionId: userId,
				owner: id,
			});
			const { total } = await MessageModel.getList(
				{ owner: userId, companionId: id },
				{}
			);
			await ChatModel.update(isChat._id, userId, {
				total,
				seen: total,
				watched: false,
				lastMessage: message,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			const { total: Total } = await MessageModel.getList(
				{ owner: id, companionId: userId },
				{}
			);
			await ChatModel.update(isCompanionChat._id, id, {
				total: Total,
				lastMessage: message,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			return res.status(201).json({
				status: 'success',
				code: 201,
				data: newMessage,
			});
		}
	} catch (e) {
		next(e);
	}
};

const imageMessage = async (req, res, next) => {
	try {
		const userId = req.user.id;
		const id = req.params.companionId;
		const idTime = Math.round(Date.now() / 1000);
		const isChat = await ChatModel.getByField(id, userId);
		const isCompanionChat = await ChatModel.getByField(userId, id);
		const DIR_IMAGES = process.env.DIR_IMAGES;
		const pathToFile = req.file.path;
		const originalName = req.file.originalname;
		const newNameImg = `${Math.round(Date.now() / 1000)}${originalName}`;
		const fullType = req.file.mimetype;
		await Jimp.read(pathToFile);
		await createFolderIsExist(path.join(DIR_IMAGES, userId));
		await fs.rename(pathToFile, path.join(DIR_IMAGES, userId, newNameImg));
		const imgUrl = path.normalize(path.join(userId, newNameImg));
		if (isChat && isCompanionChat && imgUrl) {
			const { name, lastName, avatarUrl, color, number } = req.user;
			const newMessage = await MessageModel.add({
				message: imgUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'image',
				fullType,
				idTime,
				companionId: id,
				owner: userId,
			});
			await MessageModel.add({
				message: imgUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'image',
				fullType,
				idTime,
				companionId: userId,
				owner: id,
			});
			const { total } = await MessageModel.getList(
				{ owner: userId, companionId: id },
				{}
			);
			await ChatModel.update(isChat._id, userId, {
				total,
				seen: total,
				watched: false,
				lastMessage: imgUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			const { total: Total } = await MessageModel.getList(
				{ owner: id, companionId: userId },
				{}
			);
			await ChatModel.update(isCompanionChat._id, id, {
				total: Total,
				lastMessage: imgUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			return res.status(201).json({
				status: 'success',
				code: 201,
				data: newMessage,
			});
		}
	} catch (e) {
		next(e);
	}
};

const audioMessage = async (req, res, next) => {
	try {
		const userId = req.user.id;
		const id = req.params.companionId;
		const idTime = Math.round(Date.now() / 1000);
		const isChat = await ChatModel.getByField(id, userId);
		const isCompanionChat = await ChatModel.getByField(userId, id);
		const DIR_AUDIOS = process.env.DIR_AUDIOS;
		const pathToFile = req.file.path;
		const originalName = req.file.originalname;
		const newNameAudio = `${Math.round(Date.now() / 1000)}${originalName}`;
		const fullType = req.file.mimetype;
		await createFolderIsExist(path.join(DIR_AUDIOS, userId));
		await fs.rename(pathToFile, path.join(DIR_AUDIOS, userId, newNameAudio));
		const audioUrl = path.normalize(path.join(userId, newNameAudio));
		if (isChat && isCompanionChat && audioUrl) {
			const { name, lastName, avatarUrl, color, number } = req.user;
			const newMessage = await MessageModel.add({
				message: audioUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'audio',
				fullType,
				idTime,
				companionId: id,
				owner: userId,
			});
			await MessageModel.add({
				message: audioUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'audio',
				fullType,
				idTime,
				companionId: userId,
				owner: id,
			});
			const { total } = await MessageModel.getList(
				{ owner: userId, companionId: id },
				{}
			);
			await ChatModel.update(isChat._id, userId, {
				total,
				seen: total,
				watched: false,
				lastMessage: audioUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			const { total: Total } = await MessageModel.getList(
				{ owner: id, companionId: userId },
				{}
			);
			await ChatModel.update(isCompanionChat._id, id, {
				total: Total,
				lastMessage: audioUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			return res.status(201).json({
				status: 'success',
				code: 201,
				data: newMessage,
			});
		}
	} catch (e) {
		next(e);
	}
};

const videoMessage = async (req, res, next) => {
	try {
		const userId = req.user.id;
		const id = req.params.companionId;
		const idTime = Math.round(Date.now() / 1000);
		const isChat = await ChatModel.getByField(id, userId);
		const isCompanionChat = await ChatModel.getByField(userId, id);
		const DIR_VIDEOS = process.env.DIR_VIDEOS;
		const pathToFile = req.file.path;
		const originalName = req.file.originalname;
		const newNameVideo = `${Math.round(Date.now() / 1000)}${originalName}`;
		const fullType = req.file.mimetype;
		await createFolderIsExist(path.join(DIR_VIDEOS, userId));
		await fs.rename(pathToFile, path.join(DIR_VIDEOS, userId, newNameVideo));
		const videoUrl = path.normalize(path.join(userId, newNameVideo));
		if (isChat && isCompanionChat && videoUrl) {
			const { name, lastName, avatarUrl, color, number } = req.user;
			const newMessage = await MessageModel.add({
				message: videoUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'video',
				fullType,
				idTime,
				companionId: id,
				owner: userId,
			});
			await MessageModel.add({
				message: videoUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type: 'video',
				fullType,
				idTime,
				companionId: userId,
				owner: id,
			});
			const { total } = await MessageModel.getList(
				{ owner: userId, companionId: id },
				{}
			);
			await ChatModel.update(isChat._id, userId, {
				total,
				seen: total,
				watched: false,
				lastMessage: videoUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			const { total: Total } = await MessageModel.getList(
				{ owner: id, companionId: userId },
				{}
			);
			await ChatModel.update(isCompanionChat._id, id, {
				total: Total,
				lastMessage: videoUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			return res.status(201).json({
				status: 'success',
				code: 201,
				data: newMessage,
			});
		}
	} catch (e) {
		next(e);
	}
};

const fileMessage = async (req, res, next) => {
	try {
		const userId = req.user.id;
		const id = req.params.companionId;
		const idTime = Math.round(Date.now() / 1000);
		const isChat = await ChatModel.getByField(id, userId);
		const isCompanionChat = await ChatModel.getByField(userId, id);
		const DIR_FILES = process.env.DIR_FILES;
		const pathToFile = req.file.path;
		const fullType = req.file.mimetype;
		let type;
		switch (fullType) {
			case 'application/pdf':
				type = 'pdf';
				break;
			case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
				type = 'docx';
				break;
			case 'application/octet-stream':
				type = 'docx';
				break;
			default:
				break;
		}
		const newNameFile = `${Math.round(Date.now() / 1000)}file.${type}`;
		await createFolderIsExist(path.join(DIR_FILES, userId));
		await fs.rename(pathToFile, path.join(DIR_FILES, userId, newNameFile));
		const fileUrl = path.normalize(path.join(userId, newNameFile));
		if (isChat && isCompanionChat && fileUrl) {
			const { name, lastName, avatarUrl, color, number } = req.user;
			const newMessage = await MessageModel.add({
				message: fileUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type,
				fullType,
				idTime,
				companionId: id,
				owner: userId,
			});
			await MessageModel.add({
				message: fileUrl,
				name,
				lastName,
				avatarUrl,
				color,
				number,
				type,
				fullType,
				idTime,
				companionId: userId,
				owner: id,
			});
			const { total } = await MessageModel.getList(
				{ owner: userId, companionId: id },
				{}
			);
			await ChatModel.update(isChat._id, userId, {
				total,
				seen: total,
				watched: false,
				lastMessage: fileUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			const { total: Total } = await MessageModel.getList(
				{ owner: id, companionId: userId },
				{}
			);
			await ChatModel.update(isCompanionChat._id, id, {
				total: Total,
				lastMessage: fileUrl,
				lastMessageCreatedAt: newMessage.createdAt,
			});
			return res.status(201).json({
				status: 'success',
				code: 201,
				data: newMessage,
			});
		}
	} catch (e) {
		next(e);
	}
};

module.exports = {
	listMessages,
	removeMessage,
	listMessagesById,
	sentMessage,
	imageMessage,
	audioMessage,
	videoMessage,
	fileMessage,
};