public static IIssueRepository GetIssueRepository(
[NotNull] string directoryFullPath,
[NotNull] string gdbName,
[CanBeNull] ISpatialReference spatialReference,
IssueRepositoryType issueRepositoryType,
double gridSize1 = 0d,
double gridSize2 = 0d,
double gridSize3 = 0d,
bool addExceptionFields = false)
{
IFeatureWorkspace workspace =
CreateDatabase(directoryFullPath, gdbName, issueRepositoryType);
if (workspace == null)
{
return(null);
}
IIssueTableFieldManagement fields = GetFields(issueRepositoryType,
addExceptionFields);
Assert.NotNull(fields, "No field definition for repository type {0}",
issueRepositoryType);
var issueGdbCreator = new IssueGeodatabaseCreator(workspace,
fields,
spatialReference,
gridSize1,
gridSize2,
gridSize3);
return(issueGdbCreator.GetIssueRepository());
}
private static IIssueTableFields GetTargetFields(
[NotNull] ICollection <IObjectClass> targetExceptionClasses,
bool ensureRequiredFields = true)
{
IWorkspace workspace =
Assert.NotNull(DatasetUtils.GetUniqueWorkspace(targetExceptionClasses));
IIssueTableFieldManagement fields =
IssueTableFieldsFactory.GetIssueTableFields(
addExceptionFields: true,
useDbfFieldNames: WorkspaceUtils.IsShapefileWorkspace(workspace),
addManagedExceptionFields: true);
if (ensureRequiredFields)
{
using (_msg.IncrementIndentation("Ensuring required target fields"))
{
int addedFields = EnsureTargetFields(targetExceptionClasses, fields);
if (addedFields == 0)
{
_msg.Info("All required fields exist in target datasets");
}
}
}
return(fields);
}
private static ITable CreateTable(
[NotNull] string name,
[NotNull] IFeatureWorkspace workspace,
[NotNull] IIssueTableFieldManagement fields)
{
return(DatasetUtils.CreateTable(workspace, name, null,
FieldUtils.CreateFields(
CreateAttributeFields(fields))));
}
public IssueGeodatabaseCreator([NotNull] IFeatureWorkspace featureWorkspace,
[NotNull] IIssueTableFieldManagement fields,
[CanBeNull] ISpatialReference spatialReference,
double gridSize1 = 0d,
double gridSize2 = 0d,
double gridSize3 = 0d)
{
Assert.ArgumentNotNull(featureWorkspace, nameof(featureWorkspace));
Assert.ArgumentNotNull(fields, nameof(fields));
_featureWorkspace = featureWorkspace;
_fields = fields;
_rowWriter = CreateRowWriter(IssueDatasetUtils.RowClassName, featureWorkspace,
fields, LocalizableStrings.IssuesStandaloneTableName);
if (spatialReference != null)
{
var spatialReferenceCopy =
(ISpatialReference)((IClone)spatialReference).Clone();
if (!spatialReferenceCopy.HasZPrecision())
{
SpatialReferenceUtils.SetZDomain(spatialReferenceCopy,
-10000, 100000,
0.0001, 0.001);
}
_featureWriters.Add(
CreateFeatureWriter(
IssueDatasetUtils.PolygonClassName, featureWorkspace, fields,
esriGeometryType.esriGeometryPolygon,
spatialReferenceCopy, gridSize1, gridSize2, gridSize3,
LocalizableStrings.RawIssuesLayerName_Polygon));
_featureWriters.Add(
CreateFeatureWriter(
IssueDatasetUtils.PolylineClassName, featureWorkspace, fields,
esriGeometryType.esriGeometryPolyline,
spatialReferenceCopy, gridSize1, gridSize2, gridSize3,
LocalizableStrings.RawIssuesLayerName_Polyline));
_featureWriters.Add(
CreateFeatureWriter(
IssueDatasetUtils.MultipointClassName, featureWorkspace, fields,
esriGeometryType.esriGeometryMultipoint,
spatialReferenceCopy, gridSize1, gridSize2, gridSize3,
LocalizableStrings.RawIssuesLayerName_Multipoint));
_featureWriters.Add(
CreateFeatureWriter(
IssueDatasetUtils.MultiPatchClassName, featureWorkspace, fields,
esriGeometryType.esriGeometryMultiPatch,
spatialReferenceCopy, gridSize1, gridSize2, gridSize3,
LocalizableStrings.RawIssuesLayerName_MultiPatch));
}
}
private static IEnumerable <IField> CreateAttributeFields(
[NotNull] IIssueTableFieldManagement fields)
{
yield return(FieldUtils.CreateOIDField());
foreach (IField field in fields.CreateFields())
{
yield return(field);
}
}
private static IssueRowWriter CreateRowWriter(
[NotNull] string className,
[NotNull] IFeatureWorkspace featureWorkspace,
[NotNull] IIssueTableFieldManagement fields,
[CanBeNull] string aliasName = null)
{
ITable table = CreateTable(className, featureWorkspace, fields);
if (StringUtils.IsNotEmpty(aliasName))
{
DatasetUtils.TrySetAliasName(table, aliasName);
}
var attributeWriter = new IssueAttributeWriter(table, fields);
return(new IssueRowWriter((IObjectClass)table, attributeWriter));
}
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);
}
private static IssueFeatureWriter CreateFeatureWriter(
[NotNull] string className,
[NotNull] IFeatureWorkspace featureWorkspace,
[NotNull] IIssueTableFieldManagement fields,
esriGeometryType geometryType,
[NotNull] ISpatialReference spatialReference,
double gridSize1, double gridSize2, double gridSize3,
[NotNull] string aliasName)
{
IFeatureClass featureClass = CreateFeatureClass(className, featureWorkspace,
fields, geometryType,
spatialReference,
gridSize1, gridSize2, gridSize3);
DatasetUtils.TrySetAliasName(featureClass, aliasName);
var attributeWriter = new IssueAttributeWriter((ITable)featureClass, fields);
return(new IssueFeatureWriter(featureClass, attributeWriter));
}
private static int EnsureTargetFields(
[NotNull] IEnumerable <IObjectClass> targetExceptionClasses,
[NotNull] IIssueTableFieldManagement targetFields)
{
var addedFields = 0;
var attributes = new[]
{
// fields specific to managed exceptions
IssueAttribute.ManagedExceptionOrigin,
IssueAttribute.ManagedExceptionLineageUuid,
IssueAttribute.ManagedExceptionVersionBeginDate,
IssueAttribute.ManagedExceptionVersionEndDate,
IssueAttribute.ManagedExceptionVersionUuid,
IssueAttribute.ManagedExceptionVersionOrigin,
IssueAttribute.ManagedExceptionVersionImportStatus,
// issue fields added after initial version
IssueAttribute.IssueAssignment
};
foreach (IObjectClass targetObjectClass in targetExceptionClasses)
{
foreach (IssueAttribute attribute in attributes)
{
if (targetFields.GetIndex(attribute, (ITable)targetObjectClass,
optional: true) >= 0)
{
// field already exists
continue;
}
Add(targetObjectClass, targetFields.CreateField(attribute));
addedFields++;
}
}
return(addedFields);
}
private static IFeatureClass CreateFeatureClass(
[NotNull] string name,
[NotNull] IFeatureWorkspace workspace,
[NotNull] IIssueTableFieldManagement fields,
esriGeometryType geometryType,
[NotNull] ISpatialReference spatialReference,
double gridSize1, double gridSize2, double gridSize3)
{
const bool zAware = true;
var list = new List <IField>
{
FieldUtils.CreateShapeField(
geometryType, spatialReference,
gridSize1, gridSize2, gridSize3,
zAware)
};
list.AddRange(CreateAttributeFields(fields));
return(DatasetUtils.CreateSimpleFeatureClass(workspace, name,
FieldUtils.CreateFields(list)));
}
