private bool CanLoadProperties(MetadataViewModelBase obj)
        {
            if (obj is CategoryViewModel || obj == null)
            {
                return(false);
            }

            return(!obj.Root.IsLoadingInProcess && !obj.IsBusy && obj.Root.IsConnected);
        }
        private bool CanRefresh(MetadataViewModelBase o)
        {
            if (o == null)
            {
                return(false);
            }

            return(!o.Root.IsLoadingInProcess && !o.IsBusy && o.Root.IsConnected);
        }
 private void Refresh(MetadataViewModelBase o)
 {
     o.RefreshTreeItem();
     if (o.Model.IsPropertyLoaded)
     {
         ShowProperties(o);
     }
     o.Model.Definition = string.Empty;
 }
        private async void LoadProperties(MetadataViewModelBase obj)
        {
            if (obj.Model.IsPropertyLoaded)
            {
                obj.Root.RefreshProperties(obj);
            }
            await obj.Root.LoadProperties(obj);

            ItemProperties.Clear();
            ItemProperties.AddRange(obj.Model.Properties);
        }
 private bool CanShowDefinition(MetadataViewModelBase obj)
 {
     if (obj == null)
     {
         return(false);
     }
     if (obj.Type == DbEntityEnum.Table &&
         (!obj.Model.IsChildrenLoaded(DbEntityEnum.Column).GetValueOrDefault(false) && !obj.Root.IsConnected))
     {
         return(false);
     }
     return(!(obj is CategoryViewModel) && _printerFactory.IsSupported(obj.Model) && !obj.IsBusy && !obj.Root.IsLoadingInProcess);
 }
        private async void ShowDefinition(MetadataViewModelBase obj)
        {
            obj.IsBusy = true;
            obj.Root.IsLoadingInProcess = true;
            try
            {
                if (!string.IsNullOrWhiteSpace(obj.Model.Definition))
                {
                    DefinitionText = obj.Model.Definition;
                    return;
                }
                if (obj.Type == DbEntityEnum.Table)
                {
                    if (!obj.Model.IsChildrenLoaded(null).GetValueOrDefault(false))
                    {
                        await obj.Root.LoadModel(obj, DbEntityEnum.All);
                    }
                    foreach (var child in obj.Model.Children)
                    {
                        if (!child.IsPropertyLoaded)
                        {
                            obj.Root.DbLoader.Connection.InitialCatalog = obj.Model.DataBaseName;
                            await obj.Root.DbLoader.LoadProperties(child);

                            if (obj.Root.IsDefaultDatabase)
                            {
                                obj.Root.DbLoader.Connection.InitialCatalog = string.Empty;
                            }
                        }
                    }
                }

                //get printer

                DefinitionText = obj.Model.Definition = _printerFactory.GetPrinter(obj.Model).GetDefintition(obj.Model);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                obj.IsBusy = false;
                obj.Root.IsLoadingInProcess = false;
            }
        }
        private IEnumerable <MetadataViewModelBase> FindMatchesNode(MetadataViewModelBase node, string text, DbEntityEnum mask)
        {
            if (node.Name.Contains(text) && !(node is CategoryViewModel) && mask.HasFlag(node.Type))
            {
                yield return(node);
            }

            if (node.Children.Count != 0 && !node.HasFakeChild)
            {
                foreach (var treeViewItemViewModelBase in node.Children)
                {
                    var treeViewItem = (MetadataViewModelBase)treeViewItemViewModelBase;

                    foreach (MetadataViewModelBase res in FindMatchesNode(treeViewItem, text, mask))
                    {
                        yield return(res);
                    }
                }
            }
        }