public async Task <ActionResult> MessagePost(string name, string message)
{
//TelemetryClient.TrackTrace(name + " says: '" + message + "'");
await messageRepository.AddMessageAsync(name, message, Request.UserHostAddress);
var responseUrl = Request.Url.AbsoluteUri.Split('?').First();
return(Redirect($"{responseUrl}?{Query.MessageKey}={Query.MessageSentValue}"));
}
public async Task AddMessageAsync(string content, Guid userId, Guid conversationId)
{
var user = await _userRepository.GetAsync(userId);
var conversation = await _conversationRepository.GetAsync(conversationId);
var message = new Message(content, user, conversation);
await _messageRepository.AddMessageAsync(message);
}
public async Task <SendMessagePayload> SendMessageAsync(
SendMessageInput input,
[Service] IMessageRepository repository,
[Service] ITopicEventSender sender)
{
var message = new Message(input.Text);
await repository.AddMessageAsync(message);
await sender.SendAsync("AllMessages", message);
return(new SendMessagePayload(message, input.ClientMutationId));
}
public async Task <IActionResult> Create([Bind("IdMessage,Name,Description,PostingDate1,IdCategory,IdRegion")] Message message)
{
if (ModelState.IsValid)
{
await _messageRepository.AddMessageAsync(message);
return(RedirectToAction(nameof(Index)));
}
PopulateMessage(message.IdRegion, message.IdCategory);
return(View(message));
}
public async Task <SendMessagePayload> SendMessageAsync(
SendMessageInput input,
FieldNode field,
[GlobalState] string currentUserEmail,
PersonByEmailDataLoader personByEmail,
[Service] IMessageRepository messageRepository,
[Service] IEventDispatcher eventDispatcher,
CancellationToken cancellationToken)
{
IReadOnlyList <Person> participants =
await personByEmail.LoadAsync(
cancellationToken, currentUserEmail, input.RecipientEmail)
.ConfigureAwait(false);
if (participants[1] is null)
{
throw new QueryException(
ErrorBuilder.New()
.SetCode("UNKNOWN_RECIPIENT")
.SetMessage("The given recipient id is invalid.")
.AddLocation(field.Arguments[0])
.Build());
}
Person sender = participants[0];
Person recipient = participants[1];
var message = new Message(
sender.Id,
recipient.Id,
input.Text);
await messageRepository.AddMessageAsync(
message, cancellationToken)
.ConfigureAwait(false);
await eventDispatcher.SendAsync(
recipient.Email, message, cancellationToken)
.ConfigureAwait(false);
return(new SendMessagePayload(
sender,
recipient,
message,
input.ClientMutationId));
}
public async Task <ActionResult> AddMessage(Guid userId, [FromBody] MessageToAdd message)
{
if (message == null && userId != Guid.Empty)
{
return(NotFound());
}
if (!_userRepository.CheckIfUserExists(message.ToWho) || !_userRepository.CheckIfUserExists(userId))
{
return(NotFound());
}
var messageToAdd = _mapper.Map <Message>(message);
messageToAdd.FromWho = userId;
await _messageRepository.AddMessageAsync(messageToAdd);
return(NoContent());
}
public async Task <IActionResult> CreateMessage([FromBody] Message message)
{
try
{
IActionResult result = null;
if (message == null)
{
return(BadRequest($"The message is invalid (null)"));
}
if (message.Id <= 0)
{
return(BadRequest($"The message id is invalid. Id must be greater than zero"));
}
if (await _repository.GetMessageByIdAsync(message.Id) == null)
{
result = this.CreatedAtRoute(
routeName: "Default",
value: await _repository.AddMessageAsync(
new Message()
{
Id = message.Id,
Name = message?.Name,
Body = message?.Body
}
)
);
}
else
{
result = BadRequest($"The message with {message.Id} already exists");
}
return(result);
}
catch (Exception ex)
{
throw new MessagesDomainException("An error caused an exception", ex);
}
}
public async Task <IActionResult> Create(MessageViewModel messageViewModel)
{
if (ModelState.IsValid)
{
var result = await validator.ValidateCreationAsync(messageViewModel);
if (result.Succeeded)
{
var message = await mapper.FromViewModelAsync(messageViewModel);
var encrypt = encryptor.EncryptMessage(messageViewModel.Message, messageViewModel.Key);
message.Value = encrypt.Value;
message.IV = encrypt.IV;
await repository.AddMessageAsync(message);
return(RedirectToAction(nameof(Success), new { Id = message.Code }));
}
ModelState.AddModelError("", result.Description);
}
return(View());
}
public async Task <IActionResult> Index([Bind("IdMessage,Name,Description,PostingDate1,IdCategory,IdRegion")] Message message)
{
var id = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
AppUser appUser = await _appDbContext.Users
.Include(i => i.PermissionRegions)
.ThenInclude(i => i.Region)
.Where(i => i.Id == id)
.FirstOrDefaultAsync(m => m.Id == id);
if (ModelState.IsValid)
{
message.PostingDate1 = DateTime.Now;
if (appUser.PermissionRegions.Where(p => p.Region.IdRegion == message.IdRegion).Any() || HttpContext.User.IsInRole("Admin"))
{
await _messageRepository.AddMessageAsync(message);
}
return(RedirectToAction(nameof(Index)));
}
PopulateMessage(appUser, message.IdRegion, message.IdCategory);
return(View(message));
}
public async Task <ActionResult> ReceiveMessage([FromForm, Required] string body, [FromForm, Required] string from)
{
try
{
if (String.IsNullOrWhiteSpace(AppConfiguration.MessageToNumber))
{
throw new InvalidOperationException("The message 'To' number is missing.");
}
var item = await _messageRepository.AddMessageAsync(new Models.Message {
From = from, Body = body, To = AppConfiguration.MessageToNumber
});
await _messageHubContext.Clients.All.SendAsync("SmsReceived", item);
return(Ok());
// TODO: find out why there is no XML formatter for CreatedAtActionResult().
//return CreatedAtAction(nameof(GetMessgeById), item.Id);
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <SendMessageResult> SendMessageAsync(Message message)
{
try
{
Dictionary <string, byte[]> keys = null;
string text = message.Text;
await messageRepository.AddMessageAsync(message);
if (EncryptionEnabled)
{
var deviceIdAndPublicKeyMap = await deviceInfoProvider.GetUserDevicesAndPublicKeys((int)message.Recipient);
if (deviceIdAndPublicKeyMap.Count > 0)
{
//don't forget current user's other devices
var myDevices = await deviceInfoProvider.GetUserDevicesAndPublicKeys(Settings.MyId);
foreach (var myDevice in myDevices)
{
if (myDevice.Key != Settings.UserDeviceId && myDevice.Key != Settings.MyId.ToString())
{
deviceIdAndPublicKeyMap[myDevice.Key] = myDevice.Value;
}
}
text = cryptoService.Encrypt(message.Text, deviceIdAndPublicKeyMap, out keys);
}
}
var request = new SendMessageRequest
{
ReceiverUserId = message.Recipient,
SenderName = Settings.NickName,
MessageType = ServerClient.Entities.Ws.Requests.MessageType.Text,
MessageToken = message.MessageToken,
Thumbnail = message.Thumbnail,
GroupId = message.GroupId,
Message = text,
Keys = keys,
};
var response = await messagingService.SendMessage(request);
if (response.Error == Errors.SendMessage_ProvideKeysForTheseDevices)
{
foreach (var item in response.MissedDevicesWithPublicKeysToReEncrypt)
{
await deviceInfoProvider.SavePublicKeyForDeviceId(item.DeviceId, item.UserId, Convert.ToBase64String(item.PublicKey));
}
//try again
return(await SendMessageAsync(message));
}
if (response.Error == Errors.SendMessage_ReceiversNotFound)
{
return(SendMessageResult.ReceiverUnknown);
}
if (response.Error == Errors.SendMessage_ReceiverAndSenderAreSame)
{
return(SendMessageResult.ReceiverAndSenderAreSame);
}
OnMessageSent(message.MessageToken);
return(SendMessageResult.Ok);
}
catch (ConnectionException)
{
return(SendMessageResult.ConnectionError);
}
catch (Exception ex)
{
App.Logger.Report(ex);
return(SendMessageResult.UnknownError);
}
}
public Task AddMessage([FromRoute] string messageBoardId, [FromBody] GameMessage message) => _chatRepository.AddMessageAsync(messageBoardId, message);
