internal ValidationResult ParseValidationResponseWithCompletenessIndicator()
        {
            var errors = GetErrors(_inspireValidationResponse);
            var validationResult = new ValidationResult();

            validationResult.Result = ComputeValidationResultFromCompletenessIndicator();
            validationResult.Messages = String.Join("\r\n", errors);

            return validationResult;
        }
        public ValidationResult ParseValidationResponse(bool allowSpatialDataThemeError, bool allowConformityError)
        {
            var errors = GetErrors(_inspireValidationResponse);

            var validationResult = new ValidationResult();
            validationResult.Result = ComputeValidationResult(errors, allowSpatialDataThemeError, allowConformityError);

            if (!validationResult.IsOk())
                validationResult.Messages = String.Join("\r\n", errors);

            return validationResult;
        }
        public ValidationResult Validate(MetadataEntry metadataEntry, MD_Metadata_Type metadata, string rawXmlProcessed)
        {
            ValidationResult validationResult = new ValidationResult();

            if (metadataEntry.HasResourceType("software"))
            {
                validationResult = HasDistributionUrl(metadata, validationResult);
            }
            else
            {
                bool allowSpatialDataThemeError = true;
                bool allowConformityError = true;
                validationResult = new InspireValidator().Validate(rawXmlProcessed, allowSpatialDataThemeError, allowConformityError);
            }

            return validationResult;
        }
        private static ValidationResult HasDistributionUrl(MD_Metadata_Type metadata, ValidationResult validationResult)
        {
            if (metadata.distributionInfo != null
                && metadata.distributionInfo.MD_Distribution != null
                && metadata.distributionInfo.MD_Distribution.transferOptions != null
                && metadata.distributionInfo.MD_Distribution.transferOptions[0] != null
                && metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions != null
                && metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions.onLine != null
                && metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions.onLine[0] != null
                &&
                metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions.onLine[0]
                    .CI_OnlineResource != null
                &&
                metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions.onLine[0]
                    .CI_OnlineResource.linkage != null
                &&
                metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions.onLine[0]
                    .CI_OnlineResource.linkage.URL != null)
            {
                string url =
                    metadata.distributionInfo.MD_Distribution.transferOptions[0].MD_DigitalTransferOptions.onLine[0]
                        .CI_OnlineResource.linkage.URL;
                if (url.Trim().Length > 1)
                {
                    validationResult.Result = 1;
                }
                else
                {
                    validationResult.Result = 0;
                    validationResult.Messages = "Empty URL in distributionInfo.";
                }
            }
            else
            {
                validationResult.Result = 0;
                validationResult.Messages = "Missing URL in distributionInfo.";
            }

            return validationResult;
        }
        public MetadataEntry RetrieveAndValidate(string uuid)
        {
            MetadataEntry metadataEntry = null;
            try
            {
                var getCswRecordRequest = CreateGetCswRecordRequest(uuid);
                Log.Info("Henter metadata for uuid=" + uuid + " fra GeoNorge.");
                string cswRecordResponse = _httpRequestExecutor.PostRequest(Constants.EndpointUrlGeoNorgeCsw,
                                                                            ContentTypeXml, ContentTypeXml,
                                                                            getCswRecordRequest);

                /* Quick and dirty hacks to fix exceptions in serialization due to invalid xml */

                Regex fixWrongDecimalInRealElements = new Regex("<gco:Real>([0-9]+),([0-9]+)</gco:Real>");

                var fixedResponse = cswRecordResponse.Replace("<gco:Boolean />", "<gco:Boolean>false</gco:Boolean>")
                                                     .Replace("<gco:Real />", "<gco:Real>0.0</gco:Real>")
                                                     .Replace("<gco:DateTime />", "")
                                                     .Replace("<gmd:MD_TopicCategoryCode />", "");

                var rawXmlProcessed = fixWrongDecimalInRealElements.Replace(fixedResponse, "<gco:Real>$1.$2</gco:Real>");

                GetRecordByIdResponseType getRecordResponse = SerializeUtil.DeserializeFromString<GetRecordByIdResponseType>(rawXmlProcessed);
                MD_Metadata_Type metadata = getRecordResponse.Items[0] as MD_Metadata_Type;

                metadataEntry = ParseCswRecordResponse(uuid, metadata);
                ValidationResult validationResult;
                if (metadataEntry.ResourceType == "unknown")
                {
                    validationResult = new ValidationResult
                        {
                            Messages = "Unknown resource type, please check value of hierarchyLevel element.",
                            Result = -1,
                            Timestamp = DateTime.Now
                        };
                }
                else
                {
                    if (metadataEntry.InspireResource)
                    {
                        Log.Info("Validating metadata with INSPIRE-validator.");
                        validationResult = new InspireValidator(_httpRequestExecutor).Validate(rawXmlProcessed);
                    }
                    else
                    {
                        Log.Info("Validating metadata with Norge Digitalt-validator.");
                        validationResult = new NorgeDigitaltValidator().Validate(metadataEntry, metadata, rawXmlProcessed);
                    }
                }
                Log.Info("Validation result: " + validationResult.Messages);
                metadataEntry.ValidationResults.Add(validationResult);
            }
            catch (Exception e)
            {
                metadataEntry = ParseCswRecordResponse(uuid, null);

                string message = e.Message;
                if (e.InnerException != null)
                    message += e.InnerException.Message;

                metadataEntry.ValidationResults.Add(new ValidationResult { Messages="Exception during validation: " + message, Result = -1, Timestamp = DateTime.Now });
                Log.Error("Exception occured for uuid=" + uuid + ", not validated. " + message);
            }
            return metadataEntry;
        }