Create a RequestBuilder for phrase requests.

@param  {String} id      phrase id
@param  {String} param1  path parameter
@param  {String} param2  path parameter
@param  {String} paramN  path parameter

@return {corbel.CompoSR.RequestBuilder}
188966
function() {
                var requestBuilder = new corbel.CompoSR.RequestBuilder(Array.prototype.slice.call(arguments));
                requestBuilder.driver = this.driver;
                return requestBuilder;
            }
1253902
function(options) {
                var queryParams = '';
                if (options && options.avoidNotification) {
                    queryParams = '?avoidnotification=true';
                }
                console.log('iamInterface.user.delete');
                corbel.validate.value('id', this.id);
                return this.request({
                    url: this._buildUriWithDomain(this.uri, this.id) + queryParams,
                    method: corbel.request.method.DELETE
                });
            }
69724
function create_layer(path, params) {
    var p = path.substring(1).split('/');
    if (p[1] == 'browse')
      browse(p[2], params)
    else if (p[1] == 'create')
      form(p[2])
    else if (p[1] == 'update')
      form(p[2], p[3]);
  }
1191680
function param(err) {
    if (err) {
      return done(err);
    }

    if (i >= keys.length ) {
      return done();
    }

    paramIndex = 0;
    key = keys[i++];
    name = key.name;
    paramVal = req.params[name];
    paramCallbacks = params[name];
    paramCalled = called[name];

    if (paramVal === undefined || !paramCallbacks) {
      return param();
    }

    // param previously called with same value or error occurred
    if (paramCalled && (paramCalled.match === paramVal
      || (paramCalled.error && paramCalled.error !== 'route'))) {
      // restore value
      req.params[name] = paramCalled.value;

      // next param
      return param(paramCalled.error);
    }

    called[name] = paramCalled = {
      error: null,
      match: paramVal,
      value: paramVal
    };

    paramCallback();
  }
115730
function buildMethodName(req) {
    return [
        req.params.service,
        req.params.subservice
    ].filter(Boolean).join('-');
}
81081
function (params) {
  const oThis = this
  ;

  params = params || {};
  oThis.passphrase = params.passphrase || '';
  oThis.chain = params.chain;
}
668817
public function createForTask(string $id, array $params = [])
    {
        return $this->executeRequest(
            RequestMethodEnum::POST,
            ResourceMethodEnum::CREATE_FOR_TASK,
            $params,
            $id
        );
    }
719380
public String buildUrl(String path, List<Pair> queryParams, List<Pair> collectionQueryParams) {
        final StringBuilder url = new StringBuilder();
        url.append(basePath).append(path);

        if (queryParams != null && !queryParams.isEmpty()) {
            // support (constant) query string in `path`, e.g. "/posts?draft=1"
            String prefix = path.contains("?") ? "&" : "?";
            for (Pair param : queryParams) {
                if (param.getValue() != null) {
                    if (prefix != null) {
                        url.append(prefix);
                        prefix = null;
                    } else {
                        url.append("&");
                    }
                    String value = parameterToString(param.getValue());
                    url.append(escapeString(param.getName())).append("=").append(escapeString(value));
                }
            }
        }

        if (collectionQueryParams != null && !collectionQueryParams.isEmpty()) {
            String prefix = url.toString().contains("?") ? "&" : "?";
            for (Pair param : collectionQueryParams) {
                if (param.getValue() != null) {
                    if (prefix != null) {
                        url.append(prefix);
                        prefix = null;
                    } else {
                        url.append("&");
                    }
                    String value = parameterToString(param.getValue());
                    // collection query parameter value already escaped as part of parameterToPairs
                    url.append(escapeString(param.getName())).append("=").append(value);
                }
            }
        }

        return url.toString();
    }
1173368
function(id) {
                var resource = new corbel.Borrow.BorrowBuilder(id);
                resource.driver = this.driver;
                return resource;
            }
1013449
function Request(path, client, delim) {
  if (!(this instanceof Request)) return new Request(path, client);

  // init client
  this.client = client;
  if (!this.client) throw new Error('hyper-path requires a client to be passed as the second argument');

  this.delim = delim || '.';
  this.parse(path);

  this._listeners = {};
  this._scope = {};
  this._warnings = {};
}
1070826
def build_params(self, params, i):
        
        prefix = 'Tags.member.%d.' % i
        params[prefix+'ResourceId'] = self.resource_id
        params[prefix+'ResourceType'] = self.resource_type
        params[prefix+'Key'] = self.key
        params[prefix+'Value'] = self.value
        if self.propagate_at_launch:
            params[prefix+'PropagateAtLaunch'] = 'true'
        else:
            params[prefix+'PropagateAtLaunch'] = 'false'
167033
public UriBuilder queryParam(String param, String value) throws URISyntaxException {
        if (StringUtils.isNotBlank(param) && StringUtils.isNotBlank(value)) {
            return new UriBuilder(addParameter(param, value));
        } else {
            return this;
        }
    }
94847
function argReq (method, path) {
  return async function (args, data) {
    // `args` can either be a single value or an array
    if (Array.isArray(args)) {
      args = args.join('/')
    }
    return await this.request(method, `${path}/${args}`, data)
  }
}
484858
function(id) {
                console.log('oauthInterface.user.emailConfirmation');
                this.uri += '/' + id + '/emailConfirmation';

                var params = corbel.utils.extend(this.params, {});
                params.url = this._buildUri(this.uri, id);
                params.method = corbel.request.method.PUT;
                params.noRetry = true;

                return this.request(params);
            }
448694
@SafeVarargs
    public final RequestBuilder params(Map.Entry<String, ?>... params) {
        this.params = Lists.of(params);
        return this;
    }
1080497
public JSONObject post(String path, Map<String, Object> params) throws APIError {
        return request(Verb.POST, path, params);
    }
934871
public function setQueryParams($id, $params = [])
    {
        $requestQuery = $this->request->query->get('query_id');
        
        if(isset($requestQuery[$id])) {
            $paramsQuery = $requestQuery[$id];
        } elseif(isset($params['query'])) {
            $paramsQuery = $params['query'];
        } else {
            $paramsQuery = [];
        }
        
        $query = array_merge([
            'limit' => null,
            'offset' => null,
            'orderby' => null,
            'order' => null
        ], $paramsQuery);
        
        if($query['offset'] !== null && $query['offset'] >= $this->paramDefaults['offset']) {
            $this->qb->setFirstResult($query['offset']);
        }
        
        if($query['limit'] !== null && $query['limit'] >= $this->paramDefaults['limit']) {
            $this->qb->setMaxResults($query['limit']);
        }
        
        if(in_array($query['orderby'], $this->paramDefaults['orderby'])) {
            $order = in_array(strtoupper($query['order']), $this->paramDefaults['order']) ? $query['order'] : $this->paramDefaults['order'][0];

            $this->qb->orderBy('a.'.Inflector::camelize($query['orderby']), strtoupper($order));
        }
    }