public async Task <IActionResult> AddLikeAsync( [FromBody][Required] LikeDto newLikeDto, CancellationToken cancellationToken) { var currentUserId = _userManager.GetUserIdAsInt(HttpContext.User); var likeEntity = new LikeEntity { PostId = newLikeDto.PostId, UserId = currentUserId }; var updatedPost = await _post.DoAddLikeAsync(likeEntity, cancellationToken) .ConfigureAwait(false); var notification = new NotificationEntity { Type = NotificationType.AddLike, SentByUserId = currentUserId, ReceivedUserId = updatedPost !.UserId, TriggeredOn = DateTimeOffset.Now // TODO - add post to notification }; await _notification.DoAddAsync(notification, cancellationToken) .ConfigureAwait(false); await _notification.DoBroadcastNotifications(updatedPost !.UserId) .ConfigureAwait(false); return(Ok(CreatePostDto(updatedPost !))); }
public async Task <IActionResult> Post([FromBody] LikeDto like) { var toDb = new Like() { AuthorId = like.AuthorId, LikedPostId = like.LikedPostId, DateAdded = DateTime.Now }; var existing = await _forumContext.Likes.FirstOrDefaultAsync(like1 => like1.AuthorId == like.AuthorId && like1.LikedPostId == like.LikedPostId); if (existing != null) { like.Id = 0; _forumContext.Likes.Remove(existing); await _forumContext.SaveChangesAsync(); } else { await _forumContext.Likes.AddAsync(toDb); await _forumContext.SaveChangesAsync(); like.Id = toDb.Id; } return(Ok(like)); }
public LikeDto AddLike(Like like, Guid userId) { Like existingLike = null; if (like.HouseId != 0) { existingLike = GetLike(like.HouseId, userId); } LikeDto likeDto = new LikeDto { UserId = like.UserId, HouseId = like.HouseId, }; if (existingLike == null) { _db.Likes.Add(like); likeDto.Liked = true; } else { _db.Likes.Remove(existingLike); likeDto.Liked = false; } _db.SaveChanges(); return(likeDto); }
public ResultHelperModel ToggleLike(LikeDto dto) { var result = new ResultHelperModel { Success = true, Message = string.Empty }; var entity = _baseRepository.Get <TweetLike>(x => x.UserProfileId == dto.UserProfileId && x.TweetId == dto.DestinationId); try { if (entity != null) { _baseRepository.Remove(entity); } else { var like = _mapper.Map <TweetLike>(dto); _baseRepository.Create(like); } } catch (Exception ex) { result.Success = false; result.Message = ex.Message; } return(result); }
public async Task <LikeDto> Like(LikeDto dto) { // Obtención de un like para un usuario y un post con Linq //var model = await _context.Likes.FirstOrDefaultAsync(x => x.UserId == dto.UserId && x.PostId == dto.PostId); // Obtención de un like para un usuario y un post FromSql var model = await _context.Likes .FromSqlRaw("SELECT * FROM Likes WHERE UserId = {0} AND PostId = {1}", dto.UserId, dto.PostId).FirstOrDefaultAsync(); if (model != null) { // Si existe el like lo eliminamos _context.Likes.Remove(model); } else { // Si no existe, mapeamos al objeto entidad y lo añadimos al contexto model = _mapper.Map <Like>(dto); _context.Likes.Add(model); } // Guardamos y mapeamos al dto de salida _context.SaveChangesAsync(); return(_mapper.Map <LikeDto>(model)); }
public void UpdateBuffer(LikeDto dto, int id) { if (_likesFrom[id] == null) { _likesFrom[id] = Compress(ConvertIntToString(new int[] { dto.Id })); } else { var existed = ConvertStringToIds(Decompress(_likesFrom[id])); existed.Add(dto.Id); _likesFrom[id] = Compress(ConvertIntToString(existed)); } var likeDto = new LikeDto { Id = id, TimeStamp = dto.TimeStamp }; if (_likesTo[dto.Id] == null) { _likesTo[dto.Id] = Compress(ConvertLikeDtoToString(new List <LikeDto> { likeDto })); } else { var existed = ConvertStringToLikeDto(Decompress(_likesTo[dto.Id])); existed.Add(likeDto); _likesTo[dto.Id] = Compress(ConvertLikeDtoToString(existed)); } }
public async Task <IActionResult> Unlike([FromBody] LikeDto model) { model.AppUserId = User.GetUserId(); await _likeService.Unlike(model); return(Json("Success")); }
public void UpdateBuffer(LikeDto dto, int id) { if (!_postFrom.ContainsKey(id)) { _postFrom[id] = new List <int> { dto.Id }; } else { _postFrom[id].Add(dto.Id); } if (!_postTo.ContainsKey(dto.Id)) { _postTo[dto.Id] = new List <LikeDto> { new LikeDto { Id = id, TimeStamp = dto.TimeStamp } }; } else { _postTo[dto.Id].Add(new LikeDto { Id = id, TimeStamp = dto.TimeStamp }); } }
public async Task Unlike(LikeDto model) { var isLiked = await _unitOfWork.Like.FirstOrDefault(x => x.AppUserId == model.AppUserId && x.TweetId == model.TweetId); _unitOfWork.Like.Delete(isLiked); await _unitOfWork.Commit(); }
public IActionResult Like([FromBody] LikeDto likeDto) { if (likeDto == null) { return(BadRequest()); } likeDto.CreatedDate = DateTime.UtcNow; var existingMatch = _context.Likes.AsQueryable().Where(x => x.UserId == likeDto.UserId && x.LikedId == likeDto.LikedId); if (existingMatch.Any()) { return(Ok()); } var likesEntry = _context.Likes.Add(_mapper.Map <Likes>(likeDto)); _context.SaveChanges(); var match = _context.Likes.AsQueryable().FirstOrDefault(x => x.UserId == likeDto.LikedId && x.LikedId == likeDto.UserId); if (match != null) { return(Ok(true)); } return(likesEntry == null?StatusCode(500) : Ok()); }
public async Task <ApiResponse <LikeResponseDto> > LikePost(LikeDto likeRequest) { // Do a check on the Request Ip Address and User-Agent to ensure a like action is not // Initiated twice from the same user on the same device to avoid spam // Also do a check on the RequestUsername supplied from the client, to ensure a particular user // Does not Like twice (just incase request is sent from same user with the a different device) ApiResponse <LikeResponseDto> result = new ApiResponse <LikeResponseDto>(); var resultMessage = ""; Likes like = _mapper.Map <Likes>(likeRequest); try { var isLikedFromClient = await LikedExistFromClient(likeRequest.RequestIpAddress, likeRequest.RequestUserAgent, likeRequest.ClientReferenceId, likeRequest.PostId, likeRequest.RequestUsername); if (isLikedFromClient) { resultMessage = $"Post with Id: {likeRequest.PostId} has be been Liked from {resultMessage} Ip Address:: {likeRequest.RequestIpAddress} by Username:: {likeRequest.RequestUsername} (Action is permitted only once) "; _logger.LogInformation(resultMessage); throw new AppException(resultMessage); } like.CreatedOn = DateTime.Now; await _likeRepository.AddAsync(like); await _unitOfWork.CompleteAsync(); resultMessage = "Successfully liked post"; result.Status = Helpers.ApiReponseStatusCodes.Created; result.Message = resultMessage; result.Data = new LikeResponseDto { RequestIpAddress = like.RequestIpAddress, RequestUserAgent = like.RequestUserAgent, PostId = like.PostId, ClientReferenceId = like.ClientReferenceId, RequestUsername = like.RequestUsername }; return(result); } catch (Exception ex) { _logger.Log(LogLevel.Error, ex.StackTrace); _logger.Log(LogLevel.Error, ex.Message); throw new AppException(ex.Message); } }
public IActionResult Like([FromBody] LikeDto request, [FromServices] ILikePostCommand command) { request.UserId = actor.Id; executor.ExecuteCommand(command, request); return(StatusCode(StatusCodes.Status201Created)); }
public void AddLike(LikeDto dto, int userId) { var newLike = Mapper.Map <Like>(dto); newLike.UserId = userId; ctx.Likes.Add(newLike); ctx.SaveChanges(); }
public void SaveLikeSubComment(string myuserName, LikeDto likeDto, int subCommentId, string groupName) { Clients.All.SaveLikeSubComment(likeDto.Check, subCommentId, groupName); if (myuserName != likeDto.UserName) { List <string> listId = GetListConnectIdByUserName("No value", likeDto.UserName); Clients.Clients(listId).UpdateNotiRealtime(); } }
public async Task <IActionResult> LikePost([FromBody] LikeDto likeDto) { var action = await _mediator.Send(new LikePostCommand { LikeDto = likeDto }); return(Ok(action)); }
private static LikeDto Transform(long input) { var dto = new LikeDto { Id = (int)(input & _mask), TimeStamp = (int)(input >> 25) }; return(dto); }
public IHttpActionResult UpdateLike(LikeDto dto) { if (service.UpdateLike(dto, User.Identity.GetUserId <int>())) { return(Ok()); } service.AddLike(dto, User.Identity.GetUserId <int>()); string location = Request.RequestUri + "/"; return(Created(location, "")); }
public async Task Like(LikeDto model) { var isLiked = await _unitOfWork.Like.FirstOrDefault(x => x.AppUserId == model.AppUserId && x.TweetId == model.TweetId); if (isLiked == null) { var like = _mapper.Map <LikeDto, Like>(model); await _unitOfWork.Like.Add(like); await _unitOfWork.Commit(); } }
public ICollection <Post> Resolve(Like source, LikeDto destination, ICollection <Post> dest, ResolutionContext context) { var likes = _uow.Likes.Find(x => x.UserId == source.UserId).ToList(); var likedPosts = new List <Post>(); foreach (var likedpost in likes) { likedPosts.Add(_uow.Posts.Find(x => x.Id == likedpost.PostId).FirstOrDefault()); } return(likedPosts); }
public bool UpdateLike(LikeDto dto, int userId) { var like = ctx.Likes .FirstOrDefault(l => l.LikeableItemId == dto.LikeableItemId && l.UserId == userId); if (like == null) { return(false); } like.Liked = dto.Liked; ctx.SaveChanges(); return(true); }
public async Task <IActionResult> GetLikesForPost(int postId) { var userFromDb = await _userManager.GetUserAsync(this.User); var likes = await _repository.Like.GetLikesForPostAsync(postId); var likesDto = new LikeDto() { LikesCount = likes.Count(), CurrentUserLiked = likes.Any(l => l.LikerId == userFromDb.Id) }; return(Ok(likesDto)); }
public bool Post(LikeDto likeDto) { string userId = userManager.GetUserId(CurrentHttpContext.Current?.User); Like userLiked = repository.Likes.FirstOrDefault(l => l.UserId == userId && l.BlogId == likeDto.BlogId); if (userId != null && userLiked == null) { repository.AddLike(new Like { BlogId = likeDto.BlogId, UserId = userId, Liked = likeDto.Liked }); return(true); } return(false); }
public async Task <IActionResult> UpdateLike(string id, [FromBody] LikeDto likeDto) { if (likeDto.Value == 0 || likeDto.Value > 1 || likeDto.Value < -1) { return(BadRequest()); } if (likeDto.SharedMealUUID == null) { return(BadRequest()); } return(Ok(await _likeService.UpdateLike(likeDto, HttpContext.User.Identity.Name))); }
public static LikeViewModel ToViewModel(this LikeDto like) { if (like == null) { return(null); } return(new LikeViewModel { Id = like.Id, IsLike = like.IsLike, PostId = like.PostId, UserId = like.UserId }); }
public async Task <ActionResult <GetPostDto> > DeleteLikeAsync( [FromBody][Required] LikeDto deletedLikeDto, CancellationToken cancellationToken) { var currentUserId = _userManager.GetUserIdAsInt(HttpContext.User); var likeEntity = new LikeEntity { PostId = deletedLikeDto.PostId, UserId = currentUserId }; var updatedPost = await _post.DoDeleteLikeAsync(likeEntity, cancellationToken) .ConfigureAwait(false); return(Ok(CreatePostDto(updatedPost !))); }
public async Task <ResultDto> AddNewLike(LikeDto likeDto, string userId) { var like = _mapper.Map <Like>(likeDto); like.UUID = Guid.NewGuid().ToString(); like.User = await _context.Users.Where(u => u.UUID == userId).FirstOrDefaultAsync(); like.CreatedAt = DateTime.Now; like.UpdatedAt = DateTime.Now; like.SharedMeal = await _context.SharedMeals.Where(sm => sm.UUID == likeDto.SharedMealUUID) .FirstOrDefaultAsync(); _context.Add(like); await _context.SaveChangesAsync(); return(new ResultDto(true, "Like added succesfully")); }
public void Execute(LikeDto request) { validator.ValidateAndThrow(request); var findLike = context.Likes.Where(x => x.PieceOfArtId == request.PieceOfArtId && x.UserId == request.UserId).FirstOrDefault(); if (findLike == null) { var like = mapper.Map <Like>(request); context.Likes.Add(like); context.SaveChanges(); } else { findLike.Status = request.Status; context.SaveChanges(); } }
public async Task <IActionResult> GetGood(string key, string field) { //var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); Like like; if (field.Equals("name")) { like = await _repo.GetFirstAsync(woak => woak.Title.Equals(key)); } else { like = await _repo.GetFirstAsync(woak => woak.Srl == Convert.ToInt32(key)); } LikeDto likeDto = _mapper.Map <LikeDto>(like); return(Ok(new { likeDto = likeDto })); }
public JsonResult SaveLikePost(int?id) { var userName = Session["userName"] as string; User user = db.Users.FirstOrDefault(us => us.UserName.Equals(userName)); LikeDto result = new LikeDto { Check = false, UserName = "" }; Like like = db.Likes.FirstOrDefault(s => s.UserId == user.Id && s.PostId == id); if (like != null) { db.Likes.Remove(like); } else { Like like2 = new Like { PostId = id, UserId = user.Id }; db.Likes.Add(like2); result.Check = true; } if (result.Check) { Post post = db.Posts.FirstOrDefault(s => s.Id == id); if (post.UserId != user.Id) { Notification noti = new Notification { UserId = post.UserId, PostId = post.Id, NameOfUser = user.Name, Avatar = user.Avatar, TextNoti = "Đã thích bài viết của bạn", ClassIconName = "far fa-thumbs-up", NotificationState = false }; result.UserName = post.User.UserName; db.Notifications.Add(noti); } } db.SaveChanges(); return(Json(result, JsonRequestBehavior.AllowGet)); }
public async Task <IActionResult> LikeMember(LikeDto likeDto) { try { await unitOfWork.LikeRepository.addUserLike( this.User.GetUsername(), likeDto.Username, likeDto.Like ); } catch (Exception e) { return(BadRequest(e.Message)); } return(await this.unitOfWork.Complete() ? Ok() : throw new Exception(" unknown error has accord, Error code: 8047")); }