revoke authorization of a group
357438
def del_permission(self, role, name):
        
        if not self.has_permission(role, name):
            return True
        targetGroup = AuthGroup.objects(role=role, creator=self.client).first()
        target = AuthPermission.objects(groups=targetGroup, name=name, creator=self.client).first()
        if not target:
            return True
        target.delete()
        return True
168120
def disable(resource_group_name, workflow_name, custom_headers:nil)
      response = disable_async(resource_group_name, workflow_name, custom_headers:custom_headers).value!
      nil
    end
177967
def revoke_admin_privileges(name, **client_args):
    '''
    
    '''
    client = _client(**client_args)
    client.revoke_admin_privileges(name)

    return True
780956
def revoke_auth(self, load):
        '''
        
        '''
        if 'id' not in load:
            return False
        keyapi = salt.key.Key(self.opts)
        keyapi.delete_key(load['id'],
                          preserve_minions=load.get('preserve_minion_cache',
                                                         False))
        return True
176107
async def revoke(self):
        
        await self.controller.revoke(self.username)
        self._user_info.access = ''
448058
def revoke_user_access(self, instance, user, db_names, strict=True):
        
        return instance.revoke_user_access(user, db_names, strict=strict)
1134981
async def remove(gc: GroupControl, slaves):
    """"""
    click.echo("Removing from existing group: %s" % slaves)
    click.echo(await gc.remove(slaves))
980252
def remove_user_permission(rid, uid, action='full'):
    
    rid = rid.replace('/', '%252F')

    try:
        acl_url = urljoin(_acl_url(), 'acls/{}/users/{}/{}'.format(rid, uid, action))
        r = http.delete(acl_url)
        assert r.status_code == 204
    except DCOSHTTPException as e:
        if e.response.status_code != 400:
            raise
64812
def revoke(access_token)
      response = client.as(access_token).post(path: "/oauth/revoke")
      response.code == 200 && response.empty?
    end
1081651
def delete(self, token_id, *args, **kwargs):
        

        return self.client._put(
            "{0}/revoked".format(
                self._url(token_id)
            ),
            None,
            *args,
            **kwargs
        )
248435
def revoke_user_access( self, access_id ):
        '''
            
        ''' 
        path = "/api/v3/publisher/user/access/revoke"

        data = {
            'api_token': self.api_token, 
            'access_id': access_id,
        }

        r = requests.get( self.base_url + path, data=data )

        if r.status_code != 200:
            raise ValueError( path + ":" + r.reason )
241306
def deluser(name, username):
    '''
    
    '''
    grp_info = __salt__['group.info'](name)

    if username not in grp_info['members']:
        return True

    # Note: pw exits with code 65 if group is unknown
    retcode = __salt__['cmd.retcode']('pw groupmod {0} -d {1}'.format(
        name, username), python_shell=False)

    return not retcode
138848
def revoke_token(self, subid):
    ''''''
    from expfactory.database.models import Participant
    p = Participant.query.filter(Participant.id == subid).first()
    if p is not None:
        p.token = 'revoked'
    self.session.commit()
    return p
748732
def revoke(self):
        """"""
        if self.access_token is None:
            raise InvalidInvocation("no token available to revoke")

        self._authenticator.revoke_token(self.access_token, "access_token")
        self._clear_access_token()
905724
def revoke_oauth_credential(self):
        """"""
        if self.session.token_type == auth.SERVER_TOKEN_TYPE:
            return

        credential = self.session.oauth2credential
        revoke_access_token(credential)
489299
def revoke_refresh_token(self):
        

        if not self._refresh_token:
            return

        self.execute_post('authentication/revoke', json=dict(
            token_type_hint='refresh_token',
            token=self._refresh_token
        ))

        self._refresh_token = None
1039923
def revoke_grant(key_id, grant_id, region=None, key=None, keyid=None,
                 profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    if key_id.startswith('alias/'):
        key_id = _get_key_id(key_id)
    r = {}
    try:
        conn.revoke_grant(key_id, grant_id)
        r['result'] = True
    except boto.exception.BotoServerError as e:
        r['result'] = False
        r['error'] = __utils__['boto.get_error'](e)
    return r