public void SelectFromDb(string connectionString, string select, int nrRows, string result)
{
var fileName = Path.Combine(Environment.CurrentDirectory, Guid.NewGuid().ToString("N"));
File.WriteAllText(fileName, select);
IReceive status = null;
IDataToSent data = null;
$"Assume Sql Server instance {connectionString} exists , if not see docker folder".w(() => {
});
$"When I create the ReceiveQueryFromFileSql ".w(() => status = new ReceiveQueryFromFileSql(fileName, connectionString));
$"and receive data".w(async() =>
{
data = await status.TransformData(null);
});
$"the data should have a table".w(() =>
{
data.DataToBeSentFurther.Count.Should().Be(2); // first table file, second table sql
});
$"should be {nrRows} rows".w(() => { data.DataToBeSentFurther[1].Rows.Count.Should().Be(nrRows); });
$"and the result should be {result} ".w(() => { data.DataToBeSentFurther[1].Rows[0][0]?.ToString().Should().Be(result); });
}
public void TestSimpleCSV(string fileContents, int numberRows, string filter, string contain, int numberRowsAfterFilter)
{
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
fileContents = fileContents.Replace("{NewLine}", nl);
$"When I create the receiver csv for the content {fileContents}".w(() => receiver = new ReceiverCSVText(fileContents));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With 1 tables and {numberRows} rows".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
data.DataToBeSentFurther[0].Rows.Count.Should().Be(numberRows);
});
$"And when I filter with {filter} {contain} ".w(async() => data = await new FilterRetainColumnDataContains(filter, contain).TransformData(data));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With 1 table and {numberRowsAfterFilter} after filter".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
data.DataToBeSentFurther[0].Rows.Count.Should().Be(numberRowsAfterFilter);
});
}
public void TestSimpleSenderOutputToExcel(string fileContents, int NumberRows, string fileName)
{
IReceive receiver = null;
IDataToSent data = null;
ISenderToOutput sender = null;
var nl = Environment.NewLine;
fileContents = fileContents.Replace("{NewLine}", nl);
fileName = Guid.NewGuid().ToString("N") + fileName;
$"the Excel {fileName} should not exists".w(() => File.Exists(fileName).Should().BeFalse());
$"When I create the receiver csv for the content {fileContents}".w(() => receiver = new ReceiverCSVText(fileContents));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRows));
$"and now I want to export to excel file ".w(async() =>
{
sender = new SenderOutputExcel(fileName);
data = await sender.TransformData(data);
}
);
$"the Excel should exists".w(() => {
sender.OutputByte.Should().NotBeNull();
sender.OutputByte.Rows.Count.Should().Be(1);
});
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
var tableAndPosition = FindTableAfterColumnName(ColumnName, receiveData);
foreach (var tablePosition in tableAndPosition)
{
var table = tablePosition.Value;
table.Columns.Add(NewColumnName);
receiveData.Metadata.Columns.Add(new Column()
{
IDTable = tablePosition.Key, Name = NewColumnName, Id = receiveData.Metadata.Columns.Count
});
foreach (DataRow dr in table.Rows)
{
var val = dr[ColumnName]?.ToString();
dr[NewColumnName] = val;
if (string.IsNullOrWhiteSpace(val))
{
continue;
}
var doc = new HtmlDocument();
doc.LoadHtml(val);
var attr = doc.DocumentNode.SelectNodes("//@" + AttributeName).FirstOrDefault();
if (attr != null)
{
dr[NewColumnName] = attr.Attributes[AttributeName].Value;
continue;
}
}
}
return(await Task.FromResult(receiveData));
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
DataTable dt;
if (receiveData.Metadata.Tables.Count(it => it.Name == "Cachet") == 1)
{
dt = receiveData.FindAfterName("Cachet").Value;
}
else
{
dt = receiveData.DataToBeSentFurther[0];
}
var componentsList = await components();
foreach (DataRow dr in dt.Rows)
{
var componentName = dr["component"].ToString();
if (!componentsList.Exists(it => it.Value == componentName))
{
var id = await CreateComponent(componentName);
componentsList.Add(new KeyValuePair <long, string>(id, componentName));
}
var componentId = componentsList.First(it => it.Value == componentName).Key;
var incidentName = dr["incidentName"].ToString();
var incidentMessage = dr["incidentMessage"].ToString();
var incidentStatus = int.Parse(dr["incidentStatus"].ToString());
var componentStatus = int.Parse(dr["componentStatus"].ToString());
await CreateNewIncident(componentId, componentStatus, incidentName, incidentMessage, incidentStatus);
}
return(await Task.FromResult(receiveData));
}
public void TestSimpleCSVRender(string fileContents, int numberRows)
{
string newFolder = Guid.NewGuid().ToString("N");
var dir = Path.Combine(Environment.CurrentDirectory, newFolder);
Directory.CreateDirectory(dir);
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
fileContents = fileContents.Replace("{NewLine}", nl);
$"When I create the receiver csv for the content {fileContents}".w(() => receiver = new ReceiverCSVText(fileContents));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {numberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(numberRows));
$"and now use SenderRazorTableOneByOne ".w(async() =>
{
data = await new SenderRazorTableOneByOne("aaa", dir).TransformData(data);
});
$"and the new folder {dir} should have 1 file".w(() => { Directory.GetFiles(dir).Length.Should().Be(1); });
}
protected int FastAddTable(IDataToSent receiveData, DataTable dt)
{
int id = receiveData.AddNewTable(dt);
receiveData.Metadata.AddTable(dt, id);
return(id);
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
foreach (var item in receiveData.DataToBeSentFurther)
{
var table = item.Value;
if (!this.IsTableOk(table))
{
continue;
}
table.Columns.Add(NewColumnName + "@", typeof(string), Expression);
table.Columns.Add(NewColumnName, typeof(string));
foreach (DataRow dr in table.Rows)
{
dr[NewColumnName] = dr[NewColumnName + "@"]?.ToString();
}
table.Columns.Remove(NewColumnName + "@");
receiveData.Metadata.Columns.Add(new Column()
{
IDTable = item.Key, Name = NewColumnName, Id = receiveData.Metadata.Columns.Count
});
}
return(await Task.FromResult(receiveData));
}
public void TestSimpleCSV(string fileContents, int NumberRows)
{
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
fileContents = fileContents.Replace("{NewLine}", nl);
$"When I create the receiver csv for the content {fileContents}".w(() => receiver = new ReceiverCSVText(fileContents));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRows));
var filesCSV = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.json");
foreach (var f in filesCSV)
{
File.Delete(f);
}
$" and no csv files existing".w(() => Directory.GetFiles(Directory.GetCurrentDirectory(), "*.csv").Length.Should().Be(0));
$"and now I export to json to the current folder".w(async() => data = await new SenderDefinitionToFile("a.json").TransformData(data));
$" and now 1 json files existing".w(() => Directory.GetFiles(Directory.GetCurrentDirectory(), "*.json").Length.Should().Be(1));
}
public override Task <IDataToSent> TransformData(IDataToSent receiveData)
{
tables = FindTableAfterColumnName(NameColumn, receiveData)
.Select(it => it.Value.TableName)
.ToArray();
return(base.TransformData(receiveData));
}
protected DataTable CreateTable(IDataToSent dataToSent)
{
string nameTable = nameof(AliveStatus);
try{
return(dataToSent.FindAfterName(nameTable).Value);
}
catch
{
//do nothing, create table is following
}
var m = new DataTable();
m.TableName = nameTable;
m.Columns.Add("Process", typeof(string));
m.Columns.Add("Arguments", typeof(string));
m.Columns.Add("To", typeof(string));
m.Columns.Add("IsSuccess", typeof(bool));
m.Columns.Add("Result", typeof(string));
m.Columns.Add("Duration", typeof(long));
m.Columns.Add("DetailedResult", typeof(string));
m.Columns.Add("Exception", typeof(string));
m.Columns.Add("StartedDate", typeof(DateTime));
dataToSent.AddNewTable(m);
dataToSent.Metadata.AddTable(m, dataToSent.Metadata.Tables.Count);
return(m);
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
DataTable dt = new DataTable
{
TableName = Path.GetDirectoryName(dirPath)
};
dt.Columns.Add(new DataColumn("FileName", typeof(string)));
dt.Columns.Add(new DataColumn("FullFileName", typeof(string)));
dt.Columns.Add(new DataColumn("Info", typeof(string)));
foreach (string item in Directory.EnumerateFiles(dirPath))
{
try
{
FileVersionInfo info = FileVersionInfo.GetVersionInfo(item);
dt.Rows.Add(new[] { Path.GetFileName(item), item, JsonConvert.SerializeObject(info) });
}
catch (Exception)
{
//TODO: log
}
}
int id = receiveData.AddNewTable(dt);
receiveData.Metadata.AddTable(dt, id);
return(await Task.FromResult(receiveData));
}
//[Example("Server=(local);Database=msdb;User Id=SA;Password = <YourStrong!Passw0rd>;", "sys.tables", "a.xlsx")]
public void ExportTableToExcelSql(string connectionString, string tableName, string fileName)
{
IReceive status = null;
IDataToSent data = null;
fileName = Guid.NewGuid().ToString("N") + fileName;
$"the Excel {fileName} should not exists".w(() => File.Exists(fileName).Should().BeFalse());
$"Assume Sql Server instance {connectionString} exists , if not see docker folder".w(() => { });
$"When I create the ExportTableToExcelSql ".w(() =>
status = new ExportTableToExcelSql(connectionString, tableName, fileName));
$"and receive data".w(async() => { data = await status.TransformData(null); });
$"the data should have a table".w(() =>
{
data.DataToBeSentFurther.Count.Should().Be(3);
//table + 2 outputs
});
$"the Excel {fileName} should exists".w(() => File.Exists(fileName).Should().BeTrue());
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
var nr = receiveData.DataToBeSentFurther.Count;
var fmt = "#".PadLeft(nr.ToString().Count() + 1).Replace(" ", "0");
foreach (var item in receiveData.DataToBeSentFurther)
{
string fileName = item.Key.ToString(fmt) + item.Value.TableName;
var fullFilePath = Path.Combine(FolderPath, fileName + ".wpost");
var cf = new CompoundFile(@"a.wpost", CFSUpdateMode.ReadOnly, CFSConfiguration.Default);
var rs = cf.RootStorage;
var t = rs.TryGetStream("Title");
t.SetData(Str(fileName));
var allData = new StringBuilder(First);
var c = rs.TryGetStream("Contents");
foreach (DataRow dr in item.Value.Rows)
{
var str = string.Join(SeparatorColumn, dr.ItemArray);
allData.Append($"{str}{SeparatorRow}");
}
allData.Append(Last);
c.SetData(Str(allData.ToString()));
cf.Save(fullFilePath);
}
return(await Task.FromResult(receiveData));
}
public void TestSimpleCSVWithConst(string fileContents, int NumberRows, string newVal)
{
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
fileContents = fileContents.Replace("{NewLine}", nl);
$"When I create the receiver csv for the content {fileContents}".w(() => receiver = new ReceiverCSVText(fileContents));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRows));
$"and now I send to razor {nameof(SenderToRazorWithContents)}".w(async() =>
{
data = await new SenderToRazorWithContents("asdasdasd").TransformData(data);
});
$"and I can transform the value of the output ".w(async() =>
{
data = await new TransformerOutputStringColumnName(newVal).TransformData(data);
});
$"should be the value equal to {newVal}".w(() =>
{
data.FindAfterName("OutputString").Value.Rows[0]["Name"].ToString().Should().Be(newVal.Replace("'", ""));
});
}
public void TestAmazonCopyPasteStackOverflow(string fileName, int nrRows, string author)
{
IReceive receiver = null;
IDataToSent data = null;
DataTable dtContent = null;
$"Given the file {fileName} ".w(() =>
{
File.Exists(fileName).Should().BeTrue();
});
$"When I create the {nameof(AmazonMeta)} for the {fileName}".w(() => receiver = new AmazonMeta(fileName, null));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {nrRows}".w(() =>
{
dtContent = data.DataToBeSentFurther[0];
dtContent.Rows.Count.Should().Be(nrRows);
});
$"and should contain as {nameof(author)} me: {author}".w(() =>
{
var dv = new DataView(dtContent);
dv.RowFilter = $"meta_name='author'";
dv.Count.Should().Be(1);
dv[0]["meta_content"].ToString().Should().Be((author));
});
}
public void TestSimpleJSON(string fileName, int NumberRows)
{
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
$"Given the file {fileName}".w(() =>
{
File.Exists(fileName).Should().BeTrue();
});
$"When I create the ReceiveRest for the {fileName}".w(() => receiver = new ReceiveRestFromFile(fileName));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRows));
$"and now I export to typescript definition ".w(async() =>
data = await new SenderToTypeScript().TransformData(data));
$"should have 1 record in ExportOutput".w(() =>
data.FindAfterName("OutputString").Value.Rows.Count.Should().Be(1));
}
public void TestSimpleJSON(string fileName, int NumberRows)
{
string urlCachet = Environment.GetEnvironmentVariable("cachet");
if (string.IsNullOrWhiteSpace(urlCachet))
{
urlCachet = "localhost";
}
urlCachet = "http://" + urlCachet + ":8000";
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
$"Given the file {fileName}".w(() =>
{
File.Exists(fileName).Should().BeTrue();
});
$"When I create the {nameof(ReceiveRest)} for the {fileName}".w(() => receiver = new ReceiveRestFromFile(fileName));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRows));
$"and now I transform with {nameof(SenderCachet)}".w(async() =>
data = await new SenderCachet(urlCachet, "5DiHQgKbsJqck4TWhMVO").TransformData(data)
);
}
//[Example("https://trello.com/b/SQYjpHEf.json",3)]
public void TestTrelloJson(string fileName, int numberTables, int nrLists, int nrCards, int nrComments)
{
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
$"Given the file {fileName}".w(() =>
{
//File.Exists(fileName).Should().BeTrue();
});
$"When I create the receiver trello for the {fileName}".w(() => receiver = new ReceiverFromTrello(fileName));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a {numberTables}: tables: list, card , tables".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(numberTables);
});
$"With {nrLists} lists".w(() =>
{
var list = data.FindAfterName("list");
list.Value.Rows.Count.Should().Be(nrLists);
});
$"With {nrCards} cards".w(() =>
{
var list = data.FindAfterName("card");
list.Value.Rows.Count.Should().Be(nrCards);
});
$"with {nrComments} comments".w(() =>
{
var list = data.FindAfterName("comment");
list.Value.Rows.Count.Should().Be(nrComments);
});
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
results = CreateTable(receiveData);
sw = Stopwatch.StartNew();
StartedDate = DateTime.UtcNow;
try
{
process = new ProcessIntercept(FileName, Arguments);
process.OutputDataReceived += new dia.DataReceivedEventHandler(Process_OutputDataReceived);
process.ErrorDataReceived += new dia.DataReceivedEventHandler(Process_ErrorDataReceived);
//process.Exited += new System.EventHandler(Process_Exited);
process.StartProcessAndWait();
}
catch (Exception ex)
{
results.Rows.Add("process", Arguments, FileName + Arguments, false, ex.Message, sw.ElapsedMilliseconds, "", ex.Message, StartedDate);
}
return(await Task.FromResult(receiveData));
}
public void CreateOutputIfNotExists(IDataToSent receiveData)
{
try
{
OutputString = receiveData.FindAfterName("OutputString").Value as DataTableString;
}
catch
{
OutputString = new DataTableString
{
TableName = "OutputString"
};
FastAddTable(receiveData, OutputString);
}
try
{
OutputByte = receiveData.FindAfterName("OutputByte").Value as DataTableByte;
}
catch
{
OutputByte = new DataTableByte
{
TableName = "OutputByte"
};
FastAddTable(receiveData, OutputByte);
}
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
var reg = new Regex(Expression, RegexOptions.IgnoreCase | RegexOptions.Multiline);
var tables = base.FindTableAfterColumnName(NameColumn, receiveData);
foreach (var item in tables)
{
for (int i = item.Value.Rows.Count - 1; i >= 0; i--)
{
var val = item.Value.Rows[i][NameColumn]?.ToString();
if (val == null)
{
continue;
}
if (reg.IsMatch(val))
{
continue;
}
item.Value.Rows.RemoveAt(i);
}
}
return(await Task.FromResult(receiveData));
}
public void TestSimpleCSV(string fileContents, int NumberRows, int NumberRowsAfterFilter)
{
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
fileContents = fileContents.Replace("{NewLine}", nl);
$"When I create the receiver csv for the content {fileContents}".w(() =>
receiver = new ReceiverCSVText(fileContents));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRows}".w(() =>
data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRows));
$"And when I filter".w(async() =>
data = await new FilterRemoveColumnDataGreaterThanLength("Car", 5).TransformData(data));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {NumberRowsAfterFilter}".w(() =>
data.DataToBeSentFurther[0].Rows.Count.Should().Be(NumberRowsAfterFilter));
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
DataTable results = CreateTable(receiveData);
var sw = Stopwatch.StartNew();
var StartedDate = DateTime.UtcNow;
try
{
var resp = NewConnection();
using (resp)
{
resp.ConnectionString = connectionString;
await resp.OpenAsync();
results.Rows.Add("receiverdatabaseserver", "", connectionString, true, resp.State, sw.ElapsedMilliseconds, resp.ServerVersion, null, StartedDate);
}
}
catch (Exception ex)
{
results.Rows.Add("receiverdatabaseserver", "", connectionString, false, null, sw.ElapsedMilliseconds, null, ex.Message, StartedDate);
}
return(await Task.FromResult(receiveData));
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
var jobUrl = url + "/job/" + jobName + "/api/json";
var res = new ReceiveRestFromFile(jobUrl);
var results = CreateTable(receiveData);
var sw = Stopwatch.StartNew();
DateTime StartedDate = DateTime.UtcNow;
try
{
var data = await res.TransformData(receiveData);
results.Rows.Add("jenkinsjob", "/job/" + jobName + "/api/json", url, true, "", sw.ElapsedMilliseconds, "", null, StartedDate);
return(data);
}
catch (Exception ex)
{
results.Rows.Add("jenkinsjob", "", url, false, null, sw.ElapsedMilliseconds, null, ex.Message, StartedDate);
}
return(receiveData);
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
foreach (var dt in receiveData.DataToBeSentFurther)
{
var colString = new List <string>();
foreach (DataColumn dc in dt.Value.Columns)
{
if (dc.DataType == typeof(string))
{
colString.Add(dc.ColumnName);
}
}
if (colString.Count == 0)
{
continue;
}
foreach (DataRow dr in dt.Value.Rows)
{
foreach (var col in colString)
{
dr[col] = dr[col]?.ToString()?.Trim();
}
}
}
return(await Task.FromResult(receiveData));
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
var sw = Stopwatch.StartNew();
DataTable results = CreateTable(receiveData);
var pingSender = new Ping();
var StartedDate = DateTime.UtcNow;
try
{
var reply = pingSender.Send(NameSite);
results.Rows.Add("ping", "", NameSite, true, (int)reply.Status, reply.RoundtripTime.ToString(), reply.RoundtripTime.ToString(), null, StartedDate);
}
catch (Exception ex)
{
results.Rows.Add("ping", "", NameSite, false, null, sw.ElapsedMilliseconds, null, ex.Message, StartedDate);
}
return(await Task.FromResult(receiveData));
}
public void SenderToHTML(string connectionString)
{
IReceive status = null;
ISenderToOutput sender = null;
IDataToSent data = null;
$"Assume Sql Server instance {connectionString} exists , if not see docker folder".w(() => {
});
$"When I create the ReceiverDBServer ".w(() => status = new ReceiveMetadataFromDatabaseSql(connectionString));
$"and receive data".w(async() =>
{
data = await status.TransformData(null);
});
$"the data should have a tables, columns, relations,keys,properties".w(() =>
{
data.DataToBeSentFurther.Count.Should().Be(5);
});
$"and now export to SenderToDot".w(async() => {
sender = new SenderDBDiagramHTMLDocument("");
data = await sender.TransformData(data);
});
$"should be some content".w(() =>
{
sender.OutputString.Should().NotBeNull();
sender.OutputString.Rows.Count.Should().Be(1);
//File.WriteAllText(@"C:\Users\Surface1\Desktop\viz.html", sender.OutputContents.First().Value);
//Process.Start("notepad.exe","a.txt");
});
}
public void TestSimpleReceive(string newFileName, int numberRows)
{
string newFolder = Guid.NewGuid().ToString("N");
var dir = Path.Combine(Environment.CurrentDirectory, newFolder);
Directory.CreateDirectory(dir);
var full = Path.Combine(dir, newFileName);
File.WriteAllText(full, newFileName);
IReceive receiver = null;
IDataToSent data = null;
var nl = Environment.NewLine;
$"When I create the receiver files in folder {newFolder}".w(() => receiver = new ReceiverReadFileText(full));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With a table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().Be(1);
});
$"The number of rows should be {numberRows}".w(() => data.DataToBeSentFurther[0].Rows.Count.Should().Be(numberRows));
$"and the contents should be {newFileName}".w(() =>
data.DataToBeSentFurther[0].Rows[0]["FileContents"].Should().Be(newFileName));
$"and the FilePath should be {full}".w(() =>
data.DataToBeSentFurther[0].Rows[0]["FilePath"].Should().Be(full));
}
public void TestAliveJob(string url, string job, int numberTables)
{
//if this does not work and you have already a jenkins running in docker-compose
//run this
//docker exec docker_jenkins_1 bash -c "cat /var/jenkins_home/jenkinsjob.xml | java -jar /var/jenkins_home/war/WEB-INF/jenkins-cli.jar -s http://localhost:8080 create-job newmyjob"
IReceive receiver = null;
IDataToSent data = null;
string nl = Environment.NewLine;
$"When I create the {nameof(ReceiverJenkinsJob)} for the {url}".w(() => receiver = new ReceiverJenkinsJob(url, job));
$"And I read the data".w(async() => data = await receiver.TransformData(null));
$"Then should be a data".w(() => data.Should().NotBeNull());
$"With {numberTables} table".w(() =>
{
data.DataToBeSentFurther.Should().NotBeNull();
data.DataToBeSentFurther.Count.Should().BeGreaterOrEqualTo(numberTables);
});
$"and should have data success".w(() =>
{
var res = AliveStatus.FromTable(data.DataToBeSentFurther.First().Value);
res.Should().NotBeNull();
res.Count().Should().Be(1);
res.First().IsSuccess.Should().Be(true);
});
}
