private SqlEditorViewModel(IMySqlExecutor mySqlExecutor,
IStatusBar statusBar,
IDatabaseProvider databaseProvider,
ITaskRunner taskRunner,
INativeTextDocument sql)
{
Code = sql;
ExecuteSql = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
async() =>
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Executing query"));
try
{
await mySqlExecutor.ExecuteSql(Code.ToString());
statusBar.PublishNotification(new PlainNotification(NotificationType.Success, "Query executed"));
}
catch (Exception e)
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Error, "Failure during query execution"));
Console.WriteLine(e);
}
});
}, () => databaseProvider.IsConnected);
IsLoading = false;
Save = new DelegateCommand(() =>
{
ExecuteSql.Execute(null);
});
}
public ConditionsFindAnywhereSource(IConditionDataManager dataManager,
IMySqlExecutor mySqlExecutor,
Lazy <IMessageBoxService> messageBoxService)
{
this.dataManager = dataManager;
this.mySqlExecutor = mySqlExecutor;
this.messageBoxService = messageBoxService;
}
protected ViewModelBase(IHistoryManager history,
DatabaseTableSolutionItem solutionItem,
ISolutionItemNameRegistry solutionItemName,
ISolutionManager solutionManager,
ISolutionTasksService solutionTasksService,
IEventAggregator eventAggregator,
IQueryGenerator queryGenerator,
IDatabaseTableDataProvider databaseTableDataProvider,
IMessageBoxService messageBoxService,
ITaskRunner taskRunner,
IParameterFactory parameterFactory,
ITableDefinitionProvider tableDefinitionProvider,
IItemFromListProvider itemFromListProvider,
ISolutionItemIconRegistry iconRegistry,
ISessionService sessionService,
IDatabaseTableCommandService commandService,
IParameterPickerService parameterPickerService,
IStatusBar statusBar,
IMySqlExecutor mySqlExecutor)
{
this.solutionItemName = solutionItemName;
this.solutionManager = solutionManager;
this.solutionTasksService = solutionTasksService;
this.queryGenerator = queryGenerator;
this.databaseTableDataProvider = databaseTableDataProvider;
this.messageBoxService = messageBoxService;
this.taskRunner = taskRunner;
this.parameterFactory = parameterFactory;
this.tableDefinitionProvider = tableDefinitionProvider;
this.itemFromListProvider = itemFromListProvider;
this.sessionService = sessionService;
this.commandService = commandService;
this.parameterPickerService = parameterPickerService;
this.statusBar = statusBar;
this.mySqlExecutor = mySqlExecutor;
this.solutionItem = solutionItem;
History = history;
undoCommand = new DelegateCommand(History.Undo, CanUndo);
redoCommand = new DelegateCommand(History.Redo, CanRedo);
Save = new AsyncAutoCommand(SaveSolutionItem);
title = solutionItemName.GetName(solutionItem);
Icon = iconRegistry.GetIcon(solutionItem);
nameGeneratorParameter = parameterFactory.Factory("Parameter");
History.PropertyChanged += (_, _) =>
{
undoCommand.RaiseCanExecuteChanged();
redoCommand.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(IsModified));
};
tableDefinition = tableDefinitionProvider.GetDefinition(solutionItem.DefinitionId) !;
LoadAndCreateCommands();
nameGeneratorParameter = parameterFactory.Factory(tableDefinition.Picker);
}
public MetaSqlSolutionItemEditorProvider(Lazy <ISolutionItemSqlGeneratorRegistry> sqlGeneratorsRegistry,
IMySqlExecutor mySqlExecutor,
IStatusBar statusBar,
ITaskRunner taskRunner)
{
this.sqlGeneratorsRegistry = sqlGeneratorsRegistry;
this.mySqlExecutor = mySqlExecutor;
this.statusBar = statusBar;
this.taskRunner = taskRunner;
}
public MetaSqlSolutionItemEditorProvider(Lazy <ISolutionItemSqlGeneratorRegistry> sqlGeneratorsRegistry,
Func <INativeTextDocument> document,
IMySqlExecutor mySqlExecutor,
IStatusBar statusBar,
ITaskRunner taskRunner)
{
this.sqlGeneratorsRegistry = sqlGeneratorsRegistry;
this.document = document;
this.mySqlExecutor = mySqlExecutor;
this.statusBar = statusBar;
this.taskRunner = taskRunner;
}
public DatabaseTableDataProvider(ITableDefinitionProvider tableDefinitionProvider,
IMySqlExecutor sqlExecutor,
IMessageBoxService messageBoxService,
IDatabaseProvider databaseProvider,
IDatabaseTableModelGenerator tableModelGenerator)
{
this.tableDefinitionProvider = tableDefinitionProvider;
this.sqlExecutor = sqlExecutor;
this.messageBoxService = messageBoxService;
this.databaseProvider = databaseProvider;
this.tableModelGenerator = tableModelGenerator;
}
public DatabaseTablesFindAnywhereSource(IMySqlExecutor executor,
ITableDefinitionProvider definitionProvider,
Lazy <IDocumentManager> documentManager,
IEventAggregator eventAggregator,
IParameterFactory parameterFactory)
{
this.executor = executor;
this.definitionProvider = definitionProvider;
this.documentManager = documentManager;
this.eventAggregator = eventAggregator;
this.parameterFactory = parameterFactory;
}
public SqlEditorViewModel(IMySqlExecutor mySqlExecutor, IStatusBar statusBar, ITaskRunner taskRunner, string sql)
{
Code = new TextDocument(sql);
ExecuteSql = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
async() =>
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Executing query"));
await mySqlExecutor.ExecuteSql(Code.Text);
statusBar.PublishNotification(new PlainNotification(NotificationType.Success, "Query executed"));
});
});
}
public SqlEditorViewModel(IMySqlExecutor mySqlExecutor,
IStatusBar statusBar,
IDatabaseProvider databaseProvider,
ITaskRunner taskRunner,
ISolutionItemSqlGeneratorRegistry sqlGeneratorsRegistry,
INativeTextDocument sql,
MetaSolutionSQL item) : this(mySqlExecutor, statusBar, databaseProvider, taskRunner, sql)
{
IsLoading = true;
taskRunner.ScheduleTask("Generating SQL",
async() =>
{
string sql = await sqlGeneratorsRegistry.GenerateSql(item.ItemToGenerate);
Code.FromString(sql);
IsLoading = false;
});
}
public SolutionTasksService(ITaskRunner taskRunner,
ISolutionItemSqlGeneratorRegistry sqlGenerator,
ISolutionItemRemoteCommandGeneratorRegistry remoteCommandGenerator,
IMySqlExecutor sqlExecutor,
ISolutionItemNameRegistry solutionItemNameRegistry,
IRemoteConnectorService remoteConnectorService,
IDatabaseProvider databaseProvider,
IStatusBar statusBar)
{
this.taskRunner = taskRunner;
this.sqlGenerator = sqlGenerator;
this.remoteCommandGenerator = remoteCommandGenerator;
this.sqlExecutor = sqlExecutor;
this.solutionItemNameRegistry = solutionItemNameRegistry;
this.remoteConnectorService = remoteConnectorService;
this.databaseProvider = databaseProvider;
this.statusBar = statusBar;
}
public WizardStyleViewModelBase(
IMessageBoxService messageBoxService,
ICoreSourceSettings coreSourceSettings,
ISourceSqlUpdateService sqlUpdateService,
IAuthMySqlExecutor authExecutor,
IMySqlExecutor worldExecutor,
IWindowManager windowManager,
ITaskRunner taskRunner,
IStatusBar statusBar,
INativeTextDocument resultCode)
{
ResultCode = resultCode;
CoreSourceFolder = coreSourceSettings.CurrentCorePath;
if (!string.IsNullOrEmpty(coreSourceSettings.CurrentCorePath))
{
Dispatcher.UIThread.Post(() => WizardStep++);
}
CommandPreviousStep = new DelegateCommand(() => WizardStep--, () => !IsLoading && WizardStep > 0)
.ObservesProperty(() => IsLoading)
.ObservesProperty(() => WizardStep);
CommandNextStep = new DelegateCommand(() => WizardStep++, () => !IsLoading && WizardStep < TotalSteps - 1)
.ObservesProperty(() => IsLoading)
.ObservesProperty(() => WizardStep);
PickCoreSourceFolder = new AsyncAutoCommand(async() =>
{
var selectedPath = await windowManager.ShowFolderPickerDialog(coreSourceFolder);
if (selectedPath != null)
{
if (!coreSourceSettings.SetCorePath(selectedPath))
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Invalid folder")
.SetMainInstruction("Invalid wow source folder")
.SetContent(
"It looks like it is not an valid wow server source folder.\n\nThe folder should contain src/ and sql/ subfolders")
.WithOkButton(true)
.Build());
}
CoreSourceFolder = coreSourceSettings.CurrentCorePath;
}
});
ExecuteSqlCommand = new AsyncAutoCommand(async() =>
{
var(auth, world) = GenerateSql();
try
{
await taskRunner.ScheduleTask("Executing commands update", async() =>
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Executing query"));
if (auth != null)
{
if (authExecutor.IsConnected)
{
await authExecutor.ExecuteSql(auth);
}
else
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Auth database not connected")
.SetIcon(MessageBoxIcon.Warning)
.SetMainInstruction("Auth database not connected")
.SetContent(
"You are trying to execute auth query, but auth database is not connected.\n\nEnsure you have correct auth database data in settings.")
.WithOkButton(true)
.Build());
}
}
if (world != null)
{
if (worldExecutor.IsConnected)
{
await worldExecutor.ExecuteSql(world);
}
else
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("World database not connected")
.SetIcon(MessageBoxIcon.Warning)
.SetMainInstruction("World database not connected")
.SetContent(
"You are trying to execute world query, but world database is not connected.\n\nEnsure you have correct world database data in settings.")
.WithOkButton(true)
.Build());
}
}
statusBar.PublishNotification(new PlainNotification(NotificationType.Success,
"Executed query"));
});
}
catch (Exception)
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Error, "Error while executing query. Check Database Query Debug window"));
}
}, _ => worldExecutor.IsConnected || authExecutor.IsConnected);
SaveSqlCommand = new AsyncAutoCommand(async() =>
{
var(auth, world) = GenerateSql();
if (auth != null)
{
sqlUpdateService.SaveAuthUpdate(SqlSuffixName, auth);
}
if (world != null)
{
sqlUpdateService.SaveWorldUpdate(SqlSuffixName, world);
}
if (auth != null || world != null)
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Done!")
.SetContent("SQL files saved to sql/updates/")
.SetIcon(MessageBoxIcon.Information)
.WithOkButton(true)
.Build());
}
});
}
public TextDocumentViewModel(IWindowManager windowManager,
ITaskRunner taskRunner,
IStatusBar statusBar,
IMySqlExecutor mySqlExecutor,
IDatabaseProvider databaseProvider,
INativeTextDocument nativeTextDocument,
IQueryParserService queryParserService,
ISessionService sessionService,
IMessageBoxService messageBoxService)
{
Extension = "txt";
Title = "New file";
this.statusBar = statusBar;
document = nativeTextDocument;
SaveCommand = new AsyncAutoCommand(async() =>
{
var path = await windowManager.ShowSaveFileDialog($"{Extension} file|{Extension}|All files|*");
if (path != null)
{
await File.WriteAllTextAsync(path, document.ToString());
}
});
ExecuteSqlSaveSession = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
() => WrapStatusbar(async() =>
{
var query = Document.ToString();
IList <ISolutionItem>?solutionItems = null;
IList <string>?errors = null;
if (inspectQuery && sessionService.IsOpened && !sessionService.IsPaused)
{
(solutionItems, errors) = await queryParserService.GenerateItemsForQuery(query);
}
await mySqlExecutor.ExecuteSql(query);
if (solutionItems != null)
{
foreach (var item in solutionItems)
{
await sessionService.UpdateQuery(item);
}
if (errors !.Count > 0)
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Apply query")
.SetMainInstruction("Some queries couldn't be transformed into session items")
.SetContent("Details:\n\n" + string.Join("\n", errors.Select(s => " - " + s)))
.WithOkButton(true)
.Build());
}
}
}));
}, () => databaseProvider.IsConnected);
ExecuteSql = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
() => WrapStatusbar(() => mySqlExecutor.ExecuteSql(Document.ToString())));
}, () => databaseProvider.IsConnected);
}
