/// <summary> /// Returns a hashmap of service admin grants. /// Keys are process agent IDs where the process agent is the qualifier of the grant /// Values are lists of service admin grants that have that process agent as a qualifier /// /// A grant is a service admin grant if /// 1. The agent is a service admin group /// 2. The function should be a "service admin" or "service management" ticket type /// 3. qualifier should be a process agent /// </summary> /// <returns></returns> protected Dictionary<int, List<Grant>> getServiceAdminGrants() { // initializations Dictionary<int, List<Grant>> servAdminGrants = new Dictionary<int, List<Grant>>(); AuthorizationWrapperClass wrapper = new AuthorizationWrapperClass(); // get all grants int[] grantIDs = wrapper.ListGrantIDsWrapper(); Grant[] grants = wrapper.GetGrantsWrapper(grantIDs); int effGroupID = Convert.ToInt32(Session["GroupID"]); foreach (Grant grant in grants) { if (grant.agentID.Equals(effGroupID)) { // check if the grant is a service admin or service manage grant // 1. agent should be a "service admin" group // 2. function should be a "service admin" or "service management" ticket type // 3. qualifier should be a process agent int paID = 0; Qualifier qualifier = new Qualifier(); string function = grant.function; if (TicketTypes.IsAdministerPAType(function)) { // get process agent that corresponds to qualifier qualifier = AuthorizationAPI.GetQualifier(grant.qualifierID); paID = qualifier.qualifierReferenceID; } else if (TicketTypes.IsManagePAType(function)) { bool isManage = true; bool isProcessAgent = false; int targetId = -1; qualifier = AuthorizationAPI.GetQualifier(grant.qualifierID); //Qualifier is a Resource Mapping if (qualifier.qualifierType.Equals(Qualifier.resourceMappingQualifierTypeID)) { //int resourceMappingID = ; ResourceMapping mapping = ticketIssuer.GetResourceMapping(qualifier.qualifierReferenceID); if (mapping != null) { ResourceMappingKey mappingKey = mapping.Key; if (mapping.Key.Type.Equals(ResourceMappingTypes.GROUP)) { if (mapping.values[0].Type == ResourceMappingTypes.CLIENT) paID = ticketIssuer.FindProcessAgentIdForClient((int)mapping.values[0].Entry, ProcessAgentType.SCHEDULING_SERVER); } else if (mapping.Key.Type.Equals(ResourceMappingTypes.PROCESS_AGENT)) { if (mapping.values[2].Type.Equals(ResourceMappingTypes.TICKET_TYPE))// && mapping.values[2].Entry.Equals(TicketTypes.GetTicketType(TicketTypes.MANAGE_USS_GROUP))) { paID = (int)mapping.values[1].Entry; ResourceMappingValue[] mappingValues = mapping.values; //TO BE FIXED: I am assuming that the Mapping has 3 values, the 3rd one being the Ticket Type, //the 2nd one being the Process Agent, and the 1st one the Resource Type. //if (mappingValues[2].Type.Equals(ResourceMappingTypes.TICKET_TYPE)) //{ // if (TicketTypes.IsManagePAType((string)mappingValues[2].Entry)) // isManage = true; //} if (mappingValues[1].Type.Equals(ResourceMappingTypes.PROCESS_AGENT)) { isProcessAgent = true; targetId = (int)mappingValues[1].Entry; } } } } } } if (paID > 0) { //get the list of grants that correspond to the process agent qualifier List<Grant> list = new List<Grant>(); if (servAdminGrants.TryGetValue(paID, out list)) { // process agent already exists // add grant list.Add(grant); } else // process agent does not exist // add list { list = new List<Grant>(); list.Add(grant); servAdminGrants.Add(paID, list); } } } } return servAdminGrants; }
/* !------------------------------------------------------------------------------! * CALLS FOR QUALIFIERS - DATABASE CALLS * !------------------------------------------------------------------------------! */ /// <summary> /// to add a qualifier - returns the qualifierID /// </summary> public static int InsertQualifier(Qualifier qualifier) { int qID= -1; DbConnection myConnection = FactoryDB.GetConnection(); DbCommand myCommand = FactoryDB.CreateCommand("AddQualifier", myConnection); myCommand.CommandType = CommandType.StoredProcedure; myCommand.Parameters.Add(FactoryDB.CreateParameter(myCommand, "@qualifierTypeID", qualifier.qualifierType, DbType.Int32)); myCommand.Parameters.Add(FactoryDB.CreateParameter(myCommand, "@qualifierReferenceID", qualifier.qualifierReferenceID, DbType.Int32)); myCommand.Parameters.Add(FactoryDB.CreateParameter(myCommand, "@qualifierName", qualifier.qualifierName, DbType.String,512)); try { myConnection.Open(); qID = Convert.ToInt32(myCommand.ExecuteScalar()); if (qID>0) { //Refresh cache AuthCache.QualifierSet = InternalAuthorizationDB.RetrieveQualifiers(); AuthCache.QualifierHierarchySet = InternalAuthorizationDB.RetrieveQualifierHierarchy(); } } catch (Exception ex) { throw new Exception("Exception thrown in InsertQualifier. "+ ex.Message,ex); } finally { myConnection.Close(); } return qID; }
/// <summary> /// /// </summary> /// <param name="qualifierReferenceID">the ID of the resource represented by the qualifier (null if not necessary);</param> /// <param name="type">one of the statically configured qualifierTypes registered with the Service Broker; the qualifier type is used to check type compatibility between function and qualifier in grants</param> /// <param name="name">A semantically meaningful string describing the purpose of the qualifier</param> /// <param name="parentQualifierID">the ID of a previously created Qualifier to serve as the parent of the Qualifier being added; the parentID locates the new Qualifier in the hierarchy; additional parents may be added by the AddQualifier-Parent() method</param> /// <returns>the ID of the new qualifier if it is successfully created, null otherwise</returns> public static int AddQualifier( int qualifierReferenceID, int type, string name, int parentQualifierID ) { Qualifier q = new Qualifier(); q.qualifierReferenceID = qualifierReferenceID; q.qualifierType = type; q.qualifierName = name; bool qualifierReferenceIDValid = false; int qualifierID = -1; ProcessAgentDB db = new ProcessAgentDB(); ProcessAgent agent = null; //need to check whether the qualifierReferenceID for a particular qualifierType //actually exists before it is added to the table switch (type) { // LabServerfo // Replace with case for all processAgent types an use exits for the combination of ID & type case Qualifier.labServerQualifierTypeID: { agent = db.GetProcessAgent(qualifierReferenceID); if(agent != null && ((agent.type.Equals(ProcessAgentType.BATCH_LAB_SERVER)) ||(agent.type.Equals(ProcessAgentType.LAB_SERVER)))){ qualifierReferenceIDValid = true; } break; } //LabClient case Qualifier.serviceBrokerQualifierTypeID: { agent = db.GetProcessAgent(qualifierReferenceID); if (agent != null && ((agent.type.Equals(ProcessAgentType.SERVICE_BROKER)) ||(agent.type.Equals(ProcessAgentType.BATCH_SERVICE_BROKER)) || (agent.type.Equals(ProcessAgentType.REMOTE_SERVICE_BROKER)))) { qualifierReferenceIDValid = true; } break; } case Qualifier.labSchedulingQualifierTypeID: { agent = db.GetProcessAgent(qualifierReferenceID); if (agent != null && agent.type.Equals(ProcessAgentType.LAB_SCHEDULING_SERVER)) { qualifierReferenceIDValid = true; } break; } case Qualifier.userSchedulingQualifierTypeID: { agent = db.GetProcessAgent(qualifierReferenceID); if (agent != null && agent.type.Equals(ProcessAgentType.SCHEDULING_SERVER)) { qualifierReferenceIDValid = true; } break; } case Qualifier.storageServerQualifierTypeID: { agent = db.GetProcessAgent(qualifierReferenceID); if (agent != null && agent.type.Equals(ProcessAgentType.EXPERIMENT_STORAGE_SERVER)) { qualifierReferenceIDValid = true; } break; } case Qualifier.labClientQualifierTypeID: { int[] labClientIDs = InternalAdminDB.SelectLabClientIDs(); foreach (int labClientID in labClientIDs) { if (labClientID == qualifierReferenceID) { qualifierReferenceIDValid = true; break; } } break; } //Group case Qualifier.groupQualifierTypeID: { int[] groupIDs = InternalAdminDB.SelectGroupIDs(); foreach(int groupID in groupIDs) { if(groupID == qualifierReferenceID) { qualifierReferenceIDValid = true; break; } } break; } //Experiment Collection case Qualifier.experimentCollectionQualifierTypeID: { int[] groupIDs = InternalAdminDB.SelectGroupIDs(); foreach(int groupID in groupIDs) { if(groupID == qualifierReferenceID) { qualifierReferenceIDValid = true; break; } } break; } //Experiment case Qualifier.experimentQualifierTypeID: { Criterion c = new Criterion("experiment_id","=",qualifierReferenceID.ToString()); if (InternalDataDB.SelectExperimentIDs(new Criterion[] { c }).Length > 0) qualifierReferenceIDValid = true; break; } // Resource Mapping case Qualifier.resourceMappingQualifierTypeID: { BrokerDB brokerDb = new BrokerDB(); ResourceMapping mapping = brokerDb.GetResourceMapping(qualifierReferenceID); if (mapping != null) qualifierReferenceIDValid = true; break; } } if(qualifierReferenceIDValid) { try { qualifierID = InternalAuthorizationDB.InsertQualifier(q); if(qualifierID != -1) { InternalAuthorizationDB.InsertQualifierHierarchy(qualifierID,parentQualifierID); } } catch(Exception ex) { throw; } } return qualifierID; }
/// <summary> /// method returns the qualifier instance associated with the supplied argument /// </summary> /// <param name="qualifierID"></param> /// <returns>a qualifier instance pertaining to the supplied qualifier ID; otherwise an empty qualifier instance</returns> public static Qualifier GetQualifierFromDS(int qualifierID) { Qualifier q = new Qualifier(); DataTable qualifiersTable = AuthCache.QualifierSet.Tables[0]; string query = "qualifier_id = " + qualifierID; DataRow []rows = qualifiersTable.Select(query); foreach(DataRow dataRow in rows) { q.qualifierReferenceID = Convert.ToInt32(dataRow["qualifier_reference_id"]); q.qualifierType = Convert.ToInt32(dataRow["qualifier_type_id"]); q.qualifierID = Convert.ToInt32(dataRow["qualifier_id"]); q.qualifierName = dataRow["qualifier_name"].ToString(); break; } return q; }