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(); }