/// <summary> /// Deletes all splices for a cable to any other at any splice closure /// </summary> /// <param name="cable">Cable</param> /// <param name="isExistingOperation">Are we already in an edit operation?</param> /// <returns>Success</returns> public bool BreakAllSplices(FiberCableWrapper cable, bool isExistingOperation) { bool success = false; bool isOperationOpen = false; #region Validation if (null == cable) { throw new ArgumentNullException("cable"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion if (!isExistingOperation) { _editor.StartOperation(); isOperationOpen = true; } try { ESRI.ArcGIS.Geodatabase.ITable spliceTable = _wkspHelper.FindTable(ConfigUtil.FiberSpliceTableName); // ESRI.ArcGIS.Geodatabase.ITable spliceTable = GdbUtils.GetTable(cable.Feature.Class, ConfigUtil.FiberSpliceTableName); ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); // A and B is arbitrary, so we check the given combinations going both ways. The structure is: // Where either the A or B cableID is our cable ID filter.WhereClause = string.Format("{0}='{1}' OR {2}='{1}'", ConfigUtil.ACableIdFieldName, cable.IPID, ConfigUtil.BCableIdFieldName); spliceTable.DeleteSearchedRows(filter); ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(filter); if (isOperationOpen) { _editor.StopOperation("Break Splices"); isOperationOpen = false; } success = true; } catch { if (isOperationOpen) { _editor.AbortOperation(); } success = false; } return success; }
/// <summary> /// Determines if all given ranges are available (neither spliced nor connected) /// </summary> /// <param name="units">Units to check</param> /// <param name="cableWrapper">Cable to check</param> /// <param name="isFromEnd">Flag of which end we are checking</param> /// <returns>True if they are all available</returns> public static bool AreRangesAvailable(ICollection<int> units, FiberCableWrapper cableWrapper, bool isFromEnd) { bool result = true; List<int> splicedStrands = GetSplicedStrands(cableWrapper, isFromEnd); List<int> connectedStrands = GetConnectedStrands(cableWrapper, isFromEnd); foreach (int unit in units) { if (splicedStrands.Contains(unit) || connectedStrands.Contains(unit)) { result = false; break; } } return result; }
/// <summary> /// Returns a list of connections between the cable and the device, at the cable's given end, to the device's given port type /// </summary> /// <param name="cable">Cable to check</param> /// <param name="device">Device to check</param> /// <param name="isFromEnd">Digitized end of cable</param> /// <param name="portType">Input or output</param> /// <returns>List of Connection</returns> public List<Connection> GetConnections(FiberCableWrapper cable, DeviceWrapper device, bool isFromEnd, PortType portType) { if (null == cable) { throw new ArgumentNullException("cable"); } if (null == device) { throw new ArgumentNullException("device"); } List<Connection> result = new List<Connection>(); List<int> ports = new List<int>(); List<int> strands = new List<int>(); using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = device.Feature.Class as ESRI.ArcGIS.Geodatabase.IFeatureClass; ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetPortRelationship(deviceFtClass); if (null == deviceHasPorts) { throw new Exception("Unable to find port relationship class."); } ESRI.ArcGIS.Geodatabase.ITable portTable = deviceHasPorts.DestinationClass as ESRI.ArcGIS.Geodatabase.ITable; if (null == portTable) { throw new Exception("Invalid destination on port relationship class."); } ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); filter.WhereClause = string.Format("{0}='{1}' AND {2}='{3}' AND {4}='{5}' AND {6}='{7}' AND {8} IS NOT NULL AND {9} IS NOT NULL", deviceHasPorts.OriginForeignKey, device.Feature.get_Value(deviceFtClass.FindField(deviceHasPorts.OriginPrimaryKey)), ConfigUtil.ConnectedCableFieldName, cable.IPID, ConfigUtil.PortTypeFieldName, (PortType.Input == portType ? "1" : "2"), ConfigUtil.ConnectedEndFieldName, (isFromEnd ? "T" : "F"), ConfigUtil.ConnectedFiberFieldName, ConfigUtil.PortIdFieldName); // ORDER BY does not work outside of SDE. // Removing for now, should not be important. string orderFormat = "ORDER BY {0}"; if (PortType.Input == portType) { // ((ESRI.ArcGIS.Geodatabase.IQueryFilterDefinition2)filter).PostfixClause = string.Format(orderFormat, ConfigUtil.ConnectedFiberFieldName); } else { // ((ESRI.ArcGIS.Geodatabase.IQueryFilterDefinition2)filter).PostfixClause = string.Format(orderFormat, ConfigUtil.PortIdFieldName); } ESRI.ArcGIS.Geodatabase.ICursor portCursor = portTable.Search(filter, true); ESRI.ArcGIS.Geodatabase.IRow portRow = portCursor.NextRow(); int portIdIdx = portTable.FindField(ConfigUtil.PortIdFieldName); int fiberNumberIdx = portTable.FindField(ConfigUtil.ConnectedFiberFieldName); while (null != portRow) { ports.Add((int)portRow.get_Value(portIdIdx)); strands.Add((int)portRow.get_Value(fiberNumberIdx)); ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(portRow); portRow = portCursor.NextRow(); } ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(portCursor); } List<Range> portRanges = SpliceAndConnectionUtils.MergeRanges(ports); List<Range> strandRanges = SpliceAndConnectionUtils.MergeRanges(strands); if (PortType.Input == portType) { result = SpliceAndConnectionUtils.MatchUp(strandRanges, portRanges); } else { result = SpliceAndConnectionUtils.MatchUp(portRanges, strandRanges); } return result; }
/// <summary> /// Returns devices at the endpoints of the given cable /// </summary> /// <param name="deviceWrapper">Cable to check</param> /// <returns>List of ConnectableDeviceWrapper</returns> public List<ConnectableDeviceWrapper> GetCoincidentDevices(FiberCableWrapper fiberCableWrapper) { List<ConnectableDeviceWrapper> result = new List<ConnectableDeviceWrapper>(); if (null == fiberCableWrapper) { throw new ArgumentNullException("fiberCableWrapper"); } ESRI.ArcGIS.Geometry.IPolyline cableGeometry = (ESRI.ArcGIS.Geometry.IPolyline)fiberCableWrapper.Feature.Shape; string[] deviceFtClassNames = ConfigUtil.DeviceFeatureClassNames; double buffer = _hookHelper.ConvertPixelsToMapUnits(1); for (int i = 0; i < deviceFtClassNames.Length; i++) { string ftClassName = deviceFtClassNames[i]; ESRI.ArcGIS.Carto.IFeatureLayer ftLayer = _hookHelper.FindFeatureLayer(ftClassName); if (ftLayer == null) { // Layer might not be in the map so just skip if not found. continue; } ESRI.ArcGIS.Geodatabase.IFeatureClass ftClass = ftLayer.FeatureClass; int displayIdx = ftClass.FindField(ftLayer.DisplayField); List<ESRI.ArcGIS.Geodatabase.IFeature> fromFts = GdbUtils.GetFeaturesWithCoincidentVertices(cableGeometry.FromPoint, ftClass, false, buffer); for (int fromIdx = 0; fromIdx < fromFts.Count; fromIdx++) { result.Add(new ConnectableDeviceWrapper(fromFts[fromIdx], true, displayIdx)); } List<ESRI.ArcGIS.Geodatabase.IFeature> toFts = GdbUtils.GetFeaturesWithCoincidentVertices(cableGeometry.ToPoint, ftClass, false, buffer); for (int toIdx = 0; toIdx < toFts.Count; toIdx++) { result.Add(new ConnectableDeviceWrapper(toFts[toIdx], false, displayIdx)); } } return result; }
/// <summary> /// Prompts the user about saving pending edits /// </summary> /// <param name="spliceWrapper"></param> /// <param name="cableAWrapper"></param> /// <param name="cableBWrapper"></param> /// <returns>False if the user chooses to cancel what they were doing; True if they choose Yes or No /// (which means they are OK with what they are doing)</returns> private bool IsUserSure(SpliceClosureWrapper spliceWrapper, FiberCableWrapper cableAWrapper, SpliceableCableWrapper cableBWrapper) { bool result = true; // Assume they do not want to save and do want to continue DialogResult dialogResult = DialogResult.No; dialogResult = MessageBox.Show("You have unsaved edits. Would you like to save them before closing?", "Connection Editor", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question); if (DialogResult.Cancel == dialogResult) { // The user isn't sure about what they are doing and wants to cancel it result = false; } else if (DialogResult.Yes == dialogResult) { bool isSaveOk = SaveChanges(spliceWrapper, cableAWrapper, cableBWrapper); if (!isSaveOk) { // They wanted to save but it didn't work. They probably got a message telling them what to fix. Cancel // whatever they were doing so that they have a chance to do so result = false; } } return result; }
/// <summary> /// Determines if a cable has any connections or splices on its strands /// </summary> /// <param name="cableWrapper">Cable to check</param> /// <returns>True if any strand is connected or spliced</returns> public static bool HasAnyConnections(FiberCableWrapper cableWrapper) { int? fiberCount = cableWrapper.fibers; List<Range> ranges = null; bool isFromClear = true; bool isToClear = true; if (null != fiberCount && 0 < fiberCount) { ranges = GetAvailableRanges(cableWrapper, true); isFromClear = AreRangesWholeUnitCount(ranges, (int)fiberCount); ranges = GetAvailableRanges(cableWrapper, false); isToClear = AreRangesWholeUnitCount(ranges, (int)fiberCount); } // If either end is not clear, there are connections return (!isFromClear || !isToClear); }
/// <summary> /// Finds ranges of fibers that are not yet spliced or connected /// </summary> /// <param name="cable">Cable to check</param> /// <param name="isFromEnd">Flag of which side of the cable to check</param> /// <returns>List of Range</returns> public static List<Range> GetAvailableRanges(FiberCableWrapper cable, bool isFromEnd) { List<Range> result = new List<Range>(); if (null == cable) { throw new ArgumentNullException("cable"); } List<int> usedStrands = new List<int>(); usedStrands.AddRange(GetSplicedStrands(cable, isFromEnd)); // Gets the ones that are spliced to another cable usedStrands.AddRange(GetConnectedStrands(cable, isFromEnd)); // Gets the ones that are connected to a device usedStrands.Sort(); List<Range> splicedRanges = MergeRanges(usedStrands); // int? fiberCount = GdbUtils.GetDomainedIntName(cable.Feature, ConfigUtil.NumberOfFibersFieldName); int? fiberCount = cable.fibers; if (null != fiberCount) { int lowFiber = 1; for (int i = 0; i < splicedRanges.Count; i++) { Range range = splicedRanges[i]; if (lowFiber != range.Low) { // We are good until this range starts result.Add(new Range(lowFiber, range.Low - 1)); } lowFiber = range.High + 1; } if (lowFiber <= fiberCount) { result.Add(new Range(lowFiber, (int)fiberCount)); } } return result; }
/// <summary> /// Cable features can have related: /// splices, /// connections, /// strands /// buffer tubes, /// maintenance loop /// </summary> /// <param name="cableFeature">Deleted IFeature</param> private void CascadeFiberCableDelete(ESRI.ArcGIS.Geodatabase.IFeature cableFeature) { FiberCableWrapper cable = new FiberCableWrapper(cableFeature); // Delete splices (to other cables) _spliceHelper.BreakAllSplices(cable, true); // Delete connections (to equipment) _connectionHelper.BreakAllConnections(cable, true); }
/// <summary> /// Deletes given splices from one cable to the other, at a given splice closure /// </summary> /// <param name="cableA">Cable A</param> /// <param name="cableB">Cable B</param> /// <param name="splice">Splice Closure</param> /// <param name="strands">Strands to remove</param> /// <param name="isExistingOperation">Flag to control whether we need to wrap this in an edit operation</param> /// <returns>Success</returns> public bool BreakSplices(FiberCableWrapper cableA, SpliceableCableWrapper cableB, SpliceClosureWrapper splice, Dictionary<int,FiberSplice> strands, bool isExistingOperation) { bool success = false; bool isOperationOpen = false; #region Validation if (null == cableA) { throw new ArgumentNullException("cableA"); } if (null == cableB) { throw new ArgumentNullException("cableB"); } if (null == splice) { throw new ArgumentNullException("splice"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion if (!isExistingOperation) { _editor.StartOperation(); isOperationOpen = true; } try { ESRI.ArcGIS.Geodatabase.ITable spliceTable = _wkspHelper.FindTable(ConfigUtil.FiberSpliceTableName); // ESRI.ArcGIS.Geodatabase.ITable spliceTable = GdbUtils.GetTable(splice.Feature.Class, ConfigUtil.FiberSpliceTableName); using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); // A and B is arbitrary, so we check the given combinations going both ways. The structure is: // Where the splice closure IPID is ours and // ((the A Cable/Fiber matches our A cable and B Cable/Fiber matches our B) // OR (the A Cable/Fiber matches our B cable and B Cable/Fiber matches our A)) string format = "{0}='{1}' AND (({2}='{3}' AND {4}={5} AND {6}='{7}' AND {8}={9})" + " OR ({2}='{7}' AND {4}={9} AND {6}='{3}' AND {8}={5}))"; foreach (KeyValuePair<int, FiberSplice> pair in strands) { filter.WhereClause = string.Format(format, ConfigUtil.SpliceClosureIpidFieldName, splice.IPID, ConfigUtil.ACableIdFieldName, cableA.IPID, ConfigUtil.AFiberNumberFieldName, pair.Key, ConfigUtil.BCableIdFieldName, cableB.IPID, ConfigUtil.BFiberNumberFieldName, pair.Value.BRange.Low); spliceTable.DeleteSearchedRows(filter); } if (isOperationOpen) { _editor.StopOperation("Break Splices"); isOperationOpen = false; } success = true; } } catch { if (isOperationOpen) { _editor.AbortOperation(); } success = false; } return success; }
private FiberCableWrapper GetConnectedFiber(DeviceWrapper device, int portId, PortType portType, out int fiberNumber) { FiberCableWrapper result = null; fiberNumber = -1; ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = (ESRI.ArcGIS.Geodatabase.IFeatureClass)device.Feature.Class; ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetPortRelationship(deviceFtClass); if (null == deviceHasPorts) { throw new Exception("Device to port relationship is missing or cannot be opened."); } ESRI.ArcGIS.Geodatabase.ITable portTable = deviceHasPorts.DestinationClass as ESRI.ArcGIS.Geodatabase.ITable; if (null == portTable) { throw new Exception("Port table is missing or cannot be opened."); } using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); filter.WhereClause = string.Format("{0}='{1}' AND {2}={3} AND {4}='{5}'", deviceHasPorts.OriginForeignKey, device.Feature.get_Value(deviceFtClass.FindField(deviceHasPorts.OriginPrimaryKey)), ConfigUtil.PortIdFieldName, portId, ConfigUtil.PortTypeFieldName, PortType.Input == portType ? 1 : 2); ESRI.ArcGIS.Geodatabase.ICursor cursor = portTable.Search(filter, false); releaser.ManageLifetime(cursor); ESRI.ArcGIS.Geodatabase.IRow portRow = cursor.NextRow(); if (null != portRow) { //releaser.ManageLifetime(portRow); object cableIdValue = portRow.get_Value(portTable.FindField(ConfigUtil.ConnectedCableFieldName)); if (DBNull.Value != cableIdValue) { ESRI.ArcGIS.Geodatabase.IFeatureClass cableFtClass = _wkspHelper.FindFeatureClass(ConfigUtil.FiberCableFtClassName); filter.WhereClause = string.Format("{0}='{1}'", ConfigUtil.IpidFieldName, cableIdValue); ESRI.ArcGIS.Geodatabase.IFeatureCursor cableCursor = cableFtClass.Search(filter, false); releaser.ManageLifetime(cableCursor); ESRI.ArcGIS.Geodatabase.IFeature cable = cableCursor.NextFeature(); if (null != cable) { result = new FiberCableWrapper(cable); object fiberNumberValue = portRow.get_Value(portTable.FindField(ConfigUtil.ConnectedFiberFieldName)); if (DBNull.Value != fiberNumberValue) { int.TryParse(fiberNumberValue.ToString(), out fiberNumber); } } } } } return result; }
/// <summary> /// Update the dropdowns of features on the UI /// </summary> /// <param name="helper">Helper class</param> private void PopulateDropDowns(FiberDeviceConnectionHelper helper) { // Clear the existing choices cboFrom.Items.Clear(); cboTo.Items.Clear(); lblAvailableFrom.Text = ""; lblAvailableTo.Text = ""; // Get the features and the display index for use when creating the wrapper ESRI.ArcGIS.Carto.IFeatureLayer ftLayer = _hookHelper.FindFeatureLayer(ConfigUtil.FiberCableFtClassName); int displayIdx = ftLayer.FeatureClass.FindField(ftLayer.DisplayField); // Get the selected features List<ESRI.ArcGIS.Geodatabase.IFeature> selectedFts = _hookHelper.GetSelectedFeatures(ftLayer); // Add each of the fiber features to the drop down for (int ftIdx = 0; ftIdx < selectedFts.Count; ftIdx++) { FiberCableWrapper w = new FiberCableWrapper(selectedFts[ftIdx], displayIdx); cboFrom.Items.Add(w); } // Now do that same thing for each of the device feature classes string[] deviceClassNames = ConfigUtil.DeviceFeatureClassNames; for (int deviceClassIdx = 0; deviceClassIdx < deviceClassNames.Length; deviceClassIdx++) { string ftClassName = deviceClassNames[deviceClassIdx]; // Get the features and the display index for use when creating the wrapper ftLayer = _hookHelper.FindFeatureLayer(ftClassName); if (ftLayer != null) // what if layer removed from map { selectedFts = _hookHelper.GetSelectedFeatures(ftLayer); displayIdx = ftLayer.FeatureClass.FindField(ftLayer.DisplayField); for (int ftIdx = 0; ftIdx < selectedFts.Count; ftIdx++) { DeviceWrapper w = new DeviceWrapper(selectedFts[ftIdx], displayIdx); cboFrom.Items.Add(w); } } } // Preselect the first choice if (0 < cboFrom.Items.Count) { cboFrom.SelectedItem = cboFrom.Items[0]; } }
/// <summary> /// Check changes to the grid and save them to the database /// </summary> /// <param name="splice">The associated splice closure</param> /// <param name="cableA">A cable</param> /// <param name="cableB">The other cable</param> /// <returns>Success</returns> private bool SaveChanges(SpliceClosureWrapper splice, FiberCableWrapper cableA, SpliceableCableWrapper cableB) { bool result = false; string isNotOkString = string.Empty; Dictionary<int, FiberSplice> currentGrid = new Dictionary<int, FiberSplice>(); List<int> currentBStrands = new List<int>(); try { int aIdx = colRangeA.Index; int bIdx = colRangeB.Index; int lossIdx = colLoss.Index; int typeIdx = grdSplices.Columns[colType.Name].Index; // If we had to use colTypeText, it will be using the same name // Less than count-1 lets us avoid the insert row for (int i = 0; i < grdSplices.Rows.Count - 1; i++) { if (grdSplices[aIdx, i].Value == null || grdSplices[bIdx, i].Value == null) { isNotOkString = "A or B unit range missing."; } if (0 < isNotOkString.Length) { // No need to check the rest if this one was not OK break; } List<Range> aRanges = SpliceAndConnectionUtils.ParseRanges(grdSplices[aIdx, i].Value.ToString()); List<Range> bRanges = SpliceAndConnectionUtils.ParseRanges(grdSplices[bIdx, i].Value.ToString()); if (!SpliceAndConnectionUtils.AreCountsEqual(aRanges, bRanges)) { isNotOkString = "Number of units from A to B must match on each row."; } else if (!SpliceAndConnectionUtils.AreRangesWithinFiberCount(aRanges, cableA)) { isNotOkString = "Selected units exceed fiber count for cable A."; } else if (!SpliceAndConnectionUtils.AreRangesWithinFiberCount(bRanges, cableB)) { isNotOkString = "Selected units exceed fiber count for cable B."; } if (0 < isNotOkString.Length) { // No need to check the rest if this one was not OK break; } List<Connection> matchedUp = SpliceAndConnectionUtils.MatchUp(aRanges, bRanges); foreach (Connection range in matchedUp) { Range a = range.ARange; Range b = range.BRange; int numUnits = a.High - a.Low + 1; for (int offset = 0; offset < numUnits; offset++) { int aUnit = a.Low + offset; int bUnit = b.Low + offset; if (currentGrid.ContainsKey(aUnit)) { isNotOkString = string.Format("Duplicate splicing found for A Strand {0}", aUnit); // No need to check the rest if this one was not OK break; } else if (currentBStrands.Contains(bUnit)) { isNotOkString = string.Format("Duplicate splicing found for B Strand {0}", bUnit); // No need to check the rest if this one was not OK break; } else { object lossObj = grdSplices[lossIdx, i].Value; object typeObj = grdSplices[typeIdx, i].Value; double? loss = null; if (null != lossObj) { double dblLoss = -1; if (double.TryParse(lossObj.ToString(), out dblLoss)) { loss = dblLoss; } else { MessageBox.Show("Loss value on row {0} could not be parsed. Using null.", "Splice Editor", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } FiberSplice fiberSplice = new FiberSplice(new Range(aUnit, aUnit), new Range(bUnit, bUnit), loss, typeObj); currentGrid[aUnit] = fiberSplice; currentBStrands.Add(bUnit); } } } } } catch (Exception ex) { isNotOkString = ex.Message; } // Check the ranges are within the feature's units List<int> checkToUnits = new List<int>(); List<int> checkFromUnits = new List<int>(); // Anything that is in the current grid, we will see if it is available. But if it was deleted, we can ignore // checking its availabilty, because we are about to free it up. Also if it was original, we can ignore it, // since we are reprocessing it. Duplicates ON the grid have already been checked for. // NOTE: We can simplify this to just check original, since any deleted ones were in the original. foreach (FiberSplice checkSplice in currentGrid.Values) { int unit = checkSplice.BRange.Low; checkToUnits.Add(unit); } foreach (FiberSplice checkSplice in _original.Values) { int unit = checkSplice.BRange.Low; if (checkToUnits.Contains(unit)) { checkToUnits.Remove(unit); } } foreach (int fromUnit in currentGrid.Keys) { if (!_original.ContainsKey(fromUnit)) { checkFromUnits.Add(fromUnit); } } if (!SpliceAndConnectionUtils.AreRangesAvailable(checkFromUnits, cableA, cableB.IsOtherFromEnd)) { isNotOkString = "Some A units are not in the available ranges for the A Cable."; } else if (!SpliceAndConnectionUtils.AreRangesAvailable(checkToUnits, cableB, cableB.IsThisFromEnd)) { isNotOkString = "Some B units are not in the available ranges for the B Cable."; } if (0 < isNotOkString.Length) { string message = string.Format("{0}\nPlease correct this and try again.", isNotOkString); MessageBox.Show(message, "Splice Editor", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { if (null != cableA && null != cableB) { // For the deleted ones, if they were added back, don't delete them... List<int> keys = new List<int>(); keys.AddRange(_deleted.Keys); foreach (int key in keys) { if (currentGrid.ContainsKey(key)) { FiberSplice fiberSplice = currentGrid[key]; if (fiberSplice.BRange.Low == _deleted[key].BRange.Low && fiberSplice.Loss == _deleted[key].Loss && fiberSplice.Type == _deleted[key].Type) { // It is added back, so don't delete it _deleted.Remove(key); } } } if (0 < _deleted.Count) { _spliceHelper.BreakSplices(cableA, cableB, splice, _deleted, false); } // For the added ones, if they already exist or are not available, don't add them // Since we already know they are in the fiber count range, the only problem would be if they were already // spliced. This would be the case if (1) it was part of the original or (2) has already appeared higher // on the currentGrid. (2) is handled when building currentGrid, by checking if the aUnit or bUnit was already used. keys.Clear(); keys.AddRange(currentGrid.Keys); foreach (int key in keys) { if (_original.ContainsKey(key)) { FiberSplice fiberSplice = currentGrid[key]; if (fiberSplice.BRange.Low == _original[key].BRange.Low && fiberSplice.Loss == _original[key].Loss && fiberSplice.Type == _original[key].Type) { // It was on the original, so we don't need to create it currentGrid.Remove(key); } } } if (0 < currentGrid.Count) { _spliceHelper.CreateSplices(cableA, cableB, splice, currentGrid, false); } // These are no longer part of the originals foreach (KeyValuePair<int, FiberSplice> deletedPair in _deleted) { _original.Remove(deletedPair.Key); } // These are now part of the originals foreach (KeyValuePair<int, FiberSplice> addedPair in currentGrid) { _original[addedPair.Key] = addedPair.Value; } _deleted.Clear(); // The grid is fresh // Set the existing rows as committed data. Less than count-1 lets us avoid the insert row for (int i = 0; i < grdSplices.Rows.Count - 1; i++) { grdSplices.Rows[i].ReadOnly = true; } btnSave.Enabled = false; btnSave.Tag = false; // No edits made yet result = true; } } return result; }
/// <summary> /// Load the B dropdown with spliceable cables /// </summary> /// <param name="helper">SpliceEditorHelper</param> /// <param name="cableA">A Cable</param> private void PopulateBCables(FiberSpliceHelper helper, FiberCableWrapper cableA) { try { // Clear anything that is dependent on what we are about to load ClearGrid(); cboCableB.Items.Clear(); lblAvailableA.Text = ""; lblAvailableB.Text = ""; SpliceClosureWrapper splice = cboSpliceClosure.SelectedItem as SpliceClosureWrapper; if (null != splice) { List<SpliceableCableWrapper> spliceableCables = _spliceHelper.GetSpliceableCables(cableA, splice); for (int i = 0; i < spliceableCables.Count; i++) { cboCableB.Items.Add(spliceableCables[i]); } if (0 < cboCableB.Items.Count) { cboCableB.SelectedItem = cboCableB.Items[0]; } } } catch (Exception e) { _logHelper.addLogEntry(DateTime.Now.ToString(), "ERROR", "Splice Connection Window (PopulateBCables): ", e.Message); } }
/// <summary> /// Load the A dropdown with selected cables /// </summary> /// <param name="helper">SpliceEditorHelper</param> private void PopulateACables(FiberSpliceHelper helper, SpliceClosureWrapper spliceWrapper) { try { // Clear anything that is dependent on what we are about to load ClearGrid(); cboCableA.Items.Clear(); cboCableB.Items.Clear(); lblAvailableA.Text = ""; lblAvailableB.Text = ""; List<ESRI.ArcGIS.Geodatabase.IFeature> selectedCables = helper.GetConnectedCables(spliceWrapper); ESRI.ArcGIS.Carto.IFeatureLayer ftLayer = _hookHelper.FindFeatureLayer(ConfigUtil.FiberCableFtClassName); int displayIdx = ftLayer.FeatureClass.FindField(ftLayer.DisplayField); for (int i = 0; i < selectedCables.Count; i++) { FiberCableWrapper w = new FiberCableWrapper(selectedCables[i], displayIdx); cboCableA.Items.Add(w); } if (0 < cboCableA.Items.Count) { cboCableA.SelectedItem = cboCableA.Items[0]; } } catch (Exception e) { _logHelper.addLogEntry(DateTime.Now.ToString(), "ERROR", "Splice Connection Window (PopulateACables): ", e.Message); } }
/// <summary> /// Loads the grid with existing splice ranges between the given features /// </summary> /// <param name="spliceWrapper">Selected Splice Closure</param> /// <param name="cableA">Selected Cable A</param> /// <param name="cableB">Selected Cable B</param> private void LoadExistingRecords(SpliceClosureWrapper spliceWrapper, FiberCableWrapper cableA, SpliceableCableWrapper cableB) { ClearGrid(); if (null != spliceWrapper && null != cableA && null != cableB) { List<FiberSplice> rangesAtoB = SpliceAndConnectionUtils.GetSplicedRanges(cableA, cableB, spliceWrapper); for (int i = 0; i < rangesAtoB.Count; i++) { FiberSplice fiberSplice = rangesAtoB[i]; int rowIdx = grdSplices.Rows.Add(fiberSplice.ARange, fiberSplice.BRange, fiberSplice.Loss, fiberSplice.Type); grdSplices.Rows[rowIdx].ReadOnly = true; // Allow this to be deleted, but not edited. Range a = fiberSplice.ARange; Range b = fiberSplice.BRange; int numUnits = a.High - a.Low + 1; for (int offset = 0; offset < numUnits; offset++) { int aUnit = a.Low + offset; int bUnit = b.Low + offset; FiberSplice originalSplice = new FiberSplice(new Range(aUnit, aUnit), new Range(bUnit, bUnit), fiberSplice.Loss, fiberSplice.Type); _original[aUnit] = originalSplice; } } // These are valid for display because it is these two cables at this splice, the A and B side assignment is // arbitrary. We do need to reverse them in the display though. For example is Cable X (1-12) is spliced to // Cable Y (36-47), and they have selected X/Y in the form -- the grid should show X's units on the left and // Y's on the right. Here we are requesting them as Y/X though. List<FiberSplice> rangesBtoA = SpliceAndConnectionUtils.GetSplicedRanges((FiberCableWrapper)cboCableB.SelectedItem, (FiberCableWrapper)cboCableA.SelectedItem, spliceWrapper); for (int i = 0; i < rangesBtoA.Count; i++) { FiberSplice fiberSplice = rangesBtoA[i]; int rowIdx = grdSplices.Rows.Add(fiberSplice.BRange, fiberSplice.ARange, fiberSplice.Loss, fiberSplice.Type); grdSplices.Rows[rowIdx].ReadOnly = true; // Allow this to be deleted, but not edited. Range a = fiberSplice.ARange; Range b = fiberSplice.BRange; int numUnits = a.High - a.Low + 1; for (int offset = 0; offset < numUnits; offset++) { int aUnit = a.Low + offset; int bUnit = b.Low + offset; FiberSplice originalSplice = new FiberSplice(new Range(bUnit, bUnit), new Range(aUnit, aUnit), fiberSplice.Loss, fiberSplice.Type); _original[bUnit] = originalSplice; } } } btnSave.Enabled = false; btnSave.Tag = false; // No edits made yet }
/// <summary> /// Creates given connections between cable and device /// </summary> /// <param name="cable">Cable</param> /// <param name="device">Device</param> /// <param name="units">Units to connect</param> /// <param name="isFromEnd">Is it the cable's from end?</param> /// <param name="portType">Input or Output?</param> /// <param name="isExistingOperation">Flag to control whether we need to wrap this in a new edit operation</param> /// <returns>Success</returns> public bool MakeConnections(FiberCableWrapper cable, DeviceWrapper device, Dictionary<int, int> units, bool isFromEnd, PortType portType, bool isExistingOperation) { bool success = false; bool isOperationOpen = false; #region Validation if (null == cable) { throw new ArgumentNullException("cable"); } if (null == device) { throw new ArgumentNullException("device"); } if (null == units) { throw new ArgumentNullException("units"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion if (!isExistingOperation) { _editor.StartOperation(); isOperationOpen = true; } try { ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = device.Feature.Class as ESRI.ArcGIS.Geodatabase.IFeatureClass; ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetPortRelationship(deviceFtClass); if (null == deviceHasPorts) { throw new Exception("Unable to get port relationship class."); } ESRI.ArcGIS.Geodatabase.ITable portTable = deviceHasPorts.DestinationClass as ESRI.ArcGIS.Geodatabase.ITable; if (null == portTable) { throw new Exception("Invalid destination on port relationship class."); } int portIdIdx = portTable.FindField(ConfigUtil.PortIdFieldName); int fiberNumberIdx = portTable.FindField(ConfigUtil.ConnectedFiberFieldName); int cableIdIdx = portTable.FindField(ConfigUtil.ConnectedCableFieldName); int isFromEndIdx = portTable.FindField(ConfigUtil.ConnectedEndFieldName); string isFromEndValue = isFromEnd ? "T" : "F"; Dictionary<int, int> portsAsKeys = units; if (PortType.Input == portType) { portsAsKeys = new Dictionary<int, int>(); foreach (KeyValuePair<int, int> pair in units) { portsAsKeys[pair.Value] = pair.Key; } } using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); string format = "{0}='{1}' AND {2}='{3}'"; filter.WhereClause = string.Format(format, deviceHasPorts.OriginForeignKey, device.Feature.get_Value(deviceFtClass.FindField(deviceHasPorts.OriginPrimaryKey)), ConfigUtil.PortTypeFieldName, (PortType.Input == portType ? "1" : "2")); // Non recylcing cursor since we are doing updates. ESRI.ArcGIS.Geodatabase.ICursor portCursor = portTable.Update(filter, false); releaser.ManageLifetime(portCursor); ESRI.ArcGIS.Geodatabase.IRow portRow = portCursor.NextRow(); while (null != portRow) { object portIdObj = portRow.get_Value(portIdIdx); if (DBNull.Value != portIdObj) { int portId = System.Convert.ToInt32(portIdObj); if (portsAsKeys.ContainsKey(portId)) { portRow.set_Value(cableIdIdx, cable.IPID); portRow.set_Value(isFromEndIdx, isFromEndValue); portRow.set_Value(fiberNumberIdx, portsAsKeys[portId]); portRow.Store(); } } ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(portRow); portRow = portCursor.NextRow(); } if (isOperationOpen) { _editor.StopOperation("Create Connections"); isOperationOpen = false; } success = true; } } catch(Exception ex) { if (isOperationOpen) { _editor.AbortOperation(); } success = false; throw new Exception("Save operation failed."); } return success; }
/// <summary> /// Break all connections for a given cable /// </summary> /// <param name="cable">Cable to break connections</param> /// <param name="isExistingOperation">Should we start/stop the edit operation, or are we already in one?</param> /// <returns>Success</returns> public bool BreakAllConnections(FiberCableWrapper cable, bool isExistingOperation) { bool success = false; bool isOperationOpen = false; #region Validation if (null == cable) { throw new ArgumentNullException("cable"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion if (!isExistingOperation) { _editor.StartOperation(); isOperationOpen = true; } try { using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IFeatureClass cableFtClass = cable.Feature.Class as ESRI.ArcGIS.Geodatabase.IFeatureClass; ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); filter.WhereClause = string.Format("{0}='{1}'", ConfigUtil.ConnectedCableFieldName, cable.IPID); filter.SubFields = string.Format("{0},{1},{2}", ConfigUtil.ConnectedCableFieldName, ConfigUtil.ConnectedFiberFieldName, ConfigUtil.ConnectedEndFieldName); string[] deviceClassNames = ConfigUtil.DeviceFeatureClassNames; for (int i = 0; i < deviceClassNames.Length; i++) { string deviceClassName = deviceClassNames[i]; ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = _wkspHelper.FindFeatureClass(deviceClassName); // ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = GdbUtils.GetFeatureClass(cableFtClass, deviceClassName); ESRI.ArcGIS.Geodatabase.ITable portTable = ConfigUtil.GetPortTable(deviceFtClass); ESRI.ArcGIS.Geodatabase.IRowBuffer buffer = portTable.CreateRowBuffer(); // We want to set them to null, so we can just send the empty buffer portTable.UpdateSearchedRows(filter, buffer); ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(buffer); } if (isOperationOpen) { _editor.StopOperation("Break Connections"); isOperationOpen = false; } success = true; } } catch { if (isOperationOpen) { _editor.AbortOperation(); } success = false; } return success; }
/// <summary> /// Splices all available strands from one cable to the other, at a given splice closure /// </summary> /// <param name="cableA">Cable A</param> /// <param name="cableB">Cable B</param> /// <param name="splice">Splice Closure</param> /// <param name="strands">Strands to splice together</param> /// <param name="isExistingOperation">Flag to control whether we need to wrap this in an edit operation</param> /// <returns>Success</returns> public bool CreateSplices(FiberCableWrapper cableA, SpliceableCableWrapper cableB, SpliceClosureWrapper splice, Dictionary<int,FiberSplice> strands, bool isExistingOperation) { bool success = false; bool isOperationOpen = false; #region Validation if (null == cableA) { throw new ArgumentNullException("cableA"); } if (null == cableB) { throw new ArgumentNullException("cableB"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion if (!isExistingOperation) { _editor.StartOperation(); isOperationOpen = true; } if (null == splice) { splice = GenerateSpliceClosure(cableA, cableB); } else if (0 == splice.IPID.Length) { // Populate an IPID; we will need it ESRI.ArcGIS.Geodatabase.IFeature spliceFt = splice.Feature; Guid g = Guid.NewGuid(); spliceFt.set_Value(spliceFt.Fields.FindField(ConfigUtil.IpidFieldName), g.ToString("B").ToUpper()); spliceFt.Store(); } try { ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = _wkspHelper.FindTable(ConfigUtil.FiberSpliceTableName); // ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = GdbUtils.GetTable(cableA.Feature.Class, ConfigUtil.FiberSpliceTableName); int aCableIdx = fiberSpliceTable.FindField(ConfigUtil.ACableIdFieldName); int bCableIdx = fiberSpliceTable.FindField(ConfigUtil.BCableIdFieldName); int aFiberNumIdx = fiberSpliceTable.FindField(ConfigUtil.AFiberNumberFieldName); int bFiberNumIdx = fiberSpliceTable.FindField(ConfigUtil.BFiberNumberFieldName); int spliceIpidIdx = fiberSpliceTable.FindField(ConfigUtil.SpliceClosureIpidFieldName); int isAFromIdx = fiberSpliceTable.FindField(ConfigUtil.IsAFromEndFieldName); int isBFromIdx = fiberSpliceTable.FindField(ConfigUtil.IsBFromEndFieldName); int lossIdx = fiberSpliceTable.FindField(ConfigUtil.LossFieldName); int typeIdx = fiberSpliceTable.FindField(ConfigUtil.TypeFieldName); ESRI.ArcGIS.Geodatabase.IField typeField = fiberSpliceTable.Fields.get_Field(typeIdx); string aCableId = cableA.IPID; string bCableId = cableB.IPID; string isAFromEnd = cableB.IsOtherFromEnd ? "T" : "F"; string isBFromEnd = cableB.IsThisFromEnd ? "T" : "F"; string spliceIpid = splice.IPID; using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { // TODO cant use insert cursor since edit events wont fire. // We need evetns to fire for dynamic values to get populated. // ESRI.ArcGIS.Geodatabase.ICursor insertCursor = fiberSpliceTable.Insert(true); // releaser.ManageLifetime(insertCursor); foreach (KeyValuePair<int, FiberSplice> pair in strands) { IRow row = fiberSpliceTable.CreateRow(); releaser.ManageLifetime(row); FiberSplice fiberSplice = pair.Value; row.set_Value(aCableIdx, aCableId); row.set_Value(bCableIdx, bCableId); row.set_Value(aFiberNumIdx, pair.Key); row.set_Value(bFiberNumIdx, fiberSplice.BRange.Low); row.set_Value(spliceIpidIdx, spliceIpid); row.set_Value(isAFromIdx, isAFromEnd); row.set_Value(isBFromIdx, isBFromEnd); if (null == fiberSplice.Loss) { row.set_Value(lossIdx, DBNull.Value); } else { row.set_Value(lossIdx, fiberSplice.Loss); } object typeValue = DBNull.Value; if (null != fiberSplice.Type) { try { typeValue = GdbUtils.CheckForCodedValue(typeField, fiberSplice.Type); } catch { // TODO: Log a warning about why we can't set the default split splice type? } } row.set_Value(typeIdx, typeValue); row.Store(); } } if (isOperationOpen) { _editor.StopOperation("Edit Splices"); } success = true; } catch { if (isOperationOpen) { _editor.AbortOperation(); } success = false; } return success; }
/// <summary> /// Determines if all the ranges fall between 1 to fibercount /// </summary> /// <param name="ranges">Ranges to check</param> /// <param name="cable">Cable to check on</param> /// <returns>True if valid ranges</returns> public static bool AreRangesWithinFiberCount(List<Range> ranges, FiberCableWrapper cable) { bool result = true; #region Validation if (null == cable) { throw new ArgumentNullException("cable"); } if (null == ranges) { throw new ArgumentNullException("ranges"); } #endregion // int? fiberCount = GdbUtils.GetDomainedIntName(cable.Feature, ConfigUtil.NumberOfFibersFieldName); int? fiberCount = cable.fibers; if (null == fiberCount) { result = false; } else { foreach (Range r in ranges) { if (r.High > fiberCount || 1 > r.Low) { result = false; break; } } } return result; }
/// <summary> /// Gets all cables that are considered splicable to another cable at a given splice closure. /// </summary> /// <param name="cable">Cable to splice with</param> /// <param name="spliceClosure">Splice Closure to splice at</param> /// <returns>List of SpliceableCableWrapper</returns> public List<SpliceableCableWrapper> GetSpliceableCables(FiberCableWrapper cable, SpliceClosureWrapper spliceClosure) { // At the time of this comment, splicable means they are connected in the geometric network List<SpliceableCableWrapper> result = new List<SpliceableCableWrapper>(); if (null == cable) { throw new ArgumentNullException("cable"); } if (null == spliceClosure) { throw new ArgumentNullException("spliceClosure"); } int searchOid = cable.Feature.OID; ESRI.ArcGIS.Geodatabase.IEdgeFeature cableFt = cable.Feature as ESRI.ArcGIS.Geodatabase.IEdgeFeature; ESRI.ArcGIS.Carto.IFeatureLayer ftLayer = _hookHelper.FindFeatureLayer(ConfigUtil.FiberCableFtClassName); int displayIdx = ftLayer.FeatureClass.FindField(ftLayer.DisplayField); if (null != cableFt) { // We assume it is simple. Complex junctions are not supported for splicing cables ESRI.ArcGIS.Geodatabase.ISimpleJunctionFeature junction = spliceClosure.Feature as ESRI.ArcGIS.Geodatabase.ISimpleJunctionFeature; if (null != junction) { bool isAFromEnd = false; // would be in the case that junction.EID == cableFt.ToJunctionEID if (junction.EID == cableFt.FromJunctionEID) { isAFromEnd = true; } else if (junction.EID != cableFt.ToJunctionEID) { // It isn't the from or the two? It shouldn't have been passed in as if it was coincident with the cable return result; // throw new InvalidOperationException("Given splice closure is not the junction for the given cable."); } int edgeCount = junction.EdgeFeatureCount; for (int i = 0; i < edgeCount; i++) { ESRI.ArcGIS.Geodatabase.IEdgeFeature connectedEdge = junction.get_EdgeFeature(i); ESRI.ArcGIS.Geodatabase.IFeature feature = (ESRI.ArcGIS.Geodatabase.IFeature)connectedEdge; ESRI.ArcGIS.Geodatabase.IDataset dataset = feature.Class as ESRI.ArcGIS.Geodatabase.IDataset; string featureClassName = GdbUtils.ParseTableName(dataset); if (0 == string.Compare(featureClassName, ConfigUtil.FiberCableFtClassName) && feature.OID != searchOid) { if (junction.EID == connectedEdge.FromJunctionEID) { result.Add(new SpliceableCableWrapper(feature, true, isAFromEnd, displayIdx)); } else if (junction.EID == connectedEdge.ToJunctionEID) { result.Add(new SpliceableCableWrapper(feature, false, isAFromEnd, displayIdx)); } } } } } return result; }
/// <summary> /// Get the existing splice ranges between two cables at an existing closure /// </summary> /// <param name="cableA">One cable</param> /// <param name="cableB">Other cable</param> /// <param name="splice">Splice Closure</param> /// <returns>List of FiberSplice</returns> /// <remarks>Currently only checks A/B as passed, does not check the reverse B/A combination</remarks> public static List<FiberSplice> GetSplicedRanges(FiberCableWrapper cableA, FiberCableWrapper cableB, SpliceClosureWrapper splice) { List<FiberSplice> result = new List<FiberSplice>(); string spliceWhere = string.Format("{0}='{1}' AND {2}='{3}' AND {4}='{5}'", ConfigUtil.ACableIdFieldName, cableA.IPID, ConfigUtil.BCableIdFieldName, cableB.IPID, ConfigUtil.SpliceClosureIpidFieldName, splice.IPID); using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = TelecomWorkspaceHelper.Instance().FindTable(ConfigUtil.FiberSpliceTableName); // ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = GdbUtils.GetTable(cableA.Feature.Class, ConfigUtil.FiberSpliceTableName); ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); filter.WhereClause = spliceWhere; ((ESRI.ArcGIS.Geodatabase.IQueryFilterDefinition)filter).PostfixClause = string.Format("ORDER BY {0}",ConfigUtil.AFiberNumberFieldName); int aUnitIdx = fiberSpliceTable.FindField(ConfigUtil.AFiberNumberFieldName); int bUnitIdx = fiberSpliceTable.FindField(ConfigUtil.BFiberNumberFieldName); int lossIdx = fiberSpliceTable.FindField(ConfigUtil.LossFieldName); int typeIdx = fiberSpliceTable.FindField(ConfigUtil.TypeFieldName); ESRI.ArcGIS.Geodatabase.IField typeField = fiberSpliceTable.Fields.get_Field(typeIdx); ESRI.ArcGIS.Geodatabase.ICodedValueDomain typeDomain = typeField.Domain as ESRI.ArcGIS.Geodatabase.ICodedValueDomain; ESRI.ArcGIS.Geodatabase.ICursor splices = fiberSpliceTable.Search(filter, true); releaser.ManageLifetime(splices); ESRI.ArcGIS.Geodatabase.IRow spliceRow = splices.NextRow(); int lastAUnit = -1; int lastBUnit = -1; double? lastLoss = null; object lastType = Type.Missing; int aLow = -1; int bLow = -1; while (null != spliceRow) { // These are not-null columns int aUnit = (int)spliceRow.get_Value(aUnitIdx); int bUnit = (int)spliceRow.get_Value(bUnitIdx); object lossObj = spliceRow.get_Value(lossIdx); double? loss = null; if (DBNull.Value != lossObj) { loss = (double)lossObj; } object type = spliceRow.get_Value(typeIdx); if (aUnit != (lastAUnit + 1) || bUnit != (lastBUnit + 1) || loss != lastLoss || !type.Equals(lastType)) { if (-1 != lastAUnit) { string typeString = string.Empty; if (null != typeString) { if (null != typeDomain) { typeString = GdbUtils.GetDomainNameForValue(typeDomain, lastType); } else { typeString = lastType.ToString(); // DBNull.Value will return string.Empty } } result.Add(new FiberSplice(new Range(aLow, lastAUnit), new Range(bLow, lastBUnit), lastLoss, typeString)); } aLow = aUnit; bLow = bUnit; } lastAUnit = aUnit; lastBUnit = bUnit; lastLoss = loss; lastType = type; ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(spliceRow); spliceRow = splices.NextRow(); } if (-1 < aLow) { string typeString = string.Empty; if (null != typeString) { if (null != typeDomain) { typeString = GdbUtils.GetDomainNameForValue(typeDomain, lastType); } else { typeString = lastType.ToString(); // DBNull.Value will return string.Empty } } result.Add(new FiberSplice(new Range(aLow, lastAUnit), new Range(bLow, lastBUnit), lastLoss, typeString)); } } return result; }
/// <summary> /// Generates a splice closure at the coincident endpoint. Does not start an edit operation. /// </summary> /// <param name="cableA">Cable A</param> /// <param name="cableB">Cable B</param> /// <returns>SpliceClosureWRapper based on new feature</returns> private SpliceClosureWrapper GenerateSpliceClosure(FiberCableWrapper cableA, SpliceableCableWrapper cableB) { SpliceClosureWrapper wrapper = null; #region Validation if (null == cableA) { throw new ArgumentNullException("cableA"); } if (null == cableB) { throw new ArgumentNullException("cableB"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion // Populate an IPID; we will need it Guid g = Guid.NewGuid(); string spliceIpid = g.ToString("B").ToUpper(); try { ESRI.ArcGIS.Geometry.IPolyline line = cableB.Feature.Shape as ESRI.ArcGIS.Geometry.IPolyline; if (null != line) { ESRI.ArcGIS.Geometry.IPoint splicePoint = null; if (cableB.IsThisFromEnd) { splicePoint = line.FromPoint; } else { splicePoint = line.ToPoint; } ESRI.ArcGIS.Geodatabase.IFeatureClass spliceClosureFtClass = _wkspHelper.FindFeatureClass(ConfigUtil.SpliceClosureFtClassName); // ESRI.ArcGIS.Geodatabase.IFeatureClass spliceClosureFtClass = GdbUtils.GetFeatureClass(cableA.Feature.Class, ConfigUtil.SpliceClosureFtClassName); ESRI.ArcGIS.Geodatabase.IFeature spliceFt = spliceClosureFtClass.CreateFeature(); spliceFt.Shape = splicePoint; spliceFt.set_Value(spliceClosureFtClass.Fields.FindField(ConfigUtil.IpidFieldName), spliceIpid); spliceFt.Store(); wrapper = new SpliceClosureWrapper(spliceFt); } } catch { wrapper = null; } return wrapper; }
/// <summary> /// Gets a list of all strand numbers from a cable that are connected on the given end /// </summary> /// <param name="cable">Cable to check</param> /// <param name="isFromEnd">True to check from end, False to check to end</param> /// <returns>List of int</returns> private static List<int> GetConnectedStrands(FiberCableWrapper cable, bool isFromEnd) { #region Validation if (null == cable) { throw new ArgumentNullException("cable"); } #endregion List<int> result = new List<int>(); using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IFeatureClass cableFtClass = cable.Feature.Class as ESRI.ArcGIS.Geodatabase.IFeatureClass; string[] deviceClassNames = ConfigUtil.DeviceFeatureClassNames; for (int i = 0; i < deviceClassNames.Length; i++) { string deviceClassName = deviceClassNames[i]; ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = TelecomWorkspaceHelper.Instance().FindFeatureClass(deviceClassName); // ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = GdbUtils.GetFeatureClass(cableFtClass, deviceClassName); if (null != deviceFtClass) { ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetPortRelationship(deviceFtClass); if (null != deviceHasPorts) { ESRI.ArcGIS.Geodatabase.ITable portTable = deviceHasPorts.DestinationClass as ESRI.ArcGIS.Geodatabase.ITable; if (null != portTable) { ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); filter.WhereClause = string.Format("{0}='{1}' AND {2}='{3}' AND {4} IS NOT NULL", ConfigUtil.ConnectedCableFieldName, cable.IPID, ConfigUtil.ConnectedEndFieldName, (isFromEnd ? "T" : "F"), ConfigUtil.ConnectedFiberFieldName); ESRI.ArcGIS.Geodatabase.ICursor portCursor = portTable.Search(filter, true); ESRI.ArcGIS.Geodatabase.IRow portRow = portCursor.NextRow(); int fiberIdIdx = portTable.FindField(ConfigUtil.ConnectedFiberFieldName); while (null != portRow) { result.Add((int)portRow.get_Value(fiberIdIdx)); ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(portRow); portRow = portCursor.NextRow(); } ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(portCursor); } } } } } return result; }
/// <summary> /// Deletes given connections between cable to device /// </summary> /// <param name="cable">Cable</param> /// <param name="device">Device</param> /// <param name="units">Units to connect</param> /// <param name="portType">Input or Output?</param> /// <param name="isExistingOperation">Flag to control whether we need to wrap this in an edit operation</param> /// <returns>Success</returns> public bool BreakConnections(FiberCableWrapper cable, DeviceWrapper device, Dictionary<int, int> units, PortType portType, bool isExistingOperation) { bool success = false; bool isOperationOpen = false; #region Validation if (null == cable) { throw new ArgumentNullException("cable"); } if (null == device) { throw new ArgumentNullException("device"); } if (null == units) { throw new ArgumentNullException("units"); } if (ESRI.ArcGIS.Editor.esriEditState.esriStateNotEditing == _editor.EditState) { throw new InvalidOperationException("You must be editing to perform this operation"); } #endregion if (0 < units.Count) { if (!isExistingOperation) { _editor.StartOperation(); isOperationOpen = true; } try { ESRI.ArcGIS.Geodatabase.IFeatureClass deviceFtClass = device.Feature.Class as ESRI.ArcGIS.Geodatabase.IFeatureClass; ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetPortRelationship(deviceFtClass); if (null == deviceFtClass) { throw new Exception("Unable to find port relationship class."); } ESRI.ArcGIS.Geodatabase.ITable portTable = deviceHasPorts.DestinationClass as ESRI.ArcGIS.Geodatabase.ITable; if (null == portTable) { throw new Exception("Invalid destination on port relationship class."); } using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); StringBuilder inList = new StringBuilder(1024); foreach (KeyValuePair<int, int> pair in units) { string appendFormat = "{0},"; if (PortType.Input == portType) { inList.AppendFormat(appendFormat, pair.Key); } else { inList.AppendFormat(appendFormat, pair.Value); } } inList.Remove(inList.Length - 1, 1); string format = "{0}='{1}' AND {2}='{3}' AND {4}='{5}' AND {6} IN ({7})"; filter.WhereClause = string.Format(format, deviceHasPorts.OriginForeignKey, device.Feature.get_Value(deviceFtClass.FindField(deviceHasPorts.OriginPrimaryKey)), ConfigUtil.ConnectedCableFieldName, cable.IPID, ConfigUtil.PortTypeFieldName, (PortType.Input == portType ? "1" : "2"), ConfigUtil.ConnectedFiberFieldName, inList.ToString()); filter.SubFields = string.Format("{0},{1},{2}", ConfigUtil.ConnectedEndFieldName, ConfigUtil.ConnectedFiberFieldName, ConfigUtil.ConnectedCableFieldName); ESRI.ArcGIS.Geodatabase.IRowBuffer buffer = portTable.CreateRowBuffer(); releaser.ManageLifetime(buffer); // We want to set them to null, so we can just send the empty buffer portTable.UpdateSearchedRows(filter, buffer); if (isOperationOpen) { _editor.StopOperation("Break Connections"); isOperationOpen = false; } success = true; } } catch { if (isOperationOpen) { _editor.AbortOperation(); } success = false; } } return success; }
/// <summary> /// Gets a list of all strand numbers from a cable that are spliced on the given end /// </summary> /// <param name="cable">Cable to check</param> /// <param name="isFromEnd">True to check from end, False to check to end</param> /// <returns>List of int</returns> private static List<int> GetSplicedStrands(FiberCableWrapper cable, bool isFromEnd) { if (null == cable) { throw new ArgumentNullException("cable"); } List<int> result = new List<int>(); using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser()) { ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = TelecomWorkspaceHelper.Instance().FindTable(ConfigUtil.FiberSpliceTableName); // ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = GdbUtils.GetTable(cable.Feature.Class, ConfigUtil.FiberSpliceTableName); ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass(); releaser.ManageLifetime(filter); filter.WhereClause = string.Format("{0}='{1}' AND {2}='{3}'", ConfigUtil.ACableIdFieldName, cable.IPID, ConfigUtil.IsAFromEndFieldName, (isFromEnd ? "T" : "F")); ESRI.ArcGIS.Geodatabase.ICursor spliceCursor = fiberSpliceTable.Search(filter, true); ESRI.ArcGIS.Geodatabase.IRow spliceRow = spliceCursor.NextRow(); int fiberIdIdx = fiberSpliceTable.FindField(ConfigUtil.AFiberNumberFieldName); while (null != spliceRow) { result.Add((int)spliceRow.get_Value(fiberIdIdx)); ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(spliceRow); spliceRow = spliceCursor.NextRow(); } ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(spliceCursor); filter.WhereClause = string.Format("{0}='{1}' AND {2}='{3}'", ConfigUtil.BCableIdFieldName, cable.IPID, ConfigUtil.IsBFromEndFieldName, (isFromEnd ? "T" : "F")); spliceCursor = fiberSpliceTable.Search(filter, true); spliceRow = spliceCursor.NextRow(); fiberIdIdx = fiberSpliceTable.FindField(ConfigUtil.BFiberNumberFieldName); while (null != spliceRow) { result.Add((int)spliceRow.get_Value(fiberIdIdx)); ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(spliceRow); spliceRow = spliceCursor.NextRow(); } ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(spliceCursor); } return result; }
/// <summary> /// Creates a label string for the available ranges of a cable at a certain end /// </summary> /// <param name="cable">Cable to check</param> /// <param name="isFromEnd">End to check</param> /// <returns>string</returns> private string GetAvailableRangeString(FiberCableWrapper cable, bool isFromEnd) { List<Range> availableRanges = SpliceAndConnectionUtils.GetAvailableRanges(cable, isFromEnd); string result = "No available ranges!"; if (0 < availableRanges.Count) { StringBuilder availableLabel = new StringBuilder(64); for (int i = 0; i < availableRanges.Count; i++) { availableLabel.AppendFormat("{0},", availableRanges[i].ToString()); } availableLabel.Remove(availableLabel.Length - 1, 1); result = string.Format("Available: {0}", availableLabel.ToString()); } return result; }