private void _ObjectClassProperty_Change(CswNbtNodeProp Prop, bool Creating)
{
CswEnumNbtObjectClass OriginalOC = ObjectClassProperty.GetOriginalPropRowValue(CswNbtFieldTypeRuleList.SubFieldName.Text);
if (false == string.IsNullOrEmpty(OriginalOC) &&
OriginalOC != CswNbtResources.UnknownEnum &&
ObjectClassPropertyValue.ObjectClass != CswEnumNbtObjectClass.GenericClass &&
ObjectClassPropertyValue.ObjectClass != OriginalOC)
{
if (OriginalOC == CswEnumNbtObjectClass.GenericClass)
{
// Convert NodeType
//NodeType = CheckVersioning( RelationalNodeType );
IconFileName.Value.FromString(ObjectClassPropertyValue.IconFileName);
// Sync properties with new object class
// see case 31678
_requiresSync = true;
ObjectClassProperty.ServerManaged = true;
}
else if (_overrideNodeConversionCheck)
{
_requiresSync = true;
}
else
{
throw new CswDniException(CswEnumErrorType.Warning, "Cannot convert this NodeType", "Nodetype " + RelationalNodeType.NodeTypeName + " (" + RelationalNodeType.NodeTypeId + ") cannot be converted because it is not Generic");
}
}
} // _ObjectClassProperty_Change
} // runBatchOp()
#region Private Helper Methods
#region Helper Methods
private CswNbtNode _getNodeFromBarcode(string barcode, CswEnumNbtObjectClass objClassType, string barcodePropertyName, bool IncludeDefaultFilters = true)
{
CswNbtNode returnNode = null;
CswNbtView objClassView = new CswNbtView(_CswNbtResources);
CswNbtMetaDataObjectClass objClass = _CswNbtResources.MetaData.getObjectClass(objClassType);
CswNbtMetaDataObjectClassProp barcodeOCP = objClass.getObjectClassProp(barcodePropertyName);
CswNbtViewRelationship parent = objClassView.AddViewRelationship(objClass, IncludeDefaultFilters);
objClassView.AddViewPropertyAndFilter(parent,
MetaDataProp: barcodeOCP,
Value: barcode,
FilterMode: CswEnumNbtFilterMode.Equals);
ICswNbtTree Tree = _CswNbtResources.Trees.getTreeFromView(objClassView, false, true, true);
Tree.goToRoot();
for (int i = 0; i < Tree.getChildNodeCount(); i++)
{
Tree.goToNthChild(i);
returnNode = Tree.getNodeForCurrentPosition();
Tree.goToParentNode();
}
return(returnNode);
}
private Dictionary<string, string> InitNodeTypePermissionOptions()
{
// set NodeType Permissions options
// Could be a performance problem!!!
Dictionary<string, string> NodeTypeOptions = new Dictionary<string, string>();
foreach( CswNbtMetaDataNodeType NodeType in _CswNbtResources.MetaData.getNodeTypesLatestVersion() )
{
CswEnumNbtObjectClass oc = NodeType.getObjectClass().ObjectClass;
if( ( oc != CswEnumNbtObjectClass.DesignNodeTypeClass &&
oc != CswEnumNbtObjectClass.DesignNodeTypeTabClass &&
oc != CswEnumNbtObjectClass.DesignNodeTypePropClass &&
oc != CswEnumNbtObjectClass.DesignSequenceClass ) ||
_CswNbtResources.Permit.can( CswEnumNbtActionName.Design, this ) )
{
foreach( CswEnumNbtNodeTypePermission Permission in CswEnumNbtNodeTypePermission.Members )
{
string Key = MakeNodeTypePermissionValue( NodeType.FirstVersionNodeTypeId, Permission );
string Value = MakeNodeTypePermissionText( NodeType.NodeTypeName, Permission );
NodeTypeOptions.Add( Key, Value );
}
foreach( CswNbtMetaDataNodeTypeTab Tab in NodeType.getNodeTypeTabs() )
{
foreach( CswEnumNbtNodeTypeTabPermission Permission in CswEnumNbtNodeTypeTabPermission.Members )
{
string Key = MakeNodeTypeTabPermissionValue( NodeType.FirstVersionNodeTypeId, Tab.FirstTabVersionId, Permission );
string Value = MakeNodeTypeTabPermissionText( NodeType.NodeTypeName, Tab.TabName, Permission );
NodeTypeOptions.Add( Key, Value );
}
} // foreach( CswNbtMetaDataNodeTypeTab Tab in NodeType.NodeTypeTabs )
}
} // foreach( CswNbtMetaDataNodeType NodeType in _CswNbtResources.MetaData.NodeTypes )
return NodeTypeOptions;
} // InitNodeTypePermissionOptions()
private void _addNodeTypeAttributes(CswNbtMetaDataNodeType NodeType, JObject ReturnVal)
{
CswEnumNbtObjectClass ObjectClass = NodeType.getObjectClassValue();
string NtName = "nodetype_" + NodeType.NodeTypeId;
ReturnVal[NtName] = new JObject();
ReturnVal[NtName]["id"] = NodeType.NodeTypeId;
ReturnVal[NtName]["name"] = NodeType.NodeTypeName;
ReturnVal[NtName]["iconfilename"] = CswNbtMetaDataObjectClass.IconPrefix16 + NodeType.IconFileName;
ReturnVal[NtName]["objectclass"] = ObjectClass.ToString();
ReturnVal[NtName]["objectclassid"] = NodeType.ObjectClassId.ToString();
switch (ObjectClass)
{
// This is expensive, and as far as I can tell, not used by anyone
//case CswEnumNbtObjectClass.InspectionDesignClass:
// CswNbtMetaDataNodeTypeProp InspectionTargetNTP = NodeType.getNodeTypePropByObjectClassProp( CswNbtObjClassInspectionDesign.PropertyName.Target );
// ReturnVal[NtName]["targetnodetypeid"] = InspectionTargetNTP.FKValue.ToString();
// if( InspectionTargetNTP.FKType == CswEnumNbtViewPropIdType.NodeTypePropId.ToString() )
// {
// ReturnVal[NtName]["targetnodetypeid"] = InspectionTargetNTP.FKValue.ToString();
// }
// break;
case CswEnumNbtObjectClass.NonChemicalClass:
case CswEnumNbtObjectClass.ChemicalClass:
ReturnVal["action"] = CswEnumNbtActionName.Create_Material;
break;
}
}
} // update()
private CswNbtMetaDataNodeType _createPermissionNT( CswEnumNbtObjectClass PermissionClass, string PermissionNTName )
{
CswNbtMetaDataObjectClass PermissionOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( PermissionClass );
CswNbtMetaDataNodeType PermissionNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( PermissionOC.ObjectClassId, PermissionNTName, "System" );
PermissionNT.setNameTemplateText(
CswNbtMetaData.MakeTemplateEntry( CswNbtPropertySetPermission.PropertyName.PermissionGroup ) + "-" +
CswNbtMetaData.MakeTemplateEntry( CswNbtPropertySetPermission.PropertyName.Role ) + "-" +
CswNbtMetaData.MakeTemplateEntry( CswNbtPropertySetPermission.PropertyName.WorkUnit ) );
_setPermissionPropFilters( PermissionNT );
return PermissionNT;
}
private void _setNTPermissionsForOC( CswEnumNbtObjectClass OCName, CswNbtObjClassRole Role, bool AllowEdit )
{
CswNbtMetaDataObjectClass OC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( OCName );
foreach( CswNbtMetaDataNodeType NT in OC.getNodeTypes() )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.View, NT, Role, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Edit, NT, Role, AllowEdit );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Create, NT, Role, AllowEdit );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Delete, NT, Role, AllowEdit );
}
}
// For validating object class casting
protected static bool _Validate(CswNbtNode Node, CswEnumNbtObjectClass TargetObjectClass)
{
if (Node == null)
{
throw new CswDniException(CswEnumErrorType.Error, "Invalid node", "CswNbtObjClass._Validate was given a null node as a parameter");
}
if (!(Node.getObjectClass().ObjectClass == TargetObjectClass))
{
throw (new CswDniException(CswEnumErrorType.Error, "Invalid cast", "Can't cast current object class as " + TargetObjectClass.ToString() + "; Current object class is " + Node.getObjectClass().ObjectClass.ToString()));
}
return(true);
}
private CswNbtMetaDataNodeType _createGroupNT( CswEnumNbtObjectClass GroupClass, string GroupNTName, string TargetsGridPropName )
{
CswNbtMetaDataObjectClass GroupOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( GroupClass );
CswNbtMetaDataNodeType GroupNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( GroupOC.ObjectClassId, GroupNTName, "System" );
GroupNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassReportGroup.PropertyName.Name ) );
CswNbtMetaDataNodeTypeTab TaregetsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( GroupNT, TargetsGridPropName );
CswNbtMetaDataNodeTypeProp TargetsNTP = GroupNT.getNodeTypePropByObjectClassProp( TargetsGridPropName );
TargetsNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TaregetsTab.TabId );
CswNbtMetaDataNodeTypeTab PermissionsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( GroupNT, CswNbtObjClassReportGroup.PropertyName.Permissions );
CswNbtMetaDataNodeTypeProp PermissionsNTP = GroupNT.getNodeTypePropByObjectClassProp( CswNbtObjClassReportGroup.PropertyName.Permissions );
PermissionsNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, PermissionsTab.TabId );
return GroupNT;
}
public CswNbtSchemaUpdateLayoutMgr(CswNbtSchemaModTrnsctn SchemaModTrnsctn, CswEnumNbtObjectClass ObjectClass, CswEnumNbtLayoutType LayoutType = null)
{
if (null == ObjectClass || CswResources.UnknownEnum == ObjectClass)
{
throw new CswDniException("Cannot instance a Layout Mgr without an Object Class. Object Class was null.");
}
this.LayoutType = LayoutType;
this.SchemaModTrnsctn = SchemaModTrnsctn;
this.ObjectClass = this.SchemaModTrnsctn.MetaData.getObjectClass(ObjectClass);
LatestVersionNodeTypes = this.ObjectClass.getLatestVersionNodeTypes();
Props = new Collection <LayoutProp>();
}
public CswPrimaryKey _getNodeIdByBarcode(CswEnumNbtObjectClass ObjClass, string Barcode, bool IncludeDefaultFilters)
{
CswPrimaryKey Ret = null;
ICswNbtTree tree = _getTree(ObjClass, Barcode, IncludeDefaultFilters);
int childCount = tree.getChildNodeCount();
if (childCount > 0)
{
tree.goToNthChild(0);
Ret = tree.getNodeIdForCurrentPosition();
}
return(Ret);
}
private static void _populate(CswNbtResources NbtResources, CswEnumNbtObjectClass ObjectClass, CswCommaDelimitedString Ret)
{
CswNbtMetaDataObjectClass ObjClass = NbtResources.MetaData.getObjectClass(ObjectClass);
if (null != ObjClass) //Module permissions might cause this to be null
{
foreach (CswNbtMetaDataNodeType NodeType in ObjClass.getNodeTypes())
{
Ret.Add("NT_" + NodeType.NodeTypeId.ToString());
}
Ret.Add("OC_" + ObjClass.ObjectClassId);
}
}
} // update()
private void _makeProp( CswEnumNbtObjectClass ObjClass )
{
CswNbtMetaDataObjectClass requestOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( ObjClass );
CswNbtMetaDataObjectClassProp approvalLvlOCP = requestOC.getObjectClassProp( CswNbtObjClassRequestMaterialCreate.PropertyName.ApprovalLevel );
if( null == approvalLvlOCP )
{
_CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( requestOC )
{
PropName = CswNbtObjClassRequestMaterialCreate.PropertyName.ApprovalLevel,
FieldType = CswEnumNbtFieldType.List,
ListOptions = CswEnumNbtMaterialRequestApprovalLevel.All.ToString()
} );
}
}
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()
} // update()
//From MLM module
private void _toggleMaterialRequestApprovalLevel( CswEnumNbtObjectClass ObjClass, bool MLMDisabled )
{
CswNbtMetaDataObjectClass createMaterialRequestOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( ObjClass );
foreach( CswNbtMetaDataNodeType createMaterialRequestNT in createMaterialRequestOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp approvalLevelNT = createMaterialRequestNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestMaterialCreate.PropertyName.ApprovalLevel );
if( MLMDisabled )
{
approvalLevelNT.removeFromAllLayouts();
}
else
{
CswNbtMetaDataNodeTypeTab firstTab = createMaterialRequestNT.getFirstNodeTypeTab();
approvalLevelNT.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId: firstTab.TabId );
approvalLevelNT.updateLayout( CswEnumNbtLayoutType.Add, true );
}
}
}
public ICswNbtTree _getTree(CswEnumNbtObjectClass ObjClass, string Barcode, bool IncludeDefaultFilters)
{
ICswNbtTree tree = null;
CswNbtMetaDataObjectClass metaDataOC = _CswNbtResources.MetaData.getObjectClass(ObjClass);
CswNbtMetaDataObjectClassProp barcodeOCP = (CswNbtMetaDataObjectClassProp)metaDataOC.getBarcodeProperty();
if (null != barcodeOCP)
{
CswNbtView view = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship parent = view.AddViewRelationship(metaDataOC, IncludeDefaultFilters);
view.AddViewPropertyAndFilter(parent,
MetaDataProp: barcodeOCP,
Value: Barcode,
SubFieldName: CswNbtFieldTypeRuleBarCode.SubFieldName.Barcode,
FilterMode: CswEnumNbtFilterMode.Equals
);
if (ObjClass.Equals(CswEnumNbtObjectClass.ContainerClass))
{
CswNbtMetaDataObjectClassProp disposedOCP = metaDataOC.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Disposed);
view.AddViewProperty(parent, disposedOCP);
CswNbtMetaDataObjectClassProp quantityOCP = metaDataOC.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Quantity);
view.AddViewProperty(parent, quantityOCP);
}
if (ObjClass.Equals(CswEnumNbtObjectClass.LocationClass))
{
CswNbtMetaDataObjectClassProp locationOCP = metaDataOC.getObjectClassProp(CswNbtObjClassLocation.PropertyName.Location);
view.AddViewProperty(parent, locationOCP);
}
tree = _CswNbtResources.Trees.getTreeFromView(view, true, false, false);
}
return(tree);
}
/// <summary>
/// for each method condition and method characteristic attached to this
/// certDef, this method created a corresponding certDef condition
/// and certDef characteristic.
/// </summary>
private void _createCertDefSpecsAndCharacteristics()
{
CswNbtMetaDataObjectClass MethodOC = _CswNbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.MethodClass );
CswNbtMetaDataObjectClass MethodConditionOC = _CswNbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.MethodConditionClass );
CswNbtMetaDataObjectClass MethodCharacteristicOC = _CswNbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.MethodCharacteristicClass);
CswNbtMetaDataObjectClass CertDefConditionOC = _CswNbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.CertDefConditionClass );
CswNbtMetaDataObjectClass CertDefCharacteristicOC = _CswNbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.CertDefCharacteristicLimitClass);
CswNbtMetaDataNodeType CertDefConditionDefaultNT = CertDefConditionOC.FirstNodeType;
CswNbtMetaDataNodeType CertDefCharacteristicDefaultNT = CertDefCharacteristicOC.FirstNodeType;
CswNbtMetaDataObjectClassProp MethodConditionMethodOCP = _CswNbtResources.MetaData.getObjectClassProp(MethodConditionOC.ObjectClassId,
CswNbtObjClassMethodCondition.PropertyName.Method);
CswNbtMetaDataObjectClassProp MethodCharacteristicMethodOCP = _CswNbtResources.MetaData.getObjectClassProp(MethodCharacteristicOC.ObjectClassId,
CswNbtObjClassMethodCharacteristic.PropertyName.Method);
//create a view of all methodcondition and methodcharacteristics
//attached to this method
CswNbtView MethodConditionAndCharacteristicsView = new CswNbtView( _CswNbtResources );
MethodConditionAndCharacteristicsView.ViewName = "View of all method characteristics and method conditions attached to a method";
CswNbtViewRelationship MethodAsRootRelationship = MethodConditionAndCharacteristicsView.AddViewRelationship( MethodOC, false );
MethodAsRootRelationship.NodeIdsToFilterIn.Add( Method.RelatedNodeId );
MethodConditionAndCharacteristicsView.AddViewRelationship( MethodAsRootRelationship,
CswEnumNbtViewPropOwnerType.Second,
MethodConditionMethodOCP,
false );
MethodConditionAndCharacteristicsView.AddViewRelationship( MethodAsRootRelationship,
CswEnumNbtViewPropOwnerType.Second,
MethodCharacteristicMethodOCP,
false );
ICswNbtTree MethodConditionAndCharacteristicsTree = _CswNbtResources.Trees.getTreeFromView( MethodConditionAndCharacteristicsView, false, true, true, true );
if( MethodConditionAndCharacteristicsTree.getChildNodeCount() > 0 )
{
MethodConditionAndCharacteristicsTree.goToNthChild( 0 );
for( int i = 0; i < MethodConditionAndCharacteristicsTree.getChildNodeCount(); i++ )
{
MethodConditionAndCharacteristicsTree.goToNthChild( i );
CswNbtNode thisNode = MethodConditionAndCharacteristicsTree.getNodeForCurrentPosition();
CswEnumNbtObjectClass thisNodeOC = thisNode.getObjectClass().ObjectClass;
if( thisNodeOC == CswEnumNbtObjectClass.MethodConditionClass)
{
if( CertDefConditionDefaultNT != null )
{
CswNbtObjClassMethodCondition thisMethodCondition = thisNode;
CswNbtObjClassCertDefCondition correspondingCertDefCondition = _CswNbtResources.Nodes.makeNodeFromNodeTypeId( CertDefConditionDefaultNT.NodeTypeId );
correspondingCertDefCondition.MethodCondition.RelatedNodeId = thisMethodCondition.NodeId;
correspondingCertDefCondition.CertDefSpec.RelatedNodeId = this.NodeId;
correspondingCertDefCondition.postChanges( false );
}
else
{
throw new CswDniException(CswEnumErrorType.Error,
"A CertDef Condition corresponding to an existing Method Condition could not be created because there is no CertDef Condition NodeType",
"CertDef Condition NodeType not found, so CertDef Condition cannot be created");
}
}
else if( thisNodeOC == CswEnumNbtObjectClass.MethodCharacteristicClass)
{
if( CertDefConditionDefaultNT != null )
{
CswNbtObjClassMethodCharacteristic thisMethodCharacteristic = thisNode;
CswNbtObjClassCertDefCharacteristicLimit correspondingCertDefCharacteristic = _CswNbtResources.Nodes.makeNodeFromNodeTypeId( CertDefCharacteristicDefaultNT.NodeTypeId );
correspondingCertDefCharacteristic.MethodCharacteristic.RelatedNodeId = thisMethodCharacteristic.NodeId;
correspondingCertDefCharacteristic.CertDefSpec.RelatedNodeId = this.NodeId;
correspondingCertDefCharacteristic.postChanges( false );
}
else
{
throw new CswDniException(CswEnumErrorType.Error,
"A CertDef Characteristic Limit corresponding to an existing Method Characteristic Limit could not be created because there is no CertDef Characteristic Limit NodeType",
"CertDef Characteristic Limit NodeType not found, so CertDef Characteristic Limit cannot be created");
}
}
MethodConditionAndCharacteristicsTree.goToParentNode();
}
}
}
/// <summary>
/// Returns whether the user has any permission to any group
/// </summary>
/// <param name="PermObjectClass">Limit to one class of permission</param>
/// <param name="RequireEdit">Limit to Edit permissions</param>
public bool hasUserPermissions(CswEnumNbtObjectClass PermObjectClass = null, bool RequireEdit = false)
{
return(getUserPermissions(PermObjectClass, RequireEdit).Keys.Count > 0);
}
public static void createDefaultWildcardPermission( CswNbtResources _CswNbtResources, CswEnumNbtObjectClass PermissionClass, CswPrimaryKey GroupId )
{
CswNbtMetaDataObjectClass PermissionOC = _CswNbtResources.MetaData.getObjectClass( PermissionClass );
CswNbtView PermissionsView = new CswNbtView( _CswNbtResources );
CswNbtViewRelationship PermissionVR = PermissionsView.AddViewRelationship( PermissionOC, IncludeDefaultFilters: false );
CswNbtMetaDataObjectClassProp GroupOCP = PermissionOC.getObjectClassProp( PropertyName.PermissionGroup );
PermissionsView.AddViewPropertyAndFilter( PermissionVR, GroupOCP, Value: GroupId.ToString(), SubFieldName: CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID );
ICswNbtTree PermissionTree = _CswNbtResources.Trees.getTreeFromView( PermissionsView, false, false, false );
if( PermissionTree.getChildNodeCount() == 0 )
{
CswNbtMetaDataNodeType PermissionNT = PermissionOC.FirstNodeType;
if( null != PermissionNT )
{
_CswNbtResources.Nodes.makeNodeFromNodeTypeId( PermissionNT.NodeTypeId, delegate( CswNbtNode NewNode )
{
CswNbtPropertySetPermission WildCardPermission = NewNode;
WildCardPermission.ApplyToAllRoles.Checked = CswEnumTristate.True;
WildCardPermission.ApplyToAllWorkUnits.Checked = CswEnumTristate.True;
WildCardPermission.PermissionGroup.RelatedNodeId = GroupId;
WildCardPermission.View.Checked = CswEnumTristate.True;
WildCardPermission.Edit.Checked = CswEnumTristate.True;
WildCardPermission.setWildCardValues();
} );
}
}
}
public Dictionary <CswPrimaryKey, CswPrimaryKey> getUserPermissions(CswEnumNbtObjectClass PermObjectClass = null, bool RequireEdit = false)
{
CswNbtObjClassUser UserNode = _CswNbtResources.Nodes[UserId];
return(UserNode.getUserPermissions(PermObjectClass, RequireEdit));
}
public Dictionary <CswPrimaryKey, CswPrimaryKey> getUserPermissions(CswEnumNbtObjectClass PermGroupType = null, bool RequireEdit = false)
{
return(new Dictionary <CswPrimaryKey, CswPrimaryKey>());
}
public bool hasUserPermissions(CswEnumNbtObjectClass PermObjectClass = null, bool RequireEdit = false)
{
return(true);
}
/// <summary>
/// Returns a dictionary of Permission Groups and Permissions (primary keys only), if any exists for this User
/// </summary>
/// <param name="PermObjectClass">Limit to one class of permission</param>
/// <param name="RequireEdit">Limit to Edit permissions</param>
public Dictionary <CswPrimaryKey, CswPrimaryKey> getUserPermissions(CswEnumNbtObjectClass PermObjectClass = null, bool RequireEdit = false)
{
Dictionary <CswPrimaryKey, CswPrimaryKey> ret;
// Check the cache for the general case
if (null == PermObjectClass &&
false == RequireEdit &&
null != _UserPermissions &&
_UserPermissions.Keys.Count > 0)
{
ret = _UserPermissions;
}
else
{
ret = new Dictionary <CswPrimaryKey, CswPrimaryKey>();
if (CswTools.IsPrimaryKey(CurrentWorkUnitId) && CswTools.IsPrimaryKey(RoleId))
{
CswNbtMetaDataPropertySet PermissionSet = _CswNbtResources.MetaData.getPropertySet(CswEnumNbtPropertySetName.PermissionSet);
// This performs better than having it in its own 'with' query in large scale data,
// because it avoids a full table scan on jct_nodes_props.
string pvalQuery = @"from jct_propertyset_ocprop jpocp
join object_class_props ocp on ocp.objectclasspropid = jpocp.objectclasspropid
join nodetype_props ntp on ntp.objectclasspropid = ocp.objectclasspropid
join jct_nodes_props j on j.nodetypepropid = ntp.nodetypepropid
where jpocp.propertysetid = :permsetid";
string SQLQuery = @"with perms as (select n.nodeid,
(select j.field1_fk " + pvalQuery + @" and j.nodeid = n.nodeid and ocp.propname = :roleocp) userrole,
(select j.field1_fk " + pvalQuery + @" and j.nodeid = n.nodeid and ocp.propname = :workunitocp) userworkunit,
(select j.field1_fk " + pvalQuery + @" and j.nodeid = n.nodeid and ocp.propname = :permgroupocp) userpermgroup,
(select j.field1 " + pvalQuery + @" and j.nodeid = n.nodeid and ocp.propname = :applyallrolesocp) applyallroles,
(select j.field1 " + pvalQuery + @" and j.nodeid = n.nodeid and ocp.propname = :applyallworkunitsocp) applyallworkunits,
(select j.field1 " + pvalQuery + @" and j.nodeid = n.nodeid and ocp.propname = :editocp) edit
from nodes n
join nodetypes nt on n.nodetypeid = nt.nodetypeid
join object_class oc on nt.objectclassid = oc.objectclassid
where n.istemp = 0";
if (null != PermObjectClass)
{
CswNbtMetaDataObjectClass PermOC = _CswNbtResources.MetaData.getObjectClass(PermObjectClass);
if (null != PermOC)
{
SQLQuery += @" and oc.objectclassid = " + PermOC.ObjectClassId;
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "Server Configuration Error", "getUserPermissions() filtered to an invalid or disabled object class (" + PermObjectClass + ")");
}
}
else
{
SQLQuery += @" and oc.objectclassid in (select jpsoc.objectclassid
from jct_propertyset_objectclass jpsoc
where jpsoc.propertysetid = :permsetid)";
}
SQLQuery += @" )
select *
from perms
where (perms.userrole = :role or perms.userrole is null)
and (perms.userworkunit = :workunit or perms.userworkunit is null)";
if (RequireEdit)
{
SQLQuery += @" and perms.edit = '" + CswConvert.ToDbVal((CswEnumTristate)CswEnumTristate.True) + @"' ";
}
SQLQuery += @" order by userpermgroup, applyallroles, applyallworkunits";
CswArbitrarySelect Query = _CswNbtResources.makeCswArbitrarySelect("getUserPermissions", SQLQuery);
Query.addParameter("roleocp", CswNbtPropertySetPermission.PropertyName.Role);
Query.addParameter("workunitocp", CswNbtPropertySetPermission.PropertyName.WorkUnit);
Query.addParameter("permgroupocp", CswNbtPropertySetPermission.PropertyName.PermissionGroup);
Query.addParameter("applyallrolesocp", CswNbtPropertySetPermission.PropertyName.ApplyToAllRoles);
Query.addParameter("applyallworkunitsocp", CswNbtPropertySetPermission.PropertyName.ApplyToAllWorkUnits);
Query.addParameter("editocp", CswNbtPropertySetPermission.PropertyName.Edit);
Query.addParameter("permsetid", PermissionSet.PropertySetId.ToString());
Query.addParameter("role", RoleId.PrimaryKey.ToString());
Query.addParameter("workunit", CurrentWorkUnitId.PrimaryKey.ToString());
DataTable DataTable = Query.getTable();
foreach (DataRow Row in DataTable.Rows)
{
CswPrimaryKey PermGroupPk = new CswPrimaryKey("nodes", CswConvert.ToInt32(Row["userpermgroup"].ToString()));
CswPrimaryKey PermPk = new CswPrimaryKey("nodes", CswConvert.ToInt32(Row["nodeid"]));
if (false == ret.ContainsKey(PermGroupPk))
{
ret.Add(PermGroupPk, PermPk);
}
}
} // if( CswTools.IsPrimaryKey( CurrentWorkUnitId ) && CswTools.IsPrimaryKey( RoleId ) )
// Cache the general case for next time
if (null == PermObjectClass && false == RequireEdit)
{
_UserPermissions = ret;
}
} // if-else( null == PermObjectClass && false == RequireEdit )
return(ret);
} // getUserPermissions()
public void testMetaData()
{
CswEnumNbtObjectClass fakeObjectClassName = CswEnumNbtObjectClass.FakeClass;
string fakeNodeTypeName = "fake Test";
// new object class
_fakeTestOC = _SchemaModTrnsctn.createObjectClass(fakeObjectClassName, "doc.png", AuditLevel: CswEnumAuditLevel.NoAudit);
Assert.IsNotNull(_fakeTestOC, "fakeTestOC was null");
// new object class prop
CswNbtMetaDataObjectClassProp fakeTestNameOCP = _SchemaModTrnsctn.createObjectClassProp(_fakeTestOC, new CswNbtWcfMetaDataModel.ObjectClassProp()
{
PropName = "Name",
FieldType = CswEnumNbtFieldType.Text
});
Assert.IsNotNull(fakeTestNameOCP, "fakeTestNameOCP was null");
// new nodetype
CswNbtMetaDataNodeType fakeTestNT = _SchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(_fakeTestOC)
{
NodeTypeName = fakeNodeTypeName,
Category = "fake cat"
});
Assert.IsNotNull(fakeTestNT, "fakeTestNT was null");
Assert.IsNotNull(fakeTestNT.DesignNode, "fakeTestNT.DesignNode was null");
Assert.IsNotNull(fakeTestNT.getNodeTypeProp("Name"), "fakeTestNT.getNodeTypeProp( Name ) was null");
Assert.IsNotNull(fakeTestNT.getNodeTypeProp("Name").DesignNode, "fakeTestNT.getNodeTypeProp( Name ).DesignNode was null");
// new nodetype tab
CswNbtMetaDataNodeTypeTab fakeTabNTT = _SchemaModTrnsctn.MetaData.makeNewTab(fakeTestNT, "faketab");
Assert.IsNotNull(fakeTabNTT, "fakeTabNTT was null");
Assert.IsNotNull(fakeTabNTT.DesignNode, "fakeTabNTT.DesignNode was null");
// new nodetype prop
CswNbtMetaDataNodeTypeProp fakeTestStatusNTP = _SchemaModTrnsctn.MetaData.makeNewProp(new CswNbtWcfMetaDataModel.NodeTypeProp(fakeTestNT, _SchemaModTrnsctn.MetaData.getFieldType(CswEnumNbtFieldType.List), "Status"));
Assert.IsNotNull(fakeTestStatusNTP, "fakeTestStatusNTP was null");
Assert.IsNotNull(fakeTestStatusNTP.DesignNode, "fakeTestStatusNTP.DesignNode was null");
// another new object class prop
CswNbtMetaDataObjectClassProp fakeTestNumOCP = _SchemaModTrnsctn.createObjectClassProp(_fakeTestOC, new CswNbtWcfMetaDataModel.ObjectClassProp()
{
PropName = "Num",
FieldType = CswEnumNbtFieldType.Number,
NumberMinValue = 10
});
Assert.IsNotNull(fakeTestNumOCP, "fakeTestNumOCP was null");
// makemissingnodetypeprops
_SchemaModTrnsctn.MetaData.makeMissingNodeTypeProps();
Assert.IsNotNull(fakeTestNT.getNodeTypeProp("Num"), "fakeTestNT.getNodeTypeProp( Num ) was null");
Assert.IsNotNull(fakeTestNT.getNodeTypeProp("Num").DesignNode, "fakeTestNT.DesignNode.getNodeTypeProp( Num ).DesignNode was null");
// ensure both design node and nodetype_prop row are synchronized
Assert.AreEqual(CswConvert.ToInt32(fakeTestNT.getNodeTypeProp("Num")._DataRow[CswEnumNbtNodeTypePropAttributes.numberminvalue]), 10);
Assert.AreEqual(CswConvert.ToInt32(fakeTestNT.getNodeTypeProp("Num").DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.MinimumValue].AsNumber.Value), 10);
} // testMetaData()
public bool hasUserPermissions(CswEnumNbtObjectClass PermObjectClass = null, bool RequireEdit = false)
{
CswNbtObjClassUser UserNode = _CswNbtResources.Nodes[UserId];
return(UserNode.hasUserPermissions(PermObjectClass, RequireEdit));
}
public NodeSelect.Response getNodes(NodeSelect.Request Request)
{
NodeSelect.Response Ret = new NodeSelect.Response();
Ret.CanAdd = true;
Ret.UseSearch = false;
Ret.NodeTypeId = Request.NodeTypeId;
Ret.ObjectClassId = Request.ObjectClassId;
Ret.PropertySetId = Request.PropertySetId;
CswNbtMetaDataObjectClass MetaDataObjectClass = null;
// case 25956
Collection <Int32> NodeTypeIds = new Collection <Int32>();
// If we have a view, use it
CswNbtView View = _getView(Request);
if (null != View)
{
if (Request.PropertySetId > 0)
{
CswNbtMetaDataPropertySet PropSet = _CswNbtResources.MetaData.getPropertySet(Request.PropertySetId);
foreach (CswNbtMetaDataObjectClass OC in PropSet.getObjectClasses())
{
foreach (CswNbtMetaDataNodeType NT in OC.getNodeTypes())
{
NodeTypeIds.Add(NT.NodeTypeId);
}
}
}
else
{
// Absent a MetaDataObject ID,
// the safest assumption is that we want all nodes of the same Object Class at the lowest level of the View,
// using the relationships defined on the View, of course.
Dictionary <Int32, Int32> LowestLevelNodeTypes = _getRelationshipSecondType(View);
foreach (KeyValuePair <int, int> KeyValuePair in LowestLevelNodeTypes)
{
NodeTypeIds.Add(KeyValuePair.Key);
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(KeyValuePair.Key);
Ret.CanAdd = Ret.CanAdd ||
_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create,
NodeType);
}
Ret.ObjectClassId = LowestLevelNodeTypes.FirstOrDefault().Value;
MetaDataObjectClass = _CswNbtResources.MetaData.getObjectClass(Ret.ObjectClassId);
}
}
// If we don't have a view, make one
if (null == View)
{
if (Request.NodeTypeId > 0)
{
CswNbtMetaDataNodeType MetaDataNodeType = _CswNbtResources.MetaData.getNodeType(Request.NodeTypeId);
if (null != MetaDataNodeType)
{
MetaDataObjectClass = MetaDataNodeType.getObjectClass();
NodeTypeIds.Add(MetaDataNodeType.NodeTypeId);
View = new CswNbtView(_CswNbtResources);
View.AddViewRelationship(MetaDataNodeType, IncludeDefaultFilters: true);
Ret.NodeTypeId = MetaDataNodeType.NodeTypeId;
Ret.CanAdd = _CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create, MetaDataNodeType);
}
}
else
{
if (Request.ObjectClassId > 0)
{
MetaDataObjectClass = _CswNbtResources.MetaData.getObjectClass(Request.ObjectClassId);
}
else if (Request.ObjectClass != CswNbtResources.UnknownEnum)
{
MetaDataObjectClass = _CswNbtResources.MetaData.getObjectClass(Request.ObjectClass);
}
if (null != MetaDataObjectClass)
{
Ret.ObjectClassId = MetaDataObjectClass.ObjectClassId;
View = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship Relationship = View.AddViewRelationship(MetaDataObjectClass, IncludeDefaultFilters: true);
if (false == string.IsNullOrEmpty(Request.RelatedToObjectClass) &&
CswTools.IsPrimaryKey(Request.RelatedNodeId))
{
CswEnumNbtObjectClass RealRelatedObjectClass = Request.RelatedToObjectClass;
CswNbtNode RelatedNode = _CswNbtResources.Nodes[Request.RelatedNodeId];
if (null != RelatedNode)
{
if (RelatedNode.ObjClass.ObjectClass.ObjectClass == RealRelatedObjectClass)
{
Collection <CswNbtMetaDataObjectClassProp> RelatedProps = new Collection <CswNbtMetaDataObjectClassProp>();
CswNbtMetaDataObjectClass MetaRelatedObjectClass = _CswNbtResources.MetaData.getObjectClass(RealRelatedObjectClass);
Ret.RelatedObjectClassId = MetaRelatedObjectClass.ObjectClassId;
foreach (CswNbtMetaDataObjectClassProp OcProp in
from _OcProp
in MetaDataObjectClass.getObjectClassProps()
where
_OcProp.getFieldTypeValue() ==
CswEnumNbtFieldType.Relationship &&
//_OcProp.FKType == NbtViewRelatedIdType.ObjectClassId.ToString() &&
//_OcProp.FKValue == MetaRelatedObjectClass.ObjectClassId
_OcProp.FkMatches(MetaRelatedObjectClass)
select _OcProp)
{
RelatedProps.Add(OcProp);
}
if (RelatedProps.Any())
{
foreach (CswNbtMetaDataObjectClassProp RelationshipProp in RelatedProps)
{
View.AddViewPropertyAndFilter(Relationship, RelationshipProp,
SubFieldName:
CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID,
Value:
Request.RelatedNodeId.PrimaryKey.ToString());
}
}
}
}
}
Ret.CanAdd = MetaDataObjectClass.getLatestVersionNodeTypes()
.Aggregate(false,
(current, NodeType) =>
current ||
_CswNbtResources.Permit.canNodeType(
CswEnumNbtNodeTypePermission.Create, NodeType));
}
else
{
Ret.CanAdd = false;
}
}
}
if (null != View)
{
Ret.Nodes = getOptions(View, NodeTypeIds, Ret.ObjectClassId);
Ret.UseSearch = Ret.UseSearch || Ret.Nodes.Count >= _SearchThreshold;
}
return(Ret);
}
