/// <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;
}
