public void NestedUnitsWithSameScopeInnerException()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (var unit = new UnitOfWork())
{
Repository.Data.Save(entity);
using (var unit2 = new UnitOfWork())
{
Repository.Data.Save(entity2);
Assert.Throws <UnitOfWorkException>(() => unit2.Rollback());
// will throw exception because this is not the owner of the UOW
}
// user will not come to this point and try to commit transaction
// else it should throw exception
Assert.Throws <UnitOfWorkException>(() => unit.Commit());
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.Null(entity);
Assert.Null(entity2);
}
public void EntityCacheTest()
{
var sessionFactory = IoC.Resolve <ISessionFactory>();
//Create and save entity. Reopen conversation to clean 1-st level cache.
var item = new SimpleCacheEntity
{
Name = "Cache Test #1"
};
Repository.Data.Save(item);
ConversationHelper.ReOpen();
//Check if entity exists in cache directly.
var cache = GetCachedObjectDirectly(item.Id, item.GetType());
Assert.NotNull(cache);
//Check if entity is loaded from cache instead of getting from DB.
Console.WriteLine("*** No call to DB should be done from this moment ***");
sessionFactory.Statistics.Clear();
var retrievedEntity = Repository.Data.Get <SimpleCacheEntity>(item.Id);
Assert.NotNull(retrievedEntity);
Assert.Equal(item.Id, retrievedEntity.Id);
Assert.Equal(item.Name, retrievedEntity.Name);
Assert.Equal(0, sessionFactory.Statistics.EntityLoadCount);
}
public void NestedUnitsWithSameScopeRollbackBothTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (var unit = new UnitOfWork())
{
Repository.Data.Save(entity);
using (var unit2 = new UnitOfWork())
{
Repository.Data.Save(entity2);
Assert.Throws <UnitOfWorkException>(() => unit2.Rollback());
}
unit.Rollback();
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.Null(entity);
Assert.Null(entity2);
}
public void NestedUnitsWithSameScopeOuterDisposeTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (new UnitOfWork())
{
Repository.Data.Save(entity);
using (var unit2 = new UnitOfWork())
{
Repository.Data.Save(entity2);
unit2.Commit();
}
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.Null(entity);
Assert.Null(entity2);
}
public void NestedUnitsWithNewInnerScopeRollbackAndCommitTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (var unit = new UnitOfWork())
{
Repository.Data.Save(entity);
using (var unit2 = new UnitOfWork(UnitOfWorkScopeType.New))
{
Repository.Data.Save(entity2);
unit2.Rollback();
}
unit.Commit();
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.NotNull(entity);
Assert.Null(entity2);
}
public TextMessageDataStore(ContentResolver contentResolver, string threadId)
{
var messages = ConversationHelper.GetMessagesByThreadId(contentResolver, threadId);
items.Clear();
items.AddRange(messages);
}
public void UnitOfWorkRollBackAfterRollbackTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (var unit = new UnitOfWork())
{
//Some external method
Repository.Data.Save(entity);
UnitOfWork.Current.Rollback();
Assert.Throws <UnitOfWorkException>(() => Repository.Data.Save(entity2));
unit.Rollback();
}
Repository.Data.Cache.Clear(entity);
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
Assert.Null(entity);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.Null(entity2);
}
public void QueryCacheTest()
{
var sessionFactory = IoC.Resolve <ISessionFactory>();
//Create and save entities. Reopen conversation to clean 1-st level cache.
var item1 = new SimpleCacheEntity
{
Name = "Query Cache Test #1"
};
var item2 = new SimpleCacheEntity
{
Name = "Query Cache Test #2"
};
Repository.Data.Save(item1);
Repository.Data.Save(item2);
ConversationHelper.ReOpen();
//Query the entities by name
var query = Repository.Data.Get <SimpleCacheEntity>().Where(x => x.Name.Contains("Query Cache Test"));
var queryResult = query.All();
Assert.NotEmpty(queryResult);
ConversationHelper.ReOpen();
//Query once again and check if the result is loaded from cache instead of getting from DB.
Console.WriteLine("*** No call to DB should be done from this moment ***");
sessionFactory.Statistics.Clear();
var cachedQueryResult = query.All();
Assert.NotEmpty(cachedQueryResult);
Assert.Equal(0, sessionFactory.Statistics.EntityLoadCount);
}
public static IEnumerable <Thread> GetSentSMS(Context context)
{
var uri = Telephony.Sms.Sent.ContentUri;
var groupedThreads = ConversationHelper.GetDistinctThreads(context, uri);
var populatedThreads = ConversationHelper.GetThreadDetails(context, uri, groupedThreads);
return(populatedThreads);
}
private async Task SaveAnswer(IDialogContext context, IMessageActivity message)
{
var question = context.PrivateConversationData.GetValue <string>(Constants.QuestionToAnswerKey);
var typing = context.MakeMessage();
typing.Type = ActivityTypes.Typing;
await context.PostAsync(typing);
await this.updateKnowledgeBaseService.AddAnswer(question, message.Text);
context.PrivateConversationData.RemoveValue(Constants.IsAnsweringKey);
context.PrivateConversationData.RemoveValue(Constants.QuestionToAnswerKey);
if (ConversationHelper.IsSlackChannel(message))
{
var responseUrl = context.PrivateConversationData.GetValue <string>(Constants.SlackResponseUrlKey);
context.PrivateConversationData.RemoveValue(Constants.SlackResponseUrlKey);
var interactiveMessage = new SlackInteractiveMessage
{
ResponseType = "in_channel",
DeleteOriginal = true,
Text = $"Wow! I just learnt something new. Thanks {message.From.Name}!",
Attachments =
{
new SlackAttachment
{
Color = "#36a64f",
Title = $"{question}",
Text = message.Text
}
}
};
await SendSlackInteractiveMessage(responseUrl, interactiveMessage);
}
else
{
var reply = context.MakeMessage();
reply.Text = $"Wow! I just learnt something new. Thanks {message.From.Name}!";
reply.Attachments = new List <Attachment>
{
new HeroCard
{
Title = question,
Text = message.Text,
}.ToAttachment()
};
await context.PostAsync(reply);
}
await context.FlushAsync(CancellationToken.None);
context.Wait(this.MessageReceivedAsync);
}
/// <summary>
/// Initializes a new instance of the <see cref="MatchingService"/> class.
/// </summary>
/// <param name="dataProvider">The data provider to use</param>
/// <param name="conversationHelper">Conversation helper instance to notify team members</param>
/// <param name="telemetryClient">The telemetry client to use</param>
/// <param name="botAdapter">Bot adapter.</param>
public MatchingService(IBotDataProvider dataProvider, ConversationHelper conversationHelper, TelemetryClient telemetryClient, BotAdapter botAdapter)
{
this.dataProvider = dataProvider;
this.conversationHelper = conversationHelper;
this.telemetryClient = telemetryClient;
this.botAdapter = botAdapter;
this.maxPairUpsPerTeam = Convert.ToInt32(CloudConfigurationManager.GetSetting("MaxPairUpsPerTeam"));
this.botDisplayName = CloudConfigurationManager.GetSetting("BotDisplayName");
}
private void InitializeConversation()
{
IEnumerable <SimpleMessage> conversation = _cappuMessageController.GetConversation(new SimpleUser(Conversation.TargetUsername));
foreach (var message in conversation)
{
Messages.Add(new OwnSimpleMessage(message));
}
ConversationHelper = new ConversationHelper(Conversation, Messages);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
SignalHelperFacade.ChatSignalHelper.PrivateMessageReceivedHandler -= SignalHelperOnMessageReceived;
ConversationHelper.Dispose();
}
base.Dispose(disposing);
}
public void NestedUnitsCombinatedTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
var entity3 = new SimpleEntity
{
Name = "UnitTest3"
};
var entity4 = new SimpleEntity
{
Name = "UnitTest4"
};
using (var unit = new UnitOfWork())
{
Repository.Data.Save(entity);
using (var unit2 = new UnitOfWork())
{
Repository.Data.Save(entity2);
using (var unit3 = new UnitOfWork())
{
Repository.Data.Save(entity3);
unit3.Commit();
}
using (var unit4 = new UnitOfWork(UnitOfWorkScopeType.New))
{
Repository.Data.Save(entity4);
unit4.Commit();
}
Assert.Throws <UnitOfWorkException>(() => unit2.Rollback());
}
Assert.Throws <UnitOfWorkException>(() => unit.Commit());
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
entity3 = Repository.Data.Get <SimpleEntity>(entity3.Id);
entity4 = Repository.Data.Get <SimpleEntity>(entity4.Id);
Assert.Null(entity);
Assert.Null(entity2);
Assert.Null(entity3);
Assert.NotNull(entity4);
}
public void SaveClassWithStorageInfo()
{
Guid id;
using (var tx = new TransactionScope())
{
var e = new TestStorageEntity
{
Name = "My file",
StorageStream = GetType().Assembly.GetManifestResourceStream(GetType().Namespace + ".IMGP2526.jpg")
};
Repository.Data.Save(e);
id = e.Id;
tx.Complete();
}
ConversationHelper.ReOpen();
using (var tx = new TransactionScope())
{
var e = Repository.Data.Get <TestStorageEntity>(id);
e.Name += "1";
Repository.Data.Save(e);
tx.Complete();
}
ConversationHelper.ReOpen();
using (var tx = new TransactionScope())
{
var e = Repository.Data.Get <TestStorageEntity>(id);
e.Name += "2";
e.StorageStream = GetType().Assembly.GetManifestResourceStream(GetType().Namespace + ".IMGP2526.jpg");
Repository.Data.Save(e);
tx.Complete();
}
ConversationHelper.ReOpen();
using (new TransactionScope())
{
var e = Repository.Data.Get <TestStorageEntity>(id);
e.Name += "3";
e.StorageStream = GetType().Assembly.GetManifestResourceStream(GetType().Namespace + ".IMGP2526.jpg");
Repository.Data.Save(e);
}
ConversationHelper.ReOpen();
using (var tx = new TransactionScope())
{
var e = Repository.Data.Get <TestStorageEntity>(id);
Repository.Data.Delete(e);
tx.Complete();
}
ConversationHelper.ReOpen();
}
public MessageController(IOptions <PoCConversationConfiguration> configSettings)
{
this.configSettings = configSettings.Value;
conversation = new ConversationHelper(
this.configSettings.ConversationUsername,
this.configSettings.ConversationPassword,
this.configSettings.ConversationWorkspaceId,
this.configSettings.ProxyUse,
this.configSettings.ProxyHost,
this.configSettings.ProxyPort,
this.configSettings.ProxyHost,
this.configSettings.ProxyPassword);
}
/// <summary>
/// Initializes a new instance of the <see cref="IcebreakerBot"/> class.
/// </summary>
/// <param name="dataProvider">The data provider to use</param>
/// <param name="conversationHelper">Conversation helper instance to notify team members</param>
/// <param name="appCredentials">Microsoft app credentials to use.</param>
/// <param name="telemetryClient">The telemetry client to use</param>
public IcebreakerBot(IBotDataProvider dataProvider, ConversationHelper conversationHelper, MicrosoftAppCredentials appCredentials, TelemetryClient telemetryClient)
{
this.dataProvider = dataProvider;
this.conversationHelper = conversationHelper;
this.appCredentials = appCredentials;
this.telemetryClient = telemetryClient;
this.botDisplayName = CloudConfigurationManager.GetSetting("BotDisplayName");
this.disableTenantFilter = Convert.ToBoolean(CloudConfigurationManager.GetSetting("DisableTenantFilter"), CultureInfo.InvariantCulture);
var allowedTenants = CloudConfigurationManager.GetSetting("AllowedTenants");
this.allowedTenantIds = allowedTenants
?.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries)
?.Select(p => p.Trim())
.ToHashSet();
}
public void LongRunningPreAsyncEvent()
{
var item = new SimpleEventEntity
{
Name = "AsyncCreated should not be aborted since event is handled asynchronously"
};
Repository.Data.Save(item);
ConversationHelper.ReOpen();
var item2 = Repository.Data.Get <SimpleEventEntity>(item.Id);
Assert.NotNull(item2);
}
public void LongRunningPreEvent()
{
var item = new SimpleEventEntity
{
Name = "Created should be aborted"
};
Assert.Throws <TransactionManagerCommunicationException>(() => Repository.Data.Save(item));
ConversationHelper.ReOpen();
var item2 = Repository.Data.Get <SimpleEventEntity>(item.Id);
Assert.Null(item2);
}
public void ChangeNameInEvent()
{
var item = new SimpleEventEntity
{
Name = "ChangeMe #1"
};
Repository.Data.Save(item);
Assert.Equal("ChangeMe #1 create created", item.Name);
ConversationHelper.ReOpen();
var item2 = Repository.Data.Get <SimpleEventEntity>(item.Id);
Assert.Equal("ChangeMe #1 create", item2.Name);
}
public void NestedUnitsWithSameScopeRollbackAndCommitActionTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (var unit = new UnitOfWork())
{
int onCommitActionsCount;
int onRollBackActionsCount;
UnitOfWork.Current.PostCommitActions.Add(() => { });
UnitOfWork.Current.PostRollbackActions.Add(() => { });
Repository.Data.Save(entity);
Assert.Equal(1, UnitOfWork.Current.PostCommitActions.Count);
Assert.Equal(1, UnitOfWork.Current.PostRollbackActions.Count);
using (var unit2 = new UnitOfWork())
{
UnitOfWork.Current.PostCommitActions.Add(() => { });
UnitOfWork.Current.PostRollbackActions.Add(() => { });
onCommitActionsCount = UnitOfWork.Current.PostCommitActions.Count;
onRollBackActionsCount = UnitOfWork.Current.PostRollbackActions.Count;
Repository.Data.Save(entity2);
Assert.Throws <UnitOfWorkException>(() => unit2.Rollback());
}
Assert.Equal(2, onCommitActionsCount);
Assert.Equal(2, onRollBackActionsCount);
Assert.Throws <UnitOfWorkException>(() => unit.Commit());
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.Null(entity);
Assert.Null(entity2);
}
public void ScopeWithoutException()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
using (var unit = new UnitOfWork())
{
Repository.Data.Save(entity);
unit.Rollback(); // will not throw exception
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
Assert.Null(entity);
}
public void UnitOfWorkRollbackTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
using (var unit = new UnitOfWork())
{
Repository.Data.Save(entity);
unit.Rollback();
}
Repository.Data.Cache.Clear(entity);
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
Assert.Null(entity);
}
public void NestedUnitsWithInnerScopeRollbackAndCommitActionTest()
{
var entity = new SimpleEntity
{
Name = "UnitTest"
};
var entity2 = new SimpleEntity
{
Name = "UnitTest2"
};
using (var unit = new UnitOfWork())
{
UnitOfWork.Current.PostCommitActions.Add(() => { });
UnitOfWork.Current.PostRollbackActions.Add(() => { });
Repository.Data.Save(entity);
Assert.Equal(1, UnitOfWork.Current.PostCommitActions.Count);
Assert.Equal(1, UnitOfWork.Current.PostRollbackActions.Count);
using (var unit2 = new UnitOfWork(UnitOfWorkScopeType.New))
{
UnitOfWork.Current.PostCommitActions.Add(() => { });
UnitOfWork.Current.PostRollbackActions.Add(() => { });
Repository.Data.Save(entity2);
unit2.Rollback();
}
Assert.Equal(1, UnitOfWork.Current.PostCommitActions.Count);
Assert.Equal(1, UnitOfWork.Current.PostRollbackActions.Count);
unit.Commit();
}
Repository.Data.Cache.Clear(typeof(SimpleEntity));
ConversationHelper.ReOpen();
entity = Repository.Data.Get <SimpleEntity>(entity.Id);
entity2 = Repository.Data.Get <SimpleEntity>(entity2.Id);
Assert.NotNull(entity);
Assert.Null(entity2);
}
public void TryToAutoMergeIfNeeded()
{
var item = new SimpleEntity
{
Name = "PageType #1"
};
Repository.Data.Save(item);
ConversationHelper.ReOpen();
item = Repository.Data.Get <SimpleEntity>(item.Id);
item.Name += ".2";
Repository.Data.Save(item);
ConversationHelper.ReOpen();
Repository.Data.Get <SimpleEntity>(item.Id);
item.Name += ".3";
Repository.Data.Save(item);
}
public static IEnumerable <Thread> GetSentMMS(Context context)
{
var cursor = context.ContentResolver.Query(Android.Provider.Telephony.Sms.Sent.ContentUri,
new string[] { "address", "date", "body", "_id", "thread_id", "read" }, //columns
"thread_id", //GROUP BY
null,
null /*"DATE DESC"*/);
var output = ConversationHelper.GetFullConvoListFromCursor(context, cursor);
var grouped = from s in output
group s by s.ThreadId into m
select new { ThreadId = m.Key, MaxDate = m.Max(s => s.DateAsLong) };
output = from o in output
join g in grouped on o.ThreadId equals g.ThreadId
where o.DateAsLong == g.MaxDate
select o;
return(output);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var message = await result;
context.PrivateConversationData.TryGetValue <bool>(Constants.IsAnsweringKey, out bool isAnswering);
if (isAnswering)
{
await this.SaveAnswer(context, message);
}
else if ((ConversationHelper.IsSlackChannel(message) && (message.ChannelData == null || message.ChannelData.Payload == null)) || !ConversationHelper.IsUserGoingToAnswerQuestion(message))
{
var text = message.Conversation.IsGroup.GetValueOrDefault()
? $"Oops. I dont know how to answer that. Anyone willing to help?\n\n**{message.Text}**"
: $"Oops. I dont know how to answer that. Do you know the answer to **{message.Text}**?";
// in reality we can just check if user is going to answer a question and remove the Slack specific check
var askForHelpReply = context.MakeMessage();
askForHelpReply.Text = text;
askForHelpReply.Attachments = new List <Attachment>
{
new HeroCard
{
Buttons = new List <CardAction>
{
// sending the question as part of the button. Not required for Slack but a quick workaround for other channels.
new CardAction(ActionTypes.PostBack, "Answer", value: $"{Constants.WikiQuestionKey}{message.Text}")
}
}.ToAttachment()
};
await context.PostAsync(askForHelpReply);
context.Wait(this.MessageReceivedAsync);
}
else
{
string user = message.From.Name;
// the value of the button should contain the question
string question = message.Text.Substring(Constants.WikiQuestionKey.Length);
context.PrivateConversationData.SetValue(Constants.IsAnsweringKey, true);
context.PrivateConversationData.SetValue(Constants.QuestionToAnswerKey, question);
if (ConversationHelper.IsSlackChannel(message))
{
string responseUrl = message.ChannelData.Payload.response_url;
context.PrivateConversationData.SetValue(Constants.SlackResponseUrlKey, responseUrl);
await context.FlushAsync(CancellationToken.None);
// just showing how to access the data from the Slack payload
user = message.ChannelData.Payload.user.name;
// question = message.ChannelData.Payload.original_message.text.ToString().Replace("*", string.Empty).Replace("\n", string.Empty);
var interactiveMessage = new SlackInteractiveMessage
{
ResponseType = "in_channel",
ReplaceOriginal = true,
Text = message.Conversation.IsGroup.GetValueOrDefault()
? "Oops. I dont know how to answer that. Anyone willing to help?"
: "Oops. I dont know how to answer that. Do you know the answer?",
Attachments =
{
new SlackAttachment
{
Color = "#36a64f",
Title = question,
Text = $"@{user} is answering"
}
}
};
await SendSlackInteractiveMessage(responseUrl, interactiveMessage);
}
else
{
await context.FlushAsync(CancellationToken.None);
await context.PostAsync($"@{user} is answering");
}
context.Wait(this.MessageReceivedAsync);
}
}
public string GetReponse(string message, string context)
{
ConversationHelper helper = new ConversationHelper(WatsonConstants.WorkSpaceId1, WatsonConstants.Username, WatsonConstants.Password);
var res = helper.GetResponse(message).GetAwaiter().GetResult();
if (workspaceId == WatsonConstants.WorkSpaceId1)
{
if (context != null)
{
JObject jResponse = JObject.Parse(res);
JObject jObject = (JObject)jResponse["context"];
if ((JValue)jObject["selected_type"] != null)
{
HttpContext.Session.SetString("selected_type", Convert.ToString((JValue)jObject["selected_type"]));
}
if ((JValue)jObject["formatted_selected_date"] != null)
{
HttpContext.Session.SetString("formatted_selected_date", Convert.ToString((JValue)jObject["formatted_selected_date"]));
}
if ((JValue)jObject["formatted_selected_time"] != null)
{
HttpContext.Session.SetString("formatted_selected_time", Convert.ToString((JValue)jObject["formatted_selected_time"]));
}
JValue email = (JValue)jObject["useremail"];
if (email != null)
{
LabTest labTest = new LabTest()
{
Testtype = HttpContext.Session.GetString("selected_type"),
Testdate = HttpContext.Session.GetString("formatted_selected_date"),
Testtime = HttpContext.Session.GetString("formatted_selected_time"),
Useremail = Convert.ToString(email),
};
new EmailService().SendMail(labTest);
}
}
}
else if (workspaceId == WatsonConstants.WorkSpaceId2)
{
if (context != null)
{
JObject jResponse = JObject.Parse(res);
JObject jObject = (JObject)jResponse["context"];
if ((JValue)jObject["selected_type"] != null)
{
HttpContext.Session.SetString("selected_type", Convert.ToString((JValue)jObject["selected_type"]));
}
if ((JValue)jObject["formatted_selected_date"] != null)
{
HttpContext.Session.SetString("formatted_selected_date", Convert.ToString((JValue)jObject["formatted_selected_date"]));
}
if ((JValue)jObject["formatted_selected_time"] != null)
{
HttpContext.Session.SetString("formatted_selected_time", Convert.ToString((JValue)jObject["formatted_selected_time"]));
}
JValue email = (JValue)jObject["useremail"];
if (email != null)
{
LabTest labTest = new LabTest()
{
Testtype = HttpContext.Session.GetString("selected_type"),
Testdate = HttpContext.Session.GetString("formatted_selected_date"),
Testtime = HttpContext.Session.GetString("formatted_selected_time"),
Useremail = Convert.ToString(email),
};
new EmailService().SendMail(labTest);
}
}
}
return(res.ToString());
}
protected override void Init()
{
ConversationHelper.Open();
Repository.Data.Cache.Clear();
}
private void ParseConversations()
{
String args = String.Format("{0} \"{1}\" {2} {3} {4} {3} {5} {3} {6} {3} {7} {8} \"{9}.{10}\"",
TSharkHelper.ARG_READ_FILE,
NetworkTrace.FullName,
TSharkHelper.FILTER_FIELDS,
TSharkHelper.FIELD,
TSharkHelper.FIELD_REQUEST_IN,
TSharkHelper.FIELD_FRAME_NUMBER,
TSharkHelper.FIELD_MAC_DST,
TSharkHelper.FIELD_MAC_SRC,
TSharkHelper.ARG_DISPLAY_FILTER,
CTTSettings.PROTOCOL_HTTP,
CTTSettings.FILTER_RESPONSE);
String output;
if (!TSharkHelper.RunTShark(args, out output))
{
return;
}
var detectedDevices = FrameList.GetDevices();
String[] lines = output.SplitToLines();
foreach (String[] parts in lines.Select(line => line.Split(TSharkHelper.OUTPUT_SEPARATOR)))
{
int requestFrameNumber;
int responseFrameNumber;
int.TryParse(parts[0], out requestFrameNumber); // 0 as default value if TryParse failed
if (0 == requestFrameNumber)
{
continue;
}
int.TryParse(parts[1], out responseFrameNumber);
String clientMac = parts[2];
String deviceMac = parts[3];
Unit client = UnitSet.GetUnit(clientMac);
if (null == client)
{
var macIpPair = detectedDevices.First(item => item.Item1 == clientMac);
client = new Client(NetworkTrace, macIpPair.Item1, macIpPair.Item2);
UnitSet.Add(client);
}
else
{
client.FoundInTraces.Add(NetworkTrace);
}
Unit device = UnitSet.GetUnit(deviceMac);
if (null == device)
{
var macIpPair = detectedDevices.First(item => item.Item1 == deviceMac);
device = new Device(NetworkTrace, macIpPair.Item1, macIpPair.Item2);
UnitSet.Add(device);
}
else
{
device.FoundInTraces.Add(NetworkTrace);
}
var conversation = ConversationList.Find(client, device);
if (null == conversation)
{
conversation = new Conversation(NetworkTrace, client, device);
ConversationList.Add(conversation);
}
conversation.FoundInTraces.Add(NetworkTrace);
Directory.CreateDirectory(ConversationHelper.GetConversationFolder(NetworkTrace, conversation));
var request = new HttpRequest(FrameList.GetFrame(requestFrameNumber), conversation);
var response = new HttpResponse(FrameList.GetFrame(responseFrameNumber), conversation);
conversation.Add(new RequestResponsePair(request, response, NetworkTrace, conversation, ContentType.Http));
}
}