julien/adastra_api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mise à jour et ajout de controllers, routes, services et utilities

Browse Source
This commit is contained in:
Julien Gautier
2025-11-30 17:54:01 +01:00
parent bcf107cd1f
commit 9355431730
36 changed files with 978 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/controllers/article.controller.js
+210 -240
View File
@@ -1,99 +1,205 @@
const { ArticleService } = require('../services');
//const { where } = require("sequelize");
const { ArticleService, TagService, UserService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
/*const Article = require("../database/models/mysql/Article");
const Tag = require("../database/models/mysql/Tag");
const User = require("../database/models/mysql/User");*/
const ErrorResponse = require("../utils/errorResponse");
const slug = require("slug");
const DB = require('../database/mysql');
const { Article, Tag, User } = DB;
/*const {
appendFollowers,
appendFavorites,
appendTagList,
} = require("../utils/helpers");*/
const includeOptions = [
{
model: Tag,
as: "articleTags",
attributes: ["name"],
through: { attributes: [] },
},
{ model: User, as: "author", attributes: { exclude: ["email", "password"] } },
];
const includeOptions = ArticleService.getArticleIncludeAssoc();
module.exports.createArticle = asyncHandler(async (req, res, next) => {
try {
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
fieldValidation(req.body.article.title, next);
fieldValidation(req.body.article.description, next);
fieldValidation(req.body.article.body, next);
const { title, description, body, tagList } = req.body.article;
const articleSlug = ArticleService.slugify(title);
const slugInDB = await ArticleService.isSlugUsed(articleSlug);
if (slugInDB) {
return next(new ErrorResponse("Slug already exists", 400));
}
const article = await ArticleService.createArticle({
slug: articleSlug,
title: title,
description: description,
body: body,
});
for (const tag of tagList) {
const tagInDB = await TagService.getTagByPk(tag.trim());
if (tagInDB) {
await article.addArticleTag(tagInDB);
} else if (tag.length > 2) {
const newTag = await TagService.createTag(tag.trim());
await article.addArticleTag(newTag);
}
}
delete loggedUser.dataValues.token;
article.dataValues.tagList = tagList;
article.setAuthor(loggedUser);
article.dataValues.author = loggedUser;
await ArticleService.appendFollowers(loggedUser, loggedUser);
await ArticleService.appendFavorites(loggedUser, article);
res.status(201).json({
message: 'Article created successfully.',
data: article.toJSONFor(),
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while creating article.', 500, err.message));
}
});
module.exports.deleteArticle = asyncHandler(async (req, res, next) => {
try {
const { slug } = req.params;
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
const article = await ArticleService.getArticleBySlug(slug);
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
if (article.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401, "You are not allowed to access this resource."));
}
let data = await ArticleService.deleteArticle(article);
res.status(200).json({
message: 'Article deleted successfully.',
data: data.slug
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while deleting article.', 500, err.message));
}
});
module.exports.getArticle = asyncHandler(async (req, res, next) => {
const { slug } = req.params;
try {
const { slug } = req.params;
let article = await ArticleService.getArticleBySlug(slug);
let article = await ArticleService.getArticleBySlugWithTagList(slug);
if (!article) {
return next(new ErrorResponse("Article not found", 404));
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
const loggedUser = await UserService.getLoggedUserById(req.payload?.id || null);
//await ArticleService.appendTagList(article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
res.status(200).json({ article: article.toJSONFor() });
} catch (err) {
return next(new ErrorResponse('Something went wrong while fetching article.', 500, err.message));
}
let tagList = article.articleTags;
//let author = article.author;
article = article.toJSONFor();
article.tagList = tagList;
//article.author = author
res.status(200).json({ article: article });
});
module.exports.getArticles = asyncHandler(async (req, res, next) => {
try {
const { tag, author, favorited, limit = 20, offset = 0 } = req.query;
//const { loggedUser } = req;
const loggedUser = await User.findOne({
attributes: { exclude: ["password", "email", "hash", "salt"] },
where: { id: req.payload.id },
});
const searchOptions = {
include: [
{
model: Tag,
as: "articleTags",
attributes: ["name"],
through: { attributes: [] }, // ? this will remove the rows from the join table
// where: tag ? { name: tag } : {},
...(tag && { where: { name: tag } }),
},
{
model: User,
as: "author",
attributes: { exclude: ["password", "email", "hash", "salt"] },
// where: author ? { username: author } : {},
...(author && { where: { username: author } }),
},
],
limit: parseInt(limit),
offset: parseInt(offset),
order: [["createdAt", "DESC"]],
distinct: true,
};
let articles = { rows: [], count: 0 };
const { tag, author, favorited, limit = 20, offset = 0 } = req.query;
const loggedUser = await UserService.getLoggedUserById(req.payload?.id || null);
const searchOptions = await ArticleService.getSearchOptionsArticles(tag, author, limit, offset);
if (favorited) {
const user = await User.findOne({ where: { username: favorited } });
articles.rows = await user.getFavorites(searchOptions);
articles.count = await user.countFavorites();
const user = await UserService.getUserByUsername(favorited);
if (!user) {
return next(new ErrorResponse("User not found", 404));
}
articles.rows = await UserService.getFavorites(user, searchOptions);
articles.count = await UserService.getFavoritesCount(user);
} else {
articles = await Article.findAndCountAll(searchOptions);
articles = await ArticleService.getAllArticlesAndCount(searchOptions);
}
for (let article of articles.rows) {
const articleTags = await article.getTagLists();
//console.log("articleTags: ", articleTags);
// const articleTags = article.tagLists;
ArticleService.appendTagList(articleTags, article);
await ArticleService.appendTagList(article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
}
const data = articles.rows.map((article) => {
return article.toJSONFor();
});
//delete article.dataValues.Favorites;
res.status(200).json({
data: {
articles: data,
articlesCount: articles.count
}
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while fetching articles.', 500, err.message));
}
});
module.exports.updateArticle = asyncHandler(async (req, res, next) => {
try {
const { slug } = req.params;
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
const article = await ArticleService.getArticleBySlug(slug);
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
if (article.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401, "You are not allowed to access this resource."));
}
const { title, description, body } = req.body.article;
const articleSlug = ArticleService.slugify(title ? title : article.title);
const slugInDB = await ArticleService.isSlugUsed(articleSlug);
if (slugInDB && articleSlug !== slug) {
return next(new ErrorResponse("Title already exists", 400));
}
//await article.update({
await ArticleService.updateArticleById({
slug: articleSlug ? articleSlug : article.slug,
title: title ? title : article.title,
description: description ? description : article.description,
body: body ? body : article.body,
}, article.id);
const update = await ArticleService.getArticleByIdWithTagList(article.id);
await ArticleService.appendFollowers(loggedUser, update);
await ArticleService.appendFavorites(loggedUser, update);
res.status(200).json({
message: 'Article updated successfully.',
article: update.toJSONFor()
//article: article
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while updating article.', 500, err.message));
}
});
module.exports.articlesFeed = asyncHandler(async (req, res, next) => {
try {
const { limit = 3, offset = 0 } = req.query;
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
const authors = await UserService.getUserFollowed(loggedUser);
const searchOptions = {
include: includeOptions,
limit: parseInt(limit),
offset: offset * limit,
order: [["createdAt", "DESC"]],
where: { authorId: authors.map((author) => author.id) },
distinct: true,
}
const articles = await ArticleService.getAllArticlesAndCount(searchOptions);
for (const article of articles.rows) {
await ArticleService.appendTagList(article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
}
res.status(200).json({
@@ -103,185 +209,49 @@ module.exports.getArticles = asyncHandler(async (req, res, next) => {
}
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while fetching articles - ${err.message}`, 500));
return next(new ErrorResponse('Something went wrong while fetching articles feed.', 500, err.message));
}
});
module.exports.createArticle = asyncHandler(async (req, res, next) => {
const { loggedUser } = req;
fieldValidation(req.body.article.title, next);
fieldValidation(req.body.article.description, next);
fieldValidation(req.body.article.body, next);
const { title, description, body, tagList } = req.body.article;
const slugInDB = await Article.findOne({ where: { slug: slug(`${title}`) } });
if (slugInDB) {
return next(new ErrorResponse("Title already exists", 400));
}
const article = await Article.create({
title: title,
description: description,
body: body,
});
for (const tag of tagList) {
const tagInDB = await Tag.findByPk(tag.trim());
if (tagInDB) {
await article.addTagList(tagInDB);
} else if (tag.length > 2) {
const newTag = await Tag.create({ name: tag.trim() });
await article.addTagList(newTag);
}
}
delete loggedUser.dataValues.token;
article.dataValues.tagList = tagList;
article.setAuthor(loggedUser);
article.dataValues.author = loggedUser;
await ArticleService.appendFollowers(loggedUser, loggedUser);
await ArticleService.appendFavorites(loggedUser, article);
res.status(201).json({ article });
});
module.exports.deleteArticle = asyncHandler(async (req, res, next) => {
const { slug } = req.params;
const { loggedUser } = req;
const article = await Article.findOne({
where: { slug: slug },
include: includeOptions,
});
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
if (article.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401));
}
await article.destroy();
res.status(200).json({ article });
});
module.exports.updateArticle = asyncHandler(async (req, res, next) => {
const { slug } = req.params;
const { loggedUser } = req;
const article = await Article.findOne({
where: { slug: slug },
include: includeOptions,
});
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
if (article.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401));
}
const { title, description, body } = req.body.article;
const slugInDB = await Article.findOne({
where: {
slug: slug(title ? title : article.title)
},
});
if (slugInDB && slugInDB.slug !== slug) {
return next(new ErrorResponse("Title already exists", 400));
}
await article.update({
title: title ? title : article.title,
description: description ? description : article.description,
body: body ? body : article.body,
});
const articleTags = await article.getTagLists();
ArticleService.appendTagList(articleTags, article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
res.status(200).json({ article });
});
module.exports.articlesFeed = asyncHandler(async (req, res) => {
const { loggedUser } = req;
const { limit = 3, offset = 0 } = req.query;
const authors = await loggedUser.getFollowing();
const articles = await Article.findAndCountAll({
include: includeOptions,
limit: parseInt(limit),
offset: offset * limit,
order: [["createdAt", "DESC"]],
where: { authorId: authors.map((author) => author.id) },
distinct: true,
});
for (const article of articles.rows) {
const articleTags = await article.getTagLists();
ArticleService.appendTagList(articleTags, article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
}
res.json({ articles: articles.rows, articlesCount: articles.count });
});
module.exports.addFavoriteArticle = asyncHandler(async (req, res, next) => {
const { loggedUser } = req;
const { slug } = req.params;
try {
const { slug } = req.params;
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
const article = await ArticleService.getArticleBySlugWithTagList(slug);
const article = await Article.findOne({
where: { slug: slug },
include: includeOptions,
});
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
if (!article) {
return next(new ErrorResponse("Article not found", 404));
await UserService.addFavoriteArticle(loggedUser, article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
res.status(200).json({ article });
} catch (err) {
return next(new ErrorResponse('Something went wrong while adding a favorite.', 500, err.message));
}
await loggedUser.addFavorite(article);
const articleTags = await article.getTagLists();
ArticleService.appendTagList(articleTags, article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
res.status(200).json({ article });
});
module.exports.deleteFavoriteArticle = asyncHandler(async (req, res, next) => {
const { loggedUser } = req;
const { slug } = req.params;
try {
const { slug } = req.params;
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
const article = await Article.findOne({
where: { slug: slug },
include: includeOptions,
});
const article = await ArticleService.getArticleBySlugWithTagList(slug);
if (!article) {
return next(new ErrorResponse("Article not found", 404));
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
await UserService.removeFavoriteArticle(loggedUser, article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
res.status(200).json({ article });
} catch (err) {
return next(new ErrorResponse('Something went wrong while removing a favorite.', 500, err.message));
}
await loggedUser.removeFavorite(article);
const articleTags = await article.getTagLists();
ArticleService.appendTagList(articleTags, article);
await ArticleService.appendFollowers(loggedUser, article);
await ArticleService.appendFavorites(loggedUser, article);
res.status(200).json({ article });
});
const fieldValidation = (field, next) => {
src/controllers/clan.controller.js
+38 -67
View File
@@ -1,32 +1,49 @@
const { HWClanService } = require('../services');
const { ClanService, UserService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
const ErrorResponse = require("../utils/errorResponse");
var mongoose = require('mongoose'),
User = mongoose.model('User');
module.exports.createClan = asyncHandler(async (req, res, next) => {
try {
const user = await UserService.getUserById(req.payload.id);
if (!user) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
const {
id, title, country, description, disbanding, frameId, icon, level, members,
membersCount, minLevel, ownerId, serverId, topActivity, topDungeon
} = req.body;
const author = user.id;
const author = await User.findById(req.payload.id).then(function (user) {
return user._id;
});
const clan = await HWClanService.createClan({
const clan = await ClanService.createClan({
id, title, country, description, disbanding, frameId, icon, level, members,
membersCount, minLevel, ownerId, serverId, topActivity, topDungeon, author
});
//console.log(clan);
res.status(201).json({
message: 'Clan created successfully',
message: 'Clan created successfully.',
data: clan.toJSONFor(),
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while creating clan - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while creating clan.`, 500, err.message));
}
});
module.exports.deleteClan = asyncHandler(async (req, res, next) => {
try {
const { clanId } = req.params;
let clan = await ClanService.getClanById(clanId);
if (req.payload.id !== clan.author.id) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
let data = await ClanService.deleteClan(clan);
res.status(200).json({
message: 'Clan deleted successfully.',
data: data.id
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while deleting clan.`, 500, err.message));
}
});
@@ -44,7 +61,7 @@ module.exports.getAllClans = asyncHandler(async (req, res, next) => {
}
}
const data = await HWClanService.getAllClans(query, limit, offset);
const data = await ClanService.getAllClans(query, limit, offset);
res.status(200).json({
data: {
clans: data.clans.map(function (clan) {
@@ -54,86 +71,40 @@ module.exports.getAllClans = asyncHandler(async (req, res, next) => {
}
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while fetching clans - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while fetching clans.`, 500, err.message));
}
});
module.exports.getClan = asyncHandler(async (req, res, next) => {
try {
//console.log("Clan controller getClan");
const { clanId } = req.params;
let clan = await HWClanService.getClanById(clanId);
let clan = await ClanService.getClanById(clanId);
if (!clan) {
return next(new ErrorResponse("Clan not found", 404));
}
res.status(200).json({ clan: clan.toJSONFor() });
} catch (err) {
return next(new ErrorResponse(`Something went wrong while fetching clan - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while fetching clan.`, 500, err.message));
}
});
module.exports.updateClan = asyncHandler(async (req, res, next) => {
try {
//console.log("Clan controller updateClan", req.payload);
const { clanId } = req.params;
let clan = await HWClanService.getClanById(clanId);
//console.log(req.body.clan, clan);
let clan = await ClanService.getClanById(clanId);
if (req.payload.id !== clan.author._id.toString()) {
return next(new ErrorResponse("Unauthorized", 401));
console.log(clan.author.id, clan.author);
if (req.payload.id !== clan.author.id) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
Object.assign(clan, req.body.clan);
let data = await HWClanService.updateClan(clan);
//res.status(200).json({ clan: data.toJSONFor() });
let data = await ClanService.updateClan(clan);
res.status(200).json({
message: 'Clan updated successfully',
message: 'Clan updated successfully.',
clan: data.toJSONFor()
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while updating clan - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while updating clan.`, 500, err.message));
}
});
module.exports.deleteClan = asyncHandler(async (req, res, next) => {
try {
const { clanId } = req.params;
let clan = await HWClanService.getClanById(clanId);
//console.log(clanId, clan.author._id.toString(), req.payload.id);
if (req.payload.id !== clan.author._id.toString()) {
return next(new ErrorResponse("Unauthorized", 401));
}
let data = await HWClanService.deleteClan(clan);
res.status(200).json({
message: 'Clan deleted successfully',
data: data.id
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while deleting clan - ${err.message}`, 500));
}
});
/*
module.exports.deleteArticle = asyncHandler(async (req, res, next) => {
const { slug } = req.params;
const { loggedUser } = req;
const article = await Article.findOne({
where: { slug: slug },
include: includeOptions,
});
if (!article) {
return next(new ErrorResponse("Article not found", 404));
}
if (article.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401));
}
await article.destroy();
res.status(200).json({ article });
});
*/
src/controllers/comment.controller.js
+9 -16
View File
@@ -1,9 +1,10 @@
const { CommentService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
const ErrorResponse = require("../utils/errorResponse");
const createComment = async (req, res) => {
module.exports.createComment = asyncHandler(async (req, res, next) => {
try {
const { slug, title, description, body, authorId } = req.body;
const comment = await CommentService.createComment({
slug,
title,
@@ -13,18 +14,15 @@ const createComment = async (req, res) => {
});
res.status(201).json({
message: 'Comment created successfully',
message: 'Comment created successfully.',
data: comment,
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while creating comment',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while creating comment.', 500, err.message));
}
};
});
const getAllComments = async (req, res) => {
module.exports.getAllComments = asyncHandler(async (req, res, next) => {
try {
const comments = await CommentService.getAllComments();
@@ -32,11 +30,6 @@ const getAllComments = async (req, res) => {
data: comments,
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while fetching comments',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while fetching comments.', 500, err.message));
}
};
module.exports = { createComment, getAllComments };
});
src/controllers/herowars.controller.js
+60
View File
@@ -0,0 +1,60 @@
const { HeroWarService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
const ErrorResponse = require("../utils/errorResponse");
module.exports.createMember = asyncHandler(async (req, res, next) => {
try {
const { slug, title, description, body, authorId } = req.body;
const member = await HeroWarService.createMember({
slug,
title,
description,
body,
authorId
});
res.status(201).json({
message: 'Member created successfully.',
data: member,
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while creating member.`, 500, err.message));
}
});
module.exports.getAllMembers = asyncHandler(async (req, res, next) => {
try {
const members = await HeroWarService.getAllMembers();
res.status(200).json({ data: members });
} catch (err) {
return next(new ErrorResponse(`Something went wrong while fetching members.`, 500, err.message));
}
});
module.exports.getMember = asyncHandler(async (req, res, next) => {
try {
let member = await HeroWarService.getMemberById(req.member.id);
if (!member) {
return next(new ErrorResponse("Article not found", 404));
}
} catch (err) {
return next(new ErrorResponse(`Something went wrong while fetching member.`, 500, err.message));
}
});
module.exports.updateMember = asyncHandler(async (req, res, next) => {
try {
const { loggedUser } = req;
if (!loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
let member = await HeroWarService.getMemberById(req.payload.id);
return member.save().then(function () {
return res.json({ user: member.toAuthJSON() });
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while updating member.`, 500, err.message));
}
});
src/controllers/member.controller.js
+37 -38
View File
@@ -1,31 +1,48 @@
const { HWMemberService } = require('../services');
const { MemberService, UserService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
const ErrorResponse = require("../utils/errorResponse");
var mongoose = require('mongoose'),
User = mongoose.model('User');
module.exports.createMember = asyncHandler(async (req, res, next) => {
try {
const user = await UserService.getUserById(req.payload.id);
if (!user) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
const {
id, allowPm, avatarId, clanIcon, clanId, clanRole, clanTitle, commander, frameId,
isChatModerator, lastLoginTime, leagueId, level, name, serverId
} = req.body;
const author = user.id;
const author = await User.findById(req.payload.id).then(function (user) {
return user._id;
});
const member = await HWMemberService.createMember({
const member = await MemberService.createMember({
id, allowPm, avatarId, clanIcon, clanId, clanRole, clanTitle, commander, frameId,
isChatModerator, lastLoginTime, leagueId, level, name, serverId, author
});
res.status(201).json({
message: 'Member created successfully',
message: 'Member created successfully.',
data: member.toJSONFor(),
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while creating member - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while creating member.`, 500, err.message));
}
});
module.exports.deleteMember = asyncHandler(async (req, res, next) => {
try {
const { memberId } = req.params;
let member = await MemberService.getMemberById(memberId);
if (req.payload.id !== member.author.id) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
let data = await MemberService.deleteMember(member);
res.status(200).json({
message: 'Member deleted successfully.',
data: data.id
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while deleting member.`, 500, err.message));
}
});
@@ -43,7 +60,7 @@ module.exports.getAllMembers = asyncHandler(async (req, res, next) => {
}
}
const data = await HWMemberService.getAllMembers(query, limit, offset);
const data = await MemberService.getAllMembers(query, limit, offset);
res.status(200).json({
data: {
members: data.members.map(function (member) {
@@ -53,58 +70,40 @@ module.exports.getAllMembers = asyncHandler(async (req, res, next) => {
}
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while fetching members - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while fetching members.`, 500, err.message));
}
});
module.exports.getMember = asyncHandler(async (req, res, next) => {
try {
const { memberId } = req.params;
let member = await HWMemberService.getMemberById(memberId);
let member = await MemberService.getMemberById(memberId);
if (!member) {
return next(new ErrorResponse("Member not found", 404));
}
res.status(200).json({ member: member.toJSONFor() });
} catch (err) {
return next(new ErrorResponse(`Something went wrong while updating member - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while updating member.`, 500, err.message));
}
});
module.exports.updateMember = asyncHandler(async (req, res, next) => {
try {
const { memberId } = req.params;
let member = await HWMemberService.getMemberById(memberId);
let member = await MemberService.getMemberById(memberId);
if (req.payload.id !== member.author._id.toString()) {
return next(new ErrorResponse("Unauthorized", 401));
if (req.payload.id !== member.author.id) {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
Object.assign(member, req.body.member);
let data = await HWMemberService.updateMember(member);
let data = await MemberService.updateMember(member);
res.status(200).json({
message: 'Member updated successfully',
message: 'Member updated successfully.',
member: data.toJSONFor()
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while updating member - ${err.message}`, 500));
}
});
module.exports.deleteMember = asyncHandler(async (req, res, next) => {
try {
const { memberId } = req.params;
let member = await HWMemberService.getMemberById(memberId);
if (req.payload.id !== member.author._id.toString()) {
return next(new ErrorResponse("Unauthorized", 401));
}
let data = await HWMemberService.deleteMember(member);
res.status(200).json({
message: 'Member deleted successfully',
data: data.id
});
} catch (err) {
return next(new ErrorResponse(`Something went wrong while deleting member - ${err.message}`, 500));
return next(new ErrorResponse(`Something went wrong while updating member.`, 500, err.message));
}
});
src/controllers/product.controller.js
+4 -4
View File
@@ -135,10 +135,10 @@ module.exports.createProduct = asyncHandler(async (req, res, next) => {
const tagInDB = await Tag.findByPk(tag.trim());
if (tagInDB) {
await product.addTagList(tagInDB);
await product.addProductTag(tagInDB);
} else if (tag.length > 2) {
const newTag = await Tag.create({ name: tag.trim() });
await product.addTagList(newTag);
await product.addProductTag(newTag);
}
}
delete loggedUser.dataValues.token;
@@ -166,7 +166,7 @@ module.exports.deleteProduct = asyncHandler(async (req, res, next) => {
}
if (product.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401));
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
await product.destroy();
@@ -187,7 +187,7 @@ module.exports.updateProduct = asyncHandler(async (req, res, next) => {
next(new ErrorResponse("Product not found", 404));
}
if (product.authorId !== loggedUser.id) {
return next(new ErrorResponse("Unauthorized", 401));
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
const { title, description, body } = req.body.product;
src/controllers/tag.controller.js
+50 -25
View File
@@ -1,42 +1,67 @@
const { TagService } = require('../services');
const { TagService, UserService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
const ErrorResponse = require("../utils/errorResponse");
const createTag = async (req, res) => {
module.exports.createTag = asyncHandler(async (req, res, next) => {
try {
const { slug, title, description, body, authorId } = req.body;
const tag = await TagService.createTag({
slug,
title,
description,
body,
authorId
});
fieldValidation(req.body.tag.name, next);
const { name } = req.body.tag;
const tagInDB = await TagService.tagIsInDB(name);
if (tagInDB) {
return next(new ErrorResponse("Tag already exists", 400));
}
const tag = await TagService.createTag(name);
res.status(201).json({
message: 'Tag created successfully',
data: tag,
message: 'Tag created successfully.',
data: tag.toJSONFor(),
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while creating tag',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while creating tag.', 500, err.message));
}
};
});
const getAllTags = async (req, res) => {
module.exports.deleteTag = asyncHandler(async (req, res, next) => {
try {
const { name } = req.params;
const tag = await TagService.getTagByName(name);
if (!tag) {
return next(new ErrorResponse("Tag not found", 404));
}
const loggedUser = await UserService.getLoggedUserById(req.payload.id);
if (loggedUser.role !== "Admin") {
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
let data = await TagService.deleteTag(tag);
res.status(200).json({
message: 'Tag deleted successfully.',
data: data.name
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while fetching tags.', 500, err.message));
}
});
module.exports.getAllTags = asyncHandler(async (req, res, next) => {
try {
const tags = await TagService.getAllTags();
res.status(200).json({
data: tags,
data: {
tags: tags,
tagsCount: tags.length
}
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while fetching tags',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while fetching tags.', 500, err.message));
}
});
const fieldValidation = (field, next) => {
if (!field) {
return next(new ErrorResponse(`Missing fields`, 400));
}
};
module.exports = { createTag, getAllTags };
src/controllers/user.controller.js
+62 -47
View File
@@ -1,50 +1,54 @@
//const { UserService } = require('../services/user.service');
const { UserService } = require('../services');
const asyncHandler = require("../middlewares/asyncHandler");
const ErrorResponse = require("../utils/errorResponse");
const passport = require('passport');
const authenticate = async (req, res, next) => {
module.exports.authenticate = asyncHandler(async (req, res, next) => {
try {
passport.authenticate('headerapikey', { session: false }, function (err, application, info) {
if (err) {
return res.status(err.status || 500).json({message: "An authentication error occured.", err: err.message});
//return next(err);
//return res.status(err.status || 500).json({message: "An authentication error occured.", err: err.message});
return next(new ErrorResponse('Something went wrong while authenticating.', err.status || 500, err.message));
}
if (!application) {
return res.status(401).json({message: "Unauthorized - You are not allowed to access this resource.", err: err, info: info});
return next(new ErrorResponse("Unauthorized", 401, "You are not allowed to access this resource."));
}
if (application.author) {
application.author.token = application.author.generateJWT();
return res.json({ user: application.author.toAuthJSON(), application: application.toAuthJSON() });
return res.json({
user: application.author.toAuthJSON(),
application: application.toAuthJSON()
});
} else {
return res.status(422).json(info);
}
})(req, res, next);
} catch (err) {
res.status(500).json({
message: 'something went wrong while creating user',
error: err.message,
});
//res.status(500).json({ message: 'Something went wrong while authenticating.', error: err.message });
return next(new ErrorResponse('Something went wrong while authenticating.', 500, err.message));
}
};
});
const createUser = async (req, res) => {
module.exports.createUser = asyncHandler(async (req, res, next) => {
try {
const { username, firstname, lastname, email } = req.body.user;
const user = await UserService.createUser({ username, firstname, lastname, email });
const user = await UserService.createUser({
username,
firstname,
lastname,
email
});
res.status(201).json({
message: 'User created successfully',
message: 'User created successfully.',
data: user,
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while creating user',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while creating user.', 500, err.message));
}
};
});
const getAllUsers = async (req, res) => {
module.exports.getAllUsers = asyncHandler(async (req, res, next) => {
try {
const users = await UserService.getAllUsers();
@@ -52,32 +56,26 @@ const getAllUsers = async (req, res) => {
data: users,
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while fetching users',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while fetching user.', 500, err.message));
}
};
});
const getUser = async (req, res) => {
module.exports.getUser = asyncHandler(async (req, res, next) => {
try {
const user = await UserService.getUserById(req.payload.id);
if (!user) {
return res.status(401).json({ errors: { "Unauthorized": "autentification requise" } });
return next(new ErrorResponse("Unauthorized", 401, "Authentication required."));
}
res.status(200).json({
user: user.toAuthJSON(),
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while fetching user',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while fetching user.', 500, err.message));
}
};
});
const loginAsUser = async (req, res, next) => {
module.exports.loginAsUser = asyncHandler(async (req, res, next) => {
try {
if (!req.body.user.email) {
return res.status(422).json({ errors: { email: "email can't be blank" } });
@@ -97,18 +95,15 @@ const loginAsUser = async (req, res, next) => {
}
})(req, res, next);
} catch (err) {
res.status(500).json({
message: 'something went wrong while processing login',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while processing login.', 500, err.message));
}
};
});
const updateUser = async (req, res) => {
module.exports.updateUser = asyncHandler(async (req, res, next) => {
try {
let user = await UserService.getUserById(req.payload.id);
if (!user) {
return res.status(401).json({ errors: { "Unauthorized": "autentification requise" } });
return next(new ErrorResponse("Unauthorized", 401, "You are not allowed to access this resource."));
}
if (typeof req.body.user.username !== 'undefined') {
user.username = req.body.user.username;
@@ -149,14 +144,34 @@ const updateUser = async (req, res) => {
user: user.toAuthJSON(),
});*/
return user.save().then(function () {
return res.json({ user: user.toAuthJSON() });
return res.json({
message: 'User updated successfully.',
user: user.toAuthJSON()
});
});
} catch (err) {
res.status(500).json({
message: 'something went wrong while updating user',
error: err.message,
});
return next(new ErrorResponse('Something went wrong while updating user.', 500, err.message));
}
};
});
module.exports = { authenticate, createUser, getAllUsers, getUser, loginAsUser, updateUser };
module.exports.addFollowUser = asyncHandler(async (req, res, next) => {
try {
return res.status(200).json({
message: 'The user is now being followed.',
user: true
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while following a user.', 500, err.message));
}
});
module.exports.deleteFollowUser = asyncHandler(async (req, res, next) => {
try {
return res.status(200).json({
message: 'The user is no longer being followed.',
user: true
});
} catch (err) {
return next(new ErrorResponse('Something went wrong while unfollowing a user.', 500, err.message));
}
});