public async Task <IActionResult> Edit(int id, [Bind("ID,UserID,TemplateID,Favourite,Download")] UserReaction userReaction)
{
if (id != userReaction.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userReaction);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserReactionExists(userReaction.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["TemplateID"] = new SelectList(_context.Templates, "ID", "FilmName", userReaction.TemplateID);
ViewData["UserID"] = new SelectList(_context.Users, "ID", "Email", userReaction.UserID);
return(View(userReaction));
}
public async Task <ReactionShort> GetReactionsAsync(string publicationId, string author)
{
var reactions = new Dictionary <ReactionType, int>();
try
{
var response = await reactionsApi.GetAsync($"publication_{publicationId}");
reactions = response.Keys
.Select(k => (Enum.Parse <ReactionType>(k), response[k]))
.ToDictionary(o => o.Item1, o => o.Item2);
}
catch (ApiException)
{
// ignored
}
UserReaction userReaction = null;
if (author != null)
{
try
{
var reactionByAuthor = await reactionsApi.GetReactionByAuthorAsync($"publication_{publicationId}", author);
userReaction = new UserReaction(Enum.Parse <ReactionType>(reactionByAuthor.Type));
}
catch (ApiException ex) when(ex.ErrorCode == (int)HttpStatusCode.NotFound)
{
// ignored
}
}
return(new ReactionShort(reactions, userReaction));
}
public async Task <ActionResult <UserReaction> > PostReaction(int postId, UserReaction reactionDto)
{
if (!await PostExists(postId))
{
return(NotFound());
}
var reaction = _context.UserReactions
.Find(reactionDto.PostId, reactionDto.UserId);
if (reaction == null)
{
reaction = reactionDto;
_context.UserReactions.Add(reaction);
}
else
{
//override reaction type (consider a non-reaction type to delete reactions)
reaction.Type = reactionDto.Type;
_context.UserReactions.Update(reaction);
}
await _context.SaveChangesAsync();
await BroadcastPostUpdated(postId);
return(Ok());
}
void Start()
{
if (!spatial)
{
Debug.LogError("Null SMap");
}
corners = new List <GameObject> ();
_react = GetComponent <UserReaction>();
doneAdjusting = false;
}
public static FeedsIndexDoc ToFeedIndexDoc(this UserReaction reaction, string[] likedby, string[] sharedby)
{
var doc = new FeedsIndexDoc
{
Id = reaction.ArticleId,
LikedBy = likedby,
SharedBy = sharedby
};
return(doc);
}
public bool addReaction(UserReaction userreaction)
{
var output = databaseContext.userreaction.Where(d => d.AnswerId == userreaction.AnswerId && d.UserId == userreaction.UserId).ToList().Count();
if (output > 0)
{
return(false);
}
userreaction.CreationDate = DateTime.Now;
databaseContext.userreaction.Add(userreaction);
databaseContext.SaveChanges();
return(true);
}
public async Task <IActionResult> Create([Bind("ID,UserID,TemplateID,Favourite,Download")] UserReaction userReaction)
{
if (ModelState.IsValid)
{
_context.Add(userReaction);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TemplateID"] = new SelectList(_context.Templates, "ID", "FilmName", userReaction.TemplateID);
ViewData["UserID"] = new SelectList(_context.Users, "ID", "Email", userReaction.UserID);
return(View(userReaction));
}
public async Task <(IEnumerable <NewsFeedPublication>, long)> FindManyAsync(int skip, int take, string author)
{
var publicationsResponse = await publicationsApi.SearchWithHttpInfoAsync(skip, take, order : Ordering.Desc);
var publications = publicationsResponse.Data;
var newsFeedPublications = new List <NewsFeedPublication>(publications.Count);
foreach (var publication in publications)
{
var commentsResponse = await commentsApi.SearchWithHttpInfoAsync(publication.Id, 0, 3);
var reactions = new Dictionary <ReactionType, int>();
try
{
var response = await reactionsApi.GetAsync($"publication_{publication.Id}");
reactions = response.Keys
.Select(k => (Enum.Parse <ReactionType>(k), response[k]))
.ToDictionary(o => o.Item1, o => o.Item2);
}
catch (ApiException)
{
// ignored
}
UserReaction userReaction = null;
if (author != null)
{
try
{
var reactionByAuthor = await reactionsApi.GetReactionByAuthorAsync($"publication_{publication.Id}", author);
userReaction = new UserReaction(Enum.Parse <ReactionType>(reactionByAuthor.Type));
}
catch (ApiException ex) when(ex.ErrorCode == (int)HttpStatusCode.NotFound)
{
// ignored
}
}
newsFeedPublications.Add(new NewsFeedPublication(
publication.Id,
publication.Content,
new CommentsShort(commentsResponse.Data.Select(c => new PublicationComment(
c.Id, c.Content, c.PublicationId, c.AuthorId, c.CreatedOn)).ToList(), GetTotalCountHeader(commentsResponse)),
new ReactionShort(reactions, userReaction)));
}
return(newsFeedPublications, GetTotalCountHeader(publicationsResponse));
}
public async Task <ActionResult <UserReaction> > UserReaction(UserReaction userReaction)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid model"));
}
// userReaction.Favourite == false;
var x = _context.UserReactions.Where(c => c.UserID == userReaction.UserID && c.TemplateID == userReaction.TemplateID).FirstOrDefault();
var y = _context.UserReactions.Where(c => c.Favourite == false && c.Download == false).FirstOrDefault();
if (y != null)
{
_context.UserReactions.Remove(y);
await _context.SaveChangesAsync();
}
if (x != null)
{
if (x.Favourite == true)
{
x.Favourite = false;
}
else
{
x.Favourite = true;
}
// _context.Entry(userReaction).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
else
{
userReaction.Favourite = true;
_context.Add(userReaction);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserReaction", new { id = userReaction.ID }, userReaction));
}
return(x);
// return await _context.UserReactions.ToListAsync();
}
public async Task <ActionResult <UserReaction> > UnFav(UserReaction userReaction)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid model"));
}
// userReaction.Favourite == false;
var x = _context.UserReactions.Where(c => c.UserID == userReaction.UserID && c.TemplateID == userReaction.TemplateID).FirstOrDefault();
x.Favourite = false;
await _context.SaveChangesAsync();
return(x);
// return await _context.UserReactions.ToListAsync();
}
public async Task <ActionResult <UserReaction> > GetUserReaction(int id, int tempid)
{
var userReaction = await _context.UserReactions.FirstOrDefaultAsync(b => b.UserID == id && b.TemplateID == tempid);
if (userReaction == null)
{
var User = new UserReaction
{
UserID = id,
TemplateID = tempid
};
return(User);
}
return(userReaction);
}
public async Task <string[]> AddUserReaction([FromBody] UserReaction reaction)
{
try
{
var doc = await _feedsIndex.LookupDocument <FeedsIndexDoc>(reaction.ArticleId);
var likedby = doc.LikedBy.ToList();
var sharedby = doc.SharedBy.ToList();
bool likeOrShare = true;
switch (reaction.ReactionType)
{
case "Like":
likedby.Add(reaction.UserId); break;
case "UnLike":
likedby.Remove(reaction.UserId); break;
case "ReTweet":
sharedby.Add(reaction.UserId); likeOrShare = false; break;
case "UnReTweet":
sharedby.Remove(reaction.UserId); likeOrShare = false; break;
default: throw new Exception("Unknown Reaction Type");
}
var indexDoc = reaction.ToFeedIndexDoc(likedby.ToArray(), sharedby.ToArray());
var uploadedDoc = await _feedsIndex.UploadDocument(indexDoc);
if (uploadedDoc.Results.First().Succeeded)
{
if (likeOrShare)
{
return(likedby.ToArray());
}
else
{
return(sharedby.ToArray());
}
}
throw new Exception("Could not apply User Reaction");
}
catch (Exception e)
{
throw new Exception("Could not apply User Reaction");
}
}
public async Task UpdateReactionCount(Guid?id, UserReaction reaction)
{
var record = await Repository.GetByIDAysnc(id.Value);
if (record != null)
{
switch (reaction)
{
case UserReaction.Like:
record.LikeAmount = record.LikeAmount + 1;
break;
case UserReaction.Dislike:
record.DislikeAmount = record.DislikeAmount + 1;
break;
}
Repository.Update(record);
await CommitAsync();
}
}
public async Task <ActionResult> Send(Guid suggestionId, UserReaction reaction)
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
return(RedirectToAction("Register", "Authentication"));
}
bool isSuggestionExist = await _suggestionService.AnyAsync(suggestionId);
if (!isSuggestionExist)
{
return(RedirectToAction("Index", "Home"));
}
bool isAlreadyReacted = await _service.AnyAsync(a => a.CreateBy == user.Id && a.SuggestionId == suggestionId);
if (isAlreadyReacted)
{
return(RedirectToAction("Detail", "Suggestion", new { id = suggestionId }));
}
SuggestionReactionSaveVM model = new SuggestionReactionSaveVM()
{
SuggestionId = suggestionId,
Reaction = reaction
};
var result = await _service.AddAsync(model, user.Id);
if (result.IsSuccessful)
{
await _suggestionService.UpdateReactionCount(suggestionId, reaction);
}
return(RedirectToAction("Detail", "Suggestion", new { id = suggestionId }));
}
public async Task <ActionResult> AddReaction(int userReceivedId, bool positiveReaction)
{
var reactedUserId = User.GetUserId();
var reactedByUser = await _unitOfWork.UserRepository.GetUserByIdAsync(userReceivedId);
var reactedUser = await _unitOfWork.ReactionsRepository.GetUserWithReactions(reactedUserId);
if (reactedByUser == null)
{
return(NotFound());
}
var userReaction = await _unitOfWork.ReactionsRepository.GetUserReaction(reactedUserId, reactedByUser.Id);
if (userReaction != null)
{
return(BadRequest("You already liked this user"));
}
userReaction = new UserReaction
{
ReactedByUserId = reactedByUser.Id,
ReactedUserId = reactedUserId,
PositiveReaction = positiveReaction
};
reactedUser.ReactedUsers.Add(userReaction);
if (await _unitOfWork.Complete())
{
return(Ok());
}
return(BadRequest("Failed to react to user"));
}
public bool addReaction(UserReaction userreaction)
{
var output = userReactionOperation.addReaction(userreaction);
return(output);
}
private static ReactionShort ToReactionShort(Dictionary <string, int> response, UserReaction userReaction)
{
var reactions = response.Keys
.Select(k => (Enum.Parse <ReactionType>(k), response[k]))
.ToDictionary(o => o.Item1, o => o.Item2);
return(new ReactionShort(reactions, userReaction));
}
