private static XmlVerificationReport GetVerificationReport(
[NotNull] XmlVerificationReportBuilder xmlReportBuilder,
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IEnumerable <KeyValuePair <string, string> > properties)
{
return(xmlReportBuilder.CreateReport(qualitySpecification.Name, properties));
}
public static HtmlQualitySpecification CreateHtmlQualitySpecification(
[NotNull] QualitySpecification qualitySpecification,
[CanBeNull] IHtmlDataQualityCategoryOptionsProvider optionsProvider,
bool showQualityConditionUuids = true)
{
Assert.ArgumentNotNull(qualitySpecification, nameof(qualitySpecification));
IDictionary <TestDescriptor, HtmlTestDescriptor> htmlTestDescriptors =
GetHtmlTestDescriptors(qualitySpecification);
List <HtmlQualitySpecificationElement> htmlElements;
IEnumerable <HtmlDataQualityCategory> htmlCategories =
GroupByCategories(qualitySpecification.Elements,
htmlTestDescriptors,
new HtmlDataQualityCategoryComparer(),
new HtmlQualitySpecificationElementComparer(),
optionsProvider, out htmlElements);
IEnumerable <HtmlDataModel> dataModels = GetInvolvedDataModels(htmlElements);
return(new HtmlQualitySpecification(qualitySpecification,
htmlCategories,
htmlElements,
htmlTestDescriptors.Values
.OrderBy(t => t.Name),
dataModels,
DateTime.Now)
{
ShowQualityConditionUuids = showQualityConditionUuids
});
}
private QualitySpecification PrepareQualitySpecificationTx(
IBackgroundVerificationInputs backgroundVerificationInputs)
{
QualitySpecification qualitySpecification =
backgroundVerificationInputs.QualitySpecification.Match(
qs => qualitySpecification = qs,
lbqs =>
{
qualitySpecification =
lbqs.QualitySpecification;
SetLocationBasedQualitySpecification(lbqs);
return(qualitySpecification);
});
if (DistributedTestRunner != null)
{
DistributedTestRunner.QualitySpecification = qualitySpecification;
}
// Not needed as long as VerifyEditableDatasets() is used:
//if (backgroundVerificationInputs.VerifiedDatasets != null)
//{
// DisableUninvolvedConditions(
// qualitySpecification, backgroundVerificationInputs.VerifiedDatasets);
//}
InitializeTestParameterValuesTx(qualitySpecification, _domainTransactions);
return(qualitySpecification);
}
private static IEnumerable <Dataset> GetVerifiedDatasets(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IDatasetContext datasetContext)
{
var datasets = new SimpleSet <Dataset>();
foreach (
QualitySpecificationElement qualitySpecificationElement in
qualitySpecification.Elements)
{
QualityCondition qualityCondition = qualitySpecificationElement.QualityCondition;
if (qualityCondition == null)
{
continue;
}
foreach (Dataset dataset in qualityCondition.GetDatasetParameterValues())
{
if (!datasets.Contains(dataset) && datasetContext.CanOpen(dataset))
{
datasets.Add(dataset);
}
}
}
return(datasets);
}
protected override IList <ITest> GetTests(QualitySpecification specification,
out QualityVerification qualityVerification)
{
IList <ITest> result = null;
QualityVerification verification = null;
// TODO: Copy from QualityVerificationService
// Consider moving to base or provide the (properly initialized) tests together with the
// verification in VerifyQuality() or move the condition/test dictionaries and collections
// to a separate factory/provider class that can be called previously inside the appropriate
// transaction
_domainTransactions.UseTransaction(
delegate
{
ICollection <Dataset> datasets =
QualitySpecificationUtils.GetQualityConditionDatasets(specification);
_domainTransactions.Reattach(datasets);
_backgroundVerificationInputs.InitializeSchema(datasets);
result = GetTestsCore(specification, out verification);
});
qualityVerification = verification;
return(result);
}
private static IEnumerable <QualitySpecificationElement> GetOrderedElements(
[NotNull] QualitySpecification qualitySpecification)
{
var list = new List <OrderedQualitySpecificationElement>();
var listIndex = 0;
foreach (QualitySpecificationElement element in
qualitySpecification.Elements)
{
if (!element.Enabled)
{
continue;
}
list.Add(new OrderedQualitySpecificationElement(
element,
listIndex));
listIndex++;
}
list.Sort();
return(list.Select(ordered => ordered.QualitySpecificationElement));
}
public QualityVerification Verify(
[NotNull] IBackgroundVerificationInputs backgroundVerificationInputs,
[CanBeNull] ITrackCancel trackCancel)
{
QualitySpecification qualitySpecification = null;
_backgroundVerificationInputs = backgroundVerificationInputs;
_domainTransactions.UseTransaction(
delegate
{
backgroundVerificationInputs.LoadInputsTx(
_domainTransactions, trackCancel, OnProgress);
qualitySpecification =
PrepareQualitySpecificationTx(backgroundVerificationInputs);
});
IVerificationContext verificationContext =
Assert.NotNull(backgroundVerificationInputs.VerificationContext);
VerificationServiceParameters parameters =
Assert.NotNull(backgroundVerificationInputs.VerificationParameters);
QualityVerification verification = Verify(
verificationContext, qualitySpecification, parameters,
backgroundVerificationInputs.VerifiedObjects);
if (parameters.SaveVerificationStatistics && !verification.Cancelled)
{
backgroundVerificationInputs.SaveVerification(verification, _domainTransactions);
}
return(verification);
}
/// <summary>
/// Initializes a new instance of the <see cref="QualitySpecification"/> class.
/// </summary>
/// <param name="qualitySpecification">The quality specification.</param>
public AreaSpecification([NotNull] QualitySpecification qualitySpecification)
{
Assert.ArgumentNotNull(qualitySpecification, nameof(qualitySpecification));
// this will be an unbounded, default area specification
_qualitySpecification = qualitySpecification;
}
private static QualitySpecification Union(
[NotNull] IEnumerable <QualitySpecification> qualitySpecifications)
{
Assert.ArgumentNotNull(qualitySpecifications, nameof(qualitySpecifications));
IList <QualitySpecification> specifications = qualitySpecifications.ToList();
Assert.ArgumentCondition(specifications.Count > 0,
"Empty quality specification collection");
if (specifications.Count == 1)
{
return(Assert.NotNull(specifications[0], "collection item is null"));
}
var result = new QualitySpecification(assignUuid: true);
foreach (QualitySpecification spec in specifications)
{
Assert.NotNull(spec, "collection item is null");
result = spec.Union(result);
}
result.Name = StringUtils.Concatenate(specifications, qspec => qspec.Name, ", ");
return(result);
}
public void CanGetCategoryHierarchy()
{
var cat1 = new DataQualityCategory("1", "1");
var cat2 = new DataQualityCategory("2", "2");
var cat1_1 = new DataQualityCategory("1", "1.1");
var cat1_2 = new DataQualityCategory("2", "1.2");
var cat1_1_1 = new DataQualityCategory("1", "1.1.1");
cat1.AddSubCategory(cat1_1);
cat1.AddSubCategory(cat1_2);
cat1_1.AddSubCategory(cat1_1_1);
var qspecA = new QualitySpecification("qspec A")
{
Category = cat1_1
};
var qspecB = new QualitySpecification("qspec B")
{
Category = cat1_1
};
var qspecC = new QualitySpecification("qspec C")
{
Category = cat1_1_1
};
var qspec1 = new QualitySpecification("qspec X");
var qspec2 = new QualitySpecification("qspec Y");
CreateSchema(cat1, cat2, cat1_1, cat1_2, cat1_1_1,
qspecA, qspecB, qspecC, qspec1, qspec2);
UnitOfWork.NewTransaction(
delegate
{
IList <DataQualityCategory> categories =
Repository.GetTopLevelCategories();
var qspecRepository = Resolve <IQualitySpecificationRepository>();
Assert.AreEqual(2, categories.Count);
Assert.IsTrue(categories.Contains(cat1));
Assert.IsTrue(categories.Contains(cat2));
string hierarchy = FormatHierarchy(qspecRepository, categories);
const string expected = @"* qspec X
* qspec Y
> 1
> 1
* qspec A
* qspec B
> 1
* qspec C
> 2
> 2
";
Console.WriteLine(hierarchy);
Assert.AreEqual(expected, hierarchy);
});
}
private static void WriteQualitySpecification([NotNull] TextWriter writer,
[NotNull] QualitySpecification
qualitySpecification, int level = 0)
{
writer.WriteLine(@"{0}* {1}",
GetIndentationPadding(level),
qualitySpecification.Name);
}
public static DatasetDependencyGraph GetGraph(
[NotNull] QualitySpecification qualitySpecification,
bool exportBidirectionalDependenciesAsUndirectedEdges = false,
bool includeSelfDependencies = false)
{
return(GetGraph(new[] { qualitySpecification },
exportBidirectionalDependenciesAsUndirectedEdges,
includeSelfDependencies));
}
private static string GetQualifiedName(
[CanBeNull] QualitySpecification qualitySpecification)
{
if (qualitySpecification == null)
{
return(string.Empty);
}
return(qualitySpecification.GetQualifiedName());
}
protected override bool WriteIssueMapDocument(QualitySpecification qualitySpecification,
IIssueRepository issueRepository,
IIssueStatisticsTable issueStatisticsTable,
IList <IObjectClass> verifiedObjectClasses,
XmlVerificationReport verificationReport,
IFeatureClass aoiFeatureClass)
{
// No op: Writing mxds is not supported here.
return(false);
}
public static List <string> WriteHtmlReports(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] string directory,
[NotNull] IssueStatistics issueStatistics,
[NotNull] XmlVerificationReport verificationReport,
[NotNull] string verificationReportFileName,
[CanBeNull] string defaultReportTemplatePath = null,
[CanBeNull] XmlVerificationOptions options = null,
[CanBeNull] string issueGdbPath = null,
[CanBeNull] IList <string> issueMapFilePaths = null,
[CanBeNull] IList <string> qualitySpecificationReportFilePaths = null)
{
string defaultTemplateDirectory =
VerificationOptionUtils.GetDefaultTemplateDirectory(options);
var reportDefinitions = new List <HtmlReportDefinition>();
foreach (XmlHtmlReportOptions reportOptions in
VerificationOptionUtils.GetHtmlReportOptions(
options, defaultReportTemplatePath))
{
HtmlReportDefinition reportDefinition =
VerificationOptionUtils.GetReportDefinition(reportOptions,
defaultReportTemplatePath,
defaultTemplateDirectory);
if (!File.Exists(reportDefinition.TemplatePath))
{
_msg.WarnFormat("Template file does not exist: {0}",
reportOptions.TemplatePath);
continue;
}
reportDefinitions.Add(reportDefinition);
}
List <string> filePaths =
reportDefinitions.Select(d => Path.Combine(directory, d.FileName))
.ToList();
foreach (HtmlReportDefinition reportDefinition in reportDefinitions)
{
WriteHtmlReport(qualitySpecification, directory,
reportDefinition,
issueStatistics, verificationReport,
verificationReportFileName,
issueGdbPath,
issueMapFilePaths,
filePaths,
qualitySpecificationReportFilePaths);
}
return(filePaths);
}
private static void LogBeginVerification(
[NotNull] QualitySpecification qualitySpecification,
double tileSize,
[CanBeNull] AreaOfInterest areaOfInterest)
{
using (_msg.IncrementIndentation("Begin quality verification"))
{
_msg.InfoFormat("Quality specification: {0}", qualitySpecification.Name);
_msg.InfoFormat("Verification tile size: {0}", tileSize);
if (areaOfInterest != null)
{
IGeometry testPerimeter = areaOfInterest.Geometry;
if (testPerimeter.IsEmpty)
{
_msg.Warn("Test perimeter is empty");
}
else
{
var envelope = testPerimeter as IEnvelope;
string message;
if (envelope == null)
{
Assert.ArgumentCondition(testPerimeter is IPolygon,
"Unexpected test perimeter type: {0}; must be polygon or envelope",
testPerimeter.GeometryType);
envelope = testPerimeter.Envelope;
message = string.Format("Polygon extent: {0} x {1}",
envelope.Width, envelope.Height);
}
else
{
message = string.Format("Extent: {0} x {1}",
envelope.Width, envelope.Height);
}
using (_msg.IncrementIndentation(message))
{
_msg.InfoFormat("X-Min: {0}", envelope.XMin);
_msg.InfoFormat("Y-Min: {0}", envelope.YMin);
_msg.InfoFormat("X-Max: {0}", envelope.XMax);
_msg.InfoFormat("Y-Max: {0}", envelope.YMax);
}
}
}
}
}
internal static IEnumerable <Dataset> GetDatasets(
[NotNull] QualitySpecification qualitySpecification)
{
var result = new HashSet <Dataset>();
foreach (QualitySpecificationElement element in qualitySpecification.Elements)
{
foreach (Dataset dataset in element.QualityCondition.GetDatasetParameterValues())
{
result.Add(dataset); // only added if not yet present
}
}
return(result);
}
private static QualitySpecification Union(
[NotNull] IEnumerable <AreaSpecification> areaSpecifications,
[NotNull] string qualitySpecificationName)
{
var result = new QualitySpecification(assignUuid: true);
foreach (AreaSpecification spec in areaSpecifications)
{
result = spec.QualitySpecification.Union(result);
}
result.Name = qualitySpecificationName;
return(result);
}
internal static IEnumerable <QualityCondition> GetOrderedQualityConditions(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IOpenDataset datasetOpener)
{
var list = new List <OrderedQualitySpecificationElement>();
var knownMissingDatasets = new HashSet <Dataset>();
var knownExistingDatasets = new HashSet <Dataset>();
var listOrder = 0;
foreach (QualitySpecificationElement element in qualitySpecification.Elements)
{
if (!element.Enabled)
{
continue;
}
QualityCondition condition = element.QualityCondition;
IList <TestParameterValue> deleted = condition.GetDeletedParameterValues();
if (deleted.Count > 0)
{
ReportInvalidConditionWarning(condition, deleted);
continue;
}
// try to open the datasets
ICollection <Dataset> missingDatasets = GetMissingDatasets(
condition, datasetOpener,
knownMissingDatasets, knownExistingDatasets);
if (missingDatasets.Count > 0)
{
ReportConditionWithMissingDatasetsWarning(condition, missingDatasets);
continue;
}
list.Add(new OrderedQualitySpecificationElement(element, listOrder));
listOrder++;
}
list.Sort();
return(list.Select(ordered =>
ordered.QualitySpecificationElement.QualityCondition));
}
private static void WriteHtmlReport(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] string directory,
[NotNull] HtmlReportDefinition reportDefinition,
[NotNull] IssueStatistics issueStatistics,
[NotNull] XmlVerificationReport verificationReport,
[NotNull] string verificationReportFileName,
[CanBeNull] string issueGdbPath,
[CanBeNull] IEnumerable <string> issueMapFilePaths,
[NotNull] IEnumerable <string> htmlReportFileNames,
[CanBeNull] IEnumerable <string> qualitySpecificationReportFilePaths)
{
Assert.ArgumentNotNull(reportDefinition, nameof(reportDefinition));
Assert.ArgumentCondition(File.Exists(reportDefinition.TemplatePath),
"Template file does not exist: {0}",
reportDefinition.TemplatePath);
string reportFilePath = Path.Combine(directory, reportDefinition.FileName);
_msg.DebugFormat("Preparing html report model");
var reportModel = new HtmlReportModel(qualitySpecification,
issueStatistics,
verificationReport,
directory,
verificationReportFileName,
issueGdbPath,
issueMapFilePaths,
htmlReportFileNames,
qualitySpecificationReportFilePaths,
reportDefinition);
_msg.DebugFormat("Rendering html report based on template {0}",
reportDefinition.TemplatePath);
LiquidUtils.RegisterSafeType <HtmlReportModel>();
LiquidUtils.RegisterSafeType <HtmlTexts>();
string output = LiquidUtils.Render(
reportDefinition.TemplatePath,
new KeyValuePair <string, object>("report", reportModel),
new KeyValuePair <string, object>("text", new HtmlTexts()));
_msg.DebugFormat("Writing html report to {0}", reportFilePath);
FileSystemUtils.WriteTextFile(output, reportFilePath);
_msg.InfoFormat("Html report written to {0}", reportFilePath);
}
/// <summary>
/// Initializes a new instance of the <see cref="QualitySpecification"/> class.
/// </summary>
/// <param name="qualitySpecification">The quality specification.</param>
/// <param name="polygon">The area in the spatial reference of the data model.</param>
/// <param name="editableDatasets">The editable datasets.</param>
public AreaSpecification([NotNull] QualitySpecification qualitySpecification,
[NotNull] IPolygon polygon,
[NotNull] IEnumerable <Dataset> editableDatasets)
{
Assert.ArgumentNotNull(qualitySpecification, nameof(qualitySpecification));
Assert.ArgumentNotNull(polygon, nameof(polygon));
Assert.ArgumentNotNull(editableDatasets, nameof(editableDatasets));
_qualitySpecification = qualitySpecification;
SetPolygon(polygon);
_editableDatasets = new SimpleSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (Dataset dataset in editableDatasets)
{
_editableDatasets.TryAdd(dataset.Name);
}
}
public static ExceptionObjectRepository PrepareExceptionRepository(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IDatasetContext datasetContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] AreaOfInterest areaOfInterest,
[CanBeNull] XmlVerificationOptions verificationOptions)
{
if (verificationOptions == null)
{
return(null);
}
IWorkspace workspace = VerificationOptionUtils.GetExceptionWorkspace(
verificationOptions);
if (workspace == null)
{
return(null);
}
bool useDbfFieldNames = WorkspaceUtils.IsShapefileWorkspace(workspace);
IIssueTableFieldManagement issueTableFields =
IssueTableFieldsFactory.GetIssueTableFields(true, useDbfFieldNames);
var result = new ExceptionObjectRepository(workspace, issueTableFields,
datasetContext, datasetResolver,
areaOfInterest?.Geometry);
List <QualityCondition> qualityConditions =
qualitySpecification.Elements.Select(element => element.QualityCondition)
.ToList();
InvolvedObjectsMatchCriteria involvedObjectsMatchCriteria =
VerificationOptionUtils.GetInvolvedObjectMatchCriteria(verificationOptions);
result.ReadExceptions(qualityConditions,
VerificationOptionUtils.GetDefaultShapeMatchCriterion(
verificationOptions),
VerificationOptionUtils.GetDefaultExceptionObjectStatus(
verificationOptions),
involvedObjectsMatchCriteria);
return(result);
}
GetHtmlTestDescriptors([NotNull] QualitySpecification qualitySpecification)
{
Assert.ArgumentNotNull(qualitySpecification, nameof(qualitySpecification));
var result = new Dictionary <TestDescriptor, HtmlTestDescriptor>();
foreach (QualitySpecificationElement element in qualitySpecification.Elements)
{
TestDescriptor testDescriptor = element.QualityCondition.TestDescriptor;
HtmlTestDescriptor htmlTestDescriptor;
if (!result.TryGetValue(testDescriptor, out htmlTestDescriptor))
{
htmlTestDescriptor = new HtmlTestDescriptor(testDescriptor);
result.Add(testDescriptor, htmlTestDescriptor);
}
}
return(result);
}
internal HtmlQualitySpecification(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IEnumerable <HtmlDataQualityCategory> categories,
[NotNull] IEnumerable <HtmlQualitySpecificationElement> elements,
[NotNull] IEnumerable <HtmlTestDescriptor> testDescriptors,
[NotNull] IEnumerable <HtmlDataModel> dataModels,
DateTime reportCreationDate)
{
Name = qualitySpecification.Name;
Description = StringUtils.IsNotEmpty(qualitySpecification.Description)
? qualitySpecification.Description
: null;
Uuid = qualitySpecification.Uuid;
ReportCreationDate = reportCreationDate;
string url = qualitySpecification.Url;
if (url != null && StringUtils.IsNotEmpty(url))
{
UrlText = url;
UrlLink = SpecificationReportUtils.GetCompleteUrl(url);
}
if (qualitySpecification.TileSize != null)
{
HasTileSize = true;
TileSize = qualitySpecification.TileSize.Value;
}
else
{
HasTileSize = false;
TileSize = -1;
}
// collections are assumed to be ordered already
_categories = categories.ToList();
_elements = elements.ToList();
_testDescriptors = testDescriptors.ToList();
_rootCategories = _categories.Where(c => c.IsRoot)
.ToList();
_dataModels = dataModels.ToList();
}
public void CanGetQualifiedNames()
{
var cat1 = new DataQualityCategory("1", "1");
var cat2 = new DataQualityCategory("2", "2");
var cat1_1 = new DataQualityCategory("1", "1.1");
var cat1_2 = new DataQualityCategory("2", "1.2");
var cat1_1_1 = new DataQualityCategory("1", "1.1.1");
cat1.AddSubCategory(cat1_1);
cat1.AddSubCategory(cat1_2);
cat1_1.AddSubCategory(cat1_1_1);
var qspecA = new QualitySpecification("A")
{
Category = cat1_1
};
var qspecB = new QualitySpecification("B")
{
Category = cat1_1
};
var qspecC = new QualitySpecification("C")
{
Category = cat1_1_1
};
var qspec1 = new QualitySpecification("X");
var qspec2 = new QualitySpecification("Y");
CreateSchema(cat1, cat2, cat1_1, cat1_2, cat1_1_1,
qspecA, qspecB, qspecC, qspec1, qspec2);
UnitOfWork.NewTransaction(
delegate
{
var qspecs = Resolve <IQualitySpecificationRepository>();
Assert.AreEqual("1/1/A", GetQualifiedName(qspecs.Get("A")));
Assert.AreEqual("1/1/B", GetQualifiedName(qspecs.Get("B")));
Assert.AreEqual("1/1/1/C", GetQualifiedName(qspecs.Get("C")));
Assert.AreEqual("X", GetQualifiedName(qspecs.Get("X")));
Assert.AreEqual("Y", GetQualifiedName(qspecs.Get("Y")));
});
}
public static List <string> WriteQualitySpecificationReport(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] string directory,
[CanBeNull] string defaultTemplateFilePath,
[CanBeNull] XmlVerificationOptions options)
{
string defaultTemplateDirectory =
VerificationOptionUtils.GetDefaultTemplateDirectory(options);
var reportFilePaths = new List <string>();
foreach (XmlSpecificationReportOptions reportOptions in
VerificationOptionUtils.GetSpecificationReportOptions(options,
defaultTemplateFilePath))
{
SpecificationReportDefinition reportDefinition =
VerificationOptionUtils.GetSpecificationReportDefinition(reportOptions,
defaultTemplateFilePath,
defaultTemplateDirectory);
if (!File.Exists(reportDefinition.TemplatePath))
{
_msg.WarnFormat("Template file does not exist: {0}",
reportDefinition.TemplatePath);
continue;
}
string filePath = Path.Combine(directory, reportDefinition.FileName);
HtmlQualitySpecification model =
SpecificationReportUtils.CreateHtmlQualitySpecification(qualitySpecification,
reportDefinition);
SpecificationReportUtils.RenderHtmlQualitySpecification(
model,
reportDefinition.TemplatePath,
filePath);
reportFilePaths.Add(filePath);
}
return(reportFilePaths);
}
public static ICollection <Dataset> GetQualityConditionDatasets(
QualitySpecification qualitySpecification)
{
var datasets = new List <Dataset>();
foreach (QualitySpecificationElement element in qualitySpecification.Elements)
{
if (!element.Enabled)
{
continue;
}
QualityCondition condition = element.QualityCondition;
foreach (Dataset dataset in condition.GetDatasetParameterValues())
{
datasets.Add(dataset);
}
}
return(datasets);
}
private static HashSet <string> GetVerifiedDatasetNames(
[NotNull] QualitySpecification qualitySpecification)
{
var result = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (QualitySpecificationElement element in qualitySpecification.Elements)
{
QualityCondition qualityCondition = element.QualityCondition;
if (qualityCondition == null)
{
continue;
}
foreach (Dataset dataset in qualityCondition.GetDatasetParameterValues())
{
result.Add(dataset.Name);
}
}
return(result);
}
/// <summary>
/// Verifies the specified object classes.
/// </summary>
/// <param name="qualitySpecification">The quality specification to verify.</param>
/// <param name="datasetContext">The model context.</param>
/// <param name="datasetResolver">The resolver for getting the object dataset based on a table name, in the context of a quality condition</param>
/// <param name="issueRepository">The issue repository.</param>
/// <param name="exceptionObjectRepository">The exception object repository</param>
/// <param name="tileSize">Tile size for the quality verification.</param>
/// <param name="getKeyFieldName">Function for getting the key field name for an object dataset</param>
/// <param name="areaOfInterest">The area of interest for the verification (optional).</param>
/// <param name="trackCancel">The cancel tracker.</param>
/// <returns></returns>
public bool Verify(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IDatasetContext datasetContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] IIssueRepository issueRepository,
[CanBeNull] IExceptionObjectRepository exceptionObjectRepository,
double tileSize,
[CanBeNull] Func <IObjectDataset, string> getKeyFieldName,
[CanBeNull] AreaOfInterest areaOfInterest,
[CanBeNull] ITrackCancel trackCancel)
{
int errorCount;
int warningCount;
int rowCountWithStopConditions;
return(Verify(qualitySpecification, datasetContext, datasetResolver,
issueRepository, exceptionObjectRepository, tileSize,
getKeyFieldName, areaOfInterest, trackCancel,
out errorCount,
out warningCount,
out rowCountWithStopConditions));
}
private QualityVerification Verify([NotNull] IVerificationContext verificationContext,
[NotNull] QualitySpecification qualitySpecification,
[NotNull] VerificationServiceParameters parameters,
[CanBeNull] ICollection <IObject> objects)
{
ISpatialReference spatialReference =
verificationContext.SpatialReferenceDescriptor.SpatialReference;
if (objects != null)
{
IEnvelope selectionEnvelope = InitSelection(
objects, parameters.AreaOfInterest?.Extent, null);
if (selectionEnvelope != null)
{
VerifiedPerimeter = selectionEnvelope;
TestPerimeter = selectionEnvelope;
}
}
if (TestPerimeter == null)
{
SetTestPerimeter(parameters.AreaOfInterest, spatialReference);
}
SetParameters(parameters);
VerificationContext = verificationContext;
AllowEditing = false;
QualityVerification verification = VerifyEditableDatasets(qualitySpecification);
verification.ContextType = parameters.VerificationContextType;
verification.ContextName = parameters.VerificationContextName;
return(verification);
}
