public void ValidValues(string input, RegistryPackageType type, string name, string version)
{
var success = PackageFullName.TryParsePackage(input, out var result);
Assert.That(success, Is.True);
Assert.That(result.Type, Is.EqualTo(type));
Assert.That(result.Name, Is.EqualTo(name));
Assert.That(result.Version, Is.EqualTo(version));
}
/// <summary>
/// Creates a registry package type.
/// </summary>
/// <returns>Returns the created registry package type.</returns>
public static RegistryPackageType CreateRegistryPackage()
{
var retVal = new RegistryPackageType
{
id = $"urn:uuid:{Guid.NewGuid().ToString()}"
};
return(retVal);
}
public void AssertNoDuplicates(RegistryPackageType type, RegistryPackageVersion version)
{
var hashes = version.Files.Where(f => f.Hash?.Value != null).Select(f => f.Hash.Value).ToArray();
var conflictingVersion = Get(type)
.SelectMany(s => s.Versions.Where(v => !ReferenceEquals(v, version)).Select(v => (s, v)))
.FirstOrDefault(x => x.v.Files.Count == hashes.Length && x.v.Files.All(f => hashes.Contains(f.Hash?.Value)));
if (conflictingVersion.v != null)
{
throw new UserInputException($"This version contains exactly the same file count and file hashes as {conflictingVersion.s.Name} v{conflictingVersion.v.Version}.");
}
}
public IReadOnlyCollection <RegistryPackage> Get(RegistryPackageType type)
{
if (_groupedByType == null)
{
_groupedByType = Packages
.GroupBy(package => package.Type)
.ToDictionary(
group => group.Key,
group => new SortedSet <RegistryPackage>(group) as IReadOnlyCollection <RegistryPackage>);
}
return(_groupedByType.TryGetValue(type, out var set) ? set : new SortedSet <RegistryPackage>());
}
public string GetDirectory(RegistryPackageType type)
{
return(type switch
{
RegistryPackageType.Scenes => _fs.Path.Combine(_vamDirectory, "Saves", "scene"),
RegistryPackageType.Scripts => _fs.Path.Combine(_vamDirectory, "Custom", "Scripts"),
RegistryPackageType.Clothing => _fs.Path.Combine(_vamDirectory, "Custom", "Clothing"),
RegistryPackageType.Textures => _fs.Path.Combine(_vamDirectory, "Custom", "Atom", "Person", "Textures"),
RegistryPackageType.Assets => _fs.Path.Combine(_vamDirectory, "Custom", "Assets"),
RegistryPackageType.FemaleMorphs => _fs.Path.Combine(_vamDirectory, "Custom", "Atom", "Person", "Morphs", "female"),
RegistryPackageType.MaleMorphs => _fs.Path.Combine(_vamDirectory, "Custom", "Atom", "Person", "Morphs", "male"),
_ => throw new NotImplementedException($"Type {type} is not currently handled by the folders helper."),
});
public RegistryPackage GetOrCreatePackage(RegistryPackageType type, string name)
{
var script = Get(type).FirstOrDefault(s => s.Name == name);
if (script != null)
{
return(script);
}
script = new RegistryPackage {
Type = RegistryPackageType.Scripts, Name = name, Versions = new SortedSet <RegistryPackageVersion>()
};
Packages.Add(script);
_groupedByType = null;
return(script);
}
public bool TryGetPackageVersion(RegistryPackageType type, string name, RegistryVersionString version, out RegistryPackageVersionContext context)
{
var package = Get(type)?.FirstOrDefault(p => p.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
if (package == null)
{
context = null;
return(false);
}
var packageVersion = RegistryVersionString.IsEmpty(version) ? package.GetLatestVersion() : package.Versions.FirstOrDefault(v => v.Version.Equals(version));
if (packageVersion == null)
{
context = null;
return(false);
}
context = new RegistryPackageVersionContext(this, package, packageVersion);
return(true);
}
/// <summary>
/// Creates a RegistryPackageType from a CDAPackage.
/// </summary>
/// <param name="package">The CDAPackage instance.</param>
/// <returns>The constructed RegistryPackageType.</returns>
internal RegistryPackageType CreateRegistryPackageType()
{
var registryPackage = new RegistryPackageType();
var classifications = new List <ClassificationType>();
var externalIdentifiers = new List <ExternalIdentifierType>();
// Name
registryPackage.Name = CreateInternationalStringType(documentTypeDisplayName);
// Type
registryPackage.objectType = XDS_REGISTRY_PACKAGE;
// ID
registryPackage.id = SubmissionSetId;
// SubmissionTime
registryPackage.Slot = new SlotType1[1] {
CreateSlotType("submissionTime", DateTime.Now.ToUniversalTime().ToString(DateTimeFormatString))
};
//registryPackage.Name = CreateInternationalStringType(documentTypeDisplayName);
// Author - 4 components - Only populate author institution, author person (not role and specialty)
var authorSlots = new List <SlotType1>();
authorSlots.Add(CreateSlotType("authorInstitution", xonFormattedOrganisation));
authorSlots.Add(CreateSlotType("authorPerson", xcnFormattedAuthor));
if (!String.IsNullOrEmpty(authorSpecialty))
{
authorSlots.Add(CreateSlotType("authorSpecialty", authorSpecialty));
}
ClassificationType authorClassification = CreateClassificationType(
"cl08",
XDS_SUBMISSION_SET_AUTHOR,
registryPackage.id,
"",
authorSlots,
null);
classifications.Add(authorClassification);
// Content type
classifications.Add(
CreateCodedValueClassification(
"cl09",
registryPackage.id,
documentTypeCode,
documentClassCodeDisplayName,
documentTypeCodeSystemName,
XDS_SUBMISSION_SET_CONTENT_TYPE_CODE
)
);
// UniqueId
externalIdentifiers.Add(
CreateExternalIdentifierType(
"ei03",
XDS_SUBMISSION_SET_UNIQUE_ID,
cdaDocumentIdOid,
registryPackage.id,
"XDSSubmissionSet.uniqueId"
)
);
// SourceId
externalIdentifiers.Add(
CreateExternalIdentifierType(
"ei04",
XDS_SUBMISSION_SET_SOURCE_ID,
authorQualifiedOrgId,
registryPackage.id,
"XDSSubmissionSet.sourceId"
)
);
// PatientId
externalIdentifiers.Add(
CreateExternalIdentifierType(
"ei05",
XDS_SUBMISSION_SET_PATIENT_ID,
cxFormattedPatientId,
registryPackage.id,
"XDSSubmissionSet.patientId"
)
);
registryPackage.Classification = classifications.ToArray();
registryPackage.ExternalIdentifier = externalIdentifiers.ToArray();
return(registryPackage);
}
public IEnumerable <RegistryPackageFileContext> FlattenFiles(RegistryPackageType type)
{
return(Get(type)
.SelectMany(package => package.Versions.Select(version => new RegistryPackageVersionContext(this, package, version))
.SelectMany(context => context.Version.Files.Select(file => new RegistryPackageFileContext(context, file)))));
}
public RegistryPackage GetPackage(RegistryPackageType type, string name)
{
return(Get(type).FirstOrDefault(s => s.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)));
}
