internal PackageViewModel(
IPackage package,
string source,
IMruManager mruManager,
IUIServices uiServices,
IPackageEditorService editorService,
ISettingsManager settingsManager)
{
if (package == null) {
throw new ArgumentNullException("package");
}
if (mruManager == null) {
throw new ArgumentNullException("mruManager");
}
if (uiServices == null) {
throw new ArgumentNullException("uiServices");
}
if (editorService == null) {
throw new ArgumentNullException("editorService");
}
if (settingsManager == null) {
throw new ArgumentNullException("settingsManager");
}
_settingsManager = settingsManager;
_editorService = editorService;
_uiServices = uiServices;
_mruManager = mruManager;
_package = package;
_packageMetadata = new EditablePackageMetadata(_package);
PackageSource = source;
_packageRoot = PathToTreeConverter.Convert(_package.GetFiles().ToList(), this);
}
internal PackageViewModel(
IPackage package,
string source,
IMruManager mruManager,
IUIServices uiServices,
IPackageEditorService editorService,
ISettingsManager settingsManager,
CredentialPublishProvider credentialPublishProvider,
IList <Lazy <IPackageContentViewer, IPackageContentViewerMetadata> > contentViewerMetadata,
IList <Lazy <IPackageRule> > packageRules)
{
_settingsManager = settingsManager ?? throw new ArgumentNullException(nameof(settingsManager));
_editorService = editorService ?? throw new ArgumentNullException(nameof(editorService));
_uiServices = uiServices ?? throw new ArgumentNullException(nameof(uiServices));
_mruManager = mruManager ?? throw new ArgumentNullException(nameof(mruManager));
_credentialPublishProvider = credentialPublishProvider ?? throw new ArgumentNullException(nameof(credentialPublishProvider));
_package = package ?? throw new ArgumentNullException(nameof(package));
_contentViewerMetadata = contentViewerMetadata;
_packageRules = packageRules;
_packageMetadata = new EditablePackageMetadata(_package, _uiServices);
PackageSource = source;
_isSigned = _packageMetadata.IsSigned;
_packageRoot = PathToTreeConverter.Convert(_package.GetFiles().ToList(), this);
}
private void AddFolderCore(PackageFolder childFolder)
{
Attach(childFolder);
childFolder.IsSelected = true;
IsExpanded = true;
PackageViewModel.NotifyChanges();
}
public SymbolValidator(IPackage package, string packagePath, PackageFolder?rootFolder)
{
if (string.IsNullOrWhiteSpace(packagePath))
{
throw new ArgumentException($"'{nameof(packagePath)}' cannot be null or whitespace", nameof(packagePath));
}
_package = package ?? throw new ArgumentNullException(nameof(package));
_packagePath = packagePath;
// NuGet signs all its packages and stamps on the service index. Look for that.
if (package is ISignaturePackage sigPackage)
{
if (sigPackage.RepositorySignature?.V3ServiceIndexUrl?.AbsoluteUri.Contains(".nuget.org/", StringComparison.OrdinalIgnoreCase) == true)
{
IsPublicPackage = true;
}
}
_rootFolder = rootFolder ?? PathToTreeConverter.Convert(package.GetFiles().ToList(), null);
SourceLinkResult = SymbolValidationResult.Pending;
DeterministicResult = DeterministicResult.Pending;
CompilerFlagsResult = HasCompilerFlagsResult.Pending;
}
private void AddFileToFolder(PackageFolder folder, string file)
{
if (folder == null)
{
string guessFolderName = FileHelper.GuessFolderNameFromFile(file);
bool confirmed = UIServices.Confirm(
String.Format(CultureInfo.CurrentCulture, Resources.ConfirmToMoveFileIntoFolder, file, guessFolderName));
if (confirmed)
{
if (RootFolder.ContainsFolder(guessFolderName))
{
folder = (PackageFolder)RootFolder[guessFolderName];
}
else
{
folder = RootFolder.AddFolder(guessFolderName);
}
}
else
{
folder = RootFolder;
}
}
folder.AddFile(file);
}
public void AddDraggedAndDroppedFiles(PackageFolder folder, string[] fileNames)
{
foreach (string file in fileNames)
{
AddFileToFolder(folder, file);
}
}
private static void Parse(PackageFolder root, List <Tuple <IPackageFile, string[]> > parsedPaths, int level, int start, int end)
{
int i = start;
while (i < end)
{
string s = parsedPaths[i].Item2[level];
if (parsedPaths[i].Item2.Length == level + 1)
{
// it's a file
root.Children.Add(new PackageFile(parsedPaths[i].Item1, s, root));
i++;
}
else
{
// it's a folder
int j = i;
while (j < end && level < parsedPaths[j].Item2.Length && parsedPaths[j].Item2[level] == s)
{
j++;
}
PackageFolder folder = new PackageFolder(s, root);
root.Children.Add(folder);
Parse(folder, parsedPaths, level + 1, i, j);
i = j;
}
}
}
private PackageFile(IPackageFile file, string name, PackageFolder parent, PackageViewModel viewModel)
: base(name, parent, viewModel)
{
if (file == null) {
throw new ArgumentNullException("file");
}
_file = file;
}
private PackageFile(IPackageFile file, string name, PackageFolder parent, PackageViewModel viewModel)
: base(name, parent, viewModel)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
_file = file;
}
private void AddNewFolderExecute(object parameter)
{
PackageFolder folder = (parameter ?? SelectedItem) as PackageFolder;
string folderName = "NewFolder";
bool result = UIServices.OpenRenameDialog(folderName, out folderName);
if (result)
{
folder.AddFolder(folderName);
}
}
private PackageFile(IPackageFile file, string name, PackageFolder parent, PackageViewModel viewModel)
: base(name, parent, viewModel)
{
_file = file ?? throw new ArgumentNullException("file");
if (file is DiskPackageFile physicalFile)
{
WatchPhysicalFile(physicalFile);
}
ReplaceCommand = new RelayCommand(Replace, () => !viewModel.IsSigned && !viewModel.IsInEditFileMode);
}
protected PackagePart(string name, PackageFolder parent, PackageViewModel viewModel)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
_viewModel = viewModel ?? throw new ArgumentNullException("viewModel");
_parent = parent;
OnNameChange(name);
RecalculatePath();
}
private void AddContentFileExecute(object parameter)
{
PackageFolder folder = (parameter ?? SelectedItem) as PackageFolder;
if (folder != null)
{
AddExistingFileToFolder(folder);
}
else
{
AddExistingFileToFolder(RootFolder);
}
}
private void AddPhysicalFolderCore(DirectoryInfo dirInfo)
{
PackageFolder childPackgeFolder = AddFolder(dirInfo.Name);
foreach (FileInfo file in dirInfo.GetFiles("*.*", SearchOption.TopDirectoryOnly))
{
childPackgeFolder.AddFile(file.FullName, isTempFile: false);
}
foreach (DirectoryInfo subFolder in dirInfo.GetDirectories("*.*", SearchOption.TopDirectoryOnly))
{
childPackgeFolder.AddPhysicalFolderCore(subFolder);
}
}
public PackageFolder AddFolder(string folderName)
{
if (!AddContentFolderCanExecute(folderName))
{
PackageViewModel.UIServices.Show(
string.Format(CultureInfo.CurrentCulture, Resources.RenameCausesNameCollison, folderName),
MessageLevel.Error);
return null;
}
var newFolder = new PackageFolder(folderName, this);
AddFolderCore(newFolder);
return newFolder;
}
public void AddFolder(PackageFolder childFolder, bool makeCopy = false)
{
if (childFolder is null)
{
throw new ArgumentNullException(nameof(childFolder));
}
if (!AddContentFolderCanExecute(childFolder.Name))
{
PackageViewModel.UIServices.Show(
string.Format(CultureInfo.CurrentCulture, Resources.RenameCausesNameCollison, childFolder.Name),
MessageLevel.Error);
return;
}
if (IsDescendantOf(childFolder))
{
return;
}
PackageFolder newFolder;
if (makeCopy)
{
newFolder = new PackageFolder(childFolder.Name, this);
foreach (var child in childFolder.Children)
{
if (child is PackageFile packageFile)
{
newFolder.AddFile(packageFile, true);
}
else if (child is PackageFolder packageFolder)
{
newFolder.AddFolder(packageFolder, true);
}
}
}
else
{
if (childFolder.Parent != null)
{
childFolder.Parent.Detach(childFolder);
}
newFolder = childFolder;
}
AddFolderCore(newFolder);
}
public PackageFolder AddFolder(string folderName)
{
if (ContainsFolder(folderName) || ContainsFile(folderName))
{
PackageViewModel.UIServices.Show(Resources.RenameCausesNameCollison, Types.MessageLevel.Error);
return(null);
}
var newFolder = new PackageFolder(folderName, this);
Children.Add(newFolder);
newFolder.IsSelected = true;
this.IsExpanded = true;
PackageViewModel.NotifyChanges();
return(newFolder);
}
private void AddExistingFileToFolder(PackageFolder folder)
{
var result = UIServices.OpenMultipleFilesDialog(
"Select Files",
"All files (*.*)|*.*",
out var selectedFiles);
if (result)
{
foreach (var file in selectedFiles)
{
folder.AddFile(file);
}
}
}
public static PackageFolder Convert(List<IPackageFile> paths, PackageViewModel viewModel)
{
if (paths == null) {
throw new ArgumentNullException("paths");
}
paths.Sort((p1, p2) => String.Compare(p1.Path, p2.Path, StringComparison.OrdinalIgnoreCase));
PackageFolder root = new PackageFolder("", viewModel);
List<Tuple<IPackageFile, string[]>> parsedPaths = paths.Select(p => Tuple.Create(p, p.Path.Split('\\'))).ToList();
Parse(root, parsedPaths, 0, 0, parsedPaths.Count);
return root;
}
internal PackageViewModel(
IPackage package,
string source,
IMruManager mruManager,
IUIServices uiServices,
IPackageEditorService editorService,
ISettingsManager settingsManager,
IList <Lazy <IPackageContentViewer, IPackageContentViewerMetadata> > contentViewerMetadata,
IList <Lazy <IPackageRule> > packageRules)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
if (mruManager == null)
{
throw new ArgumentNullException("mruManager");
}
if (uiServices == null)
{
throw new ArgumentNullException("uiServices");
}
if (editorService == null)
{
throw new ArgumentNullException("editorService");
}
if (settingsManager == null)
{
throw new ArgumentNullException("settingsManager");
}
_settingsManager = settingsManager;
_editorService = editorService;
_uiServices = uiServices;
_mruManager = mruManager;
_package = package;
_contentViewerMetadata = contentViewerMetadata;
_packageRules = packageRules;
_packageMetadata = new EditablePackageMetadata(_package);
PackageSource = source;
_packageRoot = PathToTreeConverter.Convert(_package.GetFiles().ToList(), this);
// HACK: this is after the package.GetFiles() since that reads the signature
_packageMetadata.PublisherCertificate = _package.PublisherCertificate;
}
private void AddExistingFileToFolder(PackageFolder folder)
{
string[] selectedFiles;
bool result = UIServices.OpenMultipleFilesDialog(
"Select Files",
"All files (*.*)|*.*",
out selectedFiles);
if (result)
{
foreach (string file in selectedFiles)
{
folder.AddFile(file, isTempFile: false);
}
}
}
public static PackageFolder Convert(List <IPackageFile> paths, PackageViewModel viewModel)
{
if (paths == null)
{
throw new ArgumentNullException("paths");
}
paths.Sort((p1, p2) => String.Compare(p1.Path, p2.Path, StringComparison.OrdinalIgnoreCase));
PackageFolder root = new PackageFolder("", viewModel);
List <Tuple <IPackageFile, string[]> > parsedPaths = paths.Select(p => Tuple.Create(p, p.Path.Split('\\'))).ToList();
Parse(root, parsedPaths, 0, 0, parsedPaths.Count);
return(root);
}
internal PackageViewModel(
IPackage package,
string source,
IMruManager mruManager,
IUIServices uiServices,
IPackageEditorService editorService,
ISettingsManager settingsManager,
IList <Lazy <IPackageContentViewer, IPackageContentViewerMetadata> > contentViewerMetadata,
IList <Lazy <IPackageRule> > packageRules)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
if (mruManager == null)
{
throw new ArgumentNullException("mruManager");
}
if (uiServices == null)
{
throw new ArgumentNullException("uiServices");
}
if (editorService == null)
{
throw new ArgumentNullException("editorService");
}
if (settingsManager == null)
{
throw new ArgumentNullException("settingsManager");
}
_settingsManager = settingsManager;
_editorService = editorService;
_uiServices = uiServices;
_mruManager = mruManager;
_package = package;
_contentViewerMetadata = contentViewerMetadata;
_packageRules = packageRules;
_packageMetadata = new EditablePackageMetadata(_package, _uiServices);
PackageSource = source;
_isSigned = package.IsSigned;
_packageRoot = PathToTreeConverter.Convert(_package.GetFiles().ToList(), this);
}
protected PackagePart(string name, PackageFolder parent, PackageViewModel viewModel)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
_viewModel = viewModel;
_parent = parent;
_name = name;
RecalculatePath();
}
private PackageFile(IPackageFile file, string name, PackageFolder parent, PackageViewModel viewModel)
: base(name, parent, viewModel)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
_file = file;
var physicalFile = file as PhysicalPackageFile;
if (physicalFile != null)
{
WatchPhysicalFile(physicalFile);
}
ReplaceCommand = new RelayCommand(Replace, () => !viewModel.IsInEditFileMode);
}
private PackageFile(IPackageFile file, string name, PackageFolder parent, PackageViewModel viewModel)
: base(name, parent, viewModel)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
_file = file;
var physicalFile = file as PhysicalPackageFile;
if (physicalFile != null)
{
WatchPhysicalFile(physicalFile);
}
ReplaceCommand = new RelayCommand(Replace, () => !viewModel.IsReadOnly && !viewModel.IsInEditFileMode);
}
private void AddNewFileToFolder(PackageFolder folder)
{
var result = UIServices.OpenRenameDialog(
"NewFile.txt",
"Provide name for the new file.",
out var newName);
if (result)
{
var sourcePath = FileHelper.CreateTempFile(newName);
var file = folder.AddFile(sourcePath);
// file can be null if it collides with other files in the same directory
if (file != null)
{
EditFileCommandExecute(file);
}
}
}
private static void Parse(PackageFolder root, List <Tuple <IPackageFile, string[]> > parsedPaths, int level,
int start, int end)
{
var i = start;
while (i < end)
{
var s = parsedPaths[i].Item2[level];
if (parsedPaths[i].Item2.Length == level + 1)
{
// it's a file
// Starting from nuget 2.0, they use a dummy file with the name "_._" to represent
// an empty folder. Therefore, we just ignore it.
if (!s.Equals(NuGetPe.Constants.PackageEmptyFileName, StringComparison.OrdinalIgnoreCase))
{
root.Children.Add(new PackageFile(parsedPaths[i].Item1, s, root));
}
i++;
}
else
{
// it's a folder
var j = i;
while (
j < end &&
level < parsedPaths[j].Item2.Length &&
parsedPaths[j].Item2[level].Equals(s, StringComparison.OrdinalIgnoreCase)
)
{
j++;
}
var folder = new PackageFolder(s, root);
root.Children.Add(folder);
Parse(folder, parsedPaths, level + 1, i, j);
i = j;
}
}
}
private static void Parse(PackageFolder root, List<Tuple<IPackageFile, string[]>> parsedPaths, int level,
int start, int end)
{
int i = start;
while (i < end)
{
string s = parsedPaths[i].Item2[level];
if (parsedPaths[i].Item2.Length == level + 1)
{
// it's a file
// Starting from nuget 2.0, they use a dummy file with the name "_._" to represent
// an empty folder. Therefore, we just ignore it.
if (!s.Equals(NuGet.Constants.PackageEmptyFileName, StringComparison.OrdinalIgnoreCase))
{
root.Children.Add(new PackageFile(parsedPaths[i].Item1, s, root));
}
i++;
}
else
{
// it's a folder
int j = i;
while (
j < end &&
level < parsedPaths[j].Item2.Length &&
parsedPaths[j].Item2[level].Equals(s, StringComparison.OrdinalIgnoreCase)
)
{
j++;
}
var folder = new PackageFolder(s, root);
root.Children.Add(folder);
Parse(folder, parsedPaths, level + 1, i, j);
i = j;
}
}
}
public void AddFolder(PackageFolder childFolder)
{
if (!AddContentFolderCanExecute(childFolder.Name))
{
PackageViewModel.UIServices.Show(
String.Format(CultureInfo.CurrentCulture, Resources.RenameCausesNameCollison, childFolder.Name),
MessageLevel.Error);
return;
}
if (this.IsDescendantOf(childFolder))
{
return;
}
if (childFolder.Parent != null)
{
childFolder.Parent.Detach(childFolder);
}
AddFolderCore(childFolder);
}
private static void Parse(PackageFolder root, List<Tuple<IPackageFile, string[]>> parsedPaths, int level, int start, int end)
{
int i = start;
while (i < end) {
string s = parsedPaths[i].Item2[level];
if (parsedPaths[i].Item2.Length == level + 1) {
// it's a file
root.Children.Add(new PackageFile(parsedPaths[i].Item1, s, root));
i++;
}
else {
// it's a folder
int j = i;
while (j < end && level < parsedPaths[j].Item2.Length && parsedPaths[j].Item2[level] == s) j++;
PackageFolder folder = new PackageFolder(s, root);
root.Children.Add(folder);
Parse(folder, parsedPaths, level + 1, i, j);
i = j;
}
}
}
public PackageFolder(string name, PackageFolder parent)
: base(name, parent, parent.PackageViewModel)
{
Children = new SortedCollection <PackagePart>();
}
public void AddDraggedAndDroppedFiles(PackageFolder folder, string[] fileNames)
{
foreach (string file in fileNames) {
AddFileToFolder(folder, file);
}
}
public PackageFolder AddFolder(string folderName)
{
if (ContainsFolder(folderName) || ContainsFile(folderName)) {
PackageViewModel.UIServices.Show(Resources.RenameCausesNameCollison, Types.MessageLevel.Error);
return null;
}
var newFolder = new PackageFolder(folderName, this);
Children.Add(newFolder);
newFolder.IsSelected = true;
this.IsExpanded = true;
PackageViewModel.NotifyChanges();
return newFolder;
}
private void AddExistingFileToFolder(PackageFolder folder)
{
string[] selectedFiles;
bool result = UIServices.OpenMultipleFilesDialog(
"Select Files",
"All files (*.*)|*.*",
out selectedFiles);
if (result) {
foreach (string file in selectedFiles) {
folder.AddFile(file);
}
}
}
public void AddDraggedAndDroppedFileDescriptors(PackageFolder folder, IEnumerable <(string FilePath, Stream Stream)> fileDescriptors)
public PackageFile(IPackageFile file, string name, PackageFolder parent)
: this(file, name, parent, parent.PackageViewModel)
{
}
private void AddFolderCore(PackageFolder childFolder)
{
Attach(childFolder);
childFolder.IsSelected = true;
IsExpanded = true;
PackageViewModel.NotifyChanges();
}
public PackageFolder(string name, PackageFolder parent)
: base(name, parent, parent.PackageViewModel)
{
Children = new SortedCollection<PackagePart>();
}
public void AddFolder(PackageFolder childFolder)
{
if (!AddContentFolderCanExecute(childFolder.Name))
{
PackageViewModel.UIServices.Show(
String.Format(CultureInfo.CurrentCulture, Resources.RenameCausesNameCollison, childFolder.Name),
MessageLevel.Error);
return;
}
if (this.IsDescendantOf(childFolder))
{
return;
}
if (childFolder.Parent != null)
{
childFolder.Parent.Detach(childFolder);
}
AddFolderCore(childFolder);
}
public PackageFolder AddFolder(string folderName)
{
if (!AddContentFolderCanExecute(folderName))
{
PackageViewModel.UIServices.Show(
String.Format(CultureInfo.CurrentCulture, Resources.RenameCausesNameCollison, folderName),
MessageLevel.Error);
return null;
}
var newFolder = new PackageFolder(folderName, this);
AddFolderCore(newFolder);
return newFolder;
}
private void AddFileToFolder(PackageFolder folder, string file)
{
if (folder == null) {
string guessFolderName = FileHelper.GuessFolderNameFromFile(file);
bool confirmed = UIServices.Confirm(
String.Format(CultureInfo.CurrentCulture, Resources.ConfirmToMoveFileIntoFolder, file, guessFolderName));
if (confirmed) {
if (RootFolder.ContainsFolder(guessFolderName)) {
folder = (PackageFolder)RootFolder[guessFolderName];
}
else {
folder = RootFolder.AddFolder(guessFolderName);
}
}
else {
folder = RootFolder;
}
}
folder.AddFile(file);
}
public void AddDraggedAndDroppedFiles(PackageFolder folder, string[] fileNames)
{
if (folder == null)
{
bool?rememberedAnswer = null;
for (var i = 0; i < fileNames.Length; i++)
{
var file = fileNames[i];
if (File.Exists(file))
{
bool movingFile;
PackageFolder targetFolder;
var guessFolderName = FileHelper.GuessFolderNameFromFile(file);
if (rememberedAnswer == null)
{
// ask user if he wants to move file
var answer = UIServices.ConfirmMoveFile(
Path.GetFileName(file),
guessFolderName, fileNames.Length - i - 1);
if (answer.Item1 == null)
{
// user presses Cancel
break;
}
movingFile = (bool)answer.Item1;
if (answer.Item2)
{
rememberedAnswer = answer.Item1;
}
}
else
{
movingFile = (bool)rememberedAnswer;
}
if (movingFile)
{
if (RootFolder.ContainsFolder(guessFolderName))
{
targetFolder = (PackageFolder)RootFolder[guessFolderName];
}
else
{
targetFolder = RootFolder.AddFolder(guessFolderName);
}
}
else
{
targetFolder = RootFolder;
}
targetFolder.AddFile(file);
}
else if (Directory.Exists(file))
{
RootFolder.AddPhysicalFolder(file);
}
}
}
else
{
foreach (var file in fileNames)
{
if (File.Exists(file))
{
folder.AddFile(file);
}
else if (Directory.Exists(file))
{
folder.AddPhysicalFolder(file);
}
}
}
}
private void AddNewFileToFolder(PackageFolder folder)
{
string newName;
bool result = UIServices.OpenRenameDialog(
"NewFile.txt",
"Provide name for the new file.",
out newName);
if (result)
{
string sourcePath = FileHelper.CreateTempFile(newName);
PackageFile file = folder.AddFile(sourcePath, isTempFile: true);
// file can be null if it collides with other files in the same directory
if (file != null)
{
EditFileCommandExecute(file);
}
}
}
public void AddDraggedAndDroppedFiles(PackageFolder folder, string[] fileNames)
{
if (folder == null)
{
bool? rememberedAnswer = null;
for (int i = 0; i < fileNames.Length; i++)
{
string file = fileNames[i];
if (File.Exists(file))
{
bool movingFile;
PackageFolder targetFolder;
string guessFolderName = FileHelper.GuessFolderNameFromFile(file);
if (rememberedAnswer == null)
{
// ask user if he wants to move file
Tuple<bool?, bool> answer = UIServices.ConfirmMoveFile(
Path.GetFileName(file),
guessFolderName, fileNames.Length - i - 1);
if (answer.Item1 == null)
{
// user presses Cancel
break;
}
movingFile = (bool) answer.Item1;
if (answer.Item2)
{
rememberedAnswer = answer.Item1;
}
}
else
{
movingFile = (bool) rememberedAnswer;
}
if (movingFile)
{
if (RootFolder.ContainsFolder(guessFolderName))
{
targetFolder = (PackageFolder) RootFolder[guessFolderName];
}
else
{
targetFolder = RootFolder.AddFolder(guessFolderName);
}
}
else
{
targetFolder = RootFolder;
}
targetFolder.AddFile(file, isTempFile: false);
}
else if (Directory.Exists(file))
{
RootFolder.AddPhysicalFolder(file);
}
}
}
else
{
foreach (string file in fileNames)
{
if (File.Exists(file))
{
folder.AddFile(file, isTempFile: false);
}
else if (Directory.Exists(file))
{
folder.AddPhysicalFolder(file);
}
}
}
}
public PackageFile(IPackageFile file, string name, PackageFolder parent)
: this(file, name, parent, parent.PackageViewModel)
{
}
