Exemple #1
0
        private void ShowNodePublishInfo(object funcDef)
        {
            if (funcDef is List <CustomNodeDefinition> )
            {
                var fs = funcDef as List <CustomNodeDefinition>;

                foreach (var f in fs)
                {
                    var pkg = dynamoViewModel.Model.Loader.PackageLoader.GetOwnerPackage(f);

                    if (dynamoViewModel.Model.Loader.PackageLoader.GetOwnerPackage(f) != null)
                    {
                        var m = MessageBox.Show("The node is part of the dynamo package called \"" + pkg.Name +
                                                "\" - do you want to submit a new version of this package?  \n\nIf not, this node will be moved to the new package you are creating.",
                                                "Package Warning", MessageBoxButton.YesNo, MessageBoxImage.Question);

                        if (m == MessageBoxResult.Yes)
                        {
                            var pkgVm = new PackageViewModel(dynamoViewModel, pkg);
                            pkgVm.PublishNewPackageVersionCommand.Execute();
                            return;
                        }
                    }
                }

                var newPkgVm = new PublishPackageViewModel(this.dynamoViewModel);
                newPkgVm.CustomNodeDefinitions = fs;
                this.dynamoViewModel.OnRequestPackagePublishDialog(newPkgVm);
            }
            else
            {
                dynamoViewModel.Model.Logger.Log("Failed to obtain function definition from node.");
            }
        }
Exemple #2
0
        private void ShowNodePublishInfo(ICollection <Tuple <CustomNodeInfo, CustomNodeDefinition> > funcDefs)
        {
            foreach (var f in funcDefs)
            {
                var pkg = DynamoViewModel.Model.PackageLoader.GetOwnerPackage(f.Item1);

                if (DynamoViewModel.Model.PackageLoader.GetOwnerPackage(f.Item1) != null)
                {
                    var m =
                        MessageBox.Show(
                            "The node is part of the dynamo package called \"" + pkg.Name
                            + "\" - do you want to submit a new version of this package?  \n\nIf not, this node will be moved to the new package you are creating.",
                            "Package Warning",
                            MessageBoxButton.YesNo,
                            MessageBoxImage.Question);

                    if (m == MessageBoxResult.Yes)
                    {
                        var pkgVm = new PackageViewModel(DynamoViewModel, pkg);
                        pkgVm.PublishNewPackageVersionCommand.Execute();
                        return;
                    }
                }
            }

            var newPkgVm = new PublishPackageViewModel(DynamoViewModel)
            {
                CustomNodeDefinitions = funcDefs.Select(pair => pair.Item2).ToList()
            };

            DynamoViewModel.OnRequestPackagePublishDialog(newPkgVm);
        }
Exemple #3
0
        public void ReturnsSameAsInputForUnknownMessages()
        {
            var message = "Unknown error";
            var actual  = PublishPackageViewModel.TranslatePackageManagerError(message);

            Assert.AreEqual(message, actual);
        }
Exemple #4
0
        private void ShowNodePublishInfo(ICollection <Tuple <CustomNodeInfo, CustomNodeDefinition> > funcDefs)
        {
            foreach (var f in funcDefs)
            {
                var pmExtension = DynamoViewModel.Model.GetPackageManagerExtension();
                var pkg         = pmExtension.PackageLoader.GetOwnerPackage(f.Item1);

                if (pkg != null)
                {
                    var m = MessageBox.Show(String.Format(Resources.MessageSubmitSameNamePackage,
                                                          DynamoViewModel.BrandingResourceProvider.ProductName, pkg.Name),
                                            Resources.PackageWarningMessageBoxTitle,
                                            MessageBoxButton.YesNo, MessageBoxImage.Question);

                    if (m == MessageBoxResult.Yes)
                    {
                        var pkgVm = new PackageViewModel(DynamoViewModel, pkg);
                        pkgVm.PublishNewPackageVersionCommand.Execute();
                        return;
                    }
                }
            }

            var newPkgVm = new PublishPackageViewModel(DynamoViewModel)
            {
                CustomNodeDefinitions = funcDefs.Select(pair => pair.Item2).ToList()
            };

            DynamoViewModel.OnRequestPackagePublishDialog(newPkgVm);
        }
        public void AddingDyfRaisesCanExecuteChangeOnDelegateCommand()
        {
            var vm = new PublishPackageViewModel(ViewModel);

            ViewModel.OnRequestPackagePublishDialog(vm);

            //find a customnode to add to the package
            string packagedirectory = Path.Combine(TestDirectory, "pkgs");
            var    packages         = Directory.EnumerateDirectories(packagedirectory);
            var    first            = Path.GetFullPath(packages.First());
            string dyfpath          = Path.Combine(first, "dyf");
            var    customnodes      = Directory.GetFiles(dyfpath);
            var    firstnode        = customnodes.First();

            Console.WriteLine("add node at" + firstnode + "to package");

            var canExecuteChangedFired = 0;

            vm.SubmitCommand.CanExecuteChanged += ((o, e) => { canExecuteChangedFired++; });
            //now add a customnode to the package
            vm.AddFile(firstnode);

            //assert that canExecute changed was fired one time
            Assert.AreEqual(canExecuteChangedFired, 1);
        }
Exemple #6
0
        public void NewPackageVersionUpload_DoesNotThrowExceptionWhenDLLIsLoadedSeveralTimes()
        {
            string packagesDirectory = Path.Combine(TestDirectory, "pkgs");

            var pathManager = new Mock <Dynamo.Interfaces.IPathManager>();

            pathManager.SetupGet(x => x.PackagesDirectories).Returns(() => new List <string> {
                packagesDirectory
            });

            var loader = new PackageLoader(pathManager.Object);

            loader.LoadAll(new LoadPackageParams
            {
                Preferences = ViewModel.Model.PreferenceSettings
            });

            PublishPackageViewModel vm = null;
            var package = loader.LocalPackages.FirstOrDefault(x => x.Name == "Custom Rounding");

            Assert.DoesNotThrow(() =>
            {
                vm = PublishPackageViewModel.FromLocalPackage(ViewModel, package);
            });

            Assert.AreEqual(PackageUploadHandle.State.Error, vm.UploadState);
        }
 public void OnRequestPackagePublishDialog(PublishPackageViewModel vm)
 {
     if (RequestPackagePublishDialog != null)
     {
         RequestPackagePublishDialog(vm);
     }
 }
        public void SetsErrorState()
        {
            //open a dyf file and modify it
            string packagedirectory = Path.Combine(TestDirectory, "pkgs");
            var    packages         = Directory.EnumerateDirectories(packagedirectory);
            var    first            = Path.GetFullPath(packages.FirstOrDefault(x => Path.GetFileName(x).Equals("Custom Rounding")));
            string dyfpath          = Path.Combine(first, "dyf");
            var    customnodes      = Directory.GetFiles(dyfpath);
            var    firstnode        = customnodes.First();

            OpenModel(firstnode);

            //add a preset so that customnode has changes that are unsaved
            GetModel().CurrentWorkspace.AddPreset("a useless preset", "some thing that will modify the definition",
                                                  new List <Guid>()
            {
                GetModel().CurrentWorkspace.Nodes.First().GUID
            });

            Assert.IsTrue(GetModel().CurrentWorkspace.HasUnsavedChanges);

            //now try to upload this file
            var vm = new PublishPackageViewModel(this.ViewModel);

            ViewModel.OnRequestPackagePublishDialog(vm);
            //now add a customnode to the package
            vm.AddFile(firstnode);
            Console.WriteLine("add node at" + firstnode + "to package");

            vm.PublishLocallyCommand.Execute();
            //assert that we have not uploaded the file or indicated that we have
            Assert.AreNotEqual(vm.UploadState, PackageUploadHandle.State.Uploaded);
            Console.WriteLine(vm.ErrorString);
        }
        private void PublishNewPackage(bool isTestMode)
        {
            Model.RefreshCustomNodesFromDirectory(dynamoViewModel.Model.CustomNodeManager, isTestMode);
            var vm = PublishPackageViewModel.FromLocalPackage(dynamoViewModel, Model);
            vm.IsNewVersion = false;

            dynamoViewModel.OnRequestPackagePublishDialog(vm);
        }
Exemple #10
0
        public void ReturnsTranslationForPackageAlreadyExistsError()
        {
            var message  = "A package with the given name and engine already exists.";
            var actual   = PublishPackageViewModel.TranslatePackageManagerError(message);
            var expected = "A package with the given name already exists.";

            Assert.AreEqual(expected, actual);
        }
Exemple #11
0
        public void ReturnsTranslationForUserIsNotAMaintainerError()
        {
            var message  = "The user sending the new package version, DynamoTeam, is not a maintainer of the package Clockwork for Dynamo 1.x";
            var actual   = PublishPackageViewModel.TranslatePackageManagerError(message);
            var expected = "The current user, 'DynamoTeam', is not a maintainer of the package 'Clockwork for Dynamo 1.x'.";

            Assert.AreEqual(expected, actual);
        }
Exemple #12
0
        public void CanOpenPackagePublishDialogAndWindowIsOwned()
        {
            var l = new PublishPackageViewModel(dynSettings.PackageManagerClient);

            Vm.OnRequestPackagePublishDialog(l);

            AssertWindowOwnedByDynamoView <PackageManagerPublishView>();
        }
Exemple #13
0
        public void CanOpenPackagePublishDialogAndWindowIsOwned()
        {
            var l = new PublishPackageViewModel(ViewModel);

            ViewModel.OnRequestPackagePublishDialog(l);

            AssertWindowOwnedByDynamoView <PublishPackageView>();
        }
Exemple #14
0
        public void PackagePublishWindowClosesWithDynamo()
        {
            var l = new PublishPackageViewModel(ViewModel);

            ViewModel.OnRequestPackagePublishDialog(l);

            AssertWindowOwnedByDynamoView <PublishPackageView>();
            AssertWindowClosedWithDynamoView <PublishPackageView>();
        }
Exemple #15
0
        private void PublishNewPackageVersion()
        {
            this.Model.RefreshCustomNodesFromDirectory(this.dynamoViewModel.Model.CustomNodeManager);
            var vm = PublishPackageViewModel.FromLocalPackage(dynamoViewModel, this.Model);

            vm.IsNewVersion = true;

            dynamoViewModel.OnRequestPackagePublishDialog(vm);
        }
Exemple #16
0
        public void PackagePublishWindowClosesWithDynamo()
        {
            var l = new PublishPackageViewModel(dynSettings.PackageManagerClient);

            Vm.OnRequestPackagePublishDialog(l);

            AssertWindowOwnedByDynamoView <PackageManagerPublishView>();
            AssertWindowClosedWithDynamoView <PackageManagerPublishView>();
        }
Exemple #17
0
        public void CannotCreateDuplicatePackagePublishDialogs()
        {
            var l = new PublishPackageViewModel(ViewModel);

            for (var i = 0; i < 10; i++)
            {
                ViewModel.OnRequestPackagePublishDialog(l);
            }

            AssertWindowOwnedByDynamoView <PublishPackageView>();
        }
Exemple #18
0
        void _vm_RequestShowPackageManagerPublish(PublishPackageViewModel model)
        {
            if (_pubPkgView == null)
            {
                _pubPkgView         = new PackageManagerPublishView(model);
                _pubPkgView.Closed += (sender, args) => _pubPkgView = null;
                _pubPkgView.Show();
            }

            _pubPkgView.Focus();
        }
Exemple #19
0
        public void CannotCreateDuplicatePackagePublishDialogs()
        {
            var l = new PublishPackageViewModel(dynSettings.PackageManagerClient);

            for (var i = 0; i < 10; i++)
            {
                Vm.OnRequestPackagePublishDialog(l);
            }

            AssertWindowOwnedByDynamoView <PackageManagerPublishView>();
        }
        /// <summary>
        ///     Class constructor
        /// </summary>
        public DynamoController(ExecutionEnvironment env, Type viewModelType, string context)
        {
            dynSettings.Controller = this;

            this.Context = context;

            //Start heartbeat reporting
            Services.InstrumentationLogger.Start();

            //create the view model to which the main window will bind
            //the DynamoModel is created therein
            this.DynamoViewModel = (DynamoViewModel)Activator.CreateInstance(viewModelType, new object[] { this });

            // custom node loader
            string directory   = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            string pluginsPath = Path.Combine(directory, "definitions");

            CustomNodeManager = new CustomNodeManager(pluginsPath);

            SearchViewModel                  = new SearchViewModel();
            PackageManagerClient             = new PackageManagerClient();
            dynSettings.PackageManagerClient = PackageManagerClient;
            PublishPackageViewModel          = new PublishPackageViewModel(PackageManagerClient);

            dynSettings.PackageLoader = new PackageLoader();

            dynSettings.PackageLoader.DoCachedPackageUninstalls();
            dynSettings.PackageLoader.LoadPackages();

            FSchemeEnvironment = env;

            DynamoViewModel.Model.CurrentSpace.X = DynamoView.CANVAS_OFFSET_X;
            DynamoViewModel.Model.CurrentSpace.Y = DynamoView.CANVAS_OFFSET_Y;

            dynSettings.Controller.DynamoViewModel.Log(String.Format(
                                                           "Dynamo -- Build {0}",
                                                           Assembly.GetExecutingAssembly().GetName().Version));

            DynamoLoader.ClearCachedAssemblies();
            DynamoLoader.LoadBuiltinTypes();

            //run tests
            if (FScheme.RunTests(dynSettings.Controller.DynamoViewModel.Log))
            {
                dynSettings.Controller.DynamoViewModel.Log("All Tests Passed. Core library loaded OK.");
            }

            NodeSubmittedForRendering += new EventHandler(Controller_NodeSubmittedForRendering);
            NodeRemovedFromRendering  += new EventHandler(Controller_NodeRemovedFromRendering);
        }
Exemple #21
0
        void _vm_RequestRequestPackageManagerPublish(PublishPackageViewModel model)
        {
            if (_pubPkgView == null)
            {
                _pubPkgView         = new PackageManagerPublishView(model);
                _pubPkgView.Closed += (sender, args) => _pubPkgView = null;
                _pubPkgView.Show();

                if (_pubPkgView.IsLoaded && this.IsLoaded)
                {
                    _pubPkgView.Owner = this;
                }
            }

            _pubPkgView.Focus();
        }
        public void CanPublishLateInitializedJsonCustomNode()
        {
            string nodePath = Path.Combine(TestDirectory, "core", "CustomNodes", "jsonCustomNode.dyf");

            //add this customNode to the package without opening it.
            var vm = new PublishPackageViewModel(this.ViewModel);

            ViewModel.OnRequestPackagePublishDialog(vm);
            vm.AddFile(nodePath);

            //assert we don't raise any exceptions during getAllFiles
            //- this will check the customNode has no unsaved changes.

            Assert.AreEqual(1, vm.CustomNodeDefinitions.Count);
            Assert.DoesNotThrow(() => { vm.GetAllFiles(); });
            Assert.AreEqual(nodePath, vm.GetAllFiles().First());
        }
        public void NewPackageVersionUpload_DoesNotThrowExceptionWhenDLLIsLoadedSeveralTimes()
        {
            string packagesDirectory = Path.Combine(TestDirectory, "pkgs");

            var loader = new PackageLoader(packagesDirectory);

            loader.LoadAll(new LoadPackageParams
            {
                Preferences = ViewModel.Model.PreferenceSettings
            });

            PublishPackageViewModel vm = null;

            Assert.DoesNotThrow(() =>
            {
                vm = PublishPackageViewModel.FromLocalPackage(ViewModel, loader.LocalPackages.First());
            });

            Assert.AreEqual(PackageUploadHandle.State.Error, vm.UploadState);
        }
Exemple #24
0
        void DynamoViewModelRequestRequestPackageManagerPublish(PublishPackageViewModel model)
        {
            if (_pubPkgView == null)
            {
                _pubPkgView = new PublishPackageView(model)
                {
                    Owner = this,
                    WindowStartupLocation = WindowStartupLocation.CenterOwner
                };
                _pubPkgView.Closed += (sender, args) => _pubPkgView = null;
                _pubPkgView.Show();

                if (_pubPkgView.IsLoaded && IsLoaded)
                {
                    _pubPkgView.Owner = this;
                }
            }

            _pubPkgView.Focus();
        }
        [Category("TechDebt")] //when a package is published - it does not load its customNodes. This may be intentional.
        public void PublishingACustomNodeSetsPackageInfoCorrectly_()
        {
            var cnworkspace = this.GetModel().CustomNodeManager.CreateCustomNode("nodeToBePublished", "somecategory", "publish this node") as CustomNodeWorkspaceModel;
            var inputNode   = new Symbol();

            inputNode.InputSymbol = "input;";
            cnworkspace.AddAndRegisterNode(inputNode);

            var tempPath = Path.Combine(TempFolder, "nodeToBePublished.dyf");

            cnworkspace.Save(tempPath, false, this.GetModel().EngineController);

            Assert.IsNull(GetModel().CustomNodeManager.NodeInfos[cnworkspace.CustomNodeId].PackageInfo);
            Assert.IsFalse(GetModel().CustomNodeManager.NodeInfos[cnworkspace.CustomNodeId].IsPackageMember);

            //now lets publish this node as a local package.
            var newPkgVm = new PublishPackageViewModel(ViewModel)
            {
                CustomNodeDefinitions = new List <CustomNodeDefinition>()
                {
                    cnworkspace.CustomNodeDefinition
                }
            };

            newPkgVm.Name         = "PublishingACustomNodeSetsPackageInfoCorrectly";
            newPkgVm.MajorVersion = "0";
            newPkgVm.MinorVersion = "0";
            newPkgVm.BuildVersion = "1";
            newPkgVm.PublishLocallyCommand.Execute();

            Assert.IsTrue(GetModel().GetPackageManagerExtension().PackageLoader.LocalPackages.Any
                              (x => x.Name == "PublishingACustomNodeSetsPackageInfoCorrectly" && x.Loaded == true && x.LoadedCustomNodes.Count == 1));


            Assert.AreEqual(new PackageInfo("PublishingACustomNodeSetsPackageInfoCorrectly", new Version(0, 0, 1))
                            , GetModel().CustomNodeManager.NodeInfos[cnworkspace.CustomNodeId].PackageInfo);
            Assert.IsFalse(GetModel().CustomNodeManager.NodeInfos[cnworkspace.CustomNodeId].IsPackageMember);
        }
Exemple #26
0
        private void ShowNodePublishInfo()
        {
            var newPkgVm = new PublishPackageViewModel(DynamoViewModel);

            DynamoViewModel.OnRequestPackagePublishDialog(newPkgVm);
        }
Exemple #27
0
        private void PublishExecute()
        {
            if (!NetworkInterface.GetIsNetworkAvailable()) {
                UIServices.Show(Resources.NoNetworkConnection, MessageLevel.Warning);
                return;
            }

            if (!this.IsValid) {
                UIServices.Show(Resources.PackageHasNoFile, MessageLevel.Warning);
                return;
            }

            string storedKey = _settingsManager.ReadApiKeyFromSettingFile();
            var publishPackageViewModel = new PublishPackageViewModel(_settingsManager.PublishPackageLocation, this) {
                PublishKey = storedKey
            };

            _uiServices.OpenPublishDialog(publishPackageViewModel);

            string newKey = publishPackageViewModel.PublishKey;
            if (!String.IsNullOrEmpty(newKey)) {
                _settingsManager.WriteApiKeyToSettingFile(newKey);
            }
        }
        private void PublishExecute()
        {
            if (!NetworkInterface.GetIsNetworkAvailable())
            {
                UIServices.Show(Resources.NoNetworkConnection, MessageLevel.Warning);
                return;
            }

            // validate the package to see if there is any error before actually creating the package.
            PackageIssue firstIssue = Validate().FirstOrDefault(p => p.Level == PackageIssueLevel.Error);
            if (firstIssue != null)
            {
                UIServices.Show(
                    Resources.PackageCreationFailed
                    + Environment.NewLine
                    + Environment.NewLine
                    + firstIssue.Description,
                    MessageLevel.Warning);
                return;
            }

            using (var mruSourceManager = new MruPackageSourceManager(
                new PublishSourceSettings(_settingsManager)))
            {
                var publishPackageViewModel = new PublishPackageViewModel(
                    mruSourceManager,
                    _settingsManager,
                    this);
                _uiServices.OpenPublishDialog(publishPackageViewModel);
            }
        }