public void MessageReactionInitsWithNoArgs()
{
var messageReaction = new MessageReaction();
Assert.NotNull(messageReaction);
Assert.IsType <MessageReaction>(messageReaction);
}
public async Task <IActionResult> CreateMessageReaction([FromBody] MessageReactionForCreateDto messageReactionForCreateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var messageReactionForCreate = new MessageReaction
{
MessageId = messageReactionForCreateDto.Message.Id,
Message = await _repo.GetMessage(messageReactionForCreateDto.Message.Id,
messageReactionForCreateDto.User.Id),
UserId = messageReactionForCreateDto.User.Id,
User = await _repo.GetUser(messageReactionForCreateDto.User.Id),
Reaction = messageReactionForCreateDto.Reaction,
Created = DateTime.Now,
LastUpdated = DateTime.Now
};
var createdMessageReaction = await _repo.CreateMessageReaction(messageReactionForCreate);
var messageReactionForReturn = _mapper.Map <MessageReactionForDetailedDto>(createdMessageReaction);
return(Ok(messageReactionForReturn));
}
public async Task Verify_emittingCommand_on_reload()
{
var orderId = new OrderId(101);
var evt = new OrderPlaced(orderId);
await ApplyEventOnSaga(evt).ConfigureAwait(false);
var evt2 = new BillPrinted(orderId);
await ApplyEventOnSaga(evt2).ConfigureAwait(false);
var sagaId = _listener.GetCorrelationId(evt);
var changesets = await _persistence.EventStoreReadChangeset(sagaId).ConfigureAwait(false);
var changeset = changesets.Last();
Assert.That(changeset.Events.Length, Is.EqualTo(1), "Single event expected");
var @event = changeset.Events.Single();
Assert.That(@event, Is.InstanceOf <MessageReaction>(), "We are expecting a messagereaction as payload");
MessageReaction reaction = (MessageReaction)@event;
Assert.That(reaction.MessagesOut.Length, Is.EqualTo(0), "Bill printed does not have out events");
}
public async Task <MessageReaction> CreateMessageReaction(MessageReaction messageReaction)
{
await _context.MessageReactions.AddAsync(messageReaction);
await _context.SaveChangesAsync();
return(messageReaction);
}
public void MessageReactionInits()
{
var type = "like";
var messageReaction = new MessageReaction(type);
Assert.NotNull(messageReaction);
Assert.IsType <MessageReaction>(messageReaction);
Assert.Equal(type, messageReaction.Type);
}
private async Task AddReactionToMessageCommonAsync(int messageId, string emojiColons, int userId)
{
var messageReaction = await _context.MessageReactions.SingleOrDefaultAsync(mr => mr.MessageId == messageId && mr.EmojiColons == emojiColons);
if (messageReaction == null)
{
messageReaction = new MessageReaction(messageId, emojiColons);
_context.MessageReactions.Add(messageReaction);
await _context.SaveChangesAsync();
}
var messageReactionUser = new MessageReactionUser(messageReaction.Id, userId);
_context.MessageReactionUsers.Add(messageReactionUser);
await _context.SaveChangesAsync();
}
public void Update(MessageReactionAddJsonModel model)
{
var emoji = Emoji.Create(model.Emoji);
var reactions = Reactions;
if (!reactions.HasValue)
{
var newReactions = new Dictionary <IEmoji, MessageReaction>();
newReactions.Add(emoji, new MessageReaction(emoji, 1, model.UserId == Client.CurrentUser.Id));
Reactions = new Optional <IReadOnlyDictionary <IEmoji, MessageReaction> >(newReactions.ReadOnly());
}
else
{
var newReactions = new Dictionary <IEmoji, MessageReaction>(reactions.Value);
var reaction = newReactions.GetValueOrDefault(emoji);
newReactions[emoji] = new MessageReaction(emoji, (reaction?.Count ?? 0) + 1, (reaction?.HasOwnReaction ?? false) || model.UserId == Client.CurrentUser.Id);
Reactions = newReactions;
}
}
public void Update(MessageReactionRemoveJsonModel model)
{
var reactions = Reactions;
if (reactions.HasValue)
{
var emoji = Emoji.Create(model.Emoji);
if (reactions.Value.TryGetValue(emoji, out var reaction))
{
var newReactions = new Dictionary <IEmoji, MessageReaction>(reactions.Value);
if (reaction.Count == 1)
{
newReactions.Remove(emoji);
}
else
{
newReactions[emoji] = new MessageReaction(emoji, reaction.Count - 1, reaction.HasOwnReaction && model.UserId == Client.CurrentUser.Id
? false
: reaction.HasOwnReaction);
}
Reactions = newReactions;
}
}
}
public Task <MessageReaction> AddReaction(Message Message, MessageReaction Reaction)
{
throw new NotImplementedException();
}
public Task <MessageReaction> FetchReactions(Message Message, MessageReaction Reaction, ReactionQueryOptions Options = null)
{
throw new NotImplementedException();
}
public Task <MessageReaction> DeleteReactions(Message Message, MessageReaction Reaction = null)
{
throw new NotImplementedException();
}
public Task <MessageReaction> DeleteReaction(Message Message, MessageReaction Reaction, long Target)
{
throw new NotImplementedException();
}
private Task RunAsync(PromptDataReaction data, MessageReaction reaction)
{
return(Task.CompletedTask);
}
//public ActionResult MakeUserInactive(int id)
//{
//}
public ActionResult ReactToMessage(int MessageId, React react)
{
Message message = db.Messages.Find(MessageId);
if (message == null)
{
return HttpNotFound();
}
var curUserId = db.Users.Single(s => s.UserName == User.Identity.Name).UserId;
bool hasMessageHasSameReact = (from mr in db.MessageReactions
where mr.MessageId == MessageId
where mr.React == react
where mr.UserId == curUserId
select mr).Count() == 1;
if (hasMessageHasSameReact) return RedirectToAction("Index");
MessageReaction messageReaction = new MessageReaction()
{
MessageId = MessageId,
UserId = curUserId,
React = react,
};
try
{
db.MessageReactions.Add(messageReaction);
db.SaveChanges();
}
catch
{
return View();
}
return View();
}
public async void SetReaction(MessageViewModel message, MessageReaction interaction, Reaction value)
{
if (Presenter == null)
{
_message = message;
_interaction = interaction;
_reaction = value;
return;
}
var recycled = _message?.Id == message.Id &&
_message?.ChatId == message.ChatId &&
_interaction?.Reaction == interaction.Reaction;
_message = message;
_interaction = interaction;
_reaction = value;
IsChecked = interaction.IsChosen;
AutomationProperties.SetName(this, string.Format(Locale.Declension("AccDescrNumberOfPeopleReactions", interaction.TotalCount, false), interaction.TotalCount, interaction.Reaction));
if (interaction.TotalCount > interaction.RecentSenderIds.Count)
{
Count ??= GetTemplateChild(nameof(Count)) as NumericTextBlock;
Count.Visibility = Windows.UI.Xaml.Visibility.Visible;
Count.Text = Converter.ShortNumber(interaction.TotalCount);
if (RecentChoosers != null)
{
RecentChoosers.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
}
}
else
{
RecentChoosers ??= GetRecentChoosers();
RecentChoosers.Visibility = Windows.UI.Xaml.Visibility.Visible;
var destination = RecentChoosers.Items;
var origin = interaction.RecentSenderIds;
if (destination.Count > 0 && recycled)
{
destination.ReplaceDiff(origin);
}
else
{
destination.Clear();
destination.AddRange(origin);
}
if (Count != null)
{
Count.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
}
}
var around = value.AroundAnimation?.StickerValue;
if (around != null && around.Local.CanBeDownloaded && !around.Local.IsDownloadingActive && !around.Local.IsFileExisting())
{
_message.ProtoService.DownloadFile(around.Id, 32);
}
var center = value.CenterAnimation?.StickerValue;
if (center == null || center.Id == _presenterId)
{
return;
}
_presenterId = center.Id;
if (center.Local.IsFileExisting())
{
Presenter.Source = await GetLottieFrame(center.Local.Path, 0, 32, 32);
}
else
{
Presenter.Source = null;
UpdateManager.Subscribe(this, _message, center, UpdateFile, true);
if (center.Local.CanBeDownloaded && !center.Local.IsDownloadingActive)
{
_message.ProtoService.DownloadFile(center.Id, 32);
}
}
}
