public async Task <IActionResult> SendNewMultiMediaMessage(IFormFile file)
{
if (string.IsNullOrEmpty(CurrentUserName))
{
return(Unauthorized());
}
var consultancyId = Request.Form["ConsultancyId"];
var personId = Request.Form["PersonId"];
var serviceSupplyId = Request.Form["ServiceSupplyId"];
var sender = (ConsultancyMessageSender)int.Parse(Request.Form["Sender"]);
var messageType = (ConsultancyMessageType)int.Parse(Request.Form["MessageType"]);
if (sender == ConsultancyMessageSender.CONSULTANT && !User.IsInRole("doctor"))
{
throw new AwroNoreException("You can not send massage as consultant");
}
var model = new SendMessageDTO
{
ConsultancyId = int.Parse(consultancyId),
PersonId = int.Parse(personId),
ServiceSupplyId = int.Parse(serviceSupplyId),
Type = messageType,
Sender = sender
};
var message = await _consultancyService.SendMultiMediaMessageAsync(model, file);
return(Ok(message));
}
public async Task <ActionResult> SendMessage(SendMessageDTO sendMessage)
{
//Find message author
var author = _userService.Load(sendMessage.UserId);
if (author == null)
{
return(NotFound(new { message = Errors.UserNotFound }));
}
//Load conversation
var conversation = _conversationService.Load(sendMessage.ConversationId, false, true, false, false);
if (conversation == null)
{
return(NotFound(new { message = Errors.ConversationNotFound }));
}
//Find user conversation
var userConversation = conversation.Users.Where(x => x.UserId == sendMessage.UserId).FirstOrDefault();
if (userConversation == null)
{
return(NotFound(new { message = Errors.UserConversationNotFound }));
}
if (userConversation.Status == -1)
{
return(BadRequest(new { message = Errors.UserWasKicked }));
}
if (userConversation.Status == -2)
{
return(BadRequest(new { message = Errors.UserLeftTheConversation }));
}
//Create message
var message = new Message()
{
Body = sendMessage.Body,
Conversation = conversation,
ConversationId = conversation.Id,
CreateDate = DateTime.Now,
UpdateDate = null,
User = author,
UserId = author.Id
};
//Add message to conversation
conversation.Messages.Add(message);
await _conversationService.Update(conversation.Id, conversation);
var usersToSendCreatedMessage = conversation.Users.Where(x => x.UserId != message.UserId).Select(x => x.UserId.ToString()).ToList();
//Send object to users
await _chatHub.Clients.Users(usersToSendCreatedMessage).SendAsync("MessageReceived", message);
return(Ok(message));
}
public async Task <IActionResult> Post([FromBody] SendMessageDTO sendMessage)
{
try
{
var result = await this.sendMessage.Send(sendMessage);
return(this.Ok(new { MobileNumbers = result.Item2, Result = result.Item1 }));
}
catch (Exception ex)
{
return(this.StatusCode(500));
}
}
public async Task <IActionResult> SendNewMessage([FromBody] SendMessageDTO model)
{
if (model.Sender == ConsultancyMessageSender.CONSULTANT && !User.IsInRole("doctor"))
{
throw new AwroNoreException("You can not send massage as consultant");
}
model.Type = ConsultancyMessageType.TEXT;
var result = await _consultancyService.SendConsultancyMessageAsync(model);
return(Ok(result));
}
public IActionResult SendMessageBoxe(SendMessageDTO model)
{
int id = int.Parse(User.Identity.Name);
var user = _userService.GetById(id);
var modelMessage = new MessageBoxe
{
User_ToName = model.User_ToName,
from_who = user.Username,
subject = model.subject,
When = DateTime.Now
};
_context.Messageboxe.Add(modelMessage);
_context.SaveChanges();
return Ok();
}
/// <summary>
/// Trimitere mail de confirmare
/// </summary>
/// <param name="messageDTO"></param>
public void StoreMessageEmail(SendMessageDTO messageDTO)
{
MailMessage mail = new MailMessage();
mail.From = new MailAddress(ConfigurationManager.AppSettings["mail_user"]);
mail.To.Add(ConfigurationManager.AppSettings["admin_mail_to"]);
mail.CC.Add(ConfigurationManager.AppSettings["admin_mail_cc"]);
mail.Subject = $"Message from {messageDTO.Name}";
mail.Body = "<p>name: " + messageDTO.Name + ", </p>";
mail.Body += "<p>email: " + messageDTO.Email + ", </p>";
mail.Body += "<p>subject: " + messageDTO.Subject + ", </p>";
mail.Body += "<p>message: " + messageDTO.Message + ", </p>";
mail.IsBodyHtml = true;
SendMail(mail);
}
public async Task <IActionResult> SendMessage(SendMessageDTO sendMessage)
{
#region TokenValidation
try
{
token = HttpContext.Request.Headers["Authorization"];
token = token.Replace("Bearer ", "");
if (!_tokenHelper.IsValidateToken(token))
{
error.Err = "Token wygasł";
error.Desc = "Zaloguj się od nowa";
return(StatusCode(405, error));
}
}
catch
{
error.Err = "Nieprawidlowy token";
error.Desc = "Wprowadz token jeszcze raz";
return(StatusCode(405, error));
}
#endregion
var id = _tokenHelper.GetIdByToken(token);
var user = await _apiHelper.ReturnUserByID(id);
var classObj = await _apiHelper.ReturnClassByID(sendMessage.classID);
if (classObj == null || !classObj.members.Contains(id))
{
error.Err = "Nie możesz wysłać wiadomości";
error.Desc = "Nie należysz do tej klasy";
return(StatusCode(405, error));
}
TextMessage textMessage = new TextMessage
{
messageID = 0,
msessage = sendMessage.message,
senderName = user.name,
senderSurname = user.surrname,
sendTime = DateTime.Now
};
var message = await _apiHelper.SendMessage(sendMessage.subjectID, textMessage);
return(Ok(textMessage));
}
public async Task <ConsultancyMessageDTO> SendConsultancyMessageAsync(SendMessageDTO model)
{
ConsultancyMessageDTO result = null;
var strategy = _dbContext.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async() =>
{
using (var transaction = _dbContext.Database.BeginTransaction())
{
var msg = new ConsultancyMessage
{
ConsultancyId = model.ConsultancyId,
ServiceSupplyId = model.ServiceSupplyId,
PersonId = model.PersonId,
CreatedAt = DateTime.Now,
Content = model.Content,
Status = ConsultancyMessageStatus.NEW,
Sender = model.Sender,
Type = model.Type,
};
await _dbContext.ConsultancyMessages.AddAsync(msg);
await _dbContext.SaveChangesAsync();
result = new ConsultancyMessageDTO
{
Id = msg.Id,
SenderReceiverType = msg.Sender == ConsultancyMessageSender.CUSTOMER ? MessageSenderReceiverType.SENT : MessageSenderReceiverType.RECEIVED,
Message = msg.Content,
Time = msg.CreatedAt.ToString("HH:mm"),
Type = msg.Type
};
transaction.Commit();
}
});
await NotifyMessageReceiverAsync(model, result);
return(result ?? throw new AwroNoreException(""));
}
public HttpResponseMessage PostOrders(SendMessageDTO request)
{
HttpResponseMessage response = null;
JSendMessage json;
var messageAdded = users.StoreMessage(request);
if (messageAdded)
{
json = new JSendMessage("success", "Message sent");
response = Request.CreateResponse(HttpStatusCode.OK, json);
}
else
{
json = new JSendMessage("failed", "Request failed.");
response = Request.CreateResponse(HttpStatusCode.BadRequest, json);
}
return(response);
}
public async Task <bool> SendMessage(SendMessageDTO chatMessageDTO)
{
var currentUser = await Context.GetUserFromContext(_userManager);
if (currentUser != null && await _chatRepository.UserIsInChat(currentUser.Id, chatMessageDTO.RoomName))
{
var message = await _chatRepository.SendMessage(currentUser.Id, chatMessageDTO);
await Clients.OthersInGroup(chatMessageDTO.RoomName).SendAsync("NewMessageReceived", message);
await Clients.Caller.SendAsync("MessageConfirmation", new MessageConfirmationDTO
{
MessageId = message.Id,
TemporalId = chatMessageDTO.TemporalId
});
return(true);
}
return(false);
}
public bool StoreMessage(SendMessageDTO message)
{
try
{
if (string.IsNullOrWhiteSpace(message.Message))
{
throw new System.Exception("failed");
}
else
{
StoreMessageEmail(message);
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public async Task <ChatMessageDTO> SendMessage(string userId, SendMessageDTO sendMessageDTO)
{
var room = await GetRoomByName(sendMessageDTO.RoomName);
if (room != null)
{
var message = new ChatMessage
{
Content = sendMessageDTO.Content,
UserId = userId,
ChatRoomId = room.Id,
Date = DateTime.Now
};
_applicationDbContext.Add(message);
await _applicationDbContext.SaveChangesAsync();
return(_mapper.Map <ChatMessage, ChatMessageDTO>(message));
}
return(null);
}
private async Task NotifyMessageReceiverAsync(SendMessageDTO model, ConsultancyMessageDTO result)
{
try
{
var instanceIds = new List <string>();
var doctorName = "";
var doctorAvatar = "";
var customerName = "";
var customerAvatar = "";
var personName = "";
var personAvatar = "";
// Receiver is doctor, so we must send notification to doctor
var serviceSupply = await _dbContext.ServiceSupplies.FindAsync(model.ServiceSupplyId);
if (serviceSupply != null)
{
doctorName = serviceSupply.Person.FullName;
doctorAvatar = serviceSupply.Person.RealAvatar;
}
var person = await _dbContext.Persons.FindAsync(model.PersonId);
if (person != null)
{
customerName = person.FullName;
customerAvatar = person.RealAvatar;
}
if (model.Sender == ConsultancyMessageSender.CUSTOMER)
{
personName = customerName;
personAvatar = customerAvatar;
if (serviceSupply != null && serviceSupply.Person.FcmInstanceIds != null)
{
instanceIds = serviceSupply.Person.FcmInstanceIds.Select(x => x.InstanceId).ToList();
}
}
else
{
personName = doctorName;
personAvatar = doctorAvatar;
if (person != null && person.FcmInstanceIds != null)
{
instanceIds = person.FcmInstanceIds.Select(x => x.InstanceId).ToList();
}
}
foreach (var item in instanceIds)
{
var payLoad = new ConsultancyMessageNotificationPayload
{
NotificationType = NotificationType.ConsultancyMessage,
ChatId = model.ConsultancyId,
ServiceSupplyId = model.ServiceSupplyId,
PersonId = model.PersonId,
PersonName = personName,
PersonAvatar = personAvatar,
MessageId = result.Id,
Sender = model.Sender,
Content = result.Message,
Type = result.Type
};
await _notificationService.SendConsultancyMessageDeliveryNotificationAsync(item, personName, result.Message?.TruncateLongString(50), payLoad);
}
}
catch
{
}
}
public async Task <ConsultancyMessageDTO> SendMultiMediaMessageAsync(SendMessageDTO model, IFormFile file)
{
ConsultancyMessageDTO result = null;
var strategy = _dbContext.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async() =>
{
using (var transaction = _dbContext.Database.BeginTransaction())
{
var msg = new ConsultancyMessage
{
ConsultancyId = model.ConsultancyId,
ServiceSupplyId = model.ServiceSupplyId,
PersonId = model.PersonId,
CreatedAt = DateTime.Now,
Content = "",
Status = ConsultancyMessageStatus.NEW,
Sender = model.Sender,
Type = model.Type,
};
await _dbContext.ConsultancyMessages.AddAsync(msg);
await _dbContext.SaveChangesAsync();
if (model.Type == ConsultancyMessageType.PHOTO)
{
var(newName, thumbName, dirPath, baseUrl) = _uploadService.GenerateConsultancyMessageImageName(model.ConsultancyId, msg.Id, file);
var url = $"{baseUrl}/{newName}";
var thumbUrl = $"{baseUrl}/{thumbName}";
msg.Content = $"{url},{thumbUrl}";
_dbContext.ConsultancyMessages.Attach(msg);
_dbContext.Entry(msg).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
await _uploadService.UploadConsultancyMessageImageAsync(file, dirPath, newName, thumbName);
}
else if (model.Type == ConsultancyMessageType.VOICE)
{
var(newName, dirPath, baseUrl) = _uploadService.GenerateConsultancyMessageVoiceName(model.ConsultancyId, msg.Id, file);
var url = $"{baseUrl}/{newName}";
msg.Content = $"{url}";
_dbContext.ConsultancyMessages.Attach(msg);
_dbContext.Entry(msg).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
await _uploadService.UploadConsultancyMessageVoiceAsync(file, dirPath, newName);
}
result = new ConsultancyMessageDTO
{
Id = msg.Id,
SenderReceiverType = msg.Sender == ConsultancyMessageSender.CUSTOMER ? MessageSenderReceiverType.SENT : MessageSenderReceiverType.RECEIVED,
Message = msg.Content,
Time = msg.CreatedAt.ToString("HH:mm"),
Type = msg.Type
};
transaction.Commit();
}
});
await NotifyMessageReceiverAsync(model, result);
return(result ?? throw new AwroNoreException(""));
}
public async Task <Tuple <IEnumerable <SendMessageResponse>, IEnumerable <string> > > Send(SendMessageDTO sendMessageDTO)
{
var mobileNumbers = this.users.Find(p => p.Feeder == sendMessageDTO.FeederId).ToList().Select(p => p.Mobile);
var result = new List <SendMessageResponse>();
foreach (var mobile in mobileNumbers)
{
var r = await this.httpClientWrapper.GetAsync <SendMessageResponse>("https://smsapi.engineeringtgr.com/", $"send/?Mobile=8880299973&Password=1989&Message={sendMessageDTO.Message}&To={mobile}&Key=shreePcyLq6mCtfBs7TG1FKjUAek");
result.Add(r);
}
return(new Tuple <IEnumerable <SendMessageResponse>, IEnumerable <string> >(result, mobileNumbers));
}
public async Task <Tuple <IEnumerable <SendMessageResponse>, IEnumerable <string> > > Send(SendMessageDTO sendMessageDTO)
{
var data = System.IO.File.ReadAllText(string.Format(configuration.AppSettings.DbTablesFilePath, "User.json"));
var users = JsonConvert.DeserializeObject <List <User> >(data);
var mobileNumbers = users.Where(p => p.Feeder == sendMessageDTO.FeederId).Select(p => p.Mobile);
var result = new List <SendMessageResponse>();
foreach (var mobile in mobileNumbers)
{
var r = await this.httpClientWrapper.GetAsync <SendMessageResponse>("https://smsapi.engineeringtgr.com/", $"send/?Mobile=8880299973&Password=1989&Message={sendMessageDTO.Message}&To={mobile}&Key=shreePcyLq6mCtfBs7TG1FKjUAek");
result.Add(r);
}
return(new Tuple <IEnumerable <SendMessageResponse>, IEnumerable <string> >(result, mobileNumbers));
}
