public void AddMessage(MessageDTO messageDto) { Message message = new Message { DialogId = messageDto.DialogId, RecipientId = messageDto.RecipientId, SenderId = messageDto.SenderId, Text = messageDto.Text, Time = messageDto.Time }; DB.Messages.AddMessage(message); DB.Save(); }
public HttpResponseMessage Post(MessageDTO message) { HttpResponseMessage response = null; if (message == null || message.CategoryId < 1 || !context.Categories.Any(c => c.Id == message.CategoryId) || string.IsNullOrEmpty(message.Content) || string.IsNullOrEmpty(message.Title) || string.IsNullOrEmpty(message.UserId)) { response = new HttpResponseMessage(HttpStatusCode.BadRequest); return(response); } User userDb = context.Users.SingleOrDefault(u => u.Id == message.UserId); if (userDb == null) { response = new HttpResponseMessage(HttpStatusCode.Unauthorized); return(response); } List <Student> studentsDb = context.Students .Where(s => s.Categories.Any(c => c.CategoryId == message.CategoryId)) .ToList(); Message messageDb = new Message() { Title = message.Title, Content = message.Content, Emails = studentsDb.Select(s => s.UserName).ToList(), AddedAt = DateTime.Now, UserId = message.UserId, SendAt = DateTime.Now }; userDb.Messages.Add(messageDb); context.SaveChanges(); foreach (string email in studentsDb.Select(s => s.UserName)) { MailHelpers.Send(email, messageDb.Title, messageDb.Content); } response = new HttpResponseMessage(HttpStatusCode.OK); response.Content = new StringContent(studentsDb.Count().ToString(), Encoding.UTF8); return(response); }
public async Task <ActionResult> GetInitData() { IndexInitDataDTO obj = await RedisHelper.GetAsync <IndexInitDataDTO>("ZswBlog:Index:InitData"); if (obj != null) { return(Ok(obj)); } else { //首页的数据初始化数据 List <Article> articles = await articleService.GetArticlesByPageAndIsShowAsync(3, 1, true); List <ArticleDTO> articleDTOs = await articleMapper.MapperToDTOsAsync(articles); List <Message> messages = (await messageService.GetMessagesOnNotReplyAsyncByPageAsync(10, 1)).ToList(); List <MessageDTO> messageDTOs = new List <MessageDTO>(); foreach (var item in messages) { User user = await userService.GetUserByIdAsync(item.UserId); MessageDTO messageDTO = await messageMapper.MapperToSingleDTOAsync(item, user); messageDTOs.Add(messageDTO); } DateTime date1 = DateTime.Parse("2019-10-08 00:00:00"); DateTime date2 = DateTime.Now; TimeSpan sp = date2.Subtract(date1); int tagCount = (await tagService.GetAllTagsAsync()).Count(); int timeCount = sp.Days; int articleCount = (await articleService.GetAllArticlesAsync()).Count(); int visitCount = await GetVisit(); IndexInitDataDTO initDataDTO = new IndexInitDataDTO() { DataCount = new CountData() { VisitsCount = visitCount, TagsCount = tagCount, RunDays = timeCount, ArticleCount = articleCount }, Articles = articleDTOs.ToList(), Messages = messageDTOs }; await RedisHelper.SetAsync("ZswBlog:Index:InitData", initDataDTO, 3600); return(Ok(initDataDTO)); } }
public async Task <ActionResult <MessageDTO> > GetById(Guid channelId, Guid messageId) { var channel = channelRepository.GetById(channelId); var message = messageRepository.GetById(messageId); if (message != null) { // Generate the user response for given user. return(Ok(MessageDTO.FromMessage(message))); } return(NotFound()); }
public virtual void messageReceived(Message message) { MessageDTO mdto = DTOUtils.getDTO(message); Console.WriteLine("Message received " + message); try { sendResponse(new NewMessageResponse(mdto)); } catch (Exception e) { throw new ChatException("Sending error: " + e); } }
public void SendMessage(MessageDTO newMessage) { var account = userRepository.GetById(newMessage.AccountId); if (account == null) { throw new NullReferenceException("account"); } var message = _mapper.Map <Message>(newMessage); messageRepository.Add(message); theaterScheduleUnitOfWork.Save(); }
/// <summary> /// Constructeur complet /// </summary> /// <param name="idmessage"></param> /// <param name="idtopic"></param> /// <param name="objuser"></param> /// <param name="datemessage"></param> /// <param name="contentmessage"></param> public Message(int idmessage, int idtopic, Registered objuser, DateTime datemessage, string contentmessage) : this() { IdMessage = idmessage; IdTopic = idtopic; ObjUser = objuser; DateMessage = datemessage; ContentMessage = AuditTool.RtfToString(contentmessage); DTO = new MessageDTO(); DTO.IdMessage = idmessage; DTO.IdTopic = idtopic; DTO.IdUser = objuser.IdUser; DTO.DateMessage = datemessage; DTO.ContentMessage = ContentMessage; }
public IActionResult Create([FromBody] MessageDTO message) { if (ModelState.IsValid) { message.CreateOn = DateTime.Now; messageService.Add(message); return(Ok()); } else { return(BadRequest(ModelState)); } }
public void Edit(MessageDTO msg) { if (msg != null) { if (msg.MessageId == 0) { return; } var message = repository.Get(msg.MessageId.ToString()); message.Text = msg.Content; repository.Update(message); repository.Save(); } }
public MessageDTO[] GetMessagesForUser(int user_id) { List <int> messages_id = new List <int>(); using (var connection = new SqlConnection(connectionString)) { var get_message_id = connection.CreateCommand(); get_message_id.CommandText = @"SELECT MessageId FROM dbo.UserMessage WHERE UserId = @UserId"; get_message_id.Parameters.AddWithValue("@UserId", user_id); connection.Open(); using (var reader = get_message_id.ExecuteReader()) { while (reader.Read()) { messages_id.Add((int)reader["MessageId"]); } } } int i = 0; int id; string text; DateTime date_of_creation; var messages = new MessageDTO[messages_id.Count]; foreach (var message_id in messages_id) { using (var connection = new SqlConnection(connectionString)) { var get_topic = connection.CreateCommand(); get_topic.CommandText = @"SELECT Id, Text, DateOfCreation FROM dbo.Message WHERE Id = @Id"; get_topic.Parameters.AddWithValue("@Id", message_id); connection.Open(); using (var reader = get_topic.ExecuteReader()) { if (reader.Read()) { id = (int)reader["Id"]; text = (string)reader["Text"]; date_of_creation = (DateTime)reader["DateOfCreation"]; messages[i] = new MessageDTO(id, text, date_of_creation); i++; } } } } return(messages); }
public async Task <IActionResult> Edit(int id, [Bind("NoonMealRecNo,Subject,AsstDirector,Inspector,DeputyInspector,AssistantInspector,JuniorAssistant,Typist,RecordClerk,OfficeAssistant,FinancialYear,PeriodCategory,Period")] NoonMealPdlForm13 noonMealPdlForm13) { using (var _context = new auditinternalContext()) { ViewBag.ListOfFinancialYear = _context.TblMasterFinancialyear.ToList(); ViewBag.ListOfPeriodCategory = _context.TblMasterPeriodCategory.ToList(); } if (id != noonMealPdlForm13.NoonMealRecNo) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(noonMealPdlForm13); var result = await _context.SaveChangesAsync(); if (result == 1) { Result = "Updated"; ViewData["Msg"] = new MessageDTO { Message = "Dear User,<br/>Details Successfully Updated!!.", Status = "S", BackPageAction = "Index", BackPageController = "NoonMealForm13" }; } else { ViewData["Msg"] = new MessageDTO { Message = "Dear User,<br/><b>Some Error Ocurred Please try Later. if the problem persists contact your system administrator..", Status = "E", BackPageAction = "Index", BackPageController = "NoonMealForm13" }; } } catch (DbUpdateConcurrencyException) { if (!NoonMealPdlForm13Exists(noonMealPdlForm13.NoonMealRecNo)) { return(NotFound()); } else { throw; } } //return RedirectToAction(nameof(Index)); } return(View(noonMealPdlForm13)); }
public Message ReceiveNewMessages(EncryptedMessage encryptedMessage) { // 1. decrypt message MessageDTO decryptedMessage = StringToMessageDTO(_encryptionService.Decrypt(encryptedMessage.Content)); // 2. Add the contact if he do not exist Contact senderContact = _contactRepository.GetContact(decryptedMessage.SenderPhoneNumber); if (senderContact == null) { senderContact = new Contact() { Name = decryptedMessage.SenderPhoneNumber, PhoneNumber = decryptedMessage.SenderPhoneNumber }; _contactRepository.AddContact(senderContact); } // fetch la public key du contact et crée le contact avec cette clef senderContact.PublicKey = FetchPublicKeyOfContact(decryptedMessage.SenderPhoneNumber); _contactRepository.UpdateContact(senderContact); // 2.5 Validate that message with its signature if (!_encryptionService.VerifySignature(encryptedMessage.DestinationPhoneNumber, decryptedMessage.Signature, senderContact)) { // If the signature is invalid, we skip this message. return(null); } // 3. Add the message in the BD Message message = new Message() { Id = encryptedMessage.Guid, Sender = senderContact, Content = decryptedMessage.Content, DestinationPhoneNumber = encryptedMessage.DestinationPhoneNumber, Timestamp = decryptedMessage.Timestamp }; if (_messageRepository.GetMessage(message.Id) == null) { _messageRepository.AddMessage(message); // 4. Push the new message in the blocking collection return(message); } // This message was already known return(null); }
public void CallBackMsg(MessageDTO msg) { App.Current.Dispatcher.BeginInvoke((Action) delegate() { Thread.Sleep(20); ChatModel currentChat = UserChats.FirstOrDefault((chat) => chat.Chat.ChatId == msg.ChatId); currentChat.Messages.Add( new MessageModel() { Message = msg , Sender = currentChat.Members.FirstOrDefault((user) => user.User.User.UserId == msg.SenderId).User }); }); }
public void TestSendWithoutRecevier_Exception() { var profile = (ProfileDTO)profiles[0].Tag; var profile1 = (ProfileDTO)profiles[1].Tag; SessionData data = CreateNewSession(profile, ClientInformation); RunServiceMethod(delegate(InternalBodyArchitectService Service) { MessageDTO message = new MessageDTO(); message.Sender = profile; message.Topic = "test topic"; message.Content = "test content"; Service.SendMessage(data.Token, message); }); }
public async Task Create(MessageDTO message) { var sqlQuery = "INSERT INTO Messages(Username, Subject, Message) VALUES(@Username, @Subject, @Message);"; var parameter = new DynamicParameters(); parameter.Add("@Username", message.Username, DbType.String); parameter.Add("@Subject", message.Subject, DbType.String); parameter.Add("@Message", message.Message, DbType.String); using (var connection = new SqlConnection(_connectionStrings.SQLDBConnectionString)) { await connection.ExecuteAsync(sqlQuery, parameter); } }
public MessageDTO GetMessage(string id) { var tmp = repository.Get(id); if (tmp != null) { var message = new MessageDTO { MessageId = tmp.Id, Content = tmp.Text }; return(message); } return(new MessageDTO()); }
//can't use interface as parameter which would be very convenient :\ public async Task AddMessage(MessageDTO message) { using (var scope = _scopeFactory.CreateScope()) { message.Date = DateTime.UtcNow; var context = scope.ServiceProvider.GetRequiredService <MessageContext>(); //Cannot deserialize into interface without custom jsonconverter var hasSavedMessage = await PostMessage(message, context); if (hasSavedMessage) { await Clients.All.SendAsync("messageReceived", message); } } }
private void Button_Click(object sender, RoutedEventArgs e) { string partisipants = Account.Id + " " + (Interlocutor.Tag as AccountDTO).Id; string partisipantsRes = partisipants.Split().Min() + " " + partisipants.Split().Max(); MessageDTO message = new MessageDTO { Content = tbMessage.Text, DeliverId = Account.Id, Data = DateTime.Now }; messengerClient.AddMessage(message.Content, message.Data, message.DeliverId.Value); messengerClient.AddChat(partisipantsRes, message, (Interlocutor.Tag as AccountDTO).Name + "&" + Account.Name, null); tbMessage.Text = ""; }
public async Task <MessageDTO> CreateAsync(MessageDTO messageDTO, int authorId) { var messageToCreate = mapper.Map <Message>(messageDTO); messageToCreate.AuthorId = authorId; messageToCreate.DateTime = DateTime.Now; var createdMessage = await unitOfWork.Messages.CreateAsync(messageToCreate); await unitOfWork.SaveAsync(); //get created message with author var getCreatedMessage = unitOfWork.Messages.GetAll(m => m.Id == createdMessage.Id); return(CreateMessageDTOs(getCreatedMessage).First()); }
public MessageDTO InsertMessage(Message message) { try { _dbContext.Messages.Add(message); _dbContext.SaveChanges(); MessageDTO response = Mapper.Map <Message, MessageDTO>(message); return(response); } catch (Exception ex) { Error.LogError(ex); return(null); } }
public static MessageDTO ToDto(this Message msg, int profileId) { if (msg == null) { return(null); } MessageDTO dto = new MessageDTO { Date = msg.Date, Message = msg.Body, ProfileId = msg.ProfileId }; return(dto); }
public async Task <ActionResult> Add(MessageDTO message) { Message m = new Message() { Id = Guid.NewGuid(), Type = message.Type, Handled = false, Content = message.Content, AddedAt = DateTime.Now }; await _messageRepository.NewMessageAsync(m); return(Ok("A new message was added.")); }
int getPriorityImageKey(MessageDTO dto) { switch (dto.Priority) { case MessagePriority.System: return(1); case MessagePriority.High: return(2); case MessagePriority.Low: return(4); } return(3); }
/// <summary> /// Base method to respond to the other ship wanting to steal from this ship. /// </summary> /// <param name="dto"></param> /// <returns></returns> public virtual MessageDTO StealDelegate(MessageDTO dto) { MessageDTO responseDto = new MessageDTO() { intent = (int)Intents.StopInteraction, fromShipName = name, }; if (tradeDtos.Count != 0) { responseDto.tradeObject = JsonConvert.DeserializeObject <TradeObjectDTO>(tradeDtos.Dequeue()); } return(responseDto); }
public void ReceiveMessage(Message message) { if (CourentUser.ParticipantDTO.Select(p => p.RoomDTO.Id == message.Room.Id).Any()) // переробить умову { i++; MessageDTO messageDTO = Convertation.ToMessageDTO(message); messageDTO.Sender = Convertation.ToUserDTO(message.Sender); Messages.Add(messageDTO); //Messages.RemoveAt(0); } else { i = 50; } }
public IHttpActionResult CreateMessageInTopic(int idUser, int idTopic, string text) { MessageDTO message = new MessageDTO { Author = userService.GetById(idUser), Text = text, PostDate = DateTime.Now, IsDeleted = false, Complaints = new List <ComplaintDTO>() }; messageService.AddToTopic(idTopic, message); return(Ok(message)); }
public ActionResult Post([FromBody] MessageDTO newUserRegisteredDTO) { if (newUserRegisteredDTO.MessageFormat == null) { return(BadRequest(Resource.MessageFormatNotNull)); } var messageBody = ApiHelper.ProcessObjectToString(newUserRegisteredDTO, MessageType.NewUserRegistered); var customerId = newUserRegisteredDTO.CustomerId.ToString(); _messagingService.SendMessageAsync(customerId, messageBody); _logger.LogInformation(Resource.RegisterUserInfo, newUserRegisteredDTO.CustomerId); return(NoContent()); }
public async Task SendMessage(MessageBaseDTO message) { try { MessageDTO createdMessage = await _chatService.CreateMessage(message); await Clients.User(message.ReceiverId).SendAsync("MessageReceived", createdMessage, message.ChatId, message.SenderId); await Clients.Caller.SendAsync("MessageSent", createdMessage, message.ChatId); } catch (Exception exception) { await Clients.Caller.SendAsync("Error", exception.Message); } }
public async Task <IActionResult> SendMessage([FromBody] MessageDTO message) { var newMessage = mapper.Map <MessageDTO, MessageEntity>(message); if (await messageRepository.SendMessage(newMessage)) { return(Ok()); } else { BadRequest("Message is not sent"); } return(BadRequest()); }
public MessageDTO Create(MessageDTO messageDto) { try { Mapper.Initialize(cfg => cfg.CreateMap <MessageDTO, Message>()); var message = Mapper.Map <MessageDTO, Message>(messageDto); _unitOfWork.Messages.Create(message); _unitOfWork.Save(); } catch (Exception ex) { throw ex; } return(null); }
public HttpResponseMessage SaveWelcomeMessage(MessageDTO message) { return SafeAction(() => { IDelightServices service = new DelightServices(); service.SaveMessage(message); var response = Request.CreateResponse<Boolean>(HttpStatusCode.OK, true); return response; }); }
public void SaveMessage(MessageDTO message) { using (DelightServiceClient service = new DelightServiceClient()) { service.SaveMessage(message); } }