public void TestParser()
{
string[] args = { "chat.txt", "chat.json", "-fu", "user", "-fk", "keyword", "-bw", "word", "-bn", "-o" };
ConversationExporterConfiguration config = CommandLineArgumentParser.ParseCommandLineArguments(args);
Assert.AreEqual("chat.txt", config.inputFilePath);
Assert.AreEqual("chat.json", config.outputFilePath);
Assert.AreEqual("user", config.userToFilter);
Assert.AreEqual("keyword", config.keywordToFilter);
Assert.AreEqual("word", config.wordToBlacklist);
Assert.IsTrue(config.blacklistNumbers);
Assert.IsTrue(config.obfuscate);
string[] args2 = { "chat.txt", "chat.json", "-bw", "word", "-o" };
config = CommandLineArgumentParser.ParseCommandLineArguments(args2);
Assert.AreEqual("chat.txt", config.inputFilePath);
Assert.AreEqual("chat.json", config.outputFilePath);
Assert.IsNull(config.userToFilter);
Assert.IsNull(config.keywordToFilter);
Assert.AreEqual("word", config.wordToBlacklist);
Assert.IsFalse(config.blacklistNumbers);
Assert.IsTrue(config.obfuscate);
}
public void ExportConversation(ConversationExporterConfiguration configuration)
{
Conversation = ConversationProcessor.ReadConversation(configuration.InputFilePath);
if (configuration.FilterType == "IdFiltering")
{
Conversation = ConversationProcessor.FilterByID(Conversation);
}
else if (configuration.FilterType == "KeywordFiltering")
{
Conversation = ConversationProcessor.FilterByKeyword(Conversation);
}
Conversation = ConversationProcessor.CheckBlackListWithPath("blacklist.txt", Conversation);
Conversation = ConversationProcessor.HidePhoneNumbers(Conversation);
Conversation = ConversationProcessor.HideCreditCardNumbers(Conversation);
ConversationWriter writer = ConversationProcessor.WriteConversation(Conversation, configuration.OutputFilePath);
if (writer.Successful)
{
Console.WriteLine($"Conversation exported from {configuration.InputFilePath} to {configuration.OutputFilePath}");
}
}
public void TestExporterOptionsSelected()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration config = new ConversationExporterConfiguration("chat.txt", "chat2.json");
config.userToFilter = "bob";
config.keywordToFilter = "Pie";
config.obfuscate = true;
exporter.ExportConversation(config);
var serializedConversation = new StreamReader(new FileStream("chat2.json", FileMode.Open)).ReadToEnd();
Conversation savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
Assert.AreEqual("My Conversation-senderId:bob-keyword:Pie", savedConversation.name);
var messages = savedConversation.messages.ToList();
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470906), messages[0].timestamp);
Assert.AreEqual("0", messages[0].senderId);
Assert.AreEqual("I'm good thanks, do you like pie?", messages[0].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[1].timestamp);
Assert.AreEqual("0", messages[1].senderId);
Assert.AreEqual("No, just want to know if there's anybody else in the pie society...", messages[1].content);
}
public void ConversationExporterConfigurationArgumentlist()
{
CommandLineArgumentParser clap = new CommandLineArgumentParser();
string[] strings = new[] { "chat.txt", "chat.json", "user=robelli" };
var res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.userFilter);
strings = new[] { "chat.txt", "chat.json", "keyword_include=pie" };
res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.keywordInclude);
strings = new[] { "chat.txt", "chat.json", "keyword_exclude=pie" };
res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.keywordExclude);
strings = new[] { "chat.txt", "chat.json", "blacklist=pie,angus" };
res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.blacklistFilter);
strings = new[] { "chat.txt", "chat.json", "hideCreditCard" };
res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.hideCreditCard);
strings = new[] { "chat.txt", "chat.json", "hidePhone" };
res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.hidePhone);
strings = new[] { "chat.txt", "chat.json", "obfuscateUser" };
res = new ConversationExporterConfiguration(strings);
Console.WriteLine(res.obfuscateUser);
}
/// <summary>
/// Helper method to initialise the command line arguments and throw argument null errors.
/// </summary>
/// <param name="exporterConfiguration">
/// The configuration for the conversation to be exported.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when input path is null.
/// </exception>
public static void ManageArguments(ConversationExporterConfiguration exporterConfiguration)
{
var conversationExporter = new ConversationExporter();
var exporterParameters = new ConversationExporterParameters(exporterConfiguration);
conversationExporter.ExportConversation(exporterParameters);
}
public void Test_Modifier_ModifyByBlacklist()
{
var output = "chat3.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.blacklist = new List <string>();
configuration.blacklist.Add("like");
configuration.blacklist.Add("pie");
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
Assert.Equal("Hello there!", messages[0].content);
Assert.Equal("I'm good thanks, do you \\*redacted*\\ \\*redacted*\\?", messages[2].content);
Assert.Equal("Hell yes! Are we buying some \\*redacted*\\?", messages[4].content);
Assert.Equal("No, just want to know if there's anybody else in the \\*redacted*\\ society...", messages[5].content);
Assert.Equal("YES! I'm the head \\*redacted*\\ eater there...", messages[6].content);
Assert.Equal("I \\*redacted*\\ \\*redacted*\\", messages[8].content);
Assert.Equal("I mean what;s not to \\*redacted*\\ about \\*redacted*\\", messages[9].content);
}
public void Test_Exporter_CalculateActivity()
{
var output = "chat8.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.obfuscateUserIDs = false;
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
var userActivityList = exporter.CalculateActivity(savedConversation);
Assert.Equal(5, userActivityList.First(x => x.userID == "matas").messageCount);
Assert.Equal(1, userActivityList.First(x => x.userID == "chris").messageCount);
Assert.Equal(1, userActivityList.First(x => x.userID == "thomas").messageCount);
Assert.Equal(2, userActivityList.First(x => x.userID == "angus").messageCount);
Assert.Equal(2, userActivityList.First(x => x.userID == "mike").messageCount);
Assert.Equal(3, userActivityList.First(x => x.userID == "bob").messageCount);
}
/// <summary>
/// Exports the conversation at <paramref name="inputFilePath"/> as JSON to <paramref name="outputFilePath"/>.
/// </summary>
/// <param name="inputFilePath">
/// The input file path.
/// </param>
/// <param name="outputFilePath">
/// The output file path.
/// </param>
/// <exception cref="ArgumentException">
/// Thrown when a path is invalid.
/// </exception>
/// <exception cref="Exception">
/// Thrown when something bad happens.
/// </exception>
public void ExportConversation(ConversationExporterConfiguration config)
{
Conversation conversation = this.ReadConversation(config.inputFilePath);
//Perform specified filterings and obfuscations.
if (config.userToFilter != null)
{
conversation = conversation.FilterByUser(config.userToFilter);
}
if (config.keywordToFilter != null)
{
conversation = conversation.FilterByKeyword(config.keywordToFilter);
}
if (config.wordToBlacklist != null)
{
conversation = conversation.BlacklistWord(config.wordToBlacklist);
}
if (config.blacklistNumbers)
{
conversation = conversation.BlacklistPhoneAndCC();
}
if (config.obfuscate)
{
conversation = conversation.ObfuscateUserIds();
}
this.WriteConversation(conversation, config.outputFilePath);
Console.WriteLine("Conversation exported from '{0}' to '{1}'", config.inputFilePath, config.outputFilePath);
}
/// <summary>
/// The application entry point.
/// </summary>
/// <param name="args">
/// The command line arguments.
/// </param>
static void Main(string[] args)
{
var conversationExporter = new ConversationExporter();
ConversationExporterConfiguration configuration = CommandLineArgumentParser.ParseCommandLineArguments(args);
conversationExporter.ExportConversation(configuration);
}
public void ExportingConversationWithNoInputFileThrowsArgumentNullError()
{
var exporterConfig = new ConversationExporterConfiguration();
ArgumentNullException exception = Assert.Throws <ArgumentNullException>(() => ConversationExporter.ManageArguments(exporterConfig));
Assert.AreEqual("Value cannot be null. (Parameter 'Input File Path')", exception.Message);
}
/// <summary>
/// Exports the conversation at <paramref name="inputFilePath"/> as JSON to <paramref name="outputFilePath"/>.
/// </summary>
/// <param name="inputFilePath">
/// The input file path.
/// </param>
/// <param name="outputFilePath">
/// The output file path.
/// </param>
/// <exception cref="ArgumentException">
/// Thrown when a path is invalid.
/// </exception>
/// <exception cref="Exception">
/// Thrown when something bad happens.
/// </exception>
///
//public void ExportConversation(string inputFilePath, string outputFilePath, string userFilter)
public void ExportConversation(ConversationExporterConfiguration configuration)
{
Conversation conversation = this.ReadConversation(configuration);
this.WriteConversation(conversation, configuration.outputFilePath);
Console.WriteLine("Conversation exported from '{0}' to '{1}'", configuration.inputFilePath, configuration.outputFilePath);
}
public void ExportControllerExportsFiles()
{
// INITIALISE an IReadController, IWriteController, IFilterController, IReportController as their respective
// concrete implementations, ReadController, WriteController, FilterController and ReportController
readController = new ReadController();
writeController = new WriteController();
filterController = new FilterController();
reportController = new ReportController();
// INITIALISE the IExportController
exportController = new ExportController(readController, writeController, filterController, reportController);
conversationConfig = new CommandLineArgumentParser().ParseCommandLineArguments(new string[] { "chat.txt", "chatE.json" }, filterController);
exportController.ExportConversation(conversationConfig.inputFilePath, conversationConfig.outputFilePath);
var serializedConversation = new StreamReader(new FileStream("chatE.json", FileMode.Open)).ReadToEnd();
Conversation savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
Assert.That(savedConversation.Name, Is.EqualTo("My Conversation"));
var messages = savedConversation.Messages.ToList();
Assert.That(savedConversation.Report.mostActiveUser, Is.EqualTo("angus"));
Assert.That(savedConversation.Report.userActivityRanking[0], Is.EqualTo("Rank 1 is angus with 4 messages"));
Assert.That(savedConversation.Report.userActivityRanking[1], Is.EqualTo("Rank 2 is bob with 3 messages"));
Assert.That(savedConversation.Report.userActivityRanking[2], Is.EqualTo("Rank 3 is mike with 2 messages"));
Assert.That(messages[0].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470901)));
Assert.That(messages[0].SenderId, Is.EqualTo("bob"));
Assert.That(messages[0].Content, Is.EqualTo("Hello there!"));
Assert.That(messages[1].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470905)));
Assert.That(messages[1].SenderId, Is.EqualTo("mike"));
Assert.That(messages[1].Content, Is.EqualTo("how are you?"));
Assert.That(messages[2].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470906)));
Assert.That(messages[2].SenderId, Is.EqualTo("bob"));
Assert.That(messages[2].Content, Is.EqualTo("I'm good thanks, do you like pie?"));
Assert.That(messages[3].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470910)));
Assert.That(messages[3].SenderId, Is.EqualTo("mike"));
Assert.That(messages[3].Content, Is.EqualTo("no, let me ask Angus..."));
Assert.That(messages[4].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470912)));
Assert.That(messages[4].SenderId, Is.EqualTo("angus"));
Assert.That(messages[4].Content, Is.EqualTo("Hell yes! Are we buying some pie?"));
Assert.That(messages[5].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470914)));
Assert.That(messages[5].SenderId, Is.EqualTo("bob"));
Assert.That(messages[5].Content, Is.EqualTo("No, just want to know if there's anybody else in the pie society..."));
Assert.That(messages[6].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470915)));
Assert.That(messages[6].SenderId, Is.EqualTo("angus"));
Assert.That(messages[6].Content, Is.EqualTo("YES! I'm the head pie eater there..."));
}
public void CheckKeyword()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
configuration.keyword = "pie";
configuration.filtersActive = true;
Conversation conversation = exporter.ReadConversation(configuration);
var messages = conversation.messages.ToList();
foreach (Message msg in messages)
{
Assert.IsTrue(msg.content.ToLower().Contains(configuration.keyword.ToLower()));
}
}
public void ConversationmostActiveUser()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json", null);
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream("chat.json", FileMode.Open)).ReadToEnd();
Conversation savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
var con = new Conversation("Test Conversation", messages, configuration);
Console.WriteLine(con.mostActiveUser);
Assert.AreEqual("User: bob made 3 Chats", con.mostActiveUser);
}
public void Test_CheckConversationName()
{
var output = "chat5.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
Assert.Equal("My Conversation", savedConversation.name);
}
public void ExportingConversationExportsConversation()
{
var exporter = new ConversationExporter();
ConversationExporterConfiguration exporterConfiguration = new ConversationExporterConfiguration();
exporterConfiguration.InputFilePath = "chat.txt";
exporterConfiguration.OutputFilePath = "chat.json";
exporter.ExportConversation(exporterConfiguration);
var serializedConversation = new StreamReader(new FileStream("chat.json", FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
Assert.That(savedConversation.name, Is.EqualTo("My Conversation"));
var messages = savedConversation.messages.ToList();
Assert.That(messages[0].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470901)));
Assert.That(messages[0].senderId, Is.EqualTo("bob"));
Assert.That(messages[0].content, Is.EqualTo("Hello there!"));
Assert.That(messages[1].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470905)));
Assert.That(messages[1].senderId, Is.EqualTo("mike"));
Assert.That(messages[1].content, Is.EqualTo("how are you?"));
Assert.That(messages[2].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470906)));
Assert.That(messages[2].senderId, Is.EqualTo("bob"));
Assert.That(messages[2].content, Is.EqualTo("I'm good thanks, do you like pie?"));
Assert.That(messages[3].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470910)));
Assert.That(messages[3].senderId, Is.EqualTo("mike"));
Assert.That(messages[3].content, Is.EqualTo("no, let me ask Angus..."));
Assert.That(messages[4].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470912)));
Assert.That(messages[4].senderId, Is.EqualTo("angus"));
Assert.That(messages[4].content, Is.EqualTo("Hell yes! Are we buying some pie?"));
Assert.That(messages[5].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470914)));
Assert.That(messages[5].senderId, Is.EqualTo("bob"));
Assert.That(messages[5].content, Is.EqualTo("No, just want to know if there's anybody else in the pie society..."));
Assert.That(messages[6].timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470915)));
Assert.That(messages[6].senderId, Is.EqualTo("angus"));
Assert.That(messages[6].content, Is.EqualTo("YES! I'm the head pie eater there..."));
}
/// <summary>
/// Helper method to read the conversation from <paramref name="inputFilePath"/>.
/// </summary>
/// <param name="inputFilePath">
/// The input file path.
/// </param>
/// <returns>
/// A <see cref="Conversation"/> model representing the conversation.
/// </returns>
/// <exception cref="FormatException">
/// Misformed and empty Inputlines will cause a Console Log, not throwned
/// </exception>
/// <exception cref="ArgumentException">
/// Thrown when the input file could not be found.
/// </exception>
/// <exception cref="Exception">
/// Thrown when something else went wrong.
/// </exception>
public Conversation ReadConversation(ConversationExporterConfiguration configuration)
{
int maxSplit = 3; // max times to split the input=string
string delimitterString = " "; // possible delimitter strings, add others without separator
char[] delimitter = delimitterString.ToCharArray(); // char arr with delimitters
string line = null; // input line to be stript down
string[] split = null;
Console.WriteLine("Converter Log\n-------------"); // write Log Title
try
{
var reader = new StreamReader(new FileStream(configuration.inputFilePath, FileMode.Open, FileAccess.Read),
Encoding.ASCII);
string conversationName = reader.ReadLine();
var messages = new List <Message>();
while ((line = reader.ReadLine()) != null)
{
split = line.Split(delimitter, maxSplit); // split inputline as maxSplit times, on delimitters
try
{
messages.Add(new Message(DateTimeOffset.FromUnixTimeSeconds(Convert.ToInt64(split[0])), split[1], split[2]));
}
catch (FormatException e)
{
// occurs at empty line feeds because of missformed date/time inputs
// write console log and ignore this line
Console.WriteLine(e.Message.ToString() + " Input: " + line.ToString());
continue;
}
}
return(new Conversation(conversationName, messages, configuration));
}
catch (FileNotFoundException)
{
throw new ArgumentException("The file was not found.");
}
catch (IOException)
{
throw new Exception("Something went wrong in the IO.");
}
}
public void Test_CheckMessages()
{
var output = "chat0.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470901), messages[0].timestamp);
Assert.Equal("bob", messages[0].senderId);
Assert.Equal("Hello there!", messages[0].content);
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470905), messages[1].timestamp);
Assert.Equal("mike", messages[1].senderId);
Assert.Equal("how are you?", messages[1].content);
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470906), messages[2].timestamp);
Assert.Equal("bob", messages[2].senderId);
Assert.Equal("I'm good thanks, do you like pie?", messages[2].content);
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470910), messages[3].timestamp);
Assert.Equal("mike", messages[3].senderId);
Assert.Equal("no, let me ask Angus...", messages[3].content);
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470912), messages[4].timestamp);
Assert.Equal("angus", messages[4].senderId);
Assert.Equal("Hell yes! Are we buying some pie?", messages[4].content);
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[5].timestamp);
Assert.Equal("bob", messages[5].senderId);
Assert.Equal("No, just want to know if there's anybody else in the pie society...", messages[5].content);
Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1448470915), messages[6].timestamp);
Assert.Equal("angus", messages[6].senderId);
Assert.Equal("YES! I'm the head pie eater there...", messages[6].content);
}
public void ExportControllerExportsFilesWithMultipleFilters2()
{
// INITIALISE an IReadController, IWriteController, IFilterController, IReportController as their respective
// concrete implementations, ReadController, WriteController, FilterController and ReportController
readController = new ReadController();
writeController = new WriteController();
filterController = new FilterController();
reportController = new ReportController();
// INITIALISE the IExportController
exportController = new ExportController(readController, writeController, filterController, reportController);
conversationConfig =
new CommandLineArgumentParser().ParseCommandLineArguments(
new string[] { "chat.txt", "chatH.json", "-filter-user", "bob", "-filter-blacklist-word", "pie|society", "-filter-obfuscate" },
filterController);
exportController.ExportConversation(conversationConfig.inputFilePath, conversationConfig.outputFilePath);
var serializedConversation = new StreamReader(new FileStream("chatH.json", FileMode.Open)).ReadToEnd();
Conversation savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
Assert.That(savedConversation.Name, Is.EqualTo("My Conversation"));
var messages = savedConversation.Messages.ToList();
Assert.That(savedConversation.Report.mostActiveUser, Is.EqualTo("User3071"));
Assert.That(savedConversation.Report.userActivityRanking[0], Is.EqualTo("Rank 1 is User3071 with 3 messages"));
Assert.That(messages[0].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470901)));
Assert.That(messages[0].SenderId, Is.EqualTo("User3071"));
Assert.That(messages[0].Content, Is.EqualTo("Hello there!"));
Assert.That(messages[1].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470906)));
Assert.That(messages[1].SenderId, Is.EqualTo("User3071"));
Assert.That(messages[1].Content, Is.EqualTo("I'm good thanks, do you like \\*redacted\\*?"));
Assert.That(messages[2].Timestamp, Is.EqualTo(DateTimeOffset.FromUnixTimeSeconds(1448470914)));
Assert.That(messages[2].SenderId, Is.EqualTo("User3071"));
Assert.That(messages[2].Content, Is.EqualTo("No, just want to know if there's anybody else in the \\*redacted\\* \\*redacted\\*..."));
}
//Main method in the program, which reads from the path and writes to the output path.
public void ExportConversation(ConversationExporterConfiguration configuration)
{
conversation = ReadConversation(configuration.inputFilePath);
var action_list = configuration.GetFilterList();
var modifier = new ConversationModifier(conversation);
conversation = modifier.PerformActions(action_list, configuration);
CalculateActivity(conversation);
WriteConversation(configuration.outputFilePath);
if (configuration.writeUserActivity)
{
var activityList = CalculateActivity(conversation);
WriteUserActivity(configuration.outputFilePath, activityList);
}
}
public void CheckObfuscateUserIDS()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
Conversation conversation = exporter.ReadConversation(configuration);
var messages = conversation.messages.ToList();
//messages with obfuscation
ConversationExporter exporterObfuscate = new ConversationExporter();
ConversationExporterConfiguration configurationObfuscate = new ConversationExporterConfiguration("chat.txt", "chat.json");
configurationObfuscate.obfuscateUserIDsFlag = true;
Conversation obfuscatedConversation = exporterObfuscate.ReadConversation(configurationObfuscate);
var obfuscatedMsgs = obfuscatedConversation.messages.ToList();
for(int i =0; i<obfuscatedMsgs.Count; i++)
{
Assert.IsTrue(obfuscatedMsgs[i].senderId == configurationObfuscate.usersMapper[messages[i].senderId]);
}
//exporterObfuscate.ExportConversation(configurationObfuscate);
}
public void Test_Modifier_ModifyByName()
{
var output = "chat1.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.user = "******";
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
Assert.Equal("Hello am I late?", messages[0].content);
Assert.Equal("I like pie", messages[1].content);
}
public void CheckAllFiltersTogether()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
configuration.filtersActive = true;
configuration.keyword = "society";
configuration.usernameFilter = "bob";
configuration.wordsBlacklist = new string[] { "pie" };
configuration.obfuscateUserIDsFlag = true;
Conversation conversation = exporter.ReadConversation(configuration);
var messages = conversation.messages.ToList();
//given conversation should return only 2 messages
Assert.IsTrue(messages.Count == 1);
foreach (Message msg in messages)
{
Assert.IsTrue(msg.senderId == "User1");
Assert.IsTrue(msg.content.ToLower().Contains(configuration.keyword.ToLower()));
}
//exporter.ExportConversation(configuration);
}
public void Test_Modifier_ModifyBySensitiveData()
{
var output = "chat6.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.hideSensitiveData = true;
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
Assert.Equal("Hello there!", messages[0].content);
Assert.Equal("hello my credit card number is \\*redacted*\\", messages[10].content);
Assert.Equal("Hello my phone number is \\*redacted*\\", messages[11].content);
}
public void Test_Modifier_ModifyByKeyword()
{
var output = "chat2.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.keyword = "pie";
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
Assert.Equal("I'm good thanks, do you like pie?", messages[0].content);
Assert.Equal("Hell yes! Are we buying some pie?", messages[1].content);
Assert.Equal("No, just want to know if there's anybody else in the pie society...", messages[2].content);
Assert.Equal("YES! I'm the head pie eater there...", messages[3].content);
Assert.Equal("I like pie", messages[4].content);
}
/// <summary>
/// Exports the conversation at <paramref name="inputFilePath"/> as JSON to <paramref name="outputFilePath"/>.
/// </summary>
/// <param name="inputFilePath">
/// The input file path.
/// </param>
/// <param name="outputFilePath">
/// The output file path.
/// </param>
/// <exception cref="ArgumentException">
/// Thrown when a path is invalid.
/// </exception>
/// <exception cref="Exception">
/// Thrown when something bad happens.
/// </exception>
public void ExportConversation(ConversationExporterConfiguration exporterConfiguration)
{
var filters = new List <BaseFilter>();
var blacklists = new List <IBlacklist>();
Conversation conversation;
if (exporterConfiguration.filterByUser != null)
{
var userFilter = new UserFilter(new string[] { exporterConfiguration.filterByUser });
filters.Add(userFilter);
}
if (exporterConfiguration.filterByKeyword != null)
{
var keywordFilter = new KeywordFilter(new string[] { exporterConfiguration.filterByKeyword });
filters.Add(keywordFilter);
}
if (exporterConfiguration.blacklist != null)
{
var blacklistWords = exporterConfiguration.blacklist.Split(',');
blacklists.Add(new KeywordBlacklist(blacklistWords, "*redacted*"));
}
if (exporterConfiguration.generateReport)
{
conversation = this.ReadConversation(exporterConfiguration.InputFilePath, filters.ToArray(), blacklists.ToArray(), true);
}
else
{
conversation = this.ReadConversation(exporterConfiguration.InputFilePath, filters.ToArray(), blacklists.ToArray());
}
this.WriteConversation(conversation, exporterConfiguration.OutputFilePath);
Console.WriteLine("Conversation exported from '{0}' to '{1}'", exporterConfiguration.InputFilePath, exporterConfiguration.OutputFilePath);
}
/// <summary>
/// The application entry point.
/// </summary>
/// <param name="args">
/// The command line arguments.
/// </param>
static void Main(string[] args)
{
UnityContainer container = new UnityContainer();
container.AddNewExtension <MyChatUnityContainer>();
ICommandLineParser parser = container.Resolve <ICommandLineParser>();
ConversationExporterConfiguration configuration = parser.ParseCommandLineArguments(args);
IExporter export = container.Resolve <IExporter>();
foreach (var argument in configuration.commandLineArguments)
{
if (argument.ArgumentType == CommandLineArgumentType.WordFilter)
{
export.AddFilter(container.Resolve <IFilter>(argument.ArgumentType.ToString(), new ParameterOverride("replacement", "*redacted*")), argument.AdditionalParameters);
}
else
{
export.AddFilter(container.Resolve <IFilter>(argument.ArgumentType.ToString()), argument.AdditionalParameters);
}
}
export.ExportConversation(configuration.inputFilePath, configuration.outputFilePath);
}
public void Test_Modifier_Obfisticate_IDS()
{
var output = "chat7.json";
var exporter = new ConversationExporter();
var configuration = new ConversationExporterConfiguration("chat.txt", output);
configuration.obfuscateUserIDs = true;
configuration.writeUserActivity = false;
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream(output, FileMode.Open)).ReadToEnd();
var savedConversation = JsonConvert.DeserializeObject <Conversation>(serializedConversation);
var messages = savedConversation.messages.ToList();
//bob mike angus matas
Assert.Equal("user1", messages[0].senderId);
Assert.Equal("user2", messages[1].senderId);
Assert.Equal("user3", messages[4].senderId);
Assert.Equal("user4", messages[7].senderId);
}
public void ExportingConversationExportsConversation()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
exporter.ExportConversation(configuration);
var serializedConversation = new StreamReader(new FileStream("chat.json", FileMode.Open)).ReadToEnd();
Conversation savedConversation = JsonConvert.DeserializeObject<Conversation>(serializedConversation);
Assert.AreEqual("My Conversation", savedConversation.name);
Assert.IsTrue(savedConversation.messages.ToList().Count > 0);
}
/*stammary>
* /// <param name="inputFilePath">
* /// The statictic async void SendAsychTask(ConversationExporterConfiguration configuration)
* {
* await Task.Run(() =>
* }*/
/// <summary>
/// Exports the conversation at <paramref name="inputFilePath"/> as JSON to <paramref name="outputFilePath"/>.
/// </suinput file path.
/// </param>
/// <param name="outputFilePath">
/// The output file path.
/// </param>
/// <exception cref="ArgumentException">
/// Thrown when a path is invalid.
/// </exception>
/// <exception cref="Exception">
/// Thrown when something bad happens.
/// </exception>
public void ExportConversation(ConversationExporterConfiguration configuration)
{
Task n = Task.Run(() => ReadConversation(configuration.inputFilePath, configuration.outputFilePath, configuration.user, configuration.keyboard, configuration.blacklist));
n.Wait();
}
public void ReadConversationTest()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
Conversation conversation = exporter.ReadConversation(configuration);
Assert.AreEqual("My Conversation", conversation.name);
var messages = conversation.messages.ToList();
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470901), messages[0].timestamp);
Assert.AreEqual("bob", messages[0].senderId);
Assert.AreEqual("Hello there!", messages[0].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470905), messages[1].timestamp);
Assert.AreEqual("mike", messages[1].senderId);
Assert.AreEqual("how are you?", messages[1].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470906), messages[2].timestamp);
Assert.AreEqual("bob", messages[2].senderId);
Assert.AreEqual("I'm good thanks, do you like pie?", messages[2].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470910), messages[3].timestamp);
Assert.AreEqual("mike", messages[3].senderId);
Assert.AreEqual("no, let me ask Angus...", messages[3].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470912), messages[4].timestamp);
Assert.AreEqual("angus", messages[4].senderId);
Assert.AreEqual("Hell yes! Are we buying some pie?", messages[4].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[5].timestamp);
Assert.AreEqual("bob", messages[5].senderId);
Assert.AreEqual("No, just want to know if there's anybody else in the pie society...", messages[5].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470915), messages[6].timestamp);
Assert.AreEqual("angus", messages[6].senderId);
Assert.AreEqual("YES! I'm the head pie eater there...", messages[6].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470918), messages[7].timestamp);
Assert.AreEqual("angus", messages[7].senderId);
Assert.AreEqual("", messages[7].content);
}
public void CompineUsernameAndKeyWordFilter()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
configuration.keyword = "pie";
configuration.usernameFilter = "bob";
configuration.filtersActive = true;
Conversation conversation = exporter.ReadConversation(configuration);
var messages = conversation.messages.ToList();
//given conversation should return only 2 messages
Assert.IsTrue(messages.Count == 2);
foreach (Message msg in messages)
{
Assert.IsTrue(msg.senderId == "bob");
Assert.IsTrue(msg.content.ToLower().Contains(configuration.keyword.ToLower()));
}
//exporter.ExportConversation(configuration);
}
public void CheckUsername()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
configuration.usernameFilter = "bob";
configuration.filtersActive = true;
Conversation conversation = exporter.ReadConversation(configuration);
var messages = conversation.messages.ToList();
foreach (Message msg in messages)
{
Assert.AreEqual(configuration.usernameFilter, msg.senderId);
}
}
public void FailToReadConversation()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration(null, "chat.json");
try
{
exporter.ReadConversation(configuration);
}
catch (Exception)
{
configuration.inputFilePath="chat.txt";
exporter.ReadConversation(configuration);
}
}
public void FailToExport()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "fileNotAllowedToAccess.json");
try
{
exporter.ExportConversation(configuration);
}
catch (Exception)
{
//catching the exception and correcting the file
configuration.outputFilePath = "chat.json";
exporter.ExportConversation(configuration);
}
}
//[TestCase(@"chat_wrong.txt", @"chat3.json", "", "", "", "ExceptionFile", ExpectedException = typeof(FileNotFoundException), ExpectedMessage = "File not found")]
public void ExportingConversationExportsConversation(string input, string output, string user = "", string keyword = "", string blacklist = "", string test = "test0")
{
ConversationExporter exporter = new ConversationExporter();
ProgramArguments args = new ProgramArguments()
{
inputFile = AppDomain.CurrentDomain.BaseDirectory + input, outFile = AppDomain.CurrentDomain.BaseDirectory + output, user = user, keyboard = keyword, blacklist = blacklist
};
ConversationExporterConfiguration conf = new ConversationExporterConfiguration(args);
exporter.ExportConversation(conf);
var serializedConversation = new StreamReader(new FileStream(AppDomain.CurrentDomain.BaseDirectory + output, FileMode.Open)).ReadToEnd();
Output savedConversation = JsonConvert.DeserializeObject <Output>(serializedConversation);
Assert.AreEqual("My Conversation", savedConversation.conversation.name);
var messages = savedConversation.conversation.messages.ToList();
switch (test)
{
case "test1":
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470901), messages[0].timestamp);
Assert.AreEqual("bob", messages[0].senderId);
Assert.AreEqual("Hello there!", messages[0].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470906), messages[1].timestamp);
Assert.AreEqual("bob", messages[1].senderId);
Assert.AreEqual("I'm good thanks, do you like pie?", messages[1].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[2].timestamp);
Assert.AreEqual("bob", messages[2].senderId);
Assert.AreEqual("No, just want to know if there's anybody else in the pie society...", messages[2].content);
break;
case "test2":
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[0].timestamp);
Assert.AreEqual("bob", messages[0].senderId);
Assert.AreEqual("No, just want to know if there's anybody else in the pie society...", messages[0].content);
break;
case "test3":
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[0].timestamp);
Assert.AreEqual("bob", messages[0].senderId);
Assert.AreEqual("No, just *redacted* to know if there's anybody else in the pie society...".ToLower(), messages[0].content);
break;
case "ExceptionFile":
break;
default:
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470901), messages[0].timestamp);
Assert.AreEqual("bob", messages[0].senderId);
Assert.AreEqual("Hello there!", messages[0].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470905), messages[1].timestamp);
Assert.AreEqual("mike", messages[1].senderId);
Assert.AreEqual("how are you?", messages[1].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470906), messages[2].timestamp);
Assert.AreEqual("bob", messages[2].senderId);
Assert.AreEqual("I'm good thanks, do you like pie?", messages[2].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470910), messages[3].timestamp);
Assert.AreEqual("mike", messages[3].senderId);
Assert.AreEqual("no, let me ask Angus...", messages[3].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470912), messages[4].timestamp);
Assert.AreEqual("angus", messages[4].senderId);
Assert.AreEqual("Hell yes! Are we buying some pie?", messages[4].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470914), messages[5].timestamp);
Assert.AreEqual("bob", messages[5].senderId);
Assert.AreEqual("No, just want to know if there's anybody else in the pie society...", messages[5].content);
Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1448470915), messages[6].timestamp);
Assert.AreEqual("angus", messages[6].senderId);
Assert.AreEqual("YES! I'm the head pie eater there...", messages[6].content);
break;
}
}
public void HideSpecificWordsCheck()
{
ConversationExporter exporter = new ConversationExporter();
ConversationExporterConfiguration configuration = new ConversationExporterConfiguration("chat.txt", "chat.json");
configuration.wordsBlacklist = new string[2] { "pie", "hell" };
configuration.filtersActive = true;
Conversation conversation = exporter.ReadConversation(configuration);
var messages = conversation.messages.ToList();
Assert.AreEqual("*redacted*o there!", messages[0].content);
Assert.AreEqual("I'm good thanks, do you like *redacted*?", messages[2].content);
Assert.AreEqual("*redacted* yes! Are we buying some *redacted*?", messages[4].content);
Assert.AreEqual("No, just want to know if there's anybody else in the *redacted* society...", messages[5].content);
Assert.AreEqual("YES! I'm the head *redacted* eater there...", messages[6].content);
}
