EssGetDatabaseAccessEx

Gets a list of user database access structures, which contain information about user access to databases. Similar to EssGetDatabaseAccess, but can accept a user directory specification or unique identity attribute for UserID.

Syntax

ESS_FUNC_M EssGetDatabaseAccessEx (hCtx, UserId, bIsIdentity, type, AppName, DbName, pCount, ppUserDb);

Parameter	Data Type	Description
hCtx	ESS_HCTX_T	API context handle (input).
UserId	ESS_STR_T	User or group name (input). Can be specified as name@provider or as a unique identity attribute. If NULL, lists all users or groups for the specified database.
bIsIdentity	ESS_BOOL_T	Input. Indicates if UserID is a name or an identity. If TRUE, UserID is an identity.
type	ESS_USHORT_T	Type of entity (input). Indicates if UserID is a group or a user. Can be one of the following: ESS_TYPE_USER ESS_TYPE_GROUP
AppName	ESS_STR_T	Application name (input). If NULL, lists all applications and databases for the specified user.
DbName	ESS_STR_T	Database name (input). If NULL, lists all databases for the specified user or application.
pCount	ESS_PUSHORT_T	Address of variable to receive count of user database structures (output).
ppUserDb	ESS_PPUSERDBEX_T	Address of pointer to receive an allocated array of user database structures (output). The user database structure can include user directories and unique identity attributes.

Notes

If any of UserID, AppName, or DbName are NULL, they will be treated as wild cards and all items of the appropriate type will be listed. If AppName is NULL, DbName is assumed to also be NULL. Any two of these arguments may be NULL, but not all three.
The Access field of the user database structure is used to represent the user's granted access to the database, whereas the MaxAccess field represents the user's highest access from all sources (e.g. via groups or default database access etc.).
The memory allocated for ppUserDb should be freed using EssFree().
Filter access privileges are equivalent to ESS_PRIV_DBLOAD privileges.

Return Value

If successful, returns a count of users/databases in pCount, and a list of user database structures in ppUserDb.

Access

This function requires the caller to have database Design privilege (ESS_PRIV_DBDESIGN) for the specified database, unless they are getting their own database access information.

Example


void DisplayUserDbInfo(ESS_PUSERDBEX_T userDb, ESS_USHORT_T count)
{
   ESS_STS_T sts = ESS_STS_NOERR;
   ESS_USHORT_T ind;

   printf ("\n------Database Access List----\n\n");    
   for (ind = 0; ind < count; ind++)
   {
      printf("\tUser: %s\n", userDb[ind].UserName);
      printf("\tProvider Name: %s\n", userDb[ind].ProviderName);
      printf("\tConnection Param: %s\n", userDb[ind].connparam);
      printf("\tApp Name: %s\n", userDb[ind].AppName);
      printf("\tDb Name: %s\n", userDb[ind].DbName);
      switch(userDb[ind].Access)
      {
         case ESS_PRIV_NONE:
            printf("\tAccess: %d - ESS_PRIV_NONE\n", userDb[ind].Access);
            break;
         case ESS_PRIV_READ:
            printf("\tAccess: %d - ESS_PRIV_READ\n", userDb[ind].Access);
            break;
         case ESS_PRIV_WRITE:
            printf("\tAccess: %d - ESS_PRIV_WRITE\n", userDb[ind].Access);
            break;
         case ESS_PRIV_CALC:
            printf("\tAccess: %d - ESS_PRIV_CALC\n", userDb[ind].Access);
            break;
         case ESS_PRIV_METAREAD:
            printf("\tAccess: %d - ESS_PRIV_METAREAD\n", userDb[ind].Access);
            break;
         case ESS_PRIV_DBLOAD:
            printf("\tAccess: %d - ESS_PRIV_DBLOAD\n", userDb[ind].Access);
            break;
         case ESS_PRIV_DBMANAGE:
            printf("\tAccess: %d - ESS_PRIV_DBMANAGE\n", userDb[ind].Access);
            break;
         case ESS_PRIV_DBCREATE:
            printf("\tAccess: %d - ESS_PRIV_DBCREATE\n", userDb[ind].Access);
            break;
         case ESS_PRIV_APPLOAD:
            printf("\tAccess: %d - ESS_PRIV_APPLOAD\n", userDb[ind].Access);
            break;
         case ESS_PRIV_APPMANAGE:
            printf("\tAccess: %d - ESS_PRIV_APPMANAGE\n", userDb[ind].Access);
            break;
         case ESS_PRIV_APPCREATE:
            printf("\tAccess: %d - ESS_PRIV_APPCREATE\n", userDb[ind].Access);
            break;
         case ESS_PRIV_USERCREATE:
            printf("\tAccess: %d - ESS_PRIV_USERCREATE\n", userDb[ind].Access);
            break;

         case ESS_ACCESS_READ:
            printf("\tAccess: %d - ESS_ACCESS_READ\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_WRITE:
            printf("\tAccess: %d - ESS_ACCESS_WRITE\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_CALC:
            printf("\tAccess: %d - ESS_ACCESS_CALC\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_METAREAD:
            printf("\tAccess: %d - ESS_ACCESS_METAREAD\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_DBMANAGE:
            printf("\tAccess: %d - ESS_ACCESS_DBMANAGE\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_DBCREATE:
            printf("\tAccess: %d - ESS_ACCESS_DBCREATE\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_APPMANAGE:
            printf("\tAccess: %d - ESS_ACCESS_APPMANAGE\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_APPCREATE:
            printf("\tAccess: %d - ESS_ACCESS_APPCREATE\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_FILTER:
            printf("\tAccess: %d - ESS_ACCESS_FILTER\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_DBALL:
            printf("\tAccess: %d - ESS_ACCESS_DBALL\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_APPALL:
            printf("\tAccess: %d - ESS_ACCESS_APPALL\n", userDb[ind].Access);
            break;
         case ESS_ACCESS_ADMIN:
            printf("\tAccess: %d - ESS_ACCESS_ADMIN\n", userDb[ind].Access);
            break;
         default:
            printf("\tAccess: Unknown\n");
      }

      switch(userDb[ind].MaxAccess)
      {
         case ESS_PRIV_NONE:
            printf("\tMax Access: %d - ESS_PRIV_NONE\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_READ:
            printf("\tMax Access: %d - ESS_PRIV_READ\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_WRITE:
            printf("\tMax Access: %d - ESS_PRIV_WRITE\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_CALC:
            printf("\tMax Access: %d - ESS_PRIV_CALC\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_METAREAD:
            printf("\tMax Access: %d - ESS_PRIV_METAREAD\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_DBLOAD:
            printf("\tMax Access: %d - ESS_PRIV_DBLOAD\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_DBMANAGE:
            printf("\tMax Access: %d - ESS_PRIV_DBMANAGE\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_DBCREATE:
            printf("\tMax Access: %d - ESS_PRIV_DBCREATE\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_APPLOAD:
            printf("\tMax Access: %d - ESS_PRIV_APPLOAD\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_APPMANAGE:
            printf("\tMax Access: %d - ESS_PRIV_APPMANAGE\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_APPCREATE:
            printf("\tMax Access: %d - ESS_PRIV_APPCREATE\n", userDb[ind].MaxAccess);
            break;
         case ESS_PRIV_USERCREATE:
            printf("\tMax Access: %d - ESS_PRIV_USERCREATE\n", userDb[ind].MaxAccess);
            break;

         case ESS_ACCESS_READ:
            printf("\tMax Access: %d - ESS_ACCESS_READ\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_WRITE:
            printf("\tMax Access: %d - ESS_ACCESS_WRITE\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_CALC:
            printf("\tMax Access: %d - ESS_ACCESS_CALC\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_METAREAD:
            printf("\tMax Access: %d - ESS_ACCESS_METAREAD\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_DBMANAGE:
            printf("\tMax Access: %d - ESS_ACCESS_DBMANAGE\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_DBCREATE:
            printf("\tMax Access: %d - ESS_ACCESS_DBCREATE\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_APPMANAGE:
            printf("\tMax Access: %d - ESS_ACCESS_APPMANAGE\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_APPCREATE:
            printf("\tMax Access: %d - ESS_ACCESS_APPCREATE\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_FILTER:
            printf("\tMax Access: %d - ESS_ACCESS_FILTER\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_DBALL:
            printf("\tMax Access: %d - ESS_ACCESS_DBALL\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_APPALL:
            printf("\tMax Access: %d - ESS_ACCESS_APPALL\n", userDb[ind].MaxAccess);
            break;
         case ESS_ACCESS_ADMIN:
            printf("\tMax Access: %d - ESS_ACCESS_ADMIN\n", userDb[ind].MaxAccess);
            break;
         default:
            printf("\tMax Access: Unknown\n");
      }

      printf("\tFilter Name: %s\n", userDb[ind].FilterName);
      printf("\n");
   }
}


ESS_FUNC_M ESS_GetDatabaseAccessEx (ESS_HCTX_T hCtx, ESS_HINST_T hInst)

{
   ESS_STS_T sts = ESS_STS_NOERR;
   ESS_STR_T userId;
   ESS_BOOL_T bIsIdentity;
   ESS_USHORT_T type;
   ESS_USHORT_T count = 0;
   ESS_USERDBEX_T userDb[2];
   ESS_PUSERDBEX_T pUserDb = ESS_NULL;

   count = 2;
   strcpy(userDb[0].UserName, "IDUser1");
   strcpy(userDb[0].ProviderName, "");
   strcpy(userDb[0].connparam, "");
   userDb[0].type = ESS_TYPE_USER;
   strcpy(userDb[0].AppName, AppName);
   strcpy(userDb[0].DbName, DbName);
   userDb[0].Access = ESS_PRIV_READ;
   userDb[0].MaxAccess = ESS_PRIV_READ;

   strcpy(userDb[1].UserName, "");
   strcpy(userDb[1].ProviderName, "");
   strcpy(userDb[1].connparam, "");
   userDb[1].type = ESS_TYPE_USER;
   strcpy(userDb[1].AppName, AppName);
   strcpy(userDb[1].DbName, DbName);
   userDb[1].Access = ESS_ACCESS_ADMIN;
   userDb[1].MaxAccess = ESS_ACCESS_ADMIN;

   sts = EssSetDatabaseAccessEx(hCtx, count, &userDb);
   printf("EssSetDatabaseAccessEx sts: %ld\n\n", sts);

   userId = "IDUser1";
   AppName  = AppName;
   DbName  = DbName;
   type = ESS_TYPE_USER;
   bIsIdentity = ESS_TRUE;
   sts = EssGetDatabaseAccessEx(hCtx, userId, bIsIdentity, type, AppName, DbName, &count, &pUserDb);
   printf("EssGetDatabaseAccessEx sts: %ld\n", sts);
   if(!sts)
   {
      if(count && pUserDb)
      {  
         DisplayUserDbInfo(pUserDb, count);         
         sts = EssFree (hInst, pUserDb);        
      }
      else
         printf ("\rUser Application list is empty\n\n");    
   }


  return (sts);      
}