public void CancelCommand_Executed_DatabaseConnection()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var closeRequested = false;
bool?dialogResult = null;
var vsa = Mock.Of <IVisualStudioAccess>();
var psdFactory = Mock.Of <Func <IPickSchemasDialog> >();
var vm = new PickServerDatabaseViewModel(vsa, psdFactory)
{
SelectedDatabaseConnection = dbConnection
};
vm.CloseRequested += (sender, args) =>
{
closeRequested = true;
dialogResult = args.DialogResult;
};
// Act
vm.CancelCommand.Execute(null);
// Assert
Assert.IsTrue(closeRequested);
Assert.IsFalse(dialogResult);
Assert.IsNull(vm.SelectedDatabaseConnection);
Assert.IsNull(vm.SelectedDatabaseDefinition);
}
public DeploymentConnectionViewModel(ProjectModel project, string key, DatabaseConnectionModel connection) : base(key, null)
{
Key = key;
ComboConnections = new Connections.ConnectionComboViewModel(project);
ComboConnections.LoadConnections <DatabaseConnectionModel>();
ComboConnections.SelectConnection(connection);
}
private IEnumerable <LabelEntity> MarkLabelsAsProcessedAndGetMissing(DatabaseConnectionModel connectionModel1,
DatabaseConnectionModel connectionModel2,
LabelsGeneratorDbTables tables,
DateTime date)
{
using (var context1 = _contextFactory.GetContext(connectionModel1, tables))
using (var context2 = _contextFactory.GetContext(connectionModel2, tables))
{
var reportId = Guid.NewGuid();
var startDate = date.StartOfDay();
var endDate = date.EndOfDayForDatabase();
var labels = context1.Set <LabelEntity>().Where(x => x.Status == 0 && x.CreateDate >= startDate && x.CreateDate <= endDate).ToArray();
var labelIdentifiers = labels.Select(x => x.UniqueID.Trim()).ToArray();
var identifiers = context2.Set <CustomerEntity>().Where(x => labelIdentifiers.Contains(x.UniqueID.Trim())).Select(x => x.UniqueID.Trim()).ToArray();
var foundLabels = labels.Where(x => identifiers.Contains(x.UniqueID.Trim())).ToArray();
foreach (var label in foundLabels)
{
label.Status = 1;
}
context1.SaveChanges();
var notFoundLabels = labels.Where(x => !identifiers.Contains(x.UniqueID.Trim())).ToArray();
return(notFoundLabels);
}
}
private DatabaseConnectionModel GetDatabaseInfo(ReverseEngineerOptions options)
{
ThreadHelper.ThrowIfNotOnUIThread();
var dbInfo = new DatabaseConnectionModel();
if (!string.IsNullOrEmpty(options.ConnectionString))
{
dbInfo.ConnectionString = options.ConnectionString;
dbInfo.DatabaseType = options.DatabaseType;
}
if (!string.IsNullOrEmpty(options.Dacpac))
{
dbInfo.DatabaseType = DatabaseType.SQLServerDacpac;
dbInfo.ConnectionString = $"Data Source=(local);Initial Catalog={Path.GetFileNameWithoutExtension(options.Dacpac)};Integrated Security=true;";
options.ConnectionString = dbInfo.ConnectionString;
options.DatabaseType = dbInfo.DatabaseType;
options.Dacpac = _package.Dte2.DTE.BuildSqlProj(options.Dacpac);
if (string.IsNullOrEmpty(options.Dacpac))
{
EnvDteHelper.ShowMessage(ReverseEngineerLocale.UnableToBuildSelectedDatabaseProject);
return(null);
}
}
if (dbInfo.DatabaseType == DatabaseType.Undefined)
{
EnvDteHelper.ShowError($"{ReverseEngineerLocale.UnsupportedProvider}");
return(null);
}
return(dbInfo);
}
/// <summary>
/// Insert NEW Connection
/// </summary>
/// <param name="dcm"></param>
/// <returns></returns>
public int InsertConnection(DatabaseConnectionModel dcm)
{
int result = -1;
using (SQLiteConnection conn = new SQLiteConnection(this._conn))
{
conn.Open();
using (SQLiteCommand cmd = new SQLiteCommand(conn))
{
cmd.CommandText = "INSERT INTO conexoes(server,username,password,database) VALUES (@server,@username,@password,@database)";
cmd.Prepare();
cmd.Parameters.AddWithValue("@server", dcm.Server);
cmd.Parameters.AddWithValue("@username", dcm.Username);
cmd.Parameters.AddWithValue("@password", dcm.Password);
cmd.Parameters.AddWithValue("@database", dcm.Database);
try
{
result = cmd.ExecuteNonQuery();
}
catch (SQLiteException ex)
{
throw ex;
}
finally
{
conn.Close();
}
}
}
return(result);
}
public void SaveCredential_Get_DeleteCredential()
{
CredentialStore credentialStore = new CredentialStore();
var databaseConnection = new DatabaseConnectionModel
{
ConnectionName = "test",
ConnectionString = "Data Source=test",
DatabaseType = DatabaseType.SQLite,
DataConnection = null,
};
var saved = credentialStore.SaveCredential(databaseConnection);
Assert.IsTrue(saved);
var connections = credentialStore.GetStoredDatabaseConnections();
Assert.AreEqual(1, connections.Count);
Assert.AreEqual("test", connections[0].ConnectionName);
Assert.AreEqual("Data Source=test", connections[0].ConnectionString);
Assert.AreEqual(DatabaseType.SQLite, connections[0].DatabaseType);
var deleted = credentialStore.DeleteCredential("test");
Assert.IsTrue(deleted);
}
public void OkCommand_Executed_CloseRequestedToView_DatabaseConnection()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var closeRequested = false;
bool?dialogResult = null;
var vsa = Mock.Of <IVisualStudioAccess>();
var vm = new PickServerDatabaseViewModel(vsa)
{
SelectedDatabaseConnection = dbConnection
};
vm.CloseRequested += (sender, args) =>
{
closeRequested = true;
dialogResult = args.DialogResult;
};
// Act
vm.OkCommand.Execute(null);
// Assert
Assert.IsTrue(closeRequested);
Assert.IsTrue(dialogResult);
Assert.AreSame(dbConnection, vm.SelectedDatabaseConnection);
Assert.IsNull(vm.SelectedDatabaseDefinition);
}
public void LoadedCommand_Executed_DatabaseConnectionsAndDefinitions()
{
// Arrange
var vsa = Mock.Of <IVisualStudioAccess>();
var psdFactory = Mock.Of <Func <IPickSchemasDialog> >();
var connFactory = Mock.Of <Func <IPickConnectionDialog> >();
var creds = Mock.Of <ICredentialStore>();
var vm = new PickServerDatabaseViewModel(vsa, creds, psdFactory, connFactory);
var dbConnection1 = new DatabaseConnectionModel();
var dbConnection2 = new DatabaseConnectionModel();
var dbDefinition1 = new DatabaseDefinitionModel();
var dbDefinition2 = new DatabaseDefinitionModel();
vm.DatabaseConnections.Add(dbConnection1);
vm.DatabaseConnections.Add(dbConnection2);
vm.DatabaseDefinitions.Add(dbDefinition1);
vm.DatabaseDefinitions.Add(dbDefinition2);
// Act
vm.LoadedCommand.Execute(null);
// Assert
Assert.AreSame(dbConnection1, vm.SelectedDatabaseConnection);
Assert.IsNull(vm.SelectedDatabaseDefinition);
}
/// <summary>
/// Marks all labels found in dbo.isCUSTOMER table with status = 1 and generates report with not found ones
/// </summary>
/// <param name="connectionModel1">The labels DB connection model</param>
/// <param name="connectionModel2">The customer DB connection model</param>
/// <param name="date">The current date</param>
public XLWorkbook MarkLabelsProcessedAndGenerateReport(DatabaseConnectionModel connectionModel1,
DatabaseConnectionModel connectionModel2,
LabelsGeneratorDbTables tables,
DateTime date,
out Boolean isReportContainData)
{
var labels = MarkLabelsAsProcessedAndGetMissing(connectionModel1, connectionModel2, tables, date);
return(GenerateReport(labels, out isReportContainData));
}
private async Task <List <TableModel> > GetTablesAsync(DatabaseConnectionModel dbInfo, CodeGenerationMode codeGenerationMode, SchemaInfo[] schemas)
{
if (dbInfo.DataConnection != null)
{
dbInfo.DataConnection.Open();
dbInfo.ConnectionString = DataProtection.DecryptString(dbInfo.DataConnection.EncryptedConnectionString);
}
var builder = new TableListBuilder(dbInfo.ConnectionString, dbInfo.DatabaseType, schemas);
return(await builder.GetTableDefinitionsAsync(codeGenerationMode));
}
private async Task <List <TableModel> > GetTablesAsync(DatabaseConnectionModel dbInfo, bool useEFCore5, SchemaInfo[] schemas)
{
if (dbInfo.DataConnection != null)
{
dbInfo.DataConnection.Open();
dbInfo.ConnectionString = DataProtection.DecryptString(dbInfo.DataConnection.EncryptedConnectionString);
}
var builder = new TableListBuilder(dbInfo.ConnectionString, dbInfo.DatabaseType, schemas);
return(await System.Threading.Tasks.Task.Run(() => builder.GetTableDefinitions(useEFCore5)));
}
/// <summary>
/// Cambia los parámetros básicos de la base de datos cuando se cambia el tipo
/// </summary>
private void AssignDataBaseParameters()
{
if (ConnectionTypes.IsSelected())
{
DatabaseConnectionModel.DataBaseType type = ConnectionTypes.GetSelectedItemTyped(DatabaseConnectionModel.DataBaseType.Odbc);
IsServerConnection = DatabaseConnectionModel.CheckIsServerConnection(type);
UseConnectionString = DatabaseConnectionModel.CheckUseConnectionString(type);
CanUseIntegratedSecurity = DatabaseConnectionModel.CheckCanUserIntegratedSecurity(type);
IsTemporalDataBase = type == DatabaseConnectionModel.DataBaseType.SqLite;
Port = DatabaseConnectionModel.GetDefaultPort(type);
}
}
public bool SaveCredential(DatabaseConnectionModel connectionModel)
{
var cred = new NetworkCredential(connectionModel.ConnectionName, connectionModel.ConnectionString).ToICredential();
cred.TargetName = Root + connectionModel.ConnectionName;
cred.Attributes = new Dictionary <string, object>
{
{ nameof(DatabaseType), (int)connectionModel.DatabaseType },
};
cred.Persistance = Persistance.LocalMachine;
cred.Type = CredentialType.Generic;
return(cred.SaveCredential());
}
/// <summary>
/// Abre el formulario de mantenimiento de una conexión
/// </summary>
private void OpenFormConnection(DatabaseConnectionModel connection)
{
DataBaseConnectionViewModel viewModel = new DataBaseConnectionViewModel(connection);
if (MainViewModel.Instance.ViewsController.OpenConnectionView(viewModel))
{
// Añade la conexión si no existía
if (connection == null)
{
Project.Connections.Add(viewModel.Connection);
}
// Graba el proyecto y actualiza
Save();
}
}
/// <summary>
/// Carga los nodos de esquema
/// </summary>
private void LoadSchemaNodes(ExplorerProjectNodeViewModel node, DatabaseConnectionModel connection)
{
try
{
SchemaDbModel schema = new Application.Providers.DataProvider().LoadSchema(connection);
LoadSchemaNodes(node, "Tablas", schema.Tables, NodeType.TablesRoot, NodeType.Table);
LoadSchemaNodes(node, "Vistas", schema.Views, NodeType.ViewsRoot, NodeType.Connection);
AddNode(node, "Procedimientos", null, true, MvvmColor.Red, MainViewModel.Instance.ViewsController.GetIcon(NodeType.ProceduresRoot));
}
catch (Exception exception)
{
MainViewModel.Instance.ControllerWindow.ShowMessage($"Error al cargar el esquema {exception.Message}");
}
}
public DataBaseConnectionViewModel(DatabaseConnectionModel connection)
{
// Inicializa los datos principales
IsNew = connection == null;
if (connection == null)
{
Connection = new DatabaseConnectionModel();
}
else
{
Connection = connection;
}
// Inicializa el viewModel
InitViewModel();
}
public ActionResult Step2(DatabaseConnectionModel model)
{
try
{
var validator = new FluentBaseValidator <DatabaseConnectionModel, DatabaseConnectionRules>(model);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new CustomValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
using (var context = new InstallationDatabaseContext())
{
_installerLanguage = new LanguageInstaller(new Repository <Language>(context));
if (_installerLanguage.Exists())
{
return(RedirectToAction("Step3"));
}
foreach (var language in _installerLanguage.GetList())
{
_installerLanguage.Add(language);
}
return(RedirectToAction("Step3"));
}
}
catch (CustomValidationException exception)
{
var validationResult = exception.ValidationResult;
foreach (var t in validationResult)
{
ModelState.AddModelError(t.PropertyName, t.ErrorMessage);
}
}
catch (SqlException exception)
{
model.HasError = true;
model.Message = "Veritabanına bağlanılamadı. Lütfen bilgilerinizi kontrol ediniz." + exception.Message;
}
return(View(model));
}
/// <summary>
/// Obtiene el esquema de una conexión
/// </summary>
private IDataProvider GetProvider(DatabaseConnectionModel connection)
{
switch (connection.Type)
{
case DatabaseConnectionModel.DataBaseType.SqLite:
return(new ScriptsSqLiteProvider(connection.Name, connection.Type.ToString(), connection.FileName));
case DatabaseConnectionModel.DataBaseType.SqlServer:
return(new ScriptsSqlServerProvider(connection.Name, connection.Type.ToString(), connection.Server,
connection.Port, connection.DataBase, connection.User,
connection.Password, connection.IntegratedSecurity));
default:
return(null);
}
}
public ViewResult Step2()
{
var connectionString = ConfigurationManager.ConnectionStrings["InstallationDatabaseContext"].ConnectionString;
var keyValuePairs = connectionString.Split(';').Select(s => s.Split('=')).Select(connectionStringArray => new KeyValuePair <string, string>(connectionStringArray[0].Trim(), connectionStringArray[1].Trim())).ToList();
var model = new DatabaseConnectionModel
{
DataSource = keyValuePairs.FirstOrDefault(x => x.Key == "Data Source").Value,
InitialCatalog = keyValuePairs.FirstOrDefault(x => x.Key == "Initial Catalog").Value,
UserId = keyValuePairs.FirstOrDefault(x => x.Key == "User ID").Value,
Password = keyValuePairs.FirstOrDefault(x => x.Key == "Password").Value,
Message = ""
};
return(View(model));
}
public void OkCommand_CanExecute_ConnectionSelected()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var vsa = Mock.Of <IVisualStudioAccess>();
var vm = new PickServerDatabaseViewModel(vsa)
{
SelectedDatabaseConnection = dbConnection
};
// Act
var canExecute = vm.OkCommand.CanExecute(null);
// Assert
Assert.IsTrue(canExecute);
}
public void LoadedCommand_Executed()
{
// Arrange
var vsa = Mock.Of <IVisualStudioAccess>();
var vm = new PickServerDatabaseViewModel(vsa);
var dbConnection1 = new DatabaseConnectionModel();
var dbConnection2 = new DatabaseConnectionModel();
vm.DatabaseConnections.Add(dbConnection1);
vm.DatabaseConnections.Add(dbConnection2);
// Act
vm.LoadedCommand.Execute(null);
// Assert
Assert.AreSame(dbConnection1, vm.SelectedDatabaseConnection);
}
public async Task <IActionResult> Index(DatabaseConnectionModel model)
{
if (ModelState.IsValid)
{
try {
await this.ServiceDatabase.TestConnectionAsync(model.ConnectionString);
this.ServiceConnection.SetDatabaseConnection(model);
return(RedirectToAction("Server", new { serveur = model.Server.Replace("\\", "-") }));
} catch (Exception e) {
ModelState.AddModelError(string.Empty, e.Message);
}
}
return(View(model));
}
/// <summary>
/// Obtiene los datos de un nodo para una conexión
/// </summary>
private MLNode GetMLConnection(DatabaseConnectionModel connection)
{
MLNode rootML = GetMLNodeBase(TagDataBaseConnection, connection);
// Asigna las propiedades
rootML.Attributes.Add(TagType, connection.Type.ToString());
rootML.Attributes.Add(TagServer, connection.Server);
rootML.Attributes.Add(TagPort, connection.Port);
rootML.Attributes.Add(TagUser, connection.User);
rootML.Attributes.Add(TagPassword, connection.Password);
rootML.Attributes.Add(TagIntegratedSecurity, connection.IntegratedSecurity);
rootML.Attributes.Add(TagDataBase, connection.DataBase);
rootML.Nodes.Add(TagFilename, connection.FileName);
rootML.Nodes.Add(TagConnectionString, connection.ConnectionString);
// Devuelve el nodo de conexión
return(rootML);
}
public void OkCommand_CanExecute_ConnectionSelected()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var vsa = Mock.Of <IVisualStudioAccess>();
var psdFactory = Mock.Of <Func <IPickSchemasDialog> >();
var connFactory = Mock.Of <Func <IPickConnectionDialog> >();
var vm = new PickServerDatabaseViewModel(vsa, psdFactory, connFactory)
{
SelectedDatabaseConnection = dbConnection
};
// Act
var canExecute = vm.OkCommand.CanExecute(null);
// Assert
Assert.IsTrue(canExecute);
}
/// <summary>
/// Carga los datos de una conexión
/// </summary>
private DatabaseConnectionModel LoadConnection(MLNode rootML)
{
DatabaseConnectionModel connection = new DatabaseConnectionModel();
// Asigna las propiedades
LoadBase(rootML, connection);
connection.Type = rootML.Attributes[TagType].Value.GetEnum(DatabaseConnectionModel.DataBaseType.Odbc);
connection.Server = rootML.Attributes[TagServer].Value;
connection.Port = rootML.Attributes[TagPort].Value.GetInt(0);
connection.User = rootML.Attributes[TagUser].Value;
connection.Password = rootML.Attributes[TagPassword].Value;
connection.IntegratedSecurity = rootML.Attributes[TagIntegratedSecurity].Value.GetBool();
connection.DataBase = rootML.Attributes[TagDataBase].Value;
connection.FileName = rootML.Nodes[TagFilename].Value;
connection.ConnectionString = rootML.Nodes[TagConnectionString].Value;
// Devuelve la conexión creada
return(connection);
}
public void AddDatabaseConnectionCommand_Executed_NewConnectionReturned()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var vsaMock = new Mock <IVisualStudioAccess>();
vsaMock.Setup(m => m.PromptForNewDatabaseConnection()).Returns(dbConnection);
var vm = new PickServerDatabaseViewModel(vsaMock.Object);
// Act
vm.AddDatabaseConnectionCommand.Execute(null);
// Assert
CollectionAssert.Contains(vm.DatabaseConnections, dbConnection);
Assert.AreSame(dbConnection, vm.SelectedDatabaseConnection);
vsaMock.Verify(m => m.PromptForNewDatabaseConnection(), Times.Once);
vsaMock.Verify(m => m.ShowMessage(It.IsNotNull <string>()), Times.Never);
}
public void PropertyChanged_NotInvokedForEqualValues()
{
// Arrange
var invokes = 0;
var dcm = new DatabaseConnectionModel();
dcm.PropertyChanged += (sender, args) => invokes++;
// Act
dcm.ConnectionName = null;
dcm.ConnectionString = null;
dcm.DatabaseType = DatabaseType.Undefined;
// Assert
Assert.AreEqual(0, invokes);
Assert.IsNull(dcm.ConnectionName);
Assert.IsNull(dcm.ConnectionString);
Assert.AreEqual(DatabaseType.Undefined, dcm.DatabaseType);
}
public void Selection_OnlyConnectionOrDefinitionSelected_DatabaseDefinition()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var dbDefinition = new DatabaseDefinitionModel();
var vsa = Mock.Of <IVisualStudioAccess>();
// ReSharper disable once UseObjectOrCollectionInitializer
var vm = new PickServerDatabaseViewModel(vsa)
{
SelectedDatabaseConnection = dbConnection
};
// Act
vm.SelectedDatabaseDefinition = dbDefinition;
// Assert
Assert.IsNull(vm.SelectedDatabaseConnection);
Assert.AreSame(dbDefinition, vm.SelectedDatabaseDefinition);
}
private DatabaseConnectionModel GetDatabaseConnectionModel(ICredential credential)
{
try
{
var result = new DatabaseConnectionModel
{
ConnectionName = credential.TargetName.Substring(5),
ConnectionString = credential.ToNetworkCredential().Password,
DatabaseType = (DatabaseType)credential.Attributes[nameof(DatabaseType)],
};
return(result);
}
catch
{
// Ignore
}
return(null);
}
public void AddDatabaseConnectionCommand_Executed_NewConnectionReturned()
{
// Arrange
var dbConnection = new DatabaseConnectionModel();
var vsaMock = new Mock <IVisualStudioAccess>();
var psdFactory = Mock.Of <Func <IPickSchemasDialog> >();
var connFactory = Mock.Of <Func <IPickConnectionDialog> >();
var creds = Mock.Of <ICredentialStore>();
vsaMock.Setup(m => m.PromptForNewDatabaseConnection()).Returns(dbConnection);
var vm = new PickServerDatabaseViewModel(vsaMock.Object, creds, psdFactory, connFactory);
// Act
vm.AddDatabaseConnectionCommand.Execute(null);
// Assert
CollectionAssert.Contains(vm.DatabaseConnections, dbConnection);
Assert.AreSame(dbConnection, vm.SelectedDatabaseConnection);
vsaMock.Verify(m => m.PromptForNewDatabaseConnection(), Times.Once);
vsaMock.Verify(m => m.ShowMessage(It.IsNotNull <string>()), Times.Never);
}
