private static TreeNodeViewModel GetNamespaceNode(TreeNodeViewModel root, string namespacePath)
{
if (string.IsNullOrWhiteSpace(namespacePath))
{
throw new NullReferenceException(nameof(namespacePath));
}
string[] namespaces = namespacePath.Split('.');
TreeNodeViewModel parentNode = root;
TreeNodeViewModel currentNode = null;
foreach (string name in namespaces)
{
currentNode = parentNode.TreeNodes.Where(n => n.NodeText == name).FirstOrDefault();
if (currentNode == null)
{
TreeNodeViewModel namespaceNode = new TreeNodeViewModel()
{
IsExpanded = true,
NodePayload = null,
NodeText = name
};
parentNode.TreeNodes.Add(namespaceNode);
parentNode = namespaceNode;
}
else
{
parentNode = currentNode;
}
}
return(parentNode);
}
private void CreateRouteNodesFromDatabase(TreeNodeViewModel rootNode)
{
DatabaseServer server = rootNode.GetAncestorPayload <DatabaseServer>();
IMessagingService messaging = Services.GetService <IMessagingService>();
ConfigureMessagingService(messaging, server, null);
if (!messaging.DaJetMQExists())
{
return;
}
DatabaseInfo database = new DatabaseInfo()
{
Name = DAJET_MQ_DATABASE_NAME
};
ConfigureMessagingService(messaging, server, database);
List <RouteInfo> routes = messaging.SelectRoutes(out string errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
_ = MessageBox.Show(errorMessage, "DaJet", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
TreeNodeViewModel routeNode;
foreach (RouteInfo route in routes)
{
routeNode = CreateRouteNode(rootNode, route);
rootNode.TreeNodes.Add(routeNode);
}
}
private TreeNodeViewModel CreateWebServerNode(TreeNodeViewModel parentNode, WebServerSettings settings)
{
TreeNodeViewModel treeNode = new TreeNodeViewModel()
{
IsExpanded = false,
NodeIcon = WEB_SERVICE_ICON,
NodeText = settings.Name,
NodeToolTip = settings.HttpHost,
NodePayload = settings
};
treeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Configure settings",
MenuItemIcon = SETTINGS_FILE_ICON,
MenuItemCommand = new RelayCommand(ConfigureWebServer),
MenuItemPayload = treeNode
});
treeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Create new catalog",
MenuItemIcon = ADD_CATALOG_ICON,
MenuItemCommand = new RelayCommand(CreateWebCatalog),
MenuItemPayload = treeNode
});
treeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Create new script",
MenuItemIcon = DATABASE_SCRIPT_ICON,
MenuItemCommand = new RelayCommand(CreateWebScript),
MenuItemPayload = treeNode
});
parentNode.TreeNodes.Add(treeNode);
return treeNode;
}
public void BuildTreeNode(object model, out TreeNodeViewModel treeNode)
{
treeNode = new TreeNodeViewModel()
{
IsExpanded = true,
NodeIcon = MODULE_ICON,
NodeText = MODULE_NAME,
NodeToolTip = MODULE_TOOLTIP,
NodePayload = Module
};
treeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Attach server",
MenuItemIcon = ATTACH_SERVER_ICON,
MenuItemCommand = new RelayCommand(AttachServer),
MenuItemPayload = treeNode
});
treeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "About...",
MenuItemIcon = MODULE_ICON,
MenuItemCommand = new RelayCommand(ShowAboutWindow),
MenuItemPayload = treeNode
});
ConfigureNodes(treeNode);
}
private void AttachContractsTreeNodes(Assembly contract, TreeNodeViewModel parentNode)
{
TreeNodeViewModel contractNode = new TreeNodeViewModel()
{
IsExpanded = false,
NodeIcon = CONTRACTS_ICON,
NodeText = $"{contract.GetName().Name} ({contract.GetName().Version.ToString()})",
NodeToolTip = null,
NodePayload = contract
};
foreach (Type type in contract.GetTypes())
{
TreeNodeViewModel typeNode = new TreeNodeViewModel()
{
IsExpanded = false,
NodeIcon = JSON_SCRIPT_ICON,
NodeText = type.Name,
NodeToolTip = type.FullName,
NodePayload = type
};
typeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "View JSON object",
MenuItemIcon = JSON_SCRIPT_ICON,
MenuItemCommand = new RelayCommand(ViewDummyObjectCommand),
MenuItemPayload = typeNode
});
contractNode.TreeNodes.Add(typeNode);
}
parentNode.TreeNodes.Add(contractNode);
}
private void AttachWebServer(object parameter)
{
if (!(parameter is TreeNodeViewModel parentNode)) return;
InputStringDialog dialog = new InputStringDialog()
{
Title = "Web server name"
};
_ = dialog.ShowDialog();
if (dialog.Result == null) return;
string catalogName = Path.Combine(Module.WebServersCatalogPath, (string)dialog.Result);
DirectoryInfo catalog = new DirectoryInfo(catalogName);
if (catalog.Exists)
{
MessageBox.Show($"Catalog \"{catalogName}\" already exists !", "1C#", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
catalog.Create();
WebServerSettings settings = new WebServerSettings()
{
Name = catalog.Name
};
string settingsFilePath = Path.Combine(catalog.FullName, SETTINGS_FILE_NAME);
SaveWebServerSettings(settings, settingsFilePath);
TreeNodeViewModel treeNode = CreateWebServerNode(parentNode, settings);
treeNode.IsExpanded = true;
}
private void AddDatabaseCommand(object parameter)
{
if (!(parameter is TreeNodeViewModel treeNode))
{
return;
}
if (!(treeNode.NodePayload is DatabaseServer server))
{
return;
}
IMetadataService metadata = Services.GetService <IMetadataService>();
List <DatabaseInfo> databases = metadata.GetDatabases(server);
if (databases.Count == 0)
{
MessageBox.Show("Список выбора баз данных пуст.",
"DaJet", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
SelectDatabaseWindow dialog = new SelectDatabaseWindow(databases);
_ = dialog.ShowDialog();
if (dialog.Result == null)
{
return;
}
if (DatabaseNameExists(server, dialog.Result))
{
MessageBox.Show("База данных " + dialog.Result.Name + " уже добавлена.",
"DaJet", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
DatabaseFormWindow form = new DatabaseFormWindow(dialog.Result);
_ = form.ShowDialog();
if (DatabaseNameExists(server, dialog.Result))
{
MessageBox.Show("База данных " + dialog.Result.Name + " уже добавлена.",
"DaJet", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
server.Databases.Add(dialog.Result);
SaveMetadataSettings();
InitializeMetadata(server, dialog.Result);
TreeNodeViewModel databaseNode = CreateDatabaseTreeNode(treeNode, dialog.Result);
treeNode.TreeNodes.Add(databaseNode);
treeNode.IsExpanded = true;
databaseNode.IsSelected = true;
InitializeDatabaseTreeNodes(databaseNode);
}
private void CreateWebCatalog(object parameter)
{
if (!(parameter is TreeNodeViewModel parentNode)) return;
// ask for catalog name
InputStringDialog dialog = new InputStringDialog()
{
Title = "Catalog name"
};
_ = dialog.ShowDialog();
if (dialog.Result == null) return;
string catalogName = (string)dialog.Result;
string catalogPath;
if (parentNode.NodePayload is WebServerSettings)
{
catalogPath = Path.Combine(parentNode.NodeText, catalogName);
}
else
{
catalogPath = Path.Combine((string)parentNode.NodePayload, catalogName);
}
string catalogFullName = Path.Combine(Module.WebServersCatalogPath, catalogPath);
if (Directory.Exists(catalogFullName))
{
MessageBox.Show($"Catalog \"{catalogPath}\" already exists !", "1C#", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
// create direcitory on the disk
_ = Directory.CreateDirectory(catalogFullName);
TreeNodeViewModel treeNode = CreateCatalogNode(parentNode, catalogName);
treeNode.IsExpanded = true;
parentNode.IsExpanded = true;
}
private void SaveScriptSourceCode()
{
IScriptingService scripting = Services.GetService <IScriptingService>();
TSqlFragment syntaxTree = scripting.ParseScript(ScriptCode, out IList <ParseError> errors);
if (errors.Count > 0)
{
ShowParseErrors(errors);
throw new InvalidOperationException("Saving script failed: incorrect syntax.");
}
ScriptingController controller = Services.GetService <ScriptingController>();
string catalogName = controller.GetScriptsCatalogName(MyServer, MyDatabase, ScriptType);
if (controller.ScriptFileExists(catalogName, Name))
{
controller.SaveScriptFile(catalogName, Name, ScriptCode);
}
else
{
if (controller.GetScriptTreeNodeByName(MyServer, MyDatabase, ScriptType, Name) != null)
{
throw new InvalidOperationException($"Script node \"{Name}\" already exists!");
}
controller.SaveScriptFile(catalogName, Name, ScriptCode);
}
MainWindowViewModel mainWindow = Services.GetService <MainWindowViewModel>();
TreeNodeViewModel treeNode = mainWindow.GetTreeNodeByPayload(mainWindow.MainTreeRegion.TreeNodes, this);
if (treeNode == null)
{
controller.CreateScriptTreeNode(this);
}
}
private void SaveWebServerScript(WebServerSettings settings, string json)
{
string catalogPath = Path.Combine(Module.WebServersCatalogPath, settings.Name);
DirectoryInfo catalog = new DirectoryInfo(catalogPath);
if (!catalog.Exists)
{
MessageBox.Show($"Catalog \"{catalogPath}\" is not found !", "1C#", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
string settingsFilePath = Path.Combine(catalog.FullName, SETTINGS_FILE_NAME);
if (!File.Exists(settingsFilePath))
{
MessageBox.Show($"File \"{settingsFilePath}\" is not found !", "1C#", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
WebServerSettings newSettings = JsonSerializer.Deserialize<WebServerSettings>(json);
string newCatalogPath = Path.Combine(Module.WebServersCatalogPath, newSettings.Name);
if (Directory.Exists(newCatalogPath))
{
MessageBox.Show($"Catalog \"{newCatalogPath}\" already exists !", "1C#", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
settings.Name = newSettings.Name;
settings.HttpHost = newSettings.HttpHost;
SaveWebServerSettings(settings, settingsFilePath);
Directory.Move(catalogPath, newCatalogPath);
TreeNodeViewModel treeNode = FindTreeNode(settings);
if (treeNode != null)
{
treeNode.NodeText = settings.Name;
treeNode.NodeToolTip = settings.HttpHost;
}
}
private Type SelectTypeReference(ISyntaxNode context, Type scopeType, Visual control)
{
// get scope provider
IScopeProvider scopeProvider = SyntaxTreeManager.GetScopeProvider(scopeType);
if (scopeProvider == null)
{
return(scopeType);
} // scope provider is not registered
// get references in the scope
IEnumerable <Type> scope = scopeProvider.Scope(context, scopeType);
if (scope == null || scope.Count() == 0)
{
return(scopeType);
} // scope provider found nothing
// build Type selection tree
TreeNodeViewModel viewModel = SyntaxNodeExtensions.BuildTypeSelectionTree(scope);
// open dialog window
PopupWindow dialog = new PopupWindow(control, viewModel);
_ = dialog.ShowDialog();
if (dialog.Result == null)
{
return(null);
} // user made no choice
// return selected reference
return(dialog.Result.NodePayload as Type);
}
public MainEncyclopedia()
{
InitializeComponent();
LoadEncyclopedia();
var n1 = new TreeNodeViewModel("General");
n1.PropertyChanged += UpdateTextBox;
using (var context = new Db1Entities())
{
var raceList = ( from c in context.Aliens select c ).ToList();
var raceNodeList = new List<TreeNodeViewModel>();
foreach (var t1 in raceList.Select(item => new TreeNodeViewModel(item.Name)))
{
t1.PropertyChanged += UpdateTextBox;
raceNodeList.Add(t1);
}
var n2 = new TreeNodeViewModel("Races", raceNodeList, null);
n2.PropertyChanged += UpdateTextBox;
var settings = new SettingsViewModel(new[]
{
n1, n2
});
DataContext = settings;
}
}
private IAssemblyConcept SelectAssemblyReference(ISyntaxNode concept, string propertyName, Visual control)
{
// get scope provider
IScopeProvider scopeProvider = SyntaxTreeManager.GetScopeProvider(concept.GetType());
if (scopeProvider == null)
{
return(null);
}
// get references in the scope
IEnumerable <ISyntaxNode> scope = scopeProvider.Scope(concept, propertyName);
if (scope == null || scope.Count() == 0)
{
return(null);
}
// build tree view
TreeNodeViewModel viewModel = SyntaxNodeExtensions.BuildAssemblySelectorTree(scope);
// open dialog window
PopupWindow dialog = new PopupWindow(control, viewModel);
_ = dialog.ShowDialog();
if (dialog.Result == null)
{
return(null);
}
// return selected reference
return(dialog.Result.NodePayload as IAssemblyConcept);
}
public MainEncyclopedia()
{
InitializeComponent();
LoadEncyclopedia();
var n1 = new TreeNodeViewModel("General");
n1.PropertyChanged += UpdateTextBox;
using (var context = new Db1Entities())
{
var raceList = (from c in context.Aliens select c).ToList();
var raceNodeList = new List <TreeNodeViewModel>();
foreach (var t1 in raceList.Select(item => new TreeNodeViewModel(item.Name)))
{
t1.PropertyChanged += UpdateTextBox;
raceNodeList.Add(t1);
}
var n2 = new TreeNodeViewModel("Races", raceNodeList, null);
n2.PropertyChanged += UpdateTextBox;
var settings = new SettingsViewModel(new[]
{
n1, n2
});
DataContext = settings;
}
}
//-- Bygger træet for den pågældne forbindelse
public TreeNodeViewModel BuildTree(OdbcConnection connection)
{
//-- 1. Root node
var rootNode = new TreeNodeViewModel
{
Name = connection.DataSource + " - Oracle",
Children = new ObservableCollection <TreeNodeViewModel>()
};
//--- Tilføjer noderne
//-- Er lavet unikt pga. arbejdsmarkedets standarder er anderledes end iflg. oracle.
//- Dvs. Der er for mange ting, end det relevante til visning.
try
{
rootNode.Children.Add(CustomNode(connection, "Triggers", "SELECT * FROM USER_TRIGGERS"));
rootNode.Children.Add(CustomNode(connection, "Tables", "SELECT * FROM USER_tables"));
rootNode.Children.Add(CustomNode(connection, "Indexes", "select * from user_indexes"));
rootNode.Children.Add(CustomNode(connection, "Views", "select * from user_views"));
}
catch (Exception)
{
//-- Do nothing
}
//-- Tilføj rootNode i TreeNodeItemsContainer via DataBaseConnectionTreeViewModel
return(rootNode);
}
private static void BuildConceptSelectorTree(TreeNodeViewModel root, List <Type> types, Type rootType)
{
if (types.Count == 0)
{
return;
}
Type baseType;
TreeNodeViewModel currentNode;
Stack <Type> stack = new Stack <Type>();
foreach (Type type in types)
{
baseType = type;
currentNode = root;
while (baseType != null)
{
if (baseType == rootType)
{
stack.Push(baseType);
break;
}
stack.Push(baseType);
baseType = baseType.BaseType;
}
while (stack.Count > 0)
{
baseType = stack.Pop();
currentNode = AddNodeToTypeSelectorTree(currentNode, baseType);
}
}
}
public static TreeNodeViewModel BuildTypeSelectionTree(IEnumerable <Type> types)
{
TreeNodeViewModel root = new TreeNodeViewModel();
foreach (Type type in types)
{
TreeNodeViewModel namespaceNode = GetNamespaceNode(root, type.Namespace);
if (namespaceNode == null)
{
return(root);
}
TreeNodeViewModel typeNode = new TreeNodeViewModel()
{
IsExpanded = false,
NodePayload = type,
NodeText = type.Name
};
foreach (Type nestedType in type.GetNestedTypes())
{
typeNode.TreeNodes.Add(new TreeNodeViewModel()
{
IsExpanded = false,
NodePayload = nestedType,
NodeText = nestedType.Name
});
}
namespaceNode.TreeNodes.Add(typeNode);
}
return(root);
}
private void CreateScriptNodes(TreeNodeViewModel parentNode, DatabaseInfo database)
{
foreach (MetaScript script in database.Scripts)
{
TreeNodeViewModel node = CreateScriptNode(parentNode, script);
parentNode.TreeNodes.Add(node);
}
}
private void VisitRecursively(TSqlFragment node, TreeNodeViewModel result)
{
if (node == null)
{
return;
}
VisitChildren(node, VisitNode(node, result));
}
public static TreeNodeViewModel Add(this IList <TreeNodeViewModel> nodes, string text, string key = "", string imageKey = "", string selectedImageKey = "", int selectedImageIndex = -1)
{
TreeNodeViewModel node = new TreeNodeViewModel();
node.Text = text;
node.Key = key;
nodes.Add(node);
return(nodes.Last());
}
public void Build(TSqlFragment fragment, out TreeNodeViewModel treeNode)
{
treeNode = new TreeNodeViewModel()
{
NodeText = "ROOT"
};
VisitRecursively(fragment, treeNode);
// VisitIteratively using queue ...
}
private void AttachContracts(TreeNodeViewModel parentNode)
{
var provider = Module.GetProvider <ContractsProvider>();
foreach (Assembly contract in provider.GetContracts())
{
AttachContractsTreeNodes(contract, parentNode);
}
}
private static void InnerFinding(this TreeNodeViewModel node, Predicate <TreeNodeViewModel> predicate,
bool searchAllChildren, List <TreeNodeViewModel> results)
{
for (int i = 0; i < node.Items.Count; i++)
{
var child = node.Items[i];
InnerSearchInsideChild(predicate, searchAllChildren, results, child);
}
}
public void SetUp()
{
_column = new ColumnBuilder().Build();
_filter = new FakeFilter();
_filterTreeNode = new FakeFilterTreeNode("Test", _column, _filter);
_mockService = new Mock <IMessageBus>();
_viewModel = new TreeNodeViewModel(
_filterTreeNode,
_mockService.Object);
}
private void CreateWebServerNodesFromSettings(TreeNodeViewModel rootNode)
{
TreeNodeViewModel serverNode;
foreach (WebServer server in WebSettings.WebServers)
{
serverNode = CreateWebServerNode(rootNode, server);
rootNode.TreeNodes.Add(serverNode);
}
}
private void FixXAndY(TreeNodeViewModel treeNode)
{
treeNode.X += this.rootOffsetX;
treeNode.Y += this.rootOffsetY;
foreach (var childId in treeNode.Children)
{
TreeNodeViewModel child = this.treeViewModel.Get(childId);
this.FixXAndY(child);
}
}
private void CreateDatabaseServerNodes(TreeNodeViewModel parentNode, WebServer server)
{
foreach (DatabaseServer dataServer in server.DatabaseServers)
{
TreeNodeViewModel node = CreateDatabaseServerNode(parentNode, dataServer);
parentNode.TreeNodes.Add(node);
CreateDatabaseNodes(node, dataServer);
}
}
private void CreateDatabaseNodes(TreeNodeViewModel parentNode, DatabaseServer server)
{
foreach (DatabaseInfo database in server.Databases)
{
TreeNodeViewModel node = CreateDatabaseNode(parentNode, database);
parentNode.TreeNodes.Add(node);
CreateScriptNodes(node, database);
}
}
public NamespaceViewModel(NamespaceModel namespaceModel, TreeNodeViewModel parent)
: base(namespaceModel.Name, parent)
{
NamespaceModel = namespaceModel;
if (NamespaceModel.Namespaces?.Count > 0 || NamespaceModel?.Types.Count > 0)
{
AddDummyChild();
}
}
private TreeNodeViewModel CreateQueuesTreeNode(TreeNodeViewModel serverNode)
{
ITreeNodeController controller = Services.GetService <MessagingController>();
if (controller == null)
{
return(null);
}
return(controller.CreateTreeNode(serverNode));
}
private TreeNodeViewModel CreateScriptsTreeNode(TreeNodeViewModel databaseNode)
{
ITreeNodeController controller = Services.GetService <ScriptingController>();
if (controller == null)
{
return(null);
}
return(controller.CreateTreeNode(databaseNode));
}
void ChangeFocus(TreeNodeViewModel node)
{
if (Tree != null)
{
Tree.ScrollIntoView(node);
var item = Tree.ItemContainerGenerator.ContainerFromItem(node) as TreeListItem;
if (item != null)
item.Focus();
else
Tree.PendingFocusNode = node;
}
}
private void OnPreviewDragOver(object sender, DragEventArgs e)
{
if (_dropObject != null)
{
FindTarget(e);
HandleDragScrolling(e);
HandleDragExpanding(e);
UpdateInsertAdorner(e);
bool _shiftPressed = (e.KeyStates & DragDropKeyStates.ShiftKey) != 0;
e.Effects = TreeNodeDropCommand != null && TreeNodeDropCommand.CanExecute(_dropObject) ? (_shiftPressed ? DragDropEffects.Copy : DragDropEffects.Move) : DragDropEffects.None;
_targetElement = null;
e.Handled = true;
}
}
private void SetFocus(object treeNode)
{
if (IsKeyboardFocused || IsKeyboardFocusWithin)
{
var item = ItemContainerGenerator.ContainerFromItem(treeNode) as TreeListItem;
if (item != null)
item.Focus();
else
PendingFocusNode = treeNode as TreeNodeViewModel;
}
}
private void ItemContainerGeneratorStatusChanged(object sender, EventArgs e)
{
if (ItemContainerGenerator.Status == GeneratorStatus.ContainersGenerated && PendingFocusNode != null)
{
var item = ItemContainerGenerator.ContainerFromItem(PendingFocusNode) as TreeListItem;
if (item != null)
item.Focus();
PendingFocusNode = null;
}
}
private ListViewItem GetItemContainer(TreeNodeViewModel item)
{
if (item == null)
return null;
return TreeList.ItemContainerGenerator.ContainerFromItem(item) as ListViewItem;
}
private void FindTarget(DragEventArgs e)
{
var point = e.GetPosition(TreeList);
var obj = TreeList.InputHitTest(point) as DependencyObject;
while (obj != null && !(obj is ListViewItem) && !(obj is ListView))
obj = VisualTreeHelper.GetParent(obj);
var container = obj as ListViewItem;
_targetElement = container == null ? null : ((ItemsControl)ItemsControl.ItemsControlFromItemContainer(container)).ItemContainerGenerator.ItemFromContainer(container) as TreeNodeViewModel;
if (container != _target)
{
_dragExpandWaitCounter = 0;
_target = container;
}
_dropObject.DataObject = e.Data;
_dropObject.Target = _targetElement;
}
