Kartverket.MetadataEditor.Models.MetadataService.UpdateMetadataFromModel C# (CSharp) Méthode

UpdateMetadataFromModel() private méthode

private UpdateMetadataFromModel ( MetadataViewModel model, SimpleMetadata metadata ) : void
model MetadataViewModel
metadata GeoNorgeAPI.SimpleMetadata
Résultat void
        private void UpdateMetadataFromModel(MetadataViewModel model, SimpleMetadata metadata)
        {
            metadata.Title = model.Title;
            metadata.Abstract = model.Abstract;

            if (!string.IsNullOrEmpty(model.ParentIdentifier))
                metadata.ParentIdentifier = model.ParentIdentifier;

            metadata.Purpose = !string.IsNullOrWhiteSpace(model.Purpose) ? model.Purpose : " ";

            if (!string.IsNullOrWhiteSpace(model.TopicCategory))
                metadata.TopicCategory = model.TopicCategory;
            if(!string.IsNullOrWhiteSpace(model.SupplementalDescription))
                metadata.SupplementalDescription = model.SupplementalDescription;

            metadata.SpecificUsage = !string.IsNullOrWhiteSpace(model.SpecificUsage) ? model.SpecificUsage : " ";

            var contactMetadata = model.ContactMetadata.ToSimpleContact();
            if (!string.IsNullOrWhiteSpace(model.EnglishContactMetadataOrganization))
            {
                contactMetadata.OrganizationEnglish = model.EnglishContactMetadataOrganization;
            }
            metadata.ContactMetadata = contactMetadata;

            var contactPublisher = model.ContactPublisher.ToSimpleContact();
            if (!string.IsNullOrWhiteSpace(model.EnglishContactPublisherOrganization))
            {
                contactPublisher.OrganizationEnglish = model.EnglishContactPublisherOrganization;
            }
            metadata.ContactPublisher = contactPublisher;

            var contactOwner = model.ContactOwner.ToSimpleContact();
            if (!string.IsNullOrWhiteSpace(model.EnglishContactOwnerOrganization))
            {
                contactOwner.OrganizationEnglish = model.EnglishContactOwnerOrganization;
            }
            metadata.ContactOwner = contactOwner;

            // documents
            metadata.ProductSpecificationUrl = model.ProductSpecificationUrl;

            metadata.ApplicationSchema = model.ApplicationSchema;

            if (metadata.IsDataset()) {
                metadata.ProductSpecificationOther = new SimpleOnlineResource
                {
                    Name = model.ProductSpecificationOther.Name,
                    URL = model.ProductSpecificationOther.URL
                };
            }

            metadata.ProductSheetUrl = model.ProductSheetUrl;
                metadata.ProductPageUrl = model.ProductPageUrl;
                metadata.LegendDescriptionUrl = model.LegendDescriptionUrl;
                metadata.CoverageUrl = model.CoverageUrl;

            metadata.Thumbnails = Thumbnail.ToSimpleThumbnailList(model.Thumbnails);

            // distribution
            //if (!string.IsNullOrWhiteSpace(model.SpatialRepresentation))
                metadata.SpatialRepresentation = model.SpatialRepresentation;

            //if (!string.IsNullOrWhiteSpace(model.ReferenceSystemCoordinateSystem))
            //{
            //    metadata.ReferenceSystem = new SimpleReferenceSystem
            //    {
            //        CoordinateSystem = model.ReferenceSystemCoordinateSystem,
            //        Namespace = model.ReferenceSystemNamespace
            //    };
            //}
                var refsys = model.GetReferenceSystems();
                if (refsys != null)
                    metadata.ReferenceSystems = refsys;

            //Upgraded to multiple distribution formats
            //if (!string.IsNullOrWhiteSpace(model.DistributionFormatName) ||
            //    !string.IsNullOrWhiteSpace(model.DistributionFormatVersion))
            //{
            //    metadata.DistributionFormat = new SimpleDistributionFormat
            //    {
            //        Name = model.DistributionFormatName,
            //        Version = model.DistributionFormatVersion
            //    };
            //}

            metadata.DistributionFormats = model.GetDistributionFormats();

            metadata.DistributionDetails = new SimpleDistributionDetails
            {
                URL = model.DistributionUrl,
                Protocol = model.DistributionProtocol,
                Name = model.DistributionName,
                UnitsOfDistribution = model.UnitsOfDistribution
            };

            // quality
            List<SimpleQualitySpecification> qualityList = new List<SimpleQualitySpecification>();
            if (!string.IsNullOrWhiteSpace(model.QualitySpecificationTitleInspire))
            {
                qualityList.Add(new SimpleQualitySpecification
                {
                    Title = model.QualitySpecificationTitleInspire,
                    Date = string.Format("{0:yyyy-MM-dd}", model.QualitySpecificationDateInspire),
                    DateType = model.QualitySpecificationDateTypeInspire,
                    Explanation = model.QualitySpecificationExplanationInspire,
                    Result = model.QualitySpecificationResultInspire,
                    Responsible = "inspire"
                });
            }
            if (!string.IsNullOrWhiteSpace(model.QualitySpecificationTitleSosi))
            {
                qualityList.Add(new SimpleQualitySpecification
                {
                    Title = model.QualitySpecificationTitleSosi,
                    Date = string.Format("{0:yyyy-MM-dd}", model.QualitySpecificationDateSosi),
                    DateType = model.QualitySpecificationDateTypeSosi,
                    Explanation = model.QualitySpecificationExplanationSosi,
                    Result = model.QualitySpecificationResultSosi,
                    Responsible = "sosi"
                });
            }
            if (model.QualitySpecificationResultSosiConformApplicationSchema)
            {
                qualityList.Add(new SimpleQualitySpecification
                {
                    Title = "Sosi applikasjonsskjema",
                    Date = string.Format("{0:yyyy-MM-dd}", model.QualitySpecificationDateSosi),
                    DateType = model.QualitySpecificationDateTypeSosi,
                    Explanation = "SOSI-filer er i henhold til applikasjonsskjema",
                    Result = true,
                    Responsible = "uml-sosi"
                });
            }
            if (model.QualitySpecificationResultSosiConformGmlApplicationSchema)
            {
                qualityList.Add(new SimpleQualitySpecification
                {
                    Title = "Sosi applikasjonsskjema",
                    Date = string.Format("{0:yyyy-MM-dd}", model.QualitySpecificationDateSosi),
                    DateType = model.QualitySpecificationDateTypeSosi,
                    Explanation = "GML-filer er i henhold til applikasjonsskjema",
                    Result = true,
                    Responsible = "uml-gml"
                });
            }
            if (!string.IsNullOrWhiteSpace(model.QualitySpecificationTitle))
            {
                qualityList.Add(new SimpleQualitySpecification
                {
                    Title = model.QualitySpecificationTitle,
                    Date = string.Format("{0:yyyy-MM-dd}", model.QualitySpecificationDate),
                    DateType = model.QualitySpecificationDateType,
                    Explanation = model.QualitySpecificationExplanation,
                    Result = model.QualitySpecificationResult,
                    Responsible = "other"
                });
            }

            metadata.QualitySpecifications = qualityList;

            metadata.ProcessHistory = !string.IsNullOrWhiteSpace(model.ProcessHistory) ? model.ProcessHistory : " ";

            if (!string.IsNullOrWhiteSpace(model.MaintenanceFrequency))
                metadata.MaintenanceFrequency = model.MaintenanceFrequency;

            if (!model.IsService())
                metadata.ResolutionScale = !string.IsNullOrWhiteSpace(model.ResolutionScale) ? model.ResolutionScale : " ";

            if (!string.IsNullOrWhiteSpace(model.Status))
                metadata.Status = model.Status;

            metadata.DateCreated = model.DateCreated;
            metadata.DatePublished = model.DatePublished;
            metadata.DateUpdated = model.DateUpdated;

            DateTime? DateMetadataValidFrom = model.DateMetadataValidFrom;
            DateTime? DateMetadataValidTo = model.DateMetadataValidTo;

                metadata.ValidTimePeriod = new SimpleValidTimePeriod()
                {
                    ValidFrom = DateMetadataValidFrom != null ? String.Format("{0:yyyy-MM-dd}", DateMetadataValidFrom) : "",
                    ValidTo = DateMetadataValidTo != null ? String.Format("{0:yyyy-MM-dd}", DateMetadataValidTo) : ""
                };

            if (!string.IsNullOrWhiteSpace(model.BoundingBoxEast))
            {
                metadata.BoundingBox = new SimpleBoundingBox
                {
                    EastBoundLongitude = model.BoundingBoxEast,
                    WestBoundLongitude = model.BoundingBoxWest,
                    NorthBoundLatitude = model.BoundingBoxNorth,
                    SouthBoundLatitude = model.BoundingBoxSouth
                };
            }

            var accessConstraintsSelected = model.AccessConstraints;
            string otherConstraintsAccess = model.OtherConstraintsAccess;

            if (!string.IsNullOrEmpty(accessConstraintsSelected))
            {
                if (accessConstraintsSelected.ToLower() == "no restrictions" || accessConstraintsSelected.ToLower() == "norway digital restricted")
                {
                    otherConstraintsAccess = accessConstraintsSelected;
                    accessConstraintsSelected = "otherRestrictions";

                }
            }

            metadata.Constraints = new SimpleConstraints
            {
                AccessConstraints = !string.IsNullOrWhiteSpace(accessConstraintsSelected) ? accessConstraintsSelected : "",
                OtherConstraints = !string.IsNullOrWhiteSpace(model.OtherConstraints) ? model.OtherConstraints : "",
                EnglishOtherConstraints = !string.IsNullOrWhiteSpace(model.EnglishOtherConstraints) ? model.EnglishOtherConstraints : "",
                OtherConstraintsLink = !string.IsNullOrWhiteSpace(model.OtherConstraintsLink) ? model.OtherConstraintsLink : null,
                OtherConstraintsLinkText = !string.IsNullOrWhiteSpace(model.OtherConstraintsLinkText) ? model.OtherConstraintsLinkText : null,
                SecurityConstraints = !string.IsNullOrWhiteSpace(model.SecurityConstraints) ? model.SecurityConstraints : "",
                SecurityConstraintsNote = !string.IsNullOrWhiteSpace(model.SecurityConstraintsNote) ? model.SecurityConstraintsNote : "",
                UseConstraints = !string.IsNullOrWhiteSpace(model.UseConstraints) ? model.UseConstraints : "",
                UseLimitations = !string.IsNullOrWhiteSpace(model.UseLimitations) ? model.UseLimitations : "",
                EnglishUseLimitations = !string.IsNullOrWhiteSpace(model.EnglishUseLimitations) ? model.EnglishUseLimitations : "",
                OtherConstraintsAccess = !string.IsNullOrWhiteSpace(otherConstraintsAccess) ? otherConstraintsAccess : "",
            };

            if(model.IsService() && !string.IsNullOrEmpty(model.DistributionProtocol))
            {
                model.KeywordsOther = AddKeywordForService(model.DistributionProtocol, model.KeywordsOther);
                metadata.ServiceType = GetServiceType(model.DistributionProtocol);
            }
            metadata.Keywords = model.GetAllKeywords();

            bool hasEnglishFields = false;
            // don't create PT_FreeText fields if it isn't necessary
            if (!string.IsNullOrWhiteSpace(model.EnglishTitle))
            {
                metadata.EnglishTitle = model.EnglishTitle;
                hasEnglishFields = true;
            }
            if (!string.IsNullOrWhiteSpace(model.EnglishAbstract))
            {
                metadata.EnglishAbstract = model.EnglishAbstract;
                hasEnglishFields = true;
            }

            if (!string.IsNullOrWhiteSpace(model.EnglishPurpose))
            {
                metadata.EnglishPurpose = model.EnglishPurpose;
                hasEnglishFields = true;
            }

            if (!string.IsNullOrWhiteSpace(model.EnglishSupplementalDescription))
            {
                metadata.EnglishSupplementalDescription = model.EnglishSupplementalDescription;
                hasEnglishFields = true;
            }

            if (!string.IsNullOrWhiteSpace(model.EnglishSpecificUsage))
            {
                metadata.EnglishSpecificUsage = model.EnglishSpecificUsage;
                hasEnglishFields = true;
            }

            if (!string.IsNullOrWhiteSpace(model.EnglishProcessHistory))
            {
                metadata.EnglishProcessHistory = model.EnglishProcessHistory;
                hasEnglishFields = true;
            }

            if (hasEnglishFields)
                metadata.SetLocale(SimpleMetadata.LOCALE_ENG);

            if (model.OperatesOn != null)
                metadata.OperatesOn = model.OperatesOn;

            if (!string.IsNullOrWhiteSpace(model.ResourceReferenceCode) || !string.IsNullOrWhiteSpace(model.ResourceReferenceCodespace))
            {
                metadata.ResourceReference = new SimpleResourceReference
                {
                 Code = model.ResourceReferenceCode != null ? model.ResourceReferenceCode : null,
                 Codespace = model.ResourceReferenceCodespace != null ? model.ResourceReferenceCodespace : null
                };
            }

            if (model.IsService())
                metadata.AccessProperties = new SimpleAccessProperties { OrderingInstructions = model.OrderingInstructions }  ;

            SetDefaultValuesOnMetadata(metadata);
        }