protected override async Task <Hades.AclService> GetAclServiceAsync()
{
var manager = new SqlServerManager(AppSettings.ConnectionString);
await manager.CreateDatabaseSchemaAsync();
return(new Hades.AclService(manager));
}
public override void SetUp()
{
base.SetUp();
person = new Person
{
FirstName = "Paymon",
LastName = "Khamooshi"
};
#region Create database for Person entity
var server = new SqlServerManager();
if (server.Exists(TempDatabaseName, DatabaseFilesPath.FullName))
{
return;
}
server.ClearConnectionPool();
server.Delete(TempDatabaseName);
foreach (var file in GetExecutableCreateDbScripts(TempDatabaseName))
{
try { server.Execute(file.Value, TempDatabaseName); }
catch (Exception ex)
{ throw new Exception("Could not execute sql file '" + file.Key.FullName + "'", ex); }
}
server.ClearConnectionPool();
#endregion
}
public void DescriptionName()
{
SqlServerManager manager = SqlServerManager.Instance;
string name = ((IManager)manager).Description.Name;
Assert.IsNotNull(name);
Assert.IsTrue(!string.IsNullOrEmpty(name));
}
public void DescriptionImageMimeType()
{
SqlServerManager manager = SqlServerManager.Instance;
string mineType = ((IManager)manager).Description.ImageMimeType;
Assert.IsNotNull(mineType);
Assert.IsTrue(!string.IsNullOrEmpty(mineType));
}
public void DescriptionImage()
{
SqlServerManager manager = SqlServerManager.Instance;
string image = ((IManager)manager).Description.Image;
Assert.IsNotNull(image);
Assert.IsTrue(!string.IsNullOrEmpty(image));
}
internal static void FieldTypeEquals(FieldType type, string connectionString, string databaseName, string tableName, string fieldName)
{
var sql = "SELECT DATA_TYPE FROM [" + databaseName + "].INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @tableName AND COLUMN_NAME = @fieldName";
var actual = ExecuteScalar(connectionString, sql, new SqlParameter("tableName", tableName), new SqlParameter("fieldName", fieldName)).ToString();
var actualType = SqlServerManager.GetFieldType(actual);
if (type != actualType)
{
throw new Exception("Field '" + fieldName + "' in table '" + tableName + "' is not a " + type + ", its " + actual + " (" + actualType + ")");
}
}
protected override async Task <IAclManager> GetManagerAsync()
{
var manager = new SqlServerManager(AppSettings.ConnectionString);
if (!_isSchemaCreated)
{
await manager.CreateDatabaseSchemaAsync();
_isSchemaCreated = true;
}
return(manager);
}
public static IEntityMetaServiceContainer CreateLoggingDomEntityMetaServiceContainer(string connectionString) => new EntityMetaServiceContainer(
new LoggingDomDbContext("x", null),
(exception, entityType, ormEntitySchemaAdapter, genericErrorField) => StorageResultBuilder.AnalyzeExceptionRecursive(
exception, entityType, ormEntitySchemaAdapter, genericErrorField,
(ex, storageResultBuilder) =>
{
LoggingDomDataAccessEfCoreManager.Analyze(ex, storageResultBuilder);
// TODO disable for InMemory
SqlServerManager.Analyze(ex, storageResultBuilder);
}
)
//(entityType) => new SqlServerOrmEntitySchemaAdapter( entityType),
//(modelBuilder) => LoggingDomDbContext.BuildModel(modelBuilder)
);
public bool Process()
{
if (ConnectionString.IsEmpty())
{
Debug.WriteLine("Temp databae creation aborted. There is no connection string.");
return(false);
}
var builder = new SqlConnectionStringBuilder(ConnectionString);
TempDatabaseName = builder.InitialCatalog.Or("").TrimStart("[").TrimEnd("]");
if (TempDatabaseName.IsEmpty())
{
Debug.WriteLine("Temp databae creation aborted. No database name was found in the connection string.");
return(false);
}
else if (!TempDatabaseName.ToLower().EndsWith(".temp") && IsTempDatabaseOptional)
{
Debug.WriteLine($"Temp databae creation aborted. Database name '{TempDatabaseName}' does not end in '.Temp'.");
// Optional and irrelevant
return(false);
}
EnsurePermissions();
builder.InitialCatalog = "master";
MasterDatabaseAgent = new SqlServerManager(builder.ToString());
ProjectTempRoot = DatabaseStoragePath.GetOrCreateSubDirectory(TempDatabaseName);
LoadMetaDirectory();
if (!IsTempDatabaseOptional)
{
if (!IsExplicitlyTempDatabase())
{
throw new Exception("For unit tests project the database name must end in '.Temp'.");
}
}
if (!IsExplicitlyTempDatabase())
{
// Not Temp mode:
return(false);
}
return(DoProcess());
}
public async Task CreateSqlServer()
{
using var numberGen = RandomNumberGenerator.Create();
var bytes = new byte[64];
numberGen.GetBytes(bytes);
var secretString = Convert.ToBase64String(bytes);
var user = secretString.Substring(0, secretString.Length / 2);
var pass = secretString.Substring(secretString.Length / 2) + "!2Ab"; //Last bit ensures complexity
var manager = new SqlServerManager(mockup.Get <IShellRunner>());
await manager.Create(TestSqlServer, TestRg, TestRegion, user, pass);
}
public bool Process()
{
if (ConnectionString.IsEmpty())
{
return(false);
}
var builder = new SqlConnectionStringBuilder(ConnectionString);
TempDatabaseName = builder.InitialCatalog.Or("").TrimStart("[").TrimEnd("]");
if (TempDatabaseName.IsEmpty())
{
// None of my business.
return(false);
}
else if (!TempDatabaseName.ToLower().EndsWith(".temp") && IsTempDatabaseOptional)
{
// Optional and irrelevant
return(false);
}
EnsurePermissions();
builder.InitialCatalog = "master";
MasterDatabaseAgent = new SqlServerManager(builder.ToString());
LoadTempDatabaseLocation();
LoadMetaDirectory();
if (!IsTempDatabaseOptional)
{
if (!IsExplicitlyTempDatabase())
{
throw new Exception("For unit tests project the database name must end in '.Temp'.");
}
}
if (!IsExplicitlyTempDatabase())
{
// Not Temp mode:
return(false);
}
return(DoProcess());
}
public ConnectionForm(SqlServerManager tableManager)
{
try
{
InitializeComponent();
Text = "DataSeeker";
this.tableManager = tableManager;
TopMost = true;
sql.ConnectionString = Settings.Default.ConnectionString;
propertyGrid.SelectedObject = sql;
}
catch
{
sql.ConnectionString = null;
propertyGrid.SelectedObject = sql;
}
}
private static async Task <Tuple <ProxyError, bool> > TransmitOneError(ProxyError error)
{
if (ErrorHandlingOption.EnableNetworkSending) // Server Connector to online or offline ?
{
try
{
await SqlServerManager.InsertErrorAsync(error);
}
catch (AggregateException exp)
{
// If an unhandled exception occurs during dataflow processing, all
// exceptions are propagated through an AggregateException object.
ErrorHandlingOption.EnableNetworkSending = false;
exp.Handle(e =>
{
ErrorHandlingOption.AtSentState = false;
return(true);
});
}
}
// Mark the head of the pipeline as complete. The continuation tasks
// propagate completion through the pipeline as each part of the
// pipeline finishes.
else
{
ErrorListenerTransformBlock.Complete();
ErrorHandlingOption.AtSentState = false;
}
if (ErrorListenerTransformBlock.InputCount == 0)
{
ErrorHandlingOption.AtSentState = false;
}
//
// Post to Acknowledge Action Block:
return(new Tuple <ProxyError, bool>(error, ErrorHandlingOption.EnableNetworkSending));
}
private static async Task ServerValidatorAsync()
{
var cm = ConnectionManager.GetDefaultConnection(); // fetch default connection
if (await cm.IsServerOnlineAsync()) // Is server on ?
{
await SqlServerManager.CreateDatabaseAsync(); // Check or Create Raw Database
if (await cm.CheckDbConnectionAsync()) // Is database exist on server ?
{
await SqlServerManager.CreateTablesAndStoredProceduresAsync(); // Check or create Tables and StoredProcedures
}
else // database is not exist !!!
{
ErrorHandlingOption.EnableNetworkSending = false;
new DataException("Database is not exist or corrupted").RaiseLog();
}
}
else // server is off !!
{
ErrorHandlingOption.EnableNetworkSending = false;
new ServerException("Server is not online!").RaiseLog();
}
}
//public static bool FindSqlException(AggregateException aggregateException, out SqlException sqlException)
//{
// sqlException = null;
// foreach (var ex in aggregateException.InnerExceptions)
// {
// if (ex is SqlException)
// {
// sqlException = (SqlException)ex;
// return true;
// }
// }
// return false;
//}
void Prepare()
{
var exceptionHandler = this.HttpContext.Features.Get <IExceptionHandlerFeature>();
var aspRoutineFeature = this.HttpContext.Features.Get <AspRoutineFeature>();
var pageRoutineFeature = this.HttpContext.Features.Get <PageRoutineFeature>();
// TODO: create url tree (where to go on error) and url to title (button name) map
if (pageRoutineFeature != null)
{
ReturnUrl = pageRoutineFeature.Referrer;
}
var unhandledException = exceptionHandler?.Error;
string detailsMarkdown = default;
var isHandledByDocument = aspRoutineFeature != null && aspRoutineFeature.TraceDocument.IsExceptionHandled;
if (unhandledException != null && !isHandledByDocument)
{
detailsMarkdown = InjectedManager.Markdown(unhandledException);
var correlationTokenRequest = this.HttpContext.Request.Headers["X-CorrelationToken"].FirstOrDefault();
Guid.TryParse(correlationTokenRequest, out var correlationToken);
applicationSettings.UnhandledExceptionLogger.TraceError(correlationToken, detailsMarkdown);
}
RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
//SqlException sqlException = null;
var remoteServerErrorType = SqlServerManager.QuickAnalyze(unhandledException);
if (remoteServerErrorType == RemoteServerErrorType.DOWN)
{
Message = "Adminka is currently down for maintenance. Back soon.";
Title = "Maintenance";
}
else if (remoteServerErrorType == RemoteServerErrorType.OVERLOADED)
{
Message = "Adminka is a bit overloaded right now... We are sorry asking you try again later";
Title = "Maintenance";
}
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (environment == "Development" || applicationSettings.ForceDetailsOnCustomErrorPage)
{
ShowAdvancedInformation = true;
}
else
{
var isAdminPrivilege = User.Claims.Any(c => c.Type == "PRIVILEGE" && c.Value == "ADMIN");
if (isAdminPrivilege)
{
ShowAdvancedInformation = true;
}
}
if (ShowAdvancedInformation)
{
if (isHandledByDocument)
{
var text = aspRoutineFeature.TraceDocument.Build();
ExceptionHtml = InjectedManager.ToHtml(text);
}
else if (unhandledException != null && detailsMarkdown != null)
{
ExceptionHtml = InjectedManager.ToHtmlException(detailsMarkdown);
}
if (aspRoutineFeature != null)
{
CorrelationToken = aspRoutineFeature.CorrelationToken.ToString();
}
}
}
public async Task RemoveServerFirewallRule()
{
var manager = new SqlServerManager(mockup.Get <IShellRunner>());
await manager.RemoveFirewallRule(TestFirewallRule, TestSqlServer, TestRg);
}
public async Task SetServerFirewallRule()
{
var manager = new SqlServerManager(mockup.Get <IShellRunner>());
await manager.SetFirewallRule(TestFirewallRule, TestSqlServer, TestRg, Ip, Ip);
}
public void ManagerClose()
{
SqlServerManager manager = SqlServerManager.Instance;
((IManager)manager).Close();
}
public void DescriptionPriority()
{
SqlServerManager manager = SqlServerManager.Instance;
Assert.IsNotNull(((IManager)manager).Description.Priority);
}
public void DescriptionImageData()
{
SqlServerManager manager = SqlServerManager.Instance;
Assert.IsNotNull(((IManager)manager).Description.ImageData);
}
public void Constructor()
{
SqlServerManager manager = SqlServerManager.Instance;
}
