public void ScanPackageDirectoryReturnsPackageForValidDirectory()
{
var pkgDir = Path.Combine(PackagesDirectory, "Custom Rounding");
var loader = ViewModel.Model.PackageLoader;
var pkg = loader.ScanPackageDirectory(pkgDir);
Assert.IsNotNull(pkg);
Assert.AreEqual("CAAD_RWTH", pkg.Group);
Assert.AreEqual("Custom Rounding", pkg.Name);
Assert.AreEqual("0.1.4", pkg.VersionName);
Assert.AreEqual("This collection of nodes allows rounding, rounding up and rounding down to a specified precision.", pkg.Description);
Assert.AreEqual("Round Up To Precision - Rounds a number *up* to a specified precision, Round Down To Precision - "
+ "Rounds a number *down* to a specified precision, Round To Precision - Rounds a number to a specified precision", pkg.Contents);
Assert.AreEqual("0.5.2.10107", pkg.EngineVersion);
var loadPackageParams = new LoadPackageParams
{
Loader = ViewModel.Model.Loader,
LibraryServices = ViewModel.Model.EngineController.LibraryServices,
Context = ViewModel.Model.Context,
IsTestMode = true,
CustomNodeManager = ViewModel.Model.CustomNodeManager
};
pkg.LoadIntoDynamo(loadPackageParams, ViewModel.Model.Logger);
Assert.AreEqual(3, pkg.LoadedCustomNodes.Count);
}
public void DisablingCustomPackagePathsCorrectlyDisablesLoading()
{
//setup clean loader where std lib is a custom package path
var loader = new PackageLoader(new[] { StandardLibraryTestDirectory }, string.Empty);
var settings = new PreferenceSettings();
//disable custom package paths
settings.DisableCustomPackageLocations = true;
settings.CustomPackageFolders = new List <string>()
{
StandardLibraryTestDirectory
};
var loaderParams = new LoadPackageParams()
{
PathManager = CurrentDynamoModel.PathManager,
Preferences = settings
};
//invoke the load
loader.LoadAll(loaderParams);
//assert the package in the custom package path was not loaded
Assert.IsFalse(loader.LocalPackages.Any(x => x.BinaryDirectory.Contains("SignedPackage2")));
Assert.AreEqual(0, loader.LocalPackages.Count());
}
public PackagePathViewModel(PackageLoader loader, LoadPackageParams loadParams, CustomNodeManager customNodeManager)
{
this.packageLoader = loader;
this.loadPackageParams = loadParams;
this.customNodeManager = customNodeManager;
InitializeRootLocations();
InitializeCommands();
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings setting)
{
PackageLoader loader = new PackageLoader(setting.CustomPackageFolders);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
PathManager = Model.PathManager
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return new PackagePathViewModel(loader, loadParams, customNodeManager);
}
public void IfPathsAreUnchangedPackagesAreNotReloaded()
{
var count = 0;
var setting = new PreferenceSettings()
{
CustomPackageFolders = { @"Z:\" }
};
var pathManager = new Mock <IPathManager>();
pathManager.SetupGet(x => x.PackagesDirectories).Returns(
() => setting.CustomPackageFolders);
PackageLoader loader = new PackageLoader(pathManager.Object);
loader.PackagesLoaded += Loader_PackagesLoaded;
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
var vm = new PackagePathViewModel(loader, loadParams, customNodeManager);
vm.SaveSettingCommand.Execute(null);
//should not have reloaded anything.
Assert.AreEqual(0, count);
var path = string.Empty;
vm.RequestShowFileDialog += (sender, args) => { args.Path = path; };
path = Path.Combine(GetTestDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)), "pkgs");
//add the new path
vm.AddPathCommand.Execute(null);
//save the new path
vm.SaveSettingCommand.Execute(null);
//should have loaded something.
Assert.AreEqual(10, count);
//commit the paths again.
vm.SaveSettingCommand.Execute(null);
//should not have loaded anything.
Assert.AreEqual(10, count);
void Loader_PackagesLoaded(System.Collections.Generic.IEnumerable <Assembly> obj)
{
count = count + obj.Count();
}
loader.PackagesLoaded -= Loader_PackagesLoaded;
}
public PackagePathViewModel(PackageLoader loader, LoadPackageParams loadParams, CustomNodeManager customNodeManager)
{
this.packageLoader = loader;
this.loadPackageParams = loadParams;
this.customNodeManager = customNodeManager;
RootLocations = new ObservableCollection <string>(setting.CustomPackageFolders);
AddPathCommand = new DelegateCommand(p => InsertPath());
DeletePathCommand = new DelegateCommand(p => RemovePathAt((int)p), CanDelete);
MovePathUpCommand = new DelegateCommand(p => SwapPath((int)p, ((int)p) - 1), CanMoveUp);
MovePathDownCommand = new DelegateCommand(p => SwapPath((int)p, ((int)p) + 1), CanMoveDown);
UpdatePathCommand = new DelegateCommand(p => UpdatePathAt((int)p));
SaveSettingCommand = new DelegateCommand(CommitChanges);
SelectedIndex = 0;
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings setting)
{
var pathManager = new Mock <IPathManager>();
pathManager.SetupGet(x => x.PackagesDirectories).Returns(
() => setting.CustomPackageFolders);
PackageLoader loader = new PackageLoader(pathManager.Object);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return(new PackagePathViewModel(loader, loadParams, customNodeManager));
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings settings)
{
var pathManager = new PathManager(new PathManagerParams {
})
{
Preferences = settings
};
PackageLoader loader = new PackageLoader(pathManager);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = settings,
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return(new PackagePathViewModel(loader, loadParams, customNodeManager));
}
public void PackageInStandardLibLocationIsLoaded()
{
//setup clean loader
var loader = new PackageLoader(new string[0], StandardLibraryTestDirectory);
var settings = new PreferenceSettings();
settings.DisableStandardLibrary = false;
var loaderParams = new LoadPackageParams()
{
PathManager = CurrentDynamoModel.PathManager,
Preferences = settings
};
//invoke the load
loader.LoadAll(loaderParams);
//assert the package in std lib was loaded.
Assert.IsTrue(loader.LocalPackages.Any(x => x.BinaryDirectory.Contains("SignedPackage2")));
Assert.AreEqual(1, loader.LocalPackages.Count());
}
public void DisablingStandardLibraryCorrectlyDisablesLoading()
{
//setup clean loader
var loader = new PackageLoader(new string[0], StandardLibraryTestDirectory);
var settings = new PreferenceSettings();
settings.DisableStandardLibrary = true;
var loaderParams = new LoadPackageParams()
{
PathManager = CurrentDynamoModel.PathManager,
Preferences = settings
};
//then invoke load
loader.LoadAll(loaderParams);
//assert the package in std lib was not loaded.
Assert.IsFalse(loader.LocalPackages.Any(x => x.Name.Contains("SignedPackage2")));
Assert.AreEqual(0, loader.LocalPackages.Count());
}
/// <summary>
/// The PreferencesViewModel constructor basically initialize all the ItemsSource for the corresponding ComboBox in the View (PreferencesView.xaml)
/// </summary>
public PreferencesViewModel(DynamoViewModel dynamoViewModel)
{
this.preferenceSettings = dynamoViewModel.PreferenceSettings;
this.pythonScriptEditorTextOptions = dynamoViewModel.PythonScriptEditorTextOptions;
this.runPreviewEnabled = dynamoViewModel.HomeSpaceViewModel.RunSettingsViewModel.RunButtonEnabled;
this.homeSpace = dynamoViewModel.HomeSpace;
this.dynamoViewModel = dynamoViewModel;
this.installedPackagesViewModel = new InstalledPackagesViewModel(dynamoViewModel,
dynamoViewModel.PackageManagerClientViewModel.PackageManagerExtension.PackageLoader);
// Scan for engines
AddPythonEnginesOptions();
PythonEngineManager.Instance.AvailableEngines.CollectionChanged += PythonEnginesChanged;
//Sets SelectedPythonEngine.
//If the setting is empty it corresponds to the default python engine
var engine = PythonEnginesList.FirstOrDefault(x => x.Equals(preferenceSettings.DefaultPythonEngine));
SelectedPythonEngine = string.IsNullOrEmpty(engine) ? Res.DefaultPythonEngineNone : preferenceSettings.DefaultPythonEngine;
string languages = Wpf.Properties.Resources.PreferencesWindowLanguages;
LanguagesList = new ObservableCollection <string>(languages.Split(','));
SelectedLanguage = languages.Split(',').First();
FontSizeList = new ObservableCollection <string>();
FontSizeList.Add(Wpf.Properties.Resources.ScalingSmallButton);
FontSizeList.Add(Wpf.Properties.Resources.ScalingMediumButton);
FontSizeList.Add(Wpf.Properties.Resources.ScalingLargeButton);
FontSizeList.Add(Wpf.Properties.Resources.ScalingExtraLargeButton);
SelectedFontSize = Wpf.Properties.Resources.ScalingMediumButton;
NumberFormatList = new ObservableCollection <string>();
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber0);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber00);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber000);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber0000);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber00000);
SelectedNumberFormat = preferenceSettings.NumberFormat;
runSettingsIsChecked = preferenceSettings.DefaultRunType;
RunPreviewIsChecked = preferenceSettings.ShowRunPreview;
//By Default the warning state of the Visual Settings tab (Group Styles section) will be disabled
isWarningEnabled = false;
StyleItemsList = LoadStyles(preferenceSettings.GroupStyleItemsList);
//When pressing the "Add Style" button some controls will be shown with some values by default so later they can be populated by the user
AddStyleControl = new StyleItem()
{
GroupName = "", HexColorString = "#" + GetRandomHexStringColor()
};
//This piece of code will populate all the description text for the RadioButtons in the Geometry Scaling section.
optionsGeometryScale = new GeometryScalingOptions();
UpdateGeoScaleRadioButtonSelected(dynamoViewModel.ScaleFactorLog);
optionsGeometryScale.DescriptionScaleRange = new ObservableCollection <string>();
optionsGeometryScale.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.Small].Item2,
scaleRanges[GeometryScaleSize.Small].Item3));
optionsGeometryScale.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.Medium].Item2,
scaleRanges[GeometryScaleSize.Medium].Item3));
optionsGeometryScale.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.Large].Item2,
scaleRanges[GeometryScaleSize.Large].Item3));
optionsGeometryScale.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.ExtraLarge].Item2,
scaleRanges[GeometryScaleSize.ExtraLarge].Item3));
SavedChangesLabel = string.Empty;
SavedChangesTooltip = string.Empty;
preferencesTabs = new Dictionary <string, TabSettings>();
preferencesTabs.Add("General", new TabSettings()
{
Name = "General", ExpanderActive = string.Empty
});
preferencesTabs.Add("Features", new TabSettings()
{
Name = "Features", ExpanderActive = string.Empty
});
preferencesTabs.Add("VisualSettings", new TabSettings()
{
Name = "VisualSettings", ExpanderActive = string.Empty
});
preferencesTabs.Add("Package Manager", new TabSettings()
{
Name = "Package Manager", ExpanderActive = string.Empty
});
//create a packagePathsViewModel we'll use to interact with the package search paths list.
var loadPackagesParams = new LoadPackageParams
{
Preferences = preferenceSettings
};
var customNodeManager = dynamoViewModel.Model.CustomNodeManager;
var packageLoader = dynamoViewModel.Model.GetPackageManagerExtension()?.PackageLoader;
PackagePathsViewModel = new PackagePathViewModel(packageLoader, loadPackagesParams, customNodeManager);
WorkspaceEvents.WorkspaceSettingsChanged += PreferencesViewModel_WorkspaceSettingsChanged;
PropertyChanged += Model_PropertyChanged;
}
/// <summary>
/// This method downloads the package represented by the PackageDownloadHandle,
/// uninstalls its current installation if necessary, and installs the package.
///
/// Note that, if the package is already installed, it must be uninstallable
/// </summary>
/// <param name="packageDownloadHandle"></param>
internal void DownloadAndInstall(PackageDownloadHandle packageDownloadHandle)
{
Downloads.Add(packageDownloadHandle);
packageDownloadHandle.DownloadState = PackageDownloadHandle.State.Downloading;
Task.Factory.StartNew(() =>
{
try
{
var pathDl = Model.DownloadPackage(packageDownloadHandle.Header._id,
packageDownloadHandle.VersionName);
DynamoViewModel.UIDispatcher.BeginInvoke((Action)(() =>
{
try
{
packageDownloadHandle.Done(pathDl);
Package dynPkg;
var firstOrDefault = DynamoViewModel.Model.PackageLoader.LocalPackages.FirstOrDefault(pkg => pkg.Name == packageDownloadHandle.Name);
if (firstOrDefault != null)
{
var dynModel = DynamoViewModel.Model;
try
{
firstOrDefault.UninstallCore(dynModel.CustomNodeManager, dynModel.PackageLoader, dynModel.PreferenceSettings);
}
catch
{
MessageBox.Show(String.Format(Resources.MessageFailToUninstallPackage, packageDownloadHandle.Name),
Resources.UninstallFailureMessageBoxTitle,
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
if (packageDownloadHandle.Extract(DynamoViewModel.Model, out dynPkg))
{
var downloadPkg = Package.FromDirectory(dynPkg.RootDirectory, DynamoViewModel.Model.Logger);
var loader = DynamoViewModel.Model.Loader;
var logger = DynamoViewModel.Model.Logger;
var libraryServices = DynamoViewModel.EngineController.LibraryServices;
var loadPackageParams = new LoadPackageParams
{
Loader = loader,
LibraryServices = libraryServices,
Context = DynamoViewModel.Model.Context,
IsTestMode = DynamoModel.IsTestMode,
CustomNodeManager = DynamoViewModel.Model.CustomNodeManager
};
downloadPkg.LoadIntoDynamo(loadPackageParams, logger);
DynamoViewModel.Model.PackageLoader.LocalPackages.Add(downloadPkg);
packageDownloadHandle.DownloadState = PackageDownloadHandle.State.Installed;
}
}
catch (Exception e)
{
packageDownloadHandle.Error(e.Message);
}
}));
}
catch (Exception e)
{
packageDownloadHandle.Error(e.Message);
}
});
}
