protected override async void LoadControl(object param = null)
        {
            _attribuetDescriptionService = _attribuetDescriptionService ?? App.Container.Resolve <IAttribuetDescriptionService>();
            _connectionTypeService       = _connectionTypeService ?? App.Container.Resolve <IConnectionTypeService>();

            var attirbuetsResult = await _attribuetDescriptionService.GetAllAsync();

            if (attirbuetsResult.Succeed)
            {
                Attribuets = attirbuetsResult.Value.ToObservable();
            }
            else
            {
                await ShowMessage(attirbuetsResult.ErrorMessage);
            }

            var blResult = await _connectionTypeService.GetAllAsync();

            if (blResult.Succeed)
            {
                ConfigureSideBar(blResult.Value.ToObservable());
                SideBar.SelectedItem = SideBar.Items.FirstOrDefault();
            }
            else
            {
                await ShowMessage(blResult.ErrorMessage);
            }

            SaveCommand.NotifyCanExecuteChanged();
        }
        protected override async void LoadControl(object param = null)
        {
            _nodeService           = _nodeService ?? App.Container.Resolve <INodeService>();
            _graphService          = _graphService ?? App.Container.Resolve <IGraphService>();
            _connectionService     = _connectionService ?? App.Container.Resolve <IConnectionService>();
            _connectionTypeService = _connectionTypeService ?? App.Container.Resolve <IConnectionTypeService>();

            if (_graphModels is null)
            {
                var graphResult = await _graphService.GetAllAsync();

                if (graphResult.Succeed)
                {
                    GraphModels = graphResult.Value.ToObservable();
                }
                else
                {
                    await ShowMessage(graphResult.ErrorMessage);
                }
            }

            if (_nodeModels is null)
            {
                var nodeResult = await _nodeService.GetNodesIdAndNameAsync();

                if (nodeResult.Succeed)
                {
                    NodeModels = nodeResult.Value.
                                 Select(x => new SimpleModel(x.Key, x.Value)).ToObservable();
                }
                else
                {
                    await ShowMessage(nodeResult.ErrorMessage);
                }
            }

            if (ConnectionTypes is null)
            {
                var connectionTypeResult = await _connectionTypeService.GetAllAsync();

                if (connectionTypeResult.Succeed)
                {
                    ConnectionTypes = connectionTypeResult.Value.ToObservable();
                }
                else
                {
                    await ShowMessage(connectionTypeResult.ErrorMessage);
                }
            }

            var connectionsResult = await _connectionService.GetAllByNameAndIdAsync();

            if (connectionsResult.Succeed)
            {
                ConfigureSideBar(connectionsResult.Value.ToObservable());
            }
            else
            {
                await ShowMessage(connectionsResult.ErrorMessage);
            }

            SaveCommand.NotifyCanExecuteChanged();
        }