// _makeNbtTreeNode()
public void _makeTreeNodeProp(CswNbtTreeNode TreeNode,
Int32 NodeTypePropId,
Int32 ObjectClassPropId,
Int32 JctNodePropId,
string PropName,
string ObjectClassPropName,
string Gestalt,
CswEnumNbtFieldType FieldType,
string Field1,
string Field2,
Int32 Field1_Fk,
double Field1_Numeric,
bool Hidden,
string Field1_Big)
{
CswNbtTreeNodeProp TreeNodeProp = new CswNbtTreeNodeProp(FieldType, PropName, ObjectClassPropName, ObjectClassPropId, NodeTypePropId, JctNodePropId, TreeNode)
{
ElementName = "NbtNodeProp",
Gestalt = Gestalt,
Field1 = Field1,
Field2 = Field2,
Field1_Fk = Field1_Fk,
Field1_Numeric = Field1_Numeric,
Hidden = Hidden,
Field1_Big = Field1_Big
};
TreeNode.ChildProps.Add(TreeNodeProp);
}
public CswViewBuilderProp(CswNbtMetaDataNodeTypeProp NodeTypeProp)
{
CswNbtMetaDataNodeType nt = NodeTypeProp.getNodeType();
if (null != nt)
{
OwnerName = nt.NodeTypeName;
}
FieldType = NodeTypeProp.getFieldTypeValue();
//ListOptions.FromString( NodeTypeProp.ListOptions );
ListOptions.FromString(NodeTypeProp.DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.Options].AsText.Text);
RelatedIdType = CswEnumNbtViewRelatedIdType.NodeTypeId;
MetaDataPropNameWithQuestionNo = NodeTypeProp.PropNameWithQuestionNo;
MetaDataPropId = NodeTypeProp.FirstPropVersionId;
MetaDataPropName = NodeTypeProp.PropName;
MetaDataTypeName = NodeTypeProp.getNodeType().NodeTypeName;
FieldTypeRule = NodeTypeProp.getFieldTypeRule();
Type = CswEnumNbtViewPropType.NodeTypePropId;
PropName = MetaDataPropName;
AssociatedPropIds.Add(MetaDataPropId.ToString());
if (NodeTypeProp.ObjectClassPropId != Int32.MinValue)
{
AssociatedPropIds.Add(NodeTypeProp.ObjectClassPropId.ToString());
}
} //ctor Ntp
} //this[NodeTypeProp]
public CswNbtPropEnmrtrFiltered this[CswEnumNbtFieldType FieldType]
{
get
{
return(new CswNbtPropEnmrtrFiltered(_Props, FieldType));
} //get
} //this[FieldType]
public void addProperty(Int32 NodeTypePropId, Int32 ObjectClassPropId, Int32 JctNodePropId, string PropName, string ObjectClassPropName, string Gestalt,
CswEnumNbtFieldType FieldType, string Field1, string Field2,
Int32 Field1_Fk, double Field1_Numeric, bool Hidden, string Field1_Big)
{
_checkCurrentNode();
_makeTreeNodeProp(_CurrentNode, NodeTypePropId, ObjectClassPropId, JctNodePropId, PropName, ObjectClassPropName, Gestalt, FieldType, Field1, Field2,
Field1_Fk, Field1_Numeric, Hidden, Field1_Big);
}
public CswNbtTreeNodeProp(CswEnumNbtFieldType NbtFieldType, string NbtPropName, string NbtObjectClassPropName, int NbtObjectClassPropId,
int NbtNodeTypePropId, int NbtJctNodePropId, CswNbtTreeNode TreeNode)
{
FieldType = NbtFieldType;
PropName = NbtPropName;
ObjectClassPropName = NbtObjectClassPropName;
ObjectClassPropId = NbtObjectClassPropId;
NodeTypePropId = NbtNodeTypePropId;
JctNodePropId = NbtJctNodePropId;
PropOwner = TreeNode;
}
public double getCurrentInventoryLevel(CswNbtObjClassInventoryLevel InventoryLevel)
{
double Ret = 0;
CswNbtView ContainerView = GetCurrentQuantityView(InventoryLevel, InventoryLevel.Location.SelectedNodeId);
if (null != ContainerView)
{
ICswNbtTree Tree = _CswNbtResources.Trees.getTreeFromView(ContainerView, false, false, false);
Int32 LocationNodeCount = Tree.getChildNodeCount();
if (LocationNodeCount > 0)
{
Dictionary <Int32, CswNbtUnitConversion> UnitConversions = new Dictionary <int, CswNbtUnitConversion>();
for (Int32 L = 0; L < LocationNodeCount; L += 1)
{
Tree.goToNthChild(L);
Int32 ContainerNodeCount = Tree.getChildNodeCount();
if (ContainerNodeCount > 0)
{
for (Int32 C = 0; C < ContainerNodeCount; C += 1)
{
Tree.goToNthChild(C);
foreach (CswNbtTreeNodeProp Prop in Tree.getChildNodePropsOfNode())
{
CswEnumNbtFieldType FieldType = Prop.FieldType;
if (FieldType == CswEnumNbtFieldType.Quantity)
{
Int32 UnitTypeId = Prop.Field1_Fk;
CswNbtUnitConversion Conversion;
if (UnitConversions.ContainsKey(UnitTypeId))
{
Conversion = UnitConversions[UnitTypeId];
}
else
{
Conversion = new CswNbtUnitConversion(_CswNbtResources, new CswPrimaryKey("nodes", UnitTypeId), InventoryLevel.Level.UnitId, InventoryLevel.Material.RelatedNodeId);
UnitConversions.Add(UnitTypeId, Conversion);
}
if (null != Conversion)
{
double ContainerQuantity = Prop.Field1_Numeric;
Ret += Conversion.convertUnit(ContainerQuantity);
}
}
}
Tree.goToParentNode();
}
}
Tree.goToParentNode();
}
}
}
return(Ret);
}
} //ctor Ntp
public CswViewBuilderProp(CswNbtViewProperty ViewProperty)
{
if (ViewProperty.Type == CswEnumNbtViewPropType.NodeTypePropId &&
null != ViewProperty.NodeTypeProp)
{
OwnerName = _getOwnerName(ViewProperty);
FieldType = ViewProperty.NodeTypeProp.getFieldTypeValue();
//ListOptions.FromString( ViewProperty.NodeTypeProp.ListOptions );
if (ViewProperty.NodeTypeProp.DesignNode.AttributeProperty.ContainsKey(CswEnumNbtPropertyAttributeName.Options))
{
ListOptions.FromString(ViewProperty.NodeTypeProp.DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.Options].AsText.Text);
}
RelatedIdType = CswEnumNbtViewRelatedIdType.NodeTypeId;
MetaDataPropNameWithQuestionNo = ViewProperty.NodeTypeProp.PropNameWithQuestionNo;
MetaDataPropId = ViewProperty.NodeTypeProp.FirstPropVersionId;
MetaDataPropName = ViewProperty.NodeTypeProp.PropName;
MetaDataTypeName = ViewProperty.NodeTypeProp.getNodeType().NodeTypeName;
FieldTypeRule = ViewProperty.NodeTypeProp.getFieldTypeRule();
AssociatedPropIds.Add(MetaDataPropId.ToString());
if (ViewProperty.NodeTypeProp.ObjectClassPropId != Int32.MinValue)
{
AssociatedPropIds.Add(ViewProperty.NodeTypeProp.ObjectClassPropId.ToString());
}
}
else if (ViewProperty.Type == CswEnumNbtViewPropType.ObjectClassPropId &&
null != ViewProperty.ObjectClassProp)
{
CswNbtMetaDataObjectClass oc = ViewProperty.ObjectClassProp.getObjectClass();
if (null != oc)
{
OwnerName = oc.ObjectClass.Value;
}
FieldType = ViewProperty.ObjectClassProp.getFieldTypeValue();
setObjectClassPropListOptions(ViewProperty.ObjectClassProp);
RelatedIdType = CswEnumNbtViewRelatedIdType.ObjectClassId;
MetaDataPropNameWithQuestionNo = ViewProperty.ObjectClassProp.PropNameWithQuestionNo;
MetaDataPropId = ViewProperty.ObjectClassProp.ObjectClassPropId;
MetaDataPropName = ViewProperty.ObjectClassProp.PropName;
MetaDataTypeName = ViewProperty.ObjectClassProp.getObjectClass().ObjectClass.ToString().Replace("Class", "");
FieldTypeRule = ViewProperty.ObjectClassProp.getFieldTypeRule();
AssociatedPropIds.Add(MetaDataPropId.ToString());
}
ViewProp = ViewProperty;
FieldType = ViewProperty.FieldType;
Filters = ViewProperty.Filters;
Type = ViewProperty.Type;
Width = ViewProperty.Width;
SortBy = ViewProperty.SortBy;
SortMethod = ViewProperty.SortMethod;
PropName = ViewProperty.Name ?? MetaDataPropName;
} //ctor Vp
public static void CreateCafProps(CswNbtResources NbtResources, List <string> NodeTypes, string PropsValsTblName, string PropsValsPKName, CswEnumSetupMode SetupMode)
{
CswNbtSchemaUpdateImportMgr ImpMgr = new CswNbtSchemaUpdateImportMgr(new CswNbtSchemaModTrnsctn(NbtResources), "CAF", ImporterSetUpMode: SetupMode);
string sql = GetCAFPropertiesSQL(PropsValsTblName, NodeTypes);
CswArbitrarySelect cafChemPropAS = NbtResources.makeCswArbitrarySelect("cafProps_" + PropsValsPKName, sql);
DataTable cafChemPropsDT = cafChemPropAS.getTable();
foreach (DataRow row in cafChemPropsDT.Rows)
{
foreach (string nt in NodeTypes)
{
CswNbtMetaDataNodeType NodeType = NbtResources.MetaData.getNodeType(nt);
string PropName = row["propertyname"].ToString();
int PropId = CswConvert.ToInt32(row["propertyid"]);
PropName = GetUniquePropName(NodeType, PropName); //keep appending numbers until we have a unique prop name
CswEnumNbtFieldType propFT = GetFieldTypeFromCAFPropTypeCode(row["propertytype"].ToString());
CswNbtMetaDataNodeTypeProp newProp = NbtResources.MetaData.makeNewProp(new CswNbtWcfMetaDataModel.NodeTypeProp(NodeType, NbtResources.MetaData.getFieldType(propFT), PropName)
{
IsRequired = CswConvert.ToBoolean(row["required"]),
ReadOnly = CswConvert.ToBoolean(row["readonly"]),
ListOptions = CswConvert.ToString(row["listopts"])
});
newProp.removeFromAllLayouts();
string cafColPropName = "prop" + row["propertyid"];
string cafSourceCol = "propvaltext";
if (CswEnumNbtFieldType.DateTime == propFT)
{
cafSourceCol = "propvaldate";
}
else if (CswEnumNbtFieldType.Number == propFT)
{
cafSourceCol = "propvalnumber";
}
ImpMgr.importBinding(cafSourceCol, PropName, "", "CAF", NodeType.NodeTypeName,
ClobTableName: PropsValsTblName,
LobDataPkColOverride: cafColPropName,
LobDataPkColName: PropsValsPKName,
LegacyPropId: PropId);
}
}
NbtResources.commitTransaction();
ImpMgr.finalize();
}
/// <summary>
/// For loading from a string (created by ToString())
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, CswDelimitedString PropertyString)
: base(CswNbtResources, View)
{
if (PropertyString[0] == CswEnumNbtViewNodeType.CswNbtViewProperty.ToString())
{
if (PropertyString[1] != string.Empty)
{
Type = PropertyString[1];
}
if (PropertyString[2] != string.Empty)
{
NodeTypePropId = CswConvert.ToInt32(PropertyString[2]);
}
if (PropertyString[3] != string.Empty)
{
Name = PropertyString[3];
}
//if( Values[4] != string.Empty )
// ArbitraryId = Values[4];
if (PropertyString[5] != string.Empty)
{
SortBy = Convert.ToBoolean(PropertyString[5]);
}
if (PropertyString[6] != string.Empty)
{
SortMethod = PropertyString[6];
}
if (PropertyString[7] != string.Empty)
{
FieldType = CswNbtMetaDataFieldType.getFieldTypeFromString(PropertyString[7]);
}
if (PropertyString[8] != string.Empty)
{
Order = CswConvert.ToInt32(PropertyString[8]);
}
if (PropertyString[9] != string.Empty)
{
Width = CswConvert.ToInt32(PropertyString[9]);
}
if (PropertyString[10] != string.Empty)
{
ObjectClassPropId = CswConvert.ToInt32(PropertyString[10]);
}
if (PropertyString[11] != string.Empty)
{
ShowInGrid = CswConvert.ToBoolean(PropertyString[11]);
}
}
}
/// <summary>
/// View property constructor
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, ICswNbtMetaDataProp Prop)
: base(CswNbtResources, View)
{
if (Prop is CswNbtMetaDataNodeTypeProp)
{
this.Type = CswEnumNbtViewPropType.NodeTypePropId;
this.NodeTypePropId = ((CswNbtMetaDataNodeTypeProp)Prop).FirstPropVersionId;
}
else if (Prop is CswNbtMetaDataObjectClassProp)
{
this.Type = CswEnumNbtViewPropType.ObjectClassPropId;
this.ObjectClassPropId = ((CswNbtMetaDataObjectClassProp)Prop).PropId;
}
this.FieldType = Prop.getFieldTypeValue();
this.Name = Prop.PropName;
}
/// <summary>
/// Get the NBT FieldType equivalent for a CAF custom prop code
/// </summary>
private static CswEnumNbtFieldType GetFieldTypeFromCAFPropTypeCode(string CafPropTypeCode)
{
CswEnumNbtFieldType Ret = null;
switch (CafPropTypeCode)
{
case "T":
Ret = CswEnumNbtFieldType.Text;
break;
case "L":
Ret = CswEnumNbtFieldType.List;
break;
case "M": //Multi-List
Ret = CswEnumNbtFieldType.MultiList;
break;
case "D":
Ret = CswEnumNbtFieldType.DateTime;
break;
case "V": //Multi-Value
Ret = CswEnumNbtFieldType.MultiList;
break;
case "E":
Ret = CswEnumNbtFieldType.Memo;
break;
case "O":
Ret = CswEnumNbtFieldType.Logical;
break;
case "N":
Ret = CswEnumNbtFieldType.Number;
break;
case "Q":
//Query - we don't import this prop
break;
}
return(Ret);
}
} //NodeTypeId
public CswEnumNbtFieldType getFieldTypeValue()
{
CswEnumNbtFieldType ret = CswNbtResources.UnknownEnum;
if (null != _NodeTypeProp)
{
ret = _NodeTypeProp.getFieldTypeValue();
}
else if (Int32.MinValue != _ObjectClassPropId)
{
CswNbtMetaDataObjectClassProp ocp = _CswNbtResources.MetaData.getObjectClassProp(_ObjectClassPropId);
if (null != ocp)
{
ret = ocp.getFieldTypeValue();
}
}
return(ret);
} // getFieldTypeValue()
} // setDefaultPropertyValues()
public void setSequenceValues(CswNbtNode Node)
{
if (false == Node.IsTemp)
{
foreach (CswNbtNodePropWrapper Prop in Node.Properties)
{
CswEnumNbtFieldType FT = Prop.getFieldTypeValue();
if (FT == CswEnumNbtFieldType.Barcode)
{
Prop.AsBarcode.setBarcodeValue(); // does not overwrite
}
else if (FT == CswEnumNbtFieldType.Sequence)
{
Prop.AsSequence.setSequenceValue(); // does not overwrite
}
}
}
}
} // copyPropertyValues()
/// <summary>
/// Sets the values of all relationships whose target matches
/// the ParentNode's nodetypeid or objectclassid to the ParentNode's nodeid.
/// </summary>
public void RelateToNode(CswNbtNode ParentNode, CswNbtView View)
{
CswNbtNodePropWrapper Prop = null;
// BZ 10372 - Iterate all relationships
foreach (CswNbtViewRelationship ViewRelationship in View.Root.GetAllChildrenOfType(CswEnumNbtViewNodeType.CswNbtViewRelationship))
{
// BZ 8355 - Set relationships on children pointing to parents, not the other way
if (ViewRelationship.PropOwner == CswEnumNbtViewPropOwnerType.Second)
{
//if( ( ( ViewRelationship.SecondType == NbtViewRelatedIdType.NodeTypeId && ViewRelationship.SecondId == this.NodeTypeId ) ||
// ( ViewRelationship.SecondType == NbtViewRelatedIdType.ObjectClassId && ViewRelationship.SecondId == this.getObjectClassId() ) ) &&
// ( ( ViewRelationship.FirstType == NbtViewRelatedIdType.NodeTypeId && ViewRelationship.FirstId == ParentNode.NodeTypeId ) ||
// ( ViewRelationship.FirstType == NbtViewRelatedIdType.ObjectClassId && ViewRelationship.FirstId == ParentNode.getObjectClassId() ) ) )
if (ViewRelationship.SecondMatches(this.getNodeType()) && ViewRelationship.FirstMatches(ParentNode.getNodeType()))
{
if (ViewRelationship.PropType == CswEnumNbtViewPropIdType.NodeTypePropId)
{
Prop = this.Properties[_CswNbtResources.MetaData.getNodeTypeProp(ViewRelationship.PropId)];
}
else if (ViewRelationship.PropType == CswEnumNbtViewPropIdType.ObjectClassPropId)
{
Prop = this.Properties[_CswNbtResources.MetaData.getObjectClassProp(ViewRelationship.PropId).PropName];
}
if (Prop != null)
{
CswEnumNbtFieldType FT = Prop.getFieldTypeValue();
if (FT == CswEnumNbtFieldType.Relationship)
{
Prop.AsRelationship.RelatedNodeId = ParentNode.NodeId;
Prop.AsRelationship.RefreshNodeName();
}
if (FT == CswEnumNbtFieldType.Location)
{
Prop.AsLocation.SelectedNodeId = ParentNode.NodeId;
Prop.AsLocation.RefreshNodeName();
}
}
}
} // if( ViewRelationship.PropOwner == PropOwnerType.Second )
} // foreach( CswNbtViewRelationship ViewRelationship in View.Root.GetAllChildrenOfType( NbtViewNodeType.CswNbtViewRelationship ) )
} // RelateToNode()
} //ctor Ntp
public CswViewBuilderProp(CswNbtMetaDataObjectClassProp ObjectClassProp)
{
CswNbtMetaDataObjectClass oc = ObjectClassProp.getObjectClass();
if (null != oc)
{
OwnerName = oc.ObjectClass.Value;
}
FieldType = ObjectClassProp.getFieldTypeValue();
setObjectClassPropListOptions(ObjectClassProp);
RelatedIdType = CswEnumNbtViewRelatedIdType.NodeTypeId;
MetaDataPropNameWithQuestionNo = ObjectClassProp.PropNameWithQuestionNo;
MetaDataPropId = ObjectClassProp.ObjectClassPropId;
MetaDataPropName = ObjectClassProp.PropName;
MetaDataTypeName = ObjectClassProp.getObjectClass().ObjectClass.ToString();
FieldTypeRule = ObjectClassProp.getFieldTypeRule();
Type = CswEnumNbtViewPropType.ObjectClassPropId;
PropName = MetaDataPropName;
AssociatedPropIds.Add(MetaDataPropId.ToString());
} //ctor Ntp
/// <summary>
/// Handles when the property value is copied to another node
/// </summary>
public void CopyGeneric(CswNbtNodePropData Source)
{
// Default, just copy the data values
CswEnumNbtFieldType FieldType = Source.getFieldTypeValue();
ICswNbtFieldTypeRule FieldTypeRule = _CswNbtResources.MetaData.getFieldTypeRule(FieldType);
foreach (CswNbtSubField SubField in FieldTypeRule.SubFields)
{
if (SubField.Column == CswEnumNbtPropColumn.Field1_FK)
{
//Implementing FieldType specific behavior here. Blame Steve.
if (FieldType == CswEnumNbtFieldType.ViewReference)
{
//we want to copy views to the new node by value, so changes to the view on either node don't affect the other
CswNbtView View = _CswNbtResources.ViewSelect.restoreView(new CswNbtViewId(Source.Field1_Fk));
CswNbtView ViewCopy = new CswNbtView(_CswNbtResources);
ViewCopy.saveNew(View.ViewName, View.Visibility, View.VisibilityRoleId, View.VisibilityUserId, View);
SetSubFieldValue(CswEnumNbtSubFieldName.ViewID, ViewCopy.ViewId);
}
else
{
SetSubFieldValue(SubField.Name, Source.Field1_Fk);
}
} // if( SubField.Column == CswEnumNbtPropColumn.Field1_FK )
else
{
SetSubFieldValue(SubField.Name, Source.GetPropRowValue(SubField));
}
} // foreach( CswNbtSubField SubField in NodeTypeProp.getFieldTypeRule().SubFields )
// Also copy Gestalt, which usually isn't listed as a subfield
SetSubFieldValue(CswEnumNbtSubFieldName.Gestalt, Source.Gestalt);
SetSubFieldValue(CswEnumNbtSubFieldName.GestaltSearch, Source.GestaltSearch);
//Case 31362 - also copy Blob_Data if necessary
if (Source.getFieldTypeValue() == CswEnumNbtFieldType.MOL || Source.getFieldTypeValue() == CswEnumNbtFieldType.Image || Source.getFieldTypeValue() == CswEnumNbtFieldType.File)
{
CswNbtSdBlobData.CopyBlobData(_CswNbtResources, Source.JctNodePropId, JctNodePropId);
}
}
private bool _propIsSupportedInMobile(CswEnumNbtFieldType FieldType)
{
return(FieldType != CswNbtResources.UnknownEnum &&
FieldType != CswEnumNbtFieldType.Button &&
FieldType != CswEnumNbtFieldType.Composite &&
FieldType != CswEnumNbtFieldType.Grid &&
FieldType != CswEnumNbtFieldType.File &&
FieldType != CswEnumNbtFieldType.Image &&
FieldType != CswEnumNbtFieldType.ImageList &&
FieldType != CswEnumNbtFieldType.LogicalSet &&
FieldType != CswEnumNbtFieldType.MOL &&
FieldType != CswEnumNbtFieldType.MTBF &&
FieldType != CswEnumNbtFieldType.MultiList &&
FieldType != CswEnumNbtFieldType.NFPA &&
FieldType != CswEnumNbtFieldType.NodeTypeSelect &&
FieldType != CswEnumNbtFieldType.Quantity &&
FieldType != CswEnumNbtFieldType.Scientific &&
FieldType != CswEnumNbtFieldType.TimeInterval &&
FieldType != CswEnumNbtFieldType.UserSelect &&
FieldType != CswEnumNbtFieldType.ViewPickList &&
FieldType != CswEnumNbtFieldType.ViewReference
);
}
public override void update()
{
//Move blob data from jct_nodes_props to blob_data
CswNbtMetaDataFieldType molFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.MOL );
CswNbtMetaDataFieldType imageFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Image );
CswNbtMetaDataFieldType fileFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.File );
string sql = "select distinct nodetypeid from nodetype_props where fieldtypeid in (" + molFT.FieldTypeId + "," + imageFT.FieldTypeId + "," + fileFT.FieldTypeId + ")";
CswArbitrarySelect arbSelect = _CswNbtSchemaModTrnsctn.makeCswArbitrarySelect( "findBlobDataNTs", sql );
DataTable nodeTypes = arbSelect.getTable();
foreach( DataRow Row in nodeTypes.Rows )
{
int NodeTypeId = CswConvert.ToInt32( Row["nodetypeid"].ToString() );
CswNbtMetaDataNodeType NodeType = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( NodeTypeId );
if( null != NodeType )
{
foreach( CswNbtNode Node in NodeType.getNodes( false, true, false, true ) )
{
foreach( CswNbtMetaDataNodeTypeProp Prop in NodeType.getNodeTypeProps() )
{
CswEnumNbtFieldType Type = Prop.getFieldTypeValue();
if( Type == CswEnumNbtFieldType.MOL ||
Type == CswEnumNbtFieldType.File ||
Type == CswEnumNbtFieldType.Image )
{
CswNbtNodePropWrapper propWrapper = Node.Properties[Prop];
_moveBlobData( propWrapper, Node );
}
}
}
}
}
} // update()
private void setupGridColumns(DataSet DS, CswNbtView View)
{
_Grid.Columns.Clear();
// Edit column
GridBoundColumn EditColumn = new GridBoundColumn();
EditColumn.UniqueName = "EditColumn";
EditColumn.HeaderText = "Edit";
EditColumn.DataField = "Edit";
EditColumn.Display = ShowActionColumns;
_Grid.Columns.Add(EditColumn);
// Node column
GridBoundColumn NodeNameColumn = new GridBoundColumn();
NodeNameColumn.UniqueName = "NodeName";
NodeNameColumn.HeaderText = "Node Name";
NodeNameColumn.DataField = "NodeName";
// BZ 6704
NodeNameColumn.Visible = false;
NodeNameColumn.Display = false;
_Grid.Columns.Add(NodeNameColumn);
// NodeKey column
GridBoundColumn NodeKeyColumn = new GridBoundColumn();
NodeKeyColumn.UniqueName = "NodeKey";
NodeKeyColumn.HeaderText = "NodeKey";
NodeKeyColumn.DataField = "NodeKey";
NodeKeyColumn.Display = false;
_Grid.Columns.Add(NodeKeyColumn);
foreach (DataTable Table in DS.Tables)
{
foreach (DataColumn Column in Table.Columns)
{
string ColumnName = Column.ColumnName;
if (ColumnName.Length > PropColumnPrefix.Length && ColumnName.Substring(0, PropColumnPrefix.Length) == PropColumnPrefix)
{
string NoPrefixColumnName = ColumnName.Substring(PropColumnPrefix.Length);
//Int32 CurrentNodeTypePropId = CswConvert.ToInt32( NoPrefixColumnName.Substring( 0, NoPrefixColumnName.IndexOf( '_' ) ) );
string RealColumnName = CswTools.XmlRealAttributeName(NoPrefixColumnName); //.Substring( NoPrefixColumnName.IndexOf( '_' ) + 1 ) );
//CswNbtMetaDataNodeTypeProp CurrentNodeTypeProp = _CswNbtResources.MetaData.getNodeTypeProp( CurrentNodeTypePropId );
//CswNbtViewProperty CurrentViewProp = View.FindPropertyById( CswNbtPropType.NodeTypePropId, CurrentNodeTypePropId );
CswNbtViewProperty CurrentViewProp = View.findPropertyByName(RealColumnName);
//if( CurrentViewProp == null )
// CurrentViewProp = View.FindPropertyByName( CurrentNodeTypeProp.PropName );
CswEnumNbtFieldType ColFieldType = CswNbtResources.UnknownEnum;
if (CurrentViewProp != null)
{
if (((CswNbtViewRelationship)CurrentViewProp.Parent).SecondType == CswEnumNbtViewRelatedIdType.NodeTypeId)
{
CswNbtMetaDataNodeType CurrentNT = _CswNbtResources.MetaData.getNodeType(((CswNbtViewRelationship)CurrentViewProp.Parent).SecondId);
CswNbtMetaDataNodeTypeProp CurrentNTP = CurrentNT.getNodeTypeProp(RealColumnName);
if (CurrentNTP != null)
{
ColFieldType = CurrentNTP.getFieldTypeValue();
}
}
else if (((CswNbtViewRelationship)CurrentViewProp.Parent).SecondType == CswEnumNbtViewRelatedIdType.ObjectClassId)
{
CswNbtMetaDataObjectClass CurrentOC = _CswNbtResources.MetaData.getObjectClass(((CswNbtViewRelationship)CurrentViewProp.Parent).SecondId);
foreach (CswNbtMetaDataNodeType CurrentNT in CurrentOC.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp CurrentNTP = CurrentNT.getNodeTypeProp(RealColumnName);
if (CurrentNTP != null)
{
ColFieldType = CurrentNTP.getFieldTypeValue();
}
}
}
}
GridBoundColumn thisColumn = null;
//switch( CurrentNodeTypeProp.FieldType.FieldType )
switch (ColFieldType)
{
case CswEnumNbtFieldType.DateTime:
thisColumn = new GridDateTimeColumn();
thisColumn.DataFormatString = "{0:M/d/yyyy}";
thisColumn.DataType = typeof(DateTime);
break;
//case CswEnumNbtFieldType.Time:
// thisColumn = new GridDateTimeColumn();
// thisColumn.DataFormatString = "{0:H:mm:ss}";
// thisColumn.DataType = typeof( DateTime );
// break;
default:
thisColumn = new GridBoundColumn();
break;
}
thisColumn.UniqueName = ColumnName;
thisColumn.HeaderText = RealColumnName;
thisColumn.DataField = ColumnName;
if (CurrentViewProp != null && CurrentViewProp.Width != Int32.MinValue)
{
thisColumn.HeaderStyle.Width = Unit.Parse((CswConvert.ToInt32(CurrentViewProp.Width * 7)).ToString() + "px"); // average pixel width per character
}
//thisColumn.OrderIndex = CurrentViewProp.Order;
//Telerik.Web.UI.GridTableView GTV = new GridTableView( _Grid );
if (CurrentViewProp != null && CurrentViewProp.Order > 0 && _Grid.Columns.Count >= CurrentViewProp.Order)
{
_Grid.Columns.AddAt(CurrentViewProp.Order, thisColumn);
}
else
{
_Grid.Columns.Add(thisColumn);
}
}
}
}
// Delete column
GridBoundColumn DeleteColumn = new GridBoundColumn();
DeleteColumn.UniqueName = "DeleteColumn";
DeleteColumn.HeaderText = "Delete";
DeleteColumn.DataField = "Delete";
DeleteColumn.Display = ShowActionColumns;
_Grid.Columns.Add(DeleteColumn);
} // setupGridColumns()
private static CswNbtNodePropWrapper _makeNodeProp(CswNbtResources CswNbtResources, CswNbtNodePropData CswNbtNodePropData, CswNbtMetaDataNodeTypeProp CswNbtMetaDataNodeTypeProp, CswNbtNode Node)
{
CswNbtNodePropWrapper ReturnVal = null;
CswNbtNodeProp InnerProperty = null;
CswEnumNbtFieldType FieldType = CswNbtMetaDataNodeTypeProp.getFieldTypeValue();
switch (FieldType)
{
case CswEnumNbtFieldType.Barcode:
InnerProperty = new CswNbtNodePropBarcode(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Button:
InnerProperty = new CswNbtNodePropButton(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.CASNo:
InnerProperty = new CswNbtNodePropCASNo(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.ChildContents:
InnerProperty = new CswNbtNodePropChildContents(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Comments:
InnerProperty = new CswNbtNodePropComments(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Composite:
InnerProperty = new CswNbtNodePropComposite(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.DateTime:
InnerProperty = new CswNbtNodePropDateTime(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.File:
InnerProperty = new CswNbtNodePropBlob(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Formula:
InnerProperty = new CswNbtNodePropFormula(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Grid:
InnerProperty = new CswNbtNodePropGrid(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Image:
InnerProperty = new CswNbtNodePropImage(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.ImageList:
InnerProperty = new CswNbtNodePropImageList(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Link:
InnerProperty = new CswNbtNodePropLink(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.List:
InnerProperty = new CswNbtNodePropList(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Location:
InnerProperty = new CswNbtNodePropLocation(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Logical:
InnerProperty = new CswNbtNodePropLogical(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.LogicalSet:
InnerProperty = new CswNbtNodePropLogicalSet(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.MetaDataList:
InnerProperty = new CswNbtNodePropMetaDataList(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Memo:
InnerProperty = new CswNbtNodePropMemo(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.MOL:
InnerProperty = new CswNbtNodePropMol(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.MTBF:
InnerProperty = new CswNbtNodePropMTBF(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
//case CswEnumNbtFieldType.MultiRelationship:
// InnerProperty = new CswNbtNodePropMultiRelationship( CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node );
// break;
case CswEnumNbtFieldType.MultiList:
//! As part of CIS-53434, remove this if statement.
if (CswNbtMetaDataNodeTypeProp.PropName == CswNbtObjClassRole.PropertyName.NodeTypePermissions)
{
InnerProperty = new CswNbtNodePropPermission(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
}
else
{
InnerProperty = new CswNbtNodePropMultiList(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
}
break;
case CswEnumNbtFieldType.NFPA:
InnerProperty = new CswNbtNodePropNFPA(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.NodeTypeSelect:
InnerProperty = new CswNbtNodePropNodeTypeSelect(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Number:
InnerProperty = new CswNbtNodePropNumber(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.NumericRange:
InnerProperty = new CswNbtNodePropNumericRange(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Password:
InnerProperty = new CswNbtNodePropPassword(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Permission:
InnerProperty = new CswNbtNodePropPermission(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.PropertyReference:
InnerProperty = new CswNbtNodePropPropertyReference(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Quantity:
InnerProperty = new CswNbtNodePropQuantity(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Question:
InnerProperty = new CswNbtNodePropQuestion(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Relationship:
InnerProperty = new CswNbtNodePropRelationship(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.ReportLink:
InnerProperty = new CswNbtNodePropReportLink(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Scientific:
InnerProperty = new CswNbtNodePropScientific(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Sequence:
InnerProperty = new CswNbtNodePropSequence(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Static:
InnerProperty = new CswNbtNodePropStatic(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.Text:
InnerProperty = new CswNbtNodePropText(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.TimeInterval:
InnerProperty = new CswNbtNodePropTimeInterval(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.UserSelect:
InnerProperty = new CswNbtNodePropUserSelect(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.ViewPickList:
InnerProperty = new CswNbtNodePropViewPickList(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
case CswEnumNbtFieldType.ViewReference:
InnerProperty = new CswNbtNodePropViewReference(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node);
break;
default:
throw new CswDniException(CswEnumErrorType.Error, "Internal System Error", "There is no CswNbtNodeProp Object for Field Type: " + FieldType.ToString());
}
ReturnVal = new CswNbtNodePropWrapper(CswNbtResources, Node, InnerProperty, CswNbtNodePropData);
return(ReturnVal);
} //makeNodeProp()
public SystemViewPropFilterDefinition makeSystemViewFilter(ICswNbtMetaDataProp ObjectClassProp, string FilterValue, CswEnumNbtFilterMode FilterMode, CswEnumNbtSubFieldName SubFieldName = null, CswEnumNbtFieldType FieldType = null, bool ShowInGrid = true)
{
SubFieldName = SubFieldName ?? ObjectClassProp.getFieldTypeRule().SubFields.Default.Name;
return(new SystemViewPropFilterDefinition
{
ObjectClassProp = ObjectClassProp,
FilterValue = FilterValue,
FilterMode = FilterMode,
SubFieldName = SubFieldName,
FieldType = FieldType,
ShowInGrid = ShowInGrid
});
}
public static ICswNbtFieldTypeRule makeRule(CswNbtFieldResources CswNbtFieldResources, CswEnumNbtFieldType FieldType)
{
ICswNbtFieldTypeRule ReturnVal = null;
//CswNbtFieldResources CswNbtFieldResources = new CswNbtFieldResources( CswNbtResources );
switch (FieldType)
{
case CswEnumNbtFieldType.Barcode:
ReturnVal = new CswNbtFieldTypeRuleBarCode(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Button:
ReturnVal = new CswNbtFieldTypeRuleButton(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.CASNo:
ReturnVal = new CswNbtFieldTypeRuleCASNo(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.ChildContents:
ReturnVal = new CswNbtFieldTypeRuleChildContents(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Comments:
ReturnVal = new CswNbtFieldTypeRuleComments(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Composite:
ReturnVal = new CswNbtFieldTypeRuleComposite(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.DateTime:
ReturnVal = new CswNbtFieldTypeRuleDateTime(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.External:
ReturnVal = new CswNbtFieldTypeRuleExternal(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.File:
ReturnVal = new CswNbtFieldTypeRuleBlob(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Formula:
ReturnVal = new CswNbtFieldTypeRuleFormula(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Grid:
ReturnVal = new CswNbtFieldTypeRuleGrid(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Image:
ReturnVal = new CswNbtFieldTypeRuleImage(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.ImageList:
ReturnVal = new CswNbtFieldTypeRuleImageList(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Link:
ReturnVal = new CswNbtFieldTypeRuleLink(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.List:
ReturnVal = new CswNbtFieldTypeRuleList(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Location:
ReturnVal = new CswNbtFieldTypeRuleLocation(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Logical:
ReturnVal = new CswNbtFieldTypeRuleLogical(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.LogicalSet:
ReturnVal = new CswNbtFieldTypeRuleLogicalSet(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.MetaDataList:
ReturnVal = new CswNbtFieldTypeRuleMetaDataList(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Memo:
ReturnVal = new CswNbtFieldTypeRuleMemo(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.MOL:
ReturnVal = new CswNbtFieldTypeRuleMol(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.MTBF:
ReturnVal = new CswNbtFieldTypeRuleMTBF(CswNbtFieldResources);
break;
//case CswEnumNbtFieldType.MultiRelationship:
// ReturnVal = new CswNbtFieldTypeRuleMultiRelationship( CswNbtFieldResources );
// break;
case CswEnumNbtFieldType.MultiList:
ReturnVal = new CswNbtFieldTypeRuleMultiList(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.NFPA:
ReturnVal = new CswNbtFieldTypeRuleNFPA(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.NodeTypeSelect:
ReturnVal = new CswNbtFieldTypeRuleNodeTypeSelect(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Number:
ReturnVal = new CswNbtFieldTypeRuleNumber(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.NumericRange:
ReturnVal = new CswNbtFieldTypeRuleNumericRange(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Password:
ReturnVal = new CswNbtFieldTypeRulePassword(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Permission:
ReturnVal = new CswNbtFieldTypeRulePermission(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.PropertyReference:
ReturnVal = new CswNbtFieldTypeRulePropertyReference(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Quantity:
ReturnVal = new CswNbtFieldTypeRuleQuantity(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Question:
ReturnVal = new CswNbtFieldTypeRuleQuestion(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Relationship:
ReturnVal = new CswNbtFieldTypeRuleRelationship(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.ReportLink:
ReturnVal = new CswNbtFieldTypeRuleReportLink(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Scientific:
ReturnVal = new CswNbtFieldTypeRuleScientific(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Sequence:
ReturnVal = new CswNbtFieldTypeRuleSequence(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Static:
ReturnVal = new CswNbtFieldTypeRuleStatic(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.Text:
ReturnVal = new CswNbtFieldTypeRuleText(CswNbtFieldResources);
break;
//case CswEnumNbtFieldType.Time:
// ReturnVal = new CswNbtFieldTypeRuleTime( CswNbtFieldResources );
// break;
case CswEnumNbtFieldType.TimeInterval:
ReturnVal = new CswNbtFieldTypeRuleTimeInterval(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.UserSelect:
ReturnVal = new CswNbtFieldTypeRuleUserSelect(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.ViewPickList:
ReturnVal = new CswNbtFieldTypeRuleViewPickList(CswNbtFieldResources);
break;
case CswEnumNbtFieldType.ViewReference:
ReturnVal = new CswNbtFieldTypeRuleViewReference(CswNbtFieldResources);
break;
default:
throw (new CswDniException("There is no field rule class for field type " + FieldType.ToString()));
//break;
}//switch
return(ReturnVal);
} //makeRule()
private void _addSystemViewPropFilter(CswEnumNbtObjectClass ObjectClass, string PropertyName, object FilterValue, CswEnumNbtFilterMode FilterMode = null, CswEnumNbtFieldType FieldType = null)
{
if (ObjectClass != CswNbtResources.UnknownEnum)
{
FilterMode = FilterMode ?? CswEnumNbtFilterMode.Contains;
CswNbtMetaDataObjectClass InstanceOc = _CswNbtResources.MetaData.getObjectClass(ObjectClass);
if (null != InstanceOc)
{
CswNbtMetaDataObjectClassProp InstancePropertyOcp = InstanceOc.getObjectClassProp(PropertyName);
if (null != InstancePropertyOcp)
{
string FilterValueString = CswConvert.ToString(FilterValue);
CswNbtActSystemViews.SystemViewPropFilterDefinition ViewPropertyFilter = _NbtSystemView.makeSystemViewFilter(InstancePropertyOcp, FilterValueString, FilterMode, FieldType: FieldType);
_NbtSystemView.addSystemViewFilter(ViewPropertyFilter, InstanceOc);
}
}
}
} // _addSystemViewPropFilter()
} // _addSystemViewPropFilter()
private void _addSystemViewBarcodeFilter(object FilterValue, CswEnumNbtFilterMode FilterMode = null, CswEnumNbtFieldType FieldType = null)
{
FilterMode = FilterMode ?? CswEnumNbtFilterMode.Contains;
foreach (CswNbtViewRelationship RootLevelRelationship in _NbtSystemView.SystemView.Root.ChildRelationships)
{
//CswNbtMetaDataObjectClass InstanceOc = null;
//CswNbtMetaDataObjectClassProp BarcodeOcp = null;
//if( NbtViewRelatedIdType.ObjectClassId == RootLevelRelationship.SecondType )
//{
// InstanceOc = _CswNbtResources.MetaData.getObjectClass( RootLevelRelationship.SecondId );
// if( null != InstanceOc )
// {
// BarcodeOcp = (CswNbtMetaDataObjectClassProp) InstanceOc.getBarcodeProperty();
// }
//}
//else if( NbtViewRelatedIdType.NodeTypeId == RootLevelRelationship.SecondType )
//{
// CswNbtMetaDataNodeType InstanceNt = _CswNbtResources.MetaData.getNodeType( RootLevelRelationship.SecondId );
// if( null != InstanceNt )
// {
// InstanceOc = InstanceNt.getObjectClass();
// CswNbtMetaDataNodeTypeProp BarcodeNtp = (CswNbtMetaDataNodeTypeProp) InstanceNt.getBarcodeProperty();
// if( null != BarcodeNtp )
// {
// BarcodeOcp = BarcodeNtp.getObjectClassProp();
// }
// }
//}
//else if( NbtViewRelatedIdType.PropertySetId == RootLevelRelationship.SecondType )
//{
// // Not much we can do...
//}
ICswNbtMetaDataDefinitionObject secondObj = _CswNbtResources.MetaData.getDefinitionObject(RootLevelRelationship.SecondType, RootLevelRelationship.SecondId);
ICswNbtMetaDataProp BarcodeProp = secondObj.getBarcodeProperty();
if (null != BarcodeProp && null != secondObj)
{
string FilterValueString = CswConvert.ToString(FilterValue);
CswNbtActSystemViews.SystemViewPropFilterDefinition ViewPropertyFilter = _NbtSystemView.makeSystemViewFilter(BarcodeProp, FilterValueString, FilterMode, FieldType: FieldType);
_NbtSystemView.addSystemViewFilter(ViewPropertyFilter, secondObj);
}
}
} // _addSystemViewBarcodeFilter()
/// <summary>
/// For loading from XML
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, XmlNode PropNode)
: base(CswNbtResources, View)
{
try
{
if (PropNode.Attributes["type"] != null)
{
Type = PropNode.Attributes["type"].Value;
}
if (PropNode.Attributes["value"] != null) //backwards compatibility
{
if (Type == CswEnumNbtViewPropType.NodeTypePropId)
{
NodeTypePropId = CswConvert.ToInt32(PropNode.Attributes["value"].Value);
}
else
{
ObjectClassPropId = CswConvert.ToInt32(PropNode.Attributes["value"].Value);
}
}
if (PropNode.Attributes["nodetypepropid"] != null)
{
NodeTypePropId = CswConvert.ToInt32(PropNode.Attributes["nodetypepropid"].Value);
}
if (PropNode.Attributes["objectclasspropid"] != null)
{
ObjectClassPropId = CswConvert.ToInt32(PropNode.Attributes["objectclasspropid"].Value);
}
if (PropNode.Attributes["name"] != null)
{
Name = PropNode.Attributes["name"].Value;
}
//if( PropNode.Attributes["arbitraryid"] != null )
// ArbitraryId = PropNode.Attributes["arbitraryid"].Value;
if (PropNode.Attributes["sortby"] != null)
{
SortBy = Convert.ToBoolean(PropNode.Attributes["sortby"].Value);
}
if (PropNode.Attributes["sortmethod"] != null)
{
SortMethod = PropNode.Attributes["sortmethod"].Value;
}
if (PropNode.Attributes["fieldtype"] != null && PropNode.Attributes["fieldtype"].Value != string.Empty)
{
FieldType = CswNbtMetaDataFieldType.getFieldTypeFromString(PropNode.Attributes["fieldtype"].Value);
}
if (PropNode.Attributes["order"] != null && PropNode.Attributes["order"].Value != string.Empty)
{
Order = CswConvert.ToInt32(PropNode.Attributes["order"].Value);
}
if (PropNode.Attributes["width"] != null && PropNode.Attributes["width"].Value != string.Empty)
{
Width = CswConvert.ToInt32(PropNode.Attributes["width"].Value);
}
if (PropNode.Attributes["showingrid"] != null && PropNode.Attributes["showingrid"].Value != string.Empty)
{
ShowInGrid = CswConvert.ToBoolean(PropNode.Attributes["showingrid"].Value);
}
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid attribute value",
ex);
}
try
{
foreach (XmlNode ChildNode in PropNode.ChildNodes)
{
if (ChildNode.Name.ToLower() == CswEnumNbtViewXmlNodeName.Filter.ToString().ToLower())
{
CswNbtViewPropertyFilter Filter = new CswNbtViewPropertyFilter(CswNbtResources, _View, ChildNode);
this.addFilter(Filter);
}
}
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid filter definition",
ex);
}
}
/// <summary>
/// All field types get these attributes
/// </summary>
public Collection <CswNbtFieldTypeAttribute> getAttributes(CswEnumNbtFieldType OwnerFieldType)
{
Collection <CswNbtFieldTypeAttribute> ret = new Collection <CswNbtFieldTypeAttribute>();
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.AuditLevel,
AttributeFieldType = CswEnumNbtFieldType.List,
Column = CswEnumNbtPropertyAttributeColumn.Auditlevel
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.CompoundUnique,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Iscompoundunique
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.DisplayConditionFilterMode,
AttributeFieldType = CswEnumNbtFieldType.List,
Column = CswEnumNbtPropertyAttributeColumn.Filtermode
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.DisplayConditionProperty,
AttributeFieldType = CswEnumNbtFieldType.Relationship,
Column = CswEnumNbtPropertyAttributeColumn.Filterpropid,
SubFieldName = CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.DisplayConditionSubfield,
AttributeFieldType = CswEnumNbtFieldType.List,
Column = CswEnumNbtPropertyAttributeColumn.Filtersubfield
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.DisplayConditionValue,
AttributeFieldType = CswEnumNbtFieldType.Text,
Column = CswEnumNbtPropertyAttributeColumn.Filtervalue
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.FieldType,
AttributeFieldType = CswEnumNbtFieldType.List,
Column = CswEnumNbtPropertyAttributeColumn.Fieldtypeid
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.HelpText,
AttributeFieldType = CswEnumNbtFieldType.Memo,
Column = CswEnumNbtPropertyAttributeColumn.Helptext
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.Hidden,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Hidden
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.NodeTypeValue,
AttributeFieldType = CswEnumNbtFieldType.Relationship,
Column = CswEnumNbtPropertyAttributeColumn.Nodetypeid,
SubFieldName = CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.ObjectClassPropName,
AttributeFieldType = CswEnumNbtFieldType.List,
Column = CswEnumNbtPropertyAttributeColumn.Objectclasspropid
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.PropName,
AttributeFieldType = CswEnumNbtFieldType.Text,
Column = CswEnumNbtPropertyAttributeColumn.Propname
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.QuestionNo,
AttributeFieldType = CswEnumNbtFieldType.Number,
Column = CswEnumNbtPropertyAttributeColumn.Questionno
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.ReadOnly,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Readonly
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.Required,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Isrequired
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.ServerManaged,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Servermanaged
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.SubQuestionNo,
AttributeFieldType = CswEnumNbtFieldType.Number,
Column = CswEnumNbtPropertyAttributeColumn.Subquestionno
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.Unique,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Isunique
});
ret.Add(new CswNbtFieldTypeAttribute(_CswNbtFieldResources.CswNbtResources)
{
OwnerFieldType = OwnerFieldType,
Name = CswEnumNbtPropertyAttributeName.UseNumbering,
AttributeFieldType = CswEnumNbtFieldType.Logical,
Column = CswEnumNbtPropertyAttributeColumn.Usenumbering
});
return(ret);
} // getAttributes()
public CswNbtPropEnmrtrFiltered(Collection <CswNbtNodePropWrapper> PropList, CswEnumNbtFieldType FieldType)
{
_FieldType = FieldType;
_PropList = PropList;
}
/// <summary>
/// For loading from JSON
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, JObject PropObj)
: base(CswNbtResources, View)
{
try
{
string _Type = CswConvert.ToString(PropObj["type"]);
if (!string.IsNullOrEmpty(_Type))
{
Type = _Type;
}
Int32 _Value = CswConvert.ToInt32(PropObj["value"]);
if (Int32.MinValue != _Value) //backwards compatibility
{
if (Type == CswEnumNbtViewPropType.NodeTypePropId)
{
NodeTypePropId = _Value;
}
else
{
ObjectClassPropId = _Value;
}
}
Int32 _NtPropId = CswConvert.ToInt32(PropObj["nodetypepropid"]);
if (Int32.MinValue != _NtPropId)
{
NodeTypePropId = _NtPropId;
}
Int32 _OcPropId = CswConvert.ToInt32(PropObj["objectclasspropid"]);
if (Int32.MinValue != _OcPropId)
{
ObjectClassPropId = _OcPropId;
}
string _Name = CswConvert.ToString(PropObj["name"]);
if (!string.IsNullOrEmpty(_Name))
{
Name = _Name;
}
if (PropObj["sortby"] != null)
{
bool _Sort = CswConvert.ToBoolean(PropObj["sortby"]);
SortBy = _Sort;
}
string _SortedMethod = CswConvert.ToString(PropObj["sortmethod"]);
if (!string.IsNullOrEmpty(_SortedMethod))
{
SortMethod = _SortedMethod;
}
string _FieldType = CswConvert.ToString(PropObj["fieldtype"]);
if (!string.IsNullOrEmpty(_FieldType))
{
FieldType = CswNbtMetaDataFieldType.getFieldTypeFromString(_FieldType);
}
Int32 _Order = CswConvert.ToInt32(PropObj["order"]);
if (Int32.MinValue != _Order)
{
Order = _Order;
}
Int32 _Width = CswConvert.ToInt32(PropObj["width"]);
if (Int32.MinValue != _Width)
{
Width = _Width;
}
ShowInGrid = CswConvert.ToBoolean(PropObj["showingrid"]);
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid attribute value",
ex);
}
try
{
JProperty FiltersProp = PropObj.Property(_FiltersName);
if (null != FiltersProp)
{
JObject FiltersObj = (JObject)FiltersProp.Value;
foreach (CswNbtViewPropertyFilter Filter in
from FilterProp
in FiltersObj.Properties()
select(JObject) FilterProp.Value
into FilterObj
let NodeName = CswConvert.ToString(FilterObj["nodename"])
where NodeName == CswEnumNbtViewXmlNodeName.Filter.ToString().ToLower()
select new CswNbtViewPropertyFilter(CswNbtResources, _View, FilterObj))
{
this.addFilter(Filter);
}
}
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid filter definition",
ex);
}
}
