private static IObject GetInvolvedObject(
[NotNull] InvolvedRow involvedRow,
[NotNull] QualityCondition qualityCondition,
[NotNull] IDatasetContext datasetContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] out IObjectDataset objectDataset)
{
Assert.ArgumentNotNull(involvedRow, nameof(involvedRow));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentCondition(!involvedRow.RepresentsEntireTable,
"involved row represents entire table");
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
//string gdbTableName = involvedRow.TableName;
//objectDataset = Assert.NotNull(
// QualityVerificationUtils.GetInvolvedObjectDataset(gdbTableName,
// qualityCondition,
// datasetResolver),
// "object dataset not found for {0}", involvedRow.TableName);
string gdbTableName = involvedRow.TableName;
objectDataset = Assert.NotNull(
datasetResolver.GetDatasetByGdbTableName(gdbTableName, qualityCondition),
"object dataset not found for {0}", involvedRow.TableName);
ITable table = datasetContext.OpenTable(objectDataset);
// TODO REFACTORMODEL revise null handling
Assert.NotNull(table, "Dataset not found in workspace: {0}", objectDataset.Name);
// TODO batch!
return((IObject)table.GetRow(involvedRow.OID));
}
public static AllowedError FindAllowedErrorInSortedList(
[NotNull] List <AllowedError> allowedErrors,
[NotNull] QaError qaError,
[NotNull] QualityCondition qualityCondition,
[NotNull] ISpatialReference spatialReference,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] ICollection <esriGeometryType> storedGeometryTypes,
bool forPre10Geodatabase)
{
Assert.ArgumentNotNull(allowedErrors, nameof(allowedErrors));
Assert.ArgumentNotNull(qaError, nameof(qaError));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(spatialReference, nameof(spatialReference));
Assert.ArgumentNotNull(storedGeometryTypes, nameof(storedGeometryTypes));
if (allowedErrors.Count <= 0)
{
return(null);
}
QaError asStoredError = GetForAllowedErrorComparison(
qaError, spatialReference, storedGeometryTypes, forPre10Geodatabase);
int index = FindAllowedErrorIndex(asStoredError,
qualityCondition,
allowedErrors,
datasetResolver);
return(index < 0
? null
: allowedErrors[index]);
}
private TestsWithRelatedGeometry CreateTestsWithRelatedGeometry(
[NotNull] ITable table, [NotNull] IList <ITest> tests,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
ITest testWithTable = tests[0];
IObjectDataset objectDataset = GetInvolvedObjectDataset(
table, testWithTable, datasetResolver);
if (objectDataset == null)
{
return(null);
}
var relClassChains = GetRelClassChains(
table, objectDataset, testWithTable,
out bool hasAnyAssociationsToFeatureClasses);
var relClassChainTests =
new TestsWithRelatedGeometry(table, tests, objectDataset, relClassChains);
relClassChainTests.HasAnyAssociationsToFeatureClasses =
hasAnyAssociationsToFeatureClasses;
return(relClassChainTests);
}
public AllowedError([NotNull] QualityCondition qualityCondition,
int?conditionVersion,
[CanBeNull] IGeometry geometry,
[NotNull] string errorDescription,
[NotNull] IList <InvolvedRow> involvedRows,
[NotNull] ITable table,
int objectId,
DateTime dateOfCreation,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(errorDescription, nameof(errorDescription));
Assert.ArgumentNotNull(involvedRows, nameof(involvedRows));
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_qualityCondition = qualityCondition;
_qualityConditionVersion = conditionVersion;
_errorDescription = errorDescription;
_involvedRows = involvedRows;
_errorGeometry = new QaErrorGeometry(geometry);
_table = table;
_oid = objectId;
_dateOfCreation = dateOfCreation;
_datasetResolver = datasetResolver;
_isUsed = false;
_invalidated = false;
_usesGdbDatasetNames = false; // uses involved row table name
}
/// <summary>
/// Initializes a new instance of the <see cref="QualityErrorRepositoryBase"/> class.
/// </summary>
/// <param name="verificationContext">The model context.</param>
/// <param name="testsByQualityCondition">The dictionary of tests by quality condition.
/// It can be empty in case the <see cref="AddError"/> method is never used and the
/// <see cref="VerifiedQualityConditions"/> property is set.</param>
/// <param name="datasetResolver">The dataset resolver.</param>
/// <param name="qualityConditionRepository">The quality condition repository.</param>
protected QualityErrorRepositoryBase(
[NotNull] IVerificationContext verificationContext,
[NotNull] Dictionary <QualityCondition, IList <ITest> > testsByQualityCondition,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] IQualityConditionRepository qualityConditionRepository)
{
Assert.ArgumentNotNull(verificationContext, nameof(verificationContext));
Assert.ArgumentNotNull(testsByQualityCondition, nameof(testsByQualityCondition));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
Assert.ArgumentNotNull(qualityConditionRepository,
nameof(qualityConditionRepository));
_verificationContext = verificationContext;
_testsByQualityCondition = testsByQualityCondition;
IssueDatasets = new QualityErrorRepositoryDatasets(_verificationContext);
VerifiedQualityConditions = testsByQualityCondition.Keys;
_userName = EnvironmentUtils.UserDisplayName;
_datasetResolver = datasetResolver;
_qualityConditionRepository = qualityConditionRepository;
int gdbMajorRelease =
((IGeodatabaseRelease)
verificationContext.PrimaryWorkspaceContext.Workspace).MajorVersion + 7;
_isPre10Geodatabase = gdbMajorRelease < 10;
}
public static string GetInvolvedObjectsString(
[NotNull] QualityCondition qualityCondition,
[NotNull] QaError qaError,
[NotNull] ICollection <ITest> tests,
int maxLength,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
IEnumerable <InvolvedRow> involvedRowsWithDatasetNames =
GetInvolvedRows(qaError,
qualityCondition,
datasetResolver);
if (tests.Count == 1)
{
return(RowParser.Format(involvedRowsWithDatasetNames, maxLength));
}
var testIndex = 0;
foreach (ITest test in tests)
{
if (test == qaError.Test)
{
return(RowParser.Format(test, testIndex, involvedRowsWithDatasetNames,
maxLength));
}
testIndex++;
}
throw new InvalidProgramException(
string.Format("Test {0} not found in QualityCondition {1}",
qaError.Test.GetType(), qualityCondition.Name));
}
public ExceptionObjectEvaluator(
[NotNull] IEnumerable <ExceptionObject> exceptionObjects,
[NotNull] IDictionary <Guid, QualityCondition> conditionsByUuid,
[NotNull] IExceptionEvaluationStatistics exceptionEvaluationStatistics,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] InvolvedObjectsMatchCriteria involvedObjectsMatchCriteria,
[CanBeNull] IGeometry areaOfInterest)
{
Assert.ArgumentNotNull(exceptionObjects, nameof(exceptionObjects));
Assert.ArgumentNotNull(conditionsByUuid, nameof(conditionsByUuid));
Assert.ArgumentNotNull(exceptionEvaluationStatistics,
nameof(exceptionEvaluationStatistics));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_conditionsByUuid = conditionsByUuid;
_exceptionEvaluationStatistics = exceptionEvaluationStatistics;
_datasetResolver = datasetResolver;
_involvedObjectsMatchCriteria = involvedObjectsMatchCriteria;
_aoiBox = areaOfInterest == null || areaOfInterest.IsEmpty
? null
: QaGeometryUtils.CreateBox(areaOfInterest.Envelope);
foreach (ExceptionObject exceptionObject in exceptionObjects)
{
Add(exceptionObject);
}
}
private IObjectDataset GetInvolvedObjectDataset(
[NotNull] ITable table,
[NotNull] ITest testWithTable,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
return(datasetResolver.GetDatasetByGdbTableName(
DatasetUtils.GetName(table), _getQualityCondition(testWithTable)));
}
public AlternateKeyConverterProvider(
[NotNull] IDictionary <Guid, QualityCondition> conditionsByGuid,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] IDatasetContext datasetContext)
{
_conditionsByGuid = conditionsByGuid;
_datasetResolver = datasetResolver;
_datasetContext = datasetContext;
}
public InvolvedObjectsIgnoredDatasetPredicate(
[NotNull] QualityCondition qualityCondition,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] InvolvedObjectsMatchCriteria criteria)
{
_qualityCondition = qualityCondition;
_datasetResolver = datasetResolver;
_ignoredObjectDatasets = GetIgnoredObjectDatasets(qualityCondition, criteria);
}
/// <summary>
/// Initializes a new instance of the <see cref="AllowedErrorFactory"/> class.
/// </summary>
/// <param name="qualityConditionsById">The quality conditions by id.</param>
/// <param name="datasetResolver">The quality condition-based dataset resolver.</param>
public AllowedErrorFactory(
[NotNull] IDictionary <int, QualityCondition> qualityConditionsById,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
Assert.ArgumentNotNull(qualityConditionsById, nameof(qualityConditionsById));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_qualityConditionsById = qualityConditionsById;
_datasetResolver = datasetResolver;
}
protected override QualityErrorRepositoryBase CreateQualityErrorRepository(
IVerificationContext verificationContext,
Dictionary <QualityCondition, IList <ITest> > qualityConditionTests,
IQualityConditionObjectDatasetResolver datasetResolver)
{
// TODO get rid of subclass; but allow injecting things like an AttributeWriter etc.
// Or in the short term create a BackgroundServiceIssueRepo that is only used to read
// (allowed) errors.
return(_issueRepository = _backgroundVerificationInputs.CreateQualityErrorRepository(
verificationContext, qualityConditionTests, datasetResolver));
}
public TestAssembler(
[NotNull] IVerificationContext verificationContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] Func <ITest, QualityCondition> getQualityCondition,
[CanBeNull] Predicate <VectorDataset> isRelevantVectorDataset)
{
_verificationContext = verificationContext;
_datasetResolver = datasetResolver;
_getQualityCondition = getQualityCondition;
_isRelevantVectorDataset = isRelevantVectorDataset;
}
public AlternateKeyConverter(
[NotNull] QualityCondition qualityCondition,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] IDatasetContext datasetContext)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
_qualityCondition = qualityCondition;
_datasetResolver = datasetResolver;
_datasetContext = datasetContext;
}
public static bool IsAllowedError(
[NotNull] QaError comparableError,
[NotNull] QualityCondition qualityCondition,
[NotNull] List <AllowedError> allowedErrors,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
int index = FindAllowedErrorIndex(comparableError,
qualityCondition,
allowedErrors,
datasetResolver);
return(index >= 0);
}
private static IEnumerable <IGeometry> GetReferenceGeometries(
[NotNull] InvolvedRow involvedRow,
[NotNull] QualityCondition qualityCondition,
[NotNull] IVerificationContext verificationContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] Predicate <VectorDataset> isRelevantVectorDataset)
{
Assert.ArgumentNotNull(involvedRow, nameof(involvedRow));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(verificationContext, nameof(involvedRow));
if (involvedRow.RepresentsEntireTable)
{
yield break;
}
IObjectDataset objectDataset;
IObject obj = GetInvolvedObject(involvedRow, qualityCondition, verificationContext,
datasetResolver, out objectDataset);
var feature = obj as IFeature;
if (feature != null)
{
IGeometry shape = feature.Shape;
if (shape != null && !shape.IsEmpty)
{
yield return(shape);
}
}
else
{
bool hasAnyAssociationsToFeatureClasses;
foreach (IList <IRelationshipClass> relClassChain
in GetRelationshipClassChainsToVerifiedFeatureClasses(
objectDataset,
verificationContext,
isRelevantVectorDataset,
out hasAnyAssociationsToFeatureClasses))
{
foreach (IGeometry shape in
GetReferenceGeometries(obj, relClassChain))
{
if (shape != null && !shape.IsEmpty)
{
yield return(shape);
}
}
}
}
}
public static AllowedError FindAllowedErrorInSortedList(
[NotNull] List <AllowedError> allowedErrors,
[NotNull] QaError qaError,
[NotNull] QualityCondition qualityCondition,
[NotNull] ISpatialReference spatialReference,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] ICollection <esriGeometryType> storedGeometryTypes)
{
const bool forPre10Geodatabase = false;
return(FindAllowedErrorInSortedList(allowedErrors, qaError, qualityCondition,
spatialReference, datasetResolver,
storedGeometryTypes, forPre10Geodatabase));
}
private static int FindAllowedErrorIndex(
[NotNull] QaError comparableError,
[NotNull] QualityCondition qualityCondition,
[NotNull] List <AllowedError> allowedErrors,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
const bool usesGdbDatasetNames = true;
// TODO resolve involved rows to datasets - compare by datasets instead of table names
var searchInstance = new AllowedError(qualityCondition,
comparableError,
datasetResolver,
usesGdbDatasetNames);
return(allowedErrors.BinarySearch(searchInstance));
}
/// <summary>
/// Should only be used to search for the proper instance of the AllowedError
/// in a list.
/// </summary>
/// <param name="qualityCondition">The quality condition.</param>
/// <param name="qaError">The qa error.</param>
/// <param name="datasetResolver">The dataset resolver.</param>
/// <param name="usesGdbDatasetNames">if set to <c>true</c> [uses GDB dataset names].</param>
internal AllowedError(
[NotNull] QualityCondition qualityCondition,
[NotNull] QaError qaError,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
bool usesGdbDatasetNames)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(qaError, nameof(qaError));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_qualityCondition = qualityCondition;
_errorDescription = qaError.Description;
_errorGeometry = new QaErrorGeometry(qaError.Geometry);
_involvedRows = qaError.InvolvedRows;
_datasetResolver = datasetResolver;
_usesGdbDatasetNames = usesGdbDatasetNames;
}
private static IEnumerable <InvolvedRow> GetInvolvedRows(
[NotNull] QaError qaError,
[NotNull] QualityCondition qualityCondition,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
foreach (InvolvedRow involvedRow in qaError.InvolvedRows)
{
IObjectDataset dataset =
datasetResolver.GetDatasetByInvolvedRowTableName(
involvedRow.TableName, qualityCondition);
Assert.NotNull(dataset,
"Unable to resolve dataset {0} for quality condition {1}",
involvedRow.TableName, qualityCondition.Name);
yield return(new InvolvedRow(dataset.Name, involvedRow.OID));
}
}
public QualityConditionExceptions(
[NotNull] QualityCondition qualityCondition,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] InvolvedObjectsMatchCriteria involvedObjectsMatchCriteria,
[CanBeNull] IBox areaOfInterestBox)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_areaOfInterestBox = areaOfInterestBox;
_qualityConditionVersionGuid = new Guid(qualityCondition.VersionUuid);
_ignoredDatasetsPredicate = new InvolvedObjectsIgnoredDatasetPredicate(
qualityCondition, datasetResolver, involvedObjectsMatchCriteria);
_involvedRowsPredicate = new ExceptionObjectInvolvedRowsPredicate(
_ignoredDatasetsPredicate.IgnoreDataset);
}
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);
}
internal static IGeometry CreateReferenceGeometry(
[NotNull] IEnumerable <InvolvedRow> involvedRows,
[NotNull] IVerificationContext verificationContext,
[NotNull] QualityCondition qualityCondition,
int maximumPointCount,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] Predicate <VectorDataset> isRelevantVectorDataset)
{
var relatedGeometries = new List <IGeometry>();
foreach (InvolvedRow involvedRow in involvedRows)
{
relatedGeometries.AddRange(GetReferenceGeometries(involvedRow, qualityCondition,
verificationContext,
datasetResolver,
isRelevantVectorDataset));
}
return(UnionReferenceGeometry(relatedGeometries, maximumPointCount));
}
public ObjectSelection(
[NotNull] IEnumerable <IObject> selectedObjects,
[NotNull] IDatasetLookup datasetLookup,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
Assert.ArgumentNotNull(selectedObjects, nameof(selectedObjects));
Assert.ArgumentNotNull(datasetLookup, nameof(datasetLookup));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_datasetResolver = datasetResolver;
ICollection <IObject> objectCollection =
CollectionUtils.GetCollection(selectedObjects);
IDictionary <IObjectClass, IObjectDataset> datasetsByClass =
VerificationUtils.GetDatasetsByObjectClass(
objectCollection, datasetLookup);
foreach (IObject obj in objectCollection)
{
if (!obj.HasOID)
{
continue;
}
IObjectClass objectClass = obj.Class;
IObjectDataset dataset = datasetsByClass[objectClass];
Assert.NotNull(dataset, "Unable to resolve dataset for object class {0}",
DatasetUtils.GetName(objectClass));
HashSet <int> objectIds;
if (!_objectsByDataset.TryGetValue(dataset, out objectIds))
{
objectIds = new HashSet <int>();
_objectsByDataset.Add(dataset, objectIds);
}
objectIds.Add(obj.OID);
}
}
private IList <TestsWithRelatedGeometry> FindTestsWithRelatedGeometry(
[NotNull] ICollection <ITest> tests,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] out IList <ITest> testsWithoutGeometry)
{
Assert.ArgumentNotNull(tests, nameof(tests));
testsWithoutGeometry = new List <ITest>();
if (tests.Count == 0)
{
return(new List <TestsWithRelatedGeometry>());
}
Dictionary <ITable, IList <ITest> > testsByTable =
TestUtils.GetTestsByTable(tests);
var testsWithRelatedGeometry = new List <TestsWithRelatedGeometry>();
foreach (KeyValuePair <ITable, IList <ITest> > pair in testsByTable)
{
ITable table = pair.Key;
IList <ITest> tableTests = pair.Value;
TestsWithRelatedGeometry testsWithRelGeom =
CreateTestsWithRelatedGeometry(table, tableTests, datasetResolver);
if (testsWithRelGeom?.HasAnyAssociationsToFeatureClasses == true)
{
testsWithRelatedGeometry.Add(testsWithRelGeom);
}
else
{
foreach (ITest test in tableTests)
{
testsWithoutGeometry.Add(test);
}
}
}
return(testsWithRelatedGeometry);
}
/// <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));
}
public BufferedIssueWriter(
[NotNull] IVerificationReportBuilder verificationReportBuilder,
[NotNull] IDatasetContext datasetContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[CanBeNull] IIssueRepository issueRepository,
[CanBeNull] Func <IObjectDataset, string> getAlternateKeyField,
int maximumErrorCount = 10000,
int maximumVertexCount = 1000000)
{
Assert.ArgumentNotNull(verificationReportBuilder,
nameof(verificationReportBuilder));
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_verificationReportBuilder = verificationReportBuilder;
_datasetContext = datasetContext;
_issueRepository = issueRepository;
_getAlternateKeyField = getAlternateKeyField;
_maximumErrorCount = maximumErrorCount;
_maximumVertexCount = maximumVertexCount;
_datasetResolver = datasetResolver;
}
private static IEnumerable <IRow> GetInvolvedRows(
[NotNull] IErrorObject errorObject,
[NotNull] IDatasetContext datasetContext,
[NotNull] IQualityConditionRepository qualityConditionRepository,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
IList <InvolvedRow> involved = RowParser.Parse(errorObject.RawInvolvedObjects);
QualityCondition qualityCondition = GetQualityCondition(errorObject,
qualityConditionRepository);
if (qualityCondition == null)
{
yield break;
}
foreach (KeyValuePair <string, IList <int> > pair in
GetInvolvedObjectIDsByTableName(involved))
{
string tableName = pair.Key;
IList <int> objectIDs = pair.Value;
IObjectDataset dataset =
datasetResolver.GetDatasetByInvolvedRowTableName(tableName, qualityCondition);
if (dataset == null)
{
continue;
}
ITable table;
try
{
table = datasetContext.OpenTable(dataset);
}
catch (Exception e)
{
_msg.WarnFormat("Error getting involved rows for table {0}: {1}", tableName,
e.Message);
continue;
}
if (table == null)
{
continue;
}
IEnumerable <IRow> rows = TryGetRows(table, objectIDs);
if (rows == null)
{
// error already logged in TryGetRows()
continue;
}
foreach (IRow row in rows)
{
if (GdbObjectUtils.IsDeleted(row))
{
// don't return deleted rows
continue;
}
yield return(row);
}
}
}
/// <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 test run perimeter (optional).</param>
/// <param name="trackCancel">The cancel tracker.</param>
/// <param name="errorCount">The number of (hard) errors.</param>
/// <param name="warningCount">The number of warnings.</param>
/// <param name="rowCountWithStopConditions">The number of rows for which a stop condition was violated - those rows may not be completely tested.</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,
out int errorCount,
out int warningCount,
out int rowCountWithStopConditions)
{
Assert.ArgumentNotNull(qualitySpecification, nameof(qualitySpecification));
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
Assert.ArgumentCondition(tileSize > 0, "Invalid tile size: {0}", tileSize);
_verificationReportBuilder.BeginVerification(areaOfInterest);
IEnumerable <QualitySpecificationElement> elements =
GetOrderedElements(qualitySpecification).ToList();
IDictionary <ITest, QualitySpecificationElement> elementsByTest;
IEnumerable <ITest> tests =
CreateTests(elements, datasetContext, out elementsByTest).ToList();
var qualityConditionCount = 0;
foreach (QualitySpecificationElement element in elements)
{
qualityConditionCount++;
_verificationReportBuilder.AddVerifiedQualityCondition(element);
}
var datasetCount = 0;
foreach (Dataset dataset in
GetVerifiedDatasets(qualitySpecification, datasetContext))
{
datasetCount++;
_verificationReportBuilder.AddVerifiedDataset(dataset);
}
Stopwatch watch = _msg.DebugStartTiming();
LogTests(tests, elementsByTest);
TestContainer testContainer = CreateTestContainer(tests, tileSize);
LogBeginVerification(qualitySpecification, tileSize, areaOfInterest);
IssueProcessor issueProcessor;
ProgressProcessor progressProcessor;
using (var issueWriter = new BufferedIssueWriter(_verificationReportBuilder,
datasetContext, datasetResolver,
issueRepository,
getKeyFieldName))
{
issueProcessor = CreateIssueProcessor(testContainer, issueWriter,
areaOfInterest, exceptionObjectRepository,
elementsByTest);
progressProcessor = new ProgressProcessor(testContainer, elementsByTest,
trackCancel);
testContainer.QaError += (sender, args) => issueProcessor.Process(args);
testContainer.TestingRow +=
delegate(object o, RowEventArgs args)
{
if (issueProcessor.HasStopCondition(args.Row))
{
args.Cancel = true;
}
};
testContainer.ProgressChanged +=
(sender, args) => progressProcessor.Process(args);
// run the tests
TestExecutionUtils.Execute(testContainer, areaOfInterest);
}
_verificationReportBuilder.AddRowsWithStopConditions(
issueProcessor.GetRowsWithStopConditions());
if (exceptionObjectRepository != null)
{
_verificationReportBuilder.AddExceptionStatistics(
exceptionObjectRepository.ExceptionStatistics);
}
_verificationReportBuilder.EndVerification(progressProcessor.Cancelled);
_msg.DebugStopTiming(watch, "Verification");
errorCount = issueProcessor.ErrorCount;
warningCount = issueProcessor.WarningCount;
rowCountWithStopConditions = issueProcessor.RowsWithStopConditionsCount;
bool fulfilled = errorCount == 0 && !progressProcessor.Cancelled;
LogResults(elements, issueProcessor,
qualityConditionCount, datasetCount,
fulfilled, progressProcessor.Cancelled,
exceptionObjectRepository?.ExceptionStatistics);
return(fulfilled);
}
