public void Include([NotNull] ManagedExceptionVersion exceptionVersion) { Assert.ArgumentNotNull(exceptionVersion, nameof(exceptionVersion)); Assert.ArgumentCondition(Uuid == exceptionVersion.LineageUuid, "not of this lineage"); _exceptionObjects.Add(exceptionVersion); }
private void WriteValue([NotNull] ManagedExceptionVersion managedExceptionVersion, IssueAttribute attribute, [NotNull] IRowBuffer buffer) { int fieldIndex = GetFieldIndex(attribute); object rawValue = managedExceptionVersion.GetValue(attribute); buffer.Value[fieldIndex] = FormatValue(rawValue); }
public ManagedExceptionVersion Clone() { var result = new ManagedExceptionVersion(ObjectID, LineageUuid, VersionUuid, VersionImportOrigin, ImportOrigin, VersionBeginDate, VersionEndDate); foreach (KeyValuePair <IssueAttribute, object> pair in _editableAttributes) { result._editableAttributes.Add(pair.Key, pair.Value); } return(result); }
public bool HasChange( [NotNull] ManagedExceptionVersion updateExceptionVersion, [NotNull] out ManagedExceptionVersion mergedExceptionVersion, [CanBeNull] out ManagedExceptionVersion replacedExceptionVersion, [NotNull] out IList <ExceptionAttributeConflict> conflicts) { conflicts = new List <ExceptionAttributeConflict>(); ExceptionLineage lineage; if (!_lineages.TryGetValue(updateExceptionVersion.LineageUuid, out lineage)) { // lineage not found -> all properties from update, no replaced rows mergedExceptionVersion = updateExceptionVersion.Clone(); replacedExceptionVersion = null; return(true); } ManagedExceptionVersion current = lineage.Current; if (current == null) { // there is no active exception in the lineage --> all properties from update, no replaced rows mergedExceptionVersion = updateExceptionVersion.Clone(); replacedExceptionVersion = null; return(true); } ManagedExceptionVersion original = lineage.GetVersion(updateExceptionVersion.VersionUuid); if (original == null) { // original exception no longer exists --> all properties from update, no replaced rows mergedExceptionVersion = updateExceptionVersion.Clone(); replacedExceptionVersion = current; return(true); } if (HasChange(updateExceptionVersion, current, original, out mergedExceptionVersion, out conflicts)) { replacedExceptionVersion = current; return(true); } replacedExceptionVersion = null; return(false); }
public void AddExistingException([NotNull] ManagedExceptionVersion exceptionVersion) { Assert.ArgumentNotNull(exceptionVersion, nameof(exceptionVersion)); ExceptionLineage lineage; if (!_lineages.TryGetValue(exceptionVersion.LineageUuid, out lineage)) { lineage = new ExceptionLineage(exceptionVersion.LineageUuid); _lineages.Add(lineage.Uuid, lineage); } lineage.Include(exceptionVersion); }
public ManagedExceptionVersion CreateExceptionVersion([NotNull] IRow row) { var result = new ManagedExceptionVersion( row.OID, Assert.NotNull(GetGuid(row, _managedLineageUuidIndex)).Value, Assert.NotNull(GetGuid(row, _managedVersionUuidIndex)).Value, GetString(row, _managedVersionOriginIndex), GetString(row, _managedOriginIndex), GetDateTime(row, _managedVersionBeginDateIndex), GetDateTime(row, _managedVersionEndDateIndex)); foreach (IssueAttribute attribute in _editableAttributes) { result.SetValue(attribute, GetValue(row, _fieldIndexes[attribute])); } return(result); }
public void Write([NotNull] IRow updateExceptionRow, DateTime updateDate, [NotNull] ManagedExceptionVersion managedExceptionVersion, [NotNull] string originValue, [NotNull] string versionOriginValue, [CanBeNull] string versionImportStatus) { Assert.ArgumentNotNull(updateExceptionRow, nameof(updateExceptionRow)); Assert.ArgumentNotNull(managedExceptionVersion, nameof(managedExceptionVersion)); Assert.ArgumentNotNullOrEmpty(originValue, nameof(originValue)); Assert.ArgumentNotNullOrEmpty(versionOriginValue, nameof(versionOriginValue)); if (_insertCursor == null) { _insertCursor = _targetTable.Insert(true); _rowBuffer = _targetTable.CreateRowBuffer(); _featureBuffer = _rowBuffer as IFeatureBuffer; } IRowBuffer buffer = Assert.NotNull(_rowBuffer); TransferAttributes(updateExceptionRow, buffer); WriteText(buffer, _originFieldIndex, originValue); buffer.Value[_versionBeginDateFieldIndex] = updateDate; buffer.Value[_versionEndDateFieldIndex] = DBNull.Value; // even if 'Inactive' buffer.Value[_versionUuidFieldIndex] = GetNewVersionUuid(); WriteText(buffer, _versionOriginFieldIndex, versionOriginValue); buffer.Value[_lineageUuidFieldIndex] = ExceptionObjectUtils.FormatGuid(managedExceptionVersion.LineageUuid); WriteText(buffer, _versionImportStatusIndex, versionImportStatus); foreach (IssueAttribute attribute in managedExceptionVersion.EditableAttributes) { WriteValue(managedExceptionVersion, attribute, buffer); } if (_featureBuffer != null) { _featureBuffer.Shape = ((IFeature)updateExceptionRow).ShapeCopy; } _insertCursor?.InsertRow(buffer); }
private static string FormatOriginValue( [NotNull] string updateOriginValue, [CanBeNull] ManagedExceptionVersion replacedExceptionVersion) { var origins = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { updateOriginValue }; if (replacedExceptionVersion != null) { foreach (string replacedOrigin in ExceptionObjectUtils.ParseOrigins(replacedExceptionVersion.ImportOrigin)) { origins.Add(replacedOrigin); } } return(ExceptionObjectUtils.FormatOrigins(origins)); }
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); } } } } } }
private bool HasChange([NotNull] ManagedExceptionVersion update, [NotNull] ManagedExceptionVersion current, [NotNull] ManagedExceptionVersion original, [NotNull] out ManagedExceptionVersion merged, [NotNull] out IList <ExceptionAttributeConflict> conflicts) { merged = update.Clone(); var changedAttributes = new List <IssueAttribute>(); conflicts = new List <ExceptionAttributeConflict>(); if (update.Status == ExceptionObjectStatus.Active && current.Status == ExceptionObjectStatus.Active) { // 1: update: active; current: active --> update of active exception // --> update attributes regularly } else if (update.Status == ExceptionObjectStatus.Inactive && current.Status == ExceptionObjectStatus.Active) { // 2: update: inactive; current: active --> "deletion" of active exception // --> update attributes regularly } else if (update.Status == ExceptionObjectStatus.Active && current.Status == ExceptionObjectStatus.Inactive) { // 3: update: active; current: inactive if (original.Status == ExceptionObjectStatus.Active) { // set to inactive by previous import // --> ignore _msg.DebugFormat( "Exception ({0}) was set to inactive by previous update, ignore update (OID: {1})", ExceptionObjectUtils.FormatGuid(current.LineageUuid), update.ObjectID); return(false); } // resurrection return(true); // --> ignore, no change } else if (update.Status == ExceptionObjectStatus.Inactive && current.Status == ExceptionObjectStatus.Inactive) { // 4: update: inactive; current: inactive // --> update attributes regularly _msg.DebugFormat( "Exception ({0}) was set to inactive by previous update, ignore update (OID: {1})", ExceptionObjectUtils.FormatGuid(current.LineageUuid), update.ObjectID); } foreach (IssueAttribute attribute in _editableAttributes) { object newValue = update.GetValue(attribute); object currentValue = current.GetValue(attribute); object originalValue = original.GetValue(attribute); if (Equals(newValue, originalValue) || Equals(newValue, currentValue)) { // the value was not changed in the update, or it is equal to the current value merged.SetValue(attribute, currentValue); } else { // different from current, changed in update changedAttributes.Add(attribute); merged.SetValue(attribute, newValue); if (!Equals(currentValue, originalValue)) { // also changed in current --> conflict conflicts.Add(CreateConflict(attribute, newValue, currentValue, originalValue, update.LineageUuid, original.VersionUuid)); } } } return(changedAttributes.Count > 0); }