Exemple #1
0
        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));
        }
Exemple #2
0
        /// <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);
        }
Exemple #3
0
        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}.");
            }
        }
Exemple #4
0
        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."),
     });
Exemple #6
0
        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);
        }
Exemple #7
0
        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);
        }
Exemple #9
0
 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)))));
 }
Exemple #10
0
 public RegistryPackage GetPackage(RegistryPackageType type, string name)
 {
     return(Get(type).FirstOrDefault(s => s.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)));
 }