/// <summary>
/// Gets the features from the selection that are from a given ft class
/// </summary>
/// <param name="ftClassName">ft class name</param>
/// <returns>List of IFeature</returns>
public List <ESRI.ArcGIS.Geodatabase.IFeature> GetSelectedFeatures(IFeatureLayer layer)
{
List <ESRI.ArcGIS.Geodatabase.IFeature> result = new List <ESRI.ArcGIS.Geodatabase.IFeature>();
if (layer == null)
{
return(result);
}
ESRI.ArcGIS.Carto.IFeatureSelection ftSelection = layer as ESRI.ArcGIS.Carto.IFeatureSelection;
if (null != ftSelection &&
null != ftSelection.SelectionSet)
{
ESRI.ArcGIS.Geodatabase.ISelectionSet selectionSet = ftSelection.SelectionSet;
ESRI.ArcGIS.Geodatabase.ICursor cursor = null;
try
{
selectionSet.Search(null, false, out cursor);
ESRI.ArcGIS.Geodatabase.IRow ft = cursor.NextRow();
while (null != ft)
{
result.Add((ESRI.ArcGIS.Geodatabase.IFeature)ft);
ft = cursor.NextRow();
}
}
finally
{
ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(cursor);
}
}
return(result);
}
/// <summary>
/// Gets the fiber record for a given fiber number on a given cable ft
/// </summary>
/// <param name="cableFeature"></param>
/// <param name="fiberNumber"></param>
/// <returns>IRow</returns>
private ESRI.ArcGIS.Geodatabase.IRow GetFiberRecord(ESRI.ArcGIS.Geodatabase.IFeature cableFeature, int fiberNumber)
{
ESRI.ArcGIS.Geodatabase.IRow result = null;
ESRI.ArcGIS.Geodatabase.IRelationshipClass fiberRelationship = GdbUtils.GetRelationshipClass(cableFeature.Class, ConfigUtil.FiberCableToFiberRelClassName);
if (null != fiberRelationship && null != fiberRelationship.DestinationClass)
{
ESRI.ArcGIS.Geodatabase.ITable fiberTable = fiberRelationship.DestinationClass as ESRI.ArcGIS.Geodatabase.ITable;
if (null != fiberTable)
{
ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass();
filter.WhereClause = string.Format("{0}='{1}' AND {2}={3}",
fiberRelationship.OriginForeignKey,
cableFeature.get_Value(cableFeature.Fields.FindField(fiberRelationship.OriginPrimaryKey)),
ConfigUtil.Fiber_NumberFieldName,
fiberNumber);
ESRI.ArcGIS.Geodatabase.ICursor cursor = null;
try
{
cursor = fiberTable.Search(filter, false);
result = cursor.NextRow();
}
finally
{
if (null != cursor)
{
ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(cursor);
}
}
}
}
return(result);
}
public void Copy(ESRI.ArcGIS.Geodatabase.IRow srcRow)
{
if (m_inspector == null)
{
m_inspector = new FeatureInspectorClass();
}
m_inspector.Copy(srcRow);
}
public void Load(ESRI.ArcGIS.Geodatabase.IWorkspace Workspace, ESRI.ArcGIS.Geodatabase.IRow Row, BaseModel AEOModel, ModelProperty Property)
{
if (!String.IsNullOrEmpty(Row.get_Value(Row.Fields.FindField(Property.Attribute.FieldName)).ToString()))
{
Property.Property.SetValue(AEOModel,
Convert.ChangeType(Row.get_Value(Row.Fields.FindField(Property.Attribute.FieldName)),
Property.Attribute.FieldType), null);
}
}
/// <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>
/// 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>
/// Copies the values from srcRow to the row being edited.
/// </summary>
/// <param name="srcRow"></param>
public void Copy(ESRI.ArcGIS.Geodatabase.IRow srcRow)
{
m_inspector.Copy(srcRow);
}
/// <summary>
/// Generate the ports for a given device
/// </summary>
/// <param name="device">The device feature</param>
/// <returns>True if completed</returns>
private bool GeneratePorts(ESRI.ArcGIS.Geodatabase.IFeature device, int lowInputPort, int inputPortCount, int lowOutputPort, int outputPortCount, ESRI.ArcGIS.Framework.IProgressDialog2 progressDialog, ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel)
{
bool isCancelled = false;
ESRI.ArcGIS.esriSystem.IStepProgressor stepProgressor = (ESRI.ArcGIS.esriSystem.IStepProgressor)progressDialog;
ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetPortRelationship((ESRI.ArcGIS.Geodatabase.IFeatureClass)device.Class);
Guid g;
if (null != deviceHasPorts)
{
using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser())
{
ESRI.ArcGIS.Geodatabase.ITable portTable = (ESRI.ArcGIS.Geodatabase.ITable)deviceHasPorts.DestinationClass;
releaser.ManageLifetime(portTable);
// Fields to populate on port
int portIpidIdx = portTable.Fields.FindField(ConfigUtil.IpidFieldName);
int portNumberIdx = portTable.Fields.FindField(ConfigUtil.PortIdFieldName);
int portTypeIdx = portTable.Fields.FindField(ConfigUtil.PortTypeFieldName);
int fkeyIdx = portTable.Fields.FindField(deviceHasPorts.OriginForeignKey);
object originPrimaryKey = device.get_Value(device.Fields.FindField(deviceHasPorts.OriginPrimaryKey));
for (int portIdx = lowInputPort; portIdx <= inputPortCount; portIdx++)
{
stepProgressor.Message = string.Format("Creating input port {0} of {1}", portIdx, inputPortCount);
stepProgressor.Step();
g = Guid.NewGuid();
string portIpid = g.ToString("B").ToUpper();
ESRI.ArcGIS.Geodatabase.IRow portRow = portTable.CreateRow();
releaser.ManageLifetime(portRow);
portRow.set_Value(portIpidIdx, portIpid);
portRow.set_Value(portTypeIdx, PortType.Input);
portRow.set_Value(portNumberIdx, portIdx);
portRow.set_Value(fkeyIdx, originPrimaryKey);
portRow.Store();
if (!trackCancel.Continue())
{
isCancelled = true;
break;
}
}
if (trackCancel.Continue())
{
for (int portIdx = lowOutputPort; portIdx <= outputPortCount; portIdx++)
{
stepProgressor.Message = string.Format("Creating output port {0} of {1}", portIdx, outputPortCount);
stepProgressor.Step();
g = Guid.NewGuid();
string portIpid = g.ToString("B").ToUpper();
ESRI.ArcGIS.Geodatabase.IRow portRow = portTable.CreateRow();
releaser.ManageLifetime(portRow);
portRow.set_Value(portIpidIdx, portIpid);
portRow.set_Value(portTypeIdx, PortType.Output);
portRow.set_Value(portNumberIdx, portIdx);
portRow.set_Value(fkeyIdx, originPrimaryKey);
portRow.Store();
if (!trackCancel.Continue())
{
isCancelled = true;
break;
}
}
}
}
}
return(!isCancelled);
}
/// <summary>
/// Finds the connected device/port
/// </summary>
/// <param name="siblingFtClass">Any feature class from the workspace</param>
/// <param name="cableId">Cable ID to check connx for</param>
/// <param name="fiberNumber">Fiber Number to check connx for</param>
/// <param name="isFromEnd">Whether to check the cable's from or to end</param>
/// <param name="portRow">(out) result port</param>
/// <param name="deviceFt">(out) result device</param>
/// <returns>True if a connx was found</returns>
private bool GetConnectedPort(ESRI.ArcGIS.Geodatabase.IFeatureClass siblingFtClass, string cableId, int fiberNumber, bool isFromEnd, out ESRI.ArcGIS.Geodatabase.IRow portRow, out ESRI.ArcGIS.Geodatabase.IFeature deviceFt)
{
portRow = null;
deviceFt = null;
bool result = false;
string[] portTableNames = ConfigUtil.PortTableNames;
using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser())
{
ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass();
filter.WhereClause = string.Format("{0}='{1}' AND {2}={3} AND {4}='{5}'",
ConfigUtil.ConnectedCableFieldName,
cableId,
ConfigUtil.ConnectedFiberFieldName,
fiberNumber,
ConfigUtil.ConnectedEndFieldName,
isFromEnd ? "T" : "F");
releaser.ManageLifetime(filter);
for (int i = 0; i < portTableNames.Length; i++)
{
string portTableName = portTableNames[i];
ESRI.ArcGIS.Geodatabase.ITable portTable = _wkspHelper.FindTable(portTableName);
ESRI.ArcGIS.Geodatabase.ICursor cursor = portTable.Search(filter, false);
releaser.ManageLifetime(cursor);
portRow = cursor.NextRow();
if (null != portRow)
{
ESRI.ArcGIS.Geodatabase.IRelationshipClass deviceHasPorts = ConfigUtil.GetDeviceRelationship(portTable);
if (null == deviceHasPorts)
{
throw new Exception("Device to port relationship is missing or cannot be opened.");
}
ESRI.ArcGIS.Geodatabase.IFeatureClass deviceClass = deviceHasPorts.OriginClass as ESRI.ArcGIS.Geodatabase.IFeatureClass;
if (null == deviceClass)
{
throw new Exception("Device feature class is missing or cannot be opened.");
}
filter.WhereClause = string.Format("{0}='{1}'",
deviceHasPorts.OriginPrimaryKey,
portRow.get_Value(portTable.FindField(deviceHasPorts.OriginForeignKey)));
ESRI.ArcGIS.Geodatabase.IFeatureCursor deviceCursor = deviceClass.Search(filter, false);
deviceFt = deviceCursor.NextFeature();
result = true;
break;
}
}
}
return(result);
}
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>
/// Looks for a fiber splice record at one end of a given cable
/// </summary>
/// <param name="fiberSpliceTable">Fiber splice table</param>
/// <param name="cableId">Cable ID of the cable we are checking</param>
/// <param name="fiberNumber">Fiber Number we are checking</param>
/// <param name="checkFromEnd">Which end of the cable are we checking?</param>
/// <param name="nextCableId">(out) Cable ID of the cable spliced on this end, or string.Empty if none</param>
/// <param name="nextFiberNumber">(out) Fiber Number of spliced on this end, or -1 if none</param>
/// <param name="spliceClosureIpid">(out) IPID of Splice Closure</param>
/// <param name="isNextFromEnd">(out) Is the result cable spliced on its from end or its to end?</param>
/// <returns>The splice record</returns>
private ESRI.ArcGIS.Geodatabase.IRow GetNextSplice(ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable, string cableId, int fiberNumber, bool checkFromEnd, out string nextCableId, out int nextFiberNumber, out string spliceClosureIpid, out bool isNextFromEnd)
{
ESRI.ArcGIS.Geodatabase.IRow spliceRow = null;
spliceClosureIpid = string.Empty;
nextCableId = cableId;
nextFiberNumber = fiberNumber;
isNextFromEnd = checkFromEnd;
using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser())
{
ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass();
filter.WhereClause = string.Format("({0}='{1}' AND {2}={3} AND {4}='{5}')"
+ " OR ({6}='{1}' AND {7}={3} AND {8}='{5}')",
ConfigUtil.ACableIdFieldName,
cableId,
ConfigUtil.AFiberNumberFieldName,
fiberNumber,
ConfigUtil.IsAFromEndFieldName,
(checkFromEnd ? "T" : "F"),
ConfigUtil.BCableIdFieldName,
ConfigUtil.BFiberNumberFieldName,
ConfigUtil.IsBFromEndFieldName);
releaser.ManageLifetime(filter);
// TODO: should we give a warning if the rowcount is more than 1? We should technically only find one splice
// record on this end of the fiber...
ESRI.ArcGIS.Geodatabase.ICursor search = fiberSpliceTable.Search(filter, false);
releaser.ManageLifetime(search);
spliceRow = search.NextRow();
if (null != spliceRow)
{
object scIpidValue = spliceRow.get_Value(_spliceClosureIpidIdx);
if (DBNull.Value != scIpidValue)
{
spliceClosureIpid = scIpidValue.ToString();
}
string aCableId = spliceRow.get_Value(_aCableIdx).ToString();
if (0 == string.Compare(aCableId, cableId))
{
// b is the one we want to return
nextCableId = spliceRow.get_Value(_bCableIdx).ToString();
nextFiberNumber = (int)spliceRow.get_Value(_bFiberNumIdx);
isNextFromEnd = spliceRow.get_Value(_isBFromIdx).ToString() == "T" ? true : false;
}
else
{
// a is the one we want to return
nextCableId = aCableId;
nextFiberNumber = (int)spliceRow.get_Value(_aFiberNumIdx);
isNextFromEnd = spliceRow.get_Value(_isAFromIdx).ToString() == "T" ? true : false;
}
}
}
return(spliceRow);
}
///// <summary>
///// The active view has refreshed. Redraw our results, if we have any
///// </summary>
///// <param name="Display">Display to draw on</param>
///// <param name="phase"></param>
//private void _arcMapWrapper_ActiveViewAfterDraw(ESRI.ArcGIS.Display.IDisplay Display, ESRI.ArcGIS.Carto.esriViewDrawPhase phase)
//{
// if (phase == ESRI.ArcGIS.Carto.esriViewDrawPhase.esriViewGeoSelection)
// {
// // Draw after the selection
// if (null != _currentResults)
// {
// ESRI.ArcGIS.Display.ILineSymbol lineSymbol = new ESRI.ArcGIS.Display.SimpleLineSymbol();
// ESRI.ArcGIS.Display.IRgbColor color = new ESRI.ArcGIS.Display.RgbColorClass();
// color.Red = 255;
// color.Green = 0;
// color.Blue = 0;
// lineSymbol.Color = color;
// lineSymbol.Width = 4;
// ESRI.ArcGIS.Display.ISimpleMarkerSymbol markerSymbol = new ESRI.ArcGIS.Display.SimpleMarkerSymbolClass();
// markerSymbol.Color = color;
// markerSymbol.Style = ESRI.ArcGIS.Display.esriSimpleMarkerStyle.esriSMSCircle;
// markerSymbol.Size = 6;
// for (int i = 0; i < _currentResults.Count; i++)
// {
// ESRI.ArcGIS.Geometry.IGeometry geometry = _currentResults[i];
// if (geometry is ESRI.ArcGIS.Geometry.IPolyline)
// {
// Display.SetSymbol((ESRI.ArcGIS.Display.ISymbol)lineSymbol);
// Display.DrawPolyline((ESRI.ArcGIS.Geometry.IPolyline)geometry);
// }
// else if (geometry is ESRI.ArcGIS.Geometry.IPoint)
// {
// Display.SetSymbol((ESRI.ArcGIS.Display.ISymbol)markerSymbol);
// Display.DrawPoint((ESRI.ArcGIS.Geometry.IPoint)geometry);
// }
// }
// }
// }
//}
private List <ESRI.ArcGIS.Geodatabase.IRow> TracePath(ESRI.ArcGIS.Geodatabase.IFeature cableFeature, int fiberNumber, bool isStartingAtFromEnd)
{
List <ESRI.ArcGIS.Geodatabase.IRow> result = new List <ESRI.ArcGIS.Geodatabase.IRow>();
string ipid = cableFeature.get_Value(cableFeature.Fields.FindField(ConfigUtil.IpidFieldName)).ToString();
ESRI.ArcGIS.Geodatabase.IFeatureClass cableFtClass = (ESRI.ArcGIS.Geodatabase.IFeatureClass)cableFeature.Class;
ESRI.ArcGIS.Geodatabase.IFeatureClass spliceFtClass = _wkspHelper.FindFeatureClass(ConfigUtil.SpliceClosureFtClassName);
ESRI.ArcGIS.Geodatabase.ITable fiberSpliceTable = _wkspHelper.FindTable(ConfigUtil.FiberSpliceTableName);
ESRI.ArcGIS.Geodatabase.IFields spliceFields = fiberSpliceTable.Fields;
string fiberClassName = ConfigUtil.FiberTableName;
ESRI.ArcGIS.Geodatabase.IRelationshipClass fiberRelationship = GdbUtils.GetRelationshipClass(cableFtClass, ConfigUtil.FiberCableToFiberRelClassName);
if (null != fiberRelationship && null != fiberRelationship.DestinationClass)
{
fiberClassName = GdbUtils.ParseTableName(fiberRelationship.DestinationClass as ESRI.ArcGIS.Geodatabase.IDataset);
}
ESRI.ArcGIS.Geodatabase.ITable fiberTable = _wkspHelper.FindTable(fiberClassName);
_aCableIdx = spliceFields.FindField(ConfigUtil.ACableIdFieldName);
_bCableIdx = spliceFields.FindField(ConfigUtil.BCableIdFieldName);
_aFiberNumIdx = spliceFields.FindField(ConfigUtil.AFiberNumberFieldName);
_bFiberNumIdx = spliceFields.FindField(ConfigUtil.BFiberNumberFieldName);
_isAFromIdx = spliceFields.FindField(ConfigUtil.IsAFromEndFieldName);
_isBFromIdx = spliceFields.FindField(ConfigUtil.IsBFromEndFieldName);
_spliceClosureIpidIdx = spliceFields.FindField(ConfigUtil.SpliceClosureIpidFieldName);
ESRI.ArcGIS.Geodatabase.IQueryFilter spliceFilter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass();
spliceFilter.WhereClause = string.Format("({0}='{1}' AND {2}={3})"
+ " OR ({4}='{1}' AND {5}={3})",
ConfigUtil.ACableIdFieldName,
ipid,
ConfigUtil.AFiberNumberFieldName,
fiberNumber,
ConfigUtil.BCableIdFieldName,
ConfigUtil.BFiberNumberFieldName);
int connections = fiberSpliceTable.RowCount(spliceFilter);
if (2 < connections)
{
// TODO: warning?
System.Windows.Forms.MessageBox.Show("Less than 2 connections were detected: " + fiberNumber, "Telecom Trace", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information);
}
string spliceClosureIpid = string.Empty;
string nextCableId = string.Empty;
int nextFiberNumber = -1;
bool isNextFromEnd = false;
// {{0}} causes the string.format to
string cableWhereFormat = string.Format("{0}='{{0}}'", ConfigUtil.IpidFieldName);
string spliceWhereFormat = string.Format("{0}='{{0}}'", ConfigUtil.IpidFieldName);
string fiberWhereFormat = string.Format("{0}='{{0}}' AND {1}={{1}}", fiberRelationship.OriginForeignKey, ConfigUtil.Fiber_NumberFieldName);
using (ESRI.ArcGIS.ADF.ComReleaser releaser = new ESRI.ArcGIS.ADF.ComReleaser())
{
ESRI.ArcGIS.Geodatabase.IQueryFilter filter = new ESRI.ArcGIS.Geodatabase.QueryFilterClass();
releaser.ManageLifetime(filter);
// Ripple down the start cable's to end
ESRI.ArcGIS.Geodatabase.IRow spliceRow = GetNextSplice(fiberSpliceTable, ipid, fiberNumber, isStartingAtFromEnd, out nextCableId, out nextFiberNumber, out spliceClosureIpid, out isNextFromEnd);
while (null != spliceRow)
{
ESRI.ArcGIS.Geodatabase.IFeature spliceClosure = null;
if (spliceClosureIpid.Equals(""))
{
System.Windows.Forms.MessageBox.Show("Found Splice with no SpliceClosure (ID/#) " + nextCableId + "/" + nextFiberNumber, "Telecom Trace", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
else
{
filter.WhereClause = string.Format(spliceWhereFormat, spliceClosureIpid);
ESRI.ArcGIS.Geodatabase.IFeatureCursor spliceCursor = spliceFtClass.Search(filter, false);
releaser.ManageLifetime(spliceCursor);
spliceClosure = spliceCursor.NextFeature();
if (spliceClosure == null)
{
System.Windows.Forms.MessageBox.Show("Invalid SpliceClosure referenced: (IPID)" + spliceClosureIpid, "Telecom Trace", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
}
filter.WhereClause = string.Format(cableWhereFormat, nextCableId);
ESRI.ArcGIS.Geodatabase.IFeatureCursor cableCursor = cableFtClass.Search(filter, false);
releaser.ManageLifetime(cableCursor);
ESRI.ArcGIS.Geodatabase.IFeature cable = cableCursor.NextFeature();
if (cable == null)
{
System.Windows.Forms.MessageBox.Show("Invalid cable ID referenced: (ID)" + nextCableId, "Telecom Trace", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
filter.WhereClause = string.Format(fiberWhereFormat, nextCableId, nextFiberNumber);
ESRI.ArcGIS.Geodatabase.ICursor fiberCursor = fiberTable.Search(filter, false);
releaser.ManageLifetime(fiberCursor);
ESRI.ArcGIS.Geodatabase.IRow fiber = fiberCursor.NextRow();
if (fiber == null)
{
System.Windows.Forms.MessageBox.Show("Invalid Fiber Cable or # referenced: (ID/#) " + nextCableId + "/" + nextFiberNumber, "Telecom Trace", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
if (isStartingAtFromEnd)
{
if (spliceRow != null)
{
result.Add(spliceRow);
}
if (spliceClosure != null)
{
result.Add(spliceClosure);
}
if (fiber != null)
{
result.Add(fiber);
}
if (cable != null)
{
result.Add(cable);
}
}
else
{
if (spliceClosure != null)
{
result.Add(spliceClosure);
}
if (spliceRow != null)
{
result.Add(spliceRow);
}
if (cable != null)
{
result.Add(cable);
}
if (fiber != null)
{
result.Add(fiber);
}
}
spliceRow = GetNextSplice(fiberSpliceTable, nextCableId, nextFiberNumber, !isNextFromEnd, out nextCableId, out nextFiberNumber, out spliceClosureIpid, out isNextFromEnd);
}
// See if there is a port for this one
ESRI.ArcGIS.Geodatabase.IRow portRow = null;
ESRI.ArcGIS.Geodatabase.IFeature deviceFt = null;
if (GetConnectedPort(cableFtClass, nextCableId, nextFiberNumber, isNextFromEnd, out portRow, out deviceFt))
{
if (isStartingAtFromEnd)
{
result.Add(portRow);
result.Add(deviceFt);
}
else
{
result.Add(deviceFt);
result.Add(portRow);
}
}
return(result);
}
}
public void Load(ESRI.ArcGIS.Geodatabase.IWorkspace _workspace, ESRI.ArcGIS.Geodatabase.IRow _row, BaseModel BaseModel, ModelProperty _property, BaseModel.LoadMethod ChooseLoadMethod)
{
this.Load(_workspace, _row, BaseModel, _property);
}