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); }