public async Task <string> replyToSbaMessage(MessageReply message, string slug)
{
string sbaLoanMessageReply =
await sbaLoanForgivenessMessageController.replyToSbaMessage(message, slug, pppLoanForgivenessMessageReply);
return(sbaLoanMessageReply);
}
public async Task <ServiceResponse <object> > SendReply(ReplyForAddDto model)
{
var ToAdd = new MessageReply
{
Reply = model.Reply,
ReplyToUserId = model.ReplyToUserId,
IsRead = false,
CreatedDateTime = DateTime.UtcNow,
ReplyFromUserId = _LoggedIn_UserID,
MessageId = model.MessageId,
};
if (model.files != null && model.files.Count() > 0)
{
for (int i = 0; i < model.files.Count(); i++)
{
var dbPath = _fileRepo.SaveFile(model.files[i]);
if (string.IsNullOrEmpty(ToAdd.Attachment))
{
ToAdd.Attachment += dbPath;
}
else
{
ToAdd.Attachment = ToAdd.Attachment + "||" + dbPath;
}
}
}
await _context.MessageReplies.AddAsync(ToAdd);
await _context.SaveChangesAsync();
_serviceResponse.Success = true;
_serviceResponse.Message = CustomMessage.Added;
return(_serviceResponse);
}
public bool StartNewJob(DeviceId deviceId, MessageReply reply)
{
reply.CreatedAt = DateTimeOffset.Now;
_amqpService.SendMessage("RuleEngine", "Job", reply);
return(true);
}
public async Task <string> replyToSbaMessage(MessageReply request, string slug, string loanForgivenessMessageUrl)
{
try
{
RestClient restClient = new RestClient($"{baseUri}/{loanForgivenessMessageUrl}/{slug}/");
restClient.Timeout = -1;
RestRequest restRequest = new RestRequest(Method.PUT);
restRequest.AddHeader("Authorization", apiToken);
restRequest.AddHeader(VENDOR_KEY, vendorKey);
restRequest.AddParameter("document_name", request.document_name);
restRequest.AddParameter("document_type", request.document_type);
restRequest.AddParameter("content", request.content);
restRequest.AddFile("document", request.document);
IRestResponse response = await restClient.ExecuteAsync(restRequest);
if (response.IsSuccessful)
{
return(response.Content);
}
throw new Exception($"Did not receive success code. please investigate. \nresponse code: {response.StatusCode}.\n response:{response.Content}");
}
catch (Exception exception)
{
Console.WriteLine($"{Environment.NewLine}{exception.Message}{Environment.NewLine}");
Console.WriteLine("------------------------------------------------------------------------");
return(exception.Message);
}
}
public void SendMessageReply(int messageId, MessageReply reply, MessageType type)
{
NMessageInfo nMessageInfo = AllMessages.Where(x => x.Id == messageId && x.Type == type).FirstOrDefault();
if (nMessageInfo != null)
{
MessageService.Instance.SendMessageReply(nMessageInfo.Id, nMessageInfo.Type, reply);
}
}
public bool Add(MessageReply messageReply)
{
bool result = _messageReplyDal.Add(messageReply);
if (result)
{
return(true);
}
return(false);
}
public bool Update(MessageReply messageReply)
{
bool result = _messageReplyDal.Update(messageReply);
if (result)
{
return(true);
}
return(false);
}
/// <summary>
/// 初始化一个<see cref="MessageReplyOutputDto"/>类型的新实例
/// </summary>
public MessageReplyOutputDto(MessageReply entity)
{
Id = entity.Id;
Content = entity.Content;
IsRead = entity.IsRead;
UserId = entity.UserId;
BelongMessageId = entity.BelongMessageId;
ParentMessageId = entity.ParentMessageId;
ParentReplyId = entity.ParentReplyId;
IsLocked = entity.IsLocked;
CreatedTime = entity.CreatedTime;
}
public async Task replyToSbaMessage()
{
MessageReply message = new MessageReply
{
document = @"<path to file>",
document_name = "<document name>",
document_type = 4,
content = "<content>"
};
string response = await cSharpClientTest.replyToSbaMessage(message, "<slug>");
Assert.IsNotNull(response);
}
public async Task replyToSbaMessage()
{
MessageReply message = new MessageReply
{
document = @"C:\Users\Administrator\Desktop\Ppdf.pdf",
document_name = "Test Document",
document_type = 4,
content = "test1"
};
string response = await cSharpClientTest.replyToSbaMessage(message, "523ed6d3-7233-40ab-835e-e01f9184dc8f");
Assert.IsNotNull(response);
}
private async Task SendMessageSender(string messageType, MessageReply message, string siteName, string siteUrl, bool isReply,
ApplicationUser senderUserDb, SendMessageInput data, string chatId, ChatDbModel chatDbModel)
{
if (messageType == SiteNotAuthenticated)
{
var msg = (MessageSiteNotAuthenticated)message;
var messageReceiverMailModel = new MessageReceiverMailModel();
messageReceiverMailModel.SiteName = siteName;
messageReceiverMailModel.SiteUrl = siteUrl;
messageReceiverMailModel.UserName = msg.FullName;
messageReceiverMailModel.Title = msg.Title;
messageReceiverMailModel.Message = FormatMessageForEmail(message.Message);
messageReceiverMailModel.IsReply = isReply;
messageReceiverMailModel.Sender = new SenderModel()
{
IsNotAuthenticated = true,
FullName = msg.FullName,
Email = msg.Email,
Phone = msg.Phone
};
await SendEmailSenderAsync(messageReceiverMailModel, msg.Email);
}
else if (senderUserDb != null)
{
var messageReceiverMailModel = new MessageReceiverMailModel();
messageReceiverMailModel.SiteName = siteName;
messageReceiverMailModel.SiteUrl = siteUrl;
var messageSource = "/administration";
if (data.Source == "User")
{
messageSource = "/utilisateur";
}
var messageUrl = UrlHelper.Concat(siteUrl, messageSource + "/messages/message/" + chatId);
messageReceiverMailModel.MessageUrl = messageUrl;
messageReceiverMailModel.UserName = senderUserDb.FullName;
messageReceiverMailModel.Message = FormatMessageForEmail(message.Message);
messageReceiverMailModel.Title = chatDbModel.Title;
messageReceiverMailModel.Sender = new SenderModel()
{
IsNotAuthenticated = false,
FullName = senderUserDb.FullName
};
messageReceiverMailModel.IsReply = isReply;
await SendEmailSenderAsync(messageReceiverMailModel, senderUserDb.Email);
}
}
public ActionResult MessageReplies(MessageReply message)
{
var user = (Member)Session["LogonUser"];
if (user == null)
{
return(RedirectToAction("Login", "Account"));
}
message.AddedDate = DateTime.Now;
message.MemberFromId = user.ID;
db.MessageReplies.Add(message);
db.SaveChanges();
return(RedirectToAction("MessageReplies", "Messages", new { id = message.MessageId }));
}
internal void SendMessageReply(int id,MessageType type,MessageReply reply)
{
NetMessage message = new NetMessage()
{
Request = new NetMessageRequest()
{
messageReplyRequest = new MessageReplyRequest()
{
Id = id,
Type = type,
Reply = reply
}
}
};
NetClient.Instance.SendMessage(message);
}
public async Task SendJobStartMessageAsync()
{
var msg = new MessageReply
{
Id = new Guid(),
Priority = MessagePriority.Normal,
CreatedBy = DeviceId.FullId,
CreatedAt = DateTimeOffset.Now,
Type = "reply",
Action = "StartJob",
AdditionalProperties = { ["jobKey"] = "ChatSendMessage" },
};
await Client.PutActionsMessageAsync(DeviceId, msg);
++JobsStarted;
}
public async Task SendJobStartMessageAsync()
{
var msg = new MessageReply
{
Id = Guid.NewGuid(),
Priority = MessagePriority.Normal,
CreatedBy = DeviceId.FullId,
CreatedAt = DateTimeOffset.Now,
Type = "JobReply",
Action = "StartJob",
Name = "ChatSendMessage"
};
await Client.PutActionsMessageAsync(DeviceId, msg);
Logger.Debug($"Started new Chat as {DeviceId.FullId} with Guid: {msg.Id}");
++JobsStarted;
}
private async Task SendMessageReceiver(string siteName, string siteUrl, ApplicationUser userDb,
MessageReply messageReply, ApplicationUser senderUserDb, string messageType, ChatDbModel chatDbModel, bool isAdmin)
{
if (senderUserDb == null || senderUserDb.Id != userDb.Id)
{
var messageReceiverMailModel = new MessageReceiverMailModel();
messageReceiverMailModel.SiteName = siteName;
messageReceiverMailModel.SiteUrl = siteUrl;
messageReceiverMailModel.UserName = userDb.FullName;
messageReceiverMailModel.Message = FormatMessageForEmail(messageReply.Message);
messageReceiverMailModel.Title = chatDbModel.Title;
var messageSource = "/administration";
if (!isAdmin)
{
messageSource = "/utilisateur";
}
var messageUrl = UrlHelper.Concat(siteUrl, messageSource + "/messages/message/" + chatDbModel.Id);
messageReceiverMailModel.MessageUrl = messageUrl;
if (messageType == SiteNotAuthenticated)
{
var msg = (MessageSiteNotAuthenticated)messageReply;
messageReceiverMailModel.Sender = new SenderModel()
{
Email = msg.Email,
FullName = msg.FullName,
Phone = msg.Phone,
IsNotAuthenticated = true
};
}
else if (senderUserDb != null)
{
messageReceiverMailModel.Sender = new SenderModel()
{
FullName = senderUserDb.FullName,
IsNotAuthenticated = false
};
}
await SendEmailAsync(messageReceiverMailModel, userDb.Email);
}
}
public IActionResult PutMessageReply(
[FromRoute][Required] string device,
[FromBody][Required] MessageReply reply)
{
try
{
var deviceId = new DeviceId(device);
if (reply == null)
{
return(BadRequest("No Body provided"));
}
if (reply.Action != null)
{
Logger.DebugLogMessage($"Received MessageReply from \"{deviceId}\" with Action \"{reply.Action}\":", reply);
switch (reply.Action)
{
case "StartJob":
_actionModel.StartNewJob(deviceId, reply);
break;
default:
break;
}
}
return(FormattedOk());
}
catch (FormatException e)
{
Logger.Error(e);
return(BadRequest("DeviceId fehlerhaft."));
}
catch (Exception e)
{
Logger.Error(e);
return(FormattedInternalServerError());
}
}
public ActionResult SendMessage(SendMessages message)
{
var user = (Member)Session["LogonUser"];
if (Session["LogonUser"] == null)
{
return(RedirectToAction("Login", "Account"));
}
Message mesaj = new Message()
{
AddedDate = DateTime.Now,
IsRead = false,
Subject = message.Subject,
MemberFromId = user.ID,
MemberToId = message.ToUserId
};
db.Messages.Add(mesaj);
int messageId = db.MessageReplies.OrderByDescending(x => x.AddedDate).Select(x => x.MessageId).Take(1).SingleOrDefault();
MessageReply mr = new MessageReply()
{
AddedDate = DateTime.Now,
MemberFromId = user.ID,
Text = message.MessageBody,
MemberToId = message.ToUserId,
};
if (mr.MessageId == 0)
{
mr.MessageId = messageId + 1;
}
else
{
mr.MessageId = 1;
}
db.MessageReplies.Add(mr);
db.SaveChanges();
return(RedirectToAction("Index", "Messages"));
}
public override async Task ShowMessage(MessageRequest request, IServerStreamWriter <MessageReply> responseStream, ServerCallContext context)
{
using var tokenSource = new CancellationTokenSource();
CancellationToken token = tokenSource.Token;
var meta = new MessageReply();
var metaData = new ImageMetaData();
metaData.FileName = "kitty.jpg";
metaData.MimeType = "image/jpeg";
meta.MetaData = metaData;
await responseStream.WriteAsync(meta);
var kitty = Path.Combine(_env.ContentRootPath, "kitty.jpg");
using var reader = new FileStream(kitty, FileMode.Open);
int chunkSize = 100;
int bytesRead;
byte[] buffer = new byte[chunkSize];
int position = 0;
long length = reader.Length;
while ((bytesRead = await reader.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
var reply = new MessageReply();
var chunk = new ImageChunk();
chunk.Length = bytesRead;
chunk.Data = ByteString.CopyFrom(buffer);
reply.Chunk = chunk;
await responseStream.WriteAsync(reply);
position += bytesRead;
Console.WriteLine(position);
}
reader.Close();
Console.WriteLine("Done");
}
public static async Task FanoutAsync(MessageReply message)
{
var now = DateTime.UtcNow;
var removedKeys = new List <string>();
foreach (var oneServicePair in _keepAlivedServices)
{
if ((now - oneServicePair.Value._lastPingTime) < _idleTime)
{
await oneServicePair.Value._channel.Writer.WriteAsync(message);
}
else
{
removedKeys.Add(oneServicePair.Key);
}
}
foreach (var oneKey in removedKeys)
{
_keepAlivedServices.TryRemove(oneKey, out var service);
}
}
void CommandConsumer_MessageHandled(MessageReply reply)
{
var messageState = MessageStateQueue[reply.MessageID] as MessageState;
if (messageState != null)
{
MessageStateQueue.TryRemove(reply.MessageID);
object result = null;
if (reply.Exception != null)
{
messageState.TaskCompletionSource.TrySetException(reply.Exception);
}
else
{
var resultProperty = messageState.Message.GetType().GetProperty("Result");
if (resultProperty != null)
{
messageState.Message.SetValueByKey("Result", reply.Result);
}
messageState.TaskCompletionSource.TrySetResult(result);
}
}
}
void OnMessageHandled(IMessageContext messageContext, MessageReply reply)
{
if (!string.IsNullOrWhiteSpace(messageContext.ReplyToEndPoint) && reply != null)
{
var replyProducer = GetReplyProducer(messageContext.ReplyToEndPoint);
if (replyProducer != null)
{
while (true)
{
try
{
replyProducer.Send(reply.BrokeredMessage);
break;
}
catch (Exception ex)
{
Thread.Sleep(1000);
_logger.Error(ex.GetBaseException().Message, ex);
}
}
_logger.InfoFormat("send reply, commandID:{0}", reply.MessageID);
}
}
}
public Task <string> replyToSbaMessage(MessageReply request, string slug, string loanForgivenessMessageUrl)
{
Console.WriteLine("Processing reply To SbaMessage");
return(sbaRestApiClient.replyToSbaMessage(request, slug, loanForgivenessMessageUrl));
}
public void Start()
{
#region init sending commands Worker
#region Init Command Queue client
if (_commandQueueNames != null && _commandQueueNames.Length > 0)
{
_commandQueueNames.ForEach(commandQueueName =>
_commandQueueClients.Add(CreateQueueClient(commandQueueName)));
}
#endregion
_sendCommandWorkTask = Task.Factory.StartNew(() =>
{
using (var messageStore = IoCFactory.Resolve <IMessageStore>())
{
messageStore.GetAllUnSentCommands()
.ForEach(commandContext => _toBeSentCommandQueue.Add(commandContext));
}
while (!_exit)
{
try
{
var commandContext = _toBeSentCommandQueue.Take();
SendCommand(commandContext);
Task.Factory.StartNew(() =>
{
using (var messageStore = IoCFactory.Resolve <IMessageStore>())
{
messageStore.RemoveSentCommand(commandContext.MessageID);
}
});
}
catch (Exception ex)
{
_logger.Debug("send command quit", ex);
}
}
}, TaskCreationOptions.LongRunning);
#endregion
#region init process command reply worker
_replySubscriptionClient = CreateSubscriptionClient(_replyTopicName, _replySubscriptionName);
_subscriptionConsumeTask = Task.Factory.StartNew(() =>
{
while (!_exit)
{
BrokeredMessage brokeredMessage = null;
try
{
brokeredMessage = _replySubscriptionClient.Receive();
if (brokeredMessage != null)
{
var reply = new MessageReply(brokeredMessage);
ConsumeReply(reply);
}
}
catch (Exception ex)
{
Thread.Sleep(1000);
_logger.Error("consume reply error", ex);
}
finally
{
if (brokeredMessage != null)
{
brokeredMessage.Complete();
}
}
}
}, TaskCreationOptions.LongRunning);
#endregion
}
public void DeleteReply(MessageReply reply)
{
_context.MessageReply.Remove(reply);
}
protected override void ConsumeMessage(IFramework.MessageQueue.EQueue.MessageFormat.MessageContext messageContext, EQueueProtocols.QueueMessage queueMessage)
{
if (messageContext == null || messageContext.Message == null)
{
return;
}
var message = messageContext.Message as ICommand;
if (message == null)
{
return;
}
MessageReply messageReply = null;
var needRetry = message.NeedRetry;
bool commandHasHandled = false;
IMessageStore messageStore = null;
try
{
PerMessageContextLifetimeManager.CurrentMessageContext = messageContext;
messageStore = IoCFactory.Resolve <IMessageStore>();
commandHasHandled = messageStore.HasCommandHandled(messageContext.MessageID);
if (!commandHasHandled)
{
var messageHandler = HandlerProvider.GetHandler(message.GetType());
_Logger.InfoFormat("Handle command, commandID:{0}", messageContext.MessageID);
if (messageHandler == null)
{
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, new NoHandlerExists());
}
else
{
do
{
try
{
((dynamic)messageHandler).Handle((dynamic)message);
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, messageContext.Reply);
needRetry = false;
}
catch (Exception ex)
{
if (!(ex is OptimisticConcurrencyException) || !needRetry)
{
throw;
}
}
} while (needRetry);
}
}
else
{
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, new MessageDuplicatelyHandled());
}
}
catch (Exception e)
{
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, e.GetBaseException());
if (e is DomainException)
{
_Logger.Warn(message.ToJson(), e);
}
else
{
_Logger.Error(message.ToJson(), e);
}
if (messageStore != null)
{
messageStore.SaveFailedCommand(messageContext);
}
}
finally
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
}
if (!commandHasHandled)
{
OnMessageHandled(messageContext, messageReply);
HandledMessageCount++;
}
}
public async Task <ApiResponse <MessageReply> > PutActionsMessageAsync(DeviceId device, MessageReply reply)
{
var uri = $"/api/actions/messages/{device.FullId}";
return(await PutAsync(uri, reply));
}
public JsonResult ReplyToCustomer(MessageReply x)
{
int AdminId = (int)Session["AdminId"];
string AdminName = db.AdminSettings.FirstOrDefault(c => c.AdminId == AdminId).DisplayName;
var response = "";
if (x != null)
{
MessageReply xdb = new MessageReply();
xdb.Content = x.Content;
xdb.PostDate = DateTime.Now;
xdb.AdminId = AdminId;
xdb.MessageId = x.MessageId;
db.MessageReplies.Add(xdb);
db.SaveChanges();
string FilePath = Server.MapPath("~/Assets/template/EmailReplyTemplate.cshtml");
StreamReader str = new StreamReader(FilePath);
string MailText = str.ReadToEnd();
str.Close();
Message m = db.Message.FirstOrDefault(c => c.Id == xdb.MessageId);
MailMessage mail = new MailMessage();
mail.From = new MailAddress("*****@*****.**", "*****@*****.**");
mail.To.Add(new MailAddress(m.Email));
mail.Subject = "RE:" + m.Subject + "";
MailText = MailText.Replace("[UserName]", m.Name.Trim());
MailText = MailText.Replace("[AdminName]", AdminName.Trim());
MailText = MailText.Replace("[ReplyContent]", xdb.Content.Trim());
mail.Body = MailText;
//mail.Body = "<html><body><p> Dear " + m.Name + ",</p ><p> Thank you for your message.</p><br></br><p> " + xdb.Content + " </p><br></br><p> If you have any questions, please do not hesitate to contact us again.</p><p> Sincerely,<br><strong> " + AdminName + " </strong> from Autlines</br ></p></body></html>";
mail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
smtp.UseDefaultCredentials = false;
smtp.Credentials = new NetworkCredential("*****@*****.**", "@utoc@rRENT2020");
smtp.Send(mail);
m.isReplied = true;
db.Entry(m).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
response = "true";
}
return(Json(response, JsonRequestBehavior.AllowGet));
}
public async Task SeedAsync()
{
if (await _messages.GetCountAsync() > 0)
{
return;
}
var path = Path.Combine(Directory.GetCurrentDirectory(), "messages.json");
var messages = await path.FromJsonFile <List <MessageModel> >("RECORDS");
if (!messages.Any())
{
return;
}
var data = new List <Message>();
var users = await _users.GetListAsync();
var me = users.First();
var wife = users.Last();
foreach (var item in messages)
{
var replyData = new List <MessageReply>();
if (!item.ReplyList.IsNullOrEmpty())
{
foreach (var reply in item.ReplyList.DeserializeToObject <List <ReplyList> >())
{
var messageReply = new MessageReply();
if (reply.Nick == "阿星Plus")
{
messageReply.UserId = me.Id.ToString();
messageReply.Name = me.Name;
messageReply.Avatar = me.Avatar;
}
else
{
messageReply.UserId = wife.Id.ToString();
messageReply.Name = wife.Name;
messageReply.Avatar = wife.Avatar;
}
messageReply.Content = new Converter().Convert(reply.Content);
messageReply.CreatedAt = $"{reply.Time}".TimestampToDateTime();
replyData.Add(messageReply);
}
}
data.Add(new Message
{
UserId = wife.Id.ToString(),
Name = wife.Name,
Avatar = wife.Avatar,
Content = new Converter().Convert(item.HtmlContent),
CreatedAt = $"{item.PubTime}".TimestampToDateTime(),
Reply = replyData
});
}
await _messages.InsertManyAsync(data);
Console.WriteLine($"Successfully processed {data.Count} message data.");
}
protected override void ConsumeMessage(IMessageContext commandContext)
{
var message = commandContext.Message as ICommand;
MessageReply messageReply = null;
if (message == null)
{
return;
}
var needRetry = message.NeedRetry;
bool commandHasHandled = false;
IMessageStore messageStore = null;
try
{
PerMessageContextLifetimeManager.CurrentMessageContext = commandContext;
messageStore = IoCFactory.Resolve <IMessageStore>();
commandHasHandled = messageStore.HasCommandHandled(commandContext.MessageID);
if (!commandHasHandled)
{
var messageHandler = HandlerProvider.GetHandler(message.GetType());
_Logger.InfoFormat("Handle command, commandID:{0}", commandContext.MessageID);
if (messageHandler == null)
{
messageReply = new MessageReply(commandContext.MessageID, new NoHandlerExists());
}
else
{
//var unitOfWork = IoCFactory.Resolve<IUnitOfWork>();
do
{
try
{
((dynamic)messageHandler).Handle((dynamic)message);
//unitOfWork.Commit();
messageReply = new MessageReply(commandContext.MessageID, commandContext.Reply);
needRetry = false;
}
catch (Exception ex)
{
if (!(ex is OptimisticConcurrencyException) || !needRetry)
{
throw;
}
}
} while (needRetry);
}
}
else
{
messageReply = new MessageReply(commandContext.MessageID, new MessageDuplicatelyHandled());
}
}
catch (Exception e)
{
messageReply = new MessageReply(commandContext.MessageID, e.GetBaseException());
if (e is DomainException)
{
_Logger.Warn(message.ToJson(), e);
}
else
{
_Logger.Error(message.ToJson(), e);
}
if (messageStore != null)
{
messageStore.SaveFailedCommand(commandContext);
}
}
finally
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
}
if (!commandHasHandled)
{
OnMessageHandled(commandContext, messageReply);
}
}
