public void HandleModifyViewFilters(CswNbtView OldView, CswNbtView NewView)
{
Master.HandleModifyViewFilters(OldView, NewView);
}
/// <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);
}
}
public void AddUniqueFilterToView(CswNbtView View, CswNbtViewProperty UniqueValueViewProperty, CswNbtNodePropWrapper PropertyValueToCheck, bool EnforceNullEntries = false)
{
_CswNbtFieldTypeRuleDefault.AddUniqueFilterToView(View, UniqueValueViewProperty, PropertyValueToCheck, EnforceNullEntries);
}
public Collection <CswNbtViewRelationship> getViewChildRelationshipOptions(CswNbtView View, string ArbitraryId)
{
Collection <CswNbtViewRelationship> ret = new Collection <CswNbtViewRelationship>();
if (View.ViewId != null)
{
CswNbtViewNode SelectedViewNode = View.FindViewNodeByArbitraryId(ArbitraryId);
if (View.ViewMode != CswEnumNbtViewRenderingMode.Unknown || View.Root.ChildRelationships.Count == 0)
{
if (SelectedViewNode is CswNbtViewRelationship)
{
CswNbtViewRelationship CurrentRelationship = (CswNbtViewRelationship)SelectedViewNode;
Int32 CurrentLevel = 0;
CswNbtViewNode Parent = CurrentRelationship;
while (!(Parent is CswNbtViewRoot))
{
CurrentLevel++;
Parent = Parent.Parent;
}
// Child options are all relations to this nodetype
Int32 CurrentId = CurrentRelationship.SecondId;
Collection <CswNbtViewRelationship> Relationships = null;
if (CurrentRelationship.SecondType == CswEnumNbtViewRelatedIdType.PropertySetId)
{
Relationships = getPropertySetRelated(CurrentId, View, CurrentLevel);
}
else if (CurrentRelationship.SecondType == CswEnumNbtViewRelatedIdType.ObjectClassId)
{
Relationships = getObjectClassRelated(CurrentId, View, CurrentLevel);
}
else if (CurrentRelationship.SecondType == CswEnumNbtViewRelatedIdType.NodeTypeId)
{
Relationships = getNodeTypeRelated(CurrentId, View, CurrentLevel);
}
foreach (CswNbtViewRelationship R in from CswNbtViewRelationship _R in Relationships orderby _R.SecondName select _R)
{
R.Parent = CurrentRelationship;
string Label = String.Empty;
if (R.PropOwner == CswEnumNbtViewPropOwnerType.First)
{
Label = R.SecondName + " (by " + R.PropName + ")";
}
else if (R.PropOwner == CswEnumNbtViewPropOwnerType.Second)
{
Label = R.SecondName + " (by " + R.SecondName + "'s " + R.PropName + ")";
}
R.TextLabel = Label;
bool contains = ret.Any(existingRel => existingRel.TextLabel == R.TextLabel); //no dupes
if (false == contains)
{
ret.Add(R);
}
} // foreach( CswNbtViewRelationship R in Relationships )
}
}
}
return(ret);
} // getViewChildOptions()
public override void update()
{
CswTableUpdate jctUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "29311_jctddntp_update", "jct_dd_ntp" );
DataTable jctTable = jctUpdate.getEmptyTable();
// Set up Sequence Nodetype
CswNbtMetaDataObjectClass SequenceOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.DesignSequenceClass );
CswNbtMetaDataNodeType SequenceNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeNew( new CswNbtWcfMetaDataModel.NodeType( SequenceOC )
{
NodeTypeName = "Design Sequence",
Category = "Design",
IconFileName = "wrench.png"
} );
//SequenceNT.addNameTemplateText( CswNbtObjClassDesignSequence.PropertyName.Name );
SequenceNT._DataRow["nametemplate"] = CswNbtMetaData.TemplateTextToTemplateValue( SequenceNT.getNodeTypeProps(), CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassDesignSequence.PropertyName.Name ) );
Int32 TabId = SequenceNT.getFirstNodeTypeTab().TabId;
CswNbtMetaDataNodeTypeProp SeqNameNTP = SequenceNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDesignSequence.PropertyName.Name );
CswNbtMetaDataNodeTypeProp SeqNextValueNTP = SequenceNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDesignSequence.PropertyName.NextValue );
CswNbtMetaDataNodeTypeProp SeqPadNTP = SequenceNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDesignSequence.PropertyName.Pad );
CswNbtMetaDataNodeTypeProp SeqPostNTP = SequenceNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDesignSequence.PropertyName.Post );
CswNbtMetaDataNodeTypeProp SeqPreNTP = SequenceNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDesignSequence.PropertyName.Pre );
// Edit Layout
SeqNameNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId, DisplayRow: 1, DisplayColumn: 1 );
SeqPreNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId, DisplayRow: 2, DisplayColumn: 1 );
SeqPostNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId, DisplayRow: 3, DisplayColumn: 1 );
SeqPadNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId, DisplayRow: 4, DisplayColumn: 1 );
SeqNextValueNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId, DisplayRow: 5, DisplayColumn: 1 );
// Add Layout
SeqNameNTP.updateLayout( CswEnumNbtLayoutType.Add, false, Int32.MinValue, DisplayRow: 1, DisplayColumn: 1 );
SeqPreNTP.updateLayout( CswEnumNbtLayoutType.Add, false, Int32.MinValue, DisplayRow: 2, DisplayColumn: 1 );
SeqPostNTP.updateLayout( CswEnumNbtLayoutType.Add, false, Int32.MinValue, DisplayRow: 3, DisplayColumn: 1 );
SeqPadNTP.updateLayout( CswEnumNbtLayoutType.Add, false, Int32.MinValue, DisplayRow: 4, DisplayColumn: 1 );
SeqNextValueNTP.removeFromLayout( CswEnumNbtLayoutType.Add );
// Populate nodes
// Very important that this happens BEFORE we map to the nodetypes table, or else we'll end up duplicating rows!
Dictionary<Int32, CswNbtObjClassDesignSequence> SequenceNodeMap = new Dictionary<int, CswNbtObjClassDesignSequence>();
CswTableSelect SequencesTableSelect = _CswNbtSchemaModTrnsctn.makeCswTableSelect( "29311_sequencetable_select", "sequences" );
DataTable SequencesTable = SequencesTableSelect.getTable();
foreach( DataRow SeqRow in SequencesTable.Rows )
{
CswNbtObjClassDesignSequence node = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( SequenceNT.NodeTypeId, OverrideUniqueValidation: true, OnAfterMakeNode: delegate( CswNbtNode NewNode )
{
CswNbtObjClassDesignSequence NewSeqNode = NewNode;
NewSeqNode.Name.Text = SeqRow["sequencename"].ToString();
NewSeqNode.Pad.Value = CswConvert.ToInt32( SeqRow["pad"] );
NewSeqNode.Post.Text = SeqRow["post"].ToString();
NewSeqNode.Pre.Text = SeqRow["prep"].ToString();
} );
node.RelationalId = new CswPrimaryKey( "sequences", CswConvert.ToInt32( SeqRow["sequenceid"] ) );
node.postChanges( false );
SequenceNodeMap.Add( node.RelationalId.PrimaryKey, node );
}
// Here's where the extra special super-secret magic comes in
//SequenceNT.TableName = "sequences";
SequenceNT._DataRow["tablename"] = "sequences";
_addJctRow( jctTable, SeqNameNTP, SequenceNT.TableName, "sequencename" );
_addJctRow( jctTable, SeqPadNTP, SequenceNT.TableName, "pad" );
_addJctRow( jctTable, SeqPostNTP, SequenceNT.TableName, "post" );
_addJctRow( jctTable, SeqPreNTP, SequenceNT.TableName, "prep" );
jctUpdate.update( jctTable );
// Set up existing relationships to sequences
Dictionary<Int32, CswNbtObjClassDesignSequence> SequenceValueMap = new Dictionary<Int32, CswNbtObjClassDesignSequence>();
string Sql = @"select n.nodeid, r.sequenceid
from nodetype_props p
join nodetypes t on p.nodetypeid = t.nodetypeid
join nodes n on t.nodetypeid = n.nodetypeid
join nodetype_props r on n.relationalid = r.nodetypepropid
where p.propname = 'Sequence' and t.nodetypename like 'Design%'";
CswArbitrarySelect ExistingSequenceIdSelect = _CswNbtSchemaModTrnsctn.makeCswArbitrarySelect( "getExistingSequenceIds", Sql );
DataTable ExistingSequenceIdTable = ExistingSequenceIdSelect.getTable();
foreach( DataRow row in ExistingSequenceIdTable.Rows )
{
Int32 thisSeqId = CswConvert.ToInt32( row["sequenceid"] );
if( Int32.MinValue != thisSeqId && SequenceNodeMap.ContainsKey( thisSeqId ) )
{
SequenceValueMap.Add( CswConvert.ToInt32( row["nodeid"] ), SequenceNodeMap[thisSeqId] );
}
}
foreach( CswEnumNbtFieldType ft in new CswEnumNbtFieldType[] { CswEnumNbtFieldType.Barcode, CswEnumNbtFieldType.Sequence } )
{
CswNbtMetaDataNodeType PropNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( CswNbtObjClassDesignNodeTypeProp.getNodeTypeName( ft ) );
//CswNbtFieldTypeRuleSequence Rule = (CswNbtFieldTypeRuleSequence) _CswNbtSchemaModTrnsctn.MetaData.getFieldTypeRule( ft );
//CswNbtFieldTypeAttribute SequenceAttribute = Rule.getAttributes().FirstOrDefault( a => a.Name == CswEnumNbtPropertyAttributeName.Sequence );
CswNbtMetaDataNodeTypeProp SequenceNTP = PropNT.getNodeTypeProp( CswEnumNbtPropertyAttributeName.Sequence );
SequenceNTP.SetFKDeprecated( CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(), SequenceOC.ObjectClassId );
CswNbtViewId ViewId = SequenceNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRuleRelationship.AttributeName.View].AsViewReference.ViewId;
CswNbtView View = _CswNbtSchemaModTrnsctn.ViewSelect.restoreView( ViewId );
CswNbtFieldTypeRuleDefaultImpl.setDefaultView( _CswNbtSchemaModTrnsctn.MetaData, SequenceNTP.DesignNode, View, CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(), SequenceOC.ObjectClassId, false );
foreach( CswNbtObjClassDesignNodeTypeProp PropNode in PropNT.getNodes( false, true ) )
{
if( SequenceValueMap.ContainsKey( PropNode.NodeId.PrimaryKey ) )
{
CswNbtObjClassDesignSequence SeqNode = SequenceValueMap[PropNode.NodeId.PrimaryKey];
if( null != SeqNode )
{
PropNode.Node.Properties[SequenceNTP].AsRelationship.RelatedNodeId = SeqNode.NodeId;
PropNode.postChanges( false );
}
}
}
} // foreach( CswEnumNbtFieldType ft in new CswEnumNbtFieldType[] {CswEnumNbtFieldType.Barcode, CswEnumNbtFieldType.Sequence} )
} // update()
protected void _populatePropsCollection(CswNbtViewRelationship relationship, CswNbtView TempView, Collection <CswNbtViewProperty> Props,
HashSet <string> seenProps, bool UseMetaName = false, bool overrideFirst = false, bool DoCheck = true)
{
CswEnumNbtViewRelatedIdType type;
Int32 Id;
if (relationship.PropOwner == CswEnumNbtViewPropOwnerType.First && Int32.MinValue != relationship.FirstId && false == overrideFirst)
{
type = relationship.FirstType;
Id = relationship.FirstId;
}
else
{
type = relationship.SecondType;
Id = relationship.SecondId;
}
if (type.Equals(CswEnumNbtViewRelatedIdType.NodeTypeId))
{
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(Id);
if (null != NodeType)
{
Collection <CswNbtViewProperty> props = _getProps(NodeType, TempView, seenProps, relationship, DoCheck);
foreach (CswNbtViewProperty vp in props)
{
if (UseMetaName)
{
vp.TextLabel = NodeType.NodeTypeName + "'s " + vp.MetaDataProp.PropName;
}
if (false == DoCheck && false == seenProps.Contains(vp.TextLabel) || DoCheck)
{
seenProps.Add(vp.TextLabel);
Props.Add(vp);
}
}
}
}
else if (type.Equals(CswEnumNbtViewRelatedIdType.ObjectClassId))
{
CswNbtMetaDataObjectClass ObjClass = _CswNbtResources.MetaData.getObjectClass(Id);
if (null != ObjClass)
{
Collection <CswNbtViewProperty> props = _getProps(ObjClass, TempView, seenProps, relationship, DoCheck);
foreach (CswNbtViewProperty vp in props)
{
if (UseMetaName)
{
vp.TextLabel = ObjClass.ObjectClass.Value + "'s " + vp.MetaDataProp.PropName;
}
Props.Add(vp);
}
}
}
else if (type.Equals(CswEnumNbtViewRelatedIdType.PropertySetId))
{
CswNbtMetaDataPropertySet PropSet = _CswNbtResources.MetaData.getPropertySet(Id);
if (null != PropSet)
{
foreach (CswNbtMetaDataObjectClass ObjClass in PropSet.getObjectClasses())
{
Collection <CswNbtViewProperty> props = _getProps(ObjClass, TempView, seenProps, relationship, DoCheck);
foreach (CswNbtViewProperty vp in props)
{
if (UseMetaName)
{
vp.TextLabel = ObjClass.ObjectClass.Value + "'s " + vp.MetaDataProp.PropName;
}
Props.Add(vp);
}
}
}
}
}
protected Collection <CswNbtViewProperty> _getProps(CswNbtMetaDataNodeType NodeType, CswNbtView TempView, HashSet <string> seenProps, CswNbtViewRelationship Relationship, bool DoCheck = true)
{
Collection <CswNbtViewProperty> Props = new Collection <CswNbtViewProperty>();
foreach (CswNbtMetaDataNodeTypeProp ntp in NodeType.getNodeTypeProps().OrderBy(Prop => Prop.PropName))
{
if (ntp.getFieldTypeRule().SearchAllowed ||
ntp.getFieldTypeValue() == CswEnumNbtFieldType.Button && false == ntp.IsSaveProp)
{
CswNbtViewProperty viewProp = TempView.AddViewProperty(Relationship, ntp);
if (false == DoCheck)
{
Props.Add(viewProp);
}
else if (false == seenProps.Contains(viewProp.TextLabel))
{
seenProps.Add(viewProp.TextLabel);
Props.Add(viewProp);
}
}
}
return(Props);
}
public override void update()
{
CswNbtMetaDataObjectClass MailReportGroupOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.MailReportGroupClass);
CswNbtObjClassMailReportGroup DemoMailReports = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(MailReportGroupOC.FirstNodeType.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassMailReportGroup DemoMailReportNode = NewNode;
DemoMailReportNode.IsDemo = true;
DemoMailReportNode.Name.Text = "Demo Mail Reports";
});
CswNbtMetaDataObjectClass MailReportOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.MailReportClass);
foreach (CswNbtObjClassMailReport MailReportNode in MailReportOC.getNodes(false, false, false, true))
{
if (MailReportNode.IsDemo)
{
MailReportNode.MailReportGroup.RelatedNodeId = DemoMailReports.NodeId;
MailReportNode.postChanges(false);
}
}
CswNbtMetaDataObjectClass MailReportGroupPermissionOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.MailReportGroupPermissionClass);
CswNbtMetaDataObjectClass RoleOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.RoleClass);
foreach (CswNbtObjClassRole RoleNode in RoleOC.getNodes(false, false, false, true))
{
if (RoleNode.Administrator.Checked == CswEnumTristate.True)
{
CswNbtObjClassMailReportGroupPermission DemoMailReportGroupPerm = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(MailReportGroupPermissionOC.FirstNodeType.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassMailReportGroupPermission DemoMailReportPermNode = NewNode;
DemoMailReportPermNode.Role.RelatedNodeId = RoleNode.NodeId;
DemoMailReportPermNode.ApplyToAllWorkUnits.Checked = CswEnumTristate.True;
DemoMailReportPermNode.PermissionGroup.RelatedNodeId = DemoMailReports.NodeId;
DemoMailReportPermNode.View.Checked = CswEnumTristate.True;
DemoMailReportPermNode.Edit.Checked = CswEnumTristate.True;
});
}
}
CswNbtObjClassMailReportGroup DefaultMailReportGroup = null;
foreach (CswNbtObjClassMailReportGroup MailReportGroupNode in MailReportGroupOC.getNodes(false, false, false, true))
{
if (MailReportGroupNode.Name.Text == "Default Mail Report Group")
{
DefaultMailReportGroup = MailReportGroupNode;
}
}
CswNbtView MyExpiringContainersView = _CswNbtSchemaModTrnsctn.restoreView("My Expiring Containers");
if (null != MyExpiringContainersView && null != DefaultMailReportGroup)
{
CswNbtObjClassMailReport MyExpiringContainersReport = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(MailReportOC.FirstNodeType.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassMailReport MyExpiringContainersReportNode = NewNode;
MyExpiringContainersReportNode.Name.Text = "My Expiring Containers";
MyExpiringContainersReportNode.Type.Value = CswNbtObjClassMailReport.TypeOptionView;
MyExpiringContainersReportNode.Event.Value = "Edit";
MyExpiringContainersReportNode.MailReportGroup.RelatedNodeId = DefaultMailReportGroup.NodeId;
MyExpiringContainersReportNode.Message.Text = "The following containers will be expiring soon: ";
MyExpiringContainersReportNode.Enabled.Checked = CswEnumTristate.False;
CswNbtView MyExpContMRView = _CswNbtSchemaModTrnsctn.makeView();
MyExpContMRView.saveNew("My Expiring Containers", CswEnumNbtViewVisibility.Hidden, CopyViewId: MyExpiringContainersView.ViewId.get());
MyExpiringContainersReportNode.ReportView.ViewId = MyExpContMRView.ViewId;
CswRateInterval DailyRate = _CswNbtSchemaModTrnsctn.makeRateInterval();
DailyRate.setHourly(24, DateTime.Today);
MyExpiringContainersReportNode.DueDateInterval.RateInterval = DailyRate;
});
}
}
public override void update()
{
// CISPro Report Group (created in CswUpdateSchema_02H_28562C) should only be accessible to CISPro roles
CswNbtMetaDataObjectClass ReportGroupOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ReportGroupClass );
CswNbtMetaDataObjectClass PermissionOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ReportGroupPermissionClass );
CswNbtMetaDataObjectClass RoleOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RoleClass );
CswNbtMetaDataObjectClassProp GroupNameOCP = ReportGroupOC.getObjectClassProp( CswNbtObjClassReportGroup.PropertyName.Name );
CswNbtMetaDataObjectClassProp PermissionGroupOCP = PermissionOC.getObjectClassProp( CswNbtObjClassReportGroupPermission.PropertyName.PermissionGroup );
CswNbtMetaDataObjectClassProp RoleNameOCP = RoleOC.getObjectClassProp( CswNbtObjClassRole.PropertyName.Name );
// Delete existing (default) permissions
CswNbtView View = _CswNbtSchemaModTrnsctn.makeView();
CswNbtViewRelationship Rel1 = View.AddViewRelationship( ReportGroupOC, false );
View.AddViewPropertyAndFilter( Rel1, GroupNameOCP, Value: "CISPro Report Group", FilterMode: CswEnumNbtFilterMode.Equals );
CswNbtViewRelationship Rel2 = View.AddViewRelationship( Rel1, CswEnumNbtViewPropOwnerType.Second, PermissionGroupOCP, false );
ICswNbtTree results = _CswNbtSchemaModTrnsctn.getTreeFromView( View, true );
CswNbtObjClassReportGroup CISProGroup = null;
for( Int32 g = 0; g < results.getChildNodeCount(); g++ )
{
results.goToNthChild( g );
CISProGroup = results.getNodeForCurrentPosition();
for( Int32 p = 0; p < results.getChildNodeCount(); p++ )
{
results.goToNthChild( p );
CswNbtNode PermNode = results.getNodeForCurrentPosition();
PermNode.delete( false, true );
results.goToParentNode();
}
results.goToParentNode();
} // for( Int32 g = 0; g < results.getChildNodeCount(); g++ )
if( null != CISProGroup )
{
// Get all cispro roles
CswNbtView rolesView = _CswNbtSchemaModTrnsctn.makeView();
CswNbtViewRelationship parent = rolesView.AddViewRelationship( RoleOC, false );
rolesView.AddViewPropertyAndFilter( parent,
MetaDataProp: RoleNameOCP,
SubFieldName: CswEnumNbtSubFieldName.Text,
FilterMode: CswEnumNbtFilterMode.Contains,
Value: "cispro" );
rolesView.AddViewPropertyAndFilter( parent,
Conjunction: CswEnumNbtFilterConjunction.Or,
MetaDataProp: RoleNameOCP,
SubFieldName: CswEnumNbtSubFieldName.Text,
FilterMode: CswEnumNbtFilterMode.Equals,
Value: "Administrator" );
rolesView.AddViewPropertyAndFilter( parent,
Conjunction: CswEnumNbtFilterConjunction.Or,
MetaDataProp: RoleNameOCP,
SubFieldName: CswEnumNbtSubFieldName.Text,
FilterMode: CswEnumNbtFilterMode.Equals,
Value: CswNbtObjClassRole.ChemSWAdminRoleName );
ICswNbtTree rolesTree = _CswNbtSchemaModTrnsctn.getTreeFromView( rolesView, true );
Collection<CswPrimaryKey> CISProRoleIds = new Collection<CswPrimaryKey>();
for( int i = 0; i < rolesTree.getChildNodeCount(); i++ )
{
rolesTree.goToNthChild( i );
CISProRoleIds.Add( rolesTree.getNodeIdForCurrentPosition() );
rolesTree.goToParentNode();
}
// Grant permission to all cispro roles
CswNbtMetaDataNodeType PermissionNT = PermissionOC.FirstNodeType;
if( null != PermissionNT )
{
foreach( CswPrimaryKey RoleId in CISProRoleIds )
{
_CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( PermissionNT.NodeTypeId, delegate( CswNbtNode NewNode )
{
CswNbtPropertySetPermission NewPermission = NewNode;
NewPermission.ApplyToAllRoles.Checked = CswEnumTristate.False;
NewPermission.ApplyToAllWorkUnits.Checked = CswEnumTristate.True;
NewPermission.PermissionGroup.RelatedNodeId = CISProGroup.NodeId;
NewPermission.View.Checked = CswEnumTristate.True;
NewPermission.Edit.Checked = CswEnumTristate.True;
NewPermission.Role.RelatedNodeId = RoleId;
} );
}
}
} // if( null != CISProGroup )
} // update()
public CswNbtWebServiceGrid(CswNbtResources CswNbtResources, CswNbtView View, bool ForReport, CswNbtNodeKey ParentNodeKey = null)
{
_CswNbtResources = CswNbtResources;
_View = View;
_ForReport = ForReport;
if (_View.ViewMode != CswEnumNbtViewRenderingMode.Grid)
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot create a grid using a view type of " + _View.ViewMode, "Cannot create a grid view if the view is not a grid.");
}
_ParentNodeKey = ParentNodeKey;
Collection <CswNbtViewRelationship> FirstLevelRelationships = new Collection <CswNbtViewRelationship>();
if (null != _ParentNodeKey && _View.Visibility == CswEnumNbtViewVisibility.Property)
{
foreach (CswNbtViewRelationship Relationship in _View.Root.ChildRelationships.SelectMany(NodeRelationship => NodeRelationship.ChildRelationships))
{
FirstLevelRelationships.Add(Relationship);
}
}
else
{
FirstLevelRelationships = _View.Root.ChildRelationships;
}
// Case 21778
// Maybe do this in Permit someday; however, the meaning of Edit and Delete is very specific in this context:
// only evaluating visibility of the option to edit or delete root nodetypes of a view
foreach (CswNbtViewRelationship Relationship in FirstLevelRelationships)
{
Collection <CswNbtMetaDataNodeType> FirstLevelNodeTypes = new Collection <CswNbtMetaDataNodeType>();
if (Relationship.SecondId != Int32.MinValue)
{
if (Relationship.SecondType == CswEnumNbtViewRelatedIdType.PropertySetId)
{
foreach (CswNbtMetaDataObjectClass SecondOc in _CswNbtResources.MetaData.getObjectClassesByPropertySetId(Relationship.SecondId))
{
if (null != SecondOc)
{
foreach (CswNbtMetaDataNodeType NT in SecondOc.getNodeTypes())
{
FirstLevelNodeTypes.Add(NT);
}
}
}
}
else if (Relationship.SecondType == CswEnumNbtViewRelatedIdType.ObjectClassId)
{
CswNbtMetaDataObjectClass SecondOc = _CswNbtResources.MetaData.getObjectClass(Relationship.SecondId);
if (null != SecondOc)
{
foreach (CswNbtMetaDataNodeType NT in SecondOc.getNodeTypes())
{
FirstLevelNodeTypes.Add(NT);
}
}
}
else if (Relationship.SecondType == CswEnumNbtViewRelatedIdType.NodeTypeId)
{
CswNbtMetaDataNodeType SecondNt = _CswNbtResources.MetaData.getNodeType(Relationship.SecondId);
if (null != SecondNt)
{
FirstLevelNodeTypes.Add(SecondNt);
}
}
} // if( Relationship.SecondId != Int32.MinValue )
foreach (CswNbtMetaDataNodeType NodeType in FirstLevelNodeTypes)
{
_NodeTypePermission Permission = new _NodeTypePermission(NodeType, _CswNbtResources);
_ActionEnabled = false == _ForReport &&
(_ActionEnabled || Permission.CanView || Permission.CanDelete || Permission.CanDelete);
if (false == _Permissions.ContainsKey(NodeType.FirstVersionNodeTypeId))
{
_Permissions.Add(NodeType.FirstVersionNodeTypeId, Permission);
}
}
}
_CswNbtGrid = new CswNbtGrid(_CswNbtResources);
_PropsInGrid = new Collection <CswViewBuilderProp>();
_getGridProperties(_View.Root.ChildRelationships, _PropsInGrid);
} //ctor
}//Update()
private void makeRequestGridView( CswNbtView GridView, CswNbtMetaDataNodeType RootNt )
{
CswNbtMetaDataObjectClass RequestOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RequestClass );
CswNbtMetaDataNodeType RequestNt = RequestOc.getLatestVersionNodeTypes().FirstOrDefault();
if( null == RequestNt )
{
CswStatusMessage Msg = new CswStatusMessage
{
AppType = AppType.SchemUpdt,
ContentType = ContentType.Error
};
Msg.Attributes.Add( ChemSW.Log.LegalAttribute.exoteric_message, "Could not get a Request NodeType" );
_CswNbtSchemaModTrnsctn.CswLogger.send( Msg );
}
else
{
CswNbtMetaDataNodeTypeProp NameNtp =
RequestNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.Name.ToString() );
CswNbtMetaDataNodeTypeProp SubmittedDateNtp =
RequestNt.getNodeTypePropByObjectClassProp(
CswNbtObjClassRequest.PropertyName.SubmittedDate.ToString() );
CswNbtMetaDataNodeTypeProp CompletedDateNtpNtp =
RequestNt.getNodeTypePropByObjectClassProp(
CswNbtObjClassRequest.PropertyName.CompletedDate.ToString() );
CswNbtMetaDataNodeTypeProp RequestorNtp =
RequestNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.Requestor.ToString() );
CswNbtMetaDataObjectClass RequestItemOc =
_CswNbtSchemaModTrnsctn.MetaData.getObjectClass(
CswNbtMetaDataObjectClass.NbtObjectClass.RequestItemClass );
CswNbtMetaDataNodeType RequestItemNt = RequestItemOc.getLatestVersionNodeTypes().FirstOrDefault();
if( null == RequestItemNt )
{
CswStatusMessage Msg = new CswStatusMessage
{
AppType = AppType.SchemUpdt,
ContentType = ContentType.Error
};
Msg.Attributes.Add( ChemSW.Log.LegalAttribute.exoteric_message, "Could not get a Request Item NodeType" );
_CswNbtSchemaModTrnsctn.CswLogger.send( Msg );
}
else
{
CswNbtMetaDataNodeTypeProp TypeNtp =
RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Type );
CswNbtMetaDataNodeTypeProp StatusNtp =
RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Status );
CswNbtMetaDataNodeTypeProp ExternalOrderNoNtp =
RequestItemNt.getNodeTypePropByObjectClassProp(
CswNbtObjClassRequestItem.PropertyName.ExternalOrderNumber );
CswNbtMetaDataNodeTypeProp NumberNtp =
RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Number );
GridView.Root.ChildRelationships.Clear();
GridView.ViewName = RootNt.NodeTypeName + " Requested Items";
GridView.Visibility = NbtViewVisibility.Property;
GridView.ViewMode = NbtViewRenderingMode.Grid;
GridView.Category = "Requests";
CswNbtViewRelationship RootRel = GridView.AddViewRelationship( RootNt, false );
CswNbtMetaDataNodeTypeProp RelationshipToRootNtp = null;
switch( RootNt.getObjectClass().ObjectClass )
{
case CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass:
RelationshipToRootNtp =
RequestItemNt.getNodeTypePropByObjectClassProp(
CswNbtObjClassRequestItem.PropertyName.Material );
break;
case CswNbtMetaDataObjectClass.NbtObjectClass.ContainerClass:
RelationshipToRootNtp =
RequestItemNt.getNodeTypePropByObjectClassProp(
CswNbtObjClassRequestItem.PropertyName.Container );
break;
default:
CswStatusMessage Msg = new CswStatusMessage
{
AppType = AppType.SchemUpdt,
ContentType = ContentType.Error
};
Msg.Attributes.Add( ChemSW.Log.LegalAttribute.exoteric_message, "Request grids of this type are not supported." );
_CswNbtSchemaModTrnsctn.CswLogger.send( Msg );
break;
}
if( null != RelationshipToRootNtp )
{
CswNbtViewRelationship RequestItemRel = GridView.AddViewRelationship( RootRel,
NbtViewPropOwnerType.Second,
RelationshipToRootNtp,
false );
CswNbtMetaDataNodeTypeProp RiRequestNtp =
RequestItemNt.getNodeTypePropByObjectClassProp(
CswNbtObjClassRequestItem.PropertyName.Request );
CswNbtViewRelationship RequestRel = GridView.AddViewRelationship( RequestItemRel,
NbtViewPropOwnerType.First,
RiRequestNtp, false );
CswNbtViewProperty CompletedVp = GridView.AddViewProperty( RequestRel, CompletedDateNtpNtp );
CompletedVp.Order = 3;
CompletedVp.SortBy = true;
CompletedVp.SortMethod = NbtViewPropertySortMethod.Descending;
CswNbtViewProperty SubmittedVp = GridView.AddViewProperty( RequestRel, SubmittedDateNtp );
SubmittedVp.Order = 2;
SubmittedVp.SortMethod = NbtViewPropertySortMethod.Descending;
CswNbtViewProperty NameVp = GridView.AddViewProperty( RequestRel, NameNtp );
NameVp.Order = 1;
NameVp.SortMethod = NbtViewPropertySortMethod.Descending;
CswNbtViewProperty RequestorVp = GridView.AddViewProperty( RequestRel, RequestorNtp );
RequestorVp.Order = 4;
CswNbtViewProperty TypeVp = GridView.AddViewProperty( RequestItemRel, TypeNtp );
TypeVp.Order = 5;
CswNbtViewProperty NumberVp = GridView.AddViewProperty( RequestItemRel, NumberNtp );
NumberVp.Order = 6;
CswNbtViewProperty OrderVp = GridView.AddViewProperty( RequestItemRel, ExternalOrderNoNtp );
OrderVp.Order = 7;
CswNbtViewProperty StatusVp = GridView.AddViewProperty( RequestItemRel, StatusNtp );
StatusVp.Order = 8;
GridView.save();
}
}
}
}
public CswViewVisibilityEditor(CswNbtResources CswNbtResources)
{
_CswNbtResources = CswNbtResources;
EnsureChildControls();
// View Visibility DropDown
_NewViewVisibilityDropDown.Items.Clear();
_NewViewVisibilityDropDown.Items.Add(new ListItem("User:"******"Role:", CswEnumNbtViewVisibility.Role.ToString()));
_NewViewVisibilityDropDown.Items.Add(new ListItem("Everyone", CswEnumNbtViewVisibility.Global.ToString()));
// Role dropdown
CswNbtMetaDataObjectClass Role_ObjectClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RoleClass);
CswNbtView RoleView = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship RoleRelationship = RoleView.AddViewRelationship(Role_ObjectClass, true);
string PriorVisibilityValue = _NewViewVisibilityRoleDropDown.SelectedValue;
_NewViewVisibilityRoleDropDown.Items.Clear();
ICswNbtTree RoleTree = _CswNbtResources.Trees.getTreeFromView(_CswNbtResources.CurrentNbtUser, RoleView, true, false, false);
RoleTree.goToRoot();
//RoleTree.goToNthChild(0);
for (int n = 0; n < RoleTree.getChildNodeCount(); n++)
{
RoleTree.goToNthChild(n);
CswNbtNode Node = RoleTree.getNodeForCurrentPosition();
_NewViewVisibilityRoleDropDown.Items.Add(new ListItem(Node.NodeName, Node.NodeId.PrimaryKey.ToString()));
RoleTree.goToParentNode();
}
if (_NewViewVisibilityRoleDropDown.Items.FindByValue(PriorVisibilityValue) != null)
{
_NewViewVisibilityRoleDropDown.SelectedValue = PriorVisibilityValue;
}
}
// User dropdown
CswNbtMetaDataObjectClass User_ObjectClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.UserClass);
CswNbtView UserView = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship UserRelationship = UserView.AddViewRelationship(User_ObjectClass, true);
if (!_CswNbtResources.CurrentNbtUser.IsAdministrator())
{
UserRelationship.NodeIdsToFilterIn.Add(_CswNbtResources.CurrentUser.UserId);
}
string PriorUserVisibilityValue = _NewViewVisibilityUserDropDown.SelectedValue;
_NewViewVisibilityUserDropDown.Items.Clear();
ICswNbtTree UserTree = _CswNbtResources.Trees.getTreeFromView(_CswNbtResources.CurrentNbtUser, UserView, true, false, false);
UserTree.goToRoot();
//UserTree.goToNthChild(0);
for (int n = 0; n < UserTree.getChildNodeCount(); n++)
{
UserTree.goToNthChild(n);
CswNbtNode Node = UserTree.getNodeForCurrentPosition();
_NewViewVisibilityUserDropDown.Items.Add(new ListItem(Node.NodeName, Node.NodeId.PrimaryKey.ToString()));
UserTree.goToParentNode();
}
if (_NewViewVisibilityUserDropDown.Items.FindByValue(PriorUserVisibilityValue) != null)
{
_NewViewVisibilityUserDropDown.SelectedValue = PriorUserVisibilityValue;
}
}
public override void update()
{
CswNbtMetaDataObjectClass InventoryGroupOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.InventoryGroupClass);
CswNbtMetaDataObjectClass InventoryGroupPermissionOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.InventoryGroupPermissionClass);
CswNbtMetaDataNodeType InvGrpNT = InventoryGroupOc.FirstNodeType;
CswNbtMetaDataNodeType InvGrpPermNT = InventoryGroupPermissionOc.FirstNodeType;
//1: Get Default Inventory Group
CswNbtObjClassInventoryGroup DefaultInventoryGroup = null;
CswNbtObjClassInventoryGroup CISProInventoryGroup = null;
foreach (CswNbtObjClassInventoryGroup InventoryGroup in InventoryGroupOc.getNodes(true, false, false, true))
{
if (InventoryGroup.Name.Text == "Default Inventory Group")
{
DefaultInventoryGroup = InventoryGroup;
}
else if (InventoryGroup.Name.Text == "CISPro")
{
CISProInventoryGroup = InventoryGroup;
}
}
if (null == DefaultInventoryGroup)
{
DefaultInventoryGroup = InventoryGroupOc.getNodes(true, false, false, true).FirstOrDefault();
}
if (null == DefaultInventoryGroup)
{
if (null != InvGrpNT)
{
DefaultInventoryGroup = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(InvGrpNT.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassInventoryGroup DefInvGrp = NewNode;
DefInvGrp.Name.Text = "Default Inventory Group";
});
}
}
if (null != DefaultInventoryGroup) //At this point DefaultInventoryGroup should never be null
{
//2: Set Default Value to Default Inventory Group, if no DefaultValue is present
CswNbtMetaDataObjectClass LocationOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.LocationClass);
foreach (CswNbtMetaDataNodeType LocationNt in LocationOc.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp InventoryGroupNtp = LocationNt.getNodeTypePropByObjectClassProp(CswNbtObjClassLocation.PropertyName.InventoryGroup);
if (false == InventoryGroupNtp.HasDefaultValue())
{
InventoryGroupNtp.DefaultValue.AsRelationship.RelatedNodeId = DefaultInventoryGroup.NodeId;
}
}
//3: Update any null Inventory Group values with Default
foreach (CswNbtObjClassLocation Location in LocationOc.getNodes(true, false, false, true))
{
if (false == CswTools.IsPrimaryKey(Location.InventoryGroup.RelatedNodeId))
{
Location.InventoryGroup.RelatedNodeId = DefaultInventoryGroup.NodeId;
Location.postChanges(ForceUpdate: false);
}
}
//4: Ensure at least one Inventory Group Permission exists
CswNbtMetaDataNodeType IgPermNt = InventoryGroupPermissionOc.getLatestVersionNodeTypes().FirstOrDefault();
if (null != IgPermNt)
{
try
{
CswNbtObjClassInventoryGroupPermission DefaultPermission = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(IgPermNt.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassInventoryGroupPermission WildCardPerm = NewNode;
WildCardPerm.PermissionGroup.RelatedNodeId = DefaultInventoryGroup.NodeId;
WildCardPerm.ApplyToAllRoles.Checked = CswEnumTristate.True;
WildCardPerm.ApplyToAllWorkUnits.Checked = CswEnumTristate.True;
WildCardPerm.Dispense.Checked = CswEnumTristate.True;
WildCardPerm.Dispose.Checked = CswEnumTristate.True;
WildCardPerm.Edit.Checked = CswEnumTristate.True;
WildCardPerm.Request.Checked = CswEnumTristate.True;
WildCardPerm.Undispose.Checked = CswEnumTristate.True;
});
}
catch (CswDniException ex) //If we're here, it's because this wildcard already exists
{
if (ex.ErrorType != CswEnumErrorType.Warning)
{
throw;
}
}
}
//5: Get rid of deprecated CISPro Inventory Group and move their permissions over to Default Inventory Group
if (null != CISProInventoryGroup)
{
CswNbtMetaDataObjectClass WorkUnitOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.WorkUnitClass);
CswNbtObjClassWorkUnit DefaultWorkUnit = null;
foreach (CswNbtObjClassWorkUnit WorkUnit in WorkUnitOc.getNodes(true, false, false, true))
{
if (WorkUnit.Name.Text == "Default Work Unit")
{
DefaultWorkUnit = WorkUnit;
}
}
if (null != DefaultWorkUnit)
{
foreach (CswNbtObjClassInventoryGroupPermission InventoryGroupPerm in InventoryGroupPermissionOc.getNodes(true, false, false, true))
{
if (InventoryGroupPerm.PermissionGroup.RelatedNodeId == CISProInventoryGroup.NodeId)
{
try
{
InventoryGroupPerm.PermissionGroup.RelatedNodeId = DefaultInventoryGroup.NodeId;
InventoryGroupPerm.PermissionGroup.SyncGestalt();
InventoryGroupPerm.WorkUnit.RelatedNodeId = DefaultWorkUnit.NodeId;
InventoryGroupPerm.WorkUnit.SyncGestalt();
InventoryGroupPerm.postChanges(false);
}
catch (CswDniException) //If we're here, it's because the Permission already exists on Default Inventory Group
{
InventoryGroupPerm.Node.delete(true, true);
}
}
}
}
CISProInventoryGroup.Node.delete(true, true);
}
}
//6: Fix Inventory Group Permissions grid prop
if (null != InvGrpNT && null != InvGrpPermNT)
{
CswNbtMetaDataNodeTypeProp PermissionsNTP = InvGrpNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroup.PropertyName.Permissions);
CswNbtView InvGrpPermView = _CswNbtSchemaModTrnsctn.restoreView(PermissionsNTP.ViewId);
if (null == InvGrpPermView)
{
InvGrpPermView = _CswNbtSchemaModTrnsctn.makeSafeView("Permissions", CswEnumNbtViewVisibility.Property);
InvGrpPermView.ViewMode = CswEnumNbtViewRenderingMode.Grid;
}
InvGrpPermView.Root.ChildRelationships.Clear();
CswNbtMetaDataNodeTypeProp PermissionGroupNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.PermissionGroup);
CswNbtMetaDataNodeTypeProp RoleNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.Role);
CswNbtMetaDataNodeTypeProp WorkUnitNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.WorkUnit);
CswNbtMetaDataNodeTypeProp ViewNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.View);
CswNbtMetaDataNodeTypeProp EditNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.Edit);
CswNbtMetaDataNodeTypeProp DispenseNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.Dispense);
CswNbtMetaDataNodeTypeProp RequestNTP = InvGrpPermNT.getNodeTypePropByObjectClassProp(CswNbtObjClassInventoryGroupPermission.PropertyName.Request);
CswNbtViewRelationship RootRel = InvGrpPermView.AddViewRelationship(InvGrpNT, false);
CswNbtViewRelationship PermRel = InvGrpPermView.AddViewRelationship(RootRel, CswEnumNbtViewPropOwnerType.Second, PermissionGroupNTP, true);
InvGrpPermView.AddViewProperty(PermRel, PermissionGroupNTP, 1);
InvGrpPermView.AddViewProperty(PermRel, RoleNTP, 2);
InvGrpPermView.AddViewProperty(PermRel, WorkUnitNTP, 3);
InvGrpPermView.AddViewProperty(PermRel, ViewNTP, 4);
InvGrpPermView.AddViewProperty(PermRel, EditNTP, 5);
InvGrpPermView.AddViewProperty(PermRel, DispenseNTP, 6);
InvGrpPermView.AddViewProperty(PermRel, RequestNTP, 7);
InvGrpPermView.save();
PermissionsNTP.ViewId = InvGrpPermView.ViewId;
}
}
public CswCommaDelimitedString getContainerLocationIds(CswNbtResources _CswNbtResources, CswNbtView ContainerLocationsView)
{
CswCommaDelimitedString ContainerLocations = new CswCommaDelimitedString();
ICswNbtTree ContainerLocationsTree = _CswNbtResources.Trees.getTreeFromView(ContainerLocationsView, false, false, false);
int ContainerLocationCount = ContainerLocationsTree.getChildNodeCount();
for (int i = 0; i < ContainerLocationCount; i++)
{
ContainerLocationsTree.goToNthChild(i);
ContainerLocations.Add(ContainerLocationsTree.getNodeIdForCurrentPosition().ToString());
ContainerLocationsTree.goToParentNode();
}
return(ContainerLocations);
}
private static void _recurseForRelatedNTs(CswNbtResources NbtResources, CswNbtExplorerReturn Return, int NodeTypeId, int level, string OwnerIdStr)
{
if (false == SEEN.Contains(NodeTypeId) && level <= MAX_DEPTH)
{
CswNbtMetaDataNodeType NodeType = NbtResources.MetaData.getNodeType(NodeTypeId);
CswNbtView View = new CswNbtView(NbtResources);
CswNbtViewRelationship Relationship = View.AddViewRelationship(NodeType, false);
CswNbtViewEditorRule ViewRule = new CswNbtViewEditorRuleAddViewLevels(NbtResources, new CswNbtViewEditorData()
{
CurrentView = View
});
string DisplayName = string.Empty;
string TargetIdStr = string.Empty;
string IconFilename = string.Empty;
string Id = string.Empty;
Random rand = new Random(DateTime.Now.Millisecond);
Collection <CswNbtViewRelationship> RelatedTypes = ViewRule.getViewChildRelationshipOptions(View, Relationship.ArbitraryId);
foreach (CswNbtViewRelationship Related in RelatedTypes)
{
bool WasNT = false;
bool ObjClassAllowed = false;
DisplayName = Related.TextLabel;
string MetaDataName = string.Empty;
int id = (Related.PropOwner == CswEnumNbtViewPropOwnerType.First && Related.FirstId != Int32.MinValue ? Related.FirstId : Related.SecondId);
CswEnumNbtViewRelatedIdType IdType = (Related.PropOwner == CswEnumNbtViewPropOwnerType.First && Related.FirstId != Int32.MinValue ? Related.FirstType : Related.SecondType);
if (Related.PropOwner == CswEnumNbtViewPropOwnerType.Second)
{
if (IdType == CswEnumNbtViewRelatedIdType.NodeTypeId)
{
CswNbtMetaDataNodeType RelatedNodeType = NbtResources.MetaData.getNodeType(id);
IconFilename = RelatedNodeType.IconFileName;
TargetIdStr = OwnerIdStr + "_NT_" + RelatedNodeType.NodeTypeId + "_" + rand.Next();
Id = "NT_" + RelatedNodeType.NodeTypeId;
CswNbtMetaDataObjectClass ObjClass = RelatedNodeType.getObjectClass();
ObjClassAllowed = FilterVal.Contains("OC_" + ObjClass.ObjectClassId);
MetaDataName = RelatedNodeType.NodeTypeName;
WasNT = true;
}
else if (IdType == CswEnumNbtViewRelatedIdType.ObjectClassId)
{
CswNbtMetaDataObjectClass RelatedObjClass = NbtResources.MetaData.getObjectClass(id);
IconFilename = RelatedObjClass.IconFileName;
TargetIdStr = OwnerIdStr + "_OC_" + RelatedObjClass.ObjectClassId + "_" + rand.Next();
Id = "OC_" + RelatedObjClass.ObjectClassId;
MetaDataName = RelatedObjClass.ObjectClassName;
}
if (((IdType == CswEnumNbtViewRelatedIdType.NodeTypeId && FilterVal.Contains("NT_" + id) || ObjClassAllowed)) ||
(IdType == CswEnumNbtViewRelatedIdType.ObjectClassId && FilterVal.Contains("OC_" + id)))
{
_addToGraph(Return, DisplayName, OwnerIdStr, TargetIdStr, IconFilename, level, "Category", Id, MetaDataName, Related.PropId);
if (level + 1 <= MAX_DEPTH && WasNT)
{
_recurseForRelatedNTs(NbtResources, Return, id, level + 1, TargetIdStr);
}
}
}
}
}
}
public override void update()
{
//get field types used for this class
CswNbtMetaDataFieldType memoFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Memo );
CswNbtMetaDataFieldType logicalFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Logical );
CswNbtMetaDataFieldType textFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Text );
#region CREATE THE REGULATORY LIST OC AND IT'S PROPS
CswNbtMetaDataObjectClass regulatoryListOC = _CswNbtSchemaModTrnsctn.createObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RegulatoryListClass, "doc.png", true, true );
CswNbtMetaDataObjectClassProp nameOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( regulatoryListOC )
{
PropName = CswNbtObjClassRegulatoryList.PropertyName.Name,
FieldType = CswNbtMetaDataFieldType.NbtFieldType.Text,
IsFk = false,
IsRequired = true,
IsUnique = true
} );
CswNbtMetaDataObjectClassProp casNumbersOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( regulatoryListOC )
{
PropName = CswNbtObjClassRegulatoryList.PropertyName.CASNumbers,
FieldType = CswNbtMetaDataFieldType.NbtFieldType.Memo,
IsFk = false,
IsRequired = true
} );
#endregion
#region CREATE THE REGULATORY LIST NODETYPE
CswNbtMetaDataNodeType regulatoryListNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( regulatoryListOC.ObjectClassId, "Regulatory List", "Materials" );
regulatoryListNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryList.PropertyName.Name ) ); //set display name
CswNbtMetaDataNodeTypeProp casNosNTP = regulatoryListNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRegulatoryList.PropertyName.CASNumbers );
casNosNTP.HelpText = "The CASNos property should be a comma delimited set of CASNos in this regulatory list. Example: \"CASNo1,CASNo2,CASNo3\"";
#endregion
#region CREATE REGULATORY LISTS VIEW
CswNbtObjClassRole cisProAdminRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
if( null != cisProAdminRole )
{
CswNbtView regListsView = _CswNbtSchemaModTrnsctn.makeNewView( "Regulatory Lists", NbtViewVisibility.Role, cisProAdminRole.NodeId );
regListsView.SetViewMode( NbtViewRenderingMode.Tree );
regListsView.Category = "CISPro Configuration";
CswNbtViewRelationship parent = regListsView.AddViewRelationship( regulatoryListOC, false );
regListsView.save();
}
#endregion
#region ADD REGULATORY LIST NODETYPE PERMISSIONS TO CISPro_Admin
if( null != cisProAdminRole )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.View, regulatoryListNT, cisProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.Create, regulatoryListNT, cisProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.Edit, regulatoryListNT, cisProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.Delete, regulatoryListNT, cisProAdminRole, true );
}
#endregion
}//Update()
public ICswNbtTree getOpenCartTree(CswNbtView CartView)
{
return(_CswNbtResources.Trees.getTreeFromView(CartView, false, false, false));
}
public override void update()
{
CswNbtMetaDataNodeType LabSafetyChecklist = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Lab Safety Checklist (demo)" );
CswNbtMetaDataNodeType LabSafetyGroup = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Lab Safety Group (demo)" );
CswNbtMetaDataNodeType LabSafetyTarget = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Lab Safety (demo)" );
if( null != LabSafetyChecklist && null != LabSafetyGroup && null != LabSafetyTarget )
{
CswNbtMetaDataNodeTypeTab SchedulesTab = LabSafetyGroup.getNodeTypeTab( "Schedules" );
if( null == SchedulesTab )
{
CswNbtMetaDataNodeType GeneratorNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( CswNbtObjClassGenerator.InspectionGeneratorNodeTypeName );
if( null != GeneratorNt )
{
SchedulesTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( LabSafetyGroup, " Schedules", 2 );
CswNbtMetaDataNodeTypeProp SchedulesNtp = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( LabSafetyGroup, CswEnumNbtFieldType.Grid, "Schedules", SchedulesTab.TabId );
CswNbtView SchedulesView = _CswNbtSchemaModTrnsctn.makeSafeView( LabSafetyTarget.NodeTypeName + " Schedules", CswEnumNbtViewVisibility.Property );
SchedulesView.NbtViewMode = CswEnumNbtViewRenderingMode.Grid.ToString();
CswNbtViewRelationship Rel = SchedulesView.AddViewRelationship( LabSafetyGroup, IncludeDefaultFilters: true );
CswNbtViewRelationship SchedRel = SchedulesView.AddViewRelationship( Rel, CswEnumNbtViewPropOwnerType.Second, GeneratorNt.getNodeTypePropByObjectClassProp( CswNbtObjClassGenerator.PropertyName.Owner ), IncludeDefaultFilters: true );
SchedulesView.AddViewProperty( SchedRel, GeneratorNt.getNodeTypePropByObjectClassProp( CswNbtObjClassGenerator.PropertyName.Description ) );
SchedulesView.AddViewProperty( SchedRel, GeneratorNt.getNodeTypePropByObjectClassProp( CswNbtObjClassGenerator.PropertyName.NextDueDate ) );
SchedulesView.AddViewProperty( SchedRel, GeneratorNt.getNodeTypePropByObjectClassProp( CswNbtObjClassGenerator.PropertyName.RunStatus ) );
SchedulesView.AddViewProperty( SchedRel, GeneratorNt.getNodeTypePropByObjectClassProp( CswNbtObjClassGenerator.PropertyName.RunTime ) );
SchedulesView.save();
SchedulesNtp.ViewId = SchedulesView.ViewId;
SchedulesNtp.removeFromLayout( CswEnumNbtLayoutType.Add );
}
}
CswNbtView GroupView = _CswNbtSchemaModTrnsctn.restoreView( "Groups, Lab Safety Checklist: Lab Safety (demo)" );
if( null != GroupView )
{
CswNbtView View = GroupView;
GroupView.Root.eachRelationship( Relationship =>
{
if( Relationship.SecondMetaDataDefinitionObject().UniqueId == LabSafetyTarget.NodeTypeId )
{
View.AddViewRelationship( Relationship, CswEnumNbtViewPropOwnerType.Second, LabSafetyChecklist.getNodeTypePropByObjectClassProp( CswNbtObjClassInspectionDesign.PropertyName.Target ), false );
}
}, null );
GroupView.save();
}
CswNbtView DoomedView1 = _CswNbtSchemaModTrnsctn.restoreView( "Inspections, Lab Safety Checklist: Lab Safety (demo)" );
if( null != DoomedView1 )
{
DoomedView1.Delete();
}
CswNbtView DoomedView2 = _CswNbtSchemaModTrnsctn.restoreView( "Scheduling, Lab Safety Checklist: Lab Safety (demo)" );
if( null != DoomedView2 )
{
DoomedView2.Delete();
}
}
} // update()
protected Collection <CswNbtViewProperty> _getProps(CswNbtMetaDataObjectClass ObjClass, CswNbtView TempView, HashSet <string> seenProps, CswNbtViewRelationship Relationship, bool DoCheck = true)
{
Collection <CswNbtViewProperty> Props = new Collection <CswNbtViewProperty>();
if (null != ObjClass)
{
foreach (CswNbtMetaDataNodeType NodeType in ObjClass.getNodeTypes())
{
foreach (CswNbtViewProperty prop in _getProps(NodeType, TempView, seenProps, Relationship, DoCheck))
{
Props.Add(prop);
}
}
}
return(Props);
}
public void reInitSystemView(CswEnumNbtSystemViewName ViewName)
{
SystemView = _initView(ViewName, true);
}
protected void _getFilterProps(CswNbtViewEditorData Return)
{
string viewStr = CurrentView.ToString();
CswNbtView TempView = new CswNbtView(_CswNbtResources);
TempView.LoadXml(viewStr);
HashSet <string> seenProps = new HashSet <string>();
CswNbtViewRelationship Relationship = (CswNbtViewRelationship)TempView.FindViewNodeByArbitraryId(Request.Relationship.ArbitraryId);
if (null != Relationship)
{
foreach (CswNbtViewProperty viewProp in Relationship.Properties.Where(p => CswEnumNbtFieldType.Button != p.FieldType))
{
seenProps.Add(viewProp.TextLabel);
Return.Step4.Properties.Add(viewProp);
}
if (Relationship.SecondType.Equals(CswEnumNbtViewRelatedIdType.PropertySetId))
{
CswNbtMetaDataPropertySet PropSet = _CswNbtResources.MetaData.getPropertySet(Relationship.SecondId);
if (null != PropSet)
{
foreach (CswNbtMetaDataObjectClass ObjClass in PropSet.getObjectClasses())
{
IEnumerable <CswNbtViewProperty> props = _getProps(ObjClass, TempView, seenProps, Relationship).Where(p => CswEnumNbtFieldType.Button != p.FieldType);;
foreach (CswNbtViewProperty vp in props)
{
Return.Step4.Properties.Add(vp);
}
}
}
}
else if (Relationship.SecondType.Equals(CswEnumNbtViewRelatedIdType.ObjectClassId))
{
CswNbtMetaDataObjectClass ObjClass = _CswNbtResources.MetaData.getObjectClass(Relationship.SecondId);
if (null != ObjClass)
{
IEnumerable <CswNbtViewProperty> props = _getProps(ObjClass, TempView, seenProps, Relationship).Where(p => CswEnumNbtFieldType.Button != p.FieldType);;
foreach (CswNbtViewProperty vp in props)
{
Return.Step4.Properties.Add(vp);
}
}
}
else if (Relationship.SecondType.Equals(CswEnumNbtViewRelatedIdType.NodeTypeId))
{
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(Relationship.SecondId);
if (null != NodeType)
{
IEnumerable <CswNbtViewProperty> props = _getProps(NodeType, TempView, seenProps, Relationship).Where(p => CswEnumNbtFieldType.Button != p.FieldType);
foreach (CswNbtViewProperty vp in props)
{
Return.Step4.Properties.Add(vp);
}
}
}
}
Collection <CswNbtViewProperty> sortedProps = new Collection <CswNbtViewProperty>();
foreach (CswNbtViewProperty prop in Return.Step4.Properties.OrderBy(vp => vp.TextLabel))
{
sortedProps.Add(prop);
}
Return.Step4.Properties = sortedProps;
Return.Step4.ViewJson = TempView.ToJson().ToString();
}
} // getMergeInfo()
private void _addMergeNodes(MergeInfoData ret, CswPrimaryKey NodeId1, CswPrimaryKey NodeId2, CswNbtMetaDataNodeTypeProp NodeReferenceProp = null)
{
CswNbtNode Node1 = _CswNbtResources.Nodes[NodeId1];
CswNbtNode Node2 = _CswNbtResources.Nodes[NodeId2];
if (null != Node1 && null != Node2)
{
// Make sure there isn't already a node pair for these nodes
if (false == ret.NodePairs.Any(np => (np.Node1Id == Node1.NodeId.ToString() && np.Node2Id == Node2.NodeId.ToString()) ||
(np.Node1Id == Node2.NodeId.ToString() && np.Node2Id == Node1.NodeId.ToString())))
{
CswNbtMetaDataNodeType Node1NT = Node1.getNodeType();
MergeInfoData.MergeInfoNodePair NodePair = new MergeInfoData.MergeInfoNodePair();
NodePair.NodeReferences = new Collection <MergeInfoData.MergeInfoNodeReference>();
NodePair.NodeTypeName = Node1NT.NodeTypeName;
NodePair.Node1Id = Node1.NodeId.ToString();
NodePair.Node2Id = Node2.NodeId.ToString();
NodePair.Node1Name = Node1.NodeName;
NodePair.Node2Name = Node2.NodeName;
if (null != NodeReferenceProp)
{
NodePair.NodeReferencePropId = NodeReferenceProp.PropId;
}
else
{
NodePair.NodeReferencePropId = Int32.MinValue;
}
foreach (CswNbtNodePropWrapper Prop1 in Node1.Properties.Where(p => (null == NodeReferenceProp || p.NodeTypePropId != NodeReferenceProp.PropId)))
{
CswNbtNodePropWrapper Prop2 = Node2.Properties[Prop1.NodeTypePropId];
if (null == Prop2 || Prop1.Gestalt != Prop2.Gestalt)
{
NodePair.Properties.Add(new MergeInfoData.MergeInfoProperty()
{
PropName = Prop1.PropName,
NodeTypePropId = Prop1.NodeTypePropId,
Node1Value = Prop1.Gestalt,
Node2Value = Prop2.Gestalt
});
} // if( null == Prop2 || Prop1.Gestalt != Prop2.Gestalt )
} // foreach( CswNbtNodePropWrapper Prop1 in Node1.Properties )
ret.NodePairs.Add(NodePair);
// If two nodes that formerly related to each of node1 and node2 now relate to the merged target,
// and they now would be compound unique violations, we have to merge those too.
// First, find references that point to the merged nodes
foreach (CswNbtMetaDataNodeTypeProp thisProp in _CswNbtResources.MetaData.getNodeTypeProps().Where(p => p.IsNodeReference() && p.FkMatches(Node1.getNodeType())))
{
// Find unique key sets for nodes using this reference that point to either node1 or node2
Dictionary <CswDelimitedString, CswPrimaryKey> Node1UniqueKeysDict = _getUniqueKeysDict(NodePair, Node1, thisProp);
Dictionary <CswDelimitedString, CswPrimaryKey> Node2UniqueKeysDict = _getUniqueKeysDict(NodePair, Node2, thisProp);
// Look for redundant keys to indicate a potential unique violation
foreach (CswDelimitedString key in Node1UniqueKeysDict.Keys)
{
if (Node2UniqueKeysDict.ContainsKey(key))
{
// unique violation! gotta merge these too.
_addMergeNodes(ret, Node1UniqueKeysDict[key], Node2UniqueKeysDict[key], thisProp);
}
} // foreach( CswDelimitedString key in Node1UniqueKeysDict.Keys )
} // foreach( CswNbtMetaDataNodeTypeProp thisProp in _CswNbtResources.MetaData.getNodeTypeProps().Where( p => p.IsNodeReference() ) )
// Special case: UserSelect properties
if (Node1NT.getObjectClassValue() == CswEnumNbtObjectClass.UserClass)
{
foreach (CswNbtMetaDataNodeTypeProp thisUserSelProp in _CswNbtResources.MetaData.getNodeTypeProps(CswEnumNbtFieldType.UserSelect))
{
// Create a view of nodes that point to either merged node via this reference
CswNbtView view = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship rel1 = view.AddViewRelationship(thisUserSelProp.getNodeType(), false);
view.AddViewPropertyAndFilter(rel1,
thisUserSelProp,
Conjunction: CswEnumNbtFilterConjunction.And,
FilterMode: CswEnumNbtFilterMode.Contains,
Value: Node1.NodeId.PrimaryKey.ToString());
view.AddViewPropertyAndFilter(rel1,
thisUserSelProp,
Conjunction: CswEnumNbtFilterConjunction.Or,
FilterMode: CswEnumNbtFilterMode.Contains,
Value: Node2.NodeId.PrimaryKey.ToString());
// Add nodes with matching UserSelect properties to NodeReferences for later updating
ICswNbtTree tree = _CswNbtResources.Trees.getTreeFromView(view, RequireViewPermissions: false, IncludeHiddenNodes: true, IncludeSystemNodes: true);
for (Int32 c = 0; c < tree.getChildNodeCount(); c++)
{
tree.goToNthChild(c);
NodePair.NodeReferences.Add(new MergeInfoData.MergeInfoNodeReference()
{
NodeId = tree.getNodeIdForCurrentPosition().ToString(),
NodeTypePropId = thisUserSelProp.PropId
});
tree.goToParentNode();
} // for( Int32 c = 0; c < tree.getChildNodeCount(); c++ )
} // foreach( CswNbtMetaDataNodeTypeProp thisUserSelProp in _CswNbtResources.MetaData.getNodeTypeProps( CswEnumNbtFieldType.UserSelect ) )
} // if( Node1NT.getObjectClassValue() == CswEnumNbtObjectClass.UserClass )
} // if(false == ret.NodePairs.Any( ... ))
} // if( null != Node1 && null != Node2 )
} // _addMergeNodes()
private Collection <CswNbtViewRelationship> getPropertySetRelated(Int32 PropertySetId, CswNbtView View, Int32 Level)
{
Collection <CswNbtViewRelationship> Relationships = new Collection <CswNbtViewRelationship>();
// If we're doing a grid, we can only pick things in which the provided nodetype has a relationship to,
// rather than things that are related to the provided nodetype.
// If this is a property grid, then the above rule does not apply to the first level.
bool Restrict = (View.ViewMode == CswEnumNbtViewRenderingMode.Grid || View.ViewMode == CswEnumNbtViewRenderingMode.Table) &&
(View.Visibility != CswEnumNbtViewVisibility.Property || Level >= 2);
CswNbtMetaDataPropertySet PropertySet = _CswNbtResources.MetaData.getPropertySet(PropertySetId);
CswStaticSelect RelationshipPropsSelect = _CswNbtResources.makeCswStaticSelect("getRelationsForPropertySetId_select", "getRelationsForPropertySetId");
RelationshipPropsSelect.S4Parameters.Add("getpropertysetid", new CswStaticParam("getpropertysetid", PropertySetId));
DataTable RelationshipPropsTable = RelationshipPropsSelect.getTable();
foreach (DataRow PropRow in RelationshipPropsTable.Rows)
{
// Ignore relationships that don't have a target
if (PropRow["fktype"].ToString() != String.Empty &&
PropRow["fkvalue"].ToString() != String.Empty)
{
ICswNbtMetaDataProp ThisProp = null;
if (PropRow["proptype"].ToString() == CswEnumNbtViewPropIdType.ObjectClassPropId.ToString())
{
ThisProp = _CswNbtResources.MetaData.getObjectClassProp(CswConvert.ToInt32(PropRow["propid"]));
}
else if (PropRow["proptype"].ToString() == CswEnumNbtViewPropIdType.NodeTypePropId.ToString())
{
ThisProp = _CswNbtResources.MetaData.getNodeTypeProp(CswConvert.ToInt32(PropRow["propid"]));
}
if (PropRow["propertysetid"].ToString() == CswEnumNbtViewRelatedIdType.PropertySetId.ToString() &&
PropRow["fktype"].ToString() == CswEnumNbtViewRelatedIdType.PropertySetId.ToString() &&
PropRow["fkvalue"].ToString() == PropertySetId.ToString())
{
// Special case -- relationship to my own set
// We need to create two relationships from this
CswNbtViewRelationship R1 = View.AddViewRelationship(null, CswEnumNbtViewPropOwnerType.First, ThisProp, false);
R1.overrideFirst(PropertySet);
R1.overrideSecond(PropertySet);
_InsertRelationship(Relationships, R1);
if (!Restrict)
{
CswNbtViewRelationship R2 = View.AddViewRelationship(null, CswEnumNbtViewPropOwnerType.Second, ThisProp, false);
R2.overrideFirst(PropertySet);
R2.overrideSecond(PropertySet);
_InsertRelationship(Relationships, R2);
}
}
else
{
CswNbtViewRelationship R = null;
if (PropRow["propertysetid"].ToString() == PropertySetId.ToString())
{
// my relation to something else
R = View.AddViewRelationship(null, CswEnumNbtViewPropOwnerType.First, ThisProp, false);
R.overrideSecond(PropRow["fktype"].ToString(), CswConvert.ToInt32(PropRow["fkvalue"]));
R.overrideFirst(PropertySet);
_InsertRelationship(Relationships, R);
}
else if (PropRow["fktype"].ToString() == CswEnumNbtViewRelatedIdType.PropertySetId.ToString() &&
PropRow["fkvalue"].ToString() == PropertySetId.ToString())
{
if (!Restrict)
{
// something else's relation to me
R = View.AddViewRelationship(null, CswEnumNbtViewPropOwnerType.Second, ThisProp, false);
if (PropRow["proptype"].ToString() == CswEnumNbtViewPropIdType.ObjectClassPropId.ToString())
{
R.overrideSecond(_CswNbtResources.MetaData.getObjectClass(CswConvert.ToInt32(PropRow["typeid"])));
}
else
{
R.overrideSecond(_CswNbtResources.MetaData.getNodeType(CswConvert.ToInt32(PropRow["typeid"])));
}
R.overrideFirst(PropertySet);
_InsertRelationship(Relationships, R);
}
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "An unexpected data condition has occurred", "getPropertySetRelated() found a relationship which did not match the original propertysetid");
}
}
}
}
return(Relationships);
}
/// <summary>
/// Create a dictionary of the unique key values of related nodes
/// As a side effect, also populate MergeInfoData.NodePair.NodeReferences
/// </summary>
private Dictionary <CswDelimitedString, CswPrimaryKey> _getUniqueKeysDict(MergeInfoData.MergeInfoNodePair NodePair, CswNbtNode Node, CswNbtMetaDataNodeTypeProp NodeReferenceProp)
{
Dictionary <CswDelimitedString, CswPrimaryKey> ret = new Dictionary <CswDelimitedString, CswPrimaryKey>();
char delimiter = '|';
// Find unique properties for this reference's nodetype
IEnumerable <CswNbtMetaDataNodeTypeProp> UniqueProps = NodeReferenceProp.getNodeType().getUniqueProps();
// Create a view of nodes that point to the target node via this reference
CswNbtView view = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship rel1 = view.AddViewRelationship(Node.getNodeType(), false);
rel1.NodeIdsToFilterIn.Add(Node.NodeId);
CswNbtViewRelationship rel2 = view.AddViewRelationship(rel1, CswEnumNbtViewPropOwnerType.Second, NodeReferenceProp, false);
foreach (CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps)
{
view.AddViewProperty(rel2, uniqueProp);
}
// Iterate children and store unique property values in a dictionary key
ICswNbtTree tree = _CswNbtResources.Trees.getTreeFromView(view, RequireViewPermissions: false, IncludeHiddenNodes: true, IncludeSystemNodes: true);
if (tree.getChildNodeCount() > 0)
{
tree.goToNthChild(0);
for (Int32 c = 0; c < tree.getChildNodeCount(); c++)
{
tree.goToNthChild(c);
CswPrimaryKey thisNodeId = tree.getNodeIdForCurrentPosition();
// Populate MergeInfoData.NodePair.NodeReferences while we're here
NodePair.NodeReferences.Add(new MergeInfoData.MergeInfoNodeReference()
{
NodeId = thisNodeId.ToString(),
NodeTypePropId = NodeReferenceProp.PropId
});
CswDelimitedString key;
if (_AllUniqueKeys.ContainsKey(thisNodeId))
{
// If we've seen this node before, use the existing key but override the merge property
// (this will allow us to merge correctly if a nodetype has
// multiple compound unique references that are all involved in the merge)
key = _AllUniqueKeys[thisNodeId];
for (Int32 u = 0; u < UniqueProps.Count(); u++)
{
if (UniqueProps.ElementAt(u).PropId == NodeReferenceProp.PropId)
{
// This value will be equal after the merge
key[u] = "[mergeresult]";
}
} // foreach( CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps )
} // if( _AllUniqueKeys.ContainsKey( thisNodeId ) )
else
{
// generate a new key
key = new CswDelimitedString(delimiter);
foreach (CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps)
{
CswNbtTreeNodeProp prop = tree.getChildNodePropsOfNode().FirstOrDefault(p => p.NodeTypePropId == uniqueProp.PropId);
if (null != prop)
{
if (prop.NodeTypePropId == NodeReferenceProp.PropId)
{
// This value will be equal after the merge
key.Add("[mergeresult]");
}
else
{
key.Add(prop.Gestalt);
}
}
else
{
key.Add("");
}
} // foreach( CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps )
} // if-else( _AllUniqueKeys.ContainsKey( thisNodeId ) )
if (key.Count > 0)
{
ret.Add(key, thisNodeId);
_AllUniqueKeys[thisNodeId] = key;
}
tree.goToParentNode();
} // for( Int32 c = 0; c < tree.getChildNodeCount(); c++ )
} // if( tree.getChildNodeCount() > 0 )
return(ret);
} // _getUniqueKeysDict()
/// <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);
}
}
} // _applyMergeChoicesToNode()
public CswNbtView finishMerge(MergeInfoData Choices)
{
CswNbtView view = new CswNbtView(_CswNbtResources);
CswNbtNode firstMergedNode = null;
foreach (MergeInfoData.MergeInfoNodePair nodePair in Choices.NodePairs)
{
// Remove the temp node
CswNbtNode NodeTemp = _CswNbtResources.Nodes[nodePair.NodeTempId];
if (null != NodeTemp)
{
NodeTemp.delete(DeleteAllRequiredRelatedNodes: false, OverridePermissions: true, ValidateRequiredRelationships: false);
}
// Merge Node1 into Node2, and delete Node1
CswNbtNode Node1 = _CswNbtResources.Nodes[nodePair.Node1Id];
CswNbtNode Node2 = _CswNbtResources.Nodes[nodePair.Node2Id];
if (null != Node1 && null != Node2)
{
// Store the first node merged to return
if (null == firstMergedNode)
{
firstMergedNode = Node2;
}
// Apply the merge to Node2
_applyMergeChoicesToNode(Choices, nodePair, Node2);
Node2.postChanges(ForceUpdate: false, IsCopy: false, OverrideUniqueValidation: true);
// Update any references to point to node2
foreach (MergeInfoData.MergeInfoNodeReference Ref in nodePair.NodeReferences)
{
CswNbtNode refNode = _CswNbtResources.Nodes[Ref.NodeId];
if (refNode.Properties[Ref.NodeTypePropId].getFieldTypeValue() == CswEnumNbtFieldType.UserSelect)
{
// Special case: UserSelect
refNode.Properties[Ref.NodeTypePropId].AsUserSelect.RemoveUser(Node1.NodeId);
refNode.Properties[Ref.NodeTypePropId].AsUserSelect.AddUser(Node2.NodeId);
refNode.Properties[Ref.NodeTypePropId].AsUserSelect.SyncGestalt();
}
else
{
// Node Reference
refNode.Properties[Ref.NodeTypePropId].AsNodeReference.ReferencedNodeId = Node2.NodeId;
refNode.Properties[Ref.NodeTypePropId].AsNodeReference.RefreshNodeName();
}
refNode.postChanges(ForceUpdate: false, IsCopy: false, OverrideUniqueValidation: true);
}
// Delete merged node 1
Node1.delete(DeleteAllRequiredRelatedNodes: false, OverridePermissions: true, ValidateRequiredRelationships: false);
} // if( null != Node1 && null != Node2 )
} // foreach( MergeInfoData.MergeInfoNodePair nodePair in Choices.NodePairs )
// Return a view of the first merged node
if (null != firstMergedNode)
{
view = firstMergedNode.getViewOfNode(includeDefaultFilters: false);
}
return(view);
} // finishMerge()
public HMISData getHMISData(HMISData.HMISDataRequest Request)
{
HMISData Data = new HMISData();
CswPrimaryKey ControlZoneId = null;
if (false == string.IsNullOrEmpty(Request.ControlZoneId))
{
ControlZoneId = CswConvert.ToPrimaryKey(Request.ControlZoneId);
}
else if (false == string.IsNullOrEmpty(Request.ControlZone))
{
if (CswTools.IsInteger(Request.ControlZone))
{
ControlZoneId = new CswPrimaryKey("nodes", CswConvert.ToInt32(Request.ControlZone));
}
else
{
CswNbtView ControlZoneView = getControlZonesView(Request.ControlZone);
ICswNbtTree ControlZoneTree = _CswNbtResources.Trees.getTreeFromView(ControlZoneView, RequireViewPermissions: false, IncludeSystemNodes: true, IncludeHiddenNodes: true);
if (ControlZoneTree.getChildNodeCount() > 0)
{
ControlZoneTree.goToNthChild(0);
ControlZoneId = ControlZoneTree.getNodeIdForCurrentPosition();
}
}
}
if (CswTools.IsPrimaryKey(ControlZoneId))
{
Data.ControlZone = _CswNbtResources.Nodes.getNodeName(ControlZoneId);
string HMISSql = @"with loc as (select n.nodeid
from nodes n
join nodetypes t on t.nodetypeid = n.nodetypeid
join object_class oc on t.objectclassid = oc.objectclassid
join (select j.nodeid, j.field1_fk
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Control Zone'
) cz on (cz.nodeid = n.nodeid)
where oc.objectclass = 'LocationClass'
and cz.field1_fk = " + ControlZoneId.PrimaryKey + @"
),
mat as (select n.nodeid, n.nodename materialname, hc.clobdata hazardclasses, sf.gestaltsearch specialflags, ps.field1 physstate
from nodes n
join nodetypes t on t.nodetypeid = n.nodetypeid
join object_class oc on t.objectclassid = oc.objectclassid
join (select j.nodeid, j.clobdata
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Hazard Classes'
) hc on (hc.nodeid = n.nodeid)
join (select j.nodeid, j.gestaltsearch
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Special Flags'
) sf on (sf.nodeid = n.nodeid)
join (select j.nodeid, j.field1
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Physical State'
) ps on (ps.nodeid = n.nodeid)
where oc.objectclass = 'ChemicalClass'
and (sf.gestaltsearch is null or sf.gestaltsearch not like '%not reportable%')";
if (string.IsNullOrEmpty(Request.Class))
{
HMISSql += " and hc.clobdata is not null";
}
else
{
HMISSql += " and hc.clobdata like '%" + Request.Class + @"%'";
}
HMISSql += @" ),
cont as (select SUM(q.field2_numeric) total_qty_kg,
SUM(q.field3_numeric) total_qty_lt,
ut.field1 usetype,
m.field1_fk materialid
from nodes n
join nodetypes t on t.nodetypeid = n.nodetypeid
join object_class oc on t.objectclassid = oc.objectclassid
join (select j.nodeid, j.field1_fk
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Location'
) l on (l.nodeid = n.nodeid)
join (select j.nodeid, j.field2_numeric, j.field3_numeric
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Quantity'
) q on (q.nodeid = n.nodeid)
join (select j.nodeid, j.field1
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Use Type'
) ut on (ut.nodeid = n.nodeid)
join (select j.nodeid, j.field1_fk
from object_class_props ocp
join nodetype_props ntp on ocp.objectclasspropid = ntp.objectclasspropid
join jct_nodes_props j on ntp.nodetypepropid = j.nodetypepropid
where ocp.propname = 'Material'
) m on (m.nodeid = n.nodeid)
where oc.objectclass = 'ContainerClass'
and ut.field1 is not null
and l.field1_fk in (select nodeid from loc)
and (q.field2_numeric > 0
or q.field3_numeric > 0)
group by ut.field1, m.field1_fk
)
select c.*, mat.hazardclasses, mat.specialflags, mat.materialname, mat.physstate
from cont c
join mat on (c.materialid = mat.nodeid)";
CswArbitrarySelect HMISSelect = _CswNbtResources.makeCswArbitrarySelect("HMIS_Select", HMISSql);
DataTable HMISTable = HMISSelect.getTable();
if (string.IsNullOrEmpty(Request.Class))
{
// Get totals for all classes
_setFireClasses(ControlZoneId, Data);
foreach (DataRow row in HMISTable.Rows)
{
CswCommaDelimitedString HazardClasses = new CswCommaDelimitedString();
HazardClasses.FromString(CswConvert.ToString(row["hazardclasses"]));
if (HazardClasses.Contains("FL-1A") || HazardClasses.Contains("FL-1B") || HazardClasses.Contains("FL-1C"))
{
HazardClasses.Add("FL-Comb");
}
foreach (String HazardClass in HazardClasses)
{
HMISData.HMISMaterial HMISMaterial = Data.Materials.FirstOrDefault(EmptyHazardClass => EmptyHazardClass.HazardClass == HazardClass);
if (null != HMISMaterial) //This would only be null if the Material's HazardClass options don't match the Default FireClass nodes
{
_addQuantityDataToHMISMaterial(HMISMaterial,
CswConvert.ToString(row["usetype"]),
CswConvert.ToDouble(row["total_qty_kg"]),
CswConvert.ToDouble(row["total_qty_lt"]),
CswConvert.ToString(row["physstate"]),
new CswPrimaryKey("nodes", CswConvert.ToInt32(row["materialid"])));
}
}
} // foreach( DataRow row in HMISTable )
} // if( string.IsNullOrEmpty( Request.Class ) )
else
{
// Get material information for one class
foreach (DataRow row in HMISTable.Rows)
{
HMISData.HMISMaterial NewMaterial = new HMISData.HMISMaterial
{
Material = CswConvert.ToString(row["materialname"]),
NodeId = CswConvert.ToInt32(row["materialid"]),
HazardClass = Request.Class
};
_addQuantityDataToHMISMaterial(NewMaterial,
CswConvert.ToString(row["usetype"]),
CswConvert.ToDouble(row["total_qty_kg"]),
CswConvert.ToDouble(row["total_qty_lt"]),
CswConvert.ToString(row["physstate"]),
new CswPrimaryKey("nodes", CswConvert.ToInt32(row["materialid"])));
Data.Materials.Add(NewMaterial);
}
} // if-else( string.IsNullOrEmpty( Request.Class ) )
} // if( CswTools.IsPrimaryKey( ControlZoneId ) )
return(Data);
}
} //Update()
private void _addProp( CswNbtView view, CswNbtViewRelationship parent, CswNbtMetaDataObjectClassProp prop, int order )
{
CswNbtViewProperty viewProp = view.AddViewProperty( parent, prop, order );
}
public override void update()
{
Int32 AdminRolePk = Int32.MinValue;
CswCommaDelimitedString AdminRoles = new CswCommaDelimitedString();
// Change the visibilily of the 'Roles and Users' view to global
CswNbtView RolesAndUsersView = _CswNbtSchemaModTrnsctn.restoreView( "Roles and Users" );
if( null != RolesAndUsersView )
{
RolesAndUsersView.SetVisibility( CswEnumNbtViewVisibility.Global, null, null );
RolesAndUsersView.save();
// For any roles that aren't Administrator roles, remove any role permissions
CswNbtMetaDataObjectClass RoleOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RoleClass );
foreach( CswNbtObjClassRole RoleNode in RoleOC.getNodes( false, true, false ) )
{
if( CswEnumTristate.True != RoleNode.Administrator.Checked )
{
foreach( CswEnumNbtNodeTypePermission Permission in CswEnumNbtNodeTypePermission.Members )
{
RoleNode.NodeTypePermissions.RemoveValue( CswNbtObjClassRole.MakeNodeTypePermissionValue( RoleOC.FirstNodeType.NodeTypeId, Permission ) );
}
RoleNode.NodeTypePermissions.SyncGestalt();
RoleNode.postChanges( false );
}
else
{
AdminRoles.Add( CswConvert.ToString( RoleNode.NodeId.PrimaryKey ) );
}
// We need this because setting the landing page for this Role is a special case
if( RoleNode.Name.Text == "Administrator" )
{
AdminRolePk = RoleNode.NodeId.PrimaryKey;
}
}
// Redirect Welcome Landingpage items
CswTableUpdate TableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "updateLandingPageItems_Case28518", "landingpage" );
DataTable LandingPageDt = TableUpdate.getTable( "where for_roleid in (" + AdminRoles.ToString() + ")" );
foreach( DataRow CurrentRow in LandingPageDt.Rows )
{
if( CswConvert.ToInt32( CurrentRow["for_roleid"] ) == AdminRolePk )
{
if( CswConvert.ToString( CurrentRow["to_nodeviewid"] ) == "19" )
{
CurrentRow["displaytext"] = RolesAndUsersView.ViewName;
}
}
if( CswConvert.ToString( CurrentRow["displaytext"] ) == "Roles and Users" )
{
CurrentRow["to_nodeviewid"] = RolesAndUsersView.ViewId.get();
}
}
TableUpdate.update( LandingPageDt );
}//if( null != RolesAndUsersView )
}// update()
public void HandleViewEditorFinish(CswNbtView View)
{
Master.HandleViewEditorFinish(View);
}
