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"));
}
