protected SynqPackageCommand(PackageItem package, ContentPaths paths) {
Contract.Requires<ArgumentNullException>(package != null);
Contract.Requires<ArgumentNullException>(paths != null);
Package = package;
Paths = paths;
}
public void UpdateSynqState(ISupportModding game, PackageItem package) {
Contract.Requires<ArgumentNullException>(package != null);
_package = package;
SetSharedState(game);
_isValidSixSync = false;
_isValidSixSyncPack = false;
_sixSyncRepoExists = false;
_sixSyncVersionInfo = null;
_package.UpdateCurrentVersion();
Revision = GetSynqRevision();
DesiredRevision = GetSynqDesiredRevision();
LatestRevision = GetSynqLatestRevision();
State = !ModMatchesActiveGame(game) ? ContentState.Incompatible : GetSynqModState();
//Cheat.PublishDomainEvent(new ModInfoChangedEvent(new ModInfo(_mod)));
}
/// <summary>
/// 讲信息传送入EPM的API
/// </summary>
/// <param name="pack">singlePackage对象</param>
/// <param name="newItem">PackageItem对象</param>
public void notifyEpm(SinglePackage pack, PackageItem newItem, string productionline)
{
try
{
Dictionary<string, string> data = new Dictionary<string, string>();
data.Add("entityId", productionline);
data.Add("packTime", ((long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalMilliseconds).ToString());
data.Add("productNr", newItem.itemUid.ToString());
data.Add("partId", pack.partNr);
new EpmService().AddProductPack(data);
}
catch (Exception e)
{
LogUtil.Logger.Error(e.Message);
}
}
public static PackageItem Convert(IEnumerable<IPackageFile> files)
{
if (files == null)
{
throw new ArgumentNullException("files");
}
List<IPackageFile> paths = files.ToList();
paths.Sort((p1, p2) => String.Compare(p1.Path, p2.Path, StringComparison.OrdinalIgnoreCase));
var root = new PackageItem("");
List<string[]> parsedPaths = paths.Select(p => p.Path.Split('/', '\\')).ToList();
Parse(root, parsedPaths, 0, 0, parsedPaths.Count);
return root;
}
public PackageContentsViewModel(IPackage packageMetadata, ICollection<User> owners, PackageItem rootFolder)
{
_packageMetadata = packageMetadata;
_rootFolder = rootFolder;
FlattenedAuthors = String.Join(", ", packageMetadata.Authors);
FlattenedOwners = String.Join(", ", owners.Select(o => o.Username));
IconUrl = packageMetadata.IconUrl == null ? null : packageMetadata.IconUrl.AbsoluteUri;
FrameworkAssemblies = packageMetadata.FrameworkAssemblies.Select(
f =>
{
if (f.SupportedFrameworks.Any())
{
return String.Format(CultureInfo.InvariantCulture, "{0} ({1})", f.AssemblyName, String.Join("; ", f.SupportedFrameworks));
}
else
{
return f.AssemblyName;
}
}).ToList();
}
private static void Parse(PackageItem root, List<string[]> parsedPaths, int level, int start, int end)
{
int i = start;
while (i < end)
{
string s = parsedPaths[i][level];
if (parsedPaths[i].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. We just ignore it.
if (!s.Equals("_._", StringComparison.OrdinalIgnoreCase))
{
root.Children.Add(new PackageItem(s, root, isFile: true));
}
i++;
}
else
{
// it's a folder
int j = i;
while (j < end &&
level < parsedPaths[j].Length &&
parsedPaths[j][level].Equals(s, StringComparison.OrdinalIgnoreCase))
{
j++;
}
var folder = new PackageItem(s, root);
root.Children.Add(folder);
Parse(folder, parsedPaths, level + 1, i, j);
i = j;
}
}
}
public void AddPackage(PackageItem package)
{
var packageDb = _mappingService.MapPackage(package);
_packageRepository.AddPackage(packageDb);
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
packageManager.Verify(p => p.InstallPackage(
projectManager1.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
packageManager.Verify(p => p.InstallPackage(
projectManager2.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public override bool CanExecute(PackageItem item)
{
return(false);
}
private string ConstructTemplate(PackageItem item, string template, string productionTemplate, string outerProdTemplate = "")
{
if (item == null)
{
return(outerProdTemplate);
}
int index = GetNextUnvisitedChildIndex(item);
string prodTemplate = productionTemplate;
if (index >= 0)
{
return(ConstructTemplate(item.Children[index], template, prodTemplate));
}
else if (AllChildrenVisited(item))//če so bili obiskani že vsi otroci
{
if (item.TreeLevel == 1)
{
prodTemplate += ReplaceDefaultValuesInTemplate(new PackageTemplateModel()
{
NumberOfProducts = item.Children.Count.ToString(), PackageSID = item.SID, PackageUID = item.UID, Products = template
}, childPackageTemplateString);
template = "";
}
else if (item.TreeLevel == 2)
{
outerProdTemplate += ReplaceDefaultValuesInTemplate(new OuterPackageTemplateModel()
{
ChildPackages = prodTemplate, PackageUID = item.UID
}, outerPackageTemplateString);
prodTemplate = "";
}
else if (item.TreeLevel > 2)
{
}
item.Visited = true;
return(ConstructTemplate(item.Parent, template, prodTemplate, outerProdTemplate));
}
else if (item.Parent != null) // prišli smo do zadnjega neobiskanega vozlišča - sprehajamo se po drevesu vse dokler ne pridemo do korena drevesa.
{
//Nastavimo šablono
if (IsLeaf(item))
{
template += ReplaceDefaultValuesInTemplate(new ProductTemplateModel()
{
ProductUID = item.UID, ProductSID = item.SID
}, productTemplateString);
}
else if (item.TreeLevel == 1)
{
prodTemplate += ReplaceDefaultValuesInTemplate(new PackageTemplateModel()
{
NumberOfProducts = item.Children.Count.ToString(), PackageSID = item.SID, PackageUID = item.UID, Products = template
}, childPackageTemplateString);
template = "";
}
else if (item.TreeLevel == 2)
{
outerProdTemplate += ReplaceDefaultValuesInTemplate(new OuterPackageTemplateModel()
{
ChildPackages = prodTemplate, PackageUID = item.UID
}, outerPackageTemplateString);
prodTemplate = "";
}
else if (item.TreeLevel > 2)
{
}
item.Visited = true;
return(ConstructTemplate(item.Parent, template, prodTemplate, outerProdTemplate));
}
else
{
return(outerProdTemplate);
}
}
public async Task <IActionResult> CreateItem(Item item, string[] selectedTag, string[] selectedItem, string[] selectedItemGroup)
{
if (ModelState.IsValid)
{
item.createDateTime = DateTimeOffset.Now;
item.updateDateTime = DateTimeOffset.Now;
item.image = "";
_context.Add(item);
_context.SaveChanges();
var getItemId = _context.item.OrderBy(i => i.Id).Single();
if (selectedItem != null)
{
var itemList = new List <PackageItem>();
foreach (var packageItem in selectedItem)
{
var packageItemToAdd = new PackageItem
{
itemId = getItemId.Id,
flowerPackageId = 10,
createDateTime = DateTimeOffset.Now,
updateDateTime = DateTimeOffset.Now
};
itemList.Add(packageItemToAdd);
}
await _context.SaveChangesAsync();
}
if (item.isTag == true)
{
item.ItemTags = new List <ItemTag>();
foreach (var itemTag in selectedTag)
{
var itemTagToAdd = new ItemTag
{
itemId = getItemId.Id,
tagId = int.Parse(itemTag),
createDateTime = DateTimeOffset.Now,
updateDateTime = DateTimeOffset.Now
};
item.ItemTags.Add(itemTagToAdd);
}
await _context.SaveChangesAsync();
}
if (selectedItemGroup != null)
{
item.ItemMmItemGroups = new List <ItemMmItemGroup>();
foreach (var itemMmItemGroup in selectedItemGroup)
{
var itemMmItemGroupToAdd = new ItemMmItemGroup
{
itemId = getItemId.Id,
itemGroupId = int.Parse(itemMmItemGroup),
createDateTime = DateTimeOffset.Now,
updateDateTime = DateTimeOffset.Now
};
item.ItemMmItemGroups.Add(itemMmItemGroupToAdd);
}
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
ViewData["packageType"] = new SelectList(_context.packageType, "Id", "name");
ViewData["supplier"] = new SelectList(_context.supplier, "Id", "campanyName");
ViewData["ItemGroup"] = _context.itemGroup;
ViewData["Tag"] = _context.tag;
ViewData["Items"] = _context.item.Where(i => i.isPackage == false);
return(View());
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Graphics g = context.Graphics;
Rectangle targetRect = new Rectangle(
context.Bounds.X + this.LeftMargin,
context.Bounds.Y,
context.Bounds.Width - this.LeftMargin,
context.Bounds.Height);
// Retrieve item information
PackageItem item = node.Tag as PackageItem;
Version itemVersion = null;
Version newVersion = null;
PackageCompatibility updateCompatibility = PackageCompatibility.None;
bool highlightItemVersion = item is LocalPackageItem;
bool isInstalled = false;
bool isUpToDate = false;
if (item != null)
{
isInstalled = item.InstalledPackageInfo != null;
updateCompatibility = item.UpdateCompatibility;
if (item.InstalledPackageInfo != null)
{
itemVersion = item.InstalledPackageInfo.Version;
}
else if (item.ItemPackageInfo != null)
{
itemVersion = item.ItemPackageInfo.Version;
}
if (item.NewestPackageInfo != null)
{
newVersion = item.NewestPackageInfo.Version;
}
if (itemVersion != null && newVersion != null)
{
isUpToDate = itemVersion >= newVersion;
}
}
string itemVersionText = PackageManager.GetDisplayedVersion(itemVersion);
string newVersionText = isInstalled && !isUpToDate?PackageManager.GetDisplayedVersion(newVersion) : string.Empty;
// Determine background color and icon based on versioning
Brush backgroundBrush = null;
Image icon = null;
if (isInstalled)
{
backgroundBrush = new SolidBrush(Color.FromArgb(32, 128, 128, 128));
}
if (isInstalled && newVersion != null && itemVersion != null)
{
if (newVersion <= itemVersion)
{
icon = Properties.PackageManagerFrontendResCache.IconUpToDate;
}
else if (updateCompatibility == PackageCompatibility.Definite)
{
icon = Properties.PackageManagerFrontendResCache.IconSafeUpdate;
}
else if (updateCompatibility == PackageCompatibility.Likely)
{
icon = Properties.PackageManagerFrontendResCache.IconLikelySafeUpdate;
}
else if (updateCompatibility == PackageCompatibility.Unlikely)
{
icon = Properties.PackageManagerFrontendResCache.IconLikelyUnsafeUpdate;
}
else
{
icon = Properties.PackageManagerFrontendResCache.IconIncompatibleUpdate;
}
}
// Calculate drawing layout and data
StringFormat stringFormat = new StringFormat {
Trimming = StringTrimming.EllipsisCharacter, Alignment = StringAlignment.Near, FormatFlags = StringFormatFlags.NoWrap
};
Rectangle currentVersionRect;
Rectangle newestVersionRect;
Rectangle iconRect;
{
SizeF currentVersionSize;
SizeF newestVersionSize;
Size iconSize;
// Base info
{
newestVersionSize = g.MeasureString(newVersionText, context.Font, targetRect.Width, stringFormat);
currentVersionSize = g.MeasureString(itemVersionText, context.Font, targetRect.Width, stringFormat);
iconSize = icon != null ? icon.Size : Size.Empty;
}
// Alignment info
{
Size totalTextSize = new Size(
(int)Math.Max(currentVersionSize.Width, newestVersionSize.Width),
(int)(currentVersionSize.Height + newestVersionSize.Height));
int leftSpacing = (targetRect.Width - totalTextSize.Width - iconSize.Width - 4) / 2;
int iconIndent = iconSize.Width + 4 + leftSpacing;
iconRect = new Rectangle(
targetRect.X + leftSpacing,
targetRect.Y + targetRect.Height / 2 - iconSize.Height / 2,
iconSize.Width,
iconSize.Height);
newestVersionRect = new Rectangle(
targetRect.X + iconIndent,
targetRect.Y + Math.Max((targetRect.Height - totalTextSize.Height) / 2, 0),
targetRect.Width - iconIndent,
(int)newestVersionSize.Height);
currentVersionRect = new Rectangle(
targetRect.X + iconIndent,
targetRect.Y + (int)newestVersionSize.Height + Math.Max((targetRect.Height - totalTextSize.Height) / 2, 0),
targetRect.Width - iconIndent,
targetRect.Height - (int)newestVersionSize.Height);
}
}
// Draw background and version texts
if (backgroundBrush != null)
{
g.FillRectangle(backgroundBrush, targetRect);
}
if (icon != null)
{
g.DrawImageUnscaledAndClipped(icon, iconRect);
}
{
bool bothVisible = !string.IsNullOrWhiteSpace(itemVersionText) && !string.IsNullOrWhiteSpace(newVersionText);
highlightItemVersion = highlightItemVersion || !bothVisible;
g.DrawString(newVersionText, context.Font, new SolidBrush(Color.FromArgb((highlightItemVersion ? 128 : 255) / (context.Enabled ? 1 : 2), this.Parent.ForeColor)), newestVersionRect, stringFormat);
g.DrawString(itemVersionText, context.Font, new SolidBrush(Color.FromArgb((highlightItemVersion ? 255 : 128) / (context.Enabled ? 1 : 2), this.Parent.ForeColor)), currentVersionRect, stringFormat);
}
}
/// <summary>
/// Returns the package dependencies of packageItem. We only return the dependencies that are not installed in the destination folder of request
/// </summary>
/// <param name="packageItem"></param>
/// <param name="request"></param>
private static IEnumerable<PackageItem> GetPackageDependenciesHelper(PackageItem packageItem, NuGetRequest request)
{
if (packageItem.Package.DependencySetList == null)
{
yield break;
}
foreach (var depSet in packageItem.Package.DependencySetList)
{
if (depSet.Dependencies == null)
{
continue;
}
foreach (var dep in depSet.Dependencies)
{
// Get the min dependencies version
string minVersion = dep.DependencyVersion.MinVersion.ToStringSafe();
// Get the max dependencies version
string maxVersion = dep.DependencyVersion.MaxVersion.ToStringSafe();
// check whether it is already installed at the destination
if (request.GetInstalledPackages(dep.Id, null, minVersion, maxVersion, minInclusive: dep.DependencyVersion.IsMinInclusive, maxInclusive: dep.DependencyVersion.IsMaxInclusive, terminateFirstFound: true))
{
request.Verbose(String.Format(CultureInfo.CurrentCulture, Messages.AlreadyInstalled, dep.Id));
// already have a dependency so move on
continue;
}
// get all the packages that match this dependency
var dependentPackageItem = request.GetPackageById(dep.Id, request, minimumVersion: minVersion, maximumVersion: maxVersion, minInclusive: dep.DependencyVersion.IsMinInclusive, maxInclusive: dep.DependencyVersion.IsMaxInclusive).ToArray();
if (dependentPackageItem.Length == 0)
{
request.WriteError(ErrorCategory.ObjectNotFound, dep.Id, Constants.Messages.UnableToFindDependencyPackage, dep.Id);
break;
}
// Get the package that is the latest version
yield return dependentPackageItem.OrderByDescending(each => each.Version).FirstOrDefault();
}
}
}
private void GetInvoice(string JobID)
{
try
{
if (!string.IsNullOrEmpty(JobID))
{
_dataService.GetJob(JobID, (res, err) =>
{
if (err != null)
{
MessageBox.Show(err.Message, err.Message); this.PrintButtonIsEnabled = true;
JobIndex++;
PropagateToNextJob();
return;
}
if (res != null)
{
try
{
Job job = new Job()
{
TrackingNo = (string)res.SelectToken("HRID"),
ReferenceInvoiceId = (string)res.SelectToken("Order.ReferenceInvoiceId"),
Date = DateTime.Today.ToLongDateString(),
PaymentMethod = (string)res.SelectToken("PaymentMethod"),
Assets = JObject.Parse(res["Assets"].ToString()),
Tasks = res.SelectToken("Tasks").ToArray(),
};
string tasks1, tasks2, tasks3 = string.Empty;
tasks1 = (string)job.Tasks[1].SelectToken("AssetRef");
tasks2 = (string)job.Tasks[2].SelectToken("AssetRef");
if (job.Tasks.Count() > 3)
{
tasks3 = (string)job.Tasks[3].SelectToken("AssetRef");
}
Dictionary <string, string> assetnames = new Dictionary <string, string>();
foreach (var item in job.Assets)
{
assetnames.Add((string)item.Key, (string)item.Value.SelectToken("UserName"));
}
job.PickupBy = assetnames.FirstOrDefault(x => x.Key == tasks1).Value;
job.DeliveryBy = assetnames.FirstOrDefault(x => x.Key == tasks2).Value;
job.CashDeliveryBy = job.Tasks.Count() > 3 ? assetnames.FirstOrDefault(x => x.Key == tasks3).Value : "";
job.PickupTime = (string)job.Tasks[1].SelectToken("ETA");
job.PickupAddress = (string)res.SelectToken("Order.From.AddressLine1");
job.ServiceCharge = (string)res.SelectToken("Order.OrderCart.ServiceCharge");
job.TotalToPay = (string)res.SelectToken("Order.OrderCart.TotalToPay");
job.SpecialNotetoDeliveryMan = (string)res.SelectToken("Order.NoteToDeliveryMan");
job.Order = JObject.Parse(res["Order"].ToString());
job.OrderCart = JObject.Parse(job.Order["OrderCart"].ToString());
job.PackageList = job.OrderCart.SelectToken("PackageList").ToArray();
job.DeliveryTime = (string)job.Tasks[2].SelectToken("ETA");
job.DeliveryAddress = (string)res.SelectToken("Order.To.AddressLine1");
job.PackageList = job.OrderCart.SelectToken("PackageList").ToArray();
foreach (var citem in job.PackageList)
{
PackageItem pi = new PackageItem()
{
Item = (string)citem.SelectToken("Item"),
Quantity = (decimal)citem.SelectToken("Quantity"),
Price = (decimal)citem.SelectToken("Price"),
Weight = (decimal)citem.SelectToken("Weight"),
Total = (decimal)citem.SelectToken("Total"),
};
job.PackageItemList.Add(pi);
}
FetchedJobs.Add(job);
JobIndex++;
this.PrintingStatus = "Printing";
SendToPrinter(job);
this.PrintingStatus = "Idle";
PropagateToNextJob();
}
catch (System.Exception ex)
{
MessageBox.Show(ex.InnerException.Message, ex.Message, MessageBoxButton.OK, MessageBoxImage.Error);
JobIndex++;
PropagateToNextJob();
return;
}
}
else
{
MessageBox.Show(string.Format("{0} Job not found. Press 'OK' to go to next job.", JobID), "", MessageBoxButton.OK, MessageBoxImage.Error);
JobIndex++;
PropagateToNextJob();
}
});
}
}
catch (Exception ex)
{
MessageBox.Show(ex.InnerException.Message, ex.Message, MessageBoxButton.OK, MessageBoxImage.Error); this.PrintButtonIsEnabled = true; return;
}
}
/// <summary>
/// Get the package dependencies that we need to installed. hasDependencyLoop is set to true if dependencyloop is detected.
/// </summary>
/// <param name="request"></param>
/// <param name="packageItem"></param>
/// <param name="hasDependencyLoop"></param>
/// <returns></returns>
internal static IEnumerable<PackageItem> GetPackageDependenciesToInstall(NuGetRequest request, PackageItem packageItem, ref bool hasDependencyLoop)
{
request.Debug(Messages.DebugInfoCallMethod, "NuGetClient", "GetPackageDependencies");
// No dependency
if (packageItem.Package.DependencySetList == null)
{
request.Debug(Messages.DebugInfoReturnCall, "NuGetClient", "GetPackageDependencies");
return Enumerable.Empty<PackageItem>();
}
// Returns list of dependency to be installed in the correct order that we should install them
List<PackageItem> dependencyToBeInstalled = new List<PackageItem>();
HashSet<PackageItem> permanentlyMarked = new HashSet<PackageItem>(new PackageItemComparer());
HashSet<PackageItem> temporarilyMarked = new HashSet<PackageItem>(new PackageItemComparer());
// checks that there are no dependency loop
hasDependencyLoop = !DepthFirstVisit(packageItem, temporarilyMarked, permanentlyMarked, dependencyToBeInstalled, request);
if (!hasDependencyLoop)
{
request.Debug(Messages.DebugInfoReturnCall, "NuGetClient", "GetPackageDependencies");
// remove the last item of the list because that is the package itself
dependencyToBeInstalled.RemoveAt(dependencyToBeInstalled.Count - 1);
return dependencyToBeInstalled;
}
// there are dependency loop.
request.Debug(Messages.DebugInfoReturnCall, "NuGetClient", "GetPackageDependencies");
return Enumerable.Empty<PackageItem>();
}
/// <summary>
/// Do a dfs visit. returns false if a cycle is encountered. Add the packageItem to the list at the end of each visit
/// </summary>
/// <param name="packageItem"></param>
/// <param name="dependencyToBeInstalled"></param>
/// <param name="permanentlyMarked"></param>
/// <param name="temporarilyMarked"></param>
/// <param name="request"></param>
/// <returns></returns>
internal static bool DepthFirstVisit(PackageItem packageItem, HashSet<PackageItem> temporarilyMarked, HashSet<PackageItem> permanentlyMarked, List<PackageItem> dependencyToBeInstalled, NuGetRequest request)
{
// dependency loop detected because the element is temporarily marked
if (temporarilyMarked.Contains(packageItem))
{
return false;
}
// this is permanently marked. So we don't have to visit it.
// This is to resolve a case where we have: A->B->C and A->C. Then we need this when we visit C again from either B or A.
if (permanentlyMarked.Contains(packageItem))
{
return true;
}
// Mark this node temporarily so we can detect cycle.
temporarilyMarked.Add(packageItem);
// Visit the dependency
foreach (var dependency in GetPackageDependenciesHelper(packageItem, request))
{
if (!DepthFirstVisit(dependency, temporarilyMarked, permanentlyMarked, dependencyToBeInstalled, request))
{
// if dfs returns false then we have encountered a loop
return false;
}
// otherwise visit the next dependency
}
// Add the package to the list so we can install later
dependencyToBeInstalled.Add(packageItem);
// Done with this node so mark it permanently
permanentlyMarked.Add(packageItem);
// Unmark it temporarily
temporarilyMarked.Remove(packageItem);
return true;
}
/// <summary>
/// Install a single package. Also install any of its dependency if they are available (the dependency will be installed first).
/// For dependencies, we will only get those that are not installed.
/// Operation is either install or download
/// installOrDownloadFunction is a function that takes in a packageitem and performs either install or download on it
/// </summary>
/// <param name="pkgItem"></param>
/// <param name="request"></param>
/// <param name="operation"></param>
/// <param name="installOrDownloadFunction"></param>
/// <returns></returns>
internal static bool InstallOrDownloadPackageHelper(PackageItem pkgItem, NuGetRequest request, string operation, Func<PackageItem, bool> installOrDownloadFunction)
{
// pkgItem.Sources is the source that the user input. The request will try this source.
request.OriginalSources = pkgItem.Sources;
int progressId = 0;
bool hasDependencyLoop = false;
// Get the dependencies that are not already installed
var dependencies = NuGetClient.GetPackageDependenciesToInstall(request, pkgItem, ref hasDependencyLoop).ToArray();
// If there is a dependency loop. Warn the user and don't install the package
if (hasDependencyLoop)
{
// package itself didn't install. Report error
request.WriteError(ErrorCategory.DeadlockDetected, pkgItem.Id, Constants.Messages.DependencyLoopDetected, pkgItem.Id);
return false;
}
// request may get canceled if there is a package dependencies missing
if (request.IsCanceled)
{
return false;
}
int n = 0;
int numberOfDependencies = dependencies.Count();
// Start progress
progressId = request.StartProgress(0, string.Format(CultureInfo.InvariantCulture, Messages.InstallingOrDownloadingPackage, operation, pkgItem.Id));
try
{
// check that this package has dependency and the user didn't want to skip dependencies
if (numberOfDependencies > 0)
{
// let's install dependencies
foreach (var dep in dependencies)
{
request.Progress(progressId, (n * 100 / (numberOfDependencies + 1)) + 1, string.Format(CultureInfo.InvariantCulture, Messages.InstallingOrDownloadingDependencyPackage, operation, dep.Id));
// Check that we successfully installed the dependency
if (!installOrDownloadFunction(dep))
{
request.WriteError(ErrorCategory.InvalidResult, dep.Id, Constants.Messages.DependentPackageFailedInstallOrDownload, dep.Id, CultureInfo.CurrentCulture.TextInfo.ToLower(operation));
return false;
}
n++;
request.Progress(progressId, (n * 100 / (numberOfDependencies + 1)), string.Format(CultureInfo.InvariantCulture, Messages.InstalledOrDownloadedDependencyPackage, operation, dep.Id));
}
}
// Now let's install the main package
if (installOrDownloadFunction(pkgItem))
{
return true;
}
}
catch (Exception ex)
{
ex.Dump(request);
}
finally
{
// Report that we have completed installing the package and its dependency this does not mean there are no errors.
// Just that it's completed.
request.CompleteProgress(progressId, false);
}
// package itself didn't install. Report error
request.WriteError(ErrorCategory.InvalidResult, pkgItem.Id, Constants.Messages.PackageFailedInstallOrDownload, pkgItem.Id, CultureInfo.CurrentCulture.TextInfo.ToLower(operation));
return false;
}
/// <summary>
/// Download a single package to destination without checking for dependencies
/// </summary>
/// <param name="pkgItem"></param>
/// <param name="request"></param>
/// <param name="destLocation"></param>
/// <returns></returns>
internal static bool DownloadSinglePackage(PackageItem pkgItem, NuGetRequest request, string destLocation)
{
if (string.IsNullOrWhiteSpace(pkgItem.PackageFilename) || pkgItem.PackageSource == null || pkgItem.PackageSource.Location == null
|| (pkgItem.PackageSource.IsSourceAFile && pkgItem.Package == null))
{
request.WriteError(ErrorCategory.ObjectNotFound, pkgItem.Id, Constants.Messages.UnableToResolvePackage, pkgItem.Id);
return false;
}
// this is if the user says -force
bool force = request.GetOptionValue("Force") != null;
// combine the path and the file name
destLocation = Path.Combine(destLocation, pkgItem.PackageFilename);
// if the file already exists
if (File.Exists(destLocation))
{
// if no force, just return
if (!force)
{
request.Verbose(Constants.Messages.SkippedDownloadedPackage, pkgItem.Id);
request.YieldPackage(pkgItem, pkgItem.PackageSource.Name);
return true;
}
// here we know it is forced, so delete
FileUtility.DeleteFile(destLocation, isThrow: false);
// if after we try delete, it is still there, tells the user we can't perform the action
if (File.Exists(destLocation))
{
request.WriteError(ErrorCategory.ResourceUnavailable, destLocation, Constants.Messages.UnableToOverwriteExistingFile, destLocation);
return false;
}
}
try
{
if (pkgItem.PackageSource.Repository.IsFile)
{
using (var input = File.OpenRead(pkgItem.Package.FullFilePath))
{
using (var output = new FileStream(destLocation, FileMode.Create, FileAccess.Write, FileShare.Read))
{
input.CopyTo(output);
}
}
}
else
{
//V2 download package protocol:
//sample url: http://www.nuget.org/api/v2/package/jQuery/2.1.3
string append = String.Format(CultureInfo.InvariantCulture, "/package/{0}/{1}", pkgItem.Id, pkgItem.Version);
string httpquery = PathUtility.UriCombine(pkgItem.PackageSource.Repository.Source, append);
NuGetClient.DownloadPackage(pkgItem.Id, pkgItem.Version, destLocation,
string.IsNullOrWhiteSpace(pkgItem.Package.ContentSrcUrl) ? httpquery : pkgItem.Package.ContentSrcUrl, request);
}
}
catch (Exception ex)
{
ex.Dump(request);
return false;
}
request.Verbose(Resources.Messages.SuccessfullyDownloaded, pkgItem.Id);
request.YieldPackage(pkgItem, pkgItem.PackageSource.Name);
return true;
}
/// <summary>
/// Install a single package without checking for dependencies
/// </summary>
/// <param name="pkgItem"></param>
/// <param name="request"></param>
/// <returns></returns>
internal static bool InstallSinglePackage(PackageItem pkgItem, NuGetRequest request)
{
PackageItem packageToBeInstalled;
// If the source location exists as a directory then we try to get the file location and provide to the packagelocal
if (Directory.Exists(pkgItem.PackageSource.Location))
{
var fileLocation = pkgItem.PackageSource.Repository.FindPackage(pkgItem.Id, new SemanticVersion(pkgItem.Version), request).FullFilePath;
packageToBeInstalled = NuGetClient.InstallPackageLocal(pkgItem.Id, pkgItem.Version, request, pkgItem.PackageSource, fileLocation);
}
else
{
//V2 download package protocol:
//sample url: http://www.nuget.org/api/v2/package/jQuery/2.1.3
string append = String.Format(CultureInfo.InvariantCulture, "/package/{0}/{1}", pkgItem.Id, pkgItem.Version);
string httpquery = PathUtility.UriCombine(pkgItem.PackageSource.Repository.Source, append);
// wait for the result from installpackage
packageToBeInstalled = NuGetClient.InstallPackage(pkgItem.Id, pkgItem.Version, request, pkgItem.PackageSource,
string.IsNullOrWhiteSpace(pkgItem.Package.ContentSrcUrl) ? httpquery : pkgItem.Package.ContentSrcUrl,
pkgItem.Package.PackageHash, pkgItem.Package.PackageHashAlgorithm);
}
// Package is installed successfully
if (packageToBeInstalled != null)
{
// if this is a http repository, return metadata from online
if (!pkgItem.PackageSource.Repository.IsFile)
{
request.YieldPackage(pkgItem, packageToBeInstalled.PackageSource.Name);
}
else
{
request.YieldPackage(packageToBeInstalled, packageToBeInstalled.PackageSource.Name);
}
request.Debug(Messages.DebugInfoReturnCall, "NuGetClient", "InstallSinglePackage");
return true;
}
return false;
}
/// <summary>
/// Creates a delayed lookup whose result can be used by an attached property.
/// </summary>
/// <param name="lookup">String to resolve later.</param>
/// <param name="targetItem">Target item that is related to the result.</param>
/// <param name="targetType">Type the result must resolve to.</param>
public DelayedItemLookup(string lookup, PackageItem targetItem, Type targetType)
{
this.Lookup = lookup;
this.targetItem = targetItem;
this.targetType = targetType;
}
/// <summary>
/// Download a package from a file repository that matches the given version and name and install it on the local system.
/// </summary>
/// <param name="packageName">Package name</param>
/// <param name="version">Package version</param>
/// <param name="request">An object passed in from the PackageManagement platform that contains APIs that can be used to interact with it </param>
/// <param name="source">Package source</param>
/// <param name="sourceFilePath">File source path pointing to the package to be installed</param>
/// <returns>PackageItem object</returns>
internal static PackageItem InstallPackageLocal(
string packageName,
string version,
NuGetRequest request,
PackageSource source,
string sourceFilePath
)
{
request.Debug(Messages.DebugInfoCallMethod, "NuGetClient", "InstallPackageLocal");
string tempSourceFilePath = null;
string tempSourceDirectory = null;
string directoryToDeleteWhenFailed = String.Empty;
bool needToDelete = false;
try
{
string destinationFilePath = request.Destination;
request.Verbose(string.Format(CultureInfo.InvariantCulture, "InstallPackageLocal' - name='{0}', version='{1}',destination='{2}'", packageName, version, destinationFilePath));
request.Debug(sourceFilePath);
if (string.IsNullOrWhiteSpace(sourceFilePath))
{
throw new ArgumentNullException(sourceFilePath);
}
if (!File.Exists(sourceFilePath)) {
throw new FileNotFoundException(sourceFilePath);
}
//Create the destination directory if it does not exist
if (!Directory.Exists(destinationFilePath)) {
Directory.CreateDirectory(destinationFilePath);
directoryToDeleteWhenFailed = destinationFilePath;
}
//Make a temp folder in the user appdata temp directory
tempSourceFilePath = FileUtility.GetTempFileFullPath(fileExtension: NuGetConstant.PackageExtension);
//Copy over the source file from the folder repository to the temp folder
File.Copy(sourceFilePath, tempSourceFilePath, true);
//Unzip it
tempSourceDirectory = PackageUtility.DecompressFile(tempSourceFilePath);
//Get a packge directory under the destination path to store the package
string installedFolder = FileUtility.MakePackageDirectoryName(request.ExcludeVersion.Value, destinationFilePath, packageName, version);
// if we did not set the directory before, then the destinationFilePath already exists, so we should not delete it
if (string.IsNullOrWhiteSpace(directoryToDeleteWhenFailed))
{
directoryToDeleteWhenFailed = installedFolder;
}
//File folder format of the Nuget packages looks like the following after installed:
//Jquery.2.0.1
// - JQuery.2.0.1.nupkg
// - contents and other stuff
//Copy the unzipped files to under the package installed folder
FileUtility.CopyDirectory(tempSourceDirectory, installedFolder, true);
//Read the package manifest and return the package object
string nuspec = Path.Combine(installedFolder, packageName) + NuGetConstant.ManifestExtension;
PackageBase package = PackageUtility.ProcessNuspec(nuspec);
var pkgItem = new PackageItem {
Package = package,
PackageSource = source,
FastPath = request.MakeFastPath(source, package.Id, package.Version),
FullPath = installedFolder
};
// Delete the nuspec file
//Get a package file path
var nuspecFilePath = Path.Combine(installedFolder, packageName + NuGetConstant.ManifestExtension);
if (File.Exists(nuspecFilePath))
{
FileUtility.DeleteFile(nuspecFilePath, false);
}
request.Debug(Messages.DebugInfoReturnCall, "NuGetClient", "InstallPackageLocal");
return pkgItem;
} catch (Exception ex) {
needToDelete = true;
// the warning will be package "packageName" failed to install
ex.Dump(request);
request.WriteError(ErrorCategory.InvalidResult, packageName, Constants.Messages.PackageFailedInstallOrDownload, packageName, CultureInfo.CurrentCulture.TextInfo.ToLower(Constants.Install));
throw;
} finally {
if (needToDelete && Directory.Exists(directoryToDeleteWhenFailed))
{
FileUtility.DeleteDirectory(directoryToDeleteWhenFailed, true, isThrow: false);
}
FileUtility.DeleteFile(tempSourceFilePath, isThrow:false);
FileUtility.DeleteDirectory(tempSourceDirectory, recursive: true, isThrow: false);
}
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Graphics g = context.Graphics;
Rectangle targetRect = new Rectangle(
context.Bounds.X + this.LeftMargin,
context.Bounds.Y,
context.Bounds.Width - this.LeftMargin,
context.Bounds.Height);
// Retrieve item information
PackageItem item = node.Tag as PackageItem;
Version itemVersion = null;
Version newVersion = null;
bool highlightItemVersion = item is LocalPackageItem;
bool isInstalled = false;
bool isUpToDate = false;
if (item != null)
{
isInstalled = item.InstalledPackageInfo != null;
if (item.InstalledPackageInfo != null)
{
itemVersion = item.InstalledPackageInfo.Version;
}
else if (item.ItemPackageInfo != null)
{
itemVersion = item.ItemPackageInfo.Version;
}
if (item.NewestPackageInfo != null)
{
newVersion = item.NewestPackageInfo.Version;
}
if (itemVersion != null && newVersion != null)
{
isUpToDate = itemVersion >= newVersion;
}
}
string itemVersionText = PackageManager.GetDisplayedVersion(itemVersion);
string newVersionText = isInstalled && !isUpToDate?PackageManager.GetDisplayedVersion(newVersion) : string.Empty;
// Determine background color based on versioning
Brush backgroundBrush = null;
if (isInstalled)
{
if (newVersion != null)
{
if (itemVersion >= newVersion)
{
backgroundBrush = new SolidBrush(Color.FromArgb(32, 160, 255, 0));
}
else
{
backgroundBrush = new SolidBrush(Color.FromArgb(32, 255, 160, 0));
}
}
else
{
backgroundBrush = new SolidBrush(Color.FromArgb(32, 128, 128, 128));
}
}
// Calculate drawing layout and data
StringFormat stringFormat = new StringFormat {
Trimming = StringTrimming.EllipsisCharacter, Alignment = StringAlignment.Center, FormatFlags = StringFormatFlags.NoWrap
};
Rectangle currentVersionRect;
Rectangle newestVersionRect;
{
SizeF currentVersionSize;
SizeF newestVersionSize;
// Base info
{
currentVersionSize = g.MeasureString(itemVersionText, context.Font, targetRect.Width, stringFormat);
newestVersionSize = g.MeasureString(newVersionText, context.Font, targetRect.Width, stringFormat);
currentVersionRect = new Rectangle(targetRect.X, targetRect.Y, targetRect.Width, (int)currentVersionSize.Height);
newestVersionRect = new Rectangle(targetRect.X, targetRect.Y + currentVersionRect.Height, targetRect.Width, targetRect.Height - currentVersionRect.Height);
}
// Alignment info
{
Size totelContentSize = new Size(Math.Max(currentVersionRect.Width, newestVersionRect.Width), currentVersionRect.Height + (int)newestVersionSize.Height);
Point alignAdjust = new Point(0, Math.Max((targetRect.Height - totelContentSize.Height) / 2, 0));
currentVersionRect.X += alignAdjust.X;
currentVersionRect.Y += alignAdjust.Y;
newestVersionRect.X += alignAdjust.X;
newestVersionRect.Y += alignAdjust.Y;
}
}
// Draw background and version texts
if (backgroundBrush != null)
{
g.FillRectangle(backgroundBrush, targetRect);
}
{
bool bothVisible = !string.IsNullOrWhiteSpace(itemVersionText) && !string.IsNullOrWhiteSpace(newVersionText);
highlightItemVersion = highlightItemVersion || !bothVisible;
g.DrawString(itemVersionText, context.Font, new SolidBrush(Color.FromArgb((highlightItemVersion ? 255 : 128) / (context.Enabled ? 1 : 2), this.Parent.ForeColor)), currentVersionRect, stringFormat);
g.DrawString(newVersionText, context.Font, new SolidBrush(Color.FromArgb((highlightItemVersion ? 128 : 255) / (context.Enabled ? 1 : 2), this.Parent.ForeColor)), newestVersionRect, stringFormat);
}
}
/// <summary>
/// Perform package uninstallation.
/// </summary>
/// <param name="request">Object given by the PackageManagement platform</param>
/// <param name="pkg">PackageItem object</param>
internal static void UninstallPackage(NuGetRequest request, PackageItem pkg)
{
request.Debug(Messages.DebugInfoCallMethod, "NuGetClient", "UninstallPackage");
if (pkg == null)
{
throw new ArgumentNullException(paramName: "pkg");
}
var dir = pkg.InstalledDirectory;
if (String.IsNullOrWhiteSpace(dir) || !Directory.Exists(dir))
{
return;
}
FileUtility.DeleteDirectory(pkg.InstalledDirectory, recursive:true, isThrow:false);
//Inform a user which package is deleted via the packageManagement platform
request.Verbose(Messages.UninstalledPackage, "NuGetClient", pkg.Id);
request.YieldPackage(pkg, pkg.Id);
}
public ManifestItem(string key, PackageItem item, XElement xml)
{
this.Key = key;
this.Item = item;
this.Xml = xml;
}
public void UpdateLocalModState(ISupportModding game)
{
_package = null;
SetSharedState(game);
}
public void CrearOrden()
{
order = new Order();
order.OrderId = Guid.NewGuid();
order.Agency = _context.Agency.First();
order.AgencyId = order.Agency.AgencyId;
order.Office = _context.Office.First();
order.OfficeId = order.Office.OfficeId;
order.User = _context.User.First();
order.UserId = _context.User.First().UserId;
order.Date = DateTime.Now.Date;
//order.TipoPago = _context.TipoPago.First();
//order.TipoPagoId = order.TipoPago.TipoPagoId;
order.Type = type;
if (type == "Mixto")
{
order.Number = "MX";
}
else if (type == "Paquete")
{
order.Number = "PA";
}
else if (type == "Alimentos")
{
order.Number = "AL";
}
else if (type == "Medicina")
{
order.Number = "ME";
}
else
{
order.Number = "RE";
}
order.Number += DateTime.Now.ToString("MMddyyyyHHmm");
if (listVA.Count() > 0)
{
for (int i = 0; i < listVA.Count(); i++)
{
ValorAduanalItem value = new ValorAduanalItem();
value.ValorAduanalItemId = Guid.NewGuid();
value.OrderId = order.OrderId;
value.Order = order;
value.ValorAduanal = _context.ValorAduanal.Where(x => x.ValorAduanalId == Guid.Parse(listVA[i])).First();
value.ValorAduanalId = Guid.Parse(listVA[i]);
order.ValorAduanal += value.ValorAduanal.Value;
order.ValorAduanalItem.Add(value);
_context.Add(value);
}
}
order.CantLb = cantlb;
order.PriceLb = preciolb;
order.OtrosCostos = otrosgastos;
order.ValorAduanal = valor;
order.Amount = order.ValorAduanal + (order.CantLb * order.PriceLb) + order.OtrosCostos;
order.Balance = order.Amount - order.ValorPagado;
if (order.Balance != 0)//si el balance no es 0 el status es pendiente si el valanece es 0 iniciado,
{
order.Status = "Pendiente";
}
else
{
order.Status = "Iniciada";
}
order.ContactId = contactId;
order.ClientId = _context.Contact.Find(order.ContactId).ClientId;
_context.Add(order);
_context.SaveChanges();
//Crear un Pacquete
Package package = new Package();
package.PackageId = Guid.NewGuid();
package.PackageNavigation = order;
_context.Add(package);
for (int i = 0; i < listProduct.Count; i++)
{
PackageItem packageItem = new PackageItem();
packageItem.PackageItemId = Guid.NewGuid();
packageItem.PackageId = pac.PackageId;
packageItem.Package = pac;
packageItem.Product = _context.Product.Where(x => x.ProductId == Guid.Parse(listProduct[i])).First();
packageItem.ProductId = packageItem.Product.ProductId;
_context.Add(packageItem);
}
order.Package = package;
_context.SaveChanges();
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as PackageItemComponent;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (Type != null)
{
dest.Type = (Hl7.Fhir.Model.CodeableConcept)Type.DeepCopy();
}
if (Quantity != null)
{
dest.Quantity = (Hl7.Fhir.Model.Quantity)Quantity.DeepCopy();
}
if (Material != null)
{
dest.Material = new List <Hl7.Fhir.Model.CodeableConcept>(Material.DeepCopy());
}
if (AlternateMaterial != null)
{
dest.AlternateMaterial = new List <Hl7.Fhir.Model.CodeableConcept>(AlternateMaterial.DeepCopy());
}
if (Device != null)
{
dest.Device = new List <Hl7.Fhir.Model.ResourceReference>(Device.DeepCopy());
}
if (ManufacturedItem != null)
{
dest.ManufacturedItem = new List <Hl7.Fhir.Model.ResourceReference>(ManufacturedItem.DeepCopy());
}
if (PackageItem != null)
{
dest.PackageItem = new List <Hl7.Fhir.Model.MedicinalProductPackaged.PackageItemComponent>(PackageItem.DeepCopy());
}
if (PhysicalCharacteristics != null)
{
dest.PhysicalCharacteristics = (Hl7.Fhir.Model.ProdCharacteristic)PhysicalCharacteristics.DeepCopy();
}
if (OtherCharacteristics != null)
{
dest.OtherCharacteristics = new List <Hl7.Fhir.Model.CodeableConcept>(OtherCharacteristics.DeepCopy());
}
if (ShelfLifeStorage != null)
{
dest.ShelfLifeStorage = new List <Hl7.Fhir.Model.ProductShelfLife>(ShelfLifeStorage.DeepCopy());
}
if (Manufacturer != null)
{
dest.Manufacturer = new List <Hl7.Fhir.Model.ResourceReference>(Manufacturer.DeepCopy());
}
return(dest);
}
private Dictionary <PackageItem, WixItem> ProcessIntermediates(IEnumerable <Intermediate> intermediates)
{
Dictionary <PackageItem, WixItem> wixItems = new Dictionary <PackageItem, WixItem>();
foreach (Intermediate intermediate in intermediates)
{
foreach (PackageItem item in intermediate.Items)
{
File file = item as File;
if (file != null)
{
WixFile msiFile = new WixFile(this, file);
wixItems.Add(file, msiFile);
NgenPackageItem ngen;
if (Ngen.TryGetPackageItem(file, out ngen))
{
ngen.LineNumber = file.LineNumber;
file.Items.Add(ngen);
WixNativeImage nativeImage = new WixNativeImage(this, ngen);
wixItems.Add(ngen, nativeImage);
}
}
else
{
Folder folder = item as Folder;
if (folder != null)
{
if (folder.External)
{
WixFolderReference msiFolderRef = new WixFolderReference(this, folder);
wixItems.Add(folder, msiFolderRef);
}
else
{
WixFolder msiFolder = new WixFolder(this, folder);
wixItems.Add(folder, msiFolder);
}
}
else
{
InprocServer inprocServer = item as InprocServer;
if (null != inprocServer)
{
WixClassId classId = new WixClassId(this, inprocServer);
wixItems.Add(inprocServer, classId);
}
else
{
OutprocServer outprocServer = item as OutprocServer;
if (null != outprocServer)
{
WixClassId classId = new WixClassId(this, outprocServer);
wixItems.Add(outprocServer, classId);
}
else
{
Property property = item as Property;
if (property != null)
{
WixProperty prop = new WixProperty(this, property);
wixItems.Add(property, prop);
}
else
{
FileSearch fileSearch = item as FileSearch;
if (fileSearch != null)
{
WixFileSearch fs = new WixFileSearch(this, fileSearch);
wixItems.Add(fileSearch, fs);
}
else
{
Group group = item as Group;
if (group != null)
{
WixGroup msiGroup = new WixGroup(this, group);
wixItems.Add(group, msiGroup);
}
else if (item is Package)
{
// TODO: send an error message since library files cannot process Package elements.
}
}
}
}
}
}
}
}
}
// Fix up all the item parents and groups now that we have them
// all processed into a single look up dictionary.
foreach (var kv in wixItems)
{
PackageItem pi = kv.Key;
WixItem wi = kv.Value;
if (pi.Parent != null)
{
wi.Parent = wixItems[pi.Parent];
}
if (pi.Group != null)
{
wi.Group = (WixGroup)wixItems[pi.Group];
wi.Group.ContainedWixItems.Add(wi);
}
}
return(wixItems);
}
private void __packageView_AfterSelect(object sender, TreeViewEventArgs e)
{
PackageItem item = e.Node.Tag as PackageItem;
PopulatePackageItemInfo(item);
}
public override void Execute(PackageItem item)
{
}
public void ExecuteMethodInstallPackagesWithInitScript()
{
// source repo has A, B, C
// solution repo has A
// project repo has C
// install B
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", content: new string[] { "hello world" }, tools: new string[] { "init.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var solutionRepository = new MockPackageRepository();
solutionRepository.AddPackage(packageA);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
var localRepository = new MockPackageRepository();
localRepository.Add(packageC);
var projectManager = CreateProjectManager(localRepository, solutionRepository);
var project = new Mock <Project>();
project.Setup(p => p.Properties.Item("TargetFrameworkMoniker").Value).Returns(".NETFramework, Version=4.0");
var scriptExecutor = new Mock <IScriptExecutor>();
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.LocalRepository).Returns(solutionRepository);
packageManager.Setup(p => p.InstallPackage(projectManager, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>())).
Raises(p => p.PackageInstalled += null, packageManager, new PackageOperationEventArgs(packageB, null, ""));
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateOnlineProvider(packageManager.Object, null, null, null, project.Object, scriptExecutor.Object, solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
// init.ps1 should be executed
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), PowerShellScripts.Init, packageB, null, null, It.IsAny <ILogger>()), Times.Once());
// InstallPackage() should get called
packageManager.Verify(p => p.InstallPackage(
projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>()), Times.Once());
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.WaitOne();
}
internal override bool PreUninstall(PackageItem packageItem)
{
// run the uninstall script
return(true);
}
public void ExecuteMethodDoNotCallUpdatePackageIfNoProjectIsChecked()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var packageB2 = PackageUtility.CreatePackage("B", "4.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageB2);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
mockPackageManager.Verify(p => p.UpdatePackage(
new Project[] { project1, project2 },
packageB2,
It.IsAny <IEnumerable <PackageOperation> >(),
true,
false,
provider,
provider), Times.Never());
manualEvent.Set();
};
var extensionB2 = new PackageItem(provider, packageB2);
// Act
provider.Execute(extensionB2);
// do not allow the method to return
manualEvent.Wait();
}
public void ExecuteMethodDoNotCallInstallPackageIfUserPressCancelOnTheProjectSelectorButton()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var localRepository2 = new MockPackageRepository();
// project2 doesn't have the package installed
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository2);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns((Func <IEnumerable <Project> >)null);
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
packageManager.Verify(p => p.InstallPackage(
projectManager2.Object,
packageB.Id,
packageB.Version,
false,
false,
provider),
Times.Never());
// Assert
packageManager.Verify(p => p.UninstallPackage(
projectManager1.Object,
packageB.Id,
null,
false,
false,
provider),
Times.Never());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
private static void AssertItem(PackageItem item, string name, int numberOfChildren)
{
Assert.Equal(name, item.Name);
Assert.Equal(numberOfChildren, item.Children.Count);
}
public WixItem(WixBackendCompiler backend, PackageItem item)
{
this.Backend = backend;
this.Item = item;
}
private void UpdatePackageItemBackground(PackageItem packageItem)
{
if (Module.PackageManager.VisualStudioPlan.Contains(packageItem.PackageIdentity))
packageItem.ItemBackground = "Blue";
else if (Module.PackageManager.UpdatePlan.Contains(packageItem.PackageIdentity))
packageItem.ItemBackground = "Yellow";
else if (Module.PackageManager.InstallPlan.Contains(packageItem.PackageIdentity))
packageItem.ItemBackground = "Green";
else if (Module.PackageManager.RemovePlan.Contains(packageItem.PackageIdentity))
packageItem.ItemBackground = "Red";
else
packageItem.ItemBackground = null;
}
/// <summary>
/// Resolves the lookup but may not fail if missing.
/// </summary>
/// <param name="context">Frontend compiler containing all the objects that may satisfy the resolution.</param>
/// <param name="allowUnresolved">Flag specifying whether to allow unresolved items to be returned.</param>
/// <returns>Item resolved.</returns>
public PackageItem Resolve(FrontendCompiler context, bool allowUnresolved)
{
if (this.ResolvedItem == null)
{
string targetPropertyName = this.targetProperty == null ? String.Empty : this.targetProperty.Name;
CompilerMessage message = null;
PackageItem item = null;
if (context.TryGetItemById(this.Lookup, out item))
{
if (this.targetType.IsInstanceOfType(item))
{
if (this.targetProperty != null)
{
this.SetTarget(context, item);
}
}
else if (!allowUnresolved)
{
message = CompilerMessage.InvalidIdResolution(
targetPropertyName,
this.Lookup,
this.targetType.Name,
item.GetType().Name);
}
}
else if (this.targetType.IsSubclassOf(typeof(FileSystemResource)) || this.targetType == typeof(IFileReference))
{
Resource resource;
FileSystemResourceManager manager = (FileSystemResourceManager)context.GetService(typeof(FileSystemResourceManager));
if (manager.TryFindResourceByPath(context, this.Lookup, out resource))
{
if (this.targetType.IsInstanceOfType(resource))
{
if (this.targetProperty != null)
{
item = this.SetTarget(context, resource);
}
else
{
item = resource;
}
}
else
{
message = CompilerMessage.InvalidIdResolution(
targetPropertyName,
this.Lookup,
this.targetType.Name,
resource.GetType().Name);
}
}
else if (!allowUnresolved)
{
message = CompilerMessage.UnknownFileSystemResolution(
targetPropertyName,
this.Lookup,
this.targetType.Name);
}
}
else if (!allowUnresolved)
{
message = CompilerMessage.UnknownIdResolution(
targetPropertyName,
this.Lookup,
this.targetType.Name);
}
if (message != null)
{
context.OnMessage(new CompilerMessageEventArgs(message, this.targetItem));
}
this.ResolvedItem = item;
}
return(this.ResolvedItem);
}
private string MakeTagId(PackageItem pkg)
{
if (pkg == null || pkg.Package == null)
{
return string.Empty;
}
// the tag id will look like this zlib#1.2.8.8#Jean-loup Gailly;Mark Adler
return string.Format(CultureInfo.CurrentCulture, "{0}#{1}", pkg.Package.Id, pkg.Package.Version.ToString());
}
public void InstallPackageInvokeInstallScript()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", tools: new[] { "install.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
var fileSystem = new Mock <IVsProjectSystem>();
fileSystem.SetupGet(f => f.UniqueName).Returns("Project1");
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager1.Setup(p => p.AddPackageReference(packageB, false, false))
.Raises(p => p.PackageReferenceAdded += (o, a) => { }, new PackageOperationEventArgs(packageB, fileSystem.As <IFileSystem>().Object, "x:\\nuget"));
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
packageManager.Setup(p => p.InstallPackage(
new[] { project1 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
It.IsAny <ILogger>(),
It.IsAny <IPackageOperationEventListener>()))
.Callback(
(IEnumerable <Project> projects,
IPackage package,
IEnumerable <PackageOperation> operations,
bool ignoreDependencies,
bool allowPrereleaseVersions,
ILogger logger,
IPackageOperationEventListener eventListener) =>
{
eventListener.OnBeforeAddPackageReference(project1);
projectManager1.Object.AddPackageReference(packageB, false, false);
});
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var scriptExecutor = new Mock <IScriptExecutor>();
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, scriptExecutor: scriptExecutor.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception callbackException = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
scriptExecutor.Verify(p => p.Execute("x:\\nuget", "install.ps1", packageB, project1, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
catch (Exception exception)
{
callbackException = exception;
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
if (callbackException != null)
{
throw callbackException;
}
}
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating()
{
// Arrange
var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA_12);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA_10);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.LocalRepository).Returns(localRepository);
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA_10);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
mockPackageManager.Verify(p => p.UpdatePackage(
new Project[0],
packageA_12,
new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) },
true,
false,
provider,
provider), Times.Once());
}
catch (Exception e)
{
exception = e;
}
finally
{
manualEvent.Set();
}
};
var extensionA_12 = new PackageItem(provider, packageA_12);
// Act
provider.Execute(extensionA_12);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
private List<PackageItem> getPackageItems(bool silent)
{
List<PackageItem> result = new List<PackageItem>();
string ddoc = getPackageXml(!silent);
if (!string.IsNullOrEmpty(ddoc))
{
try
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(ddoc);
XmlElement root = doc.DocumentElement;
XmlNodeList pkgs = root.SelectNodes("package");
if (pkgs != null)
{
foreach (XmlNode pk in pkgs)
{
PackageItem pi = new PackageItem();
pi.author = pk.Attributes["author"].InnerText;
pi.date = DateTime.Parse(pk.Attributes["date"].InnerText);
pi.description = pk.Attributes["description"].InnerText;
pi.link = pk.Attributes["link"].InnerText;
pi.minCoreVersion = Version.Parse(pk.Attributes["mincoreversion"].InnerText.Substring(1));
pi.packagetype = pk.Attributes["type"].InnerText;
pi.plugintype = pk.Attributes["plugintype"].InnerText;
pi.version = Version.Parse(pk.Attributes["version"].InnerText.Substring(1));
result.Add(pi);
}
if (!silent)
{
_pkgVersion = Version.Parse(root.Attributes["version"].InnerText.Substring(1));
_pkgDate = DateTime.Parse(root.Attributes["date"].InnerText);
Properties.Settings.Default.LastCheckDateTime = DateTime.Now;
Properties.Settings.Default.Save();
}
}
}
catch
{
}
}
return result;
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
Assert.Equal(RepositoryOperationNames.Install, sourceRepository.LastOperation);
mockPackageManager.Verify(p => p.InstallPackage(
new Project[] { project1, project2 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
includePrerelease,
provider,
provider), Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
internal void UpdateMarkLists(PackageItem packageItem)
{
IEnumerable<Package> packages = null;
switch (packageItem.Status)
{
case PackageItemStatus.MarkedForVisualStudio:
packages = Module.PackageManager.IdentifyOwnDependencies(packageItem.PackageIdentity).Where(n => n.IsInstalled && n.Name.StartsWith(packageItem.Name));
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectVisualStudio);
Module.PackageManager.AddMarks(packages, Mark.IndirectVisualStudio);
break;
case PackageItemStatus.MarkedForInstallation:
packages = Module.PackageManager.IdentifyDependencies(packageItem.PackageIdentity).Where(n => !n.IsInstalled);
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectInstall);
Module.PackageManager.AddMarks(packages, Mark.IndirectInstall);
break;
case PackageItemStatus.MarkedForReinstallation:
packages = Module.PackageManager.IdentifyDependencies(packageItem.PackageIdentity).Where(n => !n.IsInstalled);
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectReinstall);
Module.PackageManager.AddMarks(packages, Mark.IndirectReinstall);
break;
case PackageItemStatus.MarkedForUpdate:
packages = Module.PackageManager.IdentifyPackageAndDependencies((Package)packageItem.PackageIdentity.AvailableNewestUpdate);
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectUpdate);
Module.PackageManager.AddMarks(packages, Mark.IndirectUpdate);
break;
case PackageItemStatus.MarkedForUpgrade:
packages = Module.PackageManager.IdentifyPackageAndDependencies((Package)packageItem.PackageIdentity.AvailableNewestUpdate);
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectUpgrade);
Module.PackageManager.AddMarks(packages, Mark.IndirectUpgrade);
break;
case PackageItemStatus.MarkedForRemoval:
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectRemove);
break;
case PackageItemStatus.MarkedForCompleteRemoval:
packages = Module.PackageManager.IdentifyDependencies(packageItem.PackageIdentity).Where(package => !(package.Name == "coapp" && package.IsActive)).Where(n => n.IsInstalled);
Module.PackageManager.AddMark(packageItem.PackageIdentity, Mark.DirectCompletelyRemove);
Module.PackageManager.AddMarks(packages, Mark.IndirectCompletelyRemove);
break;
default:
Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectRemove);
if (Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectVisualStudio))
{
packages = Module.PackageManager.IdentifyOwnDependencies(packageItem.PackageIdentity).Where(n => n.IsInstalled && n.Name.StartsWith(packageItem.Name));
Module.PackageManager.RemoveMarks(packages, Mark.IndirectVisualStudio);
}
else if (Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectInstall))
{
packages = Module.PackageManager.IdentifyDependencies(packageItem.PackageIdentity).Where(n => !n.IsInstalled);
Module.PackageManager.RemoveMarks(packages, Mark.IndirectInstall);
}
else if (Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectCompletelyRemove))
{
packages = Module.PackageManager.IdentifyDependencies(packageItem.PackageIdentity).Where(n => n.IsInstalled);
Module.PackageManager.RemoveMarks(packages, Mark.IndirectCompletelyRemove);
}
else if (Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectUpdate))
{
packages = Module.PackageManager.IdentifyPackageAndDependencies((Package)packageItem.PackageIdentity.AvailableNewestUpdate);
Module.PackageManager.RemoveMarks(packages, Mark.IndirectUpdate);
}
else if (Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectUpgrade))
{
packages = Module.PackageManager.IdentifyPackageAndDependencies((Package)packageItem.PackageIdentity.AvailableNewestUpdate);
Module.PackageManager.RemoveMarks(packages, Mark.IndirectUpgrade);
}
else if (Module.PackageManager.RemoveMark(packageItem.PackageIdentity, Mark.DirectReinstall))
{
packages = Module.PackageManager.IdentifyDependencies(packageItem.PackageIdentity).Where(n => n.IsInstalled);
Module.PackageManager.RemoveMarks(packages, Mark.IndirectReinstall);
}
break;
}
packages = packages == null ? new[] {packageItem.PackageIdentity} : packages.Union(new[] {packageItem.PackageIdentity});
ApplyButton.IsEnabled = Module.PackageManager.IsAnyMarked;
UpdatePackageItemBackgrounds(packages);
}
/// <summary>
/// Return view of packages
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult ShowPackages(int id = 0)
{
var model = new PackageViewModel();
if (id > 0)
{
try
{
model.ServiceRequestPackage = _portfolioService.GetServiceRequestPackage(UserId, id);
}
catch (Exception exception)
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = $"Failed to retrieve service package, error: {exception.Message}";
return(View(model));
}
}
//create the list of tags
List <IServicePackageTag> tags = new List <IServicePackageTag>();
if (model.ServiceRequestPackage == null)
{
model.ServiceRequestPackage = new ServiceRequestPackageDto();
}
if (model.ServiceRequestPackage.ServiceTags != null)
{
tags.AddRange(from s in model.ServiceRequestPackage.ServiceTags select(IServicePackageTag) s);
}
if (model.ServiceRequestPackage.ServiceOptionCategoryTags != null)
{
tags.AddRange(from o in model.ServiceRequestPackage.ServiceOptionCategoryTags select(IServicePackageTag) o);
}
//add useful info for display and for linking
var packageItems = new List <PackageItem>();
foreach (var tag in tags.OrderBy(t => t.Order))
{
try
{
if (tag is IServiceTagDto)
{
var serviceTag = (IServiceTagDto)tag;
var tagInfo = new PackageItem
{
Name = _portfolioService.GetService(serviceTag.ServiceId).Name,
Id = serviceTag.Id,
Tag = tag
};
packageItems.Add(tagInfo);
}
else if (tag is IServiceOptionCategoryTagDto)
{
var categoryTag = (IServiceOptionCategoryTagDto)tag;
var tagInfo = new PackageItem
{
Name = _portfolioService.GetServiceOptionCategory(UserId, categoryTag.ServiceOptionCategoryId).Name,
Id = categoryTag.Id,
Tag = tag
};
packageItems.Add(tagInfo);
}
}
catch (Exception) { }
}
model.PackageItems = packageItems;
return(View(model));
}
/// <summary>
/// Communicate to the PackageManagement platform about the package info
/// </summary>
/// <param name="pkg"></param>
/// <param name="searchKey"></param>
/// <param name="destinationPath"></param>
/// <returns></returns>
internal bool YieldPackage(PackageItem pkg, string searchKey, string destinationPath=null)
{
try
{
if (YieldSoftwareIdentity(pkg.FastPath, pkg.Package.Id, pkg.Package.Version.ToString(), "semver", pkg.Package.Summary, pkg.PackageSource.Name, searchKey, pkg.FullPath, pkg.PackageFilename) != null)
{
if (pkg.Package.DependencySetList != null)
{
//iterate thru the dependencies and add them to the software identity.
foreach (PackageDependencySet depSet in pkg.Package.DependencySetList)
{
foreach (var dep in depSet.Dependencies)
{
AddDependency(NuGetConstant.ProviderName, dep.Id, dep.DependencyVersion.ToStringSafe(), null, null);
}
}
}
// downlevel machine does not have AddTagId interface in request object so it will return null
// hence we can't check it here.
AddTagId(MakeTagId(pkg));
// if we need to report installation location, add a payload and add directory to that
if (!string.IsNullOrWhiteSpace(destinationPath))
{
string payload = AddPayload();
if (string.IsNullOrWhiteSpace(payload))
{
return false;
}
AddDirectory(payload, Path.GetFileName(destinationPath), Path.GetDirectoryName(destinationPath), null, true);
}
if (AddMetadata(pkg.FastPath, "copyright", pkg.Package.Copyright) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "description", pkg.Package.Description) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "licenseNames", pkg.Package.LicenseNames) == null)
{
return false;
}
if (AddMetadata(pkg.FastPath, "requireLicenseAcceptance", pkg.Package.RequireLicenseAcceptance.ToString()) == null)
{
return false;
}
if (AddMetadata(pkg.FastPath, "language", pkg.Package.Language) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "releaseNotes", pkg.Package.ReleaseNotes) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "isLatestVersion", pkg.Package.IsLatestVersion.ToString()) == null)
{
return false;
}
if (AddMetadata(pkg.FastPath, "isAbsoluteLatestVersion", pkg.Package.IsAbsoluteLatestVersion.ToString()) == null)
{
return false;
}
if (pkg.Package.MinClientVersion != null && AddMetadata(pkg.FastPath, "minClientVersion", pkg.Package.MinClientVersion.ToString()) == null)
{
return false;
}
if (pkg.Package.VersionDownloadCount != -1)
{
if (AddMetadata(pkg.FastPath, "versionDownloadCount", pkg.Package.VersionDownloadCount.ToString(CultureInfo.CurrentCulture)) == null)
{
return false;
}
}
if (pkg.Package.DownloadCount != -1)
{
if (AddMetadata(pkg.FastPath, "downloadCount", pkg.Package.DownloadCount.ToString(CultureInfo.CurrentCulture)) == null)
{
return false;
}
}
if (pkg.Package.PackageSize != -1)
{
if (AddMetadata(pkg.FastPath, "packageSize", pkg.Package.PackageSize.ToString(CultureInfo.CurrentCulture)) == null)
{
return false;
}
}
if (pkg.Package.Published != null) {
if (AddMetadata(pkg.FastPath, "published", pkg.Package.Published.ToString()) == null) {
return false;
}
}
if (pkg.Package.Created != null)
{
if (AddMetadata(pkg.FastPath, "created", pkg.Package.Created.ToString()) == null)
{
return false;
}
}
if (pkg.Package.LastEdited != null)
{
if (AddMetadata(pkg.FastPath, "lastEdited", pkg.Package.LastEdited.ToString()) == null)
{
return false;
}
}
if (pkg.Package.LastUpdated != null)
{
if (AddMetadata(pkg.FastPath, "lastUpdated", pkg.Package.LastUpdated.ToString()) == null)
{
return false;
}
}
if (AddMetadata(pkg.FastPath, "tags", pkg.Package.Tags) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "title", pkg.Package.Title) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "developmentDependency", pkg.Package.DevelopmentDependency.ToString()) == null) {
return false;
}
if (AddMetadata(pkg.FastPath, "FromTrustedSource", pkg.PackageSource.Trusted.ToString()) == null) {
return false;
}
if (pkg.Package.LicenseUrl != null && !String.IsNullOrWhiteSpace(pkg.Package.LicenseUrl.ToString()))
{
if (AddLink(pkg.Package.LicenseUrl, "license", null, null, null, null, null) == null) {
return false;
}
}
if (pkg.Package.ProjectUrl != null && !String.IsNullOrWhiteSpace(pkg.Package.ProjectUrl.ToString()))
{
if (AddLink(pkg.Package.ProjectUrl, "project", null, null, null, null, null) == null) {
return false;
}
}
if (pkg.Package.ReportAbuseUrl != null && !String.IsNullOrWhiteSpace(pkg.Package.ReportAbuseUrl.ToString()))
{
if (AddLink(pkg.Package.ReportAbuseUrl, "abuse", null, null, null, null, null) == null) {
return false;
}
}
if (pkg.Package.IconUrl != null && !String.IsNullOrWhiteSpace(pkg.Package.IconUrl.ToString()))
{
if (AddLink(pkg.Package.IconUrl, "icon", null, null, null, null, null) == null) {
return false;
}
}
if (pkg.Package.GalleryDetailsUrl != null && !String.IsNullOrWhiteSpace(pkg.Package.GalleryDetailsUrl.ToString()))
{
if (AddLink(pkg.Package.GalleryDetailsUrl, "galleryDetails", null, null, null, null, null) == null)
{
return false;
}
}
if (pkg.Package.LicenseReportUrl != null && !String.IsNullOrWhiteSpace(pkg.Package.LicenseReportUrl.ToString()))
{
if (AddLink(pkg.Package.LicenseReportUrl, "licenseReport", null, null, null, null, null) == null)
{
return false;
}
}
if (pkg.Package.Authors.Any(author => AddEntity(author.Trim(), author.Trim(), "author", null) == null)) {
return false;
}
if (pkg.Package.Owners.Any(owner => AddEntity(owner.Trim(), owner.Trim(), "owner", null) == null)) {
return false;
}
var pkgBase = pkg.Package as PackageBase;
if (pkgBase != null)
{
if (pkgBase.AdditionalProperties != null)
{
foreach (var property in pkgBase.AdditionalProperties)
{
if (AddMetadata(pkg.FastPath, property.Key, property.Value) == null)
{
return false;
}
}
}
}
} else {
return false;
}
} catch (Exception e) {
e.Dump(this);
return false;
}
return true;
}
public PackageContentsViewModel(IPackageMetadata packageMetadata, ICollection <User> owners, PackageItem rootFolder)
{
_packageMetadata = packageMetadata;
_rootFolder = rootFolder;
FlattenedAuthors = String.Join(", ", packageMetadata.Authors);
FlattenedOwners = String.Join(", ", owners.Select(o => o.Username));
IconUrl = packageMetadata.IconUrl == null ? null : packageMetadata.IconUrl.AbsoluteUri;
FrameworkAssemblies = packageMetadata.FrameworkAssemblies.Select(
f =>
{
if (f.SupportedFrameworks.Any())
{
return(String.Format(CultureInfo.InvariantCulture, "{0} ({1})", f.AssemblyName, String.Join("; ", f.SupportedFrameworks)));
}
else
{
return(f.AssemblyName);
}
}).ToList();
}
public int Compare(BaseItem x, BaseItem y)
{
PackageItem itemA = x as PackageItem;
PackageItem itemB = y as PackageItem;
if (itemA == itemB)
{
return(0);
}
if (itemA == null)
{
return(this.sortOrder == SortOrder.Ascending ? 1 : -1);
}
if (itemB == null)
{
return(this.sortOrder == SortOrder.Ascending ? -1 : 1);
}
int result = 0;
if (result == 0 || this.sortMode == SortMode.Version)
{
if (itemA.Version < itemB.Version)
{
result = -1;
}
else if (itemA.Version > itemB.Version)
{
result = 1;
}
}
if (result == 0 || this.sortMode == SortMode.Date)
{
if (itemA.ItemPackageInfo.PublishDate < itemB.ItemPackageInfo.PublishDate)
{
result = -1;
}
else if (itemA.ItemPackageInfo.PublishDate > itemB.ItemPackageInfo.PublishDate)
{
result = 1;
}
}
if (result == 0 || this.sortMode == SortMode.Downloads)
{
int itemANum = itemA.Downloads.HasValue ? itemA.Downloads.Value : 0;
int itemBNum = itemB.Downloads.HasValue ? itemB.Downloads.Value : 0;
result = itemANum - itemBNum;
}
if (result == 0 || this.sortMode == SortMode.Name)
{
result = string.Compare(itemA.Title, itemB.Title);
}
if (result == 0 || this.sortMode == SortMode.PackageType)
{
result = (int)itemA.Type - (int)itemB.Type;
}
if (result == 0 || this.sortMode == SortMode.CombinedScore)
{
float scoreA = (float)itemA.ItemPackageInfo.DownloadCount * (1.0f - MathF.Clamp((float)(DateTime.Now - itemA.ItemPackageInfo.PublishDate).TotalDays / 360.0f, 0.001f, 1.0f));
float scoreB = (float)itemB.ItemPackageInfo.DownloadCount * (1.0f - MathF.Clamp((float)(DateTime.Now - itemB.ItemPackageInfo.PublishDate).TotalDays / 360.0f, 0.001f, 1.0f));
if (scoreA < scoreB)
{
result = -1;
}
else if (scoreA > scoreB)
{
result = 1;
}
}
if (result == 0)
{
result = itemA.GetHashCode() - itemB.GetHashCode();
}
return((this.sortOrder == SortOrder.Ascending) ? -result : result);
}
public void UpdatePackage(PackageItem package)
{
packageDirty = true;
OnPackageChange.Invoke();
}
public void UpdateLocalModState(ISupportModding game) {
_package = null;
SetSharedState(game);
}
public override void OnInspectorGUI()
{
DisplayObject obj = (target as DisplayObjectInfo).displayObject;
EditorGUILayout.LabelField(obj.GetType().Name + ": " + obj.id, (GUIStyle)"OL Title");
EditorGUILayout.Separator();
EditorGUI.BeginChangeCheck();
string name = EditorGUILayout.TextField("Name", obj.name);
if (EditorGUI.EndChangeCheck())
{
obj.name = name;
}
if (obj is Container)
{
EditorGUI.BeginChangeCheck();
bool fairyBatching = EditorGUILayout.Toggle("FairyBatching", ((Container)obj).fairyBatching);
if (EditorGUI.EndChangeCheck())
{
((Container)obj).fairyBatching = fairyBatching;
}
}
GObject gObj = obj.gOwner;
if (gObj != null)
{
EditorGUILayout.Separator();
EditorGUILayout.LabelField(gObj.GetType().Name + ": " + gObj.id, (GUIStyle)"OL Title");
EditorGUILayout.Separator();
if (!string.IsNullOrEmpty(gObj.resourceURL))
{
PackageItem pi = UIPackage.GetItemByURL(gObj.resourceURL);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Resource");
EditorGUILayout.LabelField(pi.name + "@" + pi.owner.name);
EditorGUILayout.EndHorizontal();
}
EditorGUI.BeginChangeCheck();
name = EditorGUILayout.TextField("Name", gObj.name);
if (EditorGUI.EndChangeCheck())
{
gObj.name = name;
}
if (gObj.parent != null)
{
string[] options = new string[gObj.parent.numChildren];
int[] values = new int[options.Length];
for (int i = 0; i < options.Length; i++)
{
options[i] = i.ToString();
values[i] = i;
}
EditorGUI.BeginChangeCheck();
int childIndex = EditorGUILayout.IntPopup("Child Index", gObj.parent.GetChildIndex(gObj), options, values);
if (EditorGUI.EndChangeCheck())
{
gObj.parent.SetChildIndex(gObj, childIndex);
}
}
else
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Child Index");
EditorGUILayout.LabelField("No Parent");
EditorGUILayout.EndHorizontal();
}
EditorGUI.BeginChangeCheck();
Vector3 position = EditorGUILayout.Vector3Field("Position", gObj.position);
if (EditorGUI.EndChangeCheck())
{
gObj.position = position;
}
EditorGUI.BeginChangeCheck();
Vector3 rotation = EditorGUILayout.Vector3Field("Rotation", new Vector3(gObj.rotationX, gObj.rotationY, gObj.rotation));
if (EditorGUI.EndChangeCheck())
{
gObj.rotationX = rotation.x;
gObj.rotationY = rotation.y;
gObj.rotation = rotation.z;
}
EditorGUI.BeginChangeCheck();
Vector2 scale = EditorGUILayout.Vector2Field("Scale", gObj.scale);
if (EditorGUI.EndChangeCheck())
{
gObj.scale = scale;
}
EditorGUI.BeginChangeCheck();
Vector2 skew = EditorGUILayout.Vector2Field("Skew", gObj.skew);
if (EditorGUI.EndChangeCheck())
{
gObj.skew = skew;
}
EditorGUI.BeginChangeCheck();
Vector2 size = EditorGUILayout.Vector2Field("Size", gObj.size);
if (EditorGUI.EndChangeCheck())
{
gObj.size = size;
}
EditorGUI.BeginChangeCheck();
Vector2 pivot = EditorGUILayout.Vector2Field("Pivot", gObj.pivot);
if (EditorGUI.EndChangeCheck())
{
gObj.pivot = pivot;
}
EditorGUI.BeginChangeCheck();
string text = EditorGUILayout.TextField("Text", gObj.text);
if (EditorGUI.EndChangeCheck())
{
gObj.text = text;
}
EditorGUI.BeginChangeCheck();
string icon = EditorGUILayout.TextField("Icon", gObj.icon);
if (EditorGUI.EndChangeCheck())
{
gObj.icon = icon;
}
}
}
public Stream LoadPackage(PackageItem packageItem)
{
throw new NotSupportedException();
}
/// <summary>
/// Returns the package dependencies of packageItem. We only return the dependencies that are not installed in the destination folder of request
/// </summary>
/// <param name="packageItem"></param>
/// <param name="processedDependencies"></param>
/// <param name="request"></param>
private static IEnumerable<PackageItem> GetPackageDependenciesHelper(PackageItem packageItem, HashSet<string> processedDependencies, NuGetRequest request)
{
if (packageItem.Package.DependencySetList == null)
{
yield break;
}
bool force = request.GetOptionValue("Force") != null;
foreach (var depSet in packageItem.Package.DependencySetList)
{
if (depSet.Dependencies == null)
{
continue;
}
foreach (var dep in depSet.Dependencies)
{
var depKey = string.Format(CultureInfo.InvariantCulture, "{0}!#!{1}", dep.Id, dep.DependencyVersion.ToStringSafe());
if (processedDependencies.Contains(depKey))
{
continue;
}
// Get the min dependencies version
string minVersion = dep.DependencyVersion.MinVersion.ToStringSafe();
// Get the max dependencies version
string maxVersion = dep.DependencyVersion.MaxVersion.ToStringSafe();
if (!force)
{
bool installed = false;
var installedPackages = request.InstalledPackages.Value;
if (request.InstalledPackages.Value.Count() > 0)
{
// check the installedpackages options passed in
foreach (var installedPackage in request.InstalledPackages.Value)
{
// if name not match, move on to the next entry
if (!string.Equals(installedPackage.Id, dep.Id, StringComparison.OrdinalIgnoreCase))
{
continue;
}
// if no version and if name matches, skip
if (string.IsNullOrWhiteSpace(installedPackage.Version))
{
// skip this dependency
installed = true;
break;
}
SemanticVersion packageVersion = new SemanticVersion(installedPackage.Version);
// checks min and max
if (request.MinAndMaxVersionMatched(packageVersion, minVersion, maxVersion, dep.DependencyVersion.IsMinInclusive, dep.DependencyVersion.IsMaxInclusive))
{
// skip this dependency
installed = true;
break;
}
}
}
// check whether package is installed at destination. only used this option if installedpackages not passed in
else if (request.GetInstalledPackages(dep.Id, null, minVersion, maxVersion, minInclusive: dep.DependencyVersion.IsMinInclusive, maxInclusive: dep.DependencyVersion.IsMaxInclusive, terminateFirstFound: true))
{
installed = true;
}
if (installed)
{
// already processed this so don't need to do this next time
processedDependencies.Add(dep.Id);
request.Verbose(String.Format(CultureInfo.CurrentCulture, Messages.AlreadyInstalled, dep.Id));
// already have a dependency so move on
continue;
}
}
// get all the packages that match this dependency
var dependentPackageItem = request.GetPackageById(dep.Id, request, minimumVersion: minVersion, maximumVersion: maxVersion, minInclusive: dep.DependencyVersion.IsMinInclusive, maxInclusive: dep.DependencyVersion.IsMaxInclusive).ToArray();
if (dependentPackageItem.Length == 0)
{
request.WriteError(ErrorCategory.ObjectNotFound, dep.Id, Constants.Messages.UnableToFindDependencyPackage, dep.Id);
break;
}
// Get the package that is the latest version
yield return dependentPackageItem.OrderByDescending(each => each.Version).FirstOrDefault();
processedDependencies.Add(depKey);
}
}
}
