private static void AddOrUpdateAttribute(
[NotNull] AttributedAssociation attributedAssociation,
[NotNull] IField field,
int fieldIndex)
{
Assert.ArgumentNotNull(field, nameof(field));
const bool includeDeleted = true;
AssociationAttribute attribute =
attributedAssociation.GetAttribute(field.Name, includeDeleted);
if (attribute == null)
{
_msg.InfoFormat("Adding attribute {0}", field.Name);
attribute = attributedAssociation.AddAttribute(field.Name, (FieldType)field.Type);
}
else
{
// attribute already registered
if (attribute.Deleted)
{
_msg.WarnFormat(
"Attribute {0} was registered as deleted, but exists now. " +
"Resurrecting it...", attribute.Name);
attribute.RegisterExisting();
}
attribute.FieldType = (FieldType)field.Type;
}
// configure the attribute
attribute.SortOrder = fieldIndex;
}
public static double Clip(double value, double min, double max,
[CanBeNull] string parameter = null)
{
if (value < min)
{
if (!string.IsNullOrEmpty(parameter))
{
_msg.WarnFormat("{0} was {1}, clipped to {2}", parameter, value, min);
}
return(min);
}
if (value > max)
{
if (!string.IsNullOrEmpty(parameter))
{
_msg.WarnFormat("{0} was {1}, clipped to {2}", parameter, value, max);
}
return(max);
}
return(value);
}
void IVerificationReportBuilder.AddIssue(Issue issue, IGeometry errorGeometry)
{
_errors.Add(issue);
_msg.WarnFormat(issue.Allowable
? "Error ({0}, soft): {1}"
: "Error ({0}, hard): {1}",
issue.QualityCondition.Name, issue);
}
private static void AddOrUpdateObjectType([NotNull] ObjectDataset objectDataset,
[NotNull] Subtype subtype,
int subtypeIndex,
[NotNull] IEnumerable <Subtype> allSubtypes)
{
Assert.ArgumentNotNull(subtype, nameof(subtype));
Assert.ArgumentNotNull(allSubtypes, nameof(allSubtypes));
ObjectType objectType = GetObjectType(objectDataset, subtype, allSubtypes);
if (objectType == null)
{
objectType = new ObjectType(objectDataset, subtype.Code, subtype.Name);
_msg.InfoFormat("Adding object type {0}", objectType.Name);
objectDataset.AddObjectType(subtype.Code, subtype.Name);
}
else
{
// object type already registered
if (objectType.Deleted)
{
_msg.WarnFormat(
"Object type {0} ({1}) was registered as deleted, but exists now. " +
"Resurrecting it...",
objectType.Name, objectType.SubtypeCode);
objectType.RegisterExisting();
}
// update properties
if (!Equals(objectType.Name, subtype.Name))
{
_msg.InfoFormat("Updating name of object type {0} to {1}",
objectType.Name, subtype.Name);
objectType.UpdateName(subtype.Name);
}
if (!Equals(objectType.SubtypeCode, subtype.Code))
{
_msg.InfoFormat("Updating subtype code of object type {0} from {1} to {2}",
objectType.Name, objectType.SubtypeCode, subtype.Code);
objectType.UpdateSubtypeCode(subtype.Code);
}
}
// configure the object type
objectType.SortOrder = subtypeIndex;
}
private static void LogResults(
[NotNull] IEnumerable <QualitySpecificationElement> qualitySpecificationElements,
[NotNull] IssueProcessor issueProcessor,
int qualityConditionCount, int datasetCount,
bool fulfilled, bool cancelled,
[CanBeNull] IExceptionStatistics exceptionStatistics)
{
using (_msg.IncrementIndentation("Quality verification finished"))
{
_msg.InfoFormat("Number of verified datasets: {0:N0}", datasetCount);
using (_msg.IncrementIndentation("Number of verified quality conditions: {0:N0}",
qualityConditionCount))
{
LogVerifiedConditions(qualitySpecificationElements,
issueProcessor,
exceptionStatistics);
}
_msg.InfoFormat("Warning count: {0:N0}", issueProcessor.WarningCount);
_msg.InfoFormat("Error count: {0:N0}", issueProcessor.ErrorCount);
if (issueProcessor.RowsWithStopConditionsCount > 0)
{
_msg.WarnFormat("Number of features with stop errors: {0:N0}",
issueProcessor.RowsWithStopConditionsCount);
}
if (exceptionStatistics != null &&
exceptionStatistics.TablesWithNonUniqueKeys.Count > 0)
{
_msg.WarnFormat(
"Number of tables with non-unique keys referenced by exception objects: {0}",
exceptionStatistics.TablesWithNonUniqueKeys.Count);
}
if (cancelled)
{
_msg.Warn("The quality verification was cancelled");
}
else if (fulfilled)
{
_msg.Info("The quality specification is fulfilled");
}
else
{
_msg.Warn("The quality specification is not fulfilled");
}
}
}
public void GetConfigurations([CanBeNull] out T localConfiguration,
[CanBeNull] out T centralConfiguration,
bool suppressXmlSchemaWarning = false)
{
centralConfiguration = null;
var issueNotifications = new NotificationCollection();
if (ConfigurationExists(CentralConfigDirectory, ConfigFileName))
{
_centralConfiguration = GetConfiguration(
CentralConfigDirectory, ConfigFileName,
issueText => issueNotifications.Add(issueText));
if (issueNotifications.Count > 0 && !suppressXmlSchemaWarning)
{
// This could happen if the schema changes other than just adding new nodes:
_msg.WarnFormat(
"The central configuration file {0} in {1} could not be read completely ({2}). Please review its structure and ensure it conforms to the current schema.",
ConfigFileName, CentralConfigDirectory,
issueNotifications.Concatenate(". "));
}
centralConfiguration = _centralConfiguration;
}
else if (_hardCodedDefaults != null)
{
centralConfiguration = _hardCodedDefaults;
}
localConfiguration = null;
issueNotifications.Clear();
if (ConfigurationExists(LocalConfigDirectory, ConfigFileName))
{
localConfiguration = GetConfiguration(
LocalConfigDirectory, ConfigFileName,
issueText => issueNotifications.Add(issueText));
if (issueNotifications.Count > 0 && !suppressXmlSchemaWarning)
{
// Could happen if the schema changes other than just adding new nodes:
_msg.WarnFormat(
"The local configuration file {0} in {1} could not be read completely ({2}). Please review and accept the current settings in the options dialog.",
ConfigFileName, CentralConfigDirectory,
issueNotifications.Concatenate(". "));
}
}
}
public FieldConfigurator(
[NotNull] IEnumerable <XmlFieldOptions> fieldOptionsCollection)
{
Assert.ArgumentNotNull(fieldOptionsCollection, nameof(fieldOptionsCollection));
foreach (XmlFieldOptions fieldOptions in fieldOptionsCollection)
{
if (string.IsNullOrEmpty(fieldOptions.Field))
{
continue;
}
string trimmedField = fieldOptions.Field.Trim();
if (trimmedField.StartsWith(_rolePrefix))
{
string roleName = trimmedField.Substring(1);
IssueAttribute role;
if (!EnumUtils.TryParse(roleName, ignoreCase: true, result: out role))
{
_msg.WarnFormat("Unknown attribute role: {0}", roleName);
continue;
}
if (_fieldOptionsByRole.ContainsKey(role))
{
_msg.WarnFormat(
"Duplicate field options configuration for attribute role {0}",
role);
continue;
}
_fieldOptionsByRole.Add(role, fieldOptions);
}
else
{
if (_fieldOptionsByName.ContainsKey(trimmedField))
{
_msg.WarnFormat("Duplicate field options configuration for field name {0}",
trimmedField);
continue;
}
_fieldOptionsByName.Add(trimmedField, fieldOptions);
}
}
}
public static Plane3D GetSourcePlane([NotNull] IList <Pnt3D> pntList,
double coplanarityTolerance,
bool warnIfNotPlanar = true)
{
Plane3D sourcePlane = Plane3D.TryFitPlane(pntList);
if (sourcePlane == null)
{
return(null);
}
double maxDeviation;
string message;
bool?coplanar = AreCoplanar(
pntList, sourcePlane, coplanarityTolerance, out maxDeviation,
out message);
if (coplanar == null || !coplanar.Value)
{
if (warnIfNotPlanar)
{
_msg.WarnFormat(
"Input geometry contains non-coplanar points. The result will not be co-planar either.");
}
_msg.DebugFormat(
"Input points are not planar w.r.t. tolerance {0}: {1}",
coplanarityTolerance, StringUtils.Concatenate(pntList, ", "));
}
return(sourcePlane);
}
private static void CreateIndex([NotNull] IssueFeatureWriter writer,
[CanBeNull] ITrackCancel trackCancel,
bool ignoreErrors)
{
_msg.InfoFormat(writer.WriteCount == 1
? "Creating spatial index for {0} issue feature in '{1}'"
: "Creating spatial index for {0} issue features in '{1}'",
writer.WriteCount, writer.Name);
try
{
writer.CreateSpatialIndex(trackCancel);
}
catch (Exception e)
{
if (!ignoreErrors)
{
throw;
}
_msg.Debug("Error creating spatial index", e);
_msg.WarnFormat("Error creating spatial index for feature class {0}: {1}",
writer.Name, e.Message);
}
}
public T ReadFromFile([NotNull] string xmlFile)
{
Action <string> logWarn =
text => _msg.WarnFormat("Reading config file {0}: {1}", xmlFile, text);
return(ReadFromFile(xmlFile, logWarn));
}
private static void TryMoveLegacyFolderContent()
{
if (!Directory.Exists(LegacyFolderPath))
{
return;
}
if (!Directory.Exists(FolderPath))
{
if (!TryCreateFormStateDirectory())
{
return;
}
}
string searchPattern = string.Format("*.{0}", _fileExtension);
foreach (string legacyFilePath in Directory.GetFiles(
LegacyFolderPath, searchPattern))
{
string fileName = Assert.NotNull(Path.GetFileName(legacyFilePath));
string targetFilePath = Path.Combine(FolderPath, fileName);
if (!File.Exists(targetFilePath))
{
_msg.DebugFormat("Moving form state file {0} to {1}", legacyFilePath,
FolderPath);
try
{
File.Move(legacyFilePath, targetFilePath);
}
catch (Exception ex)
{
_msg.WarnFormat("Error moving form state file {0} to {1}: {2}",
legacyFilePath, FolderPath, ex.Message);
}
}
else
{
TryDeleteLegacyFile(legacyFilePath);
}
}
TryDeleteLegacyFolderIfEmpty();
}
public int Compare(object value1, object value2, int fieldIndex, int fieldSortIndex)
{
// TODO: sometimes the OID gets provided (with fieldSortIndex == 1) -> we never asked for it!
// test whether we can safely ignore it by if (fieldSortIndex > 0) return 0;
try
{
if (fieldSortIndex > 0)
{
_msg.VerboseDebugFormat(
"Assuming equal IDs: value1 {0}, value2 {1}, fieldIndex {2}, fieldSortIndex {3}",
value1, value2, fieldIndex, fieldSortIndex);
return(0);
}
if (Convert.IsDBNull(value1))
{
_msg.WarnFormat("Sort field (fieldindex {0}) contains NULL (value1).",
fieldIndex);
return(Convert.IsDBNull(value2) ? 0 : -1);
}
if (Convert.IsDBNull(value2))
{
_msg.WarnFormat("Sort field (fieldindex {0}) contains NULL (value2).",
fieldIndex);
return(Convert.IsDBNull(value1) ? 0 : 1);
}
// NOTE: To avoid exception with explicit cast
// TODO: Check performance
string value1String = Convert.ToString(value1);
string value2String = Convert.ToString(value2);
return(string.Compare(value1String, value2String,
StringComparison.InvariantCultureIgnoreCase));
}
catch (Exception e)
{
_msg.Debug(
string.Format("Error comparing object values {0} and {1}", value1, value2), e);
throw;
}
}
public static bool TryDeleteOutputDirectory([NotNull] string directoryPath)
{
try
{
_msg.DebugFormat("Trying to delete the generated output directory: {0}",
directoryPath);
const bool recursive = true;
Directory.Delete(directoryPath, recursive);
_msg.Debug("Directory successfully deleted");
return(true);
}
catch (Exception e)
{
_msg.WarnFormat("Error cleaning up generated output directory: {0}", e.Message);
return(false);
}
}
private static IEnumerable <IGeometry> GetReferenceGeometries(
[NotNull] IObject obj,
[NotNull] IList <IRelationshipClass> relationshipChainToFeatureClass)
{
if (relationshipChainToFeatureClass.Count == 0)
{
yield break;
}
if (relationshipChainToFeatureClass.Count == 1)
{
foreach (IObject relatedObject in
GdbQueryUtils.GetRelatedObjects(obj, relationshipChainToFeatureClass))
{
var relatedFeature = relatedObject as IFeature;
if (relatedFeature != null)
{
yield return(relatedFeature.Shape);
}
else
{
_msg.DebugFormat("Related object in spatial relation is not a feature: {0}",
GdbObjectUtils.ToString(relatedObject));
}
}
}
else
{
int?shapeFieldIndex = null;
foreach (IRow joinedRow in GetJoinedRows(obj, relationshipChainToFeatureClass))
{
// determine shape field index based on the first row
if (shapeFieldIndex == null)
{
int index;
if (TryGetShapeFieldIndex(joinedRow.Fields, out index))
{
shapeFieldIndex = index;
}
else
{
_msg.WarnFormat(
"Shape field not found in joined table for getting reference geometry for {0}",
DatasetUtils.GetName(obj.Class));
yield break;
}
}
yield return(joinedRow.Value[shapeFieldIndex.Value] as IGeometry);
}
}
}
public static T Deserialize <T>([NotNull] TextReader textReader,
[NotNull] XmlSchema xmlSchema)
{
Assert.ArgumentNotNull(textReader, nameof(textReader));
Assert.ArgumentNotNull(xmlSchema, nameof(xmlSchema));
var schemas = new XmlSchemaSet();
schemas.Add(xmlSchema);
var settings = new XmlReaderSettings
{
Schemas = schemas,
ValidationType = ValidationType.Schema,
ValidationFlags =
XmlSchemaValidationFlags.ProcessIdentityConstraints |
XmlSchemaValidationFlags.ReportValidationWarnings |
XmlSchemaValidationFlags.AllowXmlAttributes
};
Exception firstException = null;
settings.ValidationEventHandler +=
delegate(object sender, ValidationEventArgs args)
{
if (args.Severity == XmlSeverityType.Error)
{
firstException = args.Exception;
}
else
{
_msg.WarnFormat(args.Message);
}
};
var serializer = new XmlSerializer(typeof(T));
T document;
using (XmlReader reader = XmlReader.Create(textReader, settings))
{
document = (T)serializer.Deserialize(reader);
}
if (firstException != null)
{
throw firstException;
}
return(document);
}
public static ApplyCutLinesResponse ApplyCutLines(
[NotNull] ApplyCutLinesRequest request,
[CanBeNull] ITrackCancel trackCancel)
{
IList <CutSubcurve> cutCurves = request.CutLines.Select(FromReshapeLineMsg).ToList();
FeatureCutter cutter = CreateFeatureCutter(request, out IList <IFeature> targetFeatures);
cutter.Cut(cutCurves);
List <IFeature> storedFeatures = new List <IFeature>();
var response = new ApplyCutLinesResponse();
if (cutter.ResultGeometriesByFeature.Count > 0)
{
cutter.StoreResultFeatures(storedFeatures);
cutter.LogSuccessfulCut();
ICollection <KeyValuePair <IFeature, IList <IFeature> > > insertsByOriginal =
cutter.InsertedFeaturesByOriginal;
IList <ResultObjectMsg> ResultObjectMsgs =
GetResultFeatureMessages(insertsByOriginal, storedFeatures);
response.ResultFeatures.AddRange(ResultObjectMsgs);
// Calculate the new cut lines:
List <IFeature> newSourceFeatures = new List <IFeature>(cutter.SourceFeatures);
newSourceFeatures.AddRange(
insertsByOriginal.SelectMany(kvp => kvp.Value));
var newSubcurves =
CalculateCutLines(newSourceFeatures, targetFeatures,
request.CalculationRequest, trackCancel,
out ReshapeAlongCurveUsability usability);
response.CutLinesUsability = (int)usability;
response.NewCutLines.AddRange(newSubcurves.Select(ToReshapeLineMsg));
return(response);
}
_msg.WarnFormat("The selection was not cut. Please select the lines to cut along");
return(response);
}
public static double Clamp(this double value, double min, double max, string name = null)
{
if (value < min)
{
if (!string.IsNullOrEmpty(name))
{
_msg.WarnFormat("{0} was {1}, clamped to {2}", name, value, min);
}
return(min);
}
if (value > max)
{
if (!string.IsNullOrEmpty(name))
{
_msg.WarnFormat("{0} was {1}, clamped to {2}", name, value, max);
}
return(max);
}
return(value);
}
private void HandleValidationResult(bool valid,
[NotNull] NotificationCollection notifications)
{
if (!valid)
{
if (WeakValidation)
{
_msg.WarnFormat("Invalid linear network features:{0}{1}", Environment.NewLine,
NotificationUtils.Concatenate(
notifications, Environment.NewLine));
}
else
{
throw new RuleViolationException(notifications);
}
}
}
private static AdvancedReshapeResponse NoReshapeResponse(
NotificationCollection notifications)
{
string notificationMessage =
notifications.Count > 0
? $"{Environment.NewLine}{notifications.Concatenate(Environment.NewLine)}"
: string.Empty;
string noReshapeMessage = $"Unable to perform reshape{notificationMessage}";
_msg.WarnFormat(noReshapeMessage);
return(new AdvancedReshapeResponse()
{
WarningMessage = noReshapeMessage
});
}
public bool InitializeApplication(
[NotNull] esriLicenseProductCode[] productCodes,
[NotNull] esriLicenseExtensionCode[] extensionLicenseCodes)
{
try
{
TryBindProduct(productCodes);
}
catch (Exception ex)
{
_msg.Debug("Exception while binding ArcGIS 10 product.", ex);
}
if (_aoInitialize == null)
{
try
{
// If the next line fails with error code -2147221164: make sure that exe's are compiled for x86
// Otherwise on 64bit systems this error occurs.
_aoInitialize = new AoInitializeClass();
}
catch (Exception e)
{
_msg.Debug("Error initializing ArcObjects", e);
_msg.Warn("Unable to initialize ArcGIS. This application cannot run! " +
"Please check that ArcGIS (Desktop, Engine or Server) is installed.");
return(false);
}
}
//Initialize the application
_productsCodes = productCodes;
_extensionsCodes = extensionLicenseCodes;
esriLicenseStatus licenseStatus = CheckOutLicenses();
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
_msg.WarnFormat("ESRI License Initializer: {0}", LicenseMessage(licenseStatus));
return(false);
}
return(true);
}
private void Write([NotNull] IFeature feature,
AttributeRole role,
[CanBeNull] object value)
{
Assert.ArgumentNotNull(feature, nameof(feature));
int fieldIndex;
IField field = GetField(feature.Fields, role, out fieldIndex);
if (value == null || value is DBNull)
{
if (field.IsNullable)
{
feature.Value[fieldIndex] = DBNull.Value;
}
return;
}
if (field.Type != esriFieldType.esriFieldTypeString)
{
feature.Value[fieldIndex] = value;
return;
}
var stringValue = value as string;
Assert.NotNull(stringValue, "Unexpected value for text field: {0}", value);
bool requiresTrim = stringValue.Length > field.Length;
if (requiresTrim)
{
_msg.WarnFormat("Text is too long for field '{0}', cutting off: {1}",
field.Name, stringValue);
}
string writeValue = requiresTrim
? stringValue.Substring(0, field.Length)
: stringValue;
feature.Value[fieldIndex] = writeValue;
}
public T Read()
{
if (!File.Exists(_filePath))
{
return(new T());
}
var serializer = new XmlSerializationHelper <T>();
try
{
return(serializer.ReadFromFile(_filePath));
}
catch (Exception e)
{
_msg.WarnFormat("Error reading options from file: {0}", e.Message);
return(new T());
}
}
public static BoundDataGridSelectionState <TRow> GetSelectionState <TRow>(
[NotNull] DataGridView grid, bool rowsMustAlsoBeVisible = true)
where TRow : class
{
var set = new HashSet <TRow>();
string firstErrorMessage = null;
int errorCount = 0;
foreach (DataGridViewRow row in grid.SelectedRows)
{
if (rowsMustAlsoBeVisible && !row.Visible)
{
continue;
}
TRow item;
string message;
if (!TryGetDataBoundItem(row, out item, out message))
{
errorCount++;
if (firstErrorMessage == null)
{
firstErrorMessage = message;
}
}
else if (item != null)
{
set.Add(item);
}
}
if (errorCount > 0)
{
_msg.WarnFormat("{0} error(s) getting bound items. First message: {1}",
errorCount, firstErrorMessage);
}
return(new BoundDataGridSelectionState <TRow>(set));
}
protected override void CollectCurrentUserSearchPaths(ICollection <string> paths)
{
// if environment variable exists, add the path it contains
string dirPath = Environment.GetEnvironmentVariable(
EnvironmentVariables.ConfigDirectoryVariableName);
if (!StringUtils.IsNullOrEmptyOrBlank(dirPath))
{
if (FileSystemUtils.HasInvalidPathChars(dirPath))
{
_msg.WarnFormat(
"The path specified in variable {0} contains invalid characters: {1}",
EnvironmentVariables.ConfigDirectoryVariableName, dirPath);
}
else
{
paths.Add(dirPath);
}
}
base.CollectCurrentUserSearchPaths(paths);
}
private void ProcessFinalResult(Task <bool> task, SubResponse subVerification)
{
if (task.IsFaulted)
{
_msg.WarnFormat("Sub-verification has faulted: {0}", subVerification);
CancellationTokenSource.Cancel();
CancellationMessage = task.Exception?.InnerException?.Message;
}
if (!string.IsNullOrEmpty(subVerification.CancellationMessage))
{
CancellationMessage = subVerification.CancellationMessage;
}
QualityVerificationMsg verificationMsg = subVerification.VerificationMsg;
if (verificationMsg != null)
{
AddVerification(verificationMsg, QualityVerification);
}
DrainIssues(subVerification);
}
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);
}
}
}
internal static void LogQualityVerification(
[NotNull] QualityVerification verification)
{
try
{
var sb = new StringBuilder();
sb.AppendLine(verification.Cancelled
? "The quality verification was cancelled"
: "Quality verified");
int conditionCount = verification.ConditionVerifications.Count;
sb.AppendFormat("- {0:N0} quality condition{1} verified",
conditionCount, conditionCount == 1
? ""
: "s");
sb.AppendLine();
int issueCount = verification.IssueCount;
if (issueCount == 0)
{
sb.AppendLine("- No issues found");
}
else
{
sb.AppendFormat(issueCount == 1
? "- {0:N0} issue found"
: "- {0:N0} issues found",
issueCount);
sb.AppendLine();
sb.AppendFormat(" - Errors: {0:N0}", verification.ErrorCount);
sb.AppendLine();
sb.AppendFormat(" - Warnings: {0:N0}", verification.WarningCount);
sb.AppendLine();
if (verification.RowsWithStopConditions > 0)
{
sb.AppendFormat(" - Number of rows with a stop condition error: {0:N0}",
verification.RowsWithStopConditions);
sb.AppendLine();
}
}
if (!verification.Cancelled)
{
sb.AppendLine(verification.Fulfilled
? "- The quality specification is fulfilled"
: "- The quality specification is not fulfilled");
}
if (verification.Fulfilled)
{
_msg.InfoFormat(sb.ToString());
}
else
{
_msg.WarnFormat(sb.ToString());
}
LogVerificationDetails(verification);
}
catch (Exception e)
{
_msg.Warn("Error writing report to log", e);
// continue
}
}
/// <summary>
/// Calculates the DifferenceLines and adds the subcurves to the provided result list.
/// </summary>
/// <param name="sourceGeometry"></param>
/// <param name="targetPolyline"></param>
/// <param name="resultList">All resulting subcurves including the ones that cannot be used to reshape</param>
/// <param name="trackCancel"></param>
/// <returns></returns>
public ReshapeAlongCurveUsability CalculateSubcurves(
IGeometry sourceGeometry,
IPolyline targetPolyline,
IList <CutSubcurve> resultList,
ITrackCancel trackCancel)
{
Assert.ArgumentNotNull(sourceGeometry);
Assert.ArgumentNotNull(targetPolyline);
Assert.ArgumentNotNull(resultList);
Stopwatch watch = _msg.DebugStartTiming();
IPolyline preprocessedSourcePolyline =
ChangeGeometryAlongUtils.GetPreprocessedGeometryForExtent(
sourceGeometry, ClipExtent);
if (preprocessedSourcePolyline.IsEmpty)
{
_msg.WarnFormat("Source feature is outside the processing extent.");
return(ReshapeAlongCurveUsability.NoSource);
}
IPointCollection intersectionPoints;
IGeometryCollection differences = CalculateDifferences(
preprocessedSourcePolyline,
targetPolyline,
trackCancel,
out intersectionPoints);
if (trackCancel != null && !trackCancel.Continue())
{
return(ReshapeAlongCurveUsability.Undefined);
}
if (differences == null)
{
return(ReshapeAlongCurveUsability.AlreadyCongruent);
}
SubcurveFilter?.PrepareForSource(sourceGeometry);
bool canReshape = CalculateReshapeSubcurves(
preprocessedSourcePolyline, targetPolyline, differences,
intersectionPoints, resultList, trackCancel);
JoinNonForkingSubcurves(resultList);
Marshal.ReleaseComObject(preprocessedSourcePolyline);
Marshal.ReleaseComObject(differences);
_msg.DebugStopTiming(
watch, "RecalculateReshapableSubcurves: Total number of curves: {0}.",
resultList.Count);
if (canReshape)
{
return(ReshapeAlongCurveUsability.CanReshape);
}
return(resultList.Count == 0
? ReshapeAlongCurveUsability.NoReshapeCurves
: ReshapeAlongCurveUsability.InsufficientOrAmbiguousReshapeCurves);
}
/// <summary>
/// Executes a procedure in an edit operation
/// </summary>
/// <param name="workspace">The workspace in which the operation is executed</param>
/// <param name="procedure">The operation.</param>
/// <param name="state">The state.</param>
/// <param name="description">The description for the edit operation.</param>
/// <param name="trackCancel">The cancel tracker (optional).</param>
/// <returns>
/// <c>true</c> if the operation succeeded, <c>false</c> if it was aborted.
/// </returns>
public bool Execute(IWorkspace workspace, Action <ITrackCancel> procedure,
EditStateInfo state, string description,
ITrackCancel trackCancel)
{
Assert.ArgumentNotNull(workspace, nameof(workspace));
Assert.ArgumentNotNull(procedure, nameof(procedure));
Assert.ArgumentNotNullOrEmpty(description, nameof(description));
if (trackCancel != null)
{
Assert.True(trackCancel.Continue(), "Cancel tracker already cancelled");
}
using (EditWorkspace(workspace))
{
var editWs = (IWorkspaceEdit)workspace;
var editWs2 = workspace as IWorkspaceEdit2; // not implemented for shapefiles
bool isBeingEdited = editWs.IsBeingEdited();
bool isInEditOperation = (editWs2 != null && editWs2.IsInEditOperation);
if ((state & EditStateInfo.MustNotBeEditing) != 0)
{
Assert.False(isBeingEdited, "Edit Session already open");
}
if ((state & EditStateInfo.MustBeEditing) != 0)
{
Assert.True(isBeingEdited, "Edit Session not open");
}
if ((state & EditStateInfo.MustNotBeInOperation) != 0)
{
if (isInEditOperation)
{
AbortEditOperation();
_msg.Warn("Rolled back unexpected existing edit operation");
}
isInEditOperation = false;
}
if ((state & EditStateInfo.MustBeInOperation) != 0)
{
Assert.True(isInEditOperation, "Edit Session not in Operation");
}
_aborted = false;
IWorkspaceEditEvents_Event workspaceEditEvents = null;
try
{
#region check reset current state
if (isInEditOperation)
{
if ((state & EditStateInfo.AbortExistingOperation) != 0)
{
Assert.True(
(state & EditStateInfo.StopExistingOperation) == 0,
"Cannot specify both " +
EditStateInfo.AbortExistingOperation + " and " +
EditStateInfo.StopExistingOperation);
AbortEditOperation();
isInEditOperation = false;
}
else if ((state & EditStateInfo.StopExistingOperation) != 0)
{
StopEditOperation(description);
isInEditOperation = false;
}
}
if (isBeingEdited)
{
if ((state & EditStateInfo.AbortExistingEditing) != 0)
{
Assert.True((state & EditStateInfo.StopExistingEditing) == 0,
"Cannot specify both " +
EditStateInfo.AbortExistingEditing + " and " +
EditStateInfo.StopExistingEditing);
StopEditing(false);
isBeingEdited = false;
}
else if ((state & EditStateInfo.StopExistingEditing) != 0)
{
StopEditing(true);
isBeingEdited = false;
}
}
#endregion
if (!isBeingEdited)
{
StartEditing();
}
if (!isInEditOperation && (state & EditStateInfo.DontStartOperation) == 0)
{
StartEditOperation();
}
// this may fail (COM object that has been separated from its underlying RCW cannot be used)
workspaceEditEvents = (IWorkspaceEditEvents_Event)workspace;
workspaceEditEvents.OnAbortEditOperation += editEvents_OnAbortEditOperation;
procedure(trackCancel);
if (trackCancel != null && !trackCancel.Continue())
{
_msg.WarnFormat("Operation cancelled: {0}", description);
// cancel was called in procedure
if (!_aborted)
{
// The operation is not yet aborted. Abort it now.
AbortEditOperation();
}
}
if (!_aborted &&
(!isInEditOperation &&
(state & EditStateInfo.KeepOperation) == 0) ||
(state & EditStateInfo.StopOperation) != 0)
{
// if the edit operation violates rule engine rules, the edit operation won't succeed. However
// no exception is reported when calling StopEditOperation --> the OnAbort handler is mandatory
// to detect this situation.
StopEditOperation(description);
}
if ((!isBeingEdited &&
(state & EditStateInfo.KeepEditing) == 0) ||
(state & EditStateInfo.StopEditing) != 0)
{
StopEditing(true);
}
return(!_aborted);
}
catch (Exception ex)
{
try // Clean up
{
var comEx = ex as COMException;
string message =
comEx == null
? string.Format("Error executing operation: {0} ({1})",
description, ex.Message)
: string.Format(
"Error executing operation: {0} ({1}; Error Code: {2})",
description, comEx.Message, comEx.ErrorCode);
_msg.Debug(message);
if (!isInEditOperation)
{
// if the error occurred in StopEditOperation(), then
// that edit operation might already be aborted -> check
if (editWs2 != null && editWs2.IsInEditOperation)
{
AbortEditOperation();
}
}
if (!isBeingEdited)
{
StopEditing(false);
}
}
catch (Exception e2)
{
// exception intentionally suppressed.
_msg.Error("Error cleaning up after failed gdb function", e2);
}
throw;
}
finally
{
try
{
if (workspaceEditEvents != null)
{
workspaceEditEvents.OnAbortEditOperation -=
editEvents_OnAbortEditOperation;
}
}
catch (AccessViolationException e)
{
// exception intentionally suppressed.
_msg.Warn("Error unregistering event handler", e);
}
}
}
}
public static void Update(
[CanBeNull] string whereClause,
[NotNull] IList <IObjectClass> targetExceptionClasses,
[NotNull] IList <IObjectClass> updateExceptionClasses,
[NotNull] string updateOriginValue,
DateTime updateDate,
bool requireOriginalVersionExists = true)
{
IIssueTableFields updateFields = GetUpdateFields(updateExceptionClasses);
IIssueTableFields targetFields = GetTargetFields(targetExceptionClasses);
var editableAttributes = new[]
{
IssueAttribute.ExceptionStatus,
IssueAttribute.ExceptionCategory,
IssueAttribute.ExceptionNotes,
IssueAttribute.ExceptionOrigin,
IssueAttribute.ExceptionDefinitionDate,
IssueAttribute.ExceptionLastRevisionDate,
IssueAttribute.ExceptionRetirementDate,
IssueAttribute.IssueAssignment
};
using (_msg.IncrementIndentation(
"Updating exceptions based on exported exception datasets..."))
{
foreach (ITable updateTable in updateExceptionClasses.Cast <ITable>())
{
using (_msg.IncrementIndentation("from {0}...",
DatasetUtils.GetName(updateTable)))
{
ITable targetTable = GetTargetTable(updateTable, targetExceptionClasses);
if (targetTable == null)
{
_msg.Warn(
"No matching table in target workspace, ignoring import table");
continue;
}
var targetExceptionFactory = new ManagedExceptionVersionFactory(
targetTable, targetFields, editableAttributes);
var updateExceptionFactory = new ManagedExceptionVersionFactory(
updateTable, updateFields, editableAttributes);
ExceptionUpdateDetector updateDetector = GetUpdateDetector(
targetTable,
targetExceptionFactory,
editableAttributes);
var replacedOids = new HashSet <int>();
var updatedRowsCount = 0;
var rowsWithConflictsCount = 0;
using (var exceptionWriter = new ExceptionWriter(updateTable, updateFields,
targetTable, targetFields))
{
foreach (IRow updateRow in GdbQueryUtils.GetRows(
updateTable, GetQueryFilter(whereClause), recycle: true))
{
ManagedExceptionVersion updateExceptionVersion =
updateExceptionFactory.CreateExceptionVersion(updateRow);
ManagedExceptionVersion mergedException;
ManagedExceptionVersion replacedExceptionVersion;
IList <ExceptionAttributeConflict> conflicts;
if (updateDetector.HasChange(updateExceptionVersion,
out mergedException,
out replacedExceptionVersion,
out conflicts))
{
if (replacedExceptionVersion == null)
{
string message = string.Format(
"Exception version {0} not found in lineage {1} (target table: {2})",
ExceptionObjectUtils.FormatGuid(
updateExceptionVersion.VersionUuid),
ExceptionObjectUtils.FormatGuid(
updateExceptionVersion.LineageUuid),
DatasetUtils.GetName(targetTable));
if (requireOriginalVersionExists)
{
throw new InvalidDataException(message);
}
_msg.WarnFormat(
"{0}. Creating new version with attributes from update row.",
message);
}
updatedRowsCount++;
string versionImportStatus;
if (conflicts.Count == 0)
{
versionImportStatus = null;
}
else
{
versionImportStatus =
FormatConflicts(conflicts, targetFields);
rowsWithConflictsCount++;
LogConflicts(conflicts, targetFields);
}
exceptionWriter.Write(updateRow, updateDate, mergedException,
FormatOriginValue(updateOriginValue,
replacedExceptionVersion),
updateOriginValue, versionImportStatus);
if (replacedExceptionVersion != null)
{
replacedOids.Add(replacedExceptionVersion.ObjectID);
}
}
}
}
_msg.InfoFormat("{0:N0} exception(s) updated", updatedRowsCount);
if (rowsWithConflictsCount > 0)
{
_msg.WarnFormat("{0:N0} exception(s) with conflicts",
rowsWithConflictsCount);
}
if (replacedOids.Count > 0)
{
int fixedStatusCount;
int updateCount = ProcessReplacedExceptions(targetTable, targetFields,
updateDate, replacedOids,
out fixedStatusCount);
_msg.DebugFormat("{0:N0} replaced exception version(s) updated",
updateCount);
if (fixedStatusCount > 0)
{
_msg.WarnFormat(
"Status value of {0:N0} old exception version(s) fixed",
fixedStatusCount);
}
}
}
}
}
}
