private void Create()
{
StatusInfo = string.Empty;
if (!sqlStatement.StartsWith("SELECT", StringComparison.CurrentCultureIgnoreCase))
{
StatusInfo = LocalisationHelper.GetString("ViewGeneralTab_InvalidStatement");
return;
}
var exectuableSql = QueryBuilder.CreateView(ViewName)
.IfNotExists(IsIfNotExists)
.As(sqlStatement)
.Build();
using (var dbHandler = new DatabaseHandler(selectedDatabase.DatabasePath))
{
try
{
dbHandler.ExecuteNonQuery(exectuableSql);
StatusInfo = LocalisationHelper.GetString("ViewCreator_ViewCreateSuccess");
MainTreeHandler.AddView(viewName, selectedDatabase.DatabasePath);
}
catch (Exception ex)
{
logger.Error("A view could not be created.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database\r\n", "SQL-Error - ");
}
}
}
private void Create()
{
StatusInfo = string.Empty;
if (SelectedDatabase == null)
{
StatusInfo = LocalisationHelper.GetString("TableCreator_NoDatabaseSelected");
return;
}
if (!string.IsNullOrEmpty(SqlStatement))
{
var database = SelectedDatabase as DatabaseSelectItem;
using (var dbHandler = new DatabaseHandler(database.DatabasePath))
{
try
{
dbHandler.ExecuteNonQuery(SqlStatement);
StatusInfo = LocalisationHelper.GetString("TableCreator_TableCreateSuccess");
MainTreeHandler.AddTable(tableName, selectedDatabase.DatabasePath);
}
catch (Exception ex)
{
logger.Error("An error occured when the user tried to create a table from the TableCreator.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database\r\n", "SQL-Error - ");
}
}
}
}
public void AddTrigger_WithValidDatabasePath_DoesNotAddTriggerToDifferentDatabase()
{
MainTreeHandler.AddTrigger("NewTrigger", DATABASEPATH1);
var result = TreeSearcher.DatabaseHoldsItem <TriggerFolderItem>(testTree, "NewTrigger", DATABASEPATH2);
Assert.IsFalse(result);
}
public void UpdateTriggerName_WithValidDatabasePath_RenamesTriggerInSpecifiedDatabase()
{
MainTreeHandler.UpdateTriggerName("Trigger", "NewTrigger", DATABASEPATH1);
var result = TreeSearcher.DatabaseHoldsItem <TriggerFolderItem>(testTree, "NewTrigger", DATABASEPATH1);
Assert.IsTrue(result);
}
public void AddTrigger_WithValidDatabasePath_AddsTriggerToSpecifiedDatabase()
{
MainTreeHandler.AddTrigger("NewTrigger", DATABASEPATH1);
var result = TreeSearcher.DatabaseHoldsItem <TriggerFolderItem>(testTree, "NewTrigger", DATABASEPATH1);
Assert.IsTrue(result);
}
public void UpdateTriggerName_WithValidDatabasePath_DatabaseDoesNotContainOldItemAnymore()
{
MainTreeHandler.UpdateTriggerName("Trigger", "NewTrigger", DATABASEPATH1);
var result = TreeSearcher.DatabaseHoldsItem <TriggerFolderItem>(testTree, "Trigger", DATABASEPATH1);
Assert.IsFalse(result);
}
private void RenameTrigger()
{
using (var triggerHandler = new TriggerHandler(originalElement.DatabasePath))
{
triggerHandler.UpdateTriggerName(originalElement.DisplayName, NewName);
MainTreeHandler.UpdateTriggerName(originalElement.DisplayName, NewName, originalElement.DatabasePath);
}
}
private void RenameTable()
{
using (var tableHandler = new TableHandler(originalElement.DatabasePath))
{
tableHandler.RenameTable(originalElement.DisplayName, NewName);
MainTreeHandler.UpdateTableName(originalElement.DisplayName, NewName, originalElement.DatabasePath);
}
}
private void RenameIndex()
{
using (var indexHandler = new IndexHandler(originalElement.DatabasePath))
{
indexHandler.UpdateIndexName(originalElement.DisplayName, NewName);
MainTreeHandler.UpdateIndexName(originalElement.DisplayName, NewName, originalElement.DatabasePath);
}
}
private void RenameView()
{
using (var viewHandler = new ViewHandler(originalElement.DatabasePath))
{
viewHandler.UpdateViewName(originalElement.DisplayName, NewName);
MainTreeHandler.UpdateViewName(originalElement.DisplayName, NewName, originalElement.DatabasePath);
}
}
public void UpdateViewName_WithValidDatabasePath_RenamesViewInSpecifiedDatabase()
{
MainTreeHandler.UpdateViewName("View", "NewView", DATABASEPATH1);
var result = TreeSearcher.DatabaseHoldsItem <ViewFolderItem>(testTree, "NewView", DATABASEPATH1);
Assert.IsTrue(result);
}
public void AddView_WithValidDatabasePath_AddsViewToSpecifiedDatabase()
{
MainTreeHandler.AddView("NewView", DATABASEPATH1);
var result = TreeSearcher.DatabaseHoldsItem <ViewFolderItem>(testTree, "NewView", DATABASEPATH1);
Assert.IsTrue(result);
}
public ViewCreatorViewModel()
{
IsIfNotExists = true;
Databases = MainTreeHandler.GetDatabaseSelectItems();
Tables = new ObservableCollection <TableTreeItem>();
createCommand = new DelegateCommand(Create);
}
public IndexCreatorViewModel()
{
Databases = MainTreeHandler.GetDatabaseSelectItems();
Tables = new ObservableCollection <string>();
Columns = new ObservableCollection <ColumnItem>();
Columns.CollectionChanged += CollectionContentChanged;
createCommand = new DelegateCommand(Create);
}
private void RenameDatabase()
{
var originalFileDirectory = Path.GetDirectoryName(originalElement.DatabasePath);
var originalFileEnding = Path.GetExtension(originalElement.DatabasePath);
var newFileName = string.Format("{0}{1}", NewName, originalFileEnding);
var newDatabasePath = Path.Combine(originalFileDirectory, newFileName);
File.Move(originalElement.DatabasePath, newDatabasePath);
MainTreeHandler.UpdateDatabase(originalElement.DatabasePath, newDatabasePath);
}
public MainWindowViewModel(ITreeSaveHelper treeSaveHelper)
{
this.treeSaveHelper = treeSaveHelper;
TreeViewItems = treeSaveHelper.Load();
MainTreeHandler.Register(TreeViewItems);
createDatabaseCommand = new DelegateCommand(CreateDatabase);
openDatabaseCommand = new DelegateCommand(OpenDatabase);
documentationCommand = new DelegateCommand(OpenDocumentation);
}
public QueryEditorViewModel()
{
Databases = MainTreeHandler.GetDatabaseSelectItems();
AvailableTemplates = QueryTemplateGenerator.GetAvailableTemplates();
dataGrid = new ListCollectionView(new List <object>());
selectedTemplate = LocalisationHelper.GetString("QueryEditor_Templates");
executeCommand = new DelegateCommand(Execute);
saveCommand = new DelegateCommand(SaveQuery);
loadCommand = new DelegateCommand(LoadQuery);
}
public TableCreatorViewModel()
{
Databases = MainTreeHandler.GetDatabaseSelectItems();
ColumnDefinitions = new ObservableCollection <ColumnDefinitionItem>();
ForeignKeyDefinitions = new ObservableCollection <ForeignKeyDefinitionItem>();
ColumnDefinitions.CollectionChanged += CollectionContentChanged;
ForeignKeyDefinitions.CollectionChanged += CollectionContentChanged;
addColumnCommand = new DelegateCommand(AddColumnDefinition);
addForeignKeyCommand = new DelegateCommand(AddForeignKeyDefinition);
createCommand = new DelegateCommand(Create);
}
private void Create()
{
StatusInfo = string.Empty;
using (var dbHandler = new DatabaseHandler(selectedDatabase.DatabasePath))
{
try
{
dbHandler.ExecuteNonQuery(sqlStatement);
StatusInfo = LocalisationHelper.GetString("IndexCreator_StatusInfo_Success");
MainTreeHandler.AddIndex(indexName, selectedDatabase.DatabasePath);
}
catch (Exception ex)
{
logger.Error("An error occured when the user tried to create an index from the IndexCreator.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database\r\n", "SQL-Error - ");
}
}
}
public TriggerCreatorViewModel()
{
Databases = MainTreeHandler.GetDatabaseSelectItems();
TriggerEntryPoints = new List <string> {
"BEFORE", "AFTER", "INSTEAD OF"
};
TriggerEvents = new List <string> {
"DELETE", "INSERT", "UPDATE", "UPDATE OF"
};
AvailableTargets = new ObservableCollection <string>();
Columns = new ObservableCollection <ColumnItem>();
Columns.CollectionChanged += CollectionContentChanged;
createCommand = new DelegateCommand(Create);
UpdateModel();
}
private void CopyTable()
{
logger.Info("Copying table '" + tableName + "' as '" + TargetTableName
+ "' from database " + Environment.NewLine + sourceDatabase + Environment.NewLine
+ " to database " + Environment.NewLine + selectedDatabase.DatabasePath);
bool isSuccessfullTableCopy = false;
try
{
using (var sourceTableHandler = new TableHandler(sourceDatabase))
using (var targetDbHandler = new DatabaseHandler(selectedDatabase.DatabasePath))
{
var originalTable = sourceTableHandler.GetTable(tableName);
var createStatement = originalTable.CreateStatement.Replace(tableName, TargetTableName);
targetDbHandler.ExecuteNonQuery(createStatement);
MainTreeHandler.AddTable(TargetTableName, selectedDatabase.DatabasePath);
StatusInfo = LocalisationHelper.GetString("TableMigrator_CopySuccess");
isSuccessfullTableCopy = true;
logger.Info("Successfully copied table structure to target database.");
}
}
catch (Exception ex)
{
logger.Error("A table could not be copied.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database\r\n", "SQL-Error - ");
}
if (!IsOnlyStructure && isSuccessfullTableCopy)
{
CopyValues();
}
}
public void SetUp()
{
testTree = new ObservableCollection <TreeItem>
{
new DatabaseItem
{
DisplayName = "Db1",
DatabasePath = DATABASEPATH1,
Items = new ObservableCollection <TreeItem>
{
new TableFolderItem
{
DatabasePath = DATABASEPATH1,
Items = new ObservableCollection <TreeItem>
{
new TableItem
{
DisplayName = "Table",
DatabasePath = DATABASEPATH1
}
}
},
new ViewFolderItem
{
DatabasePath = DATABASEPATH1,
Items = new ObservableCollection <TreeItem>
{
new ViewItem
{
DisplayName = "View",
DatabasePath = DATABASEPATH1
}
}
},
new TriggerFolderItem
{
DatabasePath = DATABASEPATH1,
Items = new ObservableCollection <TreeItem>
{
new TriggerItem
{
DisplayName = "Trigger",
DatabasePath = DATABASEPATH1
}
}
}
}
},
new DatabaseItem
{
DisplayName = "Db2",
DatabasePath = DATABASEPATH2,
Items = new ObservableCollection <TreeItem>
{
new TableFolderItem
{
DatabasePath = DATABASEPATH2,
Items = new ObservableCollection <TreeItem>
{
new TableItem
{
DisplayName = "Table",
DatabasePath = DATABASEPATH2
}
}
},
new ViewFolderItem
{
DatabasePath = DATABASEPATH2,
Items = new ObservableCollection <TreeItem>
{
new ViewItem
{
DisplayName = "View",
DatabasePath = DATABASEPATH2
}
}
},
new TriggerFolderItem
{
DatabasePath = DATABASEPATH1,
Items = new ObservableCollection <TreeItem>
{
new TriggerItem
{
DisplayName = "Trigger",
DatabasePath = DATABASEPATH2
}
}
}
}
}
};
MainTreeHandler.Register(testTree);
}
public void AddView_WithInvalidDatabasePath_DoesNotThrowException()
{
Assert.DoesNotThrow(
() => MainTreeHandler.AddView("NewView", "InvalidPath"));
}
public void UpdateTriggerName_WithInvalidOldName_DoesNotThrowException()
{
Assert.DoesNotThrow(
() => MainTreeHandler.UpdateTriggerName("InvalidOldName", "NewName", DATABASEPATH1));
}
public void AddTrigger_WithInvalidDatabasePath_DoesNotThrowException()
{
Assert.DoesNotThrow(
() => MainTreeHandler.AddTrigger("NewTrigger", "InvalidPath"));
}
public void SetUp()
{
MainTreeHandler.Register(new ObservableCollection <TreeItem>());
viewModel = new TriggerCreatorViewModel();
}
