static string SimpleJobFolders()
{
string fileName = DeleteFileIfExists("Demo1SimpleJobFolders.html");
//TODO: put current dir on interpret string , like env
var folderSolution = new DirectoryInfo(Directory.GetCurrentDirectory()).Parent.FullName;
var receiveFolder = new ReceiverFolderHierarchical(folderSolution, "*.csproj");
receiveFolder.ExcludeFolderNames = new string[] { "bin", "obj", "Properties", ".vs", ".git", "packages" };
var si = new SimpleJob();
si.Receivers.Add(0, receiveFolder);
si.Senders.Add(0, new Sender_Text(fileName, "<html><body><h1>Find .csproj in solution folder</h1>"));
si.Senders.Add(1, new Sender_HTMLRazor("Views/RazorHierarchical.cshtml", fileName));
si.Senders.Add(2, new Sender_HierarchicalVizFolder(fileName, "Name"));
si.Senders.Add(3, new Sender_Text(fileName, "</body></html>"));
//or you can add SyncSenderMultiple , but for now let's do it line by line
//ISend sender = new SyncSenderMultiple(
// new Sender_HTMLText(fileName, "<html><body>"),
// new Sender_HTMLRazor("Views/RazorHierarchical.cshtml", fileName),
// new Sender_HierarchicalVizFolder(fileName, "Name"),
// new Sender_HTMLText(fileName, "</body></html>")
// );
return(si.SerializeMe());
}
public async Task TestTransformerFileToLines()
{
#region arrange
var dir = AppContext.BaseDirectory;
var folderSql = Path.Combine(dir, "SqlToExecute");
var receiverFolder = new ReceiverFolderHierarchical(folderSql, "*.sql");
DirectoryInfo di = new DirectoryInfo(folderSql);
Console.WriteLine($"start files in {folderSql}");
foreach (var item in di.EnumerateFiles("*.sql"))
{
Console.WriteLine($"File {item.FullName}");
}
Console.WriteLine($"end files in {folderSql}");
#endregion
#region act
var transformer = new TransformerFileToLines();
var j = new SimpleJob();
j.Receivers.Add(0, receiverFolder);
j.FiltersAndTransformers.Add(0, transformer);
await j.Execute();
#endregion
#region assert
receiverFolder.valuesRead?.Length.ShouldBeGreaterThan(1);
transformer.valuesTransformed.ShouldNotBeNull();
var files = transformer.valuesTransformed.GroupBy(it => it.Values["FullName"]).ToArray();
files.Length.ShouldBeGreaterThan(1);
var file1Len = files.First().Count();
var file2Len = files.Last().Count();
file1Len.ShouldBeGreaterThan(0);
file2Len.ShouldBeGreaterThan(0);
(file1Len + file2Len).ShouldBeGreaterThan(2);
#endregion
}
public async Task TestCurrentDirHierarchical()
{
#region arrange
var dir = AppContext.BaseDirectory;
string filename = Path.Combine(dir, "a.html");
if (File.Exists(filename))
{
File.Delete(filename);
}
string fileNameToWrite = Guid.NewGuid().ToString("N") + ".txt";
string fullNameFile = Path.Combine(dir, fileNameToWrite);
File.WriteAllText(fullNameFile, "andrei ignat");
#endregion
#region act
IReceive r = new ReceiverFolderHierarchical(dir, "*.txt");
await r.LoadData();
#endregion
#region assert
Assert.IsTrue(r.valuesRead?.Length > 0, "must have a file");
var rowDir = r.valuesRead.FirstOrDefault(it => it.Values["FullName"]?.ToString() == dir);
Assert.IsNotNull(rowDir);
var rowFile = r.valuesRead.FirstOrDefault(it => it.Values["FullName"]?.ToString() == fullNameFile);
Assert.IsNotNull(rowFile);
var rh = rowFile as IRowReceiveHierarchicalParent;
Assert.IsNotNull(rh);
Assert.AreEqual(rh.Parent, rowDir);
#endregion
}
public async Task TestUnzip()
{
#region arrange
var dir = AppContext.BaseDirectory;
string existingZip = Path.Combine(dir, "a.zip");
dir = Path.Combine(dir, "TestUnzip");
if (Directory.Exists(dir))
{
Directory.Delete(dir, true);
}
Directory.CreateDirectory(dir);
File.Copy(existingZip, Path.Combine(dir, "a.zip"));
var receive = new ReceiverFolderHierarchical(dir, "*.zip");
var sender = new SenderUnzipFile(dir);
#endregion
#region act
var job = new SimpleJob();
job.Receivers.Add(0, receive);
job.Senders.Add(0, sender);
await job.Execute();
#endregion
#region assert
string file = Path.Combine(dir, "a.txt");
Assert.IsTrue(File.Exists(file), $"{file} should be unzipped");
#endregion
}
static string SimpleJobDllLoadTypes()
{
string dir = Environment.CurrentDirectory;
IReceive folderWithDll = new ReceiverFolderHierarchical("#static:Directory.GetCurrentDirectory()#", "*.dll");
var filterFiles = new FilterForFilesHierarchical();
var recContentFile = new ReceiverFromDllRelational();
var loadDllromFiles = new TransformerApplyReceiver(recContentFile, "DllFileName", "FullName");
var fileRazor = Path.Combine(dir, "relationalGeneric.cshtml");
string filename = "#static:Directory.GetCurrentDirectory()#\\relationalDLL.html";
ISend senderHTML = new SyncSenderMultiple(
new Sender_Text(filename, "<html><body>")
{
FileMode = FileMode.Create
},
new Sender_HTMLRazor("Views/" + Path.GetFileName(fileRazor), filename),
//new Sender_HTMLRelationViz("Name", filename),
new Sender_Text(filename, "</body></html>")
)
;
var job = new SimpleJob();
job.Receivers.Add(0, folderWithDll);
job.FiltersAndTransformers.Add(0, filterFiles);
job.FiltersAndTransformers.Add(1, loadDllromFiles);
job.Senders.Add(0, senderHTML);
return(job.SerializeMe());
}
public async Task TestFilterHierarchicalFiles()
{
#region arrange
var dir = AppContext.BaseDirectory;
dir = UtilsIO.DeleteCreateFolder(Path.Combine(dir, "TestFilterHierarchicalFiles"));
string filename = Path.Combine(dir, "a.html");
if (File.Exists(filename))
{
File.Delete(filename);
}
string fileNameToWrite = Guid.NewGuid().ToString("N") + ".txt";
string fullNameFile = Path.Combine(dir, fileNameToWrite);
File.WriteAllText(fullNameFile, "andrei ignat");
#endregion
#region act
IReceive r = new ReceiverFolderHierarchical(dir, "*.txt");
await r.LoadData();
var fi = new FilterForFilesHierarchical();
fi.valuesRead = r.valuesRead;
await fi.Run();
#endregion
#region assert
foreach (var item in fi.valuesTransformed)
{
item.Values.ShouldContainKeyAndValue("RowType", "file");
}
#endregion
}
public async Task TestSampleDataMediaDot()
{
#region arrange
var dir = AppContext.BaseDirectory;
foreach (var item in Directory.GetFiles(dir, "*.txt", SearchOption.AllDirectories))
{
File.Delete(item);
}
string fileNameToWrite = "andrei.txt";
string fullNameFile = Path.Combine(dir, fileNameToWrite);
File.WriteAllText(fullNameFile, "andrei ignat");
#endregion
#region act
IReceive r = new ReceiverFolderHierarchical(dir, "*.txt");
await r.LoadData();
var m = new MediaTransformDotFolderAndFiles();
m.valuesToBeSent = r.valuesRead;
await m.Run();
#endregion
#region assert
Assert.IsTrue(m.Result.Contains("[label=\"andrei.txt"), "result should contain " + m.Result);
Assert.IsTrue(m.Result.Contains(" -> "));
#endregion
}
public async Task TestFilterKeyEqualsRemains()
{
#region arrange
var dir = AppContext.BaseDirectory;
string filename = Path.Combine(dir, "a.html");
if (File.Exists(filename))
{
File.Delete(filename);
}
string fileNameToWrite = Guid.NewGuid().ToString("N") + ".txt";
string fullNameFile = Path.Combine(dir, fileNameToWrite);
File.WriteAllText(fullNameFile, "andrei ignat");
#endregion
#region act
IReceive r = new ReceiverFolderHierarchical(dir, "*.txt");
await r.LoadData();
IFilter f = new FilterRetainItemsWithKey("nrfiles", FilterType.Equal);
f.valuesRead = r.valuesRead;
await f.Run();
#endregion
#region assert
bool haveFolder = false;
foreach (var item in r.valuesRead)
{
if (haveFolder)
{
break;
}
var keys = item.Values.Keys.ToArray();
if (keys.Contains("nrfiles"))
{
haveFolder = true;
}
}
haveFolder.ShouldBeTrue();
f.valuesTransformed.ShouldNotBeNull();
f.valuesTransformed.Length.ShouldBeGreaterThan(0);
foreach (var item in f.valuesTransformed)
{
var keys = item.Values.Keys.ToArray();
keys.ShouldContain("nrfiles");
}
#endregion
}
static string ExecuteSqlCIOrder()
{
string fileName = DeleteFileIfExists("Demo3SimpleExecuteSql.html");
//TODO: put current dir on interpret string , like env
var receiveFolder = new ReceiverFolderHierarchical(@"#static:Directory.GetCurrentDirectory()#\SqlToExecute", "*.sql");
var dbConnection = new DBDataConnection <SqlConnection>();
dbConnection.ConnectionString = "#file:SqlServerConnectionString#";
var senderSql = new SenderSqlToDBSqlServer(dbConnection);
var si = new SimpleJob();
si.Receivers.Add(0, receiveFolder);
si.Senders.Add(0, senderSql);
return(si.SerializeMe());
}
public async Task Test2Receivers()
{
#region arrange
var dir = AppContext.BaseDirectory;
dir = Path.Combine(dir, "Test2Receivers");
if (Directory.Exists(dir))
{
Directory.Delete(dir, true);
}
Directory.CreateDirectory(dir);
string fileNameToWrite = "andrei.txt";
string fullNameFile = Path.Combine(dir, fileNameToWrite);
if (File.Exists(fullNameFile))
{
File.Delete(fullNameFile);
}
File.WriteAllText(fullNameFile, "andrei ignat");
IReceive folder = new ReceiverFolderHierarchical(dir, "andrei.txt");
StringBuilder sb = new StringBuilder();
sb.AppendLine("model,Track_number");
sb.AppendLine("Ford,B325ROS");
sb.AppendLine("Audi,PL654CSM");
sb.AppendLine("BMW,B325DFH");
sb.AppendLine("Ford,B325IYS");
string filenameCSV = "mycsv.csv";
if (File.Exists(filenameCSV))
{
File.Delete(filenameCSV);
}
File.WriteAllText(filenameCSV, sb.ToString());
//System.Diagnostics.Process.Start("notepad.exe", filenameCSV);
var CSVfile = new ReceiverCSVFileInt(filenameCSV, Encoding.ASCII);
#endregion
#region ACT
var m = new AsyncReceiverMultiple(CSVfile, folder);
await m.LoadData();
#endregion
#region assert
//4 records in CSV + 1 folder + 1 file
Assert.AreEqual(6, m.valuesRead.Length);
#endregion
}
static async Task MainAsync(string[] args)
{
var sj = new SimpleJob();
IReceive folder = new ReceiverFolderHierarchical(@"D:\test", "*.txt");
//await folder.LoadData();
var t = new TransformerFileToLines();
t.TrimEmptyLines = false;
//t.valuesRead = folder.valuesRead;
//await t.Run();
var addBak = new TransformerFieldAddString("FullName", "FullName", ".bak");
addBak.valuesRead = t.valuesTransformed;
//await addBak.Run();
//var regex = new TransformRowRegex(@"^(?x<ip>123).*?$","text");
var regex = new TransformRowRegexReplaceGuid(@"^.*x(?<ip>\w+)123.*?$", "text");
regex.ReplaceAllNextOccurences = true;
//regex.valuesRead = addBak.valuesTransformed;
//await regex.Run();
var file = new SenderByRowToFile("FullName", "lineNr", "text", ".txt");
file.FileMode = System.IO.FileMode.Append;
//file.valuesToBeSent = regex.valuesTransformed;
//await file.Send();
sj
.AddReceiver(folder)
.AddTransformer(t)
//.AddTransformer(addBak)
.AddTransformer(regex)
.AddSender(file);
File.WriteAllText("def.txt", sj.SerializeMe());
await sj.Execute();
}
public async Task TestSqlFolder()
{
#region arrange
var dir = AppContext.BaseDirectory;
var conection = GetSqlServerConnectionString();
var folderSql = Path.Combine(dir, "SqlToExecute");
var receiverFolder = new ReceiverFolderHierarchical(folderSql, "*.sql");
var con = new DBDataConnection <SqlConnection>();
con.ConnectionString = conection;
var senderSqlServer = new SenderSqlToDBSqlServer(con);
#endregion
#region act
var j = new SimpleJob();
j.Receivers.Add(0, receiverFolder);
j.Senders.Add(0, senderSqlServer);
await j.Execute();
#endregion
#region assert
receiverFolder.valuesRead?.Length.ShouldBeGreaterThan(1);
using (var conn = new SqlConnection(conection))
{
await conn.OpenAsync();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = "select count(ID) from TestAndrei";
var res = await cmd.ExecuteScalarAsync();
res.ShouldNotBeNull();
var text = res.ToString();
text.ShouldBe("1");
}
}
#endregion
}
public async Task TestTransformerApplyReceiverFiles()
{
#region arrange
var dir = AppContext.BaseDirectory;
dir = UtilsIO.DeleteCreateFolder(Path.Combine(dir, "TestTransformerApplyReceiverFiles"));
string filename = Path.Combine(dir, "a.html");
if (File.Exists(filename))
{
File.Delete(filename);
}
string fileNameToWrite = Guid.NewGuid().ToString("N") + ".txt";
string fullNameFile = Path.Combine(dir, fileNameToWrite);
File.WriteAllText(fullNameFile, "andrei ignat" + Environment.NewLine + "aaa");
var readFile = new ReceiverFileFromStorageLines(fullNameFile, Encoding.UTF8);
readFile.ReadAllFirstTime = false;
#endregion
#region act
IReceive r = new ReceiverFolderHierarchical(dir, "*.txt");
await r.LoadData();
var fi = new FilterForFilesHierarchical();
fi.valuesRead = r.valuesRead;
await fi.Run();
var transformerApplyReceiver = new TransformerApplyReceiver(readFile, "FileToRead", "FullName");
transformerApplyReceiver.valuesRead = fi.valuesTransformed;
await transformerApplyReceiver.Run();
#endregion
#region assert
transformerApplyReceiver.valuesTransformed.ShouldNotBeNull();
transformerApplyReceiver.valuesTransformed.Length.ShouldBe(2, "2 lines above");
#endregion
}
static async Task ExecuteSlnAnalysis()
{
string root = "@static:Path.GetPathRoot(#static:Directory.GetCurrentDirectory()#)@";
var si = new SimpleJob();
var recFolder = new ReceiverFolderHierarchical(root, "*tank*.sln;*StankinsSimpleJobNET*.exe");
si.Receivers.Add(0, recFolder);
IFilter fi = new FilterForFilesHierarchical();
si.FiltersAndTransformers.Add(0, fi);
si.UnSerialize(si.SerializeMe());
await si.Execute();
fi = si.FiltersAndTransformers[0] as IFilter;
var exe = fi.valuesTransformed.FirstOrDefault(it => it.Values["FullName"].ToString().EndsWith(".exe"));
if (exe == null)
{
Console.WriteLine("please build StankinsSimpleJobNET");
return;
}
string exePath = exe.Values["FullName"].ToString();
string exeDir = Path.GetDirectoryName(exePath);
//cleanup
foreach (var item in Directory.GetFiles(exeDir, "*.json"))
{
File.Delete(item);
}
//File.Copy("SolutionExport.txt", Path.Combine(exeDir, "SolutionExport.txt"));
var slns = fi.valuesTransformed.Select(it => it.Values["FullName"]?.ToString()).Where(it => (it ?? "").Contains(".sln")).ToArray();
foreach (var sln in slns)
{
Console.WriteLine($"interpret:{sln}");
var psi = new ProcessStartInfo(exePath, "execute SolutionExport.txt");
psi.WorkingDirectory = exeDir;
psi.Environment["solutionPath"] = sln;
var p = Process.Start(psi);
if (p.WaitForExit(60 * 1000))
{
var newJob = new SimpleJobConditionalTransformers();
var json = Path.Combine(exeDir, Path.GetFileNameWithoutExtension(sln) + ".json");
var rec = new ReceiverJSONFileInt(json, Encoding.UTF8);
newJob.Receivers.Add(0, rec);
string fileName = Path.Combine(AppContext.BaseDirectory, Path.GetFileNameWithoutExtension(sln) + ".html");
if (File.Exists(fileName))
{
File.Delete(fileName);
}
Console.WriteLine($"exporting to {fileName}");
string fileRazor = "solution.cshtml";
var sender = new SyncSenderMultiple(
new Sender_Text(fileName, "<html><body>"),
new Sender_HTMLRazor("Views/" + Path.GetFileName(fileRazor), fileName)
);
newJob.AddSender(sender);
var filter = new FilterExcludeRelation("referencedIn", "assemblyReferenced");
var senderViz = new SyncSenderMultiple(
new Sender_HTMLRelationViz("Name", fileName),
new Sender_Text(fileName, "</body></html>")
);
newJob.Add(filter, senderViz);
await newJob.Execute();
}
}
}
static string PBXJob()
{
var dir = AppContext.BaseDirectory;
var dirPBX = Path.Combine(dir, "PBX");
var serialize = new SerializeDataOnFile("a.txt");
IReceive r = new ReceiverFolderHierarchical(dirPBX, "*.log");
IFilter filterFiles = new FilterForFilesHierarchical();
#region filter for remove dates serialize
var filterDateTime = new FilterComparableGreat(typeof(DateTime), DateTime.MinValue, "LastWriteTimeUtc");
IFilter filterDateTimeSerializable = new FilterComparableFromSerializable(filterDateTime, serialize);
#endregion
IFilter removeFilesMaxWritten = new FilterRemovePropertyMaxMinDateTime("LastWriteTimeUtc", GroupingFunctions.Max);
ITransform transformLines = new TransformerFileToLines()
{
TrimEmptyLines = true
};
var trDateRegex = new TransformRowRegex(@"^Date:\ (?<datePBX>.{23}).*?$", "text");
var trKeyValueRegex = new TransformRowRegex(@"(^|\r|\n|\r\n)(?<tkey>(\$?[a-zA-Z0-9_[\]/ ]+))='?(?<tvalue>([a-zA-Z0-9_ ]+))'?(\r|\r\n|$)", "text");
var trToDate = new TransformerFieldStringToDate("datePBX", "NewDatePBX", "yyyy/MM/dd HH:mm:ss.fff");
var trAddDate = new TransformAddFieldDown("NewDatePBX");
var trAddKey = new TransformAddNewField("tkey");
var trAddValue = new TransformAddNewField("tvalue");
var trSimpleFields = new TransformRowRemainsProperties("NewDatePBX", "lineNr", "text", "FullName", "LastWriteTimeUtc", "tkey", "tvalue");
var data = new DBTableDataConnection <SqlConnection>(new SerializeDataInMemory());
data.ConnectionString = "#file:SqlServerConnectionString#";
data.Fields = new string[] { "NewDatePBX", "lineNr", "text", "FullName", "tkey", "tvalue" };
data.TableName = "PBXData";
var bulk = new SenderSqlServerBulkCopy(data);
var md = new MediaTransformMaxMin <DateTime>();
md.GroupFunction = GroupingFunctions.Max;
md.FieldName = "LastWriteTimeUtc";
var serializeMaxDate = new SenderMediaSerialize <DateTime>(serialize, "LastWriteTimeUtc", md);
var si = new SimpleJob();
si.Receivers.Add(0, r);
int iFilterNr = 0;
si.FiltersAndTransformers.Add(iFilterNr++, filterFiles);
si.FiltersAndTransformers.Add(iFilterNr++, filterDateTimeSerializable);
si.FiltersAndTransformers.Add(iFilterNr++, removeFilesMaxWritten);
si.FiltersAndTransformers.Add(iFilterNr++, transformLines);
si.FiltersAndTransformers.Add(iFilterNr++, trDateRegex);
si.FiltersAndTransformers.Add(iFilterNr++, trKeyValueRegex);
si.FiltersAndTransformers.Add(iFilterNr++, trToDate);
si.FiltersAndTransformers.Add(iFilterNr++, trAddDate);
si.FiltersAndTransformers.Add(iFilterNr++, trAddKey);
si.FiltersAndTransformers.Add(iFilterNr++, trAddValue);
si.FiltersAndTransformers.Add(iFilterNr++, trSimpleFields);
//TODO: add transformer to add a field down for all fields
//TODO: add transformer regex for splitting Key=Value
//TODO: add field to separate Conn(1)Type(Any)User(InternalTask) CDL Request:RSVI(Get)
si.Senders.Add(0, bulk);
si.Senders.Add(1, serializeMaxDate);
return(si.SerializeMe());
}
public async Task TestPBXData()
{
#region arrange
string connectionString = GetSqlServerConnectionString();
using (var conn = new SqlConnection(connectionString))
{
await conn.OpenAsync();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = @"
IF OBJECT_ID('dbo.PBXData', 'U') IS NOT NULL
DROP TABLE dbo.PBXData;";
await cmd.ExecuteNonQueryAsync();
cmd.CommandText = @"CREATE TABLE [PBXData](
[NewDatePBX] [datetime] NOT NULL,
[lineNr] [int] NOT NULL,
[text] [nvarchar](500) NOT NULL,
[FullName] [nvarchar](500) NOT NULL
)";
await cmd.ExecuteNonQueryAsync();
}
await Task.Delay(2000);
var dir = AppContext.BaseDirectory;
var dirPBX = Path.Combine(dir, "PBX");
File.AppendAllText(Path.Combine(dirPBX, "PBXRemove.log"), "aaaa");
#endregion
#region act
var serialize = new SerializeDataOnFile("a.txt");
IReceive r = new ReceiverFolderHierarchical(dirPBX, "*.log");
IFilter filterFiles = new FilterForFilesHierarchical();
#region filter for remove dates serialize
var filterDateTime = new FilterComparableGreat(typeof(DateTime), DateTime.MinValue, "LastWriteTimeUtc");
IFilter filterDateTimeSerializable = new FilterComparableFromSerializable(filterDateTime, serialize);
#endregion
IFilter removeFilesMaxWritten = new FilterRemovePropertyMaxMinDateTime("LastWriteTimeUtc", GroupingFunctions.Max);
ITransform transformLines = new TransformerFileToLines()
{
TrimEmptyLines = true
};
var trDateRegex = new TransformRowRegex(@"^Date:\ (?<datePBX>.{23}).*?$", "text");
var trToDate = new TransformerFieldStringToDate("datePBX", "NewDatePBX", "yyyy/MM/dd HH:mm:ss.fff");
var trAddDate = new TransformAddFieldDown("NewDatePBX");
var trSimpleFields = new TransformRowRemainsProperties("NewDatePBX", "lineNr", "text", "FullName", "LastWriteTimeUtc");
var data = new DBTableDataConnection <SqlConnection>(new SerializeDataInMemory());
data.ConnectionString = GetSqlServerConnectionString();
data.Fields = new string[] { "NewDatePBX", "lineNr", "text", "FullName" };
data.TableName = "PBXData";
var bulk = new SenderSqlServerBulkCopy(data);
var md = new MediaTransformMaxMin <DateTime>();
md.GroupFunction = GroupingFunctions.Max;
md.FieldName = "LastWriteTimeUtc";
var serializeMaxDate = new SenderMediaSerialize <DateTime>(serialize, "LastWriteTimeUtc", md);
var si = new SimpleJob();
si.Receivers.Add(0, r);
int iFilterNr = 0;
si.FiltersAndTransformers.Add(iFilterNr++, filterFiles);
si.FiltersAndTransformers.Add(iFilterNr++, filterDateTimeSerializable);
si.FiltersAndTransformers.Add(iFilterNr++, removeFilesMaxWritten);
si.FiltersAndTransformers.Add(iFilterNr++, transformLines);
si.FiltersAndTransformers.Add(iFilterNr++, trDateRegex);
si.FiltersAndTransformers.Add(iFilterNr++, trToDate);
si.FiltersAndTransformers.Add(iFilterNr++, trAddDate);
si.FiltersAndTransformers.Add(iFilterNr++, trSimpleFields);
//TODO: add transformer to add a field down for all fields
//TODO: add transformer regex for splitting Key=Value
//TODO: add field to separate Conn(1)Type(Any)User(InternalTask) CDL Request:RSVI(Get)
si.Senders.Add(0, bulk);
si.Senders.Add(1, serializeMaxDate);
await si.Execute();
#endregion
#region assert
filterFiles.valuesTransformed.Length.ShouldBe(3, "three files after first filter");
removeFilesMaxWritten.valuesTransformed.Length.ShouldBe(2, "last one file written dismissed");
transformLines.valuesTransformed.Length.ShouldBe(77251);
var d = transformLines.valuesTransformed.Select(it => it.Values["FullName"]).Distinct().ToArray();
d.Length.ShouldBe(2, "two files after reading contents");
//transformGroupingFiles.valuesTransformed.Length.ShouldBe(2);
//trDateRegex.valuesTransformed.Count(it => it.Values.ContainsKey("datePBX")).ShouldBeGreaterThan(0,"datePBX");
//trToDate.valuesTransformed.Count(it => it.Values.ContainsKey("NewDatePBX")).ShouldBeGreaterThan(0,"NewDatePBX");
foreach (var item in trAddDate.valuesTransformed)
{
item.Values.ShouldContainKey("NewDatePBX");
}
foreach (var item in trSimpleFields.valuesTransformed)
{
item.Values.Keys.Count.ShouldBe(5);
}
using (var con = new SqlConnection(connectionString))
{
await con.OpenAsync();
using (var cmd = con.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = "select count(*) from PBXData";
var val = await cmd.ExecuteScalarAsync();
val.ShouldBe(77251);
}
}
md.Result.Year.ShouldBe(DateTime.Now.Year);
#endregion
#region arange to read again
r = new ReceiverFolderHierarchical(dirPBX, "*.log");
filterFiles = new FilterForFilesHierarchical();
#region filter for remove dates serialize
filterDateTime = new FilterComparableGreat(typeof(DateTime), DateTime.MinValue, "LastWriteTimeUtc");
filterDateTimeSerializable = new FilterComparableFromSerializable(filterDateTime, serialize);
#endregion
#endregion
#region act
si = new SimpleJob();
si.Receivers.Add(0, r);
iFilterNr = 0;
si.FiltersAndTransformers.Add(iFilterNr++, filterFiles);
si.FiltersAndTransformers.Add(iFilterNr++, filterDateTimeSerializable);
await si.Execute();
#endregion
#region assert
filterDateTime.valuesTransformed?.Length.ShouldBe(1, "next time 1 file read - the added one");
#endregion
}
}
static string JobDllBlockly()
{
string dir = Environment.CurrentDirectory;
IReceive folderWithDll = new ReceiverFolderHierarchical("#static:Directory.GetCurrentDirectory()#", "*.dll");
var filterFiles = new FilterForFilesHierarchical();
var recContentFile = new ReceiverFromDllRelational();
var loadDllFromFiles = new TransformerApplyReceiver(recContentFile, "DllFileName", "FullName");
//retain just types
var filterTypes = new FilterRetainRelationalName(FilterType.Equal, "Types");
//load types that are not generic or abstract
//var justTypes = new FilterComparableEqual(typeof(string), "Types", "NameRelation");
var notAbstract = new FilterComparableEqual(typeof(bool), false, "IsAbstract");
var notGeneric = new FilterComparableEqual(typeof(bool), false, "IsGeneric");
var notInterface = new FilterComparableEqual(typeof(bool), false, "IsInterface");
//var noInterface = new FilterExcludeRelation("Interfaces");
//var rel2plain = new TransformerRelationalToPlain();
var haveProps = new FilterComparableGreat(typeof(int), 0, "PropertiesNr");
//var justRelations = new FilterRetainItemsWithKey("NameRelation", FilterType.Equal);
var fileRazor = Path.Combine(dir, "blockly.cshtml");
string filename = "#static:Directory.GetCurrentDirectory()#\\blockly.html";
ISend senderHTML = new SyncSenderMultiple(
new Sender_Text(filename, "<html><body>")
{
FileMode = FileMode.Create
},
new Sender_HTMLRazor("Views/" + Path.GetFileName(fileRazor), filename),
//new Sender_HTMLRelationViz("Name", filename),
new Sender_Text(filename, "</body></html>")
)
;
var senderRow = new SenderByRowToFile("Name", "txt", "Block Definition", "txt");
var clear = new TransformClearValues();
var trReceiveHtml = new ReceiverHTMLTable(@"blockly.html", Encoding.UTF8);
var decodeHtml = new TransformerHtmlDecode();
//var addJS = new TransformModifyField("Name", "{0}.js");
var senderBlockTag = new SenderByRowToFile("Name", "_def.txt", "Block definition", "txt");
var senderBlockDefinitionJs = new SenderByRowToFile("Name", "_block.js", "Block JS", "js");
var senderBlockCodeJs = new SenderByRowToFile("Name", "_code.js", "Block CodeGenerator", "js");
var job = new SimpleJobConditionalTransformers();
job
.AddReceiver(folderWithDll)
.AddFilter(filterFiles)
.AddTransformer(loadDllFromFiles)
.AddFilter(filterTypes)
.AddFilter(notAbstract)
.AddFilter(notGeneric)
.AddFilter(notInterface)
.AddFilter(haveProps)
//.AddTransformer(noInterface)
//.AddTransformer(rel2plain)
.AddSender(senderHTML)
.AddTransformer(clear)
.Add(clear, trReceiveHtml)
.Add(trReceiveHtml, decodeHtml)
.Add(decodeHtml, senderBlockTag)
.Add(decodeHtml, senderBlockDefinitionJs)
.Add(decodeHtml, senderBlockCodeJs)
;
return(job.SerializeMe());
}
public async Task TestSendHTMLDataHierarchical()
{
#region arange
var dir = AppContext.BaseDirectory;
dir = Path.Combine(dir, "TestSendDataHierarchical");
if (Directory.Exists(dir))
{
Directory.Delete(dir, true);
}
Directory.CreateDirectory(dir);
CreateFilesAndFolders(dir);
string filename = Path.Combine(dir, "senderhtml.html");
if (File.Exists(filename))
{
File.Delete(filename);
}
IReceive r = new ReceiverFolderHierarchical(dir, "*.txt");
await r.LoadData();
var fileRazor = Path.Combine(dir, "hierarFolder.cshtml");
File.Copy(@"Views\hierarFolder.cshtml", fileRazor, true);
// File.WriteAllText(fileRazor,
// @"@using System.Linq;
//@using StankinsInterfaces;
//@model StankinsInterfaces.IRow[]
//Number Rows: @Model.Length
//@{
// bool showTable=(Model.Length>0);
// if(!showTable){
// return;
// };
// var FieldNames= Model[0]
// .Values
// .Select(it => it.Key).ToArray();
//}
//<table>
//<thead>
//<tr>
//<td>ID</td>
//@foreach(var col in FieldNames){
//<td>
//@col
//</td>
//}
//<td>Parent</td>
//</thead>
//<tbody>
//@foreach(var item in Model){
// var m=item as IRowReceiveHierarchicalParent;
//<tr>
//<td>@m.ID</td>
//@foreach(var col in FieldNames){
//<td>
//@item.Values[col]
//</td>
//}
//<td>
//@if(m.Parent != null){
// <text>@m.Parent.ID</text>
//}
//</td>
//</tr>
//}
//<tbody>
//</table>");
#endregion
#region act
ISend sender = new SyncSenderMultiple(
new Sender_Text(filename, "<html><body>"),
new Sender_HTMLRazor("TestSendDataHierarchical/" + Path.GetFileName(fileRazor), filename),
new Sender_HierarchicalVizFolder(filename, "Name"),
new Sender_Text(filename, "</body></html>")
);
sender.valuesToBeSent = r.valuesRead;
await sender.Send();
#endregion
#region assert
Assert.IsTrue(File.Exists(filename), $"file {filename} must exists in export hierarchical");
Assert.IsTrue(File.ReadAllText(filename).Contains("ignat.txt"), "must contain data");
Assert.IsTrue(File.ReadAllText(filename).Contains("Viz("), "must contain viz ...");
//System.Diagnostics.Process.Start("explorer.exe", filename);
#endregion
}
