public ActionResult SendEmail(Message message)
{
var from = _userService.GetUserByIdentity(User.Identity.Name);
SendEmailSMS send = new SendEmailSMS();
message.FromUser = from.UserId;
message.SenderName = from.Name;
message.Type = "Email";
message.ISRead = true;
if (Request.Form["SendToAll"] != null)
{
message.Email = "ارسال به همه";
message.Mobile = "";
IList <string> emailList = new List <string>();
foreach (var item in _userService.GetAllUsers())
{
emailList.Add(item.Email);
}
send.SendEmail(emailList, message.Subject, message.ContentMessage);
}
else
{
try
{
send.SendEmail(new[] { message.Email }, message.Subject, message.ContentMessage);
}
catch
{
}
}
_messageService.Add(message);
return(RedirectToAction("Index"));
}
public ActionResult AddDraftMessageOrSendMessage(Message message)
{
if (Request["Send"] != null)
{
Message sentMessage = new Message
{
Content = message.Content,
Date = message.Date,
isDraft = message.isDraft,
From = "*****@*****.**",
Subject = message.Subject,
To = message.To
};
ValidationResult results = validationRules.Validate(sentMessage);
if (results.IsValid)
{
_messageService.Add(sentMessage);
return(RedirectToAction("SentMessages"));
}
else
{
foreach (var error in results.Errors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return(View("NewMessage"));
}
}
else if (Request["Draft"] != null)
{
Message draftMessage = new Message
{
Date = message.Date,
Content = message.Content,
From = "*****@*****.**",
Subject = message.Subject,
To = message.To,
isDraft = true
};
_messageService.Add(draftMessage);
return(RedirectToAction("GetDraftMessages"));
}
return(View());
}
public async Task <IActionResult> Create(Message message, string MessageTo)
{
if (MessageTo != null)
{
int msgID;
int.TryParse(MessageTo, out msgID);
Message M = await _messageService.GetById(msgID);
message.ToUser = M.FromUser;
message.FromUser = M.ToUser;
message.SenderName = M.UsersTo.Name;
}
else
{
var from = await _userService.GetUserByIdentity(User.Identity.Name);
message.FromUser = from.UserId;
message.SenderName = from.Name;
}
await _messageService.Add(message);
try
{
//SendEmailSMS.SendEmail("*****@*****.**", message.Email, message.Subject, message.ContentMessage);
}
catch
{
throw;
}
return(RedirectToAction("Index"));
}
public void SendMessage(MessageViewModel message)
{
if (message == null)
{
return;
}
if (!_users_ConnectionIds.ContainsKey(Context.ConnectionId))
{
_users_ConnectionIds.Add(Context.ConnectionId, message.User.UserName);
}
MessageViewModel createdMessage = _messageService.Add(message);
if (createdMessage != null)
{
foreach (var item in createdMessage.Chat.Users)
{
var result = _users_ConnectionIds.SingleOrDefault(x => x.Value.Equals(item.UserName)).Key;
if (result != null)
{
Clients.Client(result).OnMessage(createdMessage);
}
}
}
}
public async Task <HttpResponseMessage> AddMessage(NewMessageModel message)
{
try
{
var recipientsStr = "";
foreach (var rec in message.Recipients)
{
recipientsStr += rec + ";";
}
recipientsStr = recipientsStr.Substring(0, recipientsStr.Length - 2);
var messageToAdd = new Message()
{
Subject = message.Subject,
IsSent = false,
Recipients = recipientsStr,
Body = message.Body
};
var id = await _service.Add(messageToAdd);
_service.SendToNotification(messageToAdd);
return(Request.CreateResponse(HttpStatusCode.OK, id));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, String.Format("Sorry, exception occured: {0}", e.Message)));
}
}
public async Task <IActionResult> CreateMessage(int userId, MessageForCreationDto messageForCreationDto)
{
var sender = await _datingService.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageForCreationDto.SenderId = userId;
var recipient = await _datingService.GetUser(messageForCreationDto.RecipientId);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
var message = _mapper.Map <Message>(messageForCreationDto);
try
{
_messageService.Add(message);
return(StatusCode(201));
}
catch
{
throw new Exception("Creating the message failed on save");
}
}
/// <summary>
/// Handle the messages transactions between users in a room
/// </summary>
/// <param name="message">New Message Model</param>
/// <returns></returns>
public async Task Send(NewChatMessageViewModel message)
{
var user = _userService.GetSingleFirst(e => e.UserName == Context.User.Identity.Name);
var room = _roomService.GetSingleFirst(e => e.Name == message.RoomName);
//Insert the message into the database
//to historical porpuses
var msg = new Message
{
Content = message.Content,
CreatedDate = DateTime.Now,
UserId = user.Id,
Rooms = new List <RoomMessages>
{
new RoomMessages {
RoomId = room.Id
}
}
};
msg.Rooms.FirstOrDefault().Message = msg;
_messageService.Add(msg);
//deliver the message to the specific room where the current user is
await Clients.Group(message.RoomName).SendAsync("Receive", new { message.Content, Author = Context.User.Identity.Name });
}
public IActionResult Add(int id, string message) // satıcı id gelir. alanId
{
if (!(Convert.ToBoolean(HttpContext.Session.GetString("Active"))))
{
return(RedirectToAction("Login", "IO"));
}
string tempId = HttpContext.Session.GetString("id");
int userId = int.Parse(tempId); //yollayanId
Message mesaj = new Message()
{
AlanId = id,
YollayanId = userId,
Mesaj = message,
MesajTarihi = DateTime.Now
};
_messageService.Add(mesaj);
FakeMessage fakeMessage = new FakeMessage() // fake mesaj veritabanına ürün eklendi
{
RealMessageId = mesaj.Id,
AlanId = id,
Mesaj = message,
MesajTarihi = mesaj.MesajTarihi,
YollayanId = userId
};
_fakeMessageService.Add(fakeMessage);
return(RedirectToAction("GetAll", "Product"));
}
public async Task SendMessage(string chatId, string userId, string messageText)
{
if (string.IsNullOrEmpty(messageText))
{
return;
}
var curUser = await _userService.GetAsync(Context.User);
User user = await _userService.GetAsync(userId);
if (user.Id != curUser.Id)
{
return;
}
long longChatId = Convert.ToInt64(chatId);
string user_full_name = user.UserInformation.FirstName + " " + user.UserInformation.SecondName;
string imagePath = _imageService.getUserImagePath(user);
//to make js load picture we have to remove "~/" from the begining of str
imagePath = imagePath.Remove(0, 2);
Message message = new Message()
{
Text = messageText,
ChatId = longChatId,
UserId = userId
};
await Clients.Caller.SendAsync("ReceiveMessage", imagePath, messageText, message.MessageDate.ToString("O"), true);
await Clients.Others.SendAsync("ReceiveMessage", imagePath, messageText, message.MessageDate.ToString("O"), false);
_logger.LogInformation($"user {user_full_name} send message");
_messageService.Add(message);
}
public async Task <ActionResult> CreateMessage(int userId, MessageForCreationDto messageForCreationDto)
{
if (!CheckUserAuthenticate(userId))
{
return(Unauthorized());
}
messageForCreationDto.SenderId = userId;
var recipinet = await _repo.GetUserById(messageForCreationDto.RecipientId);
if (recipinet == null)
{
return(BadRequest("Receiver not found"));
}
var message = Mapping.Mapper.Map <Message>(messageForCreationDto);
_repo.Add(message);
var messageToReturn = Mapping.Mapper.Map <MessageForCreationDto>(message);
if (_unitOfWork.Complete() > 0)
{
await _hubContext.Clients.All.SendAsync("receivedMessage", messageToReturn);
return(CreatedAtAction("GetMessage", new { userId, id = message.Id }, messageToReturn));
}
throw new Exception($"Message could not save");
}
public async Task SendToRole(string roleName, string message)
{
try
{
var user = await _userManager.GetUserAsync(GetUser());
if (!string.IsNullOrEmpty(message.Trim()))
{
// Create and save message in database
var msg = new Message();
msg.FromUser = user;
msg.ToRole = await _roleManager.FindByNameAsync(roleName);
await _messageService.Add(msg);
// Broadcast the message
var users = _userManager.Users.ToList();
if (users.Count() != 0)
{
foreach (var u in users)
{
if (_userManager.GetRolesAsync(u).Result.FirstOrDefault() == roleName)
{
await Clients.User(u.UserName).SendAsync("newMessage", message, user.UserName);
}
}
}
}
}
catch (Exception e)
{
throw e;
}
}
public List <Hero> GetHeroes()
{
var heroes = MockHeroes.Heroes;
_messageService.Add($"HeroService: Fetched {heroes.Count} Heroes");
return(heroes);
}
public void Create(MessageDTO ob)
{
if (ob != null)
{
service.Add(ob);
}
}
public async Task <ActionResult> Add(MessageModel model)
{
var message = Mapper.Map <Message>(model);
await _messageService.Add(message).ConfigureAwait(false);
return(RedirectToAction(nameof(All)));
}
public async Task <ActionResult> NewMessageAsync(MessageViewModel model)
{
var userList = helper.GetOnlineUsers();
var senderUser = userManager.GetByMail(model.senderUserEmail);
if (senderUser != null)
{
model.message.SenderUserId = senderUser.Id;
model.message.ReceiverUserId = 0;
model.message.SendDate = DateTime.Now;
await this.messageHub.NewMessageAsync(model.message);
messageManager.Add(model.message);
return(Ok());
}
return(StatusCode(500));
}
public ActionResult NewMessage(Message message)
{
var mail = (string)Session["Mail"].ToString();
message.Sender = mail.ToString();
message.Date = DateTime.Parse(DateTime.Now.ToShortDateString());
messageService.Add(message);
return(RedirectToAction("AllMessages", "Message"));
}
public async Task Create(Message message)
{
await _messageService.Add(message);
//todo send the message to the channel group
var channels = await _channelService.Get();
await _hubContext.Clients.All.ChannelListUpdated(channels);
}
public IActionResult Add(Message message)
{
var result = _messageService.Add(message);
if (result.Success == true)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task Send(Message message)
{
//todo implement message sending
await _messageService.Add(message);
await Clients.Group(message.ChannelId.ToString()).MessageReceived(message);
await UpdateChannelList();
}
private void _dbSave(string message, int toUserDbId)
{
var msg = new Message();
msg.FromUserId = _authProvider.CurrentUserId;
msg.ToUserId = toUserDbId;
msg.DateSent = DateTime.Now;
msg.MsgText = message;
_messageService.Add(msg);
}
public IActionResult PostMessage(MessageEntity entity, string redirect)
{
if (ModelState.IsValid)
{
_cookie.SetValue("Message", "true", 1);
entity.Status = (int)RecordStatus.InActive;
_messageService.Add(entity);
}
return(Redirect(redirect));
}
public ActionResult Add(int?specialite, int?first, int?second, int?third, string titre, string contenu)
{
if (_specialiteService.Get((int)specialite) == null || titre.Equals("") || contenu.Equals(""))
{
return(RedirectToAction("Index", "Message"));
}
Message message = new Message
{
SpecialiteId = (int)specialite,
Titre = titre,
Contenu = contenu,
DateEnvoiMessage = DateTime.Now,
ProfesseurId = ((Professeur)Session["user"]).ProfesseurId
};
if (first != null && first == 1)
{
message.Niveau = 1;
if (_messageService.Add(message) == null)
{
return(RedirectToAction("Index", "Message"));
}
}
if (second != null && second == 2)
{
message.Niveau = 2;
if (_messageService.Add(message) == null)
{
return(RedirectToAction("Index", "Message"));
}
}
if (third != null && third == 3)
{
message.Niveau = 3;
if (_messageService.Add(message) == null)
{
return(RedirectToAction("Index", "Message"));
}
}
return(RedirectToAction("Index", "Message"));
}
public async Task Create(Message message)
{
await _messageService.Add(message);
//todo send the message to the channel group
await _hubContext.Clients.Group(message.ChannelId.ToString()).MessageReceived(message);
var channels = await _channelService.Get();
await _hubContext.Clients.All.ChannelListUpdated(channels);
}
public async Task <IActionResult> Contact(MessageAddDto messageAddDto)
{
if (ModelState.IsValid)
{
var createdName = messageAddDto.FirstName + messageAddDto.LastName;
await _messageService.Add(messageAddDto, createdName);
return(RedirectToAction("Contact"));
}
return(View(messageAddDto));
}
public async Task SendMessage(MessageVM message)
{
var connection = Connections.Find(a => a.ConnectionID == Context.ConnectionId);
if (connection != null && connection.GroupId == message.GroupId)
{
var model = _mapper.Map <MessageAddVM>(message);
await _service.Add(model, message.UserId);
await Clients.Group(message.GroupId.ToString()).SendAsync("ReceiveMessage", message);
}
}
public async Task <List <Hero> > GetHeroesAsync()
{
var heroes = await _client.GetJsonAsync <List <Hero> >($"{_baseAddress}");
_messageService.Add($"HeroService: Fetched {heroes.Count} Heroes");
return(heroes);
}
public ActionResult CompanyDetail(string name, string surname, string email, string message)
{
bool resultEnd = false;
User currentUser = new User();
bool result;
try
{
int idm = 0;
result = int.TryParse(RouteData.Values["id"].ToString(), out idm);
if (result && idm != 0)
{
currentUser.FirstName = name;
currentUser.LastName = surname;
currentUser.EMail = email;
currentUser.UserRoleID = 2;
currentUser.IsActive = false;
bool result1 = false;
try
{
result1 = _userService.Add(currentUser);
}
catch (Exception ex)
{
throw;
}
finally
{
User user = new User();
user = _userService.GetUserByEmail(currentUser.EMail);
Message msg = new Message();
msg.IsActive = true;
msg.Detail = message;
msg.CreatedDate = DateTime.Now;
msg.CompanyID = idm;
msg.UserID = user.ID;
resultEnd = _messageService.Add(msg);
}
}
}
catch (Exception ex)
{
RedirectToAction("Companies");
}
if (resultEnd)
{
ViewBag.Message = "Mesajınız başarı ile gönderildi.";
}
return(RedirectToAction("CompanyDetail"));
}
public void Add(string fromuser, string touser, string content)
{
var message = new Message
{
FromUser = fromuser,
ToUser = touser,
Content = content,
Flag = false,
AddTime = DateTime.Now
};
_service.Add(message);
}
public IActionResult Add(MessageCreateNewRequest request)
{
int?userId = HttpContext.Session.GetInt32("userId");
if (userId == null)
{
return(StatusCode(440));
}
var response = _service.Add((int)userId, request);
return(response.Equals(Error.OK) ? Ok() : BadRequest(response));
}
public async Task SendMessage(string messageText, int recipientId, string recipientName)
{
int userId = _authService.GetCurrentUserId();
//Create MessageAddRequest
MessageAddRequest message = new MessageAddRequest();
message.RecipientId = recipientId;
message.MessageText = messageText;
message.DateSent = DateTime.Now;
//DB Call
int createdMessageId = _service.Add(message, userId);
//Create message to send
Message createdMessage = new Message();
UserProfile recipient = new UserProfile();
recipient.UserId = recipientId;
UserProfile sender = new UserProfile();
sender.UserId = userId;
createdMessage.Recipient = recipient;
createdMessage.Sender = sender;
createdMessage.MessageText = messageText;
createdMessage.DateSent = DateTime.Now;
Random rnd = new Random();
createdMessage.Id = rnd.Next(500000);
// TODO Try/catch sql exception
//Get current chatroom and send
NotificationAddRequest notification = new NotificationAddRequest();
notification.UserId = recipientId;
notification.NotificationTypeId = 2;
notification.NotificationText = $"New message from {recipientName}";
Notification notification1 = new Notification();
notification1.NotificationText = $"New message from {recipientName}";
notification1.UserId = recipientId;
notification1.NotificationTypeId = 2;
notification1.DateCreated = new DateTime();
_notificationService.Add(notification);
string chatRoomId = await _chatHubService.GetCurrentUserRoom(userId);
await Clients.Group(chatRoomId).SendAsync("AddMessage", createdMessage);
await _notificationHubContext.Clients.User(recipientId.ToString()).SendAsync("ReceiveNotification", notification1);
}
public void Add_Throws_Exception_If_Validation_Returns_Errors()
{
var invalidMessage = new Message();
//mock a failed validation
var mockValidationRunner = new Mock<IValidationRunner>();
mockValidationRunner.Expect(v => v.Run(invalidMessage))
.Returns(new List<ValidationError>
{
new ValidationError("prop",
"error")
});
service = new InMemoryMessageService(null, mockValidationRunner.Object);
Assert.Throws<ValidationException>(() => service.Add(invalidMessage));
mockValidationRunner.VerifyAll();
}
