Esempio n. 1
0
        public async Task <IActionResult> SetLike(string uuid)
        {
            var  targetUsername = httpContextRetriever.HttpContext.User.Identity.Name;
            User user           = await userService.GetUserByMailAsync(targetUsername);

            Metadata metadata = null;

            try {
                metadata = await _metadataService.GetByUuidAsync(Guid.Parse(uuid));
            } catch (Exception) {
                throw new HttpException(HttpStatusCode.NotFound);
            }
            //Check if the user has already liked it
            try {
                var existingLike = await _likeService.GetLikeByUserAndMetadata(user, metadata);

                if (existingLike != null)
                {
                    await _likeService.DeleteLike(existingLike);
                }
            } catch (InvalidOperationException) {
                var like = new Like()
                {
                    LikeUser = user, Metadata = metadata
                };

                await _likeService.SaveAsync(like);
            }

            await _unitOfWork.CompleteAsync();

            return(Ok());
        }
Esempio n. 2
0
        public async Task <ActionResult <LikesModel> > DeleteLike(long postId, long userId)
        {
            try
            {
                var likeToBeDeleted = await _likeService.GetLikeById(postId, userId);

                if (likeToBeDeleted == null)
                {
                    return(NotFound());
                }

                var postModel = _mapper.Map <Likes, LikesModel>(likeToBeDeleted);

                await _likeService.DeleteLike(likeToBeDeleted);

                return(Ok(postModel));
            }
            catch (DBException e)
            {
                return(BadRequest(e.Message));
            }
            catch (Exception e)
            {
                return(BadRequest("Internal error."));
            }
        }
        public async Task <IActionResult> DeleteLike(int likeId)
        {
            var result = await _likeService.DeleteLike(likeId);

            return(result != 0
                ? Ok(result)
                : BadRequest());
        }
        public async Task <IActionResult> DeleteLike([FromBody] int shirtId)
        {
            var email = GetEmailFromHttpContextAsync();
            await _likeService.DeleteLike(shirtId, email);

            _logger.LogInfo($"Delete like for t-shirt with id: {shirtId}.");

            return(Ok());
        }
Esempio n. 5
0
        public async Task <IActionResult> DeleteLike(int id)
        {
            var user_id = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
            var post    = await _postService.Get(id);

            if (post == null)
            {
                return(NotFound());
            }

            var res = await _likeService.DeleteLike(user_id, id);

            if (res)
            {
                return(NoContent());
            }

            return(BadRequest());
        }
Esempio n. 6
0
        public async Task <ActionResult> removeLike(Like like)
        {
            await _service.DeleteLike(like);

            return(NoContent());
        }
Esempio n. 7
0
        public async Task <object> DeleteLike(int id)
        {
            var deleteLike = await _likeService.DeleteLike(id);

            return(deleteLike);
        }
Esempio n. 8
0
        public async Task <IActionResult> Delete([FromRoute] int idPost, [FromRoute] string nameUser)
        {
            Response result = await _likeService.DeleteLike(idPost, nameUser);

            return(Ok(result));
        }