private void UpdateSql()
{
var queryBuilder = QueryBuilder.CreateIndex(indexName)
.IfNotExists(isIfNotExists)
.On(selectedTable)
.Unique(isUnique);
foreach (var item in Columns)
{
if (item.SelectedAction.Equals(LocalisationHelper.GetString("IndexCreator_ColumnAction_Ascending")))
{
queryBuilder = queryBuilder.IndexColumn(item.ColumnName, OrderType.Ascending);
}
else if (item.SelectedAction.Equals(LocalisationHelper.GetString("IndexCreator_ColumnAction_Descending")))
{
queryBuilder = queryBuilder.IndexColumn(item.ColumnName, OrderType.Descending);
}
}
if (!string.IsNullOrWhiteSpace(whereStatement))
{
queryBuilder = queryBuilder.Where(whereStatement);
}
SqlStatement = queryBuilder.Build();
}
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 - ");
}
}
}
}
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 CopyValues()
{
logger.Info("Copying values.");
try
{
using (var sourceTableHandler = new TableHandler(sourceDatabase))
using (var targetDbHandler = new DatabaseHandler(selectedDatabase.DatabasePath))
{
var records = sourceTableHandler.GetRows(tableName);
var values = new List <string>();
foreach (DataRow row in records)
{
values.Clear();
foreach (var value in row.ItemArray)
{
values.Add(value.ToString());
}
var command = QueryBuilder.InsertInto(TargetTableName).Values(values).Build();
targetDbHandler.ExecuteNonQuery(command);
}
}
StatusInfo = LocalisationHelper.GetString("TableMigrator_CopySuccess");
logger.Info("Successfully copied values");
}
catch (Exception ex)
{
logger.Error("Failed to copy table values.", ex);
StatusInfo = LocalisationHelper.GetString("TableMigrator_CopySemiSuccess");
}
}
private void UpdateViewDefinition()
{
StatusInfo = string.Empty;
if (!SqlStatement.StartsWith("SELECT", StringComparison.CurrentCultureIgnoreCase))
{
StatusInfo = LocalisationHelper.GetString("ViewGeneralTab_InvalidStatement");
return;
}
try
{
using (var viewHandler = new ViewHandler(Settings.Default.CurrentDatabase))
{
viewHandler.UpdateViewDefinition(viewName, SqlStatement);
}
}
catch (Exception ex)
{
logger.Error("A view definition could not be updated.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database\r\n", "SQL-Error - ");
}
SetDataGridData();
}
public PreferencesViewModel()
{
AvailableLanguages = new List <string>
{
LocalisationHelper.GetString("Preferences_Language_German"),
LocalisationHelper.GetString("Preferences_Language_English")
};
applySettingsCommand = new DelegateCommand(ApplySettings);
}
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 ColumnItem(string columnName)
{
ColumnName = columnName;
AvailableActions = new List <string>
{
LocalisationHelper.GetString("IndexCreator_ColumnAction_DoNotUse"),
LocalisationHelper.GetString("IndexCreator_ColumnAction_Ascending"),
LocalisationHelper.GetString("IndexCreator_ColumnAction_Descending")
};
SelectedAction = LocalisationHelper.GetString("IndexCreator_ColumnAction_DoNotUse");
}
internal void DeleteRow(IList <DataGridCellInfo> currentRow)
{
StatusInfo = string.Empty;
var message = LocalisationHelper.GetString("MessageBox_TableRecordDeleteWarning");
var messageTitle = LocalisationHelper.GetString("MessageBoxTitle_TableRecordDelete");
var result = MessageBox.Show(message, messageTitle, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result != MessageBoxResult.Yes)
{
return;
}
try
{
var queryBuilder = QueryBuilder.DeleteFrom(tableName);
foreach (DataGridCellInfo cell in currentRow)
{
var column = cell.Column.Header.ToString();
var cellContent = cell.Column.GetCellContent(cell.Item);
string cellContentValue;
var cellContentTextBox = cellContent as TextBox;
if (cellContentTextBox == null)
{
var cellContentTextBlock = cellContent as TextBlock;
cellContentValue = cellContentTextBlock.Text;
}
else
{
cellContentValue = cellContentTextBox.Text;
}
queryBuilder = queryBuilder.Where(column)
.Is(cellContentValue) as DeleteQueryBuilder;
}
var command = queryBuilder.Build();
ExecuteCommand(command);
SelectAll();
}
catch (Exception ex)
{
logger.Error("Failed to update delete row from table '" + tableName + "'.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database ", "SQL Error - ");
}
}
private string GetLanguageFromSettings()
{
var setting = Properties.Settings.Default.UILanguage;
switch (setting)
{
case "de-DE":
return(LocalisationHelper.GetString("Preferences_Language_German"));
case "en-GB":
default:
return(LocalisationHelper.GetString("Preferences_Language_English"));
}
;
}
public CSVExportViewModel(string tableName)
{
this.tableName = tableName;
DescriptionLabelText = LocalisationHelper.GetString("CSVExportWindow_CSVExportFor", tableName);
AvailableSeparators = new List <string> {
",", ";", "|", "Tab"
};
AvailableEnclosures = new List <string> {
"\"", "None"
};
SelectedSeparator = ";";
SelectedEnclosure = "None";
exportCommand = new DelegateCommand(Export);
}
private void VerifyModel()
{
IsValidModel = selectedDatabase != null &&
!string.IsNullOrEmpty(triggerName) &&
!string.IsNullOrEmpty(selectedTriggerEntryPoint) &&
!string.IsNullOrEmpty(selectedTriggerEvent) &&
!string.IsNullOrEmpty(selectedTarget) &&
!string.IsNullOrEmpty(triggerActions);
if (!IsValidModel)
{
StatusInfo = LocalisationHelper.GetString("TriggerCreator_StatusInfo_InvalidModel");
}
else
{
StatusInfo = string.Empty;
}
}
private void Create()
{
StatusInfo = string.Empty;
using (var tableHandler = new TableHandler(Settings.Default.CurrentDatabase))
{
try
{
tableHandler.AddColumn(tableName, ColumnName, SelectedDataType.ToString(), IsNotNull, DefaultValue);
StatusInfo = LocalisationHelper.GetString("ColumnCreator_StatusInfo_Success");
}
catch (Exception ex)
{
logger.Warn("Failed to add new column to table '" + tableName + "'.", ex);
StatusInfo = ex.Message.Replace("SQL logic error or missing database\r\n", "SQL-Error - ");
}
}
}
private void ApplyLanguage()
{
if (selectedLanguage.Equals(GetLanguageFromSettings()))
{
return;
}
if (selectedLanguage.Equals(LocalisationHelper.GetString("Preferences_Language_German")))
{
Properties.Settings.Default.UILanguage = "de-DE";
}
else
{
Properties.Settings.Default.UILanguage = "en-GB";
}
log.Info("Applied application language " + Properties.Settings.Default.UILanguage);
}
private void VerifyModel()
{
var selectedColumns = Columns
.Where(x => !x.SelectedAction.Equals(LocalisationHelper.GetString("IndexCreator_ColumnAction_DoNotUse")));
IsValidModel = selectedDatabase != null &&
!string.IsNullOrEmpty(indexName) &&
!string.IsNullOrEmpty(selectedTable) &&
selectedColumns.Any();
if (!IsValidModel)
{
StatusInfo = LocalisationHelper.GetString("IndexCreator_StatusInfo_InvalidModel");
}
else
{
StatusInfo = string.Empty;
}
}
private IndexFolderItem MapIndexes()
{
var indexes = dbHandler.GetIndexes();
var indexFolder = new IndexFolderItem {
DisplayName = LocalisationHelper.GetString("TreeItem_Indexes")
};
foreach (var index in indexes)
{
indexFolder.Items.Add(new IndexItem
{
DisplayName = index.Name,
DatabasePath = databasePath
});
}
indexFolder.Items = new ObservableCollection <TreeItem>(indexFolder.Items.OrderBy(x => x.DisplayName));
return(indexFolder);
}
private ViewFolderItem MapViews()
{
var views = dbHandler.GetViews();
var viewFolder = new ViewFolderItem {
DisplayName = LocalisationHelper.GetString("TreeItem_Views")
};
foreach (var view in views)
{
viewFolder.Items.Add(new ViewItem
{
DisplayName = view.Name,
DatabasePath = databasePath
});
}
viewFolder.Items = new ObservableCollection <TreeItem>(viewFolder.Items.OrderBy(x => x.DisplayName));
return(viewFolder);
}
private TableFolderItem MapTables()
{
var tables = dbHandler.GetTables();
var tableFolder = new TableFolderItem {
DisplayName = LocalisationHelper.GetString("TreeItem_Tables")
};
foreach (var table in tables)
{
tableFolder.Items.Add(new TableItem
{
DisplayName = table.Name,
DatabasePath = databasePath
});
}
tableFolder.Items = new ObservableCollection <TreeItem>(tableFolder.Items.OrderBy(x => x.DisplayName));
return(tableFolder);
}
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 - ");
}
}
}
private void SaveQuery()
{
using (var fileDialog = new SaveFileDialog())
{
fileDialog.Filter = "SQL Files(*.sql)|*.sql";
if (fileDialog.ShowDialog() == DialogResult.OK)
{
try
{
File.WriteAllText(fileDialog.FileName, sqlStatement);
logger.Info("Saved query to file.");
}
catch (Exception ex)
{
logger.Info("Could not save query to file " + fileDialog.FileName, ex);
StatusInfo = LocalisationHelper.GetString("QueryEditor_FileSaveFailed");
}
}
}
}
private void LoadQuery()
{
using (var fileDialog = new OpenFileDialog())
{
fileDialog.Filter = "SQL Files(*.sql)|*.sql; |All Files |*.*";
if (fileDialog.ShowDialog() == DialogResult.OK)
{
try
{
SqlStatement = File.ReadAllText(fileDialog.FileName);
logger.Info("Loaded query from file.");
}
catch (Exception ex)
{
logger.Info("Could not read query from file " + fileDialog.FileName, ex);
StatusInfo = LocalisationHelper.GetString("QueryEditor_FileLoadFailed");
}
}
}
}
public TableMigratorViewModel(IEnumerable <TreeItem> databases, string tableName)
{
this.tableName = TargetTableName = tableName;
sourceDatabase = Settings.Default.CurrentDatabase;
WindowTitle = LocalisationHelper.GetString("WindowTitle_TableMigrator_Copy", tableName);
executeCommand = new DelegateCommand(Copy);
Databases = new List <DatabaseSelectItem>();
foreach (DatabaseItem database in databases)
{
if (!database.DatabasePath.Equals(sourceDatabase))
{
Databases.Add(new DatabaseSelectItem
{
DatabaseName = database.DisplayName,
DatabasePath = database.DatabasePath
});
}
}
}
private void Rename()
{
StatusInfo = string.Empty;
var itemType = originalElement.GetType();
try
{
if (itemType == typeof(DatabaseItem))
{
RenameDatabase();
}
else if (itemType == typeof(TableItem))
{
RenameTable();
}
else if (itemType == typeof(ViewItem))
{
RenameView();
}
else if (itemType == typeof(IndexItem))
{
RenameIndex();
}
else if (itemType == typeof(TriggerItem))
{
RenameTrigger();
}
StatusInfo = LocalisationHelper.GetString("ElementRenameWindow_Success");
originalElement.DisplayName = NewName;
WindowTitle = LocalisationHelper.GetString("WindowTitle_RenameElement", NewName);
}
catch (Exception ex)
{
logger.Warn("Failed to rename the element '" + originalElement.DisplayName + "' from RenameWindow.", ex);
dialogService.ShowMessage("MessageBox_NameChangeFailed");
}
}
private void ExportCSV(string csv)
{
using (var fileDialog = new SaveFileDialog())
{
fileDialog.Filter = "CSV Files(*.csv)|*.csv";
fileDialog.FileName = tableName + ".csv";
if (fileDialog.ShowDialog() == DialogResult.OK)
{
try
{
File.WriteAllText(fileDialog.FileName, csv);
logger.Info("Exported table to CSV file " + fileDialog.FileName);
StatusInfo = LocalisationHelper.GetString("CSVExportWindow_ExportSuccess");
}
catch (Exception ex)
{
logger.Info("Could not export table to CSV file " + fileDialog.FileName, ex);
dialogService.ShowMessage("MessageBox_TableCSVExportFailed");
}
}
}
}
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();
}
}
private void Execute()
{
StatusInfo = string.Empty;
if (SelectedDatabase == null)
{
StatusInfo = LocalisationHelper.GetString("TableCreator_NoDatabaseSelected");
return;
}
if (string.IsNullOrEmpty(SqlStatement))
{
return;
}
if (string.IsNullOrEmpty(SelectedText))
{
ExecuteSql(SqlStatement);
}
else
{
ExecuteSql(SelectedText);
}
}
static Unity()
{
_localisationHelper = new LocalisationHelper(Language.Current.ResourceManager);
}
public ElementRenameViewModel(TreeItem treeItem)
{
originalElement = treeItem;
renameCommand = new DelegateCommand(Rename);
WindowTitle = LocalisationHelper.GetString("WindowTitle_RenameElement", treeItem.DisplayName);
}
