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