/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Returns HashCode</returns>
public override int GetHashCode()
{
return(String.Format("{0}|{1}|",
PackagePath?.GetHashCode() ?? 0,
Source?.GetHashCode() ?? 0
).GetHashCode());
}
PackageIdentity CreatePackageIdentity(string packageId, string packageVersion)
{
var version = VersionFactory.CreateSemanticVersion(packageVersion);
var path = new PackagePath($"C:\\{packageId}.{packageVersion}.zip");
return(new PackageIdentity(new PackageId(packageId), version, path));
}
private static PackageInProject MakePackageForV110()
{
var path = new PackagePath("c:\\temp", "folder\\src\\project1\\packages.config",
PackageReferenceType.PackagesConfig);
return(new PackageInProject("foo.bar", "1.1.0", path));
}
public virtual ScormPackageSettings Copy(Int32 idPerson, String ipAddress, String proxyIpAddress, long idItem,
Guid uniqueId, long idVersion, Guid uniqueIdVersion, RepositoryIdentifier repository, DateTime?validUntil = null, String packagePath = "")
{
ScormPackageSettings item = new ScormPackageSettings()
{
IdItem = idItem, IdVersion = idVersion, UniqueIdItem = uniqueId, UniqueIdVersion = uniqueIdVersion, Repository = repository
};
item.CreateMetaInfo(idPerson, ipAddress, proxyIpAddress);
item.ActivityCount = ActivityCount;
item.CheckScore = CheckScore;
item.CheckScormCompletion = CheckScormCompletion;
item.CheckTime = CheckTime;
item.EvaluationType = EvaluationType;
item.IsCurrent = IsCurrent;
item.IsValid = IsValid;
item.MinScore = MinScore;
item.MinTime = MinTime;
item.UseScoreScaled = UseScoreScaled;
item.PackageGuid = uniqueIdVersion.ToString();
item.PackagePath = (String.IsNullOrWhiteSpace(packagePath) ? PackagePath.Replace(UniqueIdVersion.ToString() + "\\", uniqueIdVersion.ToString() + "\\") : packagePath);
item.ValidUntil = validUntil;
return(item);
}
private PackageInProject?XmlToPackage(XElement el, PackagePath path)
{
var id = el.Attribute("id")?.Value;
var version = el.Attribute("version")?.Value;
return(_packageInProjectReader.Read(id, version, path, null));
}
private static PackageInProject BuildPackageInProject(string packageName)
{
var path = new PackagePath("c:\\temp", "folder\\src\\project1\\packages.config",
PackageReferenceType.PackagesConfig);
return(new PackageInProject(packageName, "1.1.0", path));
}
private PackageInProject?XmlToPackage(XNamespace ns, XElement el,
PackagePath path, IEnumerable <string> projectReferences)
{
var id = el.Attribute("Include")?.Value;
var version = el.Attribute("Version")?.Value ?? el.Element(ns + "Version")?.Value;
return(_packageInProjectReader.Read(id, version, path, projectReferences));
}
private static PackageInProject MakePackageForV100()
{
var path2 = new PackagePath("c:\\temp", "folder\\src\\project2\\packages.config",
PackageReferenceType.PackagesConfig);
var currentPackage2 = new PackageInProject("foo.bar", "1.0.0", path2);
return(currentPackage2);
}
private static PackageInProject MakePackageInProjectFor(PackageIdentity package)
{
var path = new PackagePath(
Path.GetTempPath(),
Path.Combine("folder", "src", "project1", "packages.config"),
PackageReferenceType.PackagesConfig);
return(new PackageInProject(package.Id, package.Version.ToString(), path));
}
private static PackageInProject MakePackageForV110(PackageIdentity package)
{
var path = new PackagePath(
OsSpecifics.GenerateBaseDirectory(),
Path.Combine("folder", "src", "project1", "packages.config"),
PackageReferenceType.PackagesConfig);
return(new PackageInProject(package.Id, package.Version.ToString(), path));
}
public static PackageInProject MakePackageForV110(PackageVersionRange package)
{
var path = new PackagePath(
OsSpecifics.GenerateBaseDirectory(),
Path.Combine("folder", "src", "project1", "packages.config"),
PackageReferenceType.PackagesConfig);
return(new PackageInProject(package, path));
}
public void ConstructorShouldProduceExpectedParsedPropsWithExtraSlash()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
BaseDirectory,
$"{sep}checkout1{sep}src{sep}myproj.csproj",
PackageReferenceType.ProjectFile);
Assert.That(path.RelativePath, Is.EqualTo($"checkout1{sep}src{sep}myproj.csproj"));
}
/// <summary>
/// Overrides Object.GetHashCode.
/// </summary>
/// <returns>A suitable hash code for this PackagePathTemplateLocation.</returns>
public override int GetHashCode()
{
const int prime = 397;
int result = PackagePath.ToLower().GetHashCode(); // package path must be case-insensitive
result = (result * prime) ^ PackageID.GetHashCode(); // combine the hashes
return(result);
// NOTE: Object.Equals is overridden in the base class, and therefore
// does not need not be overridden here.
}
public void ConstructorShouldProduceExpectedParsedFileName()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
$"c:{sep}temp{sep}somefolder",
$"checkout1{sep}src{sep}myproj.csproj",
PackageReferenceType.ProjectFile);
Assert.That(path.Info.Name, Is.EqualTo("myproj.csproj"));
}
public void ConstructorShouldProduceExpectedInfoForProjectFile()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
_baseDirectory,
$"{sep}checkout1{sep}src{sep}myproj.csproj",
PackageReferenceType.ProjectFile);
Assert.That(path.Info, Is.Not.Null);
Assert.That(path.Info.Name, Is.EqualTo("myproj.csproj"));
}
public void ConstructorShouldProduceExpectedParsedFullPath()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
_baseDirectory,
$"checkout1{sep}src{sep}myproj.csproj",
PackageReferenceType.ProjectFile);
Assert.That(path.Info.DirectoryName, Is.EqualTo($"{_baseDirectory}{sep}checkout1{sep}src"));
Assert.That(path.FullName, Is.EqualTo($"{_baseDirectory}{sep}checkout1{sep}src{sep}myproj.csproj"));
}
private PackageInProject?XmlToPackage(XElement el, PackagePath path)
{
var id = el.Attribute("Include")?.Value;
if (id == null)
{
id = el.Attribute("Update")?.Value;
}
var version = el.Attribute("Version")?.Value;
return(_packageInProjectReader.Read(id, version, path, null));
}
private async Task DownloadAsync(PackagePath package, DirectoryInfo destFolder)
{
var tempFolder = new DirectoryInfo($"{this.packagePath.Options.TempFolder}\\tmp\\{Guid.NewGuid()}");
// first try version url...
var registry = new NpmRegistry(client);
// get tarball url...
var tarball = await registry.GetTarBallAsync(package.Options.NPMRegistry, package.Package, package.Version);
try
{
using (var stream = await client.GetStreamAsync(tarball))
{
using (var ungzStream = new GZipInputStream(stream))
{
using (var tar = TarArchive.CreateInputTarArchive(ungzStream))
{
// tar.ExtractContents(packagePath.TagFolder);
tar.ExtractContents(tempFolder.FullName);
var parent = destFolder.Parent;
if (!parent.Exists)
{
parent.Create();
}
var tmp = tempFolder.GetDirectories()[0];
tmp.MoveTo(destFolder.FullName);
// var tmp = tempFolder.GetDirectories()[0];
// Directory.Move(tmp.FullName, tagFolder.FullName);
}
}
}
}
catch
{
if (destFolder.Exists)
{
destFolder.Delete(true);
}
throw;
} finally
{
if (tempFolder.Exists)
{
tempFolder.Delete(true);
}
}
}
public void ConstructorShouldProduceExpectedSimplePropsForPackagesConfigFile()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
$"c:{sep}temp{sep}somefolder",
$"{sep}checkout1{sep}src{sep}packages.config",
PackageReferenceType.PackagesConfig);
Assert.That(path.BaseDirectory, Is.EqualTo($"c:{sep}temp{sep}somefolder"));
Assert.That(path.RelativePath, Is.EqualTo($"checkout1{sep}src{sep}packages.config"));
Assert.That(path.PackageReferenceType, Is.EqualTo(PackageReferenceType.PackagesConfig));
}
public void ConstructorShouldProduceExpectedParsedFullPathWithExtraSlash()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
$"c:{sep}temp{sep}somefolder",
$"{sep}checkout1{sep}src{sep}myproj.csproj",
PackageReferenceType.ProjectFile);
Assert.That(path.BaseDirectory, Is.EqualTo($"c:{sep}temp{sep}somefolder"));
Assert.That(path.Info.DirectoryName, Is.EqualTo($"c:{sep}temp{sep}somefolder{sep}checkout1{sep}src"));
Assert.That(path.FullName, Is.EqualTo($"c:{sep}temp{sep}somefolder{sep}checkout1{sep}src{sep}myproj.csproj"));
}
public void ConstructorShouldProduceExpectedSimplePropsForProjectFile()
{
var sep = Path.DirectorySeparatorChar;
var path = new PackagePath(
_baseDirectory,
$"{sep}checkout1{sep}src{sep}myproj.csproj",
PackageReferenceType.ProjectFile);
Assert.That(path.BaseDirectory, Is.EqualTo(_baseDirectory));
Assert.That(path.RelativePath, Is.EqualTo($"checkout1{sep}src{sep}myproj.csproj"));
Assert.That(path.PackageReferenceType, Is.EqualTo(PackageReferenceType.ProjectFile));
}
private void Rename(string newName)
{
string error;
if (!IsValidName(newName, out error))
{
ServiceProvider.Get <IDialogService>().BlockingMessageBox(string.Format(Tr._p("Message", "This package couldn't be renamed. {0}"), error), MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
var newPath = UFile.Combine(PackagePath.GetFullDirectory(), newName + PackagePath.GetFileExtension());
Rename(newPath);
}
public static PackageUpdateSet MakePackageUpdateSet(string packageName)
{
var fooPackage = new PackageIdentity(packageName, new NuGetVersion("1.2.3"));
var latest = new PackageSearchMedatadata(fooPackage, new PackageSource("http://none"), null,
Enumerable.Empty <PackageDependency>());
var packages = new PackageLookupResult(VersionChange.Major, latest, null, null);
var path = new PackagePath("c:\\foo", "bar", PackageReferenceType.ProjectFile);
var pip = new PackageInProject(fooPackage, path, null);
return(new PackageUpdateSet(packages, new List <PackageInProject> {
pip
}));
}
private async Task DownloadAsync(PackagePath package, string destination)
{
var tempFolder = new DirectoryInfo($"{package.Options.TempFolder}\\tmp\\{Guid.NewGuid()}");
var tagFolder = new DirectoryInfo(destination);
try
{
using (var stream = await client.GetStreamAsync(package.PrivateNpmUrl))
{
using (var ungzStream = new GZipInputStream(stream))
{
using (var tar = TarArchive.CreateInputTarArchive(ungzStream))
{
// tar.ExtractContents(packagePath.TagFolder);
tar.ExtractContents(tempFolder.FullName);
var parent = tagFolder.Parent;
if (!parent.Exists)
{
parent.Create();
}
var tmp = tempFolder.GetDirectories()[0];
Directory.Move(tmp.FullName, tagFolder.FullName);
}
}
}
if (tempFolder.Exists)
{
tempFolder.Delete(true);
}
}
catch
{
if (tagFolder.Exists)
{
tagFolder.Delete(true);
}
throw;
} finally
{
//if (tempFolder.Exists)
//{
// tempFolder.Delete(true);
//}
}
}
private async Task InstallAsync(PackagePath package, string destination)
{
await DownloadAsync(package, destination);
// read config..
var packageConfig = await File.ReadAllTextAsync(destination + "\\package.json");
var config = JObject.Parse(packageConfig);
if (!config.ContainsKey("dependencies"))
{
return;
}
var dep = config["dependencies"] as JObject;
if (dep == null)
{
return;
}
List <PackagePath> dependencies = new List <PackagePath>();
foreach (var key in dep.Properties())
{
string value = key.Value?.ToString();
if (value == null)
{
continue;
}
value = value.TrimStart('^');
if (!Char.IsNumber(value[0]))
{
continue;
}
string pn = $"{key.Name}@{value}";
var cp = new PackagePath(package.Options, pn.ParseNPMPath(), true);
if (queuedPackages.Contains(cp.Package))
{
continue;
}
queuedPackages.Add(cp.Package);
dependencies.Add(cp);
}
await Task.WhenAll(dependencies.Select((p) =>
InstallAsync(p, $"{packagePath.TagFolder}\\node_modules\\{p.Package}")
));
}
private static PackageUpdateSet UpdateSet(PackageReferenceType refType)
{
var fooPackage = new PackageIdentity("foo", new NuGetVersion(1, 2, 3));
var path = new PackagePath("c:\\foo", "bar", refType);
var packages = new[]
{
new PackageInProject(fooPackage, path, null)
};
var latest = new PackageSearchMedatadata(fooPackage, new PackageSource(NuGetConstants.V3FeedUrl), null, null);
var updates = new PackageLookupResult(VersionChange.Major, latest, null, null);
return(new PackageUpdateSet(updates, packages));
}
private static PackageUpdateSet UpdateSet()
{
var fooPackage = new PackageIdentity("foo", new NuGetVersion(1, 2, 3));
var path = new PackagePath("c:\\foo", "bar", PackageReferenceType.PackagesConfig);
var packages = new[]
{
new PackageInProject(fooPackage, path, null)
};
var publishedDate = new DateTimeOffset(2018, 2, 19, 11, 12, 7, TimeSpan.Zero);
var latest = new PackageSearchMedatadata(fooPackage, new PackageSource("https://somewhere"), publishedDate, null);
var updates = new PackageLookupResult(VersionChange.Major, latest, null, null);
return(new PackageUpdateSet(updates, packages));
}
private IReadOnlyCollection <PackageInProject> Read(XDocument xml, PackagePath path)
{
var packagesNode = xml.Element("Project")?.Elements("ItemGroup");
if (packagesNode == null)
{
return(Array.Empty <PackageInProject>());
}
var packageNodeList = packagesNode.Elements("PackageReference");
var packageList = packageNodeList
.Select(el => XmlToPackage(el, path))
.Where(p => p != null)
.ToList();
return(packageList !);
}
private IReadOnlyCollection <PackageInProject> Read(XDocument xml, PackagePath path)
{
var packagesNode = xml.Element("package")?.Element("metadata")?.Element("dependencies");
if (packagesNode == null)
{
return(Array.Empty <PackageInProject>());
}
var packageNodeList = packagesNode.Elements()
.Where(x => x.Name == "dependency");
var packages = packageNodeList
.Select(el => XmlToPackage(el, path))
.Where(p => p != null)
.ToList();
return(packages !);
}
public RegisterPackageUseCommand(ILog log, IManagePackageCache journal, ICalamariFileSystem fileSystem)
{
this.log = log;
this.journal = journal;
this.fileSystem = fileSystem;
Options.Add("packageId=", "Package ID of the used package", v => packageId = new PackageId(v));
Options.Add("packageVersionFormat=", $"[Optional] Format of version. Options {string.Join(", ", Enum.GetNames(typeof(VersionFormat)))}. Defaults to `{VersionFormat.Semver}`.",
v =>
{
if (!Enum.TryParse(v, out VersionFormat format))
{
throw new CommandException($"The provided version format `{format}` is not recognised.");
}
versionFormat = format;
});
Options.Add("packageVersion=", "Package version of the used package", v => packageVersion = VersionFactory.TryCreateVersion(v, versionFormat));
Options.Add("packagePath=", "Path to the package", v => packagePath = new PackagePath(v));
Options.Add("taskId=", "Id of the task that is using the package", v => taskId = new ServerTaskId(v));
}
