public static async Task EndAlertsMax(string conversationId, string channelId) { MessageDetails myPerson = GetPerson(conversationId, channelId); if (myPerson != null) { var connector = new ConnectorClient(new Uri(myPerson.serviceUrl)); var message = await GetMessageAsync(myPerson); // TO DO send the right message to the User, take more params as entry message.Text = WivaldyBotResources.ResourceManager.GetString("AlertEndMax", myPerson.cultureInfo); message.TextFormat = "markdown"; //message.Text = "Hello, this is a notification"; message.Locale = myPerson.cultureInfo.Name; await connector.Conversations.SendToConversationAsync((Activity)message); } }
public void SendGroupMessage(string messageText, string groupName, string senderUsername) { ChatGroup chatGroup = chatGroups.Where(x => x.GroupName.Equals(groupName)).FirstOrDefault(); if (chatGroup != null) { ChatUser messageSender = connectedChatUsers.Where(x => x.Username.Equals(senderUsername)).FirstOrDefault(); MessageDetails message = LMSChatHelper.GenerateMessageDetails(messageText, messageSender); chatGroup.GroupMessages.Add(message); List <string> connectionIds = LMSChatHelper.GenerateConnectionIds(chatGroup.GroupUsers); Clients.Clients(connectionIds).UpdateChat(messageSender, messageText, chatGroup.GroupName); } else { Clients.Caller.ShowMessage("Error while sending message."); } }
public async Task <ActionResult <MessageDetails> > PostMessageDetails(MessageDetails _MessageDetails) { _context.MessageDetails.Add(_MessageDetails); await _context.SaveChangesAsync(); #region "Service Bus Entry" const string ServiceBusConnectionString = "Endpoint=sb://auditor2client.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=BJtC7Tu9IhAH62XqaazRBI24PgeRj43cwbXAy0zbFLE="; //access policy const string QueueName = "a2cmessage"; queueClient = new QueueClient(ServiceBusConnectionString, QueueName); string ShareMessage = JsonConvert.SerializeObject(_MessageDetails); var message = new Message(Encoding.UTF8.GetBytes(ShareMessage)); await queueClient.SendAsync(message); #endregion return(CreatedAtAction("GetMessageDetails", new { id = _MessageDetails.Mid }, _MessageDetails)); }
private Task <IAsyncDisposable> StartKeepMessageInvisibleAsync( QueueClient queueClient, MessageDetails messageDetails) { #pragma warning disable CA2000 // Dispose objects before losing scope var updateMessageTokenSource = new CancellationTokenSource(); #pragma warning restore CA2000 // Dispose objects before losing scope var updateQueueMessageTask = KeepMessageInvisibleAsync(queueClient, messageDetails, updateMessageTokenSource.Token); var disposeAction = new DisposeAction(async() => { updateMessageTokenSource.Cancel(); updateMessageTokenSource.Dispose(); await updateQueueMessageTask; }); return(Task.FromResult((IAsyncDisposable)disposeAction)); }
protected override EmailParseResult Parse(MessageDetails message) { if (/*message.From != From ||*/ !_subjects.Contains(message.Subject)) { return(EmailParseResult.CreateError("Email was not recognized as transaction")); } var tr = new TransactionDomain { Iban = GetIban(message), Amount = GetAmount(message), Note = GetNote(message), Source = TransactionSource.ImportedFromEmail, CreatedTime = DateTimeContext.Now }; return(EmailParseResult.CreateSuccess(tr)); }
private async Task TryMoveToPoisonAsync( QueueClient queueClient, MessageDetails messageDetails, IAsyncDisposable?updateVisibilityStopAction) { if (messageDetails.Message.DequeueCount >= _workerOptions.MaxRetryCount) { try { await PoisonQueueClient.AddMessageAndCreateIfNotExistsAsync(messageDetails.Message.MessageText); await DeleteMessageAsync(queueClient, messageDetails, updateVisibilityStopAction); } catch (Exception e) { _logger.LogError(e, "TryMoveToPoisonAsync failed poison queue{poison_queue}", _workerOptions.PoisonQueueName); } } }
public async Task <IHttpActionResult> GetContacts([FromBody] MessageDetails i_Message) { string nickname = Thread.CurrentPrincipal.Identity.Name; if (i_Message.Sender != nickname) { return(BadRequest("Nicknames do not match.")); } using (CarWatchDBEntities entities = new CarWatchDBEntities()) { List <string> nicknameList = new List <string>(); List <Message> messages = await entities.Messages.Where(e => (e.Sender == i_Message.Sender) || (e.Receiver == i_Message.Sender)).ToListAsync(); foreach (Message msg in messages) { if (i_Message.Sender != msg.Sender) { if (!nicknameList.Contains(msg.Sender)) { nicknameList.Add(msg.Sender); } } else { if (!nicknameList.Contains(msg.Receiver)) { nicknameList.Add(msg.Receiver); } } } FacebookAccount account; List <FacebookAccount> fbList = new List <FacebookAccount>(); foreach (string item in nicknameList) { account = await entities.FacebookAccounts.Where(e => e.Nickname == item).FirstOrDefaultAsync(); fbList.Add(account); } return(Ok(fbList)); } }
public async Task <IActionResult> ViewMessage(int messageId) { var message = await _context.Messages.FirstOrDefaultAsync(m => m.MessageID == messageId); if (message != null) { var fromUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == message.FromUserID); var messageDetails = new MessageDetails { DateCreated = message.DateCreated, FromUser = fromUser, MessageContent = message.MessageContent, MessageID = message.MessageID, }; return(View(messageDetails)); } return(NotFound()); }
public static async Task ResumeCommand(string conversationId, string channelId, string consumption, Alert alert) { //find the good person in the list MessageDetails myPerson = GetPerson(conversationId, channelId); if (myPerson != null) { var connector = new ConnectorClient(new Uri(myPerson.serviceUrl)); var message = await GetMessageAsync(myPerson); // TO DO send the right message to the User, take more params as entry string res = "AlertExceedSwitch"; message.Text = string.Format(WivaldyBotResources.ResourceManager.GetString(res, myPerson.cultureInfo), consumption); message.TextFormat = "markdown"; //message.Text = "Hello, this is a notification"; message.Locale = myPerson.cultureInfo.Name; await connector.Conversations.SendToConversationAsync((Activity)message); } }
//[ValidateAntiForgeryToken] public ActionResult ForgotPassword(MatchBX.Models.ForgotPasswordViewModel model) { objUsers.Email = model.Email; MessageDetails _Model = new MessageDetails(); if (ModelState.IsValid) { ValidateEmail(objUsers); _Model.Message = TempData.Peek("ErrorMessage").ToString(); _Model.Status = TempData.Peek("Status").ToString(); return(Json(_Model, JsonRequestBehavior.AllowGet)); } else { _Model.Message = "Invalid Email"; _Model.Status = "false"; return(Json(_Model, JsonRequestBehavior.AllowGet)); } }
public string Post(HttpRequestMessage request) { string response = ""; //string s = Request.Content.ReadAsStringAsync().Result; var jsonString = request.Content.ReadAsStringAsync().Result; MessageDetails msgDetails = Newtonsoft.Json.JsonConvert.DeserializeObject <MessageDetails>(jsonString); UserDetail userDetail = new UserDetail(); ResponseMessage resp = new ResponseMessage(); try { if (msgDetails != null || msgDetails.Id != null) { if (GeneralActions.GetEncryptData(msgDetails.Id, ref userDetail, ref resp)) { var context = GlobalHost.ConnectionManager.GetHubContext <IMIchatHub>(); // context.Clients.All.Send("Admin", "stop the chat"); context.Clients.Group(userDetail.teamId.ToString()).chatMessage(msgDetails.Message); resp.code = 200; resp.desc = "Success"; } } else { resp.code = 405; resp.desc = "Invalid Data"; } } catch { resp.code = 500; resp.desc = "Error"; } finally { response = Newtonsoft.Json.JsonConvert.SerializeObject(resp); } return(response); }
public string PostMessage([FromBody] MessageDetails msgDetails) { string response = ""; UserDetail userDetail = new UserDetail(); ResponseMessage resp = new ResponseMessage(); try { if (msgDetails != null) { if (GeneralActions.GetEncryptData(msgDetails.Id, ref userDetail, ref resp)) { var context = GlobalHost.ConnectionManager.GetHubContext <IMIchatHub>(); List <UserDetail> toUserList = IMIchatHub.ConnectedUsers.Where(x => x.userId == userDetail.userId).ToList(); foreach (var user in toUserList) //if logined into different browsers { context.Clients.Client(user.connectionId).sendPrivateMessage(msgDetails.Message); } resp.code = 200; resp.desc = "Success"; } } else { resp.code = 405; resp.desc = "Invalid Data"; } } catch { resp.code = 500; resp.desc = "Error"; } finally { response = Newtonsoft.Json.JsonConvert.SerializeObject(resp); } return(response); }
private static async Task <IMessageActivity> GetMessageAsync(MessageDetails myPerson) { var userAccount = new ChannelAccount(myPerson.toId, myPerson.toName); var botAccount = new ChannelAccount(myPerson.fromId, myPerson.fromName); var connector = new ConnectorClient(new Uri(myPerson.serviceUrl)); IMessageActivity message = Activity.CreateMessageActivity(); string conversationId = myPerson.conversationId; if (!string.IsNullOrEmpty(myPerson.conversationId) && !string.IsNullOrEmpty(myPerson.channelId)) { message.ChannelId = myPerson.channelId; } else { conversationId = (await connector.Conversations.CreateDirectConversationAsync(botAccount, userAccount)).Id; } message.From = botAccount; message.Recipient = userAccount; message.Conversation = new ConversationAccount(id: conversationId); return(message); }
public async Task HandleMessageAsync(SocketUserMessage message) { var msgDetails = new MessageDetails { AuthorId = message.Author.Id, ChannelId = message.Channel.Id, Content = message.Content, Timestamp = message.Timestamp }; var response = await GetMatchingResponse(msgDetails); if (response is null) { return; } var msg = response.GetResponse(msgDetails); msg = client.ReplaceEmojis(msg); await message.Channel.SendMessageAsync(msg); }
private static MessageDetails CreateDetails(MatchCollection matchCollection) { if (matchCollection.Count == 0) return MessageDetails.Empty; var details = new MessageDetails { User = matchCollection[0].Groups["user"].ToString(), Hostmask = matchCollection[0].Groups["hostmask"].ToString(), Action = matchCollection[0].Groups["action"].ToString(), Target = matchCollection[0].Groups["target"].ToString(), Parameters = matchCollection[0].Groups["parameters"].ToString() }; if (details.Parameters.Length > 0) { if (details.Parameters[0] == ':') details.Parameters = details.Parameters.Substring(1); } return details; }
//This will send simple notification public static async Task Resume(string conversationId, string channelId, float consumption, Alert alert) { //find the good person in the list MessageDetails myPerson = GetPerson(conversationId, channelId); if (myPerson != null) { var connector = new ConnectorClient(new Uri(myPerson.serviceUrl)); var message = await GetMessageAsync(myPerson); // TO DO send the right message to the User, take more params as entry string res = ""; switch (alert.AlertType) { case AlertEnum.Instant: res = "AlertExceedInstant"; break; case AlertEnum.Total: res = "AlertExceedTotal"; break; case AlertEnum.Switch: //should not happen! res = "AlertExceedSwitch"; break; default: break; } message.Text = string.Format(WivaldyBotResources.ResourceManager.GetString(res, myPerson.cultureInfo), consumption.ToString("N1", myPerson.cultureInfo), alert.Threshold.ToString("N1", myPerson.cultureInfo)); message.TextFormat = "markdown"; //message.Text = "Hello, this is a notification"; message.Locale = myPerson.cultureInfo.Name; await connector.Conversations.SendToConversationAsync((Activity)message); } }
private MessageDetails getMessage(string response) { MessageDetails result = new MessageDetails(); try { var lengthMatch = Regex.Match(response, @"^\S*(?:cmgr:.+,(\d+)\s*)$", RegexOptions.IgnoreCase | RegexOptions.Multiline); var pduMatch = Regex.Match(response, @"^(?:\s*([a-fA-F0-9]+)\s*)$", RegexOptions.IgnoreCase | RegexOptions.Multiline); if (lengthMatch.Success && lengthMatch.Groups.Count > 1 && pduMatch.Success && pduMatch.Groups.Count > 1) { int length = int.Parse(lengthMatch.Groups[1].Value.Trim()); string pdu = pduMatch.Groups[1].Value.Trim(); var profile = _manager["default-receive"]; result = profile.GetMessage(pdu, length); } } catch { } return(result); }
public Guid SendMessage([FromBody] SendMessageModel model, string messageType) { if ((model.DestinationUserName != UserName) && (!Program.ConnectionsManager.ConnectionExists(UserName, model.DestinationUserName))) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Unauthorized) { ReasonPhrase = "You are not authorised to send message to the specified user" }); } MessageType type = MessageType.UserMessage; if (!string.IsNullOrEmpty(messageType) && !Enum.TryParse <MessageType>(messageType, out type)) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "Invalid Message Type" }); } var details = new MessageDetails() { Date = DateTime.Now, SourceDeviceId = DeviceId, SourceUserName = UserName, DestinationUserName = model.DestinationUserName, Value = model.Message, MessageType = type }; QueueInstances.MessageQueue.Add(details); #if DEBUG Console.WriteLine(string.Format("SendMessage : Created message from '{0}' to '{1}'", UserName, model.DestinationUserName)); #endif UserCommandsLock.Wake(model.DestinationUserName); return(details.Id); }
public Task DirectMessage(string message, string targetUserName, string loginUserName) { var senderUser = dbContext.UserDetails.Where(u => u.UserName == loginUserName).FirstOrDefault(); var receiverUser = dbContext.UserDetails.Where(u => u.UserName == targetUserName).FirstOrDefault(); MessageDetails objMess = new MessageDetails(); if (senderUser != null && receiverUser != null) { if (objMess.MsgId == 0) { objMess.SenderUserId = senderUser.UserId; objMess.ReceiverUserId = receiverUser.UserId; objMess.SenderUserName = senderUser.UserName; objMess.ReceiverUserName = receiverUser.UserName; objMess.ConnectionId = Context.ConnectionId; objMess.Message = senderUser.FullName + " says " + message; dbContext.Entry <MessageDetails>(objMess).State = EntityState.Added; dbContext.SaveChanges(); } } return(Clients.Client(Context.ConnectionId).SendAsync("ReceiveUserMessage", message, senderUser)); }
/// <summary> /// Gets the message details. /// </summary> /// <param name="jobGUID">The job GUID.</param> /// <returns>A MessageDetails struct.</returns> private static MessageDetails GetMessageDetails(Guid jobGUID) { var details = new MessageDetails(); var connectionString = ConfigurationManager.ConnectionStrings["webAppConnectionString"].ToString(); var sqlStatement = @"SELECT TOP 1 Id, UserEmail FROM Analyses WHERE JobGUID = @jobGUID;"; using (var sqlConnection = new SqlConnection(connectionString)) using (var command = new SqlCommand(sqlStatement, sqlConnection)) { sqlConnection.Open(); command.Parameters.AddWithValue("@jobGUID", jobGUID.ToString()); var reader = command.ExecuteReader(); if (reader.HasRows) { reader.Read(); int userNameOrdinal = reader.GetOrdinal("UserEmail"); int idOrdinal = reader.GetOrdinal("Id"); details.ClientEmailAddress = reader.GetString(userNameOrdinal); details.ReportId = reader.GetInt32(idOrdinal); } } return(details); }
public async Task <MessageDetails> Read(IPortPlug port, MessageStorageItem item) { MessageDetails result = new MessageDetails(); if (item == null || !item.IsValid || !_manager.ContainsProfile("default-receive")) { return(result); } if (await setFormat(port)) { var readParam = new CommandParameter(item.Index.ToString(), Constants.BasicSuccessfulResponse); var readCmd = new ParamATCommand(ATCommand.MessageRead.Command(), readParam); await readCmd.ExecuteAsync(port); if (readCmd.Succeeded()) { result = getMessage(readCmd.Response); } } return(result); }
public MessageSaveRequested(MessageDetails message) { this.CtorSet(_ => _.Message, message); }
public virtual async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result) { try { var message = await result; if (this.resumptionCookie == null) { this.resumptionCookie = new ResumptionCookie(message); } if (message.Text == WivaldyBotResources.DialogWelcomeLogout) { var reply = context.MakeMessage(); try { context.PrivateConversationData.SetValue(WivaldyBotResources.WivaldiConnectionString, ""); myWivaldy.Connection = ""; reply.Text = WivaldyBotResources.DialogKeyRemoved; } catch (Exception err) { reply.Text = WivaldyBotResources.DialogErrorMessage + $" {err.Message}"; } await context.PostAsync(reply); } else if (message.Text == WivaldyBotResources.DialogWelcomeKey) { var reply = context.MakeMessage(); try { string key; context.PrivateConversationData.TryGetValue(WivaldyBotResources.WivaldiConnectionString, out key); reply.Text = String.Format(WivaldyBotResources.DialogKeyIs, key); } catch (Exception err) { reply.Text = WivaldyBotResources.DialogErrorMessage + $"{err.Message}"; } await context.PostAsync(reply); } string wiwaldyconnection; if ((!context.PrivateConversationData.TryGetValue(WivaldyBotResources.WivaldiConnectionString, out wiwaldyconnection)) || (myWivaldy.Connection == "")) { PromptDialog.Text(context, this.ResumeAfterPrompt, WivaldyBotResources.DialogGetPrivateKey); return; } else { myWivaldy.Connection = wiwaldyconnection; } if (message.Text == WivaldyBotResources.DialogWelcomeElectricity) { await this.ElectricityMessageAsync(context); return; } else if (message.Text == WivaldyBotResources.DialogWelcomeCompare) { await this.CompareMessageAsync(context); return; } else if (message.Text == WivaldyBotResources.DialogWelcomeAlert) { // Store information about this specific point the conversation, so that the bot can resume this conversation later. if (me.serviceUrl == null) { me = new MessageDetails(); me.toId = message.From.Id; me.toName = message.From.Name; me.fromId = message.Recipient.Id; me.fromName = message.Recipient.Name; me.serviceUrl = message.ServiceUrl; me.channelId = message.ChannelId; me.conversationId = message.Conversation.Id; me.cultureInfo = System.Globalization.CultureInfo.CurrentUICulture; } bool bFound = false; foreach (var mess in ConversationStarter.messageDetails) { if (mess.channelId == me.channelId) { if (mess.conversationId == me.conversationId) { if (mess.fromId == me.fromId) { if (mess.fromName == me.fromName) { if (mess.serviceUrl == me.serviceUrl) { if (mess.toId == me.toId) { if (mess.toName == me.toName) { bFound = true; break; } } } } } } } } if (!bFound) { ConversationStarter.messageDetails.Add(me); } context.Call(new DialogAlert(this.alert), this.DialogAlertResumeAfter); return; } await this.WelcomeMessageAsync(context); } catch (Exception ex) { var reply = context.MakeMessage(); reply.Text = $"{WivaldyBotResources.DialogErrorMessage}: {ex.Message}"; ResetSettings(); await context.PostAsync(reply); await this.WelcomeMessageAsync(context); } }
//static string GetWelcome(MessageDetails details) => details switch //{ // ("english", "morning", _) => "Good morning", // ("english", "evening", _) => "Good evening", // ("german", "morning", _) => "Guten Morgen", // ("german", "evening", _) => "Guten Abend", // (_, _, "admin") => "Hello, Admin", // _ => "Здрасьть" //}; static string GetWelcome(MessageDetails details) => details switch { ("english", "morning", _) => "Good morning",
public async Task <IList <AutoReact> > GetMatchingReactions(MessageDetails message) { return(await repository.FindMatchingReactions(message)); }
public IMQGetChannelMessagesResult GetChannelMessages(IMQGetChannelMessagesParams paramsGetMsgs) { var result = new DbMQGetChannelMessagesResult(); string spName = "[SP_Get_Channel_Messages]"; SqlConnection conn = OpenConnection("ConnectionString"); SqlCommand cmd = new SqlCommand(); cmd.CommandText = schema + "." + spName; cmd.CommandType = CommandType.StoredProcedure; cmd.Connection = conn; try { SqlParameter paramChannelId = new SqlParameter("@IN_Channel_Id", SqlDbType.BigInt, 0, ParameterDirection.Input, false, 0, 0, "", DataRowVersion.Current, paramsGetMsgs.ChannelId); SqlParameter paramReceiverId = new SqlParameter("@IN_Receiver_Id", SqlDbType.BigInt, 0, ParameterDirection.Input, false, 0, 0, "", DataRowVersion.Current, paramsGetMsgs.ReceiverId); cmd.Parameters.Add(paramChannelId); cmd.Parameters.Add(paramReceiverId); DataSet ds = new DataSet(); SqlDataAdapter da = new SqlDataAdapter(); da.SelectCommand = cmd; da.Fill(ds); if (ds.Tables.Count >= 1) { for (int i = 0; i < ds.Tables[0].Rows.Count; ++i) { DataRow r = ds.Tables[0].Rows[i]; MessageDetails md = new MessageDetails(); md.Id = (long)r["Message_Id"]; md.ChannelName = (string)r["Channel_Name"]; md.ChannelId = (long)r["Channel_Id"]; md.Payload = (string)r["Message_Payload"]; md.SenderId = !DBNull.Value.Equals(r["Sender_Id"]) ? (long?)r["Sender_Id"] : null; md.SubscriberId = !DBNull.Value.Equals(r["Subscriber_Id"]) ? (long?)r["Subscriber_Id"] : null; md.Type = (string)r["Message_Type"]; result.Messages.Add(md); } } result.Success = true; } catch (Exception ex) { result.Success = false; result.Errors.Add(new Interfaces.Error() { Message = ex.Message, Code = Interfaces.EErrorCodes.MQDbError, Type = Interfaces.EErrorType.Error }); } conn.Close(); return(result); }
/// <summary> /// Determines whether the message is a match for this reaction. /// </summary> /// <param name="msg">The message.</param> /// <returns>A bool indicating whether the message matches.</returns> public virtual bool Matches(MessageDetails msg) { return(msg.Content.Contains(Phrase, StringComparison.InvariantCultureIgnoreCase)); }
public async Task <CreatePropertyCommandResult> Handle(CreatePropertyCommand request, CancellationToken cancellationToken) { #region Create property aggregate root var createdProperty = new CreatePropertyCommandResult(); var address = new PropertyAddress(request.PropertySuiteNumber, request.PropertyNumber, request.PropertyStreet, request.PropertyCity, request.PropertyStateProvince, request.PropertyZipPostCode, request.PropertyCountry); var feature = new PropertyFeature(request.NumberOfBathrooms, request.NumberOfBathrooms, request.NumberOfLayers, request.NumberOfParking, request.BasementAvailable, request.TotalLivingArea, request.IsShared, request.FeatureNotes); var facility = new PropertyFacility(request.Stove, request.Refrigerator, request.Dishwasher, request.AirConditioner, request.Laundry, request.BlindsCurtain, request.Furniture, request.Tvinternet, request.CommonFacility, request.SecuritySystem, request.UtilityIncluded, request.FireAlarmSystem, request.FacilityNotes, request.Others); var property = new Property(request.PropertyName, request.PropertyDesc, request.Type, request.PropertyManagerUserName, request.PropertyBuildYear, true, request.IsShared, request.Status, request.BasementAvailable, DateTime.Now, DateTime.Now, address, facility, feature); await _context.AddAsync(property); #endregion PropertyOwner owner = null; if (request.PropertyOwnerId == 0) { object ownerAddress = null; if (!request.IsSameAddress) { ownerAddress = new OwnerAddress(request.OwnerStreetNumber, request.OwnerCity, request.OwnerStateProv, request.OwnerCountry, request.OwnerZipPostCode); } else { ownerAddress = new OwnerAddress(request.PropertySuiteNumber + " " + request.PropertyNumber + " " + request.PropertyStreet, request.PropertyCity, request.PropertyStateProvince, request.PropertyCountry, request.PropertyZipPostCode); } owner = property.AddOwner("NotSet", request.FirstName, request.LastName, request.ContactEmail, request.ContactTelephone1, request.ContactTelephone2, request.OnlineAccessEnbaled, request.UserAvartaImgUrl, request.IsActive, request.RoleId, request.Notes, (OwnerAddress)ownerAddress); await _context.AddAsync(owner); } else { owner = _context.PropertyOwner.FirstOrDefault(o => o.Id == request.PropertyOwnerId); var ownerProperty = property.AddExsitingOwner(owner); owner.OwnerProperty.Add(ownerProperty); } try { await _context.SaveChangesAsync(); // comment out for testing message sending ONLY int PropertyId = property.Id; int NewOwnerId = owner.Id; request.PropertyId = property.Id; request.CreatedDate = property.Created; request.UpdateDate = property.Modified; //Populate return resultEnum.GetName(typeof()) // createdProperty.Id = PropertyId; createdProperty.PropertyName = request.PropertyName; createdProperty.Type = request.Type.ToString(); createdProperty.Status = request.Status.ToString(); createdProperty.PropertyLogoImgUrl = request.PropertyLogoImgUrl; createdProperty.IsShared = request.IsShared; createdProperty.IsActive = request.IsActive; createdProperty.IsBasementSuite = request.IsBasementSuite; createdProperty.CreatedDate = DateTime.Now.ToString("MMMM dd, yyyy"); createdProperty.UpdateDate = DateTime.Now.ToString("MMMM dd, yyyy"); createdProperty.PropertySuiteNumber = request.PropertySuiteNumber; createdProperty.PropertyStreet = request.PropertyStreet; createdProperty.PropertyCity = request.PropertyCity; createdProperty.PropertyStateProvince = request.PropertyStateProvince; createdProperty.PropertyZipPostCode = request.PropertyZipPostCode; createdProperty.PropertyCountry = request.PropertyCountry; Log.Information("Property with id {PropertyName} has been successfully created.", property.PropertyName); // Publish Domain Event (MediatR pattern) AssetCore.Events.PropertyCreatedEvent domainEvent = new AssetCore.Events.PropertyCreatedEvent(property); await _mediator.Publish(domainEvent); // Publish Integration Event (RabbitMQ) var streetNum = request.PropertySuiteNumber + " " + request.PropertyNumber + " " + request.PropertyStreet; //var streetNum = address.PropertySuiteNumber + " " + address.PropertyNumber + " " + address.PropertyStreet; // Send message to MQ // PropertyCreatedEvent e = new PropertyCreatedEvent(Guid.NewGuid(), request.PropertyId, request.PropertyName, request.PropertyManagerUserName, request.PropertyBuildYear, request.Type.ToString(), request.BasementAvailable, request.IsShared, request.NumberOfBedrooms, request.NumberOfBathrooms, request.NumberOfLayers, request.NumberOfParking, request.TotalLivingArea, streetNum, request.PropertyCity, request.PropertyStateProvince, request.PropertyCountry, request.PropertyZipPostCode, NewOwnerId, request.FirstName, request.LastName, request.ContactEmail, request.ContactTelephone1, request.ContactTelephone2, request.OwnerStreetNumber, request.OwnerCity, request.OwnerStateProv, request.OwnerZipPostCode, request.OwnerCountry); try { await _messagePublisher.PublishMessageAsync(e.MessageType, e, "asset_created"); // publishing the message Log.Information("Message {MessageType} with Id {MessageId} has been published successfully", e.MessageType, e.MessageId); } catch (Exception ex) { Log.Error(ex, "Error while publishing {MessageType} message with id {MessageId}.", e.MessageType, e.MessageId); } // Log message for reconciliation purpose ******** This part can be replaced by Serilog *************** // var msgDetails = new MessageDetails(); msgDetails.PrincicipalId = e.PropertyId; msgDetails.PrincipalType = "Property"; msgDetails.PrincipalNameDesc = e.PropertyName; msgDetails.OperationType = "Create"; var details = msgDetails.ToBsonDocument(); var msg = new Message(e.MessageId, "Asset Management", details, "asset_created", "asset_created.*", "Publish", DateTime.Now); await _loggingService.LogMessage(msg); } catch (Exception ex) { //throw ex; Log.Error(ex, "Error while creating property, {PropertyName} has not been created.", request.PropertyName); } return(createdProperty); //return new CreatePropertyCommandResult() { }; }
public async Task <IActionResult> Index() { FeedBackViewModel vm = new FeedBackViewModel(); vm.Messages = new List <MessageDetails>(); vm.ArchivedMessages = new List <MessageDetails>(); var user = await _userManager.GetUserAsync(HttpContext.User); if (user != null) { var userId = user.Id; var messages = await _context.Messages.Where(m => m.ToUserID == userId && m.IsArchived == false).ToListAsync(); var archivedMessages = await _context.Messages.Where(m => m.ToUserID == userId && m.IsArchived == true).ToListAsync(); if (messages != null) { foreach (var message in messages) { var fromUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == message.FromUserID); var toUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == message.ToUserID); var messageDetails = new MessageDetails { FromUserID = message.FromUserID, FromUser = fromUser, ToUserID = message.ToUserID, ToUser = toUser, MessageContent = message.MessageContent, MessageID = message.MessageID, DateCreated = message.DateCreated }; vm.Messages.Add(messageDetails); } vm.UserID = userId; } if (archivedMessages != null) { foreach (var aMessage in archivedMessages) { var fromUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == aMessage.FromUserID); var toUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == aMessage.ToUserID); var messageDetails = new MessageDetails { FromUserID = aMessage.FromUserID, FromUser = fromUser, ToUserID = aMessage.ToUserID, ToUser = toUser, MessageContent = aMessage.MessageContent, MessageID = aMessage.MessageID, DateCreated = aMessage.DateCreated }; vm.ArchivedMessages.Add(messageDetails); } vm.UserID = userId; } var x = vm.ArchivedMessages.Count; var y = vm.Messages.Count; return(View(vm)); } return(View()); }
private void ProducerRoutine(object config) { var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data.dat"); byte[] info = File.ReadAllBytes(filePath); var startMessage = "---Start of Test---"; var endingMessage = "---End of Test---"; var startMessageBytes = Encoding.ASCII.GetBytes(startMessage); var endMessageBytes = Encoding.ASCII.GetBytes(endingMessage); var b64StartMessage = Convert.ToBase64String(startMessageBytes); var b64EndMessage = Convert.ToBase64String(endMessageBytes); var base64String = Convert.ToBase64String(info); var key = cutilEncrypt.Key; var iv = cutilEncrypt.IV; Action <DeliveryReport <string, string> > handler = r => Console.WriteLine(!r.Error.IsError ? $"Delivered message to {r.TopicPartitionOffset}" : $"Delivery Error: {r.Error.Reason}"); var count = 10; var startTime = DateTime.Now.Ticks; producerDelay = messagesPerSecond > 0 ? 1000 / messagesPerSecond : 0; for (int i = 0; i < count; ++i) { try { var timeInUTC = DateTime.UtcNow; // Encrypt data using AES string dataToEncrypt; if (i == 0) { dataToEncrypt = string.Format("{0}#{1}", b64StartMessage, timeInUTC.ToFileTimeUtc()); } else if (i == count - 1) { dataToEncrypt = string.Format("{0}#{1}", b64EndMessage, timeInUTC.ToFileTimeUtc()); } else { dataToEncrypt = string.Format("{0}#{1}", base64String, timeInUTC.ToFileTimeUtc()); } //var encryptedValue = cutilEncrypt.EncryptData(dataToEncrypt); var message = EncryptMessage(dataToEncrypt);// String.Format("{0}#{1}", messageKey, Convert.ToBase64String(encryptedValue)); var msg = new MessageDetails() { Message = message, SentTime = DateTime.UtcNow }; var uid = Guid.NewGuid().ToString(); messages.Add(uid, msg); var m = new Message <string, string>() { Key = uid, Value = message, Timestamp = new Timestamp(timeInUTC) }; producer.Produce(m); Thread.Sleep(producerDelay); } catch (Exception ex) { Console.WriteLine(ex.ToString()); Thread.Sleep(5000); } } var endTime = DateTime.Now.Ticks; var totalTimeTaken = (endTime - startTime) / TimeSpan.TicksPerMillisecond; Console.WriteLine("Total time took to produce {0} messages is {1}ms\r\n", count, totalTimeTaken); }
public async Task <AutoResponse> FindMatchingResponse(MessageDetails message) { var responses = await GetAll(); return(responses.FirstOrDefault(response => response.Matches(message))); }