Fix/navigation

.gitignore

@@ -4,5 +4,9 @@ node_modules
 
 .idea/
 
+upload
 
+docker-compose.yml
 .env
+
+coverage/

lib/application/use_cases/artist/getArtist.js

@@ -0,0 +1,145 @@
+const serializeArtiste = require("../../../interfaces/serializers/ArtistSerializer");
+const throwStatusCode = require("../utils/throwStatusCode");
+const UserPublic = require("../../../domain/model/UserPublic");
+const ArtistPage = require("../../../domain/model/ArtistPage.js");
+const serializeAlbum = require("../../../interfaces/serializers/AlbumSerializer");
+const reviewSerializer = require("../../../interfaces/serializers/ReviewSerializer.js");
+module.exports = async (
+  artistId,
+  userToken,
+  {
+    accessTokenManager,
+    userRepository,
+    spotifyRepository,
+    reviewRepository,
+    followRepository,
+    friendRepository,
+  }
+) => {
+  const id_utilisateur = accessTokenManager.decode(userToken)?.value;
+  const user = await userRepository.getByUser(id_utilisateur);
+  if (!user)
+    throwStatusCode(401, "votre token d'authentification n'est pas le bon");
+  const artist = await spotifyRepository.getSpotifyArtist(artistId);
+  if (artist.error) throwStatusCode(artist.error.status, artist.error.message);
+  const doesUserFollow = await followRepository.doesFollows(
+    id_utilisateur,
+    artistId
+  );
+  const albums = await spotifyRepository.getSpotifyArtistSongs(
+    artistId,
+    "album,single"
+  );
+
+  const album_ids = albums.items.map((album) => album.id);
+  const [
+    follower_count,
+    friends_followers,
+    friend_follower_count,
+    reviewsByLike,
+    reviewsByTime,
+    reviewsByFriends,
+  ] = await Promise.all([
+    followRepository.getFollowersCount(artistId),
+    followRepository.getFriendsFollowing(artistId, user.id_utilisateur, 3),
+    followRepository.getFriendsFollowingCount(artistId, user.id_utilisateur),
+    reviewRepository.getOeuvreReviews(
+      1,
+      3,
+      true,
+      false,
+      false,
+      album_ids,
+      user.id_utilisateur
+    ),
+    reviewRepository.getOeuvreReviews(
+      1,
+      3,
+      false,
+      false,
+      false,
+      album_ids,
+      user.id_utilisateur
+    ),
+    reviewRepository.getOeuvreReviews(
+      1,
+      3,
+      false,
+      false,
+      true,
+      album_ids,
+      user.id_utilisateur
+    ),
+  ]);
+  return await artistSerizilizer(
+    user.id_utilisateur,
+    doesUserFollow,
+    artist,
+    albums,
+    follower_count,
+    friends_followers,
+    friend_follower_count,
+    reviewsByLike,
+    reviewsByTime,
+    reviewsByFriends,
+    { reviewRepository, spotifyRepository, friendRepository }
+  );
+};
+
+const artistSerizilizer = async (
+  id_utilisateur,
+  doesUserFollow,
+  artist,
+  albums,
+  followers_count,
+  friends_followers,
+  friend_follower_count,
+  reviewsByLike,
+  reviewsByTime,
+  reviewsByFriends,
+  { reviewRepository, spotifyRepository, friendRepository }
+) => {
+  artist.follower_count = followers_count;
+  artist = serializeArtiste(artist);
+
+  albums = await Promise.all(
+    albums.items.map(async (item) => {
+      item.rating = await reviewRepository.getOeuvreRating(item.id);
+      item.reviewCount = await reviewRepository.getReviewCount(item.id);
+      return serializeAlbum(item);
+    })
+  );
+
+  friends_followers = {
+    count: friend_follower_count,
+    users: friends_followers.map((item) => {
+      return new UserPublic(item);
+    }),
+  };
+  const serializeReviews = (reviews) => {
+    return reviews.map(async (review) => {
+      return reviewSerializer(
+        review,
+        id_utilisateur,
+        undefined,
+        spotifyRepository,
+        reviewRepository,
+        friendRepository
+      );
+    });
+  };
+  reviewsByLike = await Promise.all(serializeReviews(reviewsByLike));
+
+  reviewsByTime = await Promise.all(serializeReviews(reviewsByTime));
+
+  reviewsByFriends = await Promise.all(serializeReviews(reviewsByFriends));
+  return new ArtistPage(
+    artist,
+    albums,
+    friends_followers,
+    reviewsByLike,
+    reviewsByTime,
+    reviewsByFriends,
+    doesUserFollow
+  );
+};

lib/application/use_cases/artist/getArtistFollowers.js

@@ -0,0 +1,41 @@
+const throwStatusCode = require("../utils/throwStatusCode.js");
+const ArtistFollowersPage = require("../../../domain/model/ArtistFollowersPage.js"); 
+const UserPublic = require("../../../domain/model/UserPublic.js");
+
+module.exports = async (artistId, userToken, {accessTokenManager,userRepository, spotifyRepository, followRepository, friendRepository}) => {
+    const id_utilisateur = accessTokenManager.decode(userToken)?.value
+    const user = await userRepository.getByUser(id_utilisateur)
+    if(!user) throwStatusCode(401,"votre token d'authentification n'est pas le bon")
+
+    const artist = await spotifyRepository.getSpotifyArtist(artistId)
+    if(artist.error)
+        throwStatusCode(artist.error.status,artist.error.message)
+
+    const followersFriendsList = await followRepository.getFriendsFollowing(artistId,id_utilisateur)
+    const followersWithoutFriends = await followRepository.getArtistFollowersWithoutFriends(artistId, id_utilisateur)
+
+    const followersFriendsList2 = await Promise.all(followersFriendsList.map(async (item) => {
+        const areFriends = await friendRepository.areFriends(id_utilisateur, item.id_utilisateur);
+        const userPublicFriends = new UserPublic(item)
+        return {
+            ...userPublicFriends,
+            areFriends: areFriends
+        };
+    }));
+
+    const followersWithoutFriendst2 = await Promise.all(followersWithoutFriends.map(async (item) => {
+        let areFriends = await friendRepository.areFriends(id_utilisateur, item.id_utilisateur);
+        const userPublicNoFriends = new UserPublic(item)
+        if(id_utilisateur == item.id_utilisateur) {
+            areFriends = false
+        }
+        return {
+            ...userPublicNoFriends,
+            areFriends: areFriends
+        };
+    }));
+
+    const allFollowers = [...followersFriendsList2, ...followersWithoutFriendst2];
+
+    return new ArtistFollowersPage(artist, allFollowers)
+}

lib/application/use_cases/comment/deleteComment.js

@@ -0,0 +1,14 @@
+const throwStatusCode = require("../utils/throwStatusCode");
+module.exports = async (
+  idComment,
+  userToken,
+  { accessTokenManager, userRepository, commentRepository }
+) => {
+  const id_utilisateur = accessTokenManager.decode(userToken)?.value;
+  if (!(await userRepository.getByUser(id_utilisateur)))
+    throwStatusCode(401, "votre token d'authentification n'est pas le bon");
+  if (!(await commentRepository.canDelete(idComment, id_utilisateur)))
+    throwStatusCode(403, "ce n'est pas votre post");
+
+  await commentRepository.delete(idComment, id_utilisateur);
+};

lib/application/use_cases/comment/getComment.js

@@ -0,0 +1,142 @@
+const reviewSerializer = require("../../../interfaces/serializers/ReviewSerializer");
+const PublicComment = require("../../../domain/model/PublicComment");
+const UserPublic = require("../../../domain/model/UserPublic");
+const throwStatusCode = require("../utils/throwStatusCode");
+
+
+module.exports = async (
+  id_com,
+  page,
+  pageSize,
+  orderByLike,
+  userToken,
+  {
+    reviewRepository,
+    commentRepository,
+    accessTokenManager,
+    userRepository,
+    friendRepository,
+    spotifyRepository,
+  }
+) => {
+  const id_utilisateur = accessTokenManager.decode(userToken)?.value;
+  if (!(await userRepository.getByUser(id_utilisateur)))
+    throwStatusCode(401, "votre token d'authentification n'est pas le bon");
+  const mainComment = await commentRepository.getById(id_com);
+  if (!mainComment) throwStatusCode(404, "commentaire introuvable");
+  const commentsRaw = await commentRepository.getCommentsComments(
+    id_com,
+    id_utilisateur,
+    true,
+    page,
+    pageSize,
+    orderByLike
+  );
+  const review = await reviewRepository.getById(mainComment.id_review);
+  let previousComments = [];
+  let nextCommentsId = mainComment.id_reponse;
+  while (nextCommentsId) {
+    previousComments.push(await commentRepository.getById(nextCommentsId));
+    nextCommentsId = previousComments.at(-1).id_reponse;
+  }
+  return await serialize(
+    id_utilisateur,
+    mainComment,
+    previousComments,
+    commentsRaw,
+    review,
+    { spotifyRepository, friendRepository, commentRepository, reviewRepository }
+  );
+};
+
+const serialize = async (
+  id_utilisateur,
+  comment,
+  previousComments,
+  comments,
+  review,
+  { spotifyRepository, friendRepository, commentRepository, reviewRepository }
+) => {
+  const serializeReview = async () => {
+    return !review.utilisateur.is_private ||
+      friendRepository.areFriends(
+        id_utilisateur,
+        review.utilisateur.id_utilisateur
+      )
+      ? reviewSerializer(
+          review,
+          id_utilisateur,
+          comments,
+          spotifyRepository,
+          reviewRepository,
+          friendRepository
+        )
+      : {
+          private: true,
+        };
+  };
+  const serializeComment = async () => {
+    const doesUserLike = await commentRepository.doesUserLike(
+      id_utilisateur,
+      comment.id_com
+    );
+    comment.doesUserLike = doesUserLike;
+    return !comment.utilisateur.is_private ||
+      friendRepository.areFriends(
+        id_utilisateur,
+        comment.utilisateur.id_utilisateur
+      )
+      ? new PublicComment(comment, new UserPublic(comment.utilisateur))
+      : {
+          private: true,
+        };
+  };
+  const serializedPreviousComments = Promise.all(
+    previousComments.map(async (comment) => {
+      const doesUserLike = await commentRepository.doesUserLike(
+        id_utilisateur,
+        comment.id_com
+      );
+      comment.doesUserLike = doesUserLike;
+      return !comment.utilisateur.is_private ||
+        friendRepository.areFriends(
+          id_utilisateur,
+          comment.utilisateur.id_utilisateur
+        )
+        ? new PublicComment(comment)
+        : {
+            private: true,
+          };
+    })
+  );
+  const serializedComments = Promise.all(
+    comments.map(async (comment) => {
+      const doesUserLike = await commentRepository.doesUserLike(
+        id_utilisateur,
+        comment.id_com
+      );
+      comment.doesUserLike = doesUserLike;
+      return !comment.utilisateur.is_private ||
+        friendRepository.areFriends(
+          id_utilisateur,
+          comment.utilisateur.id_utilisateur
+        )
+        ? new PublicComment(comment, new UserPublic(comment.utilisateur))
+        : {
+            private: true,
+          };
+    })
+  );
+  const promise = await Promise.all([
+    serializeReview(),
+    serializeComment(),
+    serializedPreviousComments,
+    serializedComments,
+  ]);
+  return {
+    review: promise[0],
+    comment: promise[1],
+    previousComments: promise[2],
+    comments: promise[3],
+  };
+};

lib/application/use_cases/comment/likeComment.js

@@ -0,0 +1,11 @@
+const throwStatusCode = require("../utils/throwStatusCode");
+module.exports = async (commentId,userToken,{accessTokenManager,userRepository,commentRepository}) =>{
+    const id_utilisateur = accessTokenManager.decode(userToken)?.value
+    if(! await commentRepository.getById(commentId)) throwStatusCode(404,"commentaire introuvable")
+    if(! await userRepository.getByUser(id_utilisateur)) throwStatusCode(401,"votre token d'authentification n'est pas le bon")
+    if(! await commentRepository.doesUserLike(commentId,id_utilisateur)){
+        await commentRepository.like(commentId,id_utilisateur,)
+        return true
+    }
+    await commentRepository.unlike(commentId,id_utilisateur)
+}

lib/application/use_cases/comment/putComment.js

@@ -0,0 +1,16 @@
+const throwStatusCode = require("../utils/throwStatusCode");
+const PublicComment = require("../../../domain/model/PublicComment")
+const UserPublic = require("../../../domain/model/UserPublic")
+module.exports = async (
+    commentId,
+    description,
+    userToken,
+    {friendRepository,accessTokenManager,commentRepository,userRepository}) => {
+    const id_utilisateur = accessTokenManager.decode(userToken)?.value
+    if(! await userRepository.getByUser(id_utilisateur)) throwStatusCode(401,"votre token d'authentification n'est pas le bon")
+    const comment = await commentRepository.getById(commentId)
+    if(comment.utilisateur.is_private && !(await friendRepository.areFriends(id_utilisateur,comment.utilisateur.id_utilisateur)))
+            throwStatusCode(403, "l'utilisateur est en privé")
+    const commentRaw = await commentRepository.persist(comment.id_review,description,id_utilisateur,commentId)
+    return new PublicComment(commentRaw,new UserPublic(comment.utilisateur))
+}