airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From machris...@apache.org
Subject [18/54] [abbrv] [partial] airavata-django-portal git commit: Moving admin_view JS into django app and moving django project back
Date Thu, 21 Sep 2017 16:59:48 GMT
http://git-wip-us.apache.org/repos/asf/airavata-django-portal/blob/d8d7c37a/django_portal/apache/airavata/api/sharing/SharingRegistryService.py
----------------------------------------------------------------------
diff --git a/django_portal/apache/airavata/api/sharing/SharingRegistryService.py b/django_portal/apache/airavata/api/sharing/SharingRegistryService.py
deleted file mode 100644
index 5276063..0000000
--- a/django_portal/apache/airavata/api/sharing/SharingRegistryService.py
+++ /dev/null
@@ -1,11422 +0,0 @@
-#
-# Autogenerated by Thrift Compiler (0.10.0)
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-#  options string: py
-#
-
-from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
-from thrift.protocol.TProtocol import TProtocolException
-import sys
-import logging
-from .ttypes import *
-from thrift.Thrift import TProcessor
-from thrift.transport import TTransport
-
-
-class Iface(object):
-    def createDomain(self, domain):
-        """
-        <p>API method to create a new domain</p>
-
-        Parameters:
-         - domain
-        """
-        pass
-
-    def updateDomain(self, domain):
-        """
-        <p>API method to update a domain</p>
-
-        Parameters:
-         - domain
-        """
-        pass
-
-    def isDomainExists(self, domainId):
-        """
-        <p>API method to check Domain Exists</p>
-
-        Parameters:
-         - domainId
-        """
-        pass
-
-    def deleteDomain(self, domainId):
-        """
-        <p>API method to delete domain</p>
-
-        Parameters:
-         - domainId
-        """
-        pass
-
-    def getDomain(self, domainId):
-        """
-        <p>API method to retrieve a domain</p>
-
-        Parameters:
-         - domainId
-        """
-        pass
-
-    def getDomains(self, offset, limit):
-        """
-        <p>API method to get all domain.</p>
-
-        Parameters:
-         - offset
-         - limit
-        """
-        pass
-
-    def createUser(self, user):
-        """
-        <p>API method to register a user in the system</p>
-
-        Parameters:
-         - user
-        """
-        pass
-
-    def updatedUser(self, user):
-        """
-        <p>API method to update existing user</p>
-
-        Parameters:
-         - user
-        """
-        pass
-
-    def isUserExists(self, domainId, userId):
-        """
-        <p>API method to check User Exists</p>
-
-        Parameters:
-         - domainId
-         - userId
-        """
-        pass
-
-    def deleteUser(self, domainId, userId):
-        """
-        <p>API method to delete user</p>
-
-        Parameters:
-         - domainId
-         - userId
-        """
-        pass
-
-    def getUser(self, domainId, userId):
-        """
-        <p>API method to get a user</p>
-
-        Parameters:
-         - domainId
-         - userId
-        """
-        pass
-
-    def getUsers(self, domainId, offset, limit):
-        """
-        <p>API method to get a list of users in a specific domain.</p>
-        <li>domainId : Domain id</li>
-        <li>offset : Starting result number</li>
-        <li>limit : Number of max results to be sent</li>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        pass
-
-    def createGroup(self, group):
-        """
-        <p>API method to create a new group</p>
-
-        Parameters:
-         - group
-        """
-        pass
-
-    def updateGroup(self, group):
-        """
-        <p>API method to update a group</p>
-
-        Parameters:
-         - group
-        """
-        pass
-
-    def isGroupExists(self, domainId, groupId):
-        """
-        <p>API method to check Group Exists</p>
-
-        Parameters:
-         - domainId
-         - groupId
-        """
-        pass
-
-    def deleteGroup(self, domainId, groupId):
-        """
-        <p>API method to delete a group</p>
-
-        Parameters:
-         - domainId
-         - groupId
-        """
-        pass
-
-    def getGroup(self, domainId, groupId):
-        """
-        <p>API method to get a group</p>
-
-        Parameters:
-         - domainId
-         - groupId
-        """
-        pass
-
-    def getGroups(self, domainId, offset, limit):
-        """
-        <p>API method to get groups in a domainId.</p>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        pass
-
-    def addUsersToGroup(self, domainId, userIds, groupId):
-        """
-        <p>API method to add list of users to a group</p>
-
-        Parameters:
-         - domainId
-         - userIds
-         - groupId
-        """
-        pass
-
-    def removeUsersFromGroup(self, domainId, userIds, groupId):
-        """
-        <p>API method to remove users from a group</p>
-
-        Parameters:
-         - domainId
-         - userIds
-         - groupId
-        """
-        pass
-
-    def getGroupMembersOfTypeUser(self, domainId, groupId, offset, limit):
-        """
-        <p>API method to get list of child users in a group. Only the direct members will be returned.</p>
-
-        Parameters:
-         - domainId
-         - groupId
-         - offset
-         - limit
-        """
-        pass
-
-    def getGroupMembersOfTypeGroup(self, domainId, groupId, offset, limit):
-        """
-        <p>API method to get list of child groups in a group. Only the direct members will be returned.</p>
-
-        Parameters:
-         - domainId
-         - groupId
-         - offset
-         - limit
-        """
-        pass
-
-    def addChildGroupsToParentGroup(self, domainId, childIds, groupId):
-        """
-        <p>API method to add a child group to a parent group.</p>
-
-        Parameters:
-         - domainId
-         - childIds
-         - groupId
-        """
-        pass
-
-    def removeChildGroupFromParentGroup(self, domainId, childId, groupId):
-        """
-        <p>API method to remove a child group from parent group.</p>
-
-        Parameters:
-         - domainId
-         - childId
-         - groupId
-        """
-        pass
-
-    def getAllMemberGroupsForUser(self, domainId, userId):
-        """
-        Parameters:
-         - domainId
-         - userId
-        """
-        pass
-
-    def createEntityType(self, entityType):
-        """
-        <p>API method to create a new entity type</p>
-
-        Parameters:
-         - entityType
-        """
-        pass
-
-    def updateEntityType(self, entityType):
-        """
-        <p>API method to update entity type</p>
-
-        Parameters:
-         - entityType
-        """
-        pass
-
-    def isEntityTypeExists(self, domainId, entityTypeId):
-        """
-        <p>API method to check EntityType Exists</p>
-
-        Parameters:
-         - domainId
-         - entityTypeId
-        """
-        pass
-
-    def deleteEntityType(self, domainId, entityTypeId):
-        """
-        <p>API method to delete entity type</p>
-
-        Parameters:
-         - domainId
-         - entityTypeId
-        """
-        pass
-
-    def getEntityType(self, domainId, entityTypeId):
-        """
-        <p>API method to get an entity type</p>
-
-        Parameters:
-         - domainId
-         - entityTypeId
-        """
-        pass
-
-    def getEntityTypes(self, domainId, offset, limit):
-        """
-        <p>API method to get entity types in a domainId.</p>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        pass
-
-    def createEntity(self, entity):
-        """
-        <p>API method to register new entity</p>
-
-        Parameters:
-         - entity
-        """
-        pass
-
-    def updateEntity(self, entity):
-        """
-        <p>API method to update entity</p>
-
-        Parameters:
-         - entity
-        """
-        pass
-
-    def isEntityExists(self, domainId, entityId):
-        """
-        <p>API method to check Entity Exists</p>
-
-        Parameters:
-         - domainId
-         - entityId
-        """
-        pass
-
-    def deleteEntity(self, domainId, entityId):
-        """
-        <p>API method to delete entity</p>
-
-        Parameters:
-         - domainId
-         - entityId
-        """
-        pass
-
-    def getEntity(self, domainId, entityId):
-        """
-        <p>API method to get entity</p>
-
-        Parameters:
-         - domainId
-         - entityId
-        """
-        pass
-
-    def searchEntities(self, domainId, userId, filters, offset, limit):
-        """
-        <p>API method to search entities</p>
-
-        Parameters:
-         - domainId
-         - userId
-         - filters
-         - offset
-         - limit
-        """
-        pass
-
-    def getListOfSharedUsers(self, domainId, entityId, permissionTypeId):
-        """
-        <p>API method to get a list of shared users given the entity id</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - permissionTypeId
-        """
-        pass
-
-    def getListOfSharedGroups(self, domainId, entityId, permissionTypeId):
-        """
-        <p>API method to get a list of shared groups given the entity id</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - permissionTypeId
-        """
-        pass
-
-    def createPermissionType(self, permissionType):
-        """
-        <p>API method to create permission type</p>
-
-        Parameters:
-         - permissionType
-        """
-        pass
-
-    def updatePermissionType(self, permissionType):
-        """
-        <p>API method to update permission type</p>
-
-        Parameters:
-         - permissionType
-        """
-        pass
-
-    def isPermissionExists(self, dimainId, permissionId):
-        """
-        <p>API method to check Permission Exists</p>
-
-        Parameters:
-         - dimainId
-         - permissionId
-        """
-        pass
-
-    def deletePermissionType(self, domainId, permissionTypeId):
-        """
-        <p>API method to delete permission type</p>
-
-        Parameters:
-         - domainId
-         - permissionTypeId
-        """
-        pass
-
-    def getPermissionType(self, domainId, permissionTypeId):
-        """
-        <p>API method to get permission type</p>
-
-        Parameters:
-         - domainId
-         - permissionTypeId
-        """
-        pass
-
-    def getPermissionTypes(self, domainId, offset, limit):
-        """
-        <p>API method to get list of permission types in a given domainId.</p>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        pass
-
-    def shareEntityWithUsers(self, domainId, entityId, userList, perssionTypeId, cascadePermission):
-        """
-        <p>API method to share an entity with users</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - userList
-         - perssionTypeId
-         - cascadePermission
-        """
-        pass
-
-    def revokeEntitySharingFromUsers(self, domainId, entityId, userList, perssionTypeId):
-        """
-        <p>API method to revoke sharing from a list of users</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - userList
-         - perssionTypeId
-        """
-        pass
-
-    def shareEntityWithGroups(self, domainId, entityId, groupList, perssionTypeId, cascadePermission):
-        """
-        <p>API method to share an entity with list of groups</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - groupList
-         - perssionTypeId
-         - cascadePermission
-        """
-        pass
-
-    def revokeEntitySharingFromGroups(self, domainId, entityId, groupList, perssionTypeId):
-        """
-        <p>API method to revoke sharing from list of users</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - groupList
-         - perssionTypeId
-        """
-        pass
-
-    def userHasAccess(self, domainId, userId, entityId, permissionTypeId):
-        """
-        <p>API method to check whether a user has access to a specific entity</p>
-
-        Parameters:
-         - domainId
-         - userId
-         - entityId
-         - permissionTypeId
-        """
-        pass
-
-
-class Client(Iface):
-    def __init__(self, iprot, oprot=None):
-        self._iprot = self._oprot = iprot
-        if oprot is not None:
-            self._oprot = oprot
-        self._seqid = 0
-
-    def createDomain(self, domain):
-        """
-        <p>API method to create a new domain</p>
-
-        Parameters:
-         - domain
-        """
-        self.send_createDomain(domain)
-        return self.recv_createDomain()
-
-    def send_createDomain(self, domain):
-        self._oprot.writeMessageBegin('createDomain', TMessageType.CALL, self._seqid)
-        args = createDomain_args()
-        args.domain = domain
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_createDomain(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = createDomain_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        if result.dee is not None:
-            raise result.dee
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "createDomain failed: unknown result")
-
-    def updateDomain(self, domain):
-        """
-        <p>API method to update a domain</p>
-
-        Parameters:
-         - domain
-        """
-        self.send_updateDomain(domain)
-        return self.recv_updateDomain()
-
-    def send_updateDomain(self, domain):
-        self._oprot.writeMessageBegin('updateDomain', TMessageType.CALL, self._seqid)
-        args = updateDomain_args()
-        args.domain = domain
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_updateDomain(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = updateDomain_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "updateDomain failed: unknown result")
-
-    def isDomainExists(self, domainId):
-        """
-        <p>API method to check Domain Exists</p>
-
-        Parameters:
-         - domainId
-        """
-        self.send_isDomainExists(domainId)
-        return self.recv_isDomainExists()
-
-    def send_isDomainExists(self, domainId):
-        self._oprot.writeMessageBegin('isDomainExists', TMessageType.CALL, self._seqid)
-        args = isDomainExists_args()
-        args.domainId = domainId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_isDomainExists(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = isDomainExists_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "isDomainExists failed: unknown result")
-
-    def deleteDomain(self, domainId):
-        """
-        <p>API method to delete domain</p>
-
-        Parameters:
-         - domainId
-        """
-        self.send_deleteDomain(domainId)
-        return self.recv_deleteDomain()
-
-    def send_deleteDomain(self, domainId):
-        self._oprot.writeMessageBegin('deleteDomain', TMessageType.CALL, self._seqid)
-        args = deleteDomain_args()
-        args.domainId = domainId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_deleteDomain(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = deleteDomain_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteDomain failed: unknown result")
-
-    def getDomain(self, domainId):
-        """
-        <p>API method to retrieve a domain</p>
-
-        Parameters:
-         - domainId
-        """
-        self.send_getDomain(domainId)
-        return self.recv_getDomain()
-
-    def send_getDomain(self, domainId):
-        self._oprot.writeMessageBegin('getDomain', TMessageType.CALL, self._seqid)
-        args = getDomain_args()
-        args.domainId = domainId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getDomain(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getDomain_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getDomain failed: unknown result")
-
-    def getDomains(self, offset, limit):
-        """
-        <p>API method to get all domain.</p>
-
-        Parameters:
-         - offset
-         - limit
-        """
-        self.send_getDomains(offset, limit)
-        return self.recv_getDomains()
-
-    def send_getDomains(self, offset, limit):
-        self._oprot.writeMessageBegin('getDomains', TMessageType.CALL, self._seqid)
-        args = getDomains_args()
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getDomains(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getDomains_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getDomains failed: unknown result")
-
-    def createUser(self, user):
-        """
-        <p>API method to register a user in the system</p>
-
-        Parameters:
-         - user
-        """
-        self.send_createUser(user)
-        return self.recv_createUser()
-
-    def send_createUser(self, user):
-        self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
-        args = createUser_args()
-        args.user = user
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_createUser(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = createUser_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        if result.dee is not None:
-            raise result.dee
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result")
-
-    def updatedUser(self, user):
-        """
-        <p>API method to update existing user</p>
-
-        Parameters:
-         - user
-        """
-        self.send_updatedUser(user)
-        return self.recv_updatedUser()
-
-    def send_updatedUser(self, user):
-        self._oprot.writeMessageBegin('updatedUser', TMessageType.CALL, self._seqid)
-        args = updatedUser_args()
-        args.user = user
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_updatedUser(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = updatedUser_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "updatedUser failed: unknown result")
-
-    def isUserExists(self, domainId, userId):
-        """
-        <p>API method to check User Exists</p>
-
-        Parameters:
-         - domainId
-         - userId
-        """
-        self.send_isUserExists(domainId, userId)
-        return self.recv_isUserExists()
-
-    def send_isUserExists(self, domainId, userId):
-        self._oprot.writeMessageBegin('isUserExists', TMessageType.CALL, self._seqid)
-        args = isUserExists_args()
-        args.domainId = domainId
-        args.userId = userId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_isUserExists(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = isUserExists_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "isUserExists failed: unknown result")
-
-    def deleteUser(self, domainId, userId):
-        """
-        <p>API method to delete user</p>
-
-        Parameters:
-         - domainId
-         - userId
-        """
-        self.send_deleteUser(domainId, userId)
-        return self.recv_deleteUser()
-
-    def send_deleteUser(self, domainId, userId):
-        self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
-        args = deleteUser_args()
-        args.domainId = domainId
-        args.userId = userId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_deleteUser(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = deleteUser_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result")
-
-    def getUser(self, domainId, userId):
-        """
-        <p>API method to get a user</p>
-
-        Parameters:
-         - domainId
-         - userId
-        """
-        self.send_getUser(domainId, userId)
-        return self.recv_getUser()
-
-    def send_getUser(self, domainId, userId):
-        self._oprot.writeMessageBegin('getUser', TMessageType.CALL, self._seqid)
-        args = getUser_args()
-        args.domainId = domainId
-        args.userId = userId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getUser(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getUser_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getUser failed: unknown result")
-
-    def getUsers(self, domainId, offset, limit):
-        """
-        <p>API method to get a list of users in a specific domain.</p>
-        <li>domainId : Domain id</li>
-        <li>offset : Starting result number</li>
-        <li>limit : Number of max results to be sent</li>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        self.send_getUsers(domainId, offset, limit)
-        return self.recv_getUsers()
-
-    def send_getUsers(self, domainId, offset, limit):
-        self._oprot.writeMessageBegin('getUsers', TMessageType.CALL, self._seqid)
-        args = getUsers_args()
-        args.domainId = domainId
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getUsers(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getUsers_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getUsers failed: unknown result")
-
-    def createGroup(self, group):
-        """
-        <p>API method to create a new group</p>
-
-        Parameters:
-         - group
-        """
-        self.send_createGroup(group)
-        return self.recv_createGroup()
-
-    def send_createGroup(self, group):
-        self._oprot.writeMessageBegin('createGroup', TMessageType.CALL, self._seqid)
-        args = createGroup_args()
-        args.group = group
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_createGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = createGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "createGroup failed: unknown result")
-
-    def updateGroup(self, group):
-        """
-        <p>API method to update a group</p>
-
-        Parameters:
-         - group
-        """
-        self.send_updateGroup(group)
-        return self.recv_updateGroup()
-
-    def send_updateGroup(self, group):
-        self._oprot.writeMessageBegin('updateGroup', TMessageType.CALL, self._seqid)
-        args = updateGroup_args()
-        args.group = group
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_updateGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = updateGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "updateGroup failed: unknown result")
-
-    def isGroupExists(self, domainId, groupId):
-        """
-        <p>API method to check Group Exists</p>
-
-        Parameters:
-         - domainId
-         - groupId
-        """
-        self.send_isGroupExists(domainId, groupId)
-        return self.recv_isGroupExists()
-
-    def send_isGroupExists(self, domainId, groupId):
-        self._oprot.writeMessageBegin('isGroupExists', TMessageType.CALL, self._seqid)
-        args = isGroupExists_args()
-        args.domainId = domainId
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_isGroupExists(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = isGroupExists_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "isGroupExists failed: unknown result")
-
-    def deleteGroup(self, domainId, groupId):
-        """
-        <p>API method to delete a group</p>
-
-        Parameters:
-         - domainId
-         - groupId
-        """
-        self.send_deleteGroup(domainId, groupId)
-        return self.recv_deleteGroup()
-
-    def send_deleteGroup(self, domainId, groupId):
-        self._oprot.writeMessageBegin('deleteGroup', TMessageType.CALL, self._seqid)
-        args = deleteGroup_args()
-        args.domainId = domainId
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_deleteGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = deleteGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteGroup failed: unknown result")
-
-    def getGroup(self, domainId, groupId):
-        """
-        <p>API method to get a group</p>
-
-        Parameters:
-         - domainId
-         - groupId
-        """
-        self.send_getGroup(domainId, groupId)
-        return self.recv_getGroup()
-
-    def send_getGroup(self, domainId, groupId):
-        self._oprot.writeMessageBegin('getGroup', TMessageType.CALL, self._seqid)
-        args = getGroup_args()
-        args.domainId = domainId
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getGroup failed: unknown result")
-
-    def getGroups(self, domainId, offset, limit):
-        """
-        <p>API method to get groups in a domainId.</p>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        self.send_getGroups(domainId, offset, limit)
-        return self.recv_getGroups()
-
-    def send_getGroups(self, domainId, offset, limit):
-        self._oprot.writeMessageBegin('getGroups', TMessageType.CALL, self._seqid)
-        args = getGroups_args()
-        args.domainId = domainId
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getGroups(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getGroups_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getGroups failed: unknown result")
-
-    def addUsersToGroup(self, domainId, userIds, groupId):
-        """
-        <p>API method to add list of users to a group</p>
-
-        Parameters:
-         - domainId
-         - userIds
-         - groupId
-        """
-        self.send_addUsersToGroup(domainId, userIds, groupId)
-        return self.recv_addUsersToGroup()
-
-    def send_addUsersToGroup(self, domainId, userIds, groupId):
-        self._oprot.writeMessageBegin('addUsersToGroup', TMessageType.CALL, self._seqid)
-        args = addUsersToGroup_args()
-        args.domainId = domainId
-        args.userIds = userIds
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_addUsersToGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = addUsersToGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "addUsersToGroup failed: unknown result")
-
-    def removeUsersFromGroup(self, domainId, userIds, groupId):
-        """
-        <p>API method to remove users from a group</p>
-
-        Parameters:
-         - domainId
-         - userIds
-         - groupId
-        """
-        self.send_removeUsersFromGroup(domainId, userIds, groupId)
-        return self.recv_removeUsersFromGroup()
-
-    def send_removeUsersFromGroup(self, domainId, userIds, groupId):
-        self._oprot.writeMessageBegin('removeUsersFromGroup', TMessageType.CALL, self._seqid)
-        args = removeUsersFromGroup_args()
-        args.domainId = domainId
-        args.userIds = userIds
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_removeUsersFromGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = removeUsersFromGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "removeUsersFromGroup failed: unknown result")
-
-    def getGroupMembersOfTypeUser(self, domainId, groupId, offset, limit):
-        """
-        <p>API method to get list of child users in a group. Only the direct members will be returned.</p>
-
-        Parameters:
-         - domainId
-         - groupId
-         - offset
-         - limit
-        """
-        self.send_getGroupMembersOfTypeUser(domainId, groupId, offset, limit)
-        return self.recv_getGroupMembersOfTypeUser()
-
-    def send_getGroupMembersOfTypeUser(self, domainId, groupId, offset, limit):
-        self._oprot.writeMessageBegin('getGroupMembersOfTypeUser', TMessageType.CALL, self._seqid)
-        args = getGroupMembersOfTypeUser_args()
-        args.domainId = domainId
-        args.groupId = groupId
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getGroupMembersOfTypeUser(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getGroupMembersOfTypeUser_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getGroupMembersOfTypeUser failed: unknown result")
-
-    def getGroupMembersOfTypeGroup(self, domainId, groupId, offset, limit):
-        """
-        <p>API method to get list of child groups in a group. Only the direct members will be returned.</p>
-
-        Parameters:
-         - domainId
-         - groupId
-         - offset
-         - limit
-        """
-        self.send_getGroupMembersOfTypeGroup(domainId, groupId, offset, limit)
-        return self.recv_getGroupMembersOfTypeGroup()
-
-    def send_getGroupMembersOfTypeGroup(self, domainId, groupId, offset, limit):
-        self._oprot.writeMessageBegin('getGroupMembersOfTypeGroup', TMessageType.CALL, self._seqid)
-        args = getGroupMembersOfTypeGroup_args()
-        args.domainId = domainId
-        args.groupId = groupId
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getGroupMembersOfTypeGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getGroupMembersOfTypeGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getGroupMembersOfTypeGroup failed: unknown result")
-
-    def addChildGroupsToParentGroup(self, domainId, childIds, groupId):
-        """
-        <p>API method to add a child group to a parent group.</p>
-
-        Parameters:
-         - domainId
-         - childIds
-         - groupId
-        """
-        self.send_addChildGroupsToParentGroup(domainId, childIds, groupId)
-        return self.recv_addChildGroupsToParentGroup()
-
-    def send_addChildGroupsToParentGroup(self, domainId, childIds, groupId):
-        self._oprot.writeMessageBegin('addChildGroupsToParentGroup', TMessageType.CALL, self._seqid)
-        args = addChildGroupsToParentGroup_args()
-        args.domainId = domainId
-        args.childIds = childIds
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_addChildGroupsToParentGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = addChildGroupsToParentGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "addChildGroupsToParentGroup failed: unknown result")
-
-    def removeChildGroupFromParentGroup(self, domainId, childId, groupId):
-        """
-        <p>API method to remove a child group from parent group.</p>
-
-        Parameters:
-         - domainId
-         - childId
-         - groupId
-        """
-        self.send_removeChildGroupFromParentGroup(domainId, childId, groupId)
-        return self.recv_removeChildGroupFromParentGroup()
-
-    def send_removeChildGroupFromParentGroup(self, domainId, childId, groupId):
-        self._oprot.writeMessageBegin('removeChildGroupFromParentGroup', TMessageType.CALL, self._seqid)
-        args = removeChildGroupFromParentGroup_args()
-        args.domainId = domainId
-        args.childId = childId
-        args.groupId = groupId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_removeChildGroupFromParentGroup(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = removeChildGroupFromParentGroup_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "removeChildGroupFromParentGroup failed: unknown result")
-
-    def getAllMemberGroupsForUser(self, domainId, userId):
-        """
-        Parameters:
-         - domainId
-         - userId
-        """
-        self.send_getAllMemberGroupsForUser(domainId, userId)
-        return self.recv_getAllMemberGroupsForUser()
-
-    def send_getAllMemberGroupsForUser(self, domainId, userId):
-        self._oprot.writeMessageBegin('getAllMemberGroupsForUser', TMessageType.CALL, self._seqid)
-        args = getAllMemberGroupsForUser_args()
-        args.domainId = domainId
-        args.userId = userId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getAllMemberGroupsForUser(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getAllMemberGroupsForUser_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMemberGroupsForUser failed: unknown result")
-
-    def createEntityType(self, entityType):
-        """
-        <p>API method to create a new entity type</p>
-
-        Parameters:
-         - entityType
-        """
-        self.send_createEntityType(entityType)
-        return self.recv_createEntityType()
-
-    def send_createEntityType(self, entityType):
-        self._oprot.writeMessageBegin('createEntityType', TMessageType.CALL, self._seqid)
-        args = createEntityType_args()
-        args.entityType = entityType
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_createEntityType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = createEntityType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        if result.dee is not None:
-            raise result.dee
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "createEntityType failed: unknown result")
-
-    def updateEntityType(self, entityType):
-        """
-        <p>API method to update entity type</p>
-
-        Parameters:
-         - entityType
-        """
-        self.send_updateEntityType(entityType)
-        return self.recv_updateEntityType()
-
-    def send_updateEntityType(self, entityType):
-        self._oprot.writeMessageBegin('updateEntityType', TMessageType.CALL, self._seqid)
-        args = updateEntityType_args()
-        args.entityType = entityType
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_updateEntityType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = updateEntityType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "updateEntityType failed: unknown result")
-
-    def isEntityTypeExists(self, domainId, entityTypeId):
-        """
-        <p>API method to check EntityType Exists</p>
-
-        Parameters:
-         - domainId
-         - entityTypeId
-        """
-        self.send_isEntityTypeExists(domainId, entityTypeId)
-        return self.recv_isEntityTypeExists()
-
-    def send_isEntityTypeExists(self, domainId, entityTypeId):
-        self._oprot.writeMessageBegin('isEntityTypeExists', TMessageType.CALL, self._seqid)
-        args = isEntityTypeExists_args()
-        args.domainId = domainId
-        args.entityTypeId = entityTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_isEntityTypeExists(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = isEntityTypeExists_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "isEntityTypeExists failed: unknown result")
-
-    def deleteEntityType(self, domainId, entityTypeId):
-        """
-        <p>API method to delete entity type</p>
-
-        Parameters:
-         - domainId
-         - entityTypeId
-        """
-        self.send_deleteEntityType(domainId, entityTypeId)
-        return self.recv_deleteEntityType()
-
-    def send_deleteEntityType(self, domainId, entityTypeId):
-        self._oprot.writeMessageBegin('deleteEntityType', TMessageType.CALL, self._seqid)
-        args = deleteEntityType_args()
-        args.domainId = domainId
-        args.entityTypeId = entityTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_deleteEntityType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = deleteEntityType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityType failed: unknown result")
-
-    def getEntityType(self, domainId, entityTypeId):
-        """
-        <p>API method to get an entity type</p>
-
-        Parameters:
-         - domainId
-         - entityTypeId
-        """
-        self.send_getEntityType(domainId, entityTypeId)
-        return self.recv_getEntityType()
-
-    def send_getEntityType(self, domainId, entityTypeId):
-        self._oprot.writeMessageBegin('getEntityType', TMessageType.CALL, self._seqid)
-        args = getEntityType_args()
-        args.domainId = domainId
-        args.entityTypeId = entityTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getEntityType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getEntityType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getEntityType failed: unknown result")
-
-    def getEntityTypes(self, domainId, offset, limit):
-        """
-        <p>API method to get entity types in a domainId.</p>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        self.send_getEntityTypes(domainId, offset, limit)
-        return self.recv_getEntityTypes()
-
-    def send_getEntityTypes(self, domainId, offset, limit):
-        self._oprot.writeMessageBegin('getEntityTypes', TMessageType.CALL, self._seqid)
-        args = getEntityTypes_args()
-        args.domainId = domainId
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getEntityTypes(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getEntityTypes_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getEntityTypes failed: unknown result")
-
-    def createEntity(self, entity):
-        """
-        <p>API method to register new entity</p>
-
-        Parameters:
-         - entity
-        """
-        self.send_createEntity(entity)
-        return self.recv_createEntity()
-
-    def send_createEntity(self, entity):
-        self._oprot.writeMessageBegin('createEntity', TMessageType.CALL, self._seqid)
-        args = createEntity_args()
-        args.entity = entity
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_createEntity(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = createEntity_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "createEntity failed: unknown result")
-
-    def updateEntity(self, entity):
-        """
-        <p>API method to update entity</p>
-
-        Parameters:
-         - entity
-        """
-        self.send_updateEntity(entity)
-        return self.recv_updateEntity()
-
-    def send_updateEntity(self, entity):
-        self._oprot.writeMessageBegin('updateEntity', TMessageType.CALL, self._seqid)
-        args = updateEntity_args()
-        args.entity = entity
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_updateEntity(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = updateEntity_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "updateEntity failed: unknown result")
-
-    def isEntityExists(self, domainId, entityId):
-        """
-        <p>API method to check Entity Exists</p>
-
-        Parameters:
-         - domainId
-         - entityId
-        """
-        self.send_isEntityExists(domainId, entityId)
-        return self.recv_isEntityExists()
-
-    def send_isEntityExists(self, domainId, entityId):
-        self._oprot.writeMessageBegin('isEntityExists', TMessageType.CALL, self._seqid)
-        args = isEntityExists_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_isEntityExists(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = isEntityExists_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "isEntityExists failed: unknown result")
-
-    def deleteEntity(self, domainId, entityId):
-        """
-        <p>API method to delete entity</p>
-
-        Parameters:
-         - domainId
-         - entityId
-        """
-        self.send_deleteEntity(domainId, entityId)
-        return self.recv_deleteEntity()
-
-    def send_deleteEntity(self, domainId, entityId):
-        self._oprot.writeMessageBegin('deleteEntity', TMessageType.CALL, self._seqid)
-        args = deleteEntity_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_deleteEntity(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = deleteEntity_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntity failed: unknown result")
-
-    def getEntity(self, domainId, entityId):
-        """
-        <p>API method to get entity</p>
-
-        Parameters:
-         - domainId
-         - entityId
-        """
-        self.send_getEntity(domainId, entityId)
-        return self.recv_getEntity()
-
-    def send_getEntity(self, domainId, entityId):
-        self._oprot.writeMessageBegin('getEntity', TMessageType.CALL, self._seqid)
-        args = getEntity_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getEntity(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getEntity_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getEntity failed: unknown result")
-
-    def searchEntities(self, domainId, userId, filters, offset, limit):
-        """
-        <p>API method to search entities</p>
-
-        Parameters:
-         - domainId
-         - userId
-         - filters
-         - offset
-         - limit
-        """
-        self.send_searchEntities(domainId, userId, filters, offset, limit)
-        return self.recv_searchEntities()
-
-    def send_searchEntities(self, domainId, userId, filters, offset, limit):
-        self._oprot.writeMessageBegin('searchEntities', TMessageType.CALL, self._seqid)
-        args = searchEntities_args()
-        args.domainId = domainId
-        args.userId = userId
-        args.filters = filters
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_searchEntities(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = searchEntities_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "searchEntities failed: unknown result")
-
-    def getListOfSharedUsers(self, domainId, entityId, permissionTypeId):
-        """
-        <p>API method to get a list of shared users given the entity id</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - permissionTypeId
-        """
-        self.send_getListOfSharedUsers(domainId, entityId, permissionTypeId)
-        return self.recv_getListOfSharedUsers()
-
-    def send_getListOfSharedUsers(self, domainId, entityId, permissionTypeId):
-        self._oprot.writeMessageBegin('getListOfSharedUsers', TMessageType.CALL, self._seqid)
-        args = getListOfSharedUsers_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.permissionTypeId = permissionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getListOfSharedUsers(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getListOfSharedUsers_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getListOfSharedUsers failed: unknown result")
-
-    def getListOfSharedGroups(self, domainId, entityId, permissionTypeId):
-        """
-        <p>API method to get a list of shared groups given the entity id</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - permissionTypeId
-        """
-        self.send_getListOfSharedGroups(domainId, entityId, permissionTypeId)
-        return self.recv_getListOfSharedGroups()
-
-    def send_getListOfSharedGroups(self, domainId, entityId, permissionTypeId):
-        self._oprot.writeMessageBegin('getListOfSharedGroups', TMessageType.CALL, self._seqid)
-        args = getListOfSharedGroups_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.permissionTypeId = permissionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getListOfSharedGroups(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getListOfSharedGroups_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getListOfSharedGroups failed: unknown result")
-
-    def createPermissionType(self, permissionType):
-        """
-        <p>API method to create permission type</p>
-
-        Parameters:
-         - permissionType
-        """
-        self.send_createPermissionType(permissionType)
-        return self.recv_createPermissionType()
-
-    def send_createPermissionType(self, permissionType):
-        self._oprot.writeMessageBegin('createPermissionType', TMessageType.CALL, self._seqid)
-        args = createPermissionType_args()
-        args.permissionType = permissionType
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_createPermissionType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = createPermissionType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        if result.dee is not None:
-            raise result.dee
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "createPermissionType failed: unknown result")
-
-    def updatePermissionType(self, permissionType):
-        """
-        <p>API method to update permission type</p>
-
-        Parameters:
-         - permissionType
-        """
-        self.send_updatePermissionType(permissionType)
-        return self.recv_updatePermissionType()
-
-    def send_updatePermissionType(self, permissionType):
-        self._oprot.writeMessageBegin('updatePermissionType', TMessageType.CALL, self._seqid)
-        args = updatePermissionType_args()
-        args.permissionType = permissionType
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_updatePermissionType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = updatePermissionType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePermissionType failed: unknown result")
-
-    def isPermissionExists(self, dimainId, permissionId):
-        """
-        <p>API method to check Permission Exists</p>
-
-        Parameters:
-         - dimainId
-         - permissionId
-        """
-        self.send_isPermissionExists(dimainId, permissionId)
-        return self.recv_isPermissionExists()
-
-    def send_isPermissionExists(self, dimainId, permissionId):
-        self._oprot.writeMessageBegin('isPermissionExists', TMessageType.CALL, self._seqid)
-        args = isPermissionExists_args()
-        args.dimainId = dimainId
-        args.permissionId = permissionId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_isPermissionExists(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = isPermissionExists_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "isPermissionExists failed: unknown result")
-
-    def deletePermissionType(self, domainId, permissionTypeId):
-        """
-        <p>API method to delete permission type</p>
-
-        Parameters:
-         - domainId
-         - permissionTypeId
-        """
-        self.send_deletePermissionType(domainId, permissionTypeId)
-        return self.recv_deletePermissionType()
-
-    def send_deletePermissionType(self, domainId, permissionTypeId):
-        self._oprot.writeMessageBegin('deletePermissionType', TMessageType.CALL, self._seqid)
-        args = deletePermissionType_args()
-        args.domainId = domainId
-        args.permissionTypeId = permissionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_deletePermissionType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = deletePermissionType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "deletePermissionType failed: unknown result")
-
-    def getPermissionType(self, domainId, permissionTypeId):
-        """
-        <p>API method to get permission type</p>
-
-        Parameters:
-         - domainId
-         - permissionTypeId
-        """
-        self.send_getPermissionType(domainId, permissionTypeId)
-        return self.recv_getPermissionType()
-
-    def send_getPermissionType(self, domainId, permissionTypeId):
-        self._oprot.writeMessageBegin('getPermissionType', TMessageType.CALL, self._seqid)
-        args = getPermissionType_args()
-        args.domainId = domainId
-        args.permissionTypeId = permissionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getPermissionType(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getPermissionType_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getPermissionType failed: unknown result")
-
-    def getPermissionTypes(self, domainId, offset, limit):
-        """
-        <p>API method to get list of permission types in a given domainId.</p>
-
-        Parameters:
-         - domainId
-         - offset
-         - limit
-        """
-        self.send_getPermissionTypes(domainId, offset, limit)
-        return self.recv_getPermissionTypes()
-
-    def send_getPermissionTypes(self, domainId, offset, limit):
-        self._oprot.writeMessageBegin('getPermissionTypes', TMessageType.CALL, self._seqid)
-        args = getPermissionTypes_args()
-        args.domainId = domainId
-        args.offset = offset
-        args.limit = limit
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_getPermissionTypes(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = getPermissionTypes_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "getPermissionTypes failed: unknown result")
-
-    def shareEntityWithUsers(self, domainId, entityId, userList, perssionTypeId, cascadePermission):
-        """
-        <p>API method to share an entity with users</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - userList
-         - perssionTypeId
-         - cascadePermission
-        """
-        self.send_shareEntityWithUsers(domainId, entityId, userList, perssionTypeId, cascadePermission)
-        return self.recv_shareEntityWithUsers()
-
-    def send_shareEntityWithUsers(self, domainId, entityId, userList, perssionTypeId, cascadePermission):
-        self._oprot.writeMessageBegin('shareEntityWithUsers', TMessageType.CALL, self._seqid)
-        args = shareEntityWithUsers_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.userList = userList
-        args.perssionTypeId = perssionTypeId
-        args.cascadePermission = cascadePermission
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_shareEntityWithUsers(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = shareEntityWithUsers_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "shareEntityWithUsers failed: unknown result")
-
-    def revokeEntitySharingFromUsers(self, domainId, entityId, userList, perssionTypeId):
-        """
-        <p>API method to revoke sharing from a list of users</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - userList
-         - perssionTypeId
-        """
-        self.send_revokeEntitySharingFromUsers(domainId, entityId, userList, perssionTypeId)
-        return self.recv_revokeEntitySharingFromUsers()
-
-    def send_revokeEntitySharingFromUsers(self, domainId, entityId, userList, perssionTypeId):
-        self._oprot.writeMessageBegin('revokeEntitySharingFromUsers', TMessageType.CALL, self._seqid)
-        args = revokeEntitySharingFromUsers_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.userList = userList
-        args.perssionTypeId = perssionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_revokeEntitySharingFromUsers(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = revokeEntitySharingFromUsers_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "revokeEntitySharingFromUsers failed: unknown result")
-
-    def shareEntityWithGroups(self, domainId, entityId, groupList, perssionTypeId, cascadePermission):
-        """
-        <p>API method to share an entity with list of groups</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - groupList
-         - perssionTypeId
-         - cascadePermission
-        """
-        self.send_shareEntityWithGroups(domainId, entityId, groupList, perssionTypeId, cascadePermission)
-        return self.recv_shareEntityWithGroups()
-
-    def send_shareEntityWithGroups(self, domainId, entityId, groupList, perssionTypeId, cascadePermission):
-        self._oprot.writeMessageBegin('shareEntityWithGroups', TMessageType.CALL, self._seqid)
-        args = shareEntityWithGroups_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.groupList = groupList
-        args.perssionTypeId = perssionTypeId
-        args.cascadePermission = cascadePermission
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_shareEntityWithGroups(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = shareEntityWithGroups_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "shareEntityWithGroups failed: unknown result")
-
-    def revokeEntitySharingFromGroups(self, domainId, entityId, groupList, perssionTypeId):
-        """
-        <p>API method to revoke sharing from list of users</p>
-
-        Parameters:
-         - domainId
-         - entityId
-         - groupList
-         - perssionTypeId
-        """
-        self.send_revokeEntitySharingFromGroups(domainId, entityId, groupList, perssionTypeId)
-        return self.recv_revokeEntitySharingFromGroups()
-
-    def send_revokeEntitySharingFromGroups(self, domainId, entityId, groupList, perssionTypeId):
-        self._oprot.writeMessageBegin('revokeEntitySharingFromGroups', TMessageType.CALL, self._seqid)
-        args = revokeEntitySharingFromGroups_args()
-        args.domainId = domainId
-        args.entityId = entityId
-        args.groupList = groupList
-        args.perssionTypeId = perssionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_revokeEntitySharingFromGroups(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = revokeEntitySharingFromGroups_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "revokeEntitySharingFromGroups failed: unknown result")
-
-    def userHasAccess(self, domainId, userId, entityId, permissionTypeId):
-        """
-        <p>API method to check whether a user has access to a specific entity</p>
-
-        Parameters:
-         - domainId
-         - userId
-         - entityId
-         - permissionTypeId
-        """
-        self.send_userHasAccess(domainId, userId, entityId, permissionTypeId)
-        return self.recv_userHasAccess()
-
-    def send_userHasAccess(self, domainId, userId, entityId, permissionTypeId):
-        self._oprot.writeMessageBegin('userHasAccess', TMessageType.CALL, self._seqid)
-        args = userHasAccess_args()
-        args.domainId = domainId
-        args.userId = userId
-        args.entityId = entityId
-        args.permissionTypeId = permissionTypeId
-        args.write(self._oprot)
-        self._oprot.writeMessageEnd()
-        self._oprot.trans.flush()
-
-    def recv_userHasAccess(self):
-        iprot = self._iprot
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-        if mtype == TMessageType.EXCEPTION:
-            x = TApplicationException()
-            x.read(iprot)
-            iprot.readMessageEnd()
-            raise x
-        result = userHasAccess_result()
-        result.read(iprot)
-        iprot.readMessageEnd()
-        if result.success is not None:
-            return result.success
-        if result.sre is not None:
-            raise result.sre
-        raise TApplicationException(TApplicationException.MISSING_RESULT, "userHasAccess failed: unknown result")
-
-
-class Processor(Iface, TProcessor):
-    def __init__(self, handler):
-        self._handler = handler
-        self._processMap = {}
-        self._processMap["createDomain"] = Processor.process_createDomain
-        self._processMap["updateDomain"] = Processor.process_updateDomain
-        self._processMap["isDomainExists"] = Processor.process_isDomainExists
-        self._processMap["deleteDomain"] = Processor.process_deleteDomain
-        self._processMap["getDomain"] = Processor.process_getDomain
-        self._processMap["getDomains"] = Processor.process_getDomains
-        self._processMap["createUser"] = Processor.process_createUser
-        self._processMap["updatedUser"] = Processor.process_updatedUser
-        self._processMap["isUserExists"] = Processor.process_isUserExists
-        self._processMap["deleteUser"] = Processor.process_deleteUser
-        self._processMap["getUser"] = Processor.process_getUser
-        self._processMap["getUsers"] = Processor.process_getUsers
-        self._processMap["createGroup"] = Processor.process_createGroup
-        self._processMap["updateGroup"] = Processor.process_updateGroup
-        self._processMap["isGroupExists"] = Processor.process_isGroupExists
-        self._processMap["deleteGroup"] = Processor.process_deleteGroup
-        self._processMap["getGroup"] = Processor.process_getGroup
-        self._processMap["getGroups"] = Processor.process_getGroups
-        self._processMap["addUsersToGroup"] = Processor.process_addUsersToGroup
-        self._processMap["removeUsersFromGroup"] = Processor.process_removeUsersFromGroup
-        self._processMap["getGroupMembersOfTypeUser"] = Processor.process_getGroupMembersOfTypeUser
-        self._processMap["getGroupMembersOfTypeGroup"] = Processor.process_getGroupMembersOfTypeGroup
-        self._processMap["addChildGroupsToParentGroup"] = Processor.process_addChildGroupsToParentGroup
-        self._processMap["removeChildGroupFromParentGroup"] = Processor.process_removeChildGroupFromParentGroup
-        self._processMap["getAllMemberGroupsForUser"] = Processor.process_getAllMemberGroupsForUser
-        self._processMap["createEntityType"] = Processor.process_createEntityType
-        self._processMap["updateEntityType"] = Processor.process_updateEntityType
-        self._processMap["isEntityTypeExists"] = Processor.process_isEntityTypeExists
-        self._processMap["deleteEntityType"] = Processor.process_deleteEntityType
-        self._processMap["getEntityType"] = Processor.process_getEntityType
-        self._processMap["getEntityTypes"] = Processor.process_getEntityTypes
-        self._processMap["createEntity"] = Processor.process_createEntity
-        self._processMap["updateEntity"] = Processor.process_updateEntity
-        self._processMap["isEntityExists"] = Processor.process_isEntityExists
-        self._processMap["deleteEntity"] = Processor.process_deleteEntity
-        self._processMap["getEntity"] = Processor.process_getEntity
-        self._processMap["searchEntities"] = Processor.process_searchEntities
-        self._processMap["getListOfSharedUsers"] = Processor.process_getListOfSharedUsers
-        self._processMap["getListOfSharedGroups"] = Processor.process_getListOfSharedGroups
-        self._processMap["createPermissionType"] = Processor.process_createPermissionType
-        self._processMap["updatePermissionType"] = Processor.process_updatePermissionType
-        self._processMap["isPermissionExists"] = Processor.process_isPermissionExists
-        self._processMap["deletePermissionType"] = Processor.process_deletePermissionType
-        self._processMap["getPermissionType"] = Processor.process_getPermissionType
-        self._processMap["getPermissionTypes"] = Processor.process_getPermissionTypes
-        self._processMap["shareEntityWithUsers"] = Processor.process_shareEntityWithUsers
-        self._processMap["revokeEntitySharingFromUsers"] = Processor.process_revokeEntitySharingFromUsers
-        self._processMap["shareEntityWithGroups"] = Processor.process_shareEntityWithGroups
-        self._processMap["revokeEntitySharingFromGroups"] = Processor.process_revokeEntitySharingFromGroups
-        self._processMap["userHasAccess"] = Processor.process_userHasAccess
-
-    def process(self, iprot, oprot):
-        (name, type, seqid) = iprot.readMessageBegin()
-        if name not in self._processMap:
-            iprot.skip(TType.STRUCT)
-            iprot.readMessageEnd()
-            x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
-            oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
-            x.write(oprot)
-            oprot.writeMessageEnd()
-            oprot.trans.flush()
-            return
-        else:
-            self._processMap[name](self, seqid, iprot, oprot)
-        return True
-
-    def process_createDomain(self, seqid, iprot, oprot):
-        args = createDomain_args()
-        args.read(iprot)
-        iprot.readMessageEnd()
-        result = createDomain_result()
-        try:
-            result.success = self._handler.createDomain(args.domain)
-            msg_type = TMessageType.REPLY
-        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-            raise
-        except apache.airavata.model.sharing.ttypes.SharingRegistryException as sre:
-            msg_type = TMessageType.REPLY
-            result.sre = sre
-        except apache.airavata.model.sharing.ttypes.DuplicateEntryException as dee:
-            msg_type = TMessageType.REPLY
-            result.dee = dee
-        except Exception as ex:
-            msg_type = TMessageType.EXCEPTION
-            logging.exception(ex)
-            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-        oprot.writeMessageBegin("createDomain", msg_type, seqid)
-        result.write(oprot)
-        oprot.writeMessageEnd()
-        oprot.trans.flush()
-
-    def process_updateDomain(self, seqid, iprot, oprot):
-        args = updateDomain_args()
-        args.read(iprot)
-        iprot.readMessageEnd()
-        result = updateDomain_result()
-        try:
-            result.success = self._handler.updateDomain(args.domain)
-            msg_type = TMessageType.REPLY
-        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-            raise
-        except apache.airavata.model.sharing.ttypes.SharingRegistryException as sre:
-            msg_type = TMessageType.REPLY
-            result.sre = sre
-        except Exception as ex:
-            msg_type = TMessageType.EXCEPTION
-            logging.exception(ex)
-            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-        oprot.writeMessageBegin("updateDomain", msg_type, seqid)
-        result.write(oprot)
-        oprot.writeMessageEnd()
-        oprot.trans.flush()
-
-    def process_isDomainExists(self, seqid, iprot, oprot):
-        args = isDomainExists_args()
-        args.read(iprot)
-        iprot.readMessageEnd()
-        result = isDomainExists_result()
-        try:
-            result.success = self._handler.isDomainExists(args.domainId)
-            msg_type = TMessageType.REPLY
-        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-            raise
-        except apache.airavata.model.sharing.ttypes.SharingRegistryException as sre:
-            msg_type = TMessageType.REPLY
-            result.sre = sre
-        except Exception as ex:
-            msg_type = TMessageType.EXCEPTION
-            logging.exception(ex)
-            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-        oprot.writeMessageBegin("isDomainExists", msg_type, seqid)
-        result.write(oprot)
-        oprot.writeMessageEnd()
-        oprot.trans.flush()
-
-    def process_deleteDomain(self, seqid, iprot, oprot):
-        args = deleteDomain_args()
-        args.read(iprot)
-        iprot.readMessageEnd()
-        result = deleteDomain_result()
-        try:
-            result.success = self._handler.deleteDomain(args.domainId)
-            msg_type = TMessageType.REPLY
-        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-            raise
-        except apache.airavata.model.sharing.ttypes.SharingRegistryException as sre:
-            msg_type = TMessageType.REPLY
-            result.sre = sre
-        except Exception as ex:
-            msg_type = TMessageType.EXCEPTION
-            logging.exception(ex)
-            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-        oprot.writeMessageBegin("deleteDomain", msg_type, seqid)
-        result.write(oprot)
- 

<TRUNCATED>

Mime
View raw message