/// <summary> /// Saves the form state. /// </summary> /// <remarks> /// All exceptions are ignored to make sure that this miscellaneous function /// does never break the application. /// </remarks> /// <returns>True if form state was successfully stored, false if an error /// occurred</returns> public bool SaveState() { if (Form.WindowState == FormWindowState.Minimized) { // don't save state if minimized return(false); } try { // get the current form state T formState = GetCurrentState(); // write form state FormStatePersistence.WriteToXml(_fileName, formState, typeof(T)); } catch (Exception ex) { _msg.Warn("Error saving form state", ex); // ignore errors return(false); } return(true); }
/// <summary> /// Saves the window settings for the form. /// </summary> /// <remarks> /// All exceptions are ignored to make sure that this miscellaneous function /// does never break the application. /// </remarks> /// <returns>True if settings were successfully stored, false if an error /// occurred</returns> public bool SaveSettings() { if (_form.WindowState == FormWindowState.Minimized) { // don't save state if minimized return(false); } else { try { // get the current settings for the form WindowSettings settings = GetCurrentSettings(); // write settings FormStatePersistence.WriteToXml(_fileName, settings, _settingsType); } catch (Exception ex) { _msg.Warn("Error saving window settings", ex); // ignore errors return(false); } return(true); } }
protected override void CalculateDerivedGeometries(IList <Feature> selectedFeatures, CancelableProgressor progressor) { selectedFeatures = GetApplicableSelectedFeatures(selectedFeatures).ToList(); IList <Feature> overlappingFeatures = GetOverlappingFeatures(selectedFeatures, progressor); if (progressor != null && !progressor.CancellationToken.IsCancellationRequested) { _msg.Warn("Calculation of removable overlaps was cancelled."); return; } _overlaps = CalculateOverlaps(selectedFeatures, overlappingFeatures, progressor); if (progressor != null && progressor.CancellationToken.IsCancellationRequested) { _msg.Warn("Calculation of removable overlaps was cancelled."); return; } // TODO: Options bool insertVerticesInTarget = false; _overlappingFeatures = insertVerticesInTarget ? overlappingFeatures : null; _feedback.Update(_overlaps); }
private static void LogBeginVerification( [NotNull] QualitySpecification qualitySpecification, double tileSize, [CanBeNull] AreaOfInterest areaOfInterest) { using (_msg.IncrementIndentation("Begin quality verification")) { _msg.InfoFormat("Quality specification: {0}", qualitySpecification.Name); _msg.InfoFormat("Verification tile size: {0}", tileSize); if (areaOfInterest != null) { IGeometry testPerimeter = areaOfInterest.Geometry; if (testPerimeter.IsEmpty) { _msg.Warn("Test perimeter is empty"); } else { var envelope = testPerimeter as IEnvelope; string message; if (envelope == null) { Assert.ArgumentCondition(testPerimeter is IPolygon, "Unexpected test perimeter type: {0}; must be polygon or envelope", testPerimeter.GeometryType); envelope = testPerimeter.Envelope; message = string.Format("Polygon extent: {0} x {1}", envelope.Width, envelope.Height); } else { message = string.Format("Extent: {0} x {1}", envelope.Width, envelope.Height); } using (_msg.IncrementIndentation(message)) { _msg.InfoFormat("X-Min: {0}", envelope.XMin); _msg.InfoFormat("Y-Min: {0}", envelope.YMin); _msg.InfoFormat("X-Max: {0}", envelope.XMax); _msg.InfoFormat("Y-Max: {0}", envelope.YMax); } } } } }
public void Cut([NotNull] IPolyline cutPolyline, [CanBeNull] ITrackCancel trackCancel = null) { foreach (IFeature feature in GetFeaturesToCut(cutPolyline)) { if (trackCancel != null && !trackCancel.Continue()) { return; } try { CutFeature(feature, cutPolyline); } catch (Exception e) { if (!ContinueOnFailure) { throw; } _msg.Warn($"Feature {feature.OID}: {e.Message}", e); FailedCutOperations.Add( new KeyValuePair <int, string>(feature.OID, e.Message)); } } AddToRefreshArea(cutPolyline); }
void IVerificationReportBuilder.EndVerification(bool cancelled) { if (cancelled) { _msg.Warn("The verification was cancelled"); } if (_errors.Count == 0) { _msg.Info("No errors found"); } else { _msg.WarnFormat(_errors.Count == 1 ? "{0:N0} error found:" : "{0:N0} errors found:", _errors.Count); if (_rowsWithStopConditions > 0) { _msg.WarnFormat( "Number of rows with stop conditions (not completely tested): {0:N0}", _rowsWithStopConditions); } } ReportErrors(_errors); }
private async Task StartRequest(string peerName, object request) { CurrentLoad?.StartRequest(); _msg.InfoFormat("Starting verification request from {0}", peerName); if (_msg.IsVerboseDebugEnabled) { _msg.VerboseDebugFormat("Request details: {0}", request); } bool licensed = await EnsureLicenseAsync(); if (!licensed) { _msg.Warn("Could not check out the specified license"); } }
public static T Try <T>( [NotNull] Func <CallOptions, T> func, CancellationToken cancellationToken, int deadlineMilliseconds = 30000, bool noWarn = false) { if (cancellationToken.IsCancellationRequested) { _msg.Warn("Operation cancelled"); return(default);
protected void RaiseChanged(CancelEventArgs e) { try { ElementValueChanged(); } catch (Exception ex) { e.Cancel = true; _msg.Warn(ex.Message, ex); } }
protected override async Task <bool> OnSketchModifiedAsync() { _msg.VerboseDebug("OnSketchModifiedAsync"); if (_updateFeedbackTask != null) { // Still working on the previous update (large poylgons!) // -> Consider using latch (but ensure that the overlay must probably be scheduled properly) return(false); } bool nonDefaultSide = _nonDefaultSideMode || PressedKeys.Contains(_keyToggleNonDefaultSide); bool updated = false; try { if (!PressedKeys.Contains(Key.Space)) { // TODO: Exclude finish sketch by double clicking -> should not calculate preview // E.g. wait for SystemInformation.DoubleClickTime for the second click // and only start if it has not ocvurred _updateFeedbackTask = UpdateFeedbackAsync(nonDefaultSide); updated = await _updateFeedbackTask; } } catch (Exception e) { _msg.Warn("Error generating preview", e); return(false); } finally { _updateFeedbackTask = null; } // Does it make any difference what the return value is? return(updated); }
private void RestorePreviousSketch() { if (!SupportRestoreLastSketch) { return; } if (_previousSketch == null || _previousSketch.IsEmpty) { _msg.Warn("There is no previous sketch to restore."); return; } if (!IsInSketchMode) { // If a non-rectangular sketch is set while SketchType is rectangle (or probably generally the wrong type) // sketching is not possible any more and the application appears hanging // Try start sketch mode: IList <Feature> selection = SelectionUtils.GetSelectedFeatures(ActiveMapView).ToList(); if (CanUseSelection(selection)) { AfterSelection(selection, null); } } if (IsInSketchMode) { SetCurrentSketchAsync(_previousSketch); } else { _msg.Warn("Sketch cannot be restored in selection phase. " + "Please try again in the sketch phase."); } }
/// <summary> /// Shows the warning dialog. /// </summary> /// <param name="owner">The owner.</param> /// <param name="message">The message.</param> /// <param name="title">The title.</param> public void ShowWarning(IWin32Window owner, string title, string message) { Assert.ArgumentNotNullOrEmpty(title, nameof(title)); Assert.ArgumentNotNullOrEmpty(message, nameof(message)); _msg.Warn(message); Show(owner, MsgBase.ReplaceBreakTags(message), title, MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1); }
public static void WithTransaction([NotNull] IDbConnection connection, [NotNull] IDbCommand command, [NotNull] Action procedure, IsolationLevel isolationLevel = IsolationLevel.Unspecified) { Assert.ArgumentNotNull(connection, nameof(connection)); Assert.ArgumentNotNull(command, nameof(command)); Assert.ArgumentNotNull(procedure, nameof(procedure)); using (IDbTransaction transaction = BeginTransaction(connection, isolationLevel)) { command.Transaction = transaction; try { procedure(); } catch (Exception) { try { transaction.Rollback(); } catch (Exception e) { _msg.Warn( string.Format("Error rolling back transaction: {0}", e.Message), e); } throw; } transaction.Commit(); } }
protected void RaiseChanged(CancelEventArgs e) { try { ElementValueChanged(); } catch (Exception ex) { e.Cancel = true; _msg.Warn(ex.Message, ex); // TODO -- data does not parse //SetError(Notification.INVALID_FORMAT); } }
private static void Execute([NotNull] string statement, [NotNull] IDbCommand cmd) { Assert.ArgumentNotNullOrEmpty(statement, nameof(statement)); Assert.ArgumentNotNull(cmd, nameof(cmd)); _msg.Info(statement); try { cmd.CommandText = statement; cmd.ExecuteNonQuery(); } catch (Exception e) { _msg.Warn(e.Message); } }
static void Main(string[] args) { try { IServiceHealth health; Grpc.Core.Server server = Run(args, out health); _msg.Info("Type Q(uit) to stop the server."); while (true) { // Avoid mindless spinning Thread.Sleep(100); if (System.Console.KeyAvailable) { if (System.Console.ReadKey(true).Key == ConsoleKey.Q) { _msg.Warn("Shutting down due to user input"); break; } } // TODO: Uncomment after next pull //if (health.IsAnyServiceUnhealthy()) //{ // _msg.Warn("Shutting down due to service state NOT_SERVING"); // break; //} } if (server != null) { GrpcServerUtils.GracefullyStop(server); } } catch (Exception ex) { _msg.Error("An error occurred in microservice.", ex); Environment.ExitCode = -1; } finally { _msg.Debug("License released, shutting down..."); } }
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 bool SelectTargets(List <Feature> selectedFeatures, Geometry sketch, CancelableProgressor progressor) { const TargetFeatureSelection targetFeatureSelection = TargetFeatureSelection.VisibleFeatures; sketch = ToolUtils.SketchToSearchGeometry(sketch, GetSelectionTolerancePixels(), out bool _); Predicate <Feature> canUseAsTargetFeature = t => CanUseAsTargetFeature(selectedFeatures, t); SpatialRelationship spatialRel = SketchType == SketchGeometryType.Polygon ? SpatialRelationship.Contains : SpatialRelationship.Intersects; var foundOidsByLayer = MapUtils.FindFeatures(ActiveMapView, sketch, spatialRel, targetFeatureSelection, CanUseAsTargetLayer, canUseAsTargetFeature, selectedFeatures, progressor); // TODO: Picker if single click and several found if (progressor != null && progressor.CancellationToken.IsCancellationRequested) { _msg.Warn("Calculation of reshape lines was cancelled."); return(false); } IList <Feature> allTargetFeatures = GetDistinctSelectedFeatures(foundOidsByLayer, _changeAlongCurves?.TargetFeatures, KeyboardUtils.IsModifierPressed(Keys.Shift)); _changeAlongCurves = allTargetFeatures.Count > 0 ? CalculateReshapeCurves(selectedFeatures, allTargetFeatures, progressor) : new ChangeAlongCurves(new List <CutSubcurve>(), ReshapeAlongCurveUsability.NoTarget); _feedback.Update(_changeAlongCurves); return(true); }
private void _timer_Elapsed(object sender, ElapsedEventArgs e) { if (_health == null) { return; } if (_health.IsAnyServiceUnhealthy()) { _health = null; _msg.Warn("Shutting down due to unhealthy service..."); GrpcServerUtils.GracefullyStop(_server); // This allows the auto-restart to kick in: Environment.Exit(-1); } }
protected void Notify() { object currentControlValue = GetValueFromControl(); if (_msg.IsVerboseDebugEnabled) { _msg.DebugFormat( "Notify() {0}: _lastValue={1} GetValueFromControl()={2}", Accessor.Name, _lastValue, currentControlValue); } if (Equals(_lastValue, currentControlValue)) { return; } WithinLatch( delegate { _binder.Validate(this); try { _lastValue = GetValueFromModel(); // ORIGINAL >> //if (_lastValue != null) //{ // _binder.OnChange(); //} // << ORIGINAL _binder.OnChange(); } catch (Exception e) { ShowErrorMessages(e.Message); _msg.Warn("Exception in Notify() ignored", e); } }); }
public static bool TryApplySortState([NotNull] DataGridView dataGridView, [CanBeNull] string sortedColumnName, ListSortDirection direction) { Assert.ArgumentNotNull(dataGridView, nameof(dataGridView)); if (string.IsNullOrEmpty(sortedColumnName)) { return(false); } try { if (dataGridView.Columns.Contains(sortedColumnName)) { DataGridViewColumn columnToSort = dataGridView.Columns[sortedColumnName]; Assert.NotNull(columnToSort, nameof(columnToSort)); // NOTE this is very slow (not due to the actual binding to row properties or sorting the binding list, but // apparently due to the datagridview implementation itself (observed for standard data grid views also) dataGridView.Sort(columnToSort, direction); return(true); } _msg.DebugFormat("Sort column not found: {0}", sortedColumnName); } catch (Exception e) { _msg.Warn($"Error applying data grid sort order: {e.Message}", e); } return(false); }
public static IList <IGeometry> TryCut([NotNull] IPolygon inputPolygon, [NotNull] IPolyline cutLine, bool verifyTargetZs = true) { var result = new List <IGeometry>(); try { IGeometryCollection resultCollection; try { resultCollection = ((ITopologicalOperator4)inputPolygon).Cut2(cutLine); } catch (COMException comEx) { const int cannotBePerfomredOnNonSimpleGeometry = -2147220968; if (comEx.ErrorCode == cannotBePerfomredOnNonSimpleGeometry) { _msg.Debug("Cut2 failed. Trying again after simplify...", comEx); GeometryUtils.Simplify(inputPolygon); // and try again resultCollection = ((ITopologicalOperator4)inputPolygon).Cut2(cutLine); } else { throw; } } if (verifyTargetZs) { // TOP-4666: Sometimes NaN or 0 Z values are introduced instead of the Z values from the sketch if (!VerifyZs(inputPolygon, resultCollection, cutLine)) { resultCollection = ((ITopologicalOperator4)inputPolygon).Cut2(cutLine); } // The second time works correctly: if (!VerifyZs(inputPolygon, resultCollection, cutLine)) { _msg.Warn( "Z verification failed. Please review Z values carefully and report in case of wrong Z values."); } } result.AddRange(GeometryUtils.GetParts(resultCollection)); } catch (Exception e) { // TODO: Catch specific exception only // Typically: // A polygon cut operation could not classify all parts of the polygon as left or right of the cutting line. _msg.Debug("Unable to cut polygon", e); return(null); } return(result); }
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 } }
private IList <IGeometry> RemoveOverlap( [NotNull] IPolycurve fromGeometry, [NotNull] IPolycurve overlaps, ChangeAlongZSource zSource, out IList <IGeometry> overlappingResults) { Assert.ArgumentNotNull(fromGeometry, nameof(fromGeometry)); Assert.ArgumentNotNull(overlaps, nameof(overlaps)); overlaps = ChangeAlongZUtils.PrepareCutPolylineZs(overlaps, zSource); Plane3D plane = null; if (zSource == ChangeAlongZSource.SourcePlane) { plane = ChangeAlongZUtils.GetSourcePlane( GeometryConversionUtils.GetPntList(fromGeometry), GeometryUtils.GetZTolerance(fromGeometry)); } IGeometry rawResult = GetDifference(fromGeometry, overlaps); if (plane != null) { ChangeAlongZUtils.AssignZ((IPointCollection)rawResult, plane); } int originalPartCount = GetRelevantPartCount(fromGeometry); int resultPartCount = GetRelevantPartCount(rawResult); // TODO: This works for simple cases. To be correct the difference operation and part comparison would have to be // done on a per-part basis, because in the same operation one part could be added and one removed. // Just comparing part counts before and after is misleading in such cases. if (resultPartCount > originalPartCount) { Result.ResultHasMultiparts = true; } IList <IGeometry> result = new List <IGeometry>(); // TODO explode only those input parts that where cut into more than one result part // --> preserve other input parts in original geometry if (rawResult is IPolycurve && _explodeMultipartResult && IsMultipart(rawResult)) { // Exploding all selected multipart geos // to explode geos only if not avoidable, // use GetPositivePartCount and compare counts before and after cut operation foreach (IGeometry geometry in GeometryUtils.Explode(rawResult)) { var part = (IPolycurve)geometry; result.Add(part); } if (((IGeometryCollection)fromGeometry).GeometryCount > 1) { // TODO: Fix this situation by checking which individual parts were split by the overlap and only turn them into a new feature _msg.Warn( "The selection included multi-part geometry. Storing this geometry generated several copies of the feature."); } } else { result.Add(rawResult); } overlappingResults = _storeOverlapsAsNewFeatures ? CalculateOverlappingGeometries(fromGeometry, overlaps) : null; return(result); }
/// <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 Import( [CanBeNull] string importWhereClause, [NotNull] IList <IObjectClass> targetExceptionClasses, [NotNull] IList <IObjectClass> importExceptionClasses, [NotNull] string importOriginValue, DateTime importDate) { IIssueTableFields importFields = GetImportFields(importExceptionClasses); IIssueTableFields targetFields = GetTargetFields(targetExceptionClasses); IDictionary <Guid, QualityConditionExceptions> targetExceptionsByConditionVersion; using (_msg.IncrementIndentation( "Reading existing exceptions in target workspace")) { targetExceptionsByConditionVersion = ReadTargetExceptions(targetExceptionClasses, targetFields); } var replacedExceptionObjects = new Dictionary <esriGeometryType, HashSet <int> >(); using (_msg.IncrementIndentation("Importing new exceptions from issue datasets...") ) { foreach (ITable importTable in importExceptionClasses.Cast <ITable>()) { using (_msg.IncrementIndentation("from {0}...", DatasetUtils.GetName(importTable))) { ITable targetTable = GetTargetTable(importTable, targetExceptionClasses); if (targetTable == null) { _msg.Warn( "No matching table in target workspace, ignoring import table"); continue; } var factory = new ExceptionObjectFactory( importTable, importFields, defaultStatus: ExceptionObjectStatus.Inactive); var newCount = 0; var updateCount = 0; var ignoredCount = 0; using (var writer = new ExceptionWriter(importTable, importFields, targetTable, targetFields)) { foreach (IRow row in GdbQueryUtils.GetRows(importTable, GetQueryFilter( importWhereClause), recycle: true)) { int matchCount; bool added = ImportException(row, importOriginValue, importDate, factory, targetExceptionsByConditionVersion, replacedExceptionObjects, writer, out matchCount); if (!added) { ignoredCount++; } else if (matchCount == 0) { newCount++; } else { updateCount++; } } } _msg.InfoFormat("{0:N0} exception(s) imported as new", newCount); _msg.InfoFormat("{0:N0} exception(s) imported as updates", updateCount); if (ignoredCount > 0) { _msg.InfoFormat("{0:N0} exception(s) ignored", ignoredCount); } } } } using (_msg.IncrementIndentation("Processing replaced exceptions...")) { foreach (ITable targetTable in targetExceptionClasses.Cast <ITable>()) { using (_msg.IncrementIndentation("Target table {0}...", DatasetUtils.GetName(targetTable))) { int fixedStatusCount; int updateCount = ProcessReplacedExceptions(targetTable, targetFields, replacedExceptionObjects, importDate, out fixedStatusCount); _msg.InfoFormat("{0:N0} replaced exception(s) updated", updateCount); if (fixedStatusCount > 0) { _msg.InfoFormat("Status value of {0:N0} old exception version(s) fixed", fixedStatusCount); } } } } }
public static IList <TestParameter> CreateParameters([NotNull] Type type, int constructorId) { ConstructorInfo constr = type.GetConstructors()[constructorId]; ParameterInfo[] constructorParameters = constr.GetParameters(); PropertyInfo[] properties = type.GetProperties(); var testParameterProperties = new Dictionary <PropertyInfo, TestParameterAttribute>(); foreach (PropertyInfo propertyInfo in properties) { if (!propertyInfo.CanRead || !propertyInfo.CanWrite) { continue; } var testParameterAttribute = ReflectionUtils.GetAttribute <TestParameterAttribute>( propertyInfo); if (testParameterAttribute == null) { continue; } var isValid = true; foreach (ParameterInfo constructorParameter in constructorParameters) { if (string.Equals(constructorParameter.Name, propertyInfo.Name, StringComparison.InvariantCultureIgnoreCase)) { isValid = false; _msg.Warn(GetMessageConstructorParameterExistsAlsoAsProperty( type, constructorId, constructorParameter)); } } if (isValid) { testParameterProperties.Add(propertyInfo, testParameterAttribute); } } var testParameters = new List <TestParameter>(constructorParameters.Length + testParameterProperties.Count); foreach (ParameterInfo parameter in constructorParameters) { var testParameter = new TestParameter( parameter.Name, parameter.ParameterType, TestImplementationUtils.GetDescription(parameter), isConstructorParameter: true); object defaultValue; if (ReflectionUtils.TryGetDefaultValue(parameter, out defaultValue)) { testParameter.DefaultValue = defaultValue; } testParameters.Add(testParameter); } foreach (KeyValuePair <PropertyInfo, TestParameterAttribute> pair in testParameterProperties) { PropertyInfo property = pair.Key; TestParameterAttribute attribute = pair.Value; var testParameter = new TestParameter( property.Name, property.PropertyType, TestImplementationUtils.GetDescription(property), isConstructorParameter: false); testParameter.DefaultValue = attribute.DefaultValue; testParameters.Add(testParameter); } return(new ReadOnlyList <TestParameter>(testParameters)); }
private Polygon GetIntersection([NotNull] Polygon[] perimeters, int index) { Assert.ArgumentNotNull(perimeters, nameof(perimeters)); if (_msg.IsVerboseDebugEnabled) { _msg.DebugFormat("Intersecting perimeters {0} to {1}", index, perimeters.Length - 1); } Polygon intersection = GeometryFactory.Clone(perimeters[index]); // todo daro old implementation //GeometryUtils.EnsureSpatialReference(intersection, SpatialReference, true); // intersect with all following perimeters, if any int nextIndex = index + 1; if (nextIndex < perimeters.Length) { for (int combineIndex = nextIndex; combineIndex < perimeters.Length; combineIndex++) { //Polygon projectedPerimeter = // GetInWorkListSpatialReference(perimeters[combineIndex]); Polygon projectedPerimeter = perimeters[combineIndex]; if (intersection.IsEmpty) { // no further intersection, result is empty return(intersection); } if (projectedPerimeter.IsEmpty) { // no further intersection, result is empty return(projectedPerimeter); } // both are not empty; calculate intersection try { // todo daro: old implementation //var topoOp = (ITopologicalOperator)intersection; //intersection = // (IPolygon)topoOp.Intersect( // projectedPerimeter, // esriGeometryDimension.esriGeometry2Dimension); intersection = (Polygon)GeometryEngine.Instance.Intersection( intersection, projectedPerimeter, GeometryDimension.esriGeometry2Dimension); } catch (Exception e) { try { _msg.ErrorFormat( "Error intersecting perimeters ({0}). See log file for details", e.Message); _msg.DebugFormat("Perimeter index={0}:", combineIndex); // todo daro: old implementation //_msg.Debug(GeometryUtils.ToString(projectedPerimeter)); _msg.DebugFormat( "Input intersection at nextIndex={0}:", nextIndex); // todo daro: old implementation //_msg.Debug(GeometryUtils.ToString(intersection)); // leave intersection as is, and continue } catch (Exception e1) { _msg.Warn("Error writing details to log", e1); } } // todo daro: old implementation //if (_msg.IsVerboseDebugEnabled) //{ // _msg.DebugFormat("Intersection {0}: {1}", // combineIndex, // IntersectionToString(intersection)); //} } } return(intersection); }
private ServiceCallStatus VerifyStandaloneXmlCore( StandaloneVerificationRequest request, IServerStreamWriter <StandaloneVerificationResponse> responseStream, ITrackCancel trackCancel) { // Machine login SetupUserNameProvider(Environment.UserName); try { VerificationParametersMsg parameters = request.Parameters; IGeometry perimeter = ProtobufGeometryUtils.FromShapeMsg(parameters.Perimeter); XmlBasedVerificationService qaService = CreateXmlBasedStandaloneService(request); XmlQualitySpecificationMsg xmlSpecification = request.Specification; var dataSources = new List <DataSource>(); foreach (string replacement in xmlSpecification.DataSourceReplacements) { List <string> replacementStrings = StringUtils.SplitAndTrim(replacement, '>'); Assert.AreEqual(2, replacementStrings.Count, "Data source workspace is not of the format workspace_id > catalog_path"); var dataSource = new DataSource(replacementStrings[0], replacementStrings[0]) { WorkspaceAsText = replacementStrings[1] }; dataSources.Add(dataSource); } var aoi = perimeter == null ? null : new AreaOfInterest(perimeter); try { qaService.ExecuteVerification( xmlSpecification.Xml, xmlSpecification.SelectedSpecificationName, dataSources, aoi, null, parameters.TileSize, parameters.IssueFileGdbPath, IssueRepositoryType.FileGdb, true, trackCancel); } catch (ArgumentException argumentException) { _msg.Warn("Argument exception", argumentException); return(ServiceCallStatus.Failed); } } catch (Exception e) { _msg.DebugFormat("Error during processing of request {0}", request); _msg.Error("Error verifying quality: ", e); if (!EnvironmentUtils.GetBooleanEnvironmentVariableValue( "PROSUITE_QA_SERVER_KEEP_SERVING_ON_ERROR")) { SetUnhealthy(); } return(ServiceCallStatus.Failed); } return(trackCancel.Continue() ? ServiceCallStatus.Finished : ServiceCallStatus.Cancelled); }
public void ReportWarning(string text, Exception exception = null) { _msg.Warn(text, exception); }