static void Main(string[] args)
{
System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
///Specify the name of the database
string database = "db_" + DateTime.Now.ToString("yyyyMMddHHmmss");
var builder = new TaosConnectionStringBuilder()
{
DataSource = "114.116.231.247",
DataBase = database,
Username = "******",
Password = "******",
Port = 6060
};
//Example for ADO.Net
using (var connection = new TaosConnection(builder.ConnectionString))
{
connection.Open();
Console.WriteLine("create {0} {1}", database, connection.CreateCommand($"create database {database};").ExecuteNonQuery());
Console.WriteLine("create table t {0} {1}", database, connection.CreateCommand($"create table {database}.t (ts timestamp, cdata int);").ExecuteNonQuery());
Console.WriteLine("insert into t values {0} ", connection.CreateCommand($"insert into {database}.t values ({(long)(DateTime.Now.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalMilliseconds)}, 10);").ExecuteNonQuery());
//Console.WriteLine("insert into t values {0} ", connection.CreateCommand($"insert into {database}.t values ({(long)(DateTime.Now.AddMonths(1).Subtract(new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalMilliseconds)}, 20);").ExecuteNonQuery());
var cmd_select = connection.CreateCommand();
cmd_select.CommandText = $"select * from {database}.t";
var reader = cmd_select.ExecuteReader();
Console.WriteLine(cmd_select.CommandText);
Console.WriteLine("");
ConsoleTableBuilder.From(reader.ToDataTable()).WithFormat(ConsoleTableBuilderFormat.MarkDown).ExportAndWriteLine();
Console.WriteLine("");
Console.WriteLine("DROP TABLE {0} {1}", database, connection.CreateCommand($"DROP TABLE {database}.t;").ExecuteNonQuery());
Console.WriteLine("DROP DATABASE {0} {1}", database, connection.CreateCommand($"DROP DATABASE {database};").ExecuteNonQuery());
connection.Close();
}
//Example for Entity Framework Core
using (var context = new TaosContext(new DbContextOptionsBuilder()
.UseTaos(builder.ConnectionString).Options))
{
Console.WriteLine("EnsureCreated");
context.Database.EnsureCreated();
for (int i = 0; i < 10; i++)
{
var rd = new Random();
context.sensor.Add(new sensor()
{
ts = DateTime.Now.AddMilliseconds(i), degree = rd.NextDouble(), pm25 = rd.Next(0, 1000)
});
}
Console.WriteLine("Saveing");
context.SaveChanges();
Console.WriteLine("");
Console.WriteLine("from s in context.sensor where s.pm25 > 0 select s ");
Console.WriteLine("");
var f = from s in context.sensor where s.pm25 > 0 select s;
var ary = f.ToArray();
ConsoleTableBuilder.From(ary.ToList()).WithFormat(ConsoleTableBuilderFormat.MarkDown).ExportAndWriteLine();
context.Database.EnsureDeleted();
}
Console.WriteLine("");
}
private string Tabularize(List <ServerInfo> serverList)
{
var scoreTable = new DataTable();
scoreTable.Columns.Add("# SERVER", typeof(string));
scoreTable.Columns.Add("SCORE", typeof(string));
scoreTable.Columns.Add("LEVEL", typeof(string));
scoreTable.Columns.Add("NICKNAME", typeof(string));
scoreTable.Columns.Add("PLAYER COUNT", typeof(string));
foreach (var server in serverList)
{
scoreTable.Rows.Add(server.Label, server.TopPlayerScore, server.TopPlayerLevel, server.TopPlayerName, server.ClientCount);
}
var result = "```md\n";
result += ConsoleTableBuilder.From(scoreTable)
.WithFormat(ConsoleTableBuilderFormat.Minimal)
.Export()
.ToString();
result += "```";
return(result);
}
internal static void Work(string[] args)
{
var inputData = ConsoleParamsParser.GetParams(args);
var calculator = new Calculator(inputData);
calculator.Init();
var resultTable = new DataTable();
resultTable.Columns.Add("Автор", typeof(string));
var results = new List <Result>();
var totalDays = (inputData.DtTill - inputData.DtFrom).Days;
for (int i = 0; i <= totalDays; i = i + INTERVAL)
{
var dtStepFrom = inputData.DtFrom.AddDays(i);
var dtStepTill = inputData.DtFrom.AddDays(i + INTERVAL);
resultTable.Columns.Add(dtStepFrom.ToShortDateString() + " - " + dtStepTill.ToShortDateString(), typeof(int));
var result = calculator.Calculate(dtStepFrom, dtStepTill);
results.Add(result);
}
FillResultTable(results, resultTable);
if (resultTable.Rows.Count != 0)
{
ConsoleTableBuilder.From(resultTable).ExportAndWriteLine();
}
}
public async Task <int> CreateStatsAsync(MonsterCreationOption creationOption)
{
try
{
var _monsterStatsGenerator = _monsterStatsGeneratorStrategyFactory.Get(creationOption);
var monsterStats = new List <MonsterStats>
{
_monsterStatsGenerator.GenerateMonsterStats(creationOption)
};
ConsoleTableBuilder.From(monsterStats)
.WithFormat(ConsoleTableBuilderFormat.MarkDown)
.ExportAndWriteLine();
if (creationOption.WriteToFile)
{
await _fileCreatorService.CreateFile(creationOption.Path, monsterStats);
}
}
catch (Exception ex)
{
_logger.LogDebug(ex, "Something went wrong...");
return(-1);
}
return(0);
}
static void DisplayAccounts()
{
Console.Clear();
if (_bank.AccountsCount > 0)
{
Console.WriteLine($"Registered accounts: ({_bank.AccountsCount})");
var table = new DataTable();
table.Columns.Add("ID", typeof(string));
table.Columns.Add("Name", typeof(string));
table.Columns.Add("Balance", typeof(string));
table.Columns.Add("Account Type", typeof(string));
_bank.Accounts.ForEach(account =>
{
table.Rows.Add(account.Id, account.Name, $"{account.Balance} kr", account.Type.ToString());
});
ConsoleTableBuilder.From(table).WithFormat(ConsoleTableBuilderFormat.Minimal).ExportAndWriteLine();
}
else
{
Console.WriteLine("There are no registered accounts...");
}
Console.Read();
}
static void DisplayQuickNetworkResponse()
{
DataTable dt = new DataTable();
dt.Columns.Add("EXPECTED");
dt.Columns.Add("ACTUAL");
dt.Columns.Add("PROBABILITY [%]");
for (int l = 0; l < X.Length; l++)
{
double[][] x = Matrix.Create(1, N);
x[0] = X[l];
int expectedResponse = Y[l].ToList().IndexOf(Y[l].Max());
var y = CalculateReponse(x);
double actualMaxValue = y.Max();
int actualResponse = y.ToList().IndexOf(actualMaxValue);
DataRow row = dt.NewRow();
row[0] = (Animals)expectedResponse;
row[1] = (Animals)actualResponse;
row[2] = actualMaxValue;
dt.Rows.Add(row);
}
ConsoleTableBuilder builder = ConsoleTableBuilder.From(dt);
builder.ExportAndWrite();
}
public static void PrintConfusionTable(List <string> labelnames, int[,] matrix)
{
Console.WriteLine("Konfusionstabel");
DataTable dt = new DataTable();
dt.Columns.Add("Forfatter");
for (int dimension = 0; dimension < labelnames.Count; dimension++)
{
dt.Columns.Add(labelnames[dimension]);
}
for (int element = 0; element < (labelnames.Count); element++)
{
DataRow row = dt.NewRow();
for (int dimension = 0; dimension < labelnames.Count; dimension++)
{
// Console.Write("{0} ", matrix[element, dimension]);
row[0] = labelnames[element];
if (labelnames[dimension] != "")
{
row[labelnames[dimension]] = matrix[element, dimension];
}
}
dt.Rows.Add(row);
}
ConsoleTableBuilder.From(dt).WithFormat(ConsoleTableBuilderFormat.Alternative).ExportAndWriteLine();
}
static void ChargeInterests()
{
if (_bank.AccountsCount > 0)
{
Console.WriteLine($"Accounts charged: ({_bank.AccountsCount})");
var table = new DataTable();
table.Columns.Add("ID", typeof(string));
table.Columns.Add("Old Balance", typeof(string));
table.Columns.Add("New Balance", typeof(string));
table.Columns.Add("Differential", typeof(string));
table.Columns.Add("Interest", typeof(string));
_bank.Accounts.ForEach(account =>
{
var oldBalance = account.Balance;
_bank.ChargeInterest(account);
var newBalance = account.Balance;
table.Rows.Add(account.Id, $"{oldBalance} kr", $"{newBalance} kr", $"{oldBalance - newBalance} kr", $"{account.InterestRate * 100} %");
});
ConsoleTableBuilder.From(table).WithFormat(ConsoleTableBuilderFormat.Minimal).ExportAndWriteLine();
}
else
{
Console.WriteLine("There are no registered accounts...");
}
Console.Read();
}
void PrintEvaluation(int truePositive, int trueNegative, int falsePositive, int falseNegative)
{
var contingencyTable = new DataTable();
contingencyTable.Columns.Add("", typeof(string));
contingencyTable.Columns.Add("Normal Predicted", typeof(int));
contingencyTable.Columns.Add("Abnormal Predicted", typeof(int));
contingencyTable.Rows.Add("Normal Actual", truePositive, falseNegative);
contingencyTable.Rows.Add("Abnormal Actual", falsePositive, trueNegative);
Console.WriteLine("Confusion Matrix:");
ConsoleTableBuilder.From(contingencyTable)
.WithFormat(ConsoleTableBuilderFormat.MarkDown)
.ExportAndWriteLine();
// compute precision
var precision = truePositive / (double)(truePositive + falsePositive);
var recall = truePositive / (double)(truePositive + falseNegative);
var accuracy = (truePositive + trueNegative) / (double)(truePositive + trueNegative + falsePositive + falseNegative);
var fmeasure = 2 * (precision * recall) / (precision + recall);
var measuresTable = new DataTable();
measuresTable.Columns.Add("Metric", typeof(string));
measuresTable.Columns.Add("Value", typeof(double));
measuresTable.Rows.Add("Precision", precision);
measuresTable.Rows.Add("Recall", recall);
measuresTable.Rows.Add("Accuracy", accuracy);
measuresTable.Rows.Add("F-measure", fmeasure);
Console.WriteLine("Measures:");
ConsoleTableBuilder.From(measuresTable)
.WithFormat(ConsoleTableBuilderFormat.MarkDown)
.ExportAndWriteLine();
}
private void LoadAndTest(FlowProfile profile, IEnumerable <IPacketRecord> packets)
{
var getFlowKeyFunc = FlowKey.GetFlowKeyFunc(profile.FlowAggregation);
var getModelKeyFunc = profile.ProtocolFactory.GetModelKeyFunc(profile.ModelKey);
var startTime = packets.First().TimeEpoch;
var packetBins = packets.GroupBy(p => (int)Math.Floor((p.TimeEpoch - startTime) / profile.WindowSize));
var normalTotal = 0;
var abnormalTotal = 0;
var unknownTotal = 0;
foreach (var group in packetBins)
{
var flows = profile.ProtocolFactory.CollectCoapFlows(group, getModelKeyFunc, getFlowKeyFunc);
var testResults = TestAndPrint(profile, flows, $"{DateTime.UnixEpoch.AddSeconds((long)startTime + (group.Key * profile.WindowSize))}");
normalTotal += testResults.Normal;
abnormalTotal += testResults.Abnormal;
unknownTotal += testResults.Unknown;
}
var measuresTable = new DataTable();
measuresTable.Columns.Add("Metric", typeof(string));
measuresTable.Columns.Add("Value", typeof(double));
measuresTable.Rows.Add("Normal", normalTotal);
measuresTable.Rows.Add("Abnormal", abnormalTotal);
measuresTable.Rows.Add("Unknown", unknownTotal);
Console.WriteLine("Measures:");
ConsoleTableBuilder.From(measuresTable)
.WithFormat(ConsoleTableBuilderFormat.MarkDown)
.ExportAndWriteLine();
}
private void ImprimirTabelaAsync(AnaliseDto analiseDto)
{
List <AnaliseDto> listaBaseTabela = new List <AnaliseDto>()
{
analiseDto
};
ConsoleTableBuilder
.From(listaBaseTabela)
.WithFormat(ConsoleTableBuilderFormat.Alternative)
.WithColumn(
"Nome Arquivo",
"Tamanho Arquivo",
"Caminho Físico",
"Número Iterações",
"Tempo Total Geração Arquivo",
"Tempo Médio Geração Arquivo")
.WithTextAlignment(new Dictionary <int, TextAligntment>()
{
{ 1, TextAligntment.Right },
{ 3, TextAligntment.Right },
{ 4, TextAligntment.Right },
{ 5, TextAligntment.Right }
})
.ExportAndWriteLine(TableAligntment.Left);
}
public void AlternativeFormatWithDataTable()
{
var strBuilder =
ConsoleTableBuilder
.From(SampleData.SampleTableData)
.WithFormat(ConsoleTableBuilderFormat.Alternative)
.Export();
Assert.IsTrue(strBuilder.ToString() == @"
+----------------+-------------------------------+---------------+-----+------------------------+
| Name | Position | Office | Age | Start Date |
+----------------+-------------------------------+---------------+-----+------------------------+
| Airi Satou | Accountant | Tokyo | 33 | 5/9/2017 12:00:00 AM |
+----------------+-------------------------------+---------------+-----+------------------------+
| Angelica Ramos | Chief Executive Officer (CEO) | New York | 47 | 1/12/2017 12:00:00 AM |
+----------------+-------------------------------+---------------+-----+------------------------+
| Ashton Cox | Junior Technical Author | London | 46 | 4/2/2017 12:00:00 AM |
+----------------+-------------------------------+---------------+-----+------------------------+
| Bradley Greer | Software Engineer | San Francisco | 28 | 11/15/2017 12:00:00 AM |
+----------------+-------------------------------+---------------+-----+------------------------+
".TrimStart());
var lines = strBuilder.ToString().Split('\n');
Assert.IsTrue(lines.Length == 12);
}
public void AlternativeFormatWithUtf8CharactersDataTable()
{
var strBuilder =
ConsoleTableBuilder
.From <dynamic>(SampleData.SampleListWithUtf8Characters)
.WithTitle("a中123午b", ConsoleColor.Yellow, ConsoleColor.DarkGray)
.WithFormat(ConsoleTableBuilderFormat.Alternative)
.Export();
Assert.IsTrue(strBuilder.ToString() == @"
+-------------+-------------- a中123午b +-----------+------+---------+
| Id | Name | Host | Port | status |
+-------------+-------------------------+-----------+------+---------+
| 中午午午午c | tab其它语言test | 127.0.0.1 | 80 | success |
+-------------+-------------------------+-----------+------+---------+
| a中午b | London语a言aa它xx | 127.0.0.1 | 80 | success |
+-------------+-------------------------+-----------+------+---------+
| Airi Satou | Accountant | 127.0.0.1 | 80 | Tokyo |
+-------------+-------------------------+-----------+------+---------+
| Ashton Cox | Junior Technical Author | 127.0.0.1 | 80 | success |
+-------------+-------------------------+-----------+------+---------+
".TrimStart());
var lines = strBuilder.ToString().Split('\n');
Assert.IsTrue(lines.Length == 12);
}
static void Main(string[] args)
{
while (true)
{
Console.Clear();
Console.WriteLine("Enter First Name ");
fName = Console.ReadLine().ToLower();
Console.WriteLine("Enter Last Name ");
LName = Console.ReadLine().ToLower();
////int word1Score = GenerateScoreValue(word1);
//// Console.WriteLine(word1Score);
//Console.WriteLine("Enter Word 2");
//string word2 = Console.ReadLine().ToUpper();
////int word2Score = GenerateScoreValue(word2);
//// Console.WriteLine(word2Score);
//Console.WriteLine(val);
ConsoleTableBuilder
.From(GetRealData())
.ExportAndWriteLine();
// Should_Be_Similar();
Console.ReadKey();
}
}
static void DisplayTransactions()
{
Console.Clear();
if (_bank.TransactionsCount > 0)
{
Console.WriteLine($"Registered transactions: ({_bank.TransactionsCount})");
var table = new DataTable();
table.Columns.Add("ID", typeof(string));
table.Columns.Add("Sender", typeof(string));
table.Columns.Add("Reciever", typeof(string));
table.Columns.Add("Amount", typeof(string));
_bank.Transactions.ForEach(transaction =>
{
table.Rows.Add(transaction.Id.Substring(0, 12), transaction.Sender?.Id ?? "null", transaction.Reciever?.Id ?? "null", transaction.Amount.ToString("0.00"));
});
ConsoleTableBuilder.From(table).WithFormat(ConsoleTableBuilderFormat.Minimal).ExportAndWriteLine();
}
else
{
Console.WriteLine("There are no registered transactions...");
}
Console.Read();
}
static void DisplayFullNetworkResponse()
{
DataTable dt = new DataTable();
dt.Columns.Add("y1");
dt.Columns.Add("y2");
dt.Columns.Add("y3");
for (int l = 0; l < X_train.Length; l++)
{
double[][] x = Matrix.Create(1, N);
x[0] = X_train[l];
var y = CalculateReponse(x);
DataRow row = dt.NewRow();
row[0] = "PD";
row[1] = "PI";
row[2] = "PID";
row[3] = y[0];
row[4] = y[1];
row[5] = y[2];
dt.Rows.Add(row);
}
ConsoleTableBuilder builder = ConsoleTableBuilder.From(dt);
builder.ExportAndWrite();
}
static void DisplayQuickNetworkResponse()
{
DataTable dt = new DataTable();
dt.Columns.Add("EXPECTED");
dt.Columns.Add("ACTUAL");
dt.Columns.Add("PROBABILITY [%]");
for (int l = 0; l < Y_validation.Length; l++)
{
int expectedResponse = Y_validation[l].ToList().IndexOf(Y_validation[l].Max());
var y = Validate(l);
double actualMaxValue = y.Max();
int actualResponse = y.ToList().IndexOf(actualMaxValue);
DataRow row = dt.NewRow();
row[0] = (PID)expectedResponse;
row[1] = (PID)actualResponse;
row[2] = actualMaxValue;
dt.Rows.Add(row);
}
ConsoleTableBuilder builder = ConsoleTableBuilder.From(dt);
builder.ExportAndWrite();
}
private static void PrintNugetConsolidationInformations(List <Solution> solutions, CommandLineOption opts)
{
IEnumerable <Nuget> nugets = solutions.SelectMany(s => s.Nugets);
if (!string.IsNullOrEmpty(opts.FilterDependency))
{
nugets = nugets.Where(n => n.Name.Equals(opts.FilterDependency));
}
nugets.Select(n => n.Name).Distinct().ToList().ForEach(n =>
{
DataTable table = new DataTable();
table.Columns.Add("Nuget Name", typeof(string));
table.Columns.Add("Target Framework", typeof(string));
table.Columns.Add("Used versions", typeof(string));
nugets.Select(_n => _n.TargetFramework).Distinct().ToList().ForEach(tv =>
{
var usedNugetVersions = nugets.Where(_n => _n.Name == n && _n.TargetFramework == tv).Select(_n => _n.Version).Distinct().ToList();
if (usedNugetVersions.Any())
{
table.Rows.Add(n, tv, string.Join(", ", usedNugetVersions));
}
});
if (opts.Verbose)
{
ConsoleTableBuilder.From(table).ExportAndWriteLine();
Console.WriteLine(Environment.NewLine);
}
});
}
protected void Table(string name, IEnumerable <object> rows)
{
if (rows.Any())
{
var type = rows.First().GetType();
var properties = type.GetProperties();
var dt = new DataTable();
foreach (var property in properties)
{
dt.Columns.Add(property.Name);
}
foreach (var row in rows)
{
dt.Rows.Add(properties.Select(p => Truncate(p.GetValue(row)?.ToString(), 75)).ToArray());
}
ConsoleTableBuilder
.From(dt)
.WithOptions(new ConsoleTableBuilderOption
{
Delimiter = " ",
TrimColumn = true
})
.WithFormat(ConsoleTableBuilderFormat.Minimal)
.ExportAndWriteLine();
}
else
{
Console.WriteLine($"{name} has no data");
}
}
public void Display(List <Product> products)
{
var tableData = new List <List <object> >();
foreach (var product in products)
{
var row = new List <object>
{
product.Id,
product.Brand,
product.Screen.Size, product.Screen.Type, product.Screen.Touch,
product.Cpu.Series, product.Cpu.Cores, product.Cpu.Clock,
product.Ram,
product.Disk.Capacity, product.Disk.Type,
product.GraphicCard.Type, product.GraphicCard.Vram,
product.OperatingSystem,
product.DriverType
};
tableData.Add(row);
}
ConsoleTableBuilder
.From(tableData)
.WithFormat(ConsoleTableBuilderFormat.Alternative)
.WithColumn("Id", "Producent", "Przekątna ekranu", "Typ matrycy", "Dotykowy ekran",
"Nazwa CPU", "Ilość rdzeni", "Prędkość taktowania(MHz)", "Pamięć RAM", "Pojemność dysku",
"Rodzaj dysku", "GPU", "Ilość VRAM", "Systemu operacyjny", "Napęd")
.ExportAndWriteLine(TableAligntment.Left);
}
/// <summary>
/// writes the sheet in tabular form to standard output
/// </summary>
/// <param name="sheet"> A google spreadsheet </param>
public static void ConsoleLogSheet(Sheet sheet)
{
if (sheet != null)
{
DataTable table = new DataTable();
// header
foreach (var item in sheet.Data[0].RowData[0].Values)
{
table.Columns.Add(item.FormattedValue, typeof(string));
}
var body = sheet.Data[0].RowData.Skip(1);
// rows
foreach (var rowData in body)
{
table.Rows.Add(rowData.Values.Select(r => r.FormattedValue).ToArray());
}
// print
ConsoleTableBuilder
.From(table)
.ExportAndWriteLine();
}
else
{
Console.WriteLine("No data found");
}
}
private static void PrintNugetUsageFor(List <Solution> solutions, CommandLineOption opts)
{
DataTable table = new DataTable();
table.Columns.Add("Solution", typeof(string));
table.Columns.Add("Nuget Name", typeof(string));
table.Columns.Add("Version", typeof(string));
table.Columns.Add("Target Framework", typeof(string));
if (!string.IsNullOrEmpty(opts.NugetOutputFile))
{
File.Delete(opts.NugetOutputFile);
}
solutions.ForEach(solution =>
{
solution.Nugets.ForEach(nuget =>
{
if (!string.IsNullOrEmpty(opts.NugetOutputFile))
{
File.AppendAllText(opts.NugetOutputFile, $"{solution.Name};{nuget.Name};{nuget.Version};{nuget.TargetFramework};{Environment.NewLine}");
}
table.Rows.Add(solution.Name, nuget.Name, nuget.Version, nuget.TargetFramework);
});
});
if (opts.Verbose)
{
ConsoleTableBuilder.From(table).ExportAndWriteLine();
}
}
private static void PrintFwkVersion(List <Solution> solutions, CommandLineOption opts)
{
List <IGrouping <string, Solution> > a = solutions.GroupBy(s => s.TargetFramework).ToList();
DataTable table = new DataTable();
table.Columns.Add("Framework", typeof(string));
table.Columns.Add("Projects", typeof(string));
if (!string.IsNullOrEmpty(opts.NetFwkOutputFile))
{
File.Delete(opts.NetFwkOutputFile);
}
a.ForEach((grouping) =>
{
grouping.ToList().ForEach(solution =>
{
if (!string.IsNullOrEmpty(opts.NetFwkOutputFile))
{
File.AppendAllText(opts.NetFwkOutputFile, $"{solution.Name};{solution.TargetFramework};{Environment.NewLine}");
}
table.Rows.Add(solution.TargetFramework, solution.Name);
});
});
if (opts.Verbose)
{
ConsoleTableBuilder.From(table).ExportAndWriteLine();
}
}
private void ReadEntries(string SheetName)
{
string range = $"{SheetName}!A:F";
SpreadsheetsResource.ValuesResource.GetRequest request = service.Spreadsheets.Values.Get(SpreadSheetID, range);
ValueRange response = request.Execute();
IList <IList <object> > values = response.Values;
if (values != null && values.Count > 0)
{
DataTable table = new DataTable(SheetName);
foreach (object rowheader in values[0])
{
table.Columns.Add(rowheader.ToString(), typeof(string));
}
foreach (IList <object> row in values.Skip(1))
{
table.Rows.Add(row.Cast <string>().ToArray());
}
ConsoleTableBuilder
.From(table)
.WithFormat(ConsoleTableBuilderFormat.MarkDown)
.ExportAndWriteLine();
}
else
{
Console.WriteLine("No data found.");
}
}
private string BuildTabularData(Answer answerResult)
{
var answerResponse = string.Empty;
var tablularHeaders = answerResult.Facts.Value[0].RichCaption.Header;
var tabularData = answerResult.Facts.Value[0].RichCaption.Rows;
var table = new DataTable();
foreach (var header in tablularHeaders)
{
if (string.IsNullOrWhiteSpace(header))
{
table.Columns.Add(" ");
}
else
{
table.Columns.Add(header);
}
}
foreach (var row in tabularData)
{
var cells = row.Cells.Select(r => r.Text).ToArray();
table.Rows.Add(cells);
}
var tableBuilder = ConsoleTableBuilder.From(table);
answerResponse = "```\n" + tableBuilder.Export().ToString() + "\n```";
return(answerResponse);
}
static void Main(string[] args)
{
///Specify the name of the database
string database = "db_" + DateTime.Now.ToString("yyyyMMddHHmmss");
var builder = new TaosConnectionStringBuilder()
{
DataSource = "http://td.gitclub.cn/rest/sql",
DataBase = database,
Username = "******",
Password = "******"
};
//Example for ADO.Net
using (var connection = new TaosConnection(builder.ConnectionString))
{
connection.Open();
Console.WriteLine("create {0} {1}", database, connection.CreateCommand($"create database {database};").ExecuteNonQuery());
Console.WriteLine("create table t {0} {1}", database, connection.CreateCommand($"create table {database}.t (ts timestamp, cdata int);").ExecuteNonQuery());
Console.WriteLine("insert into t values {0} ", connection.CreateCommand($"insert into {database}.t values ('{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ms")}', 10);").ExecuteNonQuery());
Console.WriteLine("insert into t values {0} ", connection.CreateCommand($"insert into {database}.t values ('{DateTime.Now.AddMonths(1).ToString("yyyy-MM-dd HH:mm:ss.ms")}', 20);").ExecuteNonQuery());
var cmd_select = connection.CreateCommand();
cmd_select.CommandText = $"select * from {database}.t";
var reader = cmd_select.ExecuteReader();
Console.WriteLine(cmd_select.CommandText);
Console.WriteLine("");
ConsoleTableBuilder.From(reader.ToDataTable()).WithFormat(ConsoleTableBuilderFormat.MarkDown).ExportAndWriteLine();
Console.WriteLine("");
Console.WriteLine("DROP TABLE {0} {1}", database, connection.CreateCommand($"DROP TABLE {database}.t;").ExecuteNonQuery());
Console.WriteLine("DROP DATABASE {0} {1}", database, connection.CreateCommand($"DROP DATABASE {database};").ExecuteNonQuery());
connection.Close();
}
//Example for Entity Framework Core
using (var context = new TaosContext(new DbContextOptionsBuilder()
.UseTaos(builder.ConnectionString).Options))
{
Console.WriteLine("EnsureCreated");
context.Database.EnsureCreated();
for (int i = 0; i < 10; i++)
{
var rd = new Random();
context.sensor.Add(new sensor()
{
ts = DateTime.Now.AddMilliseconds(i), degree = rd.NextDouble(), pm25 = rd.Next(0, 1000)
});
}
Console.WriteLine("Saveing");
context.SaveChanges();
Console.WriteLine("");
Console.WriteLine("from s in context.sensor where s.pm25 > 0 select s ");
Console.WriteLine("");
var f = from s in context.sensor where s.pm25 > 0 select s;
var ary = f.ToArray();
ConsoleTableBuilder.From(ary.ToList()).WithFormat(ConsoleTableBuilderFormat.MarkDown).ExportAndWriteLine();
context.Database.EnsureDeleted();
}
Console.WriteLine("");
Console.WriteLine("Pass any key to exit....");
Console.ReadKey();
}
public void ShowSearchResult(List <UserChat> data)
{
Console.WriteLine("Result:");
ConsoleTableBuilder.From(DataToDataTable(data))
.WithFormat(ConsoleTableBuilderFormat.Alternative)
.ExportAndWriteLine();
Console.ReadKey();
}
public static void ShowResults(List <SearchResult> results)
{
Console.WriteLine("Search results:");
ConsoleTableBuilder.From(GenerateDataTable(results))
.WithFormat(ConsoleTableBuilderFormat.Alternative)
.ExportAndWriteLine();
Console.ReadKey();
}
public void PrintTable(OfficerViewModel officerViewModel)
{
consoleWriter.WriteLine(string.Empty);
consoleWriter.WriteLine("Officer list in table format");
var tableBuilder = ConsoleTableBuilder.From(OfficerTableData(officerViewModel));
tableBuilder.ExportAndWriteLine();
}
public void Minimal()
{
StringBuilder b = ConsoleTableBuilder.From(dt).WithFormat(ConsoleTableBuilderFormat.Minimal).Export();
string[] strSplit = b.ToString().Split('\n');
Assert.AreEqual(7, strSplit.Length);
Assert.IsFalse(strSplit[0].Contains('-'));
Assert.AreEqual(new string('-', 90), strSplit[1].Trim());
}
