public int Like(string login, int id_image)
{
int id_user = getUserByName(login);
List <Like> list = new List <ImagePinned.DAL.Entities.Like>(DataBase.Likes.getAll());
var users = from c in list where c.Id_Image == id_image select c;
foreach (Like likes in users)
{
if (id_user == likes.Id_user)
{
DataBase.Likes.Delete(likes.Id);
return(Dislike(likes.Id_Image));
}
}
LikeDTO likeDTO = new LikeDTO {
Id_Image = id_image, Id_user = getUserByName(login)
};
Mapper.Initialize(cfg => cfg.CreateMap <LikeDTO, Like>());
var like =
Mapper.Map <LikeDTO, Like>(likeDTO);
DataBase.Likes.Create(like);
return(Liked(like.Id_Image));
}
public IActionResult LikePost(LikeDTO like)
{
var userId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier));
_postService.LikePost(userId, like.PostId);
return(Ok());
}
public async Task UnLike(LikeDTO model)
{
var isLiked = await _unitOfWork.Like.FirstOrDefault(x => x.AppUserId == model.AppUserId && x.PostId == model.PostId);
_unitOfWork.Like.Delete(isLiked);
await _unitOfWork.Commit();
}
public static async Task Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)]
LikeDTO likeDTO,
[CosmosDB(
Constants.DatabaseName,
Constants.ThreadsCollectionName,
CreateIfNotExists = true,
ConnectionStringSetting = Constants.ConnectionStringName)]
IAsyncCollector <Thread> threadsOut,
[CosmosDB(
Constants.DatabaseName,
Constants.ThreadsCollectionName,
ConnectionStringSetting = Constants.ConnectionStringName,
Id = "{id}",
PartitionKey = "{clientId}")]
Thread thread,
ILogger log)
{
log.LogInformation("Triggered Like");
if (thread == null)
{
throw new Exception("Invalid clientId, id combination");
}
if (thread.likedBy == null)
{
thread.likedBy = new List <string>();
}
thread.likedBy.Add(likeDTO.author);
log.LogInformation($"Inserting Thread:{thread.id}");
await threadsOut.AddAsync(thread);
}
public async Task <OperationDetails> AddLike(LikeDTO likeDTO)
{
if (likeDTO.UserId == null)
{
return(new OperationDetails(false, "UserId is null.", ""));
}
Photo photo = Database.PhotoManager.GetInfo(likeDTO.PhotoId);
if (photo == null)
{
return(new OperationDetails(false, "Photo not found.", ""));
}
UserProfile user = Database.ProfileManager.Read(likeDTO.UserId);
if (user == null)
{
return(new OperationDetails(false, "User not found.", ""));
}
if (Database.LikeManager.Find(l => l.Photo == photo && l.UserProfile == user).Count() > 0)
{
return(new OperationDetails(false, "User already liked this photo.", ""));
}
Database.LikeManager.Create(new Like
{
Photo = photo,
UserProfile = user
});
await Database.SaveAsync();
return(new OperationDetails(true, "Photo liked.", ""));
}
public async Task <OperationDetails> RemoveLike(LikeDTO likeDTO)
{
if (likeDTO.UserId == null)
{
return(new OperationDetails(false, "UserId is null.", ""));
}
Photo photo = Database.PhotoManager.GetInfo(likeDTO.PhotoId);
if (photo == null)
{
return(new OperationDetails(false, "Photo not found.", ""));
}
UserProfile user = Database.ProfileManager.Read(likeDTO.UserId);
if (user == null)
{
return(new OperationDetails(false, "User not found.", ""));
}
var likes = Database.LikeManager.Find(l => l.Photo == photo && l.UserProfile == user);
if (likes.Count() == 0)
{
return(new OperationDetails(false, "User didn't liked this photo before.", ""));
}
Database.LikeManager.Delete(likes.First());
await Database.SaveAsync();
return(new OperationDetails(true, "Photo unliked.", ""));
}
public async Task UnLike(LikeDTO likeDTO)
{
var isLiked = await _unitOfWork.LikeRepository.FirstOrDefault(x => x.AppUserId == likeDTO.AppUserId && x.TweetId == likeDTO.TweetId);
_unitOfWork.LikeRepository.Delete(isLiked);
await _unitOfWork.Commit();
}
public LikePostagemDTO(int likeId, int postagemId, LikeDTO like, PostagemDTO postagem)
{
LikeId = likeId;
PostagemId = postagemId;
Like = like;
Postagem = postagem;
}
public async Task <LikeDTO> AddLike(LikeDTO like)
{
var dbLike = (await _db.Likes.AddAsync(_mapper.Map <Like>(like))).Entity;
await _db.SaveChangesAsync();
return(_mapper.Map <LikeDTO>(dbLike));
}
public async Task <IActionResult> AddLike([FromBody] LikeDTO like)
{
var result = await _likeService.AddLike(like);
return(result != null
? Ok(result)
: BadRequest());
}
public async Task <ActionResult> Save([FromBody] LikeDTO regionDTO)
{
if (ModelState.IsValid)
{
var region = await _likeService.Save(regionDTO);
return(Ok(region));
}
throw new Exception();
}
public async Task <UserSuccessLoginResponse> LoginAsync(UserLoginRequest request)
{
_logger.LogInfo(request.username + $" Attempts Login @{DateTime.Now}", "LoginAsync");
try
{
var finder = await _context.Users.Include(x => x.ArticleLiked).FirstOrDefaultAsync(x => x.Username == request.username);
if (finder == null)
{
_logger.LogInfo(request.username + " Login Denied reason: username does not exist", "LoginAsync");
return(null);
}
if (!VerifyPasswordHash(request.password, finder.PasswordHash, finder.PasswordSalt))
{
_logger.LogInfo(request.username + " Login Denied reason: password incorrect", "LoginAsync");
return(null);
}
List <LikeDTO> likes = new List <LikeDTO>();
foreach (var like in finder.ArticleLiked)
{
if (like.LikeStatus)
{
var current = new LikeDTO
{
ArticleUniqueId = like.ArticleUniqueId,
LikerUniqueId = like.LikerUniqueId,
LikeStatus = like.LikeStatus
};
likes.Add(current);
}
else
{
continue;
}
}
var result = new UserSuccessLoginResponse
{
ArticleLiked = likes,
Email = finder.Email,
Username = finder.Username,
UserUniqueIdentity = finder.UserUniqueIdentity
};
_logger.LogInfo(request.username + " Login Successful", "LoginAsync");
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex.Message + " " + "Inner Exception" + ex.InnerException.Message, " AuthenticationRepositoryLoginAsync");
throw;
}
}
public async Task Like(LikeDTO model)
{
var isLiked = await _unitOfWork.Like.FirstOrDefault(x => x.AppUserId == model.AppUserId && x.PostId == model.PostId);
if (isLiked == null)
{
var like = _mapper.Map <LikeDTO, Like>(model);
await _unitOfWork.Like.Add(like);
await _unitOfWork.Commit();
}
}
// Get likes
/// <summary>
/// Gets like data for a UserPage
/// </summary>
/// <param name="pageId">The page's database id</param>
/// <param name="userId">The user's database id</param>
/// <returns>A LikeDTO object</returns>
public async Task <LikeDTO> GetPageLikes(int pageId, string userId)
{
var likes = await _context.PageLikes.Where(x => x.PageId == pageId).ToListAsync();
LikeDTO likeDTO = new LikeDTO()
{
NumberOfLikes = likes.Count,
UserLiked = UserLiked(likes, userId)
};
return(likeDTO);
}
public async Task Like(LikeDTO likeDTO)
{
var isLiked = await _unitOfWork.LikeRepository.FirstOrDefault(x => x.AppUserId == likeDTO.AppUserId && x.TweetId == likeDTO.TweetId);
if (isLiked == null)
{
var like = _mapper.Map <LikeDTO, Like>(likeDTO);
await _unitOfWork.LikeRepository.Add(like);
await _unitOfWork.Commit();
}
}
public async Task Like(LikeDTO likeDTO)
{
var isLiked = await _unitOfWork.LikeRepository.FirstOrDefault(x => x.AppUserId == likeDTO.AppUserId && x.TweetId == likeDTO.TweetId);//DTO dan gelen ile veritabanınadakı birbirine denk mi
if (isLiked == null)
{
var like = _mapper.Map <LikeDTO, Like>(likeDTO);
await _unitOfWork.LikeRepository.Add(like);
await _unitOfWork.Commit();
}
}
public bool dislike(PostDTO post, string UserID, LikeDTO like)
{
if (checkLike(UserID, post.PostID.ToString()) == true)
{
like.Username.Remove(UserID);
like.like--;
Likes.UpdateOne(Builders <LikeDTO> .Filter.Eq("_id", post.PostID), Builders <LikeDTO> .Update.Set("Username", like.Username));
Likes.UpdateOne(Builders <LikeDTO> .Filter.Eq("_id", post.PostID), Builders <LikeDTO> .Update.Set("like", like.like));
return(true);
}
return(true); //in case it was not liked
}
/// <summary>
/// Maps like DTO to like view model.
/// </summary>
public static LikeViewModel Map(LikeDTO item)
{
if (item == null)
{
return(null);
}
return(new LikeViewModel
{
Id = item.Id,
Date = item.Date.ToString("MMMM dd, yyyy"),
Owner = UsersMapper.Map(item.Owner)
});
}
public int LikeArticle(LikeDTO like)
{
var article = Context.Articles.Include(x => x.Likes).First(x => x.Id == like.ArticleId);
article.Likes.Add(new Like
{
Id = like.Id,
ArticleId = like.ArticleId,
LikeInstant = like.LikeDate
});
Context.Update(article);
Context.SaveChanges();
return(article.Likes.Count);
}
/// <summary>
/// Maps like DTO to like view model.
/// </summary>
public static LikeViewModel ToViewModel(this LikeDTO item)
{
if (item == null)
{
return(null);
}
return(new LikeViewModel
{
Id = item.Id,
Date = item.Date.ToString("MMMM dd, yyyy"),
Owner = item.Owner.ToViewModel()
});
}
public LikeDTO LikeToDto(Like like)
{
if (like == null)
{
return(null);
}
LikeDTO likeDto = new LikeDTO
{
Id = like.Id,
User_id = like.User_id,
Event_id = like.Event_id
};
return(likeDto);
}
public JsonResult GetNotif()
{
int id = userDb.GetByName(HttpContext.User.Identity.Name).ID;
List <Article> UserArticles = artdb.GetByExp(x => x.UserID == id);
int likeCount = 0;
foreach (var item in UserArticles)
{
likeCount += item.Likes.Count;
}
LikeDTO dt = new LikeDTO();
dt.LikeCount = likeCount;
return(Json(dt, JsonRequestBehavior.AllowGet));
}
public void UnLike(int post_id, LikeDTO like)
{
try
{
var client = new MongoClient(_conn);
var db = client.GetDatabase(_DbName);
var posts = db.GetCollection <PostDTO>("Posts");
var UpdateFilter = Builders <PostDTO> .Update.Pull("Likes", like);
posts.UpdateOne(g => g.PostId == post_id, UpdateFilter);
}
catch (Exception exp)
{
throw exp;
}
}
public IActionResult GiveLike(LikeDTO like)
{
var userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;
if (userId == null)
{
return(Unauthorized());
}
var likeToCreate = new Like
{
CommentId = like.CommentId,
LikerId = userId
};
repository.Insert(likeToCreate);
return(Ok());
}
public async Task <IHttpActionResult> RemoveLike(int id)
{
LikeDTO likeDTO = new LikeDTO
{
PhotoId = id,
UserId = User.Identity.GetUserId()
};
var result = await LikeService.RemoveLike(likeDTO);
if (result.Succedeed)
{
return(Ok());
}
else
{
return(BadRequest(result.Message));
}
}
public void LikePost(LikeDTO likeDto)
{
var like = _unitOfWork.Likes.Query.Where(x => x.PostId == likeDto.PostId && x.OwnerId == likeDto.OwnerId).FirstOrDefault();
if (like == null)
{
Mapper.Initialize(cfg => cfg.CreateMap <LikeDTO, Like>());
like = Mapper.Map <LikeDTO, Like>(likeDto);
like.Owner = _unitOfWork.UserManager.FindById(likeDto.OwnerId);
like.Post = _unitOfWork.Posts.GetById(likeDto.PostId);
_unitOfWork.Likes.Create(like);
}
else
{
_unitOfWork.Likes.Delete(like.Id);
}
_unitOfWork.Save();
}
public async Task AddLike(int shirtId, string email)
{
var user = await _userManager.FindByEmailAsync(email);
var likeDto = new LikeDTO
{
AuthorName = user.DisplayName,
ShirtId = shirtId
};
var like = _mapper.Map <Like>(likeDto);
like.UserId = user.Id;
_repositoryManager.Like.CreateLike(like);
await _repositoryManager.SaveAsync();
await _hub.Clients.All.SendAsync("Like Added", like);
}
public IHttpActionResult Like(LikeDTO like)
{
ResponseMessage response = new ResponseMessage();
if (like.Validate() == false)
{
response.Code = 400;
response.Body = "Event has not been liked.";
}
if (_service.Like(like.Event_id))
{
response.Code = 201;
response.Body = "Event has been liked.";
}
else
{
response.Code = 200;
response.Body = "Event has not been liked.";
}
return(Json(response));
}
public bool Save(LikeDTO likeDTO)
{
Like like = new Like
{
User_id = likeDTO.User_id,
Event_id = likeDTO.Event_id
};
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
unitOfWork.LikeRepo.Insert(like);
unitOfWork.Save();
};
return(true);
}
catch
{
return(false);
}
}
public ActionResult LikePost(int postId)
{
try
{
var postDto = _postService.GetById(postId);
LikeDTO likeDto = new LikeDTO
{
OwnerId = User.Identity.GetUserId <int>(),
PostId = postId
};
_postService.LikePost(likeDto);
var postDtoUpdate = _postService.GetById(postId);
Mapper.Initialize(cfg => cfg.CreateMap <PostDTO, PostViewModel>());
var postViewModel = Mapper.Map <PostDTO, PostViewModel>(postDtoUpdate);
return(PartialView("_LikeButton", postViewModel));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
