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