Migrate from moment to date-fns and some changes

backend/src/app.js

@@ -0,0 +1,78 @@
+// require("dotenv/config");
+require("express-async-errors");
+const express = require("express");
+const path = require("path");
+const Youch = require("youch");
+const cors = require("cors");
+const sequelize = require("./database/");
+const multer = require("multer");
+
+const wBot = require("./controllers/wbot");
+const wbotMessageListener = require("./controllers/wbotMessageListener");
+const wbotMonitor = require("./controllers/wbotMonitor");
+
+const messageRoutes = require("./routes/message");
+const ContactRoutes = require("./routes/contacts");
+const AuthRoutes = require("./routes/auth");
+const WhatsRoutes = require("./routes/whatsapp");
+
+const app = express();
+
+const fileStorage = multer.diskStorage({
+	destination: (req, file, cb) => {
+		cb(null, "public");
+	},
+	filename: (req, file, cb) => {
+		cb(null, new Date().getTime() + "-" + file.originalname.replace(/\s/g, ""));
+	},
+});
+
+app.use(cors());
+app.use(express.json());
+app.use(multer({ storage: fileStorage }).single("media"));
+app.use("/public", express.static(path.join(__dirname, "public")));
+
+app.use(messageRoutes);
+app.use(ContactRoutes);
+app.use(WhatsRoutes);
+app.use("/auth", AuthRoutes);
+
+app.use(async (err, req, res, next) => {
+	if (process.env.NODE_ENV === "development") {
+		const errors = await new Youch(err, req).toJSON();
+		return res.status(500).json(errors);
+	}
+
+	return res.status(500).json({ error: "Internal server error" });
+});
+
+sequelize
+	.sync()
+	.then(() => {
+		const server = app.listen(process.env.PORT);
+		const io = require("./libs/socket").init(server);
+		io.on("connection", socket => {
+			console.log("Client Connected");
+			socket.on("joinChatBox", contactId => {
+				socket.join(contactId);
+			});
+
+			socket.on("joinNotification", () => {
+				console.log("chat entrou no canal de notificações");
+				socket.join("notification");
+			});
+
+			socket.on("disconnect", () => {
+				console.log("Client disconnected");
+			});
+		});
+
+		wBot.init().then(() => {
+			wbotMessageListener();
+			wbotMonitor();
+		});
+		console.log("Server started on", process.env.PORT);
+	})
+	.catch(err => {
+		console.log(err);
+	});

backend/src/config/dbConfig.js

@@ -0,0 +1,15 @@
+require("dotenv/config");
+
+module.exports = {
+	define: {
+		charset: "utf8mb4",
+		collate: "utf8mb4_bin",
+	},
+	dialect: "mysql",
+	timezone: "-03:00",
+	host: process.env.DB_HOST,
+	database: process.env.DB_NAME,
+	username: process.env.DB_USER,
+	password: process.env.DB_PASS,
+	logging: false,
+};

backend/src/controllers/auth.js

@@ -0,0 +1,46 @@
+const { validationResult } = require("express-validator");
+const bcrypt = require("bcryptjs");
+const jwt = require("jsonwebtoken");
+
+const User = require("../models/User");
+
+exports.signup = async (req, res, next) => {
+	const errors = validationResult(req);
+
+	if (!errors.isEmpty()) {
+		return res.status(400).json({ error: "Validation failed" });
+	}
+
+	const { name, password, email } = req.body;
+
+	const hashedPw = await bcrypt.hash(password, 12);
+	const user = User.build({
+		email: email,
+		password: hashedPw,
+		name: name,
+	});
+	const result = await user.save();
+	res.status(201).json({ message: "User created!", userId: result.id });
+};
+
+exports.login = async (req, res, next) => {
+	const { email, password } = req.body;
+
+	const user = await User.findOne({ where: { email: email } });
+	if (!user) {
+		return res.status(400).json({ error: "No user found with this email" });
+	}
+
+	const isEqual = await bcrypt.compare(password, user.password);
+	if (!isEqual) {
+		return res.status(401).json({ error: "Password does not match" });
+	}
+
+	const token = jwt.sign({ email: user.email, userId: user.id }, "mysecret", {
+		expiresIn: "24h",
+	});
+
+	return res
+		.status(200)
+		.json({ token: token, username: user.name, userId: user.id });
+};

backend/src/controllers/contact.js

@@ -0,0 +1,67 @@
+const Contact = require("../models/Contact");
+const Message = require("../models/Message");
+const Sequelize = require("sequelize");
+const { getIO } = require("../libs/socket");
+const { getWbot } = require("./wbot");
+
+exports.getContacts = async (req, res) => {
+	const { searchParam = "" } = req.query;
+
+	const lowerSerachParam = searchParam.toLowerCase();
+
+	const whereCondition = {
+		name: Sequelize.where(
+			Sequelize.fn("LOWER", Sequelize.col("name")),
+			"LIKE",
+			"%" + lowerSerachParam + "%"
+		),
+	};
+
+	//todo >> add contact number to search where condition
+
+	const contacts = await Contact.findAll({
+		where: whereCondition,
+		attributes: {
+			include: [
+				[
+					Sequelize.literal(`(
+			        SELECT COUNT(*)
+			        FROM messages AS message
+			        WHERE
+			            message.contactId = contact.id
+			            AND
+			            message.read = 0
+
+			    )`),
+					"unreadMessages",
+				],
+			],
+		},
+		order: [["updatedAt", "DESC"]],
+	});
+
+	return res.json(contacts);
+};
+
+exports.createContact = async (req, res) => {
+	const wbot = getWbot();
+	const io = getIO();
+	const { number, name } = req.body;
+
+	const result = await wbot.isRegisteredUser(`55${number}@c.us`);
+
+	if (!result) {
+		return res
+			.status(400)
+			.json({ error: "The suplied number is not a valid Whatsapp number" });
+	}
+	const profilePicUrl = await wbot.getProfilePicUrl(`55${number}@c.us`);
+
+	const contact = await Contact.create({
+		name,
+		number: `55${number}`,
+		profilePicUrl,
+	});
+
+	res.status(200).json(contact);
+};

backend/src/controllers/message.js

@@ -0,0 +1,126 @@
+const fs = require("fs");
+const Message = require("../models/Message");
+const Contact = require("../models/Contact");
+const { getIO } = require("../libs/socket");
+const { getWbot } = require("./wbot");
+const Sequelize = require("sequelize");
+
+const { MessageMedia } = require("whatsapp-web.js");
+
+const setMessagesAsRead = async contactId => {
+	const io = getIO();
+	await Message.update(
+		{ read: true },
+		{
+			where: {
+				contactId: contactId,
+				read: false,
+			},
+		}
+	);
+
+	io.to("notification").emit("contact", {
+		action: "updateUnread",
+		contactId: contactId,
+	});
+};
+
+exports.getContactMessages = async (req, res, next) => {
+	const wbot = getWbot();
+	const io = getIO();
+
+	const { contactId } = req.params;
+	const { searchParam = "", pageNumber = 1 } = req.query;
+
+	const lowerSerachParam = searchParam.toLowerCase();
+
+	const whereCondition = {
+		messageBody: Sequelize.where(
+			Sequelize.fn("LOWER", Sequelize.col("messageBody")),
+			"LIKE",
+			"%" + lowerSerachParam + "%"
+		),
+	};
+
+	let limit = 20;
+	let offset = limit * (pageNumber - 1);
+
+	const contact = await Contact.findByPk(contactId);
+	if (!contact) {
+		return res.status(400).json({ error: "No contact found with this ID" });
+	}
+
+	await setMessagesAsRead(contactId);
+
+	const contactMessages = await contact.getMessages({
+		where: whereCondition,
+		limit,
+		offset,
+		order: [["createdAt", "DESC"]],
+	});
+
+	const serializedMessages = contactMessages.map(message => {
+		return {
+			...message.dataValues,
+			mediaUrl: `${
+				message.mediaUrl
+					? `http://${process.env.HOST}:${process.env.PORT}/public/${message.mediaUrl}`
+					: ""
+			}`,
+		};
+	});
+
+	return res.json({
+		messages: serializedMessages.reverse(),
+		contact: contact,
+	});
+};
+
+exports.postCreateContactMessage = async (req, res, next) => {
+	const wbot = getWbot();
+	const io = getIO();
+
+	const { contactId } = req.params;
+	const message = req.body;
+	const media = req.file;
+	let sentMessage;
+
+	const contact = await Contact.findByPk(contactId);
+	if (media) {
+		const newMedia = MessageMedia.fromFilePath(req.file.path);
+		message.mediaUrl = req.file.filename.replace(/\s/g, "");
+		if (newMedia.mimetype) {
+			message.mediaType = newMedia.mimetype.split("/")[0];
+		} else {
+			message.mediaType = "other";
+		}
+
+		sentMessage = await wbot.sendMessage(`${contact.number}@c.us`, newMedia);
+	} else {
+		sentMessage = await wbot.sendMessage(
+			`${contact.number}@c.us`,
+			message.messageBody
+		);
+	}
+
+	message.id = sentMessage.id.id;
+
+	const newMessage = await contact.createMessage(message);
+
+	const serialziedMessage = {
+		...newMessage.dataValues,
+		mediaUrl: `${
+			message.mediaUrl
+				? `http://${process.env.HOST}:${process.env.PORT}/public/${message.mediaUrl}`
+				: ""
+		}`,
+	};
+
+	io.to(contactId).emit("appMessage", {
+		action: "create",
+		message: serialziedMessage,
+	});
+	await setMessagesAsRead(contactId);
+
+	return res.json({ message: "Mensagem enviada" });
+};

backend/src/controllers/wbot.js

@@ -0,0 +1,74 @@
+const qrCode = require("qrcode-terminal");
+const { Client } = require("whatsapp-web.js");
+const Whatsapp = require("../models/Whatsapp");
+const { getIO } = require("../libs/socket");
+
+let wbot;
+
+module.exports = {
+	init: async () => {
+		let sessionCfg;
+
+		const dbSession = await Whatsapp.findOne({ where: { id: 1 } });
+		if (dbSession && dbSession.session) {
+			sessionCfg = JSON.parse(dbSession.session);
+		}
+
+		wbot = new Client({
+			session: sessionCfg,
+			restartOnAuthFail: true,
+		});
+		wbot.initialize();
+		wbot.on("qr", async qr => {
+			qrCode.generate(qr, { small: true });
+			await Whatsapp.upsert({ id: 1, qrcode: qr, status: "pending" });
+			getIO().emit("qrcode", {
+				action: "update",
+				qr: qr,
+			});
+		});
+		wbot.on("authenticated", async session => {
+			console.log("AUTHENTICATED");
+			await Whatsapp.upsert({
+				id: 1,
+				session: JSON.stringify(session),
+				status: "authenticated",
+			});
+			getIO().emit("whats_auth", {
+				action: "authentication",
+				session: dbSession,
+			});
+		});
+		wbot.on("auth_failure", async msg => {
+			console.error("AUTHENTICATION FAILURE", msg);
+			await Whatsapp.update({ session: "" }, { where: { id: 1 } });
+		});
+		wbot.on("ready", async () => {
+			console.log("READY");
+			await Whatsapp.update(
+				{ status: "online", qrcode: "" },
+				{ where: { id: 1 } }
+			);
+			// const chats = await wbot.getChats(); // pega as mensagens nao lidas (recebidas quando o bot estava offline)
+			// let unreadMessages;                  // todo > salvar isso no DB pra mostrar no frontend
+			// for (let chat of chats) {
+			// 	if (chat.unreadCount > 0) {
+			// 		unreadMessages = await chat.fetchMessages({
+			// 			limit: chat.unreadCount,
+			// 		});
+			// 	}
+			// }
+
+			// console.log(unreadMessages);
+			wbot.sendPresenceAvailable();
+		});
+		return wbot;
+	},
+
+	getWbot: () => {
+		if (!wbot) {
+			throw new Error("Wbot not initialized");
+		}
+		return wbot;
+	},
+};

backend/src/controllers/wbotMessageListener.js

@@ -0,0 +1,138 @@
+const Contact = require("../models/Contact");
+const Message = require("../models/Message");
+
+const path = require("path");
+const fs = require("fs");
+
+const { getIO } = require("../libs/socket");
+const { getWbot, init } = require("./wbot");
+
+const wbotMessageListener = () => {
+	const io = getIO();
+	const wbot = getWbot();
+
+	wbot.on("message", async msg => {
+		console.log(msg);
+		let newMessage;
+		// console.log(msg);
+		if (msg.from === "status@broadcast") {
+			return;
+		}
+		try {
+			const msgContact = await msg.getContact();
+			const profilePicUrl = await msgContact.getProfilePicUrl();
+			try {
+				let contact = await Contact.findOne({
+					where: { number: msgContact.number },
+				});
+
+				if (contact) {
+					await contact.update({ profilePicUrl: profilePicUrl });
+				}
+
+				if (!contact) {
+					try {
+						contact = await Contact.create({
+							name: msgContact.pushname || msgContact.number.toString(),
+							number: msgContact.number,
+							profilePicUrl: profilePicUrl,
+						});
+					} catch (err) {
+						console.log(err);
+					}
+				}
+
+				if (msg.hasQuotedMsg) {
+					const quotedMessage = await msg.getQuotedMessage();
+					console.log("quoted", quotedMessage);
+				}
+
+				if (msg.hasMedia) {
+					const media = await msg.downloadMedia();
+
+					if (media) {
+						if (!media.filename) {
+							let ext = media.mimetype.split("/")[1].split(";")[0];
+							media.filename = `${new Date().getTime()}.${ext}`;
+						}
+
+						fs.writeFile(
+							path.join(__dirname, "..", "public", media.filename),
+							media.data,
+							"base64",
+							err => {
+								console.log(err);
+							}
+						);
+
+						newMessage = await contact.createMessage({
+							id: msg.id.id,
+							messageBody: msg.body || media.filename,
+							mediaUrl: media.filename,
+							mediaType: media.mimetype.split("/")[0],
+						});
+						await contact.update({ lastMessage: msg.body || media.filename });
+					}
+				} else {
+					newMessage = await contact.createMessage({
+						id: msg.id.id,
+						messageBody: msg.body,
+					});
+					await contact.update({ lastMessage: msg.body });
+				}
+
+				io.to(contact.id)
+					.to("notification")
+					.emit("appMessage", {
+						action: "create",
+						message: {
+							...newMessage.dataValues,
+							mediaUrl: `${
+								newMessage.mediaUrl
+									? `http://${process.env.HOST}:${process.env.PORT}/public/${newMessage.mediaUrl}`
+									: ""
+							}`,
+						},
+						contact: {
+							...contact.dataValues,
+							unreadMessages: 1,
+							lastMessage: newMessage.messageBody,
+						},
+					});
+
+				let chat = await msg.getChat();
+				chat.sendSeen();
+			} catch (err) {
+				console.log(err);
+			}
+		} catch (err) {
+			console.log(err);
+		}
+	});
+
+	wbot.on("message_ack", async (msg, ack) => {
+		try {
+			const messageToUpdate = await Message.findOne({
+				where: { id: msg.id.id },
+			});
+			if (!messageToUpdate) {
+				// will throw an error is msg wasn't sent from app
+				const error = new Error(
+					"Erro ao alterar o ack da mensagem no banco de dados"
+				);
+				error.statusCode = 501;
+				throw error;
+			}
+			await messageToUpdate.update({ ack: ack });
+
+			io.to(messageToUpdate.contactId).emit("appMessage", {
+				action: "update",
+				message: messageToUpdate,
+			});
+		} catch (err) {
+			console.log(err);
+		}
+	});
+};
+
+module.exports = wbotMessageListener;

backend/src/controllers/wbotMonitor.js

@@ -0,0 +1,50 @@
+const Whatsapp = require("../models/Whatsapp");
+const wbotMessageListener = require("./wbotMessageListener");
+
+const { getIO } = require("../libs/socket");
+const { getWbot, init } = require("./wbot");
+
+const wbotMonitor = () => {
+	const io = getIO();
+	const wbot = getWbot();
+
+	try {
+		wbot.on("change_state", newState => {
+			console.log("monitor", newState);
+		});
+
+		wbot.on("change_battery", async batteryInfo => {
+			// Battery percentage for attached device has changed
+			const { battery, plugged } = batteryInfo;
+			try {
+				await Whatsapp.update({ battery, plugged }, { where: { id: 1 } });
+			} catch (err) {
+				console.log(err);
+			}
+
+			console.log(`Battery: ${battery}% - Charging? ${plugged}`); //todo> save batery state to db
+		});
+
+		wbot.on("disconnected", reason => {
+			console.log("disconnected", reason); //todo> save connection status to DB
+			setTimeout(
+				() =>
+					init()
+						.then(res => {
+							wbotMessageListener();
+							wbotMonitor();
+						})
+						.catch(err => console.log(err)),
+				2000
+			);
+		});
+
+		// setInterval(() => {
+		// 	wbot.resetState();
+		// }, 20000);
+	} catch (err) {
+		console.log(err);
+	}
+};
+
+module.exports = wbotMonitor;

backend/src/controllers/whatsapp.js

@@ -0,0 +1,22 @@
+const Whatsapp = require("../models/Whatsapp");
+const { getIO } = require("../libs/socket");
+const { getWbot, init } = require("./wbot");
+
+exports.getSession = async (req, res, next) => {
+	const dbSession = await Whatsapp.findOne({ where: { id: 1 } });
+
+	if (!dbSession) {
+		return res.status(200).json({ message: "Session not found" });
+	}
+
+	return res.status(200).json(dbSession);
+};
+
+exports.getContacts = async (req, res, next) => {
+	const io = getIO();
+	const wbot = getWbot();
+
+	const phoneContacts = await wbot.getContacts();
+
+	return res.status(200).json(phoneContacts);
+};

backend/src/database/index.js

@@ -0,0 +1,6 @@
+const Sequelize = require("sequelize");
+const dbConfig = require("../config/dbConfig");
+
+const sequelize = new Sequelize(dbConfig);
+
+module.exports = sequelize;

backend/src/libs/socket.js

@@ -0,0 +1,14 @@
+let io;
+
+module.exports = {
+	init: httpServer => {
+		io = require("socket.io")(httpServer);
+		return io;
+	},
+	getIO: () => {
+		if (!io) {
+			throw new Error("Socket IO not initialized");
+		}
+		return io;
+	},
+};

backend/src/middleware/is-auth.js

@@ -0,0 +1,23 @@
+const jwt = require("jsonwebtoken");
+
+module.exports = (req, res, next) => {
+	let decodedToken;
+	try {
+		const [, token] = req.get("Authorization").split(" ");
+		decodedToken = jwt.verify(token, "mysecret");
+		// todo >> find user in DB and store in req.user to use latter, or throw an error if user not exists anymore
+		req.userId = decodedToken.userId;
+	} catch (err) {
+		err.statusCode = 401;
+		err.message = "invalidToken";
+		next(err);
+	}
+
+	if (!decodedToken) {
+		const error = new Error("Falha na autenticação");
+		error.statusCode = 401;
+		next(error);
+	}
+
+	next();
+};

backend/src/models/Contact.js

@@ -0,0 +1,19 @@
+const Sequelize = require("sequelize");
+
+const sequelize = require("../database");
+
+const Message = require("./Message");
+
+const Contact = sequelize.define("contact", {
+	name: { type: Sequelize.STRING(100), allowNull: false },
+	number: { type: Sequelize.STRING(15), allowNull: false },
+	profilePicUrl: { type: Sequelize.STRING(200) },
+	lastMessage: { type: Sequelize.TEXT },
+});
+
+Contact.hasMany(Message, {
+	onDelete: "CASCADE",
+	onUpdate: "RESTRICT",
+});
+
+module.exports = Contact;

backend/src/models/Message.js

@@ -0,0 +1,22 @@
+const Sequelize = require("sequelize");
+const sequelize = require("../database");
+
+const Message = sequelize.define("message", {
+	id: {
+		type: Sequelize.STRING(50),
+		allowNull: false,
+		primaryKey: true,
+	},
+	createdAt: {
+		allowNull: false,
+		type: Sequelize.DATE(6),
+	},
+	userId: { type: Sequelize.INTEGER, defaultValue: 0 },
+	ack: { type: Sequelize.INTEGER, defaultValue: 0 },
+	messageBody: { type: Sequelize.TEXT, allowNull: false },
+	read: { type: Sequelize.BOOLEAN, defaultValue: false },
+	mediaUrl: { type: Sequelize.STRING(250) },
+	mediaType: { type: Sequelize.STRING(250) },
+});
+
+module.exports = Message;

backend/src/models/User.js

@@ -0,0 +1,17 @@
+const Sequelize = require("sequelize");
+
+const sequelize = require("../database");
+
+const User = sequelize.define("user", {
+	id: {
+		type: Sequelize.INTEGER,
+		allowNull: false,
+		primaryKey: true,
+		autoIncrement: true,
+	},
+	name: { type: Sequelize.STRING(100), allowNull: false },
+	password: { type: Sequelize.STRING(100), allowNull: false },
+	email: { type: Sequelize.STRING(100), allowNull: false },
+});
+
+module.exports = User;

backend/src/models/Whatsapp.js

@@ -0,0 +1,13 @@
+const Sequelize = require("sequelize");
+
+const sequelize = require("../database");
+
+const Whatsapp = sequelize.define("whatsapp", {
+	session: { type: Sequelize.TEXT() },
+	qrcode: { type: Sequelize.TEXT() },
+	status: { type: Sequelize.STRING(60) },
+	battery: { type: Sequelize.STRING(20) },
+	plugged: { type: Sequelize.BOOLEAN() },
+});
+
+module.exports = Whatsapp;

backend/src/routes/auth.js

@@ -0,0 +1,35 @@
+const express = require("express");
+const { body } = require("express-validator");
+const User = require("../models/User");
+const authController = require("../controllers/auth");
+const isAuth = require("../middleware/is-auth");
+
+const routes = express.Router();
+
+routes.post(
+	"/signup",
+	[
+		body("email")
+			.isEmail()
+			.withMessage("Email inválido")
+			.custom((value, { req }) => {
+				return User.findOne({ where: { email: value } }).then(user => {
+					if (user) {
+						return Promise.reject("An user with this email already exists!");
+					}
+				});
+			})
+			.normalizeEmail(),
+		body("password").trim().isLength({ min: 5 }),
+		body("name").trim().not().isEmpty(),
+	],
+	authController.signup
+);
+
+routes.post("/login", authController.login);
+
+routes.get("/check", isAuth, (req, res) => {
+	res.status(200).json({ authenticated: true });
+});
+
+module.exports = routes;

backend/src/routes/contacts.js

@@ -0,0 +1,13 @@
+const express = require("express");
+const isAuth = require("../middleware/is-auth");
+
+const ContactController = require("../controllers/contact");
+
+const routes = express.Router();
+
+routes.get("/contacts", isAuth, ContactController.getContacts);
+// routes.post(ContactController.postCreateContact);
+
+routes.post("/contacts", isAuth, ContactController.createContact);
+
+module.exports = routes;

backend/src/routes/message.js

@@ -0,0 +1,19 @@
+const express = require("express");
+const isAuth = require("../middleware/is-auth");
+
+const MessangeController = require("../controllers/message");
+
+const routes = express.Router();
+
+routes.get(
+	"/messages/:contactId",
+	isAuth,
+	MessangeController.getContactMessages
+);
+routes.post(
+	"/messages/:contactId",
+	isAuth,
+	MessangeController.postCreateContactMessage
+);
+
+module.exports = routes;

backend/src/routes/whatsapp.js

@@ -0,0 +1,22 @@
+const express = require("express");
+const isAuth = require("../middleware/is-auth");
+
+const WhatsappController = require("../controllers/whatsapp");
+
+const routes = express.Router();
+
+routes.get("/whatsapp/session", isAuth, WhatsappController.getSession);
+// routes.post(
+// 	"/messages/:contactId",
+// 	isAuth,
+// 	WhatsappController.postCreateContactMessage
+// );
+
+routes.get("/whatsapp/contacts", isAuth, WhatsappController.getContacts);
+// routes.post(
+// 	"/messages/:contactId",
+// 	isAuth,
+// 	WhatsappController.postCreateContactMessage
+// );
+
+module.exports = routes;