public ActionResult SendMessage(int id, string chatMessage = null)
{
var myUser = userService.GetUserByEmail(HttpContext.User.Identity.Name);
if (chatMessage != null)
{
messageService.AddMessage(new BllMessage()
{
Date = DateTime.Now,
ProfileIdFrom = myUser.Id,
ProfileIdTo = id,
Text = chatMessage
});
}
var context = Microsoft.AspNet.SignalR.GlobalHost.ConnectionManager.GetHubContext <NotificationHub>();
var t = context.Clients.All;
var messages = messageService.GetMessages(myUser.Id, id);
var viewModel = new SendMessageModel()
{
Messages = messages,
I = profileService.Get(myUser.Id).ToViewProfileModel(),
Companion = profileService.Get(id).ToViewProfileModel()
};
if (!Request.IsAjaxRequest())
{
return(View(viewModel));
}
return(PartialView("_History", viewModel));
}
public async Task <ActionResult> IndexPost(SendMessageModel model)
{
ViewBag.ShowSuccess = false;
if (!ModelState.IsValid)
{
return(View(model));
}
var smtpClient = new SmtpClient(model.SmtpHost, model.SmtpPort)
{
Credentials = new NetworkCredential(model.UserName, model.Password)
};
var mailMessage = new MailMessage(model.EmailFrom, model.EmailTo)
{
Body = model.Body,
Subject = model.Subject,
IsBodyHtml = false
};
try
{
await smtpClient.SendMailAsync(mailMessage);
ViewBag.ShowSuccess = true;
}
catch (Exception exc)
{
ModelState.AddModelError(nameof(model.SmtpHost), exc);
}
return(View(model));
}
public ActionResult SendMessage(SendMessageModel message)
{
if (IsLogon() == false)
{
return(RedirectToAction("index", "i"));
}
DB.Messages mesaj = new Messages
{
Id = Guid.NewGuid(),
AddedDate = DateTime.Now,
IsRead = false,
Subject = message.Subject
};
var mRep = new DB.MessageReplies
{
Id = Guid.NewGuid(),
AddedDate = DateTime.Now,
Member_Id = CurrentUserId(),
Text = message.MessageBody
};
mesaj.MessageReplies.Add(mRep);
context.Messages.Add(mesaj);
context.SaveChanges();
return(RedirectToAction("i", "Mesage"));
}
public Task LeaveGroup(SendMessageModel model)
{
dataBase.LeaveRoom(model.ParticipantId, model.RoomName);
Groups.RemoveAsync(Context.ConnectionId, model.RoomName);
model.Message = model.NickName + " left " + model.RoomName;
return(SendMessage(model));
}
public async Task <IActionResult> SendMessage(SendMessageModel sendMessageModel)
{
var senderId = this.userManager.GetUserId(this.User);
var senderUserName = this.User.Identity.Name;
if (string.IsNullOrEmpty(sendMessageModel.Receiver) || string.IsNullOrWhiteSpace(sendMessageModel.Receiver))
{
this.ModelState.AddModelError(nameof(sendMessageModel.Receiver), GlobalConstants.MESSAGE_RECEIVER_REQUIRED);
return(this.View(sendMessageModel));
}
if (sendMessageModel.Receiver == senderUserName)
{
this.ModelState.AddModelError(nameof(sendMessageModel.Receiver), GlobalConstants.MESSAGE_RECEIVER_SAME_AS_SENDER);
return(this.View(sendMessageModel));
}
var receiver = await this.userManager.FindByNameAsync(sendMessageModel.Receiver);
if (receiver == null)
{
this.ModelState.AddModelError(nameof(sendMessageModel.Receiver), GlobalConstants.MESSAGE_RECEIVER_INVALID);
}
if (!ModelState.IsValid)
{
return(this.View(sendMessageModel));
}
await messagesService.SendMessageAsync(senderId, receiver.Id, sendMessageModel.Content);
return(this.RedirectToAction(nameof(Sent)));
}
// Відправка повідомлення від оператора до клієнта
public async Task <string> SetMessageToDB(SendMessageModel sendMessage)
{
// створюємо колекцію динамічних параметрів і додаємо параметри, для відправки повідомлення від оператора до клієнта
var parametrs = new DynamicParameters();
parametrs.Add("@sessionid", sendMessage.SessionId);
parametrs.Add("@MessageContent", sendMessage.MessageText);
parametrs.Add("@DateTime", sendMessage.DateTime);
parametrs.Add("@UserId", sendMessage.UserId);
//parametrs.Add("@UserEmail", sendMessage.UserEmail);
try
{
using (IDbConnection db = new SqlConnection(connectionString))
{
// отримуємо повідомлення, використовуємо хранімку Send_message_from_operator
// (вхідний параметри: sessionid, MessageContent, DateTime, UserId, які потрібні для відправки повідомлення
string result = await db.QuerySingleAsync <string>("[dbo].[Send_message_from_operator]", parametrs, commandType : CommandType.StoredProcedure);
return(result);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public IActionResult ReceiveMessage(SendMessageModel messageModel)
{
string filePublicKey = parameters.Value.FilesOutput + parameters.Value.PubKeyFile + messageModel.userNameDestination + messageModel.userNameOrigin;
RSAEncryption rsaEncryption = new RSAEncryption();
AESEncryption aesEncryption = new AESEncryption();
RSASigning rsaSigning = new RSASigning();
//Decrypt symmetric key
ResponseRSADecryption rsaDecryptResponse = new ResponseRSADecryption();
rsaDecryptResponse = rsaEncryption.DecryptAESKey(messageModel.encryptedKey, messageModel.userNameDestination + messageModel.userNameOrigin);
if (!rsaDecryptResponse.result)
{
FileWriter.WriteOnEvents(EventLevel.Error, "Error descifrando llave AES con RSA.");
return(BadRequest(new { result = false }));
}
//Decrypt Message
ResponseAESDecryption responseAESDecryption = new ResponseAESDecryption();
responseAESDecryption = aesEncryption.DecryptMessage(messageModel, rsaDecryptResponse.decryptedKey);
if (!responseAESDecryption.result)
{
FileWriter.WriteOnEvents(EventLevel.Error, "Error descifrando mensaje con AES.");
return(BadRequest(new { result = false }));
}
//Validate Sign
if (!rsaSigning.validateSignAndHash(responseAESDecryption.decryptedMessage, messageModel.encryptSignature, filePublicKey))
{
FileWriter.WriteOnEvents(EventLevel.Atention, "La información recibida es corrupta.");
return(BadRequest(new { result = false }));
}
//Muestra mensaje
return(Ok(new{ mensaje = responseAESDecryption.decryptedMessage }));
}
public async Task <IActionResult> SendMessage(SendMessageModel model)
{
var currentUser = await GetCurrentUserAsync();
if (ModelState.IsValid)
{
MessageSent message = new MessageSent()
{
Subject = model.Subject,
Content = model.Content,
DateSent = DateTime.Now,
UserEmail = currentUser.Email,
Year = currentUser.Year
};
database.Add(message);
database.SaveChanges();
return(View("SendMessageResult", model));
}
else
{
ModelState.AddModelError(string.Empty, "It wasn't possible to send your message.");
}
return(View(model));
}
public ActionResult SendMessage(SendMessageModel message)
{
//Giriş yapmayan kullanıcı bu sayfaya gelmemesi için en başta yönlendirme yaptık
if (IsLogon() == false)
{
return(RedirectToAction("Index", "i"));
}
DB.Messages mesaj = new DB.Messages()
{
Id = Guid.NewGuid(),
AddedDate = DateTime.Now,
IsRead = false,
Subject = message.Subject,
ToMemberId = message.ToUserId
};
var mRep = new DB.MessageReplies()
{
Id = Guid.NewGuid(),
AddedDate = DateTime.Now,
Member_Id = CurrentUserId(),
Text = message.MessageBody
};
mesaj.MessageReplies.Add(mRep);
context.Messages.Add(mesaj);
context.SaveChanges();
return(RedirectToAction("Index", "Message"));
}
public async Task <bool> SendMessage(string message, string receiverId)
{
var model = new SendMessageModel()
{
Receiver = receiverId,
Sender = new ViberSenderModel {
Name = "FCIT Computer Science Bot"
},
Text = message,
Type = "text"
};
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("X-Viber-Auth-Token", _apiOptions.AccessKey);
var content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8);
var response = await client.PostAsync(_apiOptions.Url + "/pa/send_message", content);
if (!response.IsSuccessStatusCode)
{
return(false);
}
return(true);
}
}
public async Task SendMessage(SendMessageModel message)
{
try
{
if (string.IsNullOrEmpty(_accessToken))
{
throw new Exception("Not logged in");
}
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var url = string.Format("{0}/api/message/send", _configuration.ServerBaseUrl);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _accessToken);
var response = await client.PostAsJsonAsync <SendMessageModel>(url, message);
if (!response.IsSuccessStatusCode)
{
throw new WebAPIException("An error occurred sending message", response.ReasonPhrase, response.StatusCode);
}
}
}
catch (Exception ex)
{
if (ex is WebAPIException)
{
throw;
}
throw new Exception("An error occurred sending message. " + ex.Message);
}
}
public IActionResult Index(SendMessageModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var factory = new ConnectionFactory()
{
HostName = model.HostName
};
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: model.QueueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var body = Encoding.UTF8.GetBytes(model.MessageBody);
channel.BasicPublish(
exchange: "",
routingKey: model.QueueName,
basicProperties: null,
body: body);
}
}
return(RedirectToAction(nameof(Success)));
}
public async Task <IActionResult> SendMessage(SendMessageModel model)
{
// Dohvatam ulogovanog usera
User loggedInUser = await this.userManager.GetUserAsync(base.User);
if (ModelState.IsValid)
{
// Pravim novu poruku
Message message = new Message( )
{
userId = loggedInUser.Id,
conversationId = model.conversationId,
sendDate = DateTime.Now,
content = model.content
};
// Stavljam poruku u bazu
await this.context.messages.AddAsync(message);
await this.context.SaveChangesAsync( );
}
// Vracam true da je poruka stavljena u bazu
return(Json(true));
}
public ActionResult Conversation(SendMessageModel send, ContactModel contact)
{
if (SessionUtils.IsLogged)
{
//SendMessageModel
send.IdUserFrom = SessionUtils.ConnectedUser.IdUser;
string idUserTo = Request.Path.Substring(26);
int idUserToInt = int.Parse(idUserTo);
send.IdUserTo = idUserToInt;
//ContactModel
contact.IdUserFrom = SessionUtils.ConnectedUser.IdUser;
contact.IdUserTo = idUserToInt;
if (ctx.SaveMessage(send))
{
ViewBag.SuccessMessage = "Your message has been sent";
List <MessageModel> lm = ctx.GetAllMessage(contact);
ConversationViewModel cv = new ConversationViewModel();
cv.ListeMessages = lm;
return(View(cv));
}
else
{
ViewBag.ErrorMessage = "Your message has not been sent, try again";
ConversationViewModel cv = new ConversationViewModel();
return(View(cv));
}
}
else
{
Session.Abandon();
return(RedirectToAction("Login", "Home", new { area = "" }));
}
}
public async Task <Response <SendReceipt> > SendMessageAsync <TData>(SendMessageModel <TData> message)
where TData : class
{
await GetQueueClient(message.QueueName);
return(await _queueClient.SendMessageAsync(message.Data.ToJson(IgnoredProperties)));
}
public IActionResult SendTextMessage(uint chatId, [FromBody] SendMessageModel model)
{
var sender = _userService.FindUser(User.Identity.Name);
var message = _chatService.SendTextMessage(sender, chatId, model.Text);
return(new JsonResult(message));
}
public async Task SendMessage_GivenInvalidModel_ReturnsErrorMessage(ServiceResponse <bool> expectedResult,
string expectedMessage)
{
// Arrange
_messageService.Setup(x => x.SendMessage(It.IsAny <SendMessageDto>())).ReturnsAsync(expectedResult);
var modelData = new SendMessageModel {
To = "", Content = ""
};
var controller = new MessagesController(_messageService.Object);
// Act
var result = await controller.SendMessage(modelData);
// Assert
var apiResult = Assert.IsType <ObjectResult>(result);
var model = Assert.IsAssignableFrom <ApiData <List <string> > >(apiResult.Value);
Assert.False(model.Success);
Assert.Equal("Model validation errors!", model.Message);
Assert.Equal(StatusCodes.Status400BadRequest, apiResult.StatusCode);
Assert.NotNull(model.Data);
Assert.Single(model.Data);
Assert.Equal(expectedMessage, model.Data.First());
}
//public ActionResult Details(string key)
//{
// var request = requestRepository.GetRequest(key);
// return View("KeyDetails", request);
//}
public ActionResult SendMessage(SendMessageModel message)
{
try
{
if (string.IsNullOrWhiteSpace(message.MessageText) && Request.Files.Count == 0)
{
Response.StatusCode = 400;
return(Content("Either a message or a file is required."));
}
if (Request.Files.Count > 0)
{
var uploadFile = Request.Files[0];
byte[] fileData = RequestRepository.ReadFully(uploadFile.InputStream);
requestRepository.AttachFileToRequest(message.KeyToken, fileData, uploadFile.FileName);
return(Content("<h1>File uploaded and sent to Key Id</h1>"));
}
else
{
requestRepository.AttachMessageToRequest(message.KeyToken, message.MessageText);
return(Content("<h1>Message encrypted and sent to Key Id</h1>"));
}
}
catch (Exception ex)
{
//Response.StatusCode = 401;
return(Content("Unable to send message. Please check the Key Id field."));
}
}
public ActionResult SendMessage(SendMessageModel sendMessageModel)
{
if (ModelState.IsValid)
{
try
{
var message = _messageService.GetByCode(sendMessageModel.Code);
Message result;
if (message != null)
{
message.MessageBody = sendMessageModel.MessageBody;
message.UpdatedDate = DateTime.UtcNow;
result = _messageService.Update(message);
}
else
{
message = Mapper.Map <SendMessageModel, Message>(sendMessageModel);
message.CreatedDate = DateTime.UtcNow;
message.UpdatedDate = DateTime.UtcNow;
result = _messageService.Create(message);
}
_messageService.SaveChanges();
var viewModel = Mapper.Map <Message, PageBViewModel>(result);
return(PartialView("PageBMessage", viewModel));
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, ex.Message));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Validation Error"));
}
internal ResponseAESDecryption DecryptMessage(SendMessageModel messageModel, byte[] decryptedKey)
{
ResponseAESDecryption response = new ResponseAESDecryption {
result = false
};
// Create an AesCryptoServiceProvider object with the specified key and IV.
using (AesCryptoServiceProvider aesDecrypt = new AesCryptoServiceProvider()){
FileWriter.WriteOnEvents(EventLevel.Info, "Inicio proceso de descifrado de mensaje.");
aesDecrypt.Key = decryptedKey;
aesDecrypt.IV = messageModel.initVector;
// Create a decryptor to perform the stream transform.
ICryptoTransform decryptor = aesDecrypt.CreateDecryptor(aesDecrypt.Key, aesDecrypt.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(messageModel.encryptedMessage))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
// Read the decrypted bytes from the decrypting stream and place them in a string.
response.decryptedMessage = srDecrypt.ReadToEnd();
response.result = true;
FileWriter.WriteOnEvents(EventLevel.Info, "Proceso de descifrado de mensaje finalizado correctamente");
}
}
}
}
return(response);
}
/// <summary>
/// Генерит jsonчик и отправляет его фейсбуку
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private async Task <int> Send(SendMessageModel model)
{
string jsonContent = JsonConvert.SerializeObject(model,
Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
jsonContent = BotTextHelper.SmileCodesReplace(jsonContent, SocialNetworkType.Facebook);
HttpResponseMessage responce;
StringContent content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
string url = $"https://graph.facebook.com/v2.6/me/messages?access_token={_token}";
using (var client = new HttpClient())
{
using (var r = await client.PostAsync(new Uri(url), content))
{
responce = r;
string responceString = await r.Content.ReadAsStringAsync();
if (responceString.ToLower().Contains("error"))
{
Logging.Logger.Error($"Facebook Api Send: NOT OK!! {responceString}");
return(1);
}
else
{
return(0);
}
}
}
}
public virtual async Task <ActionResult> SendMessageToUser(SendMessageModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var user = await UserManager.FindByEmailAsync(model.Recipient);
if (user != null)
{
await _notificationsService.SendNotificationAsync(user.Id, model.Message, null, false);
}
else
{
ModelState.AddModelError("", _localizationService.GetResource("RequestedUserNotFound"));
return(View(model));
}
}
catch (Exception e)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(e, System.Web.HttpContext.Current));
ModelState.AddModelError("", string.Format(_localizationService.GetResource("ErrorOnOperation"), e.Message, errorCode));
return(View(model));
}
return(Content(@"<script language='javascript' type='text/javascript'>
window.close();
window.opener.refreshNotificationsGrid();
</script>"));
}
public ActionResult Index()
{
SendMessageModel model = new SendMessageModel();
model.LoadSecurityQuestion();
return(View(model));
}
private bool IsSendMessageModelValid(SendMessageModel model)
{
if (model == null || string.IsNullOrEmpty(model.UserId) || string.IsNullOrEmpty(model.Text))
{
return(false);
}
return(true);
}
public async Task <BaseViewModel> SendMessage(SendMessageModel model)
{
BaseViewModel res = new BaseViewModel();
res = await _weChatHttpClientService.SendMessageService(model);
return(res);
}
public IActionResult SendMessage(string receiver)
{
var viewModel = new SendMessageModel {
Receiver = receiver
};
return(this.View(viewModel));
}
public bool SaveMessage(SendMessageModel send)
{
SendMessageEntity se = new SendMessageEntity();
se.IdUserFrom = send.IdUserFrom;
se.IdUserTo = send.IdUserTo;
se.Text = send.Text;
return(_sendMessageRepository.Insert(se));
}
public async Task <Response <SendReceipt> > SendMessageBase64Async <TData>(SendMessageModel <TData> message)
where TData : class
{
await GetQueueClient(message.QueueName);
var contentBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(message.Data.ToJson(IgnoredProperties)));
return(await _queueClient.SendMessageAsync(contentBase64));
}
public GenericResultViewModel <MessageModel> Post(SendMessageModel model)
{
var message = _messageService.SendMessage(model.Subject, model.Body, model.Recipients);
return(new GenericResultViewModel <MessageModel>()
{
Result = message
});
}
public async Task SendMessage(SendMessageModel message)
{
var userId = Context.UserIdentifier;
var messageResponse = await _messageRepository.SendMessage(int.Parse(userId), message);
var userToTask = Clients.User(message.UserToId.ToString()).SendAsync(SendMessageMethod, messageResponse);
var userFromTask = Clients.User(userId).SendAsync(SendMessageMethod, messageResponse);
Task.WaitAll(userToTask, userFromTask);
}
public ActionResult SendMessage(SendMessageModel model)
{
if (ModelState.IsValid)
{
try
{
User sender = CurrentUser;
ISet<User> setOfRecievers = new HashSet<User>();
string[] separators = new string[1];
separators[0] = "; ";
if (model.ToUsers != null)
{
string[] parsedRecievers = model.ToUsers.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var reciever in parsedRecievers)
{
if (String.IsNullOrEmpty(reciever) || (reciever == sender.Username))
{
continue;
}
setOfRecievers.Add(Model.UserService.FindByUsername(reciever));
}
}
if (model.ToGroups != null)
{
string[] parsedGroups = model.ToGroups.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var groupName in parsedGroups)
{
if (String.IsNullOrEmpty(groupName))
{
continue;
}
Group group = Model.GroupService.FindByName(groupName);
foreach (var user in Model.GroupService.GetUsers(group))
{
if (user.Username == sender.Username)
{
continue;
}
setOfRecievers.Add(user);
}
}
}
if (setOfRecievers.Count == 0)
{
ModelState.AddModelError("", "No user selected!");
var newMsgModel = prepareMessageModelToSend();
newMsgModel.Text = model.Text;
return View(newMsgModel);
}
Message prevMessage = Model.MessageService.FindById(model.PrevMessageID);
Model.MessageService.SendMessageToUsers(sender, setOfRecievers, prevMessage, model.Text);
return RedirectToAction("Index", new { page = 1.ToString() });
}
catch (InvalidOperationException)
{
ModelState.AddModelError("", "User does not exist!");
var newMsgModel = prepareMessageModelToSend();
newMsgModel.Text = model.Text;
return View(newMsgModel);
}
}
else
{
if (model.PrevMessageID == -1)
{
var newMsgModel = prepareMessageModelToSend();
newMsgModel.Text = model.Text;
newMsgModel.ToGroups = model.ToGroups;
newMsgModel.ToUsers = model.ToUsers;
return View("SendMessage", newMsgModel);
}
else
{
var newMsgModel = prepareMessageModelToReply(Model.MessageService.FindById(model.PrevMessageID));
newMsgModel.Text = model.Text;
return View("ReplyMessage", newMsgModel);
}
}
}
