protected override void RemoveActivityAction(ActivityAction action)
{
base.RemoveActivityAction(action);
Likes.RemoveForResource(action.action_id);
Comments.RemoveForResource(action.action_id);
RemoveRefActions(action);
}
/// <summary>
/// Add Like to a Photo
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult SumLike(int id)
{
var ph = db.Photo.Find(id);
var likes = ph.PH_Favourites + 1;
ph.PH_Likes = likes;
int usuario = Convert.ToInt32(Session["UserId"]);
var likeadd = new Likes();
likeadd.LIK_PH_Id = id;
likeadd.LIK_US_Id = usuario;
likeadd.LIK_ButtonLike = false;
ViewBag.buttonLike = false;
try
{
db.Likes.Add(likeadd);
db.Entry(ph).State = EntityState.Modified;
db.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e);
RedirectToAction("ErrorPage", "Error");
}
addToNotifications(id, 3);
return(RedirectToAction("PhotoViewer", "Photo", new { id = id }));
}
protected override void RemoveRecordFromTable(object refRecord)
{
Like like = refRecord as Like;
activity.Reactions[like.reaction]--;
Likes.Remove(like.poster_id, like.resource_id);
}
public ActionResult Like(int id, int u_id)
{
if (ModelState.IsValid)
{
var likeconnn = db.LikeConns.Where(x => x.Blog_Id == id && x.User_id == u_id).FirstOrDefault();
if (likeconnn != null)
{
Likes Like = db.LikeConns.Where(x => x.User_id == u_id && x.Blog_Id == id).FirstOrDefault();
db.LikeConns.Attach(Like);
Like.IsLiked = true;
db.SaveChanges();
TempData["msg"] = "Thank you for a like!!";
ModelState.Clear();
return(RedirectToAction("Index", "Dashboard"));
}
else
{
Likes Like = new Likes();
db.LikeConns.Add(Like);
Like.Blog_Id = id;
Like.User_id = u_id;
Like.IsLiked = true;
db.SaveChanges();
TempData["msg"] = "Thank you for a like!!";
ModelState.Clear();
return(RedirectToAction("Index", "Dashboard"));
}
}
return(RedirectToAction("BlogPost", new { id }));
}
public void CommentLike(string userId, int commentId,
string likeSpan, string dislikeSpan)
{
Likes like = repository.Likes
.FirstOrDefault(l => l.For == "Comment" && l.ForId == commentId &&
l.UserId == userId);
if (like == null)
{
like = new Likes
{
For = "Comment",
ForId = commentId,
UserId = userId
};
repository.AddLike(like);
//notification
_ = ShowNotification(userId, commentId);
}
else
{
repository.DeleteLike(like.Id);
}
_ = CommentLikesDislikesInitial(userId, commentId, likeSpan, dislikeSpan);
}
public async Task <bool> SaveLike(Likes like)
{
bool isLikeSaved = false;
try
{
var likeRegistered = await GetLikeDetails(like);
if (likeRegistered != null)
{
return(await DeleteLike(like));
}
await _context.Likes.AddAsync(like);
await _context.SaveChangesAsync();
isLikeSaved = true;
}
catch (Exception)
{
throw;
}
return(isLikeSaved);
}
public IActionResult LikeAct(string id)
{
var post = (from s in _context.Files
where s.DocumentId.Equals(id) select s).FirstOrDefault <Files>();
var currStd = HttpContext.Session.GetObject <Student>("student");
var like = (from l in _context.Likes
where l.DocumentId.Equals(id) &&
l.StudentId.Equals(currStd.Id) select l).FirstOrDefault <Likes>();
if (like != null)
{
_context.Likes.Remove(like);
post.Likes -= 1;
_context.Files.Update(post);
}
else
{
var objLike = new Likes()
{
DocumentId = id,
StudentId = currStd.Id
};
_context.Likes.Add(objLike);
post.Likes += 1;
_context.Files.Update(post);
}
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult RetVoteComent(int idDisc, int idComent, string btnAction)
{
string option = btnAction.ToString();
var userId = User.Identity.GetUserId();
Discussoes discs = db.Discussoes.Find(idDisc);
//seleciona os LIKES e DISLIKES do COMENTARIO com o id igual ao id passado por parâmetro
Likes li = db.Likes.Select(x => x).Where(x => x.DiscussaoFK == idDisc).Where(x => x.ComentarioFK == idComent).Where(x => x.UtilizadorFK == userId).FirstOrDefault();
Dislikes dis = db.Dislikes.Select(x => x).Where(x => x.DiscussaoFK == idDisc).Where(x => x.ComentarioFK == idComent).Where(x => x.UtilizadorFK == userId).FirstOrDefault();
switch (option)
{
case "likesComent":
discs.likes = discs.likes - 1;
db.Likes.Remove(li);
db.SaveChanges();
break;
case "dislikesComent":
discs.dislikes = discs.dislikes - 1;
db.Dislikes.Remove(dis);
db.SaveChanges();
break;
}
return(RedirectToAction("PergDisc", "PergDisc", new { id = idDisc }));
}
public ActionResult Like(Likes like, int id)
{
ViewBag.stat = "Like";
var userid = User.Identity.GetUserId();
var user = db.Users.Single(u => u.Id == userid);
var checker_like = db.likes.SingleOrDefault(l => l.whichNote == id && l.user.Id == userid);
var like_var = new Likes {
user = user,
whichNote = id
};
if (checker_like == null)
{
//ViewBag.stat = "Like";
db.likes.Add(like_var);
db.SaveChanges();
return(RedirectToAction("Details", "Notes", new { id = id }));
}
else if (checker_like != null)
{
//ViewBag.stat = "dislike";
db.likes.Remove(checker_like);
db.SaveChanges();
return(RedirectToAction("Details", "Notes", new { id = id }));
}
return(View());
}
/// <summary>
/// Syncs 2 post, raising property change event if necessary
/// </summary>
/// <param name="newPost"></param>
public void SyncWithPost(ActivityPost newPost)
{
if (UpdatedTime != newPost.UpdatedTime)
{
UpdatedTime = newPost.UpdatedTime;
this.NotifyPropertyChanged(PropertyChanged, o => o.UpdatedTime);
}
if (string.Compare(Message, newPost.Message, StringComparison.OrdinalIgnoreCase) != 0)
{
Message = newPost.Message;
this.NotifyPropertyChanged(PropertyChanged, o => o.Message);
}
if (CanLike != newPost.CanLike)
{
CanLike = newPost.CanLike;
this.NotifyPropertyChanged(PropertyChanged, o => o.CanLike);
}
if (HasLiked != newPost.HasLiked)
{
HasLiked = newPost.HasLiked;
this.NotifyPropertyChanged(PropertyChanged, o => o.HasLiked);
}
if (!Likes.Equals(newPost.Likes))
{
Likes = newPost.Likes;
this.NotifyPropertyChanged(PropertyChanged, o => o.Likes);
}
if (CanComment != newPost.CanComment)
{
CanComment = newPost.CanComment;
this.NotifyPropertyChanged(PropertyChanged, o => o.CanComment);
}
if (CanRemoveComments != newPost.CanRemoveComments)
{
CanRemoveComments = newPost.CanRemoveComments;
this.NotifyPropertyChanged(PropertyChanged, o => o.CanRemoveComments);
}
if (CommentCount != newPost.CommentCount)
{
CommentCount = newPost.CommentCount;
Comments = newPost.Comments;
this.NotifyPropertyChanged(PropertyChanged, o => o.CommentCount);
}
else
{
if (Comments.Count > 0 && (newPost.Comments.Count != Comments.Count ||
(Comments[0].Time != newPost.Comments[0].Time ||
Comments[Comments.Count - 1].Time != newPost.Comments[Comments.Count - 1].Time)))
{
Comments = newPost.Comments;
}
}
}
public ActionResult RetVote(int id, string btnAction)
{
string option = btnAction.ToString();
var userId = User.Identity.GetUserId();
Discussoes discs = db.Discussoes.Find(id);
Likes li = db.Likes.Select(x => x).Where(x => x.DiscussaoFK == id).FirstOrDefault();
Dislikes dis = db.Dislikes.Select(x => x).Where(x => x.DiscussaoFK == id).FirstOrDefault();
switch (option)
{
case "likesDisc":
discs.likes = discs.likes - 1;
db.Likes.Remove(li);
Session["stateVoteDisc"] = false;
db.SaveChanges();
break;
case "dislikesDisc":
discs.dislikes = discs.dislikes - 1;
db.Dislikes.Remove(dis);
Session["stateVoteDiscDislike"] = false;
db.SaveChanges();
break;
}
return(RedirectToAction("PergDisc", "PergDisc", new { id = id }));
}
public JsonResult OnGetAddFavorite(int favorite, int postId)
{
try
{
Users user = new Users();
user = this.context.Users.Where(x => x.UserID == BitConverter.ToInt32(_session.Get("id"))).FirstOrDefault();
if (favorite == 1)
{
Likes like = new Likes();
like.Post = this.context.Posts.Where(x => x.PostID == postId).FirstOrDefault();
like.User = user;
this.context.Likes.Add(like);
Posts post = (from p in context.Posts where p.PostID == postId select p).FirstOrDefault();
post.PostLikeCount++;
}
else
{
Likes like = new Likes();
like = this.context.Likes.Where(x => x.User.UserID == user.UserID).Where(x => x.Post.PostID == postId).First();
this.context.Likes.Remove(like);
Posts post = (from p in context.Posts where p.PostID == postId select p).FirstOrDefault();
post.PostLikeCount--;
}
this.context.SaveChanges();
Likes = this.context.Likes.Where(x => x.User.UserID == user.UserID).ToList();
return(new JsonResult(true));
}
catch (Exception)
{
return(new JsonResult(false));
}
}
public IActionResult getStars(string star, string name)
{
Lection l = lS.getAuthorByLName(name);
if (!lkS.checkExistLike(uS.getUserbyName(User.Identity.Name).Id, lS.getLectionByName(name).Id))
{
Likes like = new Likes();
like.userStar = Convert.ToInt32(star);
like.LectionId = lS.getLectionByName(name).Id;
like.UserId = uS.getUserbyName(User.Identity.Name).Id;
lkS.addLike(like);
lkS.Save();
lS.likeLection(lS.getLectionByName(name).Id, lkS.getNowRating(lS.getLectionByName(name).Id));
lS.Save();
User user = uS.getUserById(l.UserId);
user.ammountStars++;
uS.plusStar(user);
uS.Save();
}
else
{
Likes like = lkS.getLikeById(uS.getUserbyName(User.Identity.Name).Id, lS.getLectionByName(name).Id);
like.userStar = Convert.ToInt32(star);
lkS.updateLike(like);
lkS.Save();
lS.likeLection(lS.getLectionByName(name).Id, lkS.getNowRating(lS.getLectionByName(name).Id));
lS.Save();
}
ViewBag.usName = uS.getUserNameById(l.UserId);
return(View("ShowLection", lS.getLectionByName(name)));
}
public async Task <IActionResult> LikeUser(int id, int recipientId)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var like = await _DatingRepository.GetLike(id, recipientId);
if (like != null)
{
return(BadRequest("already liked"));
}
if (await _DatingRepository.GetUser(recipientId) == null)
{
return(NotFound());
}
like = new Likes
{
LikerID = id,
LikeeID = recipientId
};
_DatingRepository.Add <Likes>(like);
if (await _DatingRepository.SaveAll())
{
return(Ok());
}
return(BadRequest("unable to like user"));
}
public IActionResult LikeConcept(int ConceptsId)
{
ViewBag.errors = new List <string>();
if (!loggedIn())
{
return(RedirectToAction("Index", "User"));
}
System.Console.WriteLine("****************************Inside Like Concept");
int?UsersId = HttpContext.Session.GetInt32("UserId");
var userlikes = _context.Likes.Include(a => a.Users).Include(a => a.Concepts).Where(a => a.UsersId == UsersId && a.ConceptsId == ConceptsId).ToList();
if (userlikes.Count > 0)
{
ViewBag.errors.Add("Can't like a post more than once");
ViewBag.name = HttpContext.Session.GetString("name");
ViewBag.Concepts = GetConcepts();
int?Id = HttpContext.Session.GetInt32("UserId");
ViewBag.UsersId = (int)Id;
return(View("Show"));
}
else
{
Concepts concept = _context.Concepts.SingleOrDefault(a => a.ConceptsId == ConceptsId);
Likes likes = new Likes {
UsersId = (int)UsersId,
ConceptsId = ConceptsId,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
};
_context.Likes.Add(likes);
concept.LikeCount += 1;
_context.SaveChanges();
return(RedirectToAction("Show"));
}
}
public async Task <IActionResult> AddLike(int id)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var comm = await db.Comments.FirstOrDefaultAsync(c => c.Id == id);
Likes like = new Likes
{
CommentsId = comm.Id,
User = user,
Comments = comm
};
var find = likesRepository.FindLike(user, comm);
if (find == null)
{
likesRepository.AddLike(like, comm);
}
else
{
likesRepository.RemoveLike(find, comm);
}
return(RedirectToAction("CommentsList", new { id = comm.CarLotId }));
}
public static bool Post(string guid, bool isComment, string key)
{
//check if its disliked
if (DislikeClass.CheckExistence(guid, isComment, key))
{
return(false);
}
//Check if there is already a like by the user
if (CheckExistence(guid, isComment, key))
{
//delete the like
Delete(guid, isComment, key);
return(false);
}
//post new like
Likes like = new Likes
{
Owner_Guid = key,
};
if (isComment)
{
like.Comment_Guid = guid;
}
else
{
like.Confess_Guid = guid;
}
like.Id = Logical.Setter(like.Id);
contextLite.Likes.Insert(like);
//context.Likes.InsertOne(like);
return(true);
}
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 News UpdateFromDto(NewsDto newsDto)
{
if (newsDto == null)
{
return(this);
}
NewsId = newsDto.newsId;
AuthorId = newsDto.authorId;
Title = newsDto.title;
Body = newsDto.body;
Date = newsDto.date.UnixTimestampToDateTime();
Type = newsDto.type;
// Not recreating list in case of situation if somoene is holding list's reference during update
Likes.Clear();
Likes.AddRange(newsDto.likes);
// Same thing here
Comments.Clear();
if (newsDto.comments != null)
{
Comments.AddRange(newsDto.comments.Select(commentDto => commentDto.commentId));
}
// For fluent interface purposes
return(this);
}
public ActionResult AddDisLike(string username)
{
if (username == User.Identity.Name)
{
return(RedirectToAction("ViewProfile", new { Username = username }));
}
using (UsersContext db = new UsersContext())
{
int userIdMe = WebSecurity.GetUserId(User.Identity.Name);
int userIdTo = WebSecurity.GetUserId(username);
Likes tempLike = db.Likes.Where(m => m.From == userIdMe && m.To == userIdTo).FirstOrDefault();
if (tempLike != null)
{
if (tempLike.LikeOrDislike == true)
{
tempLike.LikeOrDislike = false;
}
else
{
db.Likes.Remove(tempLike);
}
db.SaveChanges();
}
else
{
db.Likes.Add(new Likes {
From = userIdMe, To = userIdTo, LikeOrDislike = false
});
db.SaveChanges();
}
}
return(RedirectToAction("ViewProfile", new { Username = username }));
}
//AlterLikePlant allows to like a plant with given plant ID.
public bool AlterLikePlant(AlterLikeModel model)
{
if (ctx.Likes.Where(e => e.PlantID == model.PlantID && e.UserID == _userID).Count() < 1)
{
Likes likes = new Likes
{
IsLiked = true,
PlantID = model.PlantID,
UserID = _userID,
CreatedDate = DateTimeOffset.UtcNow,
};
ctx.Likes.Add(likes);
}
else
{
bool isLiked = ctx.Likes.Single(e => e.PlantID == model.PlantID && e.UserID == _userID).IsLiked;
if (isLiked)
{
ctx.Likes.Single(e => e.PlantID == model.PlantID && e.UserID == _userID).IsLiked = false;
ctx.Likes.Single(e => e.PlantID == model.PlantID && e.UserID == _userID).ModifiedDate = DateTimeOffset.UtcNow;
}
else
{
ctx.Likes.Single(e => e.PlantID == model.PlantID && e.UserID == _userID).IsLiked = true;
ctx.Likes.Single(e => e.PlantID == model.PlantID && e.UserID == _userID).ModifiedDate = DateTimeOffset.UtcNow;
}
}
return(ctx.SaveChanges() == 1);
}
public async Task <IActionResult> PutLikes([FromRoute] int id, [FromBody] Likes likes)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != likes.IdLike)
{
return(BadRequest());
}
_context.Entry(likes).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LikesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Like(string id, string actn)
{
Likes lk = new Likes();
actn = actn.ToLower();
string result = string.Empty;
if (actn == "like")
{
var s = lk.LikeMedia(id, HttpContext.User.Identity.Name);
if (s.meta.code == "200")
{
result = "liked";
}
}
else if (actn == "unlike")
{
var s = lk.UnlikeMedia(id, HttpContext.User.Identity.Name);
if (s.meta.code == "200")
{
result = "unliked";
}
}
return(Content(result));
}
public static async void LikeInsta(InstaSharp.Models.Media selectedPost)
{
if (selectedPost != null)
{
var authInfo = new OAuth(_config);
var authResponse = new InstaSharp.Models.Responses.OAuthResponse();
var response = await _user.GetSelf();
authResponse.AccessToken = Access;
authResponse.User = response.Data;
var likes = new Likes(_config, authResponse);
if (selectedPost.UserHasLiked == true)
{
await likes.Delete(selectedPost.Id);
selectedPost.UserHasLiked = false;
await _metroWindow.ShowMessageAsync("Instagram", "Cofnięto Like'a!");
}
else
{
await likes.Post(selectedPost.Id);
selectedPost.UserHasLiked = true;
await _metroWindow.ShowMessageAsync("Instagram", "Dodano Like'a!");
}
}
else
{
await _metroWindow.ShowMessageAsync("", "Nie wybrano posta");
}
}
public Post LikeOrUnlikePost(int postId, int userId)
{
var user = _userRepository.GetUser(userId);
var post = GetPostById(postId);
bool alreadyLiked = false;
using (var connection = new SqliteConnection(_connectionString))
{
var sql = $"SELECT * FROM Likes WHERE Likes.PostId = @PostId";
var likes = connection.Query <Likes>(sql, post);
likes.ToList();
foreach (var prop in likes)
{
if (prop.UserId == user.UserId)
{
alreadyLiked = true;
}
}
if (!alreadyLiked)
{
var newLike = new Likes(user.UserId, post.PostId);
var sqlTwo = $"INSERT INTO Likes (UserId, PostId) VALUES(@UserId, @PostId)";
connection.Execute(sqlTwo, newLike);
return(post = GetPostById(newLike.PostId));
}
var sqlThree = $"DELETE FROM Likes WHERE UserId = @UserId";
connection.Execute(sqlThree, user);
return(post = GetPostById(postId));
}
}
public async Task UnlikeKwet_UnLikeSuccess_ReturnsUnlikedKwet()
{
var userGuid = Guid.NewGuid();
var likeUser = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var like = new Likes()
{
Name = "LikeUser",
userId = likeUser
};
kwet1.Likes.Add(like);
var kwetWithoutLikes = await _kwetRepository.Create(kwet1);
kwetWithoutLikes.Likes.Remove(like);
var result = await _kwetRepository.Update(kwetWithoutLikes);
Assert.Empty(result.Likes);
}
public IActionResult AddLike(Likes newLike, int addLikePostID, int likeUserID)
{
List <Likes> allLikes = _context.likes.Where(like => like.posts_id == addLikePostID).ToList();
foreach (var like in allLikes)
{
if (like.users_id == likeUserID)
{
return(RedirectToAction("Success"));
}
}
//Session User ID
int?signIn = HttpContext.Session.GetInt32("LoggedInUser");
ViewBag.signedIn = signIn;
if (signIn == null)
{
return(View("Index"));
}
newLike.users_id = likeUserID;
newLike.posts_id = addLikePostID;
_context.Add(newLike);
_context.SaveChanges();
return(RedirectToAction("Success"));
}
public async Task LikeKwet_UpdateSuccess_ReturnsLikedKwet()
{
var userGuid = Guid.NewGuid();
var likeUser = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var like = new Likes()
{
Name = "LikeUser",
userId = likeUser
};
var kwetWithLikes = kwet1;
kwetWithLikes.Likes.Add(like);
await _kwetRepository.Create(kwet1);
var result = await _kwetRepository.Update(kwetWithLikes);
Assert.Single(result.Likes);
Assert.Equal(result.Likes[0].Name, like.Name);
Assert.Equal(result.Likes[0].userId, like.userId);
}
public async void ToLike(int num_of_likes, int bookId)
{
UserContext user_db = new UserContext();
var userName = User.Identity.GetUserName();
User user = await user_db.Users.FirstOrDefaultAsync(x => x.Login == userName); // UserId found
LikesContext likes_db = new LikesContext();
var real_num_of_likes = likes_db.Likes.ToArray().Length;
Books b = db.Books.FirstOrDefault(b => b.id == bookId);
// если в бд лайков не найден ни один лайк от пользователя
Likes like = new Likes()
{
id = (++real_num_of_likes),
book_id = bookId,
user_id = user.Id
};
likes_db.Likes.Add(like);
b.likes = num_of_likes;
await db.SaveChangesAsync();
await likes_db.SaveChangesAsync();
}
public async Task <IActionResult> LikeUser(int id, int recipientId)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var like = await _context.GetLikes(id, recipientId);
if (like != null)
{
return(BadRequest("you already liked the profile"));
}
if (await _context.Getuser(recipientId) == null)
{
return(NotFound());
}
like = new Likes {
LikerId = id,
LikeeId = recipientId
};
_context.Add <Likes>(like);
if (await _context.SaveAll())
{
return(Ok());
}
return(BadRequest("Failed to like user"));
}
