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);
}
private IList <IRow> GetRowsByRelatedGeometry(
[NotNull] ITable table,
[NotNull] IObjectDataset objectDataset,
[NotNull] ITest testWithTable,
[NotNull] IEnumerable <IList <IRelationshipClass> > relClassChains)
{
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNull(objectDataset, nameof(objectDataset));
Assert.ArgumentNotNull(testWithTable, nameof(testWithTable));
HashSet <int> oids = ReferenceGeometryUtils.GetOidsByRelatedGeometry(
table, relClassChains, Assert.NotNull(_testPerimeter), testWithTable);
// Add oids of selected rows
if (ObjectSelection != null)
{
oids.UnionWith(ObjectSelection.GetSelectedOIDs(objectDataset));
}
if (oids.Count == 0)
{
return(new List <IRow>());
}
return(new List <IRow>(GdbQueryUtils.GetRowsInList(
table, table.OIDFieldName, oids,
recycle: false)));
}
public bool Contains(InvolvedRow involvedRow, QualityCondition qualityCondition,
out bool unknownTable)
{
if (involvedRow.RepresentsEntireTable)
{
unknownTable = false; // does not matter
return(false);
}
IObjectDataset dataset = _datasetResolver.GetDatasetByInvolvedRowTableName(
involvedRow.TableName, qualityCondition);
if (dataset == null)
{
// unable to resolve the dataset
unknownTable = true;
return(false);
}
unknownTable = false;
HashSet <int> objectIds;
return(_objectsByDataset.TryGetValue(dataset, out objectIds) &&
objectIds.Contains(involvedRow.OID));
}
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));
}
private static void AddResolvedInvolvedObjects(
[NotNull] AllowedError allowedError,
[NotNull] IDictionary <IObjectDataset, IDictionary <int, List <AllowedError> > >
allowedErrorsByDatasetAndObjectId)
{
foreach (InvolvedDatasetRow involvedDatasetRow in allowedError.InvolvedDatasetRows)
{
IObjectDataset objectDataset = involvedDatasetRow.Dataset;
int oid = involvedDatasetRow.ObjectId;
IDictionary <int, List <AllowedError> > errorsByInvolvedOID;
if (!allowedErrorsByDatasetAndObjectId.TryGetValue(
objectDataset,
out errorsByInvolvedOID))
{
errorsByInvolvedOID = new Dictionary <int, List <AllowedError> >();
allowedErrorsByDatasetAndObjectId.Add(objectDataset,
errorsByInvolvedOID);
}
List <AllowedError> errors;
if (!errorsByInvolvedOID.TryGetValue(oid, out errors))
{
errors = new List <AllowedError>();
errorsByInvolvedOID.Add(oid, errors);
}
errors.Add(allowedError);
}
}
public InvolvedDatasetRow([NotNull] IObjectDataset dataset, int objectId)
{
Assert.ArgumentNotNull(dataset, nameof(dataset));
Dataset = dataset;
ObjectId = objectId;
}
private esriFieldType?DetermineFieldType([NotNull] string tableName,
[NotNull] string fieldName)
{
IObjectDataset objectDataset = _datasetResolver.GetDatasetByInvolvedRowTableName(
tableName, _qualityCondition);
if (objectDataset == null)
{
return(null);
}
ITable table = _datasetContext.OpenTable(objectDataset);
if (table == null)
{
return(null);
}
int fieldIndex = table.FindField(fieldName);
if (fieldIndex < 0)
{
return(null);
}
IField field = table.Fields.Field[fieldIndex];
return(field.Type);
}
private static bool CanWriteToDataset([NotNull] IObjectDataset objectDataset,
[NotNull] IDatasetContext datasetContext)
{
IObjectClass objectClass = datasetContext.OpenObjectClass(objectDataset);
// TODO check for file geodatabase/personal geodatabase
return(objectClass != null && DatasetUtils.UserHasWriteAccess(objectClass));
}
public static IObjectClass TryOpenFromMasterDatabase(
[NotNull] IObjectDataset dataset, bool allowAlways = false)
{
IDatasetContext context = GetMasterDatabaseWorkspaceContext(dataset,
allowAlways);
return(context?.OpenObjectClass(dataset));
}
public static IObjectClass OpenObjectClass([NotNull] IFeatureWorkspace workspace,
[NotNull] string gdbDatasetName,
[NotNull] IObjectDataset dataset)
{
Model model = (Model)dataset.Model;
return(OpenObjectClass(workspace, gdbDatasetName,
dataset.GetAttribute(AttributeRole.ObjectID)?.Name,
model.SpatialReferenceDescriptor));
}
public TestsWithRelatedGeometry([NotNull] ITable table, [NotNull] IList <ITest> tests,
[NotNull] IObjectDataset objectDataset,
[NotNull]
IEnumerable <IList <IRelationshipClass> > relClassChains)
{
Table = table;
Tests = tests;
ObjectDataset = objectDataset;
RelClassChains = relClassChains;
}
public IEnumerable <int> GetSelectedOIDs(IObjectDataset dataset)
{
Assert.ArgumentNotNull(dataset, nameof(dataset));
HashSet <int> objectIds;
return(_objectsByDataset.TryGetValue(dataset, out objectIds)
? objectIds
: (IEnumerable <int>) new int[] { });
}
private static ObjectAttribute GetOriginFK([NotNull] IRelationshipClass relClass,
[NotNull] IObjectDataset objectDataset)
{
ObjectAttribute originFK = objectDataset.GetAttribute(relClass.OriginForeignKey);
Assert.NotNull(originFK, "origin foreign key not found on dataset {0}: {1}",
objectDataset.Name,
relClass.OriginForeignKey);
return(originFK);
}
public override IObjectClass OpenObjectClass(IObjectDataset dataset)
{
Assert.ArgumentNotNull(dataset, nameof(dataset));
WorkspaceDataset workspaceDataset = GetWorkspaceDataset(dataset);
return(workspaceDataset == null
? null
: ModelElementUtils.OpenObjectClass(FeatureWorkspace,
workspaceDataset.Name,
dataset));
}
private static void InvalidateAllowedErrorsByInvolvedObjectState(
[NotNull] IObjectDataset involvedObjectDataset,
[NotNull] IDatasetContext datasetContext,
[NotNull] IDictionary <int, List <AllowedError> > allowedErrorsByInvolvedObjectID,
bool invalidateIfAnyInvolvedObjectChanged)
{
ICollection <int> existingInvolvedObjectIds;
try
{
existingInvolvedObjectIds = GetExistingInvolvedObjectIds(
involvedObjectDataset, datasetContext,
allowedErrorsByInvolvedObjectID,
invalidateIfAnyInvolvedObjectChanged);
}
catch (InvolvedTableOpenException e)
{
_msg.WarnFormat(e.Message);
// don't invalidate the allowed errors that involve a table which (currently?) can't be opened
return;
}
// invalidate the allowed errors if any of the involved objects no longer exists
foreach (
KeyValuePair <int, List <AllowedError> > involvedObjectId in
allowedErrorsByInvolvedObjectID)
{
int objectId = involvedObjectId.Key;
if (objectId <= 0)
{
// QUICK FIX for https://issuetracker02.eggits.net/browse/COM-171
// this seems to be the case for allowed errors without any involved objects
// TODO find out why
continue;
}
if (existingInvolvedObjectIds.Contains(objectId))
{
// the involved object still exists
continue;
}
// object with rowId does not exist any more in table,
// so it is deleted and an implicit change
foreach (AllowedError error in
allowedErrorsByInvolvedObjectID[objectId])
{
error.Invalidated = true;
}
}
}
public static Association CreateAssociation(
[NotNull] IRelationshipClass relClass,
[NotNull] IObjectDataset destinationDataset,
[NotNull] IObjectDataset originDataset,
[NotNull] Model model)
{
bool unqualifyDatasetName = !model.HarvestQualifiedElementNames;
string relClassName = DatasetUtils.GetName(relClass);
AssociationCardinality cardinality = GetCardinality(relClass);
ObjectAttribute originPK = GetOriginPK(relClass, originDataset);
string associationName = !unqualifyDatasetName
? relClassName
: ModelElementNameUtils.GetUnqualifiedName(relClassName);
if (!relClass.IsAttributed &&
relClass.Cardinality != esriRelCardinality.esriRelCardinalityManyToMany)
{
ObjectAttribute originFK = GetOriginFK(relClass,
destinationDataset);
return(new ForeignKeyAssociation(associationName,
cardinality,
originFK,
originPK)
{
Model = model
});
}
ObjectAttribute destinationPK = GetDestinationPK(
relClass, destinationDataset);
var relTable = (ITable)relClass;
esriFieldType destinationFKType = DatasetUtils.GetField(
relTable,
relClass.DestinationForeignKey).Type;
esriFieldType originFKType = DatasetUtils.GetField(
relTable, relClass.OriginForeignKey).Type;
return(new AttributedAssociation(
associationName,
cardinality,
relClass.DestinationForeignKey, (FieldType)destinationFKType,
destinationPK,
relClass.OriginForeignKey, (FieldType)originFKType,
originPK)
{
Model = model
});
}
GetRelationshipClassChainsToVerifiedFeatureClasses(
[NotNull] IObjectDataset objectDataset,
[NotNull] IWorkspaceContextLookup workspaceContextLookup,
[CanBeNull] Predicate <VectorDataset> isRelevantVectorDataset,
out bool hasAnyAssociationsToFeatureClasses)
{
return(GetRelationshipClassChainsToVerifiedFeatureClassesCore(
objectDataset,
new List <IRelationshipClass>(),
workspaceContextLookup,
isRelevantVectorDataset,
out hasAnyAssociationsToFeatureClasses));
}
public bool IgnoreDataset([NotNull] string tableName)
{
if (_ignoredObjectDatasets == null)
{
return(false);
}
IObjectDataset objectDataset =
_datasetResolver.GetDatasetByInvolvedRowTableName(tableName,
_qualityCondition);
return(objectDataset != null && _ignoredObjectDatasets.Contains(objectDataset));
}
private static void GetSubtypes([NotNull] IObjectDataset objectDataset,
[CanBeNull] out string field,
[CanBeNull] out IList <Subtype> subtypes)
{
IObjectClass objectClass = ConfiguratorUtils.OpenFromDefaultDatabase(objectDataset);
var s = (ISubtypes)objectClass;
field = s.SubtypeFieldName;
subtypes = string.IsNullOrEmpty(field)
? null
: DatasetUtils.GetSubtypes(objectClass);
}
private TableKeyLookup GetTableRequiringIdLookup(
[NotNull] IObjectDataset objectDataset)
{
TableKeyLookup result;
if (!_tableKeyLookups.TryGetValue(objectDataset, out result))
{
result = CreateTableRequiringIdLookup(objectDataset);
_tableKeyLookups.Add(objectDataset, result);
}
return(result);
}
private static ObjectAttribute GetDestinationPK(
[NotNull] IRelationshipClass relClass,
[NotNull] IObjectDataset objectDataset)
{
ObjectAttribute destinationPK =
objectDataset.GetAttribute(relClass.DestinationPrimaryKey);
Assert.NotNull(destinationPK,
"destination primary key not found on dataset {0}: {1}",
objectDataset.Name,
relClass.DestinationPrimaryKey);
return(destinationPK);
}
private InvolvedTable CreateInvolvedTable(
[NotNull] IObjectDataset dataset,
[NotNull] IEnumerable <InvolvedRow> rows)
{
TableKeyLookup tableKeyLookup;
if (_tableKeyLookups.TryGetValue(dataset, out tableKeyLookup))
{
return(new InvolvedTable(
dataset.Name, GetAlternateKeyRowReferences(rows, tableKeyLookup),
tableKeyLookup.KeyFieldName));
}
return(new InvolvedTable(dataset.Name, GetOIDRowReferences(rows)));
}
public string GetKeyField([NotNull] IObjectDataset objectDataset)
{
if (_dataSources == null || _dataSources.Count == 0)
{
return(_defaultKeyField);
}
string key = objectDataset.Model.Name.Trim();
DataSourceKeyFieldLookup lookup;
return(_dataSources.TryGetValue(key, out lookup)
? lookup.GetKeyField(objectDataset.Name)
: _defaultKeyField);
}
public bool SaveDataset(IObjectDataset dataset)
{
try
{
if (_workspace == null)
{
Connect();
}
if (_datasets == null)
{
_datasets = new List <IObjectDataset>();
}
ITable pTable = _workspace.OpenTable("YT_TEMPLATE_DATASET");
IWorkspaceEdit pWksEdit = _workspace as IWorkspaceEdit;
pWksEdit.StartEditing(true);
pWksEdit.StartEditOperation();
IRow pRow;
int oldID = dataset.ID;
if (oldID > 0)
{
pRow = pTable.GetRow(dataset.ID);
}
else
{
pRow = pTable.CreateRow();
}
dataset.UpdateRow(pRow);
pWksEdit.StopEditOperation();
pWksEdit.StopEditing(true);
if (oldID <= 0)
{
_datasets.Add(dataset);
}
ComReleaser.ReleaseCOMObject(pTable);
DisConnect();
return(true);
}
catch (Exception ex)
{
MessageService.Current.Warn("系统发生错误:" + ex.Message);
return(false);
throw;
}
}
private IEnumerable <IList <IRelationshipClass> > GetRelClassChains(
[NotNull] ITable table,
[NotNull] IObjectDataset objectDataset,
[NotNull] ITest testWithTable,
out bool hasAnyAssociationsToFeatureClasses)
{
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNull(objectDataset, nameof(objectDataset));
Assert.ArgumentNotNull(testWithTable, nameof(testWithTable));
IEnumerable <IList <IRelationshipClass> > relClassChains =
ReferenceGeometryUtils.GetRelationshipClassChainsToVerifiedFeatureClasses(
objectDataset, _verificationContext,
_isRelevantVectorDataset, out hasAnyAssociationsToFeatureClasses);
return(relClassChains);
}
public static void RedirectAssociationEnd([NotNull] IRelationshipClass relClass,
[NotNull] AssociationEnd associationEnd,
[NotNull] IObjectDataset expectedDataset)
{
Assert.ArgumentNotNull(relClass, nameof(relClass));
Assert.ArgumentNotNull(associationEnd, nameof(associationEnd));
Assert.ArgumentNotNull(expectedDataset, nameof(expectedDataset));
if (associationEnd is ForeignKeyAssociationEnd)
{
ObjectAttribute originFK = GetOriginFK(relClass, expectedDataset);
((ForeignKeyAssociationEnd)associationEnd).Redirect(originFK);
}
else if (associationEnd is PrimaryKeyAssociationEnd)
{
ObjectAttribute originPK = GetOriginPK(relClass, expectedDataset);
((PrimaryKeyAssociationEnd)associationEnd).Redirect(originPK);
}
else if (associationEnd is ManyToManyAssociationEnd)
{
var manyToManyEnd = (ManyToManyAssociationEnd)associationEnd;
ObjectAttribute primaryKey;
if (manyToManyEnd.IsDestinationEnd)
{
primaryKey = GetDestinationPK(relClass, expectedDataset);
}
else if (manyToManyEnd.IsOriginEnd)
{
primaryKey = GetOriginPK(relClass, expectedDataset);
}
else
{
throw new InvalidDataException(
"Many to many end is neither origin nor destination for the association it belongs to");
}
manyToManyEnd.Redirect(primaryKey);
}
else
{
throw new ArgumentException("Unsupported association end type");
}
}
private void LoadObjectEdit()
{
TreeNode currentNode = trvDatabase.SelectedNode;
if (currentNode.Parent.Text == "模板")
{
IObjectTemplate template = currentNode.Tag as IObjectTemplate;
frmEditTemplate frm = new frmEditTemplate();
frm.SetTemplate(template);
frm.SetDatabase(template.Database);
frm.ShowDialog();
currentNode.Tag = frm.GetTemplate();
currentNode.Text = frm.GetTemplate().Name;
}
if (currentNode.Parent.Text == "数据字典")
{
IYTDomain domain = currentNode.Tag as IYTDomain;
frmEditDomain frm = new frmEditDomain();
frm.SetDatabase(currentNode.Parent.Parent.Tag as ITemplateDatabase);
frm.SetDomain(domain);
DialogResult result = frm.ShowDialog();
if (result == DialogResult.OK)
{
TreeNode pNode = currentNode.Parent;
pNode.Nodes.Clear();
LoadDomains(pNode.Parent.Tag as ITemplateDatabase, pNode);
}
currentNode.Tag = frm.GetDomain();
}
if (currentNode.Parent.Text == "数据集")
{
IObjectDataset dataset = currentNode.Tag as IObjectDataset;
frmEditDataset frm = new frmEditDataset();
frm.SetDatabase(currentNode.Parent.Parent.Tag as ITemplateDatabase);
frm.Dataset = dataset;
DialogResult result = frm.ShowDialog();
if (result == DialogResult.OK)
{
currentNode.Tag = frm.Dataset;
currentNode.Text = frm.Dataset.Name;
}
}
}
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 override IObjectClass OpenObjectClass(IObjectDataset dataset)
{
Assert.ArgumentNotNull(dataset, nameof(dataset));
SpatialReferenceDescriptor spatialReferenceDescriptor =
(dataset.Model as Model)?.SpatialReferenceDescriptor;
return((IObjectClass)ModelElementUtils.OpenTable(
FeatureWorkspace,
GetGdbElementName(dataset),
dataset.GetAttribute(AttributeRole.ObjectID)?.Name,
spatialReferenceDescriptor));
//return (IObjectClass) _workspaceProxy.OpenTable(
// GetGdbElementName(dataset),
// dataset.GetAttribute(AttributeRole.ObjectID)?.Name,
// spatialReferenceDescriptor);
}
private TableKeyLookup GetTableRequiringIdLookup(
[NotNull] InvolvedRow involvedRow,
[NotNull] QualitySpecificationElement element)
{
if (involvedRow.RepresentsEntireTable)
{
return(null);
}
IObjectDataset objectDataset = _datasetResolver.GetDatasetByInvolvedRowTableName(
involvedRow.TableName, element.QualityCondition);
Assert.NotNull(objectDataset,
"Unable to resolve object dataset for table name {0} and quality condition {1}",
involvedRow.TableName, element.QualityCondition.Name);
return(GetTableRequiringIdLookup(objectDataset));
}
