Get this object properties

REST: GET /email/domain/{domain}/account/{accountName}/filter/{name}
@param domain [required] Name of your domain name
@param accountName [required] Name of account
@param name [required] Filter name
498169
public OvhFilter domain_account_accountName_filter_name_GET(String domain, String accountName, String name) throws IOException {
		String qPath = "/email/domain/{domain}/account/{accountName}/filter/{name}";
		StringBuilder sb = path(qPath, domain, accountName, name);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhFilter.class);
	}
578565
@SuppressWarnings("unchecked")
  public <S> S getService(ObjectName name) {
    return (S) servicesByName.get(name);
  }
575949
public OvhAcl domain_acl_accountId_GET(String domain, String accountId) throws IOException {
		String qPath = "/email/domain/{domain}/acl/{accountId}";
		StringBuilder sb = path(qPath, domain, accountId);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhAcl.class);
	}
321800
def get_by_name(self, name: str) -> List[Account]:
        
        # return self.query.filter(Account.name == name).all()
        return self.get_by_name_from(self.book.root, name)
1082600
public static authenticationvserver_auditsyslogpolicy_binding[] get(nitro_service service, String name) throws Exception{
		authenticationvserver_auditsyslogpolicy_binding obj = new authenticationvserver_auditsyslogpolicy_binding();
		obj.set_name(name);
		authenticationvserver_auditsyslogpolicy_binding response[] = (authenticationvserver_auditsyslogpolicy_binding[]) obj.get_resources(service);
		return response;
	}
1034326
function getAccount (queryOptions, { accountId }) {
  return sendQuery(
    queryOptions,
    queryHelper.addQuery(
      queryHelper.emptyQuery(),
      'getAccount',
      {
        accountId
      }
    ),
    (resolve, reject, responseName, response) => {
      if (responseName !== 'ACCOUNT_RESPONSE') {
        const error = JSON.stringify(response.toObject().errorResponse)
        return reject(new Error(`Query response error: expected=ACCOUNT_RESPONSE, actual=${responseName}\nReason: ${error}`))
      }

      const account = response.getAccountResponse().getAccount().toObject()
      resolve(account)
    }
  )
}
351175
def pre_auth(self, transport, account_name):
        
        auth_token = AuthToken()
        auth_token.account_name = account_name

        domain = util.get_domain(account_name)
        if domain == None:
            raise AuthException('Invalid auth token account')

        if domain in self.domains:
            domain_key = self.domains[domain]
        else:
            domain_key = None

        if domain_key == None:
            raise AuthException('Invalid domain key for domain %s' % domain)

        self.log.debug('Initialized domain key for account %s'
                      % account_name)

        expires = 0
        timestamp = int(time() * 1000)
        pak = hmac.new(domain_key, '%s|%s|%s|%s' %
                       (account_name, sconstant.E_NAME, expires, timestamp),
                       hashlib.sha1).hexdigest()

        attrs = {sconstant.A_BY: sconstant.V_NAME}
        account = SOAPpy.Types.stringType(data=account_name, attrs=attrs)

        attrs = {sconstant.A_TIMESTAMP: timestamp, sconstant.A_EXPIRES: expires}
        preauth = SOAPpy.Types.stringType(data=pak,
                                          name=sconstant.E_PREAUTH,
                                          attrs=attrs)

        params = {sconstant.E_ACCOUNT: account,
                  sconstant.E_PREAUTH: preauth}

        self.log.debug('Authenticating account %s using domain key'
                       % account_name)
        try:
            res = transport.invoke(zconstant.NS_ZIMBRA_ACC_URL,
                                   sconstant.AuthRequest,
                                   params,
                                   auth_token)
        except SoapException as exc:
            raise AuthException(unicode(exc), exc)

        auth_token.token = res.authToken
        auth_token.session_id = res.sessionId

        self.log.info('Authenticated account %s, session id %s'
                      % (account_name, auth_token.session_id))

        return auth_token
416233
public ArrayList<Long> domain_task_mailinglist_GET(String domain, String account) throws IOException {
		String qPath = "/email/domain/{domain}/task/mailinglist";
		StringBuilder sb = path(qPath, domain);
		query(sb, "account", account);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, t3);
	}
596018
def get_account(self, name, **kwargs):
        
        if len(name.split(".")) == 3:
            return self.get_objects([name])[0]
        else:
            return self.get_account_by_name(name, **kwargs)
819564
public OvhTaskFilter domain_task_filter_id_GET(String domain, Long id) throws IOException {
		String qPath = "/email/domain/{domain}/task/filter/{id}";
		StringBuilder sb = path(qPath, domain, id);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhTaskFilter.class);
	}
763061
public OvhAcl domain_acl_POST(String domain, String accountId) throws IOException {
		String qPath = "/email/domain/{domain}/acl";
		StringBuilder sb = path(qPath, domain);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "accountId", accountId);
		String resp = exec(qPath, "POST", sb.toString(), o);
		return convertTo(resp, OvhAcl.class);
	}
1139475
def _get_zone_id_from_name(self, name):
        """"""
        results = self.client['Account'].getDomains(
            filter={"domains": {"name": utils.query_filter(name)}})
        return [x['id'] for x in results]
1241953
def get_account_authToken(self, account=None, account_name=''):
        
        if account is None:
            account = self.get_account(zobjects.Account(name=account_name))
        selector = account.to_selector()

        resp = self.request('DelegateAuth', {'account': selector})

        authToken = resp['authToken']
        lifetime = int(resp['lifetime'])

        return authToken, lifetime
572862
public static auditnslogpolicy_binding get(nitro_service service, String name) throws Exception{
		auditnslogpolicy_binding obj = new auditnslogpolicy_binding();
		obj.set_name(name);
		auditnslogpolicy_binding response = (auditnslogpolicy_binding) obj.get_resource(service);
		return response;
	}
1048071
public void domain_acl_accountId_DELETE(String domain, String accountId) throws IOException {
		String qPath = "/email/domain/{domain}/acl/{accountId}";
		StringBuilder sb = path(qPath, domain, accountId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1315954
@Override
    public List<String> getRoles(String name, String... domain) {
        if (domain.length == 1) {
            name = domain[0] + "::" + name;
        } else if (domain.length > 1) {
            throw new Error("error: domain should be 1 parameter");
        }

        if (!hasRole(name)) {
            throw new Error("error: name does not exist");
        }

        List<String> roles = createRole(name).getRoles();
        if (domain.length == 1) {
            for (int i = 0; i < roles.size(); i ++) {
                roles.set(i, roles.get(i).substring(domain[0].length() + 2, roles.get(i).length()));
            }
        }
        return roles;
    }
322272
public static dnszone_domain_binding[] get_filtered(nitro_service service, String zonename, String filter) throws Exception{
		dnszone_domain_binding obj = new dnszone_domain_binding();
		obj.set_zonename(zonename);
		options option = new options();
		option.set_filter(filter);
		dnszone_domain_binding[] response = (dnszone_domain_binding[]) obj.getfiltered(service, option);
		return response;
	}