/// <summary>
/// Creates a new user for testing with. It is the consumers responsibility to provide valid values for properties. Supplying a non-existant Role name will throw an error
/// </summary>
private CswNbtObjClassUser _createTestUser(string Username, string RoleName, int PageSize, string Language)
{
CswNbtMetaDataNodeType UserNT = TestData.CswNbtResources.MetaData.getNodeType("User");
if (null == UserNT)
{
throw new CswDniException(CswEnumErrorType.Error, "Unable to create a test User for REST API unit tests - no User NT was found", "Could not find a user NT by name 'User'");
}
CswNbtObjClassRole RoleNode = TestData.CswNbtResources.Nodes.makeRoleNodeFromRoleName(RoleName);
if (null == RoleNode)
{
throw new CswDniException(CswEnumErrorType.Error, "Unable to create a test User for REST API unit tests - no Role with name '" + RoleName + "'", "Could not find a role by name '" + RoleName + "'");
}
CswNbtObjClassUser TestUser = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(UserNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassUser AsUser = NewNode;
AsUser.UsernameProperty.Text = Username;
AsUser.Role.RelatedNodeId = RoleNode.NodeId;
AsUser.PageSizeProperty.Value = PageSize;
AsUser.LanguageProperty.Value = Language;
});
return(TestUser);
}
public override void update()
{
// Remove the "Define Sizes for this Material" landing page item for the Create Material wizard
// Originally added in CswUpdateSchema_01T_Case27881
CswNbtLandingPageTable LandingPageObj = _CswNbtSchemaModTrnsctn.getLandingPageTable();
string CreateMaterialActionId = _CswNbtSchemaModTrnsctn.Actions[CswEnumNbtActionName.Create_Material].ActionId.ToString();
string RoleId = "nodes_1";
CswNbtObjClassRole AdminRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "Administrator" );
if( null != AdminRole )
{
RoleId = AdminRole.NodeId.ToString();
}
LandingPageData Items = LandingPageObj.getLandingPageItems( new LandingPageData.Request()
{
RoleId = RoleId,
ActionId = CreateMaterialActionId
} );
foreach( LandingPageData.LandingPageItem Item in Items.LandingPageItems )
{
if( Item.Text == "Define Sizes for this Material" )
{
LandingPageObj.deleteLandingPageItem( new LandingPageData.Request()
{
LandingPageId = CswConvert.ToInt32( Item.LandingPageId )
} );
}
} // foreach
} // update()
public override void update()
{
//New Document NT
CswNbtMetaDataObjectClass ReceiptLotOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ReceiptLotClass );
CswNbtMetaDataObjectClass CofADocOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.CofADocumentClass );
CswNbtMetaDataNodeType CofANT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "C of A Document" ) ??
_CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeDeprecated( CofADocOC.ObjectClassId, "C of A Document", "Materials" );
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswEnumNbtModuleName.CofA, CofANT.NodeTypeId );
//Default Title
CswNbtMetaDataNodeTypeProp TitleNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Title );
TitleNTP.DefaultValue.AsText.Text = "Certificate of Analysis";
TitleNTP.removeFromLayout( CswEnumNbtLayoutType.Add );
//Set Owner FK to ReceiptLot OC (This needs to be done explicitly for the NTP - see Case 26605)
CswNbtMetaDataNodeTypeProp OwnerNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Owner );
OwnerNTP.PropName = "Receipt Lot";
OwnerNTP.SetFK( CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(), ReceiptLotOC.ObjectClassId );
//Set Prop Filters (This needs to be done explicitly for the NTP - see Case 26605)
CswNbtMetaDataNodeTypeProp FileTypeNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.FileType );
CswNbtMetaDataNodeTypeProp FileNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.File );
FileNTP.setFilter( FileTypeNTP, FileTypeNTP.getFieldTypeRule().SubFields.Default, CswEnumNbtFilterMode.Equals, CswNbtPropertySetDocument.CswEnumDocumentFileTypes.File );
CswNbtMetaDataNodeTypeProp LinkNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Link );
LinkNTP.setFilter( FileTypeNTP, FileTypeNTP.getFieldTypeRule().SubFields.Default, CswEnumNbtFilterMode.Equals, CswNbtPropertySetDocument.CswEnumDocumentFileTypes.Link );
//NT Permission
CswNbtObjClassRole RoleNode = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
if( null != RoleNode )
{
_CswNbtSchemaModTrnsctn.Permit.set( NTPermissions, CofANT, RoleNode, true );
}
} // update()
private void _createNewSDSDocNT()
{
CswEnumNbtNodeTypePermission[] NTPermissions =
{
CswEnumNbtNodeTypePermission.View,
CswEnumNbtNodeTypePermission.Create,
CswEnumNbtNodeTypePermission.Edit,
CswEnumNbtNodeTypePermission.Delete
};
//New Document NT
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
CswNbtMetaDataObjectClass DocumentOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.SDSDocumentClass );
CswNbtMetaDataNodeType SDSNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( DocumentOC.ObjectClassId, "SDS Document", "Materials" );
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswEnumNbtModuleName.SDS, SDSNT.NodeTypeId );
//Default Title
CswNbtMetaDataNodeTypeProp TitleNTP = SDSNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Title );
TitleNTP.DefaultValue.AsText.Text = "Safety Data Sheet";
TitleNTP.removeFromLayout( CswEnumNbtLayoutType.Add );
//Set Owner FK to Material OC (This needs to be done explicitly for the NTP - see Case 26605)
CswNbtMetaDataNodeTypeProp OwnerNTP = SDSNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Owner );
OwnerNTP.PropName = "Material";
OwnerNTP.SetFK( CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(), ChemicalOC.ObjectClassId );
//NT Permission
CswNbtObjClassRole RoleNode = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
if( null != RoleNode )
{
_CswNbtSchemaModTrnsctn.Permit.set( NTPermissions, SDSNT, RoleNode, true );
}
}
}//canAnyTab()
/// <summary>
/// Private logic behind canAnyTab
/// </summary>
private bool _canAnyTabImpl()
{
bool ret = _CanNodeTypeImpl();
if (false == ret)
{
if (_CswNbtPermitInfo.shouldPermissionCheckProceed())
{
foreach (CswNbtMetaDataNodeTypeTab CurrentTab in _CswNbtPermitInfo.NodeType.getNodeTypeTabs())
{
string Permission = CswNbtObjClassRole.MakeNodeTypeTabPermissionValue(
_CswNbtPermitInfo.NodeType.FirstVersionNodeTypeId, CurrentTab.FirstTabVersionId,
_CswNbtPermitInfo.NodeTypeTabPermission);
ret = ret ||
_CswNbtPermitInfo.Role.NodeTypePermissions.CheckValue(Permission);
if (_CswNbtPermitInfo.NodeTypeTabPermission == CswEnumNbtNodeTypeTabPermission.View)
{
// Having 'Edit' grants 'View' automatically
string EditPermission = CswNbtObjClassRole.MakeNodeTypeTabPermissionValue(
_CswNbtPermitInfo.NodeType.FirstVersionNodeTypeId, CurrentTab.FirstTabVersionId,
CswEnumNbtNodeTypeTabPermission.Edit);
ret = ret ||
_CswNbtPermitInfo.Role.NodeTypePermissions.CheckValue(EditPermission);
}
} //iterate tabs
} // if( _CswNbtPermitInfo.shouldPermissionCheckProceed() )
}
return(ret);
} //_canAnyTab()
} // update()
private void _addMaterialComponentPermissions()
{
CswNbtMetaDataObjectClass MaterialComponentOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.MaterialComponentClass );
if( null != MaterialComponentOC )
{
CswNbtMetaDataNodeType MaterialComponentNT = MaterialComponentOC.getNodeTypes().FirstOrDefault();
if( null != MaterialComponentNT )
{
string[] FullPermissionRoles = { "CISPro_Admin", "CISPro_General", "CISPro_Receiver", "CISPro_Request_Fulfiller", "Administrator" };
CswEnumNbtNodeTypePermission[] AllPermissions =
{
CswEnumNbtNodeTypePermission.View,
CswEnumNbtNodeTypePermission.Create,
CswEnumNbtNodeTypePermission.Edit,
CswEnumNbtNodeTypePermission.Delete
};
foreach( string RoleName in FullPermissionRoles )
{
CswNbtObjClassRole Role = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( RoleName );
_CswNbtSchemaModTrnsctn.Permit.set( AllPermissions, MaterialComponentNT, Role, true );
}
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.View, MaterialComponentNT, true );
}//if( null != MaterialComponentNT )
}//if( null != MaterialComponentOC )
}//_addMaterialComponentPermissions()
public override void update()
{
//Remove the Modules action permission from every role except ChemSW_Admin
string ModuleActionValue = CswNbtObjClassRole.MakeActionPermissionValue( _CswNbtSchemaModTrnsctn.Actions[CswEnumNbtActionName.Modules] );
CswNbtMetaDataObjectClass RoleOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RoleClass );
foreach( CswNbtObjClassRole RoleNode in RoleOC.getNodes( false, true, false, true ) )
{
if( RoleNode.Name.Text != CswNbtObjClassRole.ChemSWAdminRoleName )
{
if( RoleNode.ActionPermissions.CheckValue( ModuleActionValue ) )
{
RoleNode.ActionPermissions.RemoveValue( ModuleActionValue );
RoleNode.postChanges( false );
}
}
else
{
if( false == RoleNode.ActionPermissions.CheckValue( ModuleActionValue ) )
{
RoleNode.ActionPermissions.AddValue( ModuleActionValue );
RoleNode.postChanges( false );
}
}
}
} // update()
} //canNodeType()
/// <summary>
/// Private logic behind canNodeType
/// </summary>
private bool _CanNodeTypeImpl()
{
bool ret = _CswNbtPermitInfo.IsUberUser;
if (false == ret)
{
if (_CswNbtPermitInfo.shouldPermissionCheckProceed())
{
ret = _CswNbtPermitInfo.NoExceptionCases;
if (ret)
{
// Base case: does the Role have this nodetype permission
string PermissionValueToCheck = CswNbtObjClassRole.MakeNodeTypePermissionValue(_CswNbtPermitInfo.NodeType.FirstVersionNodeTypeId,
_CswNbtPermitInfo.NodeTypePermission);
ret = ret && _CswNbtPermitInfo.Role.NodeTypePermissions.CheckValue(PermissionValueToCheck);
if ((false == ret) && (_CswNbtPermitInfo.NodeTypePermission == CswEnumNbtNodeTypePermission.View))
{
// Having 'Edit' grants 'View' automatically
ret = _CswNbtPermitInfo.Role.NodeTypePermissions.CheckValue(CswNbtObjClassRole.MakeNodeTypePermissionValue(_CswNbtPermitInfo.NodeType.FirstVersionNodeTypeId, CswEnumNbtNodeTypePermission.Edit));
} //if we denied view permission
}
} //if pre-reqs are satisifed
}
return(ret);
} // _CanNodeTypeImpl()
public override void update()
{
_CswNbtSchemaModTrnsctn.deleteModuleActionJunction(CswNbtModuleName.NBTManager, CswNbtActionName.View_Scheduled_Rules );
CswNbtObjClassRole CswAdmin = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( CswNbtObjClassRole.ChemSWAdminRoleName );
if( null != CswAdmin )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtActionName.View_Scheduled_Rules, CswAdmin, value: true );
}
CswNbtMetaDataObjectClass RoleOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.RoleClass );
Int32 ActionId = _CswNbtSchemaModTrnsctn.getActionId( CswNbtActionName.View_Scheduled_Rules );
foreach( CswNbtObjClassRole RoleNode in RoleOc.getNodes(includeSystemNodes: false, forceReInit: true) )
{
if( _CswNbtSchemaModTrnsctn.Permit.can( CswNbtActionName.View_Scheduled_Rules, RoleNode ) )
{
CswNbtLandingPageTable Lp = _CswNbtSchemaModTrnsctn.getLandingPageTable();
Lp.addLandingPageItem(new LandingPageData.Request
{
//LandingPageId =
RoleId = RoleNode.NodeId.ToString(),
Text = "View Scheduled Rules",
Type = CswNbtLandingPageItemType.Link,
ViewType = "Action",
PkValue = ActionId.ToString(),
NewRow = 1,
NewColumn = 2
});
}
}
}
public override void update()
{
if( _CswNbtSchemaModTrnsctn.isMaster() )
{
CswNbtObjClassRole CISProReceiverRole = null;
CswNbtMetaDataObjectClass RoleOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RoleClass );
foreach( CswNbtObjClassRole RoleNode in RoleOC.getNodes( false, false, false, true ) )
{
if( RoleNode.Name.Text == "CISPro_Receiver" )
{
CISProReceiverRole = RoleNode;
break;
}
}
if( null != CISProReceiverRole )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtActionName.Create_Material, CISProReceiverRole, true );
CswNbtMetaDataPropertySet MaterialPS = _CswNbtSchemaModTrnsctn.MetaData.getPropertySet( CswEnumNbtPropertySetName.MaterialSet );
foreach( CswNbtMetaDataObjectClass MaterialOC in MaterialPS.getObjectClasses() )
{
foreach( CswNbtMetaDataNodeType MaterialNT in MaterialOC.getNodeTypes() )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.View, MaterialNT, CISProReceiverRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Edit, MaterialNT, CISProReceiverRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Create, MaterialNT, CISProReceiverRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Delete, MaterialNT, CISProReceiverRole, true );
}
}
}
}
} // update()
public override void update()
{
// Add nodetypes for new object classes
CswNbtMetaDataObjectClass RegListMemberOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RegulatoryListMemberClass );
CswNbtMetaDataObjectClassProp RegListMemberChemicalOCP = RegListMemberOC.getObjectClassProp( CswNbtObjClassRegulatoryListMember.PropertyName.Chemical );
CswNbtMetaDataNodeType RegListMemberNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeDeprecated( new CswNbtWcfMetaDataModel.NodeType( RegListMemberOC )
{
NodeTypeName = "Regulatory List Member",
Category = "Materials",
SearchDeferObjectClassPropId = RegListMemberChemicalOCP.ObjectClassPropId
} );
RegListMemberNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListMember.PropertyName.Chemical ) + "-" + CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListMember.PropertyName.RegulatoryList ) );
RegListMemberNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRegulatoryListMember.PropertyName.ByUser ).removeFromLayout( CswEnumNbtLayoutType.Add );
CswNbtMetaDataObjectClass RegListCasNoOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RegulatoryListCasNoClass );
CswNbtMetaDataObjectClassProp RegListCasNoRegListOCP = RegListCasNoOC.getObjectClassProp( CswNbtObjClassRegulatoryListCasNo.PropertyName.RegulatoryList );
CswNbtMetaDataNodeType RegListCasNoNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeDeprecated( new CswNbtWcfMetaDataModel.NodeType( RegListCasNoOC )
{
NodeTypeName = "Regulatory List CAS",
Category = "Materials",
SearchDeferObjectClassPropId = RegListCasNoRegListOCP.ObjectClassPropId
} );
RegListCasNoNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListCasNo.PropertyName.RegulatoryList ) + "-" + CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListCasNo.PropertyName.CASNo ) );
// Grant permissions to cispro_admin
CswNbtObjClassRole CISProAdminRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
CswEnumNbtNodeTypePermission[] AllPerms = new CswEnumNbtNodeTypePermission[]
{
CswEnumNbtNodeTypePermission.Create, CswEnumNbtNodeTypePermission.Delete, CswEnumNbtNodeTypePermission.Edit, CswEnumNbtNodeTypePermission.View
};
_CswNbtSchemaModTrnsctn.Permit.set( AllPerms, RegListMemberNT, CISProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( AllPerms, RegListCasNoNT, CISProAdminRole, true );
} // update()
private CswNbtObjClassRole _createRole( CswNbtMetaDataNodeType RoleNodeType, string RoleName )
{
CswNbtNode RoleNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( RoleNodeType.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
CswNbtObjClassRole NodeAsRole = RoleNode;
NodeAsRole.Name.Text = RoleName;
NodeAsRole.Timeout.Value = 30;
return NodeAsRole;
}
private void _setNodeTypePermissions( CswNbtObjClassRole Role, CswNbtMetaDataObjectClass.NbtObjectClass ObjClassName, CswNbtPermit.NodeTypePermission[] Permissions )
{
CswNbtMetaDataObjectClass ObjectClass = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( ObjClassName );
foreach( CswNbtMetaDataNodeType NodeType in ObjectClass.getNodeTypes() )
{
_CswNbtSchemaModTrnsctn.Permit.set( Permissions, NodeType, Role, true );
}
}
public static void setReceiptLotPermissions(CswNbtResources CswNbtResources, bool ModuleIsActive)
{
// CIS-52258 - grant Receipt Lot permissions to cispro_ roles
CswNbtMetaDataObjectClass ReceiptLotOC = CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ReceiptLotClass);
CswNbtMetaDataObjectClass RoleOC = CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RoleClass);
CswNbtMetaDataObjectClassProp RoleNameOCP = RoleOC.getObjectClassProp(CswNbtObjClassRole.PropertyName.Name);
CswNbtView View = new CswNbtView(CswNbtResources);
View.ViewName = "MLM Enable - Find CISPro roles";
CswNbtViewRelationship roleRelationship = View.AddViewRelationship(RoleOC, false);
CswNbtViewProperty roleNameProp = View.AddViewProperty(roleRelationship, RoleNameOCP);
View.AddViewPropertyFilter(roleNameProp,
SubFieldName: CswNbtFieldTypeRuleText.SubFieldName.Text,
FilterMode: CswEnumNbtFilterMode.Begins,
Value: "cispro_",
CaseSensitive: false);
ICswNbtTree RoleTree = CswNbtResources.Trees.getTreeFromView(View, false, true, IncludeHiddenNodes: true);
for (Int32 r = 0; r < RoleTree.getChildNodeCount(); r++)
{
RoleTree.goToNthChild(r);
CswNbtObjClassRole RoleNode = RoleTree.getCurrentNode();
foreach (CswNbtMetaDataNodeType ReceiptLotNT in ReceiptLotOC.getNodeTypes())
{
//if MLM is on, everyone needs View and admins/receivers need Edit
if (CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.MLM))
{
CswNbtResources.Permit.set(CswEnumNbtNodeTypePermission.View, ReceiptLotNT, RoleNode, true);
if ("cispro_receiver" == RoleNode.Name.Text.ToLower() ||
"cispro_admin" == RoleNode.Name.Text.ToLower())
{
CswNbtResources.Permit.set(CswEnumNbtNodeTypePermission.Edit, ReceiptLotNT, RoleNode, true);
}
}
//otherwise, if only Lot Info is on, no one needs Edit, but everyone needs View
else if (CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.ManufacturerLotInfo))
{
CswNbtResources.Permit.set(CswEnumNbtNodeTypePermission.View, ReceiptLotNT, RoleNode, true);
CswNbtResources.Permit.set(CswEnumNbtNodeTypePermission.Edit, ReceiptLotNT, RoleNode, false);
}
//if both MLM and Lot Info are off, no one needs to View or Edit
else
{
CswNbtResources.Permit.set(CswEnumNbtNodeTypePermission.View, ReceiptLotNT, RoleNode, false);
CswNbtResources.Permit.set(CswEnumNbtNodeTypePermission.Edit, ReceiptLotNT, RoleNode, false);
}
}
//RoleNode.postChanges( false ); CswNbtPermit does this.
RoleTree.goToParentNode();
}
} // setReceiptLotPermissions()
public override void update()
{
// Delete all 'Roles and Users' views except 1
CswNbtObjClassRole ChemSWAdmin = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( CswNbtObjClassRole.ChemSWAdminRoleName );
foreach( CswNbtView CurrentView in _CswNbtSchemaModTrnsctn.ViewSelect.restoreViews( "Roles and Users" ).Where( CurrentView => CurrentView.VisibilityRoleId != ChemSWAdmin.NodeId ) )
{
CurrentView.Delete();
}
}// update()
//Update()
private void _markRoleAsDemoData( string RoleName )
{
CswNbtObjClassRole RoleNode = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( RoleName );
if( null != RoleNode )
{
RoleNode.IsDemo = true;
RoleNode.postChanges( false );
}
}
public override void update()
{
CswNbtObjClassRole NodeAsRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "Dispenser" );
if( null != NodeAsRole )
{
NodeAsRole.Name.Text = "CISPro_Dispenser";
NodeAsRole.postChanges( true );
}
}//Update()
/// <summary>
/// Returns true if the role has the appropriate permissions for the Action
/// </summary>
public bool can(CswNbtAction Action, CswNbtObjClassRole Role)
{
bool ret = false;
if (null != Role && null != Action)
{
ret = Role.ActionPermissions.CheckValue(CswNbtObjClassRole.MakeActionPermissionValue(Action));
}
return(ret);
} // can( CswNbtAction Action, CswNbtObjClassRole Role )
public CswNbtPermitInfo(CswNbtResources CswNbtResources, ICswNbtUser CswNbtUser, CswNbtObjClassRole CswNbtObjClassRole, CswNbtMetaDataNodeType NodeTypeIn, CswEnumNbtNodeTypePermission nodeTypePermissionIn, CswPrimaryKey CswPrimaryKey, CswNbtMetaDataNodeTypeProp PropTypeIn)
{
PropType = PropTypeIn;
_NodePrimeKey = CswPrimaryKey;
NodeType = NodeTypeIn;
_CswNbtResources = CswNbtResources;
_CswNbtUser = CswNbtUser;
_CswNbtObjClassRole = CswNbtObjClassRole;
NodeTypePermission = nodeTypePermissionIn;
}//ctor
private void _createViewOnlyRole( CswNbtMetaDataNodeType RoleNodeType )
{
CswNbtObjClassRole ViewOnlyNode = _createRole( RoleNodeType, "CISPro_View_Only" );
_setGenericPermissions( ViewOnlyNode, ViewPermissions );
_setCISProPermissions( ViewOnlyNode, ViewPermissions );
ViewOnlyNode.postChanges( false );
_createInventoryGroupPermission( ViewOnlyNode, Tristate.False, Tristate.False );
}
private void _initPermissionInfo(CswNbtObjClassRole CswNbtObjClassRole, ICswNbtUser CswNbtUser, CswNbtMetaDataNodeType NodeType, CswEnumNbtNodeTypePermission Permission, CswPrimaryKey CswPrimaryKey = null, CswNbtMetaDataNodeTypeProp PropType = null)
{
if (null == CswNbtObjClassRole)
{
CswPrimaryKey RoleId = null;
if (null != CswNbtUser)
{
RoleId = CswNbtUser.RoleId;
}
else
{
if (null != _CswNbtResources.CurrentNbtUser)
{
CswNbtUser = _CswNbtResources.CurrentNbtUser;
RoleId = CswNbtUser.RoleId;
}
}//if the user we got is null
if (null != RoleId)
{
CswNbtObjClassRole = _getRole(RoleId);
} //if we were able to get a roleid
} //if the role we got is null
if (null != CswNbtObjClassRole)
{
CswNbtPermitInfoKey CswNbtPermitInfoKey = new CswNbtPermitInfoKey(CswNbtObjClassRole, NodeType);
if (_PermitInfoItems.ContainsKey(CswNbtPermitInfoKey))
{
_CswNbtPermitInfo = _PermitInfoItems[CswNbtPermitInfoKey];
//must reset these per-request because they change per request for the same role and nodetype (e.g., see allowAny() )
if (null != CswPrimaryKey)
{
_CswNbtPermitInfo.NodePrimeKey = CswPrimaryKey;
}
if (null != PropType)
{
_CswNbtPermitInfo.PropType = PropType;
}
_CswNbtPermitInfo.NodeTypePermission = Permission;
}
else
{
_CswNbtPermitInfo = new CswNbtPermitInfo(_CswNbtResources, CswNbtUser, CswNbtObjClassRole, NodeType, Permission, CswPrimaryKey, PropType);
_PermitInfoItems.Add(CswNbtPermitInfoKey, _CswNbtPermitInfo);
}
}
else //the permit info in this case is not catalogued, and permit info won't allow any ops to proceed
{
_CswNbtPermitInfo = new CswNbtPermitInfo(_CswNbtResources, CswNbtUser, CswNbtObjClassRole, NodeType, Permission, CswPrimaryKey, PropType);
} //if we were able to retrieve a role
} //_initPermissionInfo()
private void _createUser( CswNbtMetaDataNodeType UserNodeType, CswNbtObjClassRole RoleNode, string UserName )
{
CswNbtObjClassUser UserNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( UserNodeType.NodeTypeId, CswEnumNbtMakeNodeOperation.WriteNode );
UserNode.UsernameProperty.Text = UserName;
UserNode.PasswordProperty.Password = UserName+"123!";
UserNode.Role.RelatedNodeId = RoleNode.NodeId;
UserNode.LanguageProperty.Value = "en";
UserNode.AccountLocked.Checked = CswEnumTristate.True;
UserNode.postChanges( false );
}
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 );
}
}
public CswNbtResources makeNewUserResources(string UserName, CswPrimaryKey RoleId)
{
//CswNbtResources Ret = CswNbtResourcesFactory.makeCswNbtResources( _CswNbtResources );
CswNbtResources Ret = CswNbtResourcesFactory.makeCswNbtResources(CswEnumAppType.Nbt, CswEnumSetupMode.TestProject, true);
Ret.AccessId = _CswNbtResources.AccessId;
CswNbtObjClassRole Role = Ret.Nodes[RoleId];
Ret.InitCurrentUser = Resources => _InitNewUser(Resources, Ret, UserName, Role);
return(Ret);
}
public override void update()
{
CswNbtObjClassRole AdminRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "Administrator" );
CswNbtViewId MyBatchOperationsViewId = null;
CswNbtView MyBatchOperationsView = null;
DataTable Views = _CswNbtSchemaModTrnsctn.ViewSelect.getView( "My Batch Operations", CswEnumNbtViewVisibility.Global, null, null );
if( Views.Rows.Count > 0 )
{
MyBatchOperationsViewId = new CswNbtViewId( CswConvert.ToInt32( Views.Rows[0]["nodeviewid"] ) );
MyBatchOperationsView = _CswNbtSchemaModTrnsctn.ViewSelect.restoreView( MyBatchOperationsViewId );
}
if( null == MyBatchOperationsView )
{
throw new CswDniException( CswEnumErrorType.Error, "My Batch Operations View does not exist", "The My Batch Operations View is needed to configure a landing page for the Receiving Wizard" );
}
if( null == AdminRole )
{
throw new CswDniException( CswEnumErrorType.Error, "Administrator Role does not exist", "The Administrator Role is needed to configure a landing page for the Receiving Wizard" );
}
/*
* Case 31560 -- this button is now a link on the left hand side so that it only appears conditionally
*
_CswNbtSchemaModTrnsctn.LandingPage.addLandingPageItem( CswEnumNbtLandingPageItemType.Link, new LandingPageData.Request()
{
ActionId = _CswNbtSchemaModTrnsctn.Actions[CswEnumNbtActionName.Receiving].ActionId.ToString(),
NodeViewId = MyBatchOperationsViewId.ToString(), //I think we have to set PkValue and not NodeViewId...but idk why
PkValue = MyBatchOperationsViewId.ToString(),
ViewType = CswEnumNbtViewType.View.ToString(),
RoleId = AdminRole.NodeId.ToString(),
Text = "My Batch Operations",
NewColumn = 1,
NewRow = 1
} );
*/
CswNbtMetaDataObjectClass ChemicalClass = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
CswNbtMetaDataObjectClassProp ReceiveOCP = ChemicalClass.getObjectClassProp( CswNbtObjClassChemical.PropertyName.Receive );
_CswNbtSchemaModTrnsctn.LandingPage.addLandingPageItem( CswEnumNbtLandingPageItemType.Button, new LandingPageData.Request()
{
ActionId = _CswNbtSchemaModTrnsctn.Actions[CswEnumNbtActionName.Receiving].ActionId.ToString(),
PkValue = ReceiveOCP.PropId.ToString(),
RoleId = AdminRole.NodeId.ToString(),
Text = "Receive more of this Material",
NewColumn = 2,
NewRow = 1
} );
} // update()
public CswNbtPermitInfoKey(CswNbtObjClassRole CswNbtObjClassRole, CswNbtMetaDataNodeType NodeTypeIn)
{
Role = CswNbtObjClassRole;
NodeType = NodeTypeIn;
if (null != Role)
{
HashMultiplier += Role.GetHashCode();
}
if (null != NodeType)
{
HashMultiplier += NodeType.GetHashCode();
}
}
private void _setCISProPermissions( CswNbtObjClassRole Role, CswNbtPermit.NodeTypePermission[] Permissions )
{
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.ContainerClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.ContainerDispenseTransactionClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.InventoryGroupClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.InventoryGroupPermissionClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.InventoryLevelClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.MaterialComponentClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.MaterialSynonymClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.RequestClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.RequestItemClass, Permissions );
_setNodeTypePermissions( Role, CswNbtMetaDataObjectClass.NbtObjectClass.SizeClass, Permissions );
}
private CswNbtObjClassRole _createRole( CswNbtMetaDataNodeType RoleNodeType, string RoleName )
{
CswNbtObjClassRole RoleNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( RoleNodeType.NodeTypeId, CswEnumNbtMakeNodeOperation.WriteNode );
RoleNode.Name.Text = RoleName;
RoleNode.Timeout.Value = 30;
CswEnumNbtNodeTypePermission[] ViewPermissions = { CswEnumNbtNodeTypePermission.View };
foreach( CswNbtMetaDataNodeType NodeType in _CswNbtSchemaModTrnsctn.MetaData.getNodeTypes() )
{
bool canView = false == ( NodeType.NodeTypeName == "Role" || NodeType.NodeTypeName == "User" );
_CswNbtSchemaModTrnsctn.Permit.set( ViewPermissions, NodeType, RoleNode, canView );
}
RoleNode.postChanges( false );
return RoleNode;
}
private void _createGeneralRole( CswNbtMetaDataNodeType RoleNodeType )
{
CswNbtObjClassRole GeneralNode = _createRole( RoleNodeType, "CISPro_General" );
_setGenericPermissions( GeneralNode, ViewPermissions );
_setCISProPermissions( GeneralNode, ViewPermissions );
_setNodeTypePermissions( GeneralNode, CswNbtMetaDataObjectClass.NbtObjectClass.ContainerClass, FullPermissions );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtActionName.DispenseContainer, GeneralNode, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtActionName.DisposeContainer, GeneralNode, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtActionName.Submit_Request, GeneralNode, true );
GeneralNode.postChanges( false );
_createInventoryGroupPermission( GeneralNode, Tristate.True, Tristate.False );
}
public override void update()
{
CswNbtObjClassRole CISPro_Request_Fulfiller = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "cispro_request_fulfiller" );
CswNbtMetaDataObjectClass requestContainerUpdateOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.RequestContainerUpdateClass );
if( null != CISPro_Request_Fulfiller )
{
foreach( CswNbtMetaDataNodeType requestContainerUpdateNT in requestContainerUpdateOC.getNodeTypes() )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.View, requestContainerUpdateNT, CISPro_Request_Fulfiller, true );
}
}
} //Update()
