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