public override Dataset ReadTableData(string command, FormatterManager formatter)
{
using var connection = CreateDbConnection(ConnectionString);
connection.Open();
using var sqlCommand = CreateDbCommand(command, connection);
using var reader = sqlCommand.ExecuteReader(CommandBehavior.KeyInfo);
var tableName = reader.GetSchemaTable().Rows[0]["BaseTableName"].ToString();
var dataset = new Dataset();
var rows = new List <Row>();
while (reader.Read())
{
var columns = new List <Column>();
for (var i = 0; i < reader.VisibleFieldCount; i++)
{
var column = new Column(reader.GetName(i), formatter.Format(tableName ?? "", reader.GetName(i), reader[i]));
columns.Add(column);
}
var row = new Row {
Columns = columns
};
rows.Add(row);
}
dataset.Rows = rows;
return(dataset);
}
public override DatasetElement ReadTable(string command, FormatterManager formatter)
{
DatasetElement result = new DatasetElement();
result.Data = new XElement("data");
using (var conn = CreateDbConnection(ConnectionString))
{
conn.Open();
using (var comm = CreateDbCommand(command, conn))
{
var reader = comm.ExecuteReader(CommandBehavior.KeyInfo);
var tableSchema = reader.GetSchemaTable();
result.Table = tableSchema.TableName;
while (reader.Read())
{
XElement xmlRow = new XElement("row");
result.Data.Add(xmlRow);
for (int i = 0; i < reader.FieldCount; i++)
{
var columnName = reader.GetName(i);
var value = formatter.Format(tableSchema.TableName, columnName, reader[i]);
var attribute = new XAttribute(columnName, value);
xmlRow.Add(attribute);
}
}
}
}
return(result);
}
public void Connection_is_not_reused()
{
// This test uses a global temp table (GTT) since a GTT is deleted when the connection that created it goes out of scope.
var target = new SqlDatabaseClient(false)
{
ConnectionString = _connectionString
};
target.ExecuteCommand(_createGlobalTempTableCommand);
var formatterManager = new FormatterManager();
var actual = target.ReadTable(_verifyIfTempTableExistsQuery, formatterManager);
var expectedDatasetXml = @"
<dataset name=""a-name"" table=""a-name"">
<data>
<row TempTableExists=""0"" />
</data>
</dataset>
";
var xml = XElement.Parse(expectedDatasetXml);
var expectedDataset = DatasetElement.Load(xml);
Assert.AreEqual(expectedDataset.Data.ToString(), actual.Data.ToString());
}
public void WriteReport(Server server, FormatterManager formatterManager)
{
formatterManager.InitializeSection(".NET");
foreach (var site in server.Sites)
{
foreach (var directory in site.VirtualDirectories)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Site Name", site.Name);
formatterManager.WriteValue("Path", directory.Path);
formatterManager.WriteValue("Site Name", site.Name);
formatterManager.WriteValue("Path", directory.Path);
formatterManager.WriteValue("Physical Path", directory.PhysicalPath);
formatterManager.WriteValue("Authentication Mode", directory.AuthenticationMode);
formatterManager.WriteValue("Target .NET Framework", directory.TargetDotNetFramework);
formatterManager.WriteValue("Debug Enabled", directory.DebugEnabled.ToString());
formatterManager.WriteValue("Reveals Stock Error Pages", directory.RevealsStockErrorPages.ToString());
formatterManager.WriteValue("Reveals Error Urls", directory.RevealsErrorUrls.ToString());
formatterManager.WriteValue("Reveals ASP.NET Version Header", directory.RevealsAspNetVersionHeader.ToString());
formatterManager.WriteValue("Request Validation Disabled", directory.RequestValidationDisabled.ToString());
formatterManager.WriteValue("JavaScript Can Access Cookies", directory.JavaScriptCanAccessCookies.ToString());
formatterManager.WriteValue("Insecure Cookies Allowed", directory.InsecureCookiesAllowed.ToString());
formatterManager.WriteValue("Cookieless Sessions Allowed", directory.CookielessSessionsAllowed.ToString());
formatterManager.WriteValue("Trace Publicly Enabled", directory.TracePubliclyEnabled.ToString());
}
}
}
private static IServiceCollection AddFormatterManager(this IServiceCollection services)
{
IFormatterManager formatterManager = new FormatterManager();
formatterManager.RegisterFormatter("json", new JsonReportFormatter());
formatterManager.RegisterFormatter("xml", new XmlReportFormatter());
return(services.AddSingleton(formatterManager));
}
public void Format_WhenNoFormattersAreRegistered_ReturnValueAsString()
{
formatterManager = new FormatterManager();
var actual = formatterManager.Format("TableB", "ColumnA", 5);
actual.Should().Be("5", "because there aren't any formatters registered");
}
public void Format_When_there_are_zero_registered_formatters_Format_must_return_value_to_string()
{
_target = new FormatterManager();
var actual = _target.Format("TableB", "ColumnA", 5);
Assert.AreEqual("5", actual);
}
public IFormatter Create(Type type)
{
Type underlyingType = type.GetEnumUnderlyingType();
IFormatter underlyingFormatter = FormatterManager.GetFormatterAsync(underlyingType, false).Result;
Context context = new Context(type, underlyingFormatter, underlyingType);
return(context.BuildFormatter());
}
public void WriteReport(Server server, FormatterManager formatterManager)
{
formatterManager.InitializeSection("Summary");
formatterManager.InitializeRecord();
formatterManager.WriteValue("Server Name", server.Name);
formatterManager.WriteValue("# of App Pools", server.AppPools.Count.ToString());
formatterManager.WriteValue("# of Sites", server.Sites.Count.ToString());
formatterManager.WriteValue("# of Bindings with HTTPS", server.Sites.Select(site => site.Bindings.Count(binding => binding.Protocol.ToLower() == "https")).Sum().ToString());
}
public FormatterManagerTest()
{
formatterManager = new FormatterManager();
formatterManager.Register(typeof(DateTime), value => "registered-for-date-time");
formatterManager.Register("TableA", "ColumnA", value => "registered-for-TableA-ColumnA");
formatterManager.Register("TableA", "ColumnB", value => "registered-for-TableA-ColumnB");
formatterManager.Register("TableB", "ColumnA", value => "registered-for-TableB-ColumnA");
formatterManager.Register("ColumnA", value => "registered-for-ColumnA");
}
public void Initialize()
{
_target = new FormatterManager();
_target.Register(typeof(DateTime), value => "registered-for-date-time");
_target.Register("TableA", "ColumnA", value => "registered-for-TableA-ColumnA");
_target.Register("TableA", "ColumnB", value => "registered-for-TableA-ColumnB");
_target.Register("TableB", "ColumnA", value => "registered-for-TableB-ColumnA");
_target.Register("ColumnA", value => "registered-for-ColumnA");
}
public void GetFormatterTest(IDictionary <string, IReportFormatter> formatterStorage, string formatterName, IReportFormatter expected)
{
// Arrange
var manager = new FormatterManager(formatterStorage);
// Act
IReportFormatter formatter = manager.GetFormatter(formatterName);
// Assert
Assert.That(formatter, Is.EqualTo(expected));
}
public void GetFormatterTest_ThrowsException(string formatterName)
{
// Arrange
var manager = new FormatterManager();
// Act
IReportFormatter TestAction() => manager.GetFormatter(formatterName);
// Assert
Assert.That(TestAction, Throws.TypeOf <FormatterNotFoundException>());
}
public AowSerializer(bool hasRootWrapper, bool forceClassID)
{
_isAbstract = typeof(T).IsAbstract || forceClassID;
_hasRootWrapper = hasRootWrapper;
_formatter = FormatterManager.GetFormatter <T>(isPolymorph: _isAbstract);
if (_hasRootWrapper)
{
_formatter = new WrappingFormatterProxy(_formatter);
}
}
public void RegisterFormatterTest_ThrowsException(IDictionary <string, IReportFormatter> storage,
string name,
IReportFormatter formatter,
Type expectedException)
{
// Arrange
var manager = new FormatterManager(storage);
// Act
void TestAction() => manager.RegisterFormatter(name, formatter);
// Assert
Assert.That(TestAction, Throws.TypeOf(expectedException));
}
public void WriteReport(Server server, FormatterManager formatterManager)
{
formatterManager.InitializeSection("Application Pools");
foreach (var appPool in server.AppPools)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Name", appPool.Name);
formatterManager.WriteValue("Current State", appPool.CurrentState);
formatterManager.WriteValue("Runtime Version", appPool.RuntimeVersion);
formatterManager.WriteValue("Pipeline Mode", appPool.PipelineMode);
formatterManager.WriteValue("Auto Start", appPool.AutoStart.ToString());
formatterManager.WriteValue("Username", appPool.UserName);
formatterManager.WriteValue("Identity Type", appPool.IdentityType);
}
}
private void CreateItemFormatter()
{
Task <IFormatter> itemFormatter = FormatterManager.GetFormatterAsync(ItemType, isPolymorph: true);
Type formatterType = typeof(Task <IFormatter>);
string fieldName = "ItemFormatter";
TypeBuilder helperBuilder = GeneratedAssembly.CreateType(Type.Name + "FormatterHelper");
FieldBuilder cachedFormatterField = helperBuilder.DefineField(fieldName, formatterType, FieldAttributes.Static | FieldAttributes.Public);
Type helperType = helperBuilder.CreateType();
FieldInfo realFieldInfo = helperType.GetField(fieldName);
realFieldInfo.SetValue(null, itemFormatter);
_itemFormatterField = realFieldInfo;
_itemFormatterType = typeof(Formatter <>).MakeGenericType(ItemType);
}
public void WriteReport(Server server, FormatterManager formatterManager)
{
formatterManager.InitializeSection("Databases");
foreach (var site in server.Sites)
{
foreach (var directory in site.VirtualDirectories)
{
foreach (var database in directory.Databases)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Site Name", site.Name);
formatterManager.WriteValue("Path", directory.Path);
formatterManager.WriteValue("Connection Name", database.ConnectionName);
formatterManager.WriteValue("Provider", database.Provider);
formatterManager.WriteValue("Connection String", database.ConnectionString);
}
}
}
}
public void WriteReport(Server server, FormatterManager formatterManager)
{
formatterManager.InitializeSection("Sites");
foreach (var site in server.Sites)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Name", site.Name);
formatterManager.WriteValue("Current State", site.CurrentState);
formatterManager.WriteValue("Auto Start", site.AutoStart.ToString());
formatterManager.WriteValue("# of Bindings", site.Bindings.Count.ToString());
formatterManager.WriteValue("# of Virtual Directories", site.VirtualDirectories.Count.ToString());
}
formatterManager.InitializeSection("Bindings");
foreach (var site in server.Sites)
{
foreach (var binding in site.Bindings)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Site Name", site.Name);
formatterManager.WriteValue("Protocol", binding.Protocol);
formatterManager.WriteValue("IP Address", binding.IpAddress);
formatterManager.WriteValue("Port", binding.Port);
formatterManager.WriteValue("Host Name", binding.HostName);
formatterManager.WriteValue("Certificate Name", binding.CertificateName);
}
}
formatterManager.InitializeSection("Virtual Directories");
foreach (var site in server.Sites)
{
foreach (var directory in site.VirtualDirectories)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Site Name", site.Name);
formatterManager.WriteValue("Path", directory.Path);
formatterManager.WriteValue("Physical Path", directory.PhysicalPath);
formatterManager.WriteValue("Application Pool", directory.AppPool);
formatterManager.WriteValue("Application Path", directory.AppPath);
}
}
}
public void WriteReport(Server server, FormatterManager formatterManager)
{
formatterManager.InitializeSection("JavaScript");
foreach (var site in server.Sites)
{
foreach (var directory in site.VirtualDirectories)
{
formatterManager.InitializeRecord();
formatterManager.WriteValue("Site Name", site.Name);
formatterManager.WriteValue("Path", directory.Path);
formatterManager.WriteValue("May Use Angular.js 1.x", directory.FoundAngular1.ToString());
formatterManager.WriteValue("May Use React.js", directory.FoundReact.ToString());
formatterManager.WriteValue("May Use Backbone.js", directory.FoundBackbone.ToString());
formatterManager.WriteValue("May Use Ember.js", directory.FoundEmber.ToString());
formatterManager.WriteValue("May Use Knockout.js", directory.FoundKnockout.ToString());
formatterManager.WriteValue("May Use jQuery", directory.FoundjQuery.ToString());
formatterManager.WriteValue("May Use Underscore/Lodash", directory.FoundUnderscoreOrLodash.ToString());
formatterManager.WriteValue("May Use Bootstrap CSS", directory.FoundBootstrap.ToString());
}
}
}
/// <summary>
///
/// </summary>
public AppHost(RpcConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
Config = config;
AppId = config.AppId;
Registry = RegistryHelper.GetRegistry(this, config);
ServiceHost = new ServiceHost(this, config);
FormatterManager = new FormatterManager(config);
ClientFactory = new RpcClientFactory(this, config);
if (!string.IsNullOrWhiteSpace(config.Monitor?.Type))
{
var monitorFactory = ReflectHelper.CreateInstanceByIdentifier <IMonitorFactory>(config.Monitor.Type);
Monitor = monitorFactory.CreateMonitor(this, config);
}
if (config.Filter?.Filters.Count > 0)
{
foreach (var item in config.Filter.Filters)
{
var factory = ReflectHelper.CreateInstanceByIdentifier <IFilterFactory>(item.Type);
var filters = factory.CreateFilters();
if (filters == null)
{
continue;
}
foreach (var filter in filters)
{
AddFilter(filter);
}
}
}
}
static void Main(string[] args)
{
var iisInvestigator = new IisInvestigator();
var server = iisInvestigator.Run();
var formatters = new List <IFormatter>();
//todo: use args to signal which formatters to use, custom file names, which reporters to use, etc
formatters.Add(new ConsoleFormatter());
var machineName = string.Join("_", Environment.MachineName.Split(Path.GetInvalidFileNameChars(), StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.');
var timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
formatters.Add(new SpreadsheetFormatter(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), $"{machineName}_forensic-report_{timestamp}.xlsx"));
var formatterManager = new FormatterManager(formatters.ToArray());
var reporters = new IReporter[]
{
new SummaryReporter(),
new AppPoolReporter(),
new SiteReporter(),
new DotNetReporter(),
new DatabaseReporter(),
new JavaScriptReporter()
};
foreach (var reporter in reporters)
{
reporter.WriteReport(server, formatterManager);
}
formatterManager.End();
Console.ReadLine();
}
public void Write_read_and_compare_records()
{
var target = new SqlDatabaseClient(false)
{
ConnectionString = _connectionString
};
var deleteDataCommand = @"
DELETE [dbo].[Product];
DELETE [dbo].[Category];
DELETE [dbo].[Supplier];
";
target.ExecuteCommand(deleteDataCommand);
var datasetXml = @"
<dataset name=""suppliers"" setIdentityInsert=""true"" table=""Supplier"">
<data>
<row Id=""1"" Name=""supplier-1"" ContactName=""contact-name-1"" ContactPhone=""100-200-0001"" ContactEmail=""*****@*****.**"" />
<row Id=""2"" Name=""supplier-2"" ContactName=""contact-name-2"" ContactPhone=""100-200-0002"" ContactEmail=""*****@*****.**"" />
<row Id=""3"" Name=""supplier-3"" ContactName=""contact-name-3"" ContactPhone=""100-200-0003"" ContactEmail=""*****@*****.**"" />
</data>
</dataset>
";
var xml = XElement.Parse(datasetXml);
var dataset = DatasetElement.Load(xml);
target.WriteTable(dataset);
var formatterManager = new FormatterManager();
var selectRecordsQuery = "SELECT * FROM [dbo].[Supplier];";
var actual = target.ReadTable(selectRecordsQuery, formatterManager);
DbSafeManagerHelper.CompareDatasets(dataset, actual, new string[] { "Id" }, false, false);
}
private void CreateSubFormatterFields()
{
_subFormatters = new Dictionary <FieldBase, FieldInfo>();
TypeBuilder helperBuilder = GeneratedAssembly.CreateType(_type.Name + "FormatterHelper");
Dictionary <string, Task <IFormatter> > values = new Dictionary <string, Task <IFormatter> >();
Dictionary <string, FieldBase> fieldMap = new Dictionary <string, FieldBase>();
foreach (FieldBase field in _fields)
{
Task <IFormatter> formatterTask = FormatterManager.GetFormatterAsync(field.Type, field.Type.IsAbstract);
Type fieldType = typeof(Task <IFormatter>);
string fieldName = String.Format("_0x{0}_formatter", field.ID.ToString("x2"));
FieldBuilder cachedFormatterField = helperBuilder.DefineField(fieldName, fieldType, FieldAttributes.Static | FieldAttributes.Public);
values.Add(cachedFormatterField.Name, formatterTask);
fieldMap.Add(cachedFormatterField.Name, field);
}
FieldBuilder keyListFieldBuilder = helperBuilder.DefineField("_fieldIDs", typeof(List <int>), FieldAttributes.Static | FieldAttributes.Public);
Type helperType = helperBuilder.CreateType();
foreach (KeyValuePair <string, Task <IFormatter> > pair in values)
{
FieldInfo realFieldInfo = helperType.GetField(pair.Key);
realFieldInfo.SetValue(null, pair.Value);
_subFormatters.Add(fieldMap[pair.Key], realFieldInfo);
}
_keyListField = helperType.GetField(keyListFieldBuilder.Name);
List <int> keys = _fields.Select(f => f.ID).ToList();
_keyListField.SetValue(null, keys);
}
public void Write_read_and_compare_records()
{
var datasetXml = @"
<dataset name=""suppliers"" setIdentityInsert=""true"" table=""Supplier"">
<data>
<row id=""1"" name=""supplier-1"" contact_name=""contact-name-1"" contact_phone=""100-200-0001"" contact_email=""*****@*****.**"" />
<row id=""2"" name=""supplier-2"" contact_name=""contact-name-2"" contact_phone=""100-200-0002"" contact_email=""*****@*****.**"" />
<row id=""3"" name=""supplier-3"" contact_name=""contact-name-3"" contact_phone=""100-200-0003"" contact_email=""*****@*****.**"" />
</data>
</dataset>
";
var xml = XElement.Parse(datasetXml);
var dataset = DatasetElement.Load(xml);
_target.WriteTable(dataset);
var formatterManager = new FormatterManager();
var selectRecordsQuery = "SELECT * FROM public.supplier;";
var actual = _target.ReadTable(selectRecordsQuery, formatterManager);
DbSafeManagerHelper.CompareDatasets(dataset, actual, new string[] { "id" }, false, false);
}
public void Write_Read_And_Compare_Results()
{
var client = new SqlDatabaseClient(false)
{
ConnectionString = connectionString
};
var deleteCmd = @"
DELETE FROM public.product;
DELETE FROM public.category;
DELETE FROM public.supplier;
";
client.ExecuteCommand(deleteCmd);
var expectedDatasetJson = @"
{
""name"": ""suppliers"",
""table"": ""Supplier"",
""rows"": [
{
""columns"": [
{
""name"": ""id"",
""value"": ""1""
},
{
""name"": ""name"",
""value"": ""supplier-1""
},
{
""name"": ""contact_name"",
""value"": ""contact-name-1""
},
{
""name"": ""contact_phone"",
""value"": ""100-200-0001""
},
{
""name"": ""contact_email"",
""value"": ""*****@*****.**""
}
]
},
{
""columns"": [
{
""name"": ""id"",
""value"": ""2""
},
{
""name"": ""name"",
""value"": ""supplier-2""
},
{
""name"": ""contact_name"",
""value"": ""contact-name-2""
},
{
""name"": ""contact_phone"",
""value"": ""100-200-0002""
},
{
""name"": ""contact_email"",
""value"": ""*****@*****.**""
}
]
},
{
""columns"": [
{
""name"": ""id"",
""value"": ""3""
},
{
""name"": ""name"",
""value"": ""supplier-3""
},
{
""name"": ""contact_name"",
""value"": ""contact-name-3""
},
{
""name"": ""contact_phone"",
""value"": ""100-200-0003""
},
{
""name"": ""contact_email"",
""value"": ""*****@*****.**""
}
]
}
]
}
";
var jsonDoc = JsonDocument.Parse(expectedDatasetJson);
var expectedDataset = Dataset.Parse(jsonDoc.RootElement);
client.InsertTableData(expectedDataset);
var formatterManager = new FormatterManager();
var selectQuery = "SELECT * FROM public.supplier;";
var actualDataset = client.ReadTableData(selectQuery, formatterManager);
expectedDataset.Rows.Should().BeEquivalentTo(actualDataset.Rows);
}
public static Object.Collections.DataCollection BuildDataCollection(string connectionString, string tableName, IEnumerable <string> fields, IEnumerable <FieldFilter> filters, FormatterManager formatter)
{
var rows = new List <Object.Collections.DataRow>();
var command = $"SELECT {string.Join(",", fields)} FROM {tableName}";
if (filters != null && filters.Any())
{
filters = SpecflowDbValidatorHelper.AddQuotationMarks(filters);
var filtering = new List <string>();
foreach (var filter in filters)
{
filtering.Add($"{filter.FieldName} IN ({filter.FieldValues})");
}
command = $"{command}{Environment.NewLine}{"WHERE"} {string.Join(" AND ", filtering)}";
}
using (var conn = CreateDbConnection(connectionString))
{
using (var comm = CreateDbCommand(command, conn))
{
conn.Open();
var reader = comm.ExecuteReader(CommandBehavior.KeyInfo);
while (reader.Read())
{
var dataRow = new Object.Collections.DataRow();
rows.Add(dataRow);
var dataCells = new List <Object.Collections.DataCell>();
for (int i = 0; i < reader.FieldCount; i++)
{
var columnName = reader.GetName(i);
var dbValue = reader[i];
var value = dbValue.GetType() == typeof(DBNull) ? null : formatter.Format(tableName, columnName, dbValue);
var cell = new KeyValuePair <string, string>(columnName, value);
var dataCell = Object.Collections.DataCell.Load(cell);
dataCells.Add(dataCell);
}
dataRow.Values = dataCells.ToArray();
}
}
}
return(new Object.Collections.DataCollection
{
Rows = rows.ToArray(),
});
}
public SqlSteps(string connectionString, FormatterManager formatter = null)
: base(
BuildPopulator(connectionString),
BuildValidator(connectionString, formatter))
{
}
private static SpecflowDbValidator <SqlConnection, SqlCommand> BuildValidator(string connectionString, FormatterManager formatter)
{
return(new SpecflowDbValidator <SqlConnection, SqlCommand>(new SqlSpecflowDbSchema(connectionString), formatter));
}
static DatabaseTestSteps()
{
_formatter = new FormatterManager();
// Adding formatters if needed.
// _formatter.Register(typeof(decimal), new DecimalFormatter("0.00"));
}
