Example #1
0
        private static void CreateMetsElementAttributes(mets mets, ArchiveMetadata metadata)
        {
            mets.OBJID   = metadata.Id;
            mets.PROFILE = "http://xml.ra.se/METS/RA_METS_eARD.xml";
            mets.LABEL   = $"{metadata.System.Name}";

            if (metadata.StartDate != null && metadata.EndDate != null)
            {
                mets.LABEL += $" ({metadata.StartDate?.Year} - {metadata.EndDate?.Year})";
            }
        }
Example #2
0
        public void CreateAndSaveFile(Archive archive, ArchiveMetadata metadata)
        {
            PrepareForPackageDescription(archive, metadata);

            mets infoXml = Create(metadata);

            FileInfo targetFileName = archive.WorkingDirectory.Root().WithFile(ArkadeConstants.InfoXmlFileName);

            XmlSerializerNamespaces namespaces = SetupNamespaces();

            SerializeUtil.SerializeToFile(infoXml, targetFileName, namespaces);

            Log.Information($"Created {ArkadeConstants.InfoXmlFileName}");
        }
Example #3
0
        private static void CreateMetsElementAttributes(mets mets, ArchiveMetadata metadata)
        {
            mets.OBJID   = metadata.Id;
            mets.PROFILE = "http://xml.ra.se/METS/RA_METS_eARD.xml";

            mets.TYPE = metadata.PackageType == PackageType.SubmissionInformationPackage
                ? metsTypeTYPE.SIP
                : metsTypeTYPE.AIP;

            if (!string.IsNullOrEmpty(metadata.Label))
            {
                mets.LABEL = metadata.Label;
            }
        }
Example #4
0
        public static mets Create(ArchiveMetadata metadata)
        {
            var mets = new mets();

            CreateMetsHdr(mets, metadata);

            CreateAmdSec(mets, metadata);

            CreateFileSec(mets, metadata);

            CreateStructMap(mets, metadata);

            return(mets);
        }
Example #5
0
        public void CreateAndSaveFile(Archive archive, ArchiveMetadata metadata)
        {
            PrepareForPackageDescription(archive, metadata);

            mets infoXml = Create(metadata);

            FileInfo targetFileName = archive.GetInfoXmlFileName();

            XmlSerializerNamespaces namespaces = SetupNamespaces();

            SerializeUtil.SerializeToFile(infoXml, targetFileName, namespaces);

            Log.Information($"Created {targetFileName}");
        }
Example #6
0
        private static void CreateMetsElementAttributes(mets mets, ArchiveMetadata metadata)
        {
            mets.OBJID   = metadata.Id;
            mets.PROFILE = "http://xml.ra.se/METS/RA_METS_eARD.xml";

            mets.TYPE = metadata.PackageType == PackageType.SubmissionInformationPackage
                ? metsTypeTYPE.SIP
                : metsTypeTYPE.AIP;

            mets.LABEL = $"{metadata.System.Name}";

            if (metadata.StartDate != null && metadata.EndDate != null)
            {
                mets.LABEL += $" ({metadata.StartDate?.Year} - {metadata.EndDate?.Year})";
            }
        }
Example #7
0
        public void CreateAndSaveFile(ArchiveMetadata metadata, string packageFileName)
        {
            var packageFile = new FileInfo(packageFileName);

            PrepareForPackageDescription(metadata, packageFile);

            mets infoXml = Create(metadata);

            var targetFileObject = new FileInfo(
                Path.Combine(packageFile.DirectoryName, ArkadeConstants.InfoXmlFileName)
                );

            XmlSerializerNamespaces namespaces = SetupNamespaces();

            SerializeUtil.SerializeToFile(infoXml, targetFileObject, namespaces);

            Log.Information($"Created {targetFileObject}");
        }
Example #8
0
        public void CreateAndSaveFile(Archive archive, ArchiveMetadata metadata)
        {
            DirectoryInfo rootDirectory = archive.WorkingDirectory.Root().DirectoryInfo();

            if (rootDirectory.Exists)
            {
                string[] filesToSkip = metadata.PackageType == PackageType.SubmissionInformationPackage
                    ? new[] { ArkadeConstants.EadXmlFileName, ArkadeConstants.EacCpfXmlFileName }
                    : null;

                metadata.FileDescriptions = GetFileDescriptions(rootDirectory, rootDirectory, filesToSkip);
            }

            if (archive.WorkingDirectory.HasExternalContentDirectory())
            {
                DirectoryInfo externalContentDirectory = archive.WorkingDirectory.Content().DirectoryInfo();

                if (externalContentDirectory.Exists)
                {
                    var fileDescriptions = GetFileDescriptions(externalContentDirectory, externalContentDirectory);

                    foreach (FileDescription fileDescription in fileDescriptions)
                    {
                        fileDescription.Name = Path.Combine("content", fileDescription.Name);
                    }

                    metadata.FileDescriptions.AddRange(fileDescriptions);
                }
            }

            const int fileIdOffset = 1; // Reserving 0 for package file

            AutoIncrementFileIds(metadata.FileDescriptions, fileIdOffset);

            mets mets = Create(metadata);

            FileInfo targetFileName = archive.WorkingDirectory.Root().WithFile(ArkadeConstants.DiasMetsXmlFileName);

            XmlSerializerNamespaces namespaces = SetupNamespaces();

            SerializeUtil.SerializeToFile(mets, targetFileName, namespaces);

            Log.Information($"Created {ArkadeConstants.DiasMetsXmlFileName}");
        }
Example #9
0
        public void CreateAndSaveFile(Archive archive, ArchiveMetadata metadata)
        {
            DirectoryInfo documentsDirectory = archive.WorkingDirectory.Content()
                                               .WithSubDirectory(ArkadeConstants.DirectoryNameDocuments).DirectoryInfo();

            if (documentsDirectory.Exists)
            {
                metadata.FileDescriptions = GetFileDescriptions(documentsDirectory);
            }

            mets mets = Create(metadata);

            FileInfo targetFileName = archive.WorkingDirectory.Root().WithFile(ArkadeConstants.DiasMetsXmlFileName);

            XmlSerializerNamespaces namespaces = SetupNamespaces();

            SerializeUtil.SerializeToFile(mets, targetFileName, namespaces);

            Log.Information($"Created {ArkadeConstants.DiasMetsXmlFileName}");
        }
Example #10
0
        private static void CreateFileSec(mets mets, ArchiveMetadata metadata)
        {
            if (metadata.FileDescriptions == null || !metadata.FileDescriptions.Any())
            {
                return;
            }

            var metsFiles = new List <object>();

            foreach (FileDescription fileDescription in metadata.FileDescriptions)
            {
                metsFiles.Add(new fileType
                {
                    ID       = $"fileId_{fileDescription.Id}",
                    MIMETYPE = $"application/{fileDescription.Extension}",
                    USE      = "Datafile",
                    CHECKSUMTYPESpecified = true,
                    CHECKSUMTYPE          = fileTypeCHECKSUMTYPE.SHA256,
                    CHECKSUM = fileDescription.Sha256Checksum.ToLower(),
                    SIZE     = fileDescription.Size,
                    CREATED  = fileDescription.CreationTime,
                    FLocat   = new fileTypeFLocat
                    {
                        href    = "file:" + fileDescription.Name.Replace("\\", "/"),
                        LOCTYPE = mdSecTypeMdRefLOCTYPE.URL
                    }
                });
            }

            var metsTypeFileSecFileGrp = new metsTypeFileSecFileGrp
            {
                ID    = "fileGroup001",
                USE   = "FILES",
                Items = metsFiles.ToArray()
            };

            mets.fileSec = new metsTypeFileSec {
                fileGrp = new[] { metsTypeFileSecFileGrp }
            };
        }
Example #11
0
        public void CreateAndSaveFile(Archive archive, ArchiveMetadata metadata)
        {
            DirectoryInfo rootDirectory = archive.WorkingDirectory.Root().DirectoryInfo();

            if (rootDirectory.Exists)
            {
                metadata.FileDescriptions = GetFileDescriptions(rootDirectory, rootDirectory);
            }

            if (archive.WorkingDirectory.HasExternalContentDirectory())
            {
                DirectoryInfo externalContentDirectory = archive.WorkingDirectory.Content().DirectoryInfo();

                if (externalContentDirectory.Exists)
                {
                    var fileDescriptions = GetFileDescriptions(externalContentDirectory, externalContentDirectory);

                    foreach (FileDescription fileDescription in fileDescriptions)
                    {
                        fileDescription.Name = Path.Combine("content", fileDescription.Name);
                    }

                    metadata.FileDescriptions.AddRange(fileDescriptions);
                }
            }

            mets mets = Create(metadata);

            FileInfo targetFileName = archive.WorkingDirectory.Root().WithFile(ArkadeConstants.DiasMetsXmlFileName);

            XmlSerializerNamespaces namespaces = SetupNamespaces();

            SerializeUtil.SerializeToFile(mets, targetFileName, namespaces);

            Log.Information($"Created {ArkadeConstants.DiasMetsXmlFileName}");
        }
Example #12
0
        public void ShouldCreateMetsFromMetadata()
        {
            mets mets = MetsCreator.Create(ArchiveMetadata);

            mets.LABEL.Should().Be("Some system name (2017 - 2020)");
            mets.OBJID.Should().Be("UUID:12345-12345-12345-12345-12345-12345");

            metsTypeMetsHdr metsHdr = mets.metsHdr;

            // CREATEDATE:

            metsHdr.CREATEDATE.Should().Be(new DateTime(2023, 01, 01));

            // ARCHIVEDESCRIPTION:

            metsHdr.altRecordID.Should().Contain(altRecordId =>
                                                 altRecordId.TYPE == metsTypeMetsHdrAltRecordIDTYPE.DELIVERYSPECIFICATION &&
                                                 altRecordId.Value.Equals("Some archive description")
                                                 );

            // AGREEMENTNUMBER:

            metsHdr.altRecordID.Should().Contain(altRecordId =>
                                                 altRecordId.TYPE == metsTypeMetsHdrAltRecordIDTYPE.SUBMISSIONAGREEMENT &&
                                                 altRecordId.Value.Equals("XX 00-0000/0000; 0000-00-00")
                                                 );

            // STARTDATE

            metsHdr.altRecordID.Should().Contain(altRecordId =>
                                                 altRecordId.TYPE == metsTypeMetsHdrAltRecordIDTYPE.STARTDATE &&
                                                 altRecordId.Value.Equals("2017-01-01")
                                                 );

            // ENDDATE

            metsHdr.altRecordID.Should().Contain(altRecordId =>
                                                 altRecordId.TYPE == metsTypeMetsHdrAltRecordIDTYPE.ENDDATE &&
                                                 altRecordId.Value.Equals("2020-01-01")
                                                 );

            metsTypeMetsHdrAgent[] metsHdrAgents = metsHdr.agent;

            // ARCHIVECREATOR 1:

            metsHdrAgents[0].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[0].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[0].name.Should().Be("Entity 1");

            metsHdrAgents[1].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[1].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[1].name.Should().Be("Contactperson 1");
            metsHdrAgents[1].note.Should().Contain(n => n.Equals("Road 1, 1000 City"));
            metsHdrAgents[1].note.Should().Contain(n => n.Equals("1-99999999"));
            metsHdrAgents[1].note.Should().Contain(n => n.Equals("*****@*****.**"));

            // ARCHIVECREATOR 2:

            metsHdrAgents[2].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[2].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[2].name.Should().Be("Entity 2");

            metsHdrAgents[3].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[3].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[3].name.Should().Be("Contactperson 2");
            metsHdrAgents[3].note.Should().Contain(n => n.Equals("Road 2, 2000 City"));
            metsHdrAgents[3].note.Should().Contain(n => n.Equals("2-99999999"));
            metsHdrAgents[3].note.Should().Contain(n => n.Equals("*****@*****.**"));

            // TRANSFERER:

            metsHdrAgents[4].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[4].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[4].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.SUBMITTER);
            metsHdrAgents[4].name.Should().Be("Entity 3");

            metsHdrAgents[5].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[5].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[5].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.SUBMITTER);
            metsHdrAgents[5].name.Should().Be("Contactperson 3");
            metsHdrAgents[5].note.Should().Contain(n => n.Equals("Road 3, 3000 City"));
            metsHdrAgents[5].note.Should().Contain(n => n.Equals("3-99999999"));
            metsHdrAgents[5].note.Should().Contain(n => n.Equals("*****@*****.**"));

            // PRODUCER:

            metsHdrAgents[6].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[6].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[6].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[6].name.Should().Be("Entity 4");

            metsHdrAgents[7].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[7].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[7].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[7].name.Should().Be("Contactperson 4");
            metsHdrAgents[7].note.Should().Contain(n => n.Equals("Road 4, 4000 City"));
            metsHdrAgents[7].note.Should().Contain(n => n.Equals("4-99999999"));
            metsHdrAgents[7].note.Should().Contain(n => n.Equals("*****@*****.**"));

            // OWNER 1:

            metsHdrAgents[8].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[8].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[8].name.Should().Be("Entity 5");

            metsHdrAgents[9].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[9].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[9].name.Should().Be("Contactperson 5");
            metsHdrAgents[9].note.Should().Contain(n => n.Equals("Road 5, 5000 City"));
            metsHdrAgents[9].note.Should().Contain(n => n.Equals("5-99999999"));
            metsHdrAgents[9].note.Should().Contain(n => n.Equals("*****@*****.**"));

            // OWNER 2:

            metsHdrAgents[10].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[10].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[10].name.Should().Be("Entity 6");

            metsHdrAgents[11].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[11].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[11].name.Should().Be("Contactperson 6");
            metsHdrAgents[11].note.Should().Contain(n => n.Equals("Road 6, 6000 City"));
            metsHdrAgents[11].note.Should().Contain(n => n.Equals("6-99999999"));
            metsHdrAgents[11].note.Should().Contain(n => n.Equals("*****@*****.**"));

            // RECIPIENT:

            metsHdrAgents[12].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[12].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.PRESERVATION);
            metsHdrAgents[12].name.Should().Be("Some recipient");

            // SYSTEM:

            metsHdrAgents[13].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[13].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[13].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[13].name.Should().Be("Some system name");
            metsHdrAgents[13].note.Should().Contain(n => n.Equals("v1.0.0"));
            metsHdrAgents[13].note.Should().Contain(n => n.Equals("Noark5"));
            metsHdrAgents[13].note.Should().Contain(n => n.Equals("v3.1"));

            // ARCHIVE SYSTEM:

            metsHdrAgents[14].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[14].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[14].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[14].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[14].name.Should().Be("Some archive system name");
            metsHdrAgents[14].note.Should().Contain(n => n.Equals("v2.0.0"));
            metsHdrAgents[14].note.Should().Contain(n => n.Equals("Noark4"));

            // Type-version applies to Noark5 only and is not expected amongst agents:
            metsHdrAgents.Length.Should().Be(15);

            // FILE DESCRIPTIONS:

            var metsFile = mets.fileSec.fileGrp[0].Items[0] as fileType;

            metsFile?.ID.Should().Be("fileId_1");
            metsFile?.MIMETYPE.Should().Be("application/pdf");
            metsFile?.USE.Should().Be("Datafile");
            metsFile?.CHECKSUMTYPE.Should().Be(fileTypeCHECKSUMTYPE.SHA256);
            metsFile?.CHECKSUM.Should().Be("3b29dfcc4286e50b180af8f21904c86f8aa42a23c4055c3a71d0512f9ae3886f");
            metsFile?.SIZE.Should().Be(2325452);
            metsFile?.CREATED.Year.Should().Be(2017);
            metsFile?.CREATED.Month.Should().Be(06);
            metsFile?.CREATED.Day.Should().Be(30);
            metsFile?.FLocat.href.Should().Be("file:someDirectory/someFileName.pdf");
            metsFile?.FLocat.LOCTYPE.Should().Be(mdSecTypeMdRefLOCTYPE.URL);

            // PACKAGE TYPE

            mets.TYPE.Should().Be(metsTypeTYPE.SIP);

            // MISCELLANEOUS:

            mets.structMap.Length.Should().Be(1);
        }
Example #13
0
        public void ShouldCreateMetsFromMetadata()
        {
            mets mets = MetsCreator.Create(ArchiveMetadata);

            metsTypeMetsHdr metsHdr = mets.metsHdr;

            // ARCHIVEDESCRIPTION:

            metsHdr.altRecordID.Should().Contain(altRecordId =>
                                                 altRecordId.TYPE == metsTypeMetsHdrAltRecordIDTYPE.DELIVERYSPECIFICATION &&
                                                 altRecordId.Value.Equals("Some archive description")
                                                 );

            // AGREEMENTNUMBER:

            metsHdr.altRecordID.Should().Contain(altRecordId =>
                                                 altRecordId.TYPE == metsTypeMetsHdrAltRecordIDTYPE.SUBMISSIONAGREEMENT &&
                                                 altRecordId.Value.Equals("XX 00-0000/0000; 0000-00-00")
                                                 );

            metsTypeMetsHdrAgent[] metsHdrAgents = metsHdr.agent;

            // ARCHIVECREATOR 1:

            metsHdrAgents[0].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[0].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[0].name.Should().Be("Entity 1");

            metsHdrAgents[1].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[1].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[1].name.Should().Be("Contactperson 1");

            metsHdrAgents[2].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[2].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[2].note.First().Should().Be("1-99999999");

            metsHdrAgents[3].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[3].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[3].note.First().Should().Be("*****@*****.**");

            // ARCHIVECREATOR 2:

            metsHdrAgents[4].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[4].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[4].name.Should().Be("Entity 2");

            metsHdrAgents[5].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[5].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[5].name.Should().Be("Contactperson 2");

            metsHdrAgents[6].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[6].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[6].note.First().Should().Be("2-99999999");

            metsHdrAgents[7].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[7].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[7].note.First().Should().Be("*****@*****.**");

            // TRANSFERER:

            metsHdrAgents[8].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[8].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[8].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.SUBMITTER);
            metsHdrAgents[8].name.Should().Be("Entity 3");

            metsHdrAgents[9].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[9].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[9].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.SUBMITTER);
            metsHdrAgents[9].name.Should().Be("Contactperson 3");

            metsHdrAgents[10].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[10].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[10].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.SUBMITTER);
            metsHdrAgents[10].note.First().Should().Be("3-99999999");

            metsHdrAgents[11].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[11].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[11].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.SUBMITTER);
            metsHdrAgents[11].note.First().Should().Be("*****@*****.**");

            // PRODUCER:

            metsHdrAgents[12].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[12].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[12].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[12].name.Should().Be("Entity 4");

            metsHdrAgents[13].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[13].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[13].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[13].name.Should().Be("Contactperson 4");

            metsHdrAgents[14].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[14].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[14].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[14].note.First().Should().Be("4-99999999");

            metsHdrAgents[15].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[15].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[15].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[15].note.First().Should().Be("*****@*****.**");

            // OWNER 1:

            metsHdrAgents[16].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[16].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[16].name.Should().Be("Entity 5");

            metsHdrAgents[17].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[17].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[17].name.Should().Be("Contactperson 5");

            metsHdrAgents[18].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[18].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[18].note.First().Should().Be("5-99999999");

            metsHdrAgents[19].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[19].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[19].note.First().Should().Be("*****@*****.**");

            // OWNER 2:

            metsHdrAgents[20].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[20].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[20].name.Should().Be("Entity 6");

            metsHdrAgents[21].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[21].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[21].name.Should().Be("Contactperson 6");

            metsHdrAgents[22].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[22].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[22].note.First().Should().Be("6-99999999");

            metsHdrAgents[23].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.INDIVIDUAL);
            metsHdrAgents[23].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.IPOWNER);
            metsHdrAgents[23].note.First().Should().Be("*****@*****.**");

            // RECIPIENT:

            metsHdrAgents[24].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.ORGANIZATION);
            metsHdrAgents[24].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.PRESERVATION);
            metsHdrAgents[24].name.Should().Be("Some recipient");

            // SYSTEM:

            metsHdrAgents[25].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[25].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[25].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[25].name.Should().Be("Some system name");

            metsHdrAgents[26].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[26].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[26].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[26].note.First().Should().Be("v1.0.0");

            metsHdrAgents[27].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[27].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[27].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[27].note.First().Should().Be("Noark5");

            metsHdrAgents[28].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[28].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[28].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.ARCHIVIST);
            metsHdrAgents[28].note.First().Should().Be("v3.1");

            // ARCHIVE SYSTEM:

            metsHdrAgents[29].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[29].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[29].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[29].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[29].name.Should().Be("Some archive system name");

            metsHdrAgents[30].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[30].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[30].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[30].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[30].note.First().Should().Be("v2.0.0");

            metsHdrAgents[31].TYPE.Should().Be(metsTypeMetsHdrAgentTYPE.OTHER);
            metsHdrAgents[31].OTHERTYPE.Should().Be(metsTypeMetsHdrAgentOTHERTYPE.SOFTWARE);
            metsHdrAgents[31].ROLE.Should().Be(metsTypeMetsHdrAgentROLE.OTHER);
            metsHdrAgents[31].OTHERROLE.Should().Be(metsTypeMetsHdrAgentOTHERROLE.PRODUCER);
            metsHdrAgents[31].note.First().Should().Be("Noark4");

            // Type-version applies to Noark5 only and is not expected amongst agents:
            metsHdrAgents.Length.Should().Be(32);

            // COMMENTS:

            /* TODO: Enable when comments-creation is implemented
             * mets.amdSec.Any(a => a.techMD.Any(
             *  t1 => t1.mdWrap.Item.Equals("Some comment A")
             *        && a.techMD.Any(
             *            t2 => t2.mdWrap.Item.Equals("Some comment B")))
             * ).Should().BeTrue();
             */

            // FILE DESCRIPTIONS:

            var metsFile = mets.fileSec.fileGrp[0].Items[0] as fileType;

            metsFile?.ID.Should().Be("fileId_1");
            metsFile?.MIMETYPE.Should().Be("application/pdf");
            metsFile?.USE.Should().Be("Datafile");
            metsFile?.CHECKSUMTYPE.Should().Be(fileTypeCHECKSUMTYPE.SHA256);
            metsFile?.CHECKSUM.Should().Be("3B29DFCC4286E50B180AF8F21904C86F8AA42A23C4055C3A71D0512F9AE3886F");
            metsFile?.SIZE.Should().Be(2325452);
            metsFile?.CREATED.Year.Should().Be(2017);
            metsFile?.CREATED.Month.Should().Be(06);
            metsFile?.CREATED.Day.Should().Be(30);
            metsFile?.FLocat.href.Should().Be("someFileName.pdf");
            metsFile?.FLocat.LOCTYPE.Should().Be(mdSecTypeMdRefLOCTYPE.URL);

            // MISCELLANEOUS:

            mets.structMap.Length.Should().Be(1);
        }
Example #14
0
 private static void CreateStructMap(mets mets, ArchiveMetadata metadata)
 {
     mets.structMap = new[] { new structMapType {
                                  div = new divType()
                              } };
 }
Example #15
0
 private static void LoadMetsElementAttributes(ArchiveMetadata archiveMetadata, mets mets)
 {
     archiveMetadata.Label = mets.LABEL;
 }