Returns the param list mapped by envelope (URL, PATH, ENTITY)
501005
function (service) {

            var index, length, parameters = this.smd.parameters, param,
                svcParameters = service.parameters || [],
                params = {
                    PATH: [], //args in URL path
                    URL: [], //args in query string
                    JSON: [], //JSON in POST/PUT body
                    ENTITY: [] //custom POST/PUT entity body (e.g., multi-part)
                };

            parameters = parameters ? parameters.concat(svcParameters) : svcParameters;

            if (parameters) {
                for (index = 0, length = parameters.length; index < length; index += 1) {
                    param = parameters[index];
                    params[param.envelope].push(param);
                }
            }

            return params;

        }
1136966
@GET
	@Path("getEntities")
	public List<EntityMetaData> getEntities(@QueryParam("path") String path) {
		String absolutePath = StorageConstants.NEXT_SERVER_ROOT + path;
		List<EntityMetaData> result = new ArrayList<EntityMetaData>();
		Entity[] entities = new Entity[0];
		try {
			entities = storageService.getEntityChildren(absolutePath);
		} catch (NotFoundException e) {
			// TODO
			e.printStackTrace();
		}
		
		List<Entity> list = Arrays.asList(entities);
		Collections.sort(list, new Comparator<Entity>() {
			public int compare(Entity e1, Entity e2) {
				if (e1 instanceof Folder) {
					if (e2 instanceof Folder) {
						return Collator.getInstance().compare(e1.getName(), e2.getName());
					} else {
						return -1;
					}
				} else {
					if (e2 instanceof Folder) {
						return 1;
					} else {
						return Collator.getInstance().compare(e1.getName(), e2.getName());
					}
				}
			}
		});
		
		for (Entity entity : list) {
			result.add(createMetaData(entity));
		}
		
		return  result;
	}
357565
function namedParameterList()
    {
        return array( 'path' => array( 'type' => 'array',
                                       'required' => true,
                                       'default' => false ),
                      'node_id' => array( 'type' => 'int',
                                          'required' => false,
                                          'default' => false ),
                      'class_filter' => array( 'type' => 'array',
                                               'required' => false,
                                               'default' => false ),
                      'depth_skip' => array( 'type' => 'int',
                                             'required' => false,
                                             'default' => false ),
                      'max_level' => array( 'type' => 'int',
                                            'required' => false,
                                            'default' => false ),
                      'is_selected_method' => array( 'type' => 'string',
                                                     'required' => false,
                                                     'default' => 'tree' ),
                      'indentation_level' => array( 'type' => 'int',
                                                    'required' => false,
                                                    'default' => 15 ),
                      'language' => array( 'type' => 'string|array',
                                           'required' => false,
                                           'default' => false ),
                      'load_data_map' => array( 'type' => 'boolean',
                                           'required' => false,
                                           'default' => null ) );
    }
391215
def list(self, path):
        
        try:
            payload = {
                'list': True
            }
            return self._adapter.get('/v1/{0}'.format(path), params=payload).json()
        except exceptions.InvalidPath:
            return None
183031
def parse_params(self, intent_name):
        

        params = []
        action_func = self.assist._intent_action_funcs[intent_name][0]
        argspec = inspect.getargspec(action_func)
        param_entity_map = self.assist._intent_mappings.get(intent_name)

        args, defaults = argspec.args, argspec.defaults
        default_map = {}
        if defaults:
            default_map = dict(zip(args[-len(defaults):], defaults))

        # import ipdb; ipdb.set_trace()
        for arg in args:
            param_info = {}

            param_entity = param_entity_map.get(arg, arg)
            param_name = param_entity.replace('sys.', '')
            # param_name = arg

            param_info['name'] = param_name
            param_info['value'] = '$' + param_name
            param_info['dataType'] = '@' + param_entity
            param_info['prompts'] = []  # TODO: fill in provided prompts
            param_info['required'] = arg not in default_map
            param_info['isList'] = isinstance(default_map.get(arg), list)
            if param_info['isList']:
                param_info['defaultValue'] = ''
            else:
                param_info['defaultValue'] = default_map.get(arg, '')

            params.append(param_info)
        return params
409378
def params(self):
        
        if isinstance(self.request, list):
            return unmunchify(self.request)
        (params, _) = xmlrpc.loads(self.request)
        return params
1197045
def getparams(self, param):
        

        return list(cparam for cparam in self.values() if cparam == param)
1279768
function getRouteParams(route, params) {
  var routeParams = {};

  if (!route.path) return routeParams;

  (0, _PatternUtils.getParamNames)(route.path).forEach(function (p) {
    if (Object.prototype.hasOwnProperty.call(params, p)) {
      routeParams[p] = params[p];
    }
  });

  return routeParams;
}
919914
function getIdlParameterList(parameters) {
    var result = []

    if (parameters.length == 0) return "";

    result.push("<table>")
    parameters.forEach(function(parameter, index, list){
        var comma = (index == list.length-1) ? "" : ","
        result.push("<tr>")
        result.push("<td>" + Indent2 + (parameter.out ? "out" : "in"))
        result.push("<td>" + getIdlType(parameter.type))
        result.push("<td>" + "<span class='parameterName tdIndent'>" + parameter.name + comma + "</span>")
    })

    result.push("</table>")
    return result.join("\n") + Indent
}
1334189
def _get_path_params(match):
    
    result = {}
    for var_name, value in match.groupdict().iteritems():
      actual_var_name = ApiConfigManager._from_safe_path_param_name(var_name)
      result[actual_var_name] = urllib.unquote_plus(value)
    return result
497061
private List getInfoListAllServiceInnerEx(Map requestParamMap,String tableName,Map sortMap,String cusWhere,String cusSelect,String modelName,int limit,List cusPlaceList) throws Exception{
		String tempKeyId=calcuIdKey();

		String sort=(String) sortMap.get("sort");
		String order=(String) sortMap.get("order");
		String cusSort=(String) sortMap.get("cusSort");
		
		if(modelName==null || "".equals(modelName)){
			modelName=tableName;
		}
		
		//add 201807 ning
		//Map requestParamMap=changeCase4Param(requestParamMap0);		
		
		String id=(String) requestParamMap.get(tempKeyId);

		String where="";
		
		if(cusWhere !=null && !"".equals(cusWhere)){
			where="where "+cusWhere;
		}
		
		if(modelName==null || "".equals(modelName)){
			modelName=tableName;
		}
		
		String whereCols="";		
	
		
		Map whereColsMap=requestParamMap;
		if(whereColsMap!=null && !whereColsMap.isEmpty()){
			StringBuilder sb=new StringBuilder("");
			Set<String> keySet=whereColsMap.keySet();
			int i=0;
			for(String key:keySet){
				if(!key.contains(".")){
					continue;
				}
				if(key.contains("dbcol_")){
					continue;
				}
				String colName=key;
				String realColName=colName.replace(".", CheckModelTypeUtil.DUMMY_SPLIT);
				String colsStr=colName+" as "+realColName;
				if(i==0){
					sb.append(colsStr);	
				}else{
					sb.append(",").append(colsStr);
				}
				i++;
			}
			whereCols=sb.toString();
		}		
		
		Map modelEntryMap=getModelEntryMap(requestParamMap,tableName,modelName,dbName,whereCols);
		List placeList=new ArrayList();
		String whereInStr=createWhereInStr(requestParamMap,modelEntryMap,placeList);
		if(cusPlaceList==null){
			cusPlaceList=new ArrayList();
		}
		List realPlaceList=new ArrayList();
		realPlaceList.addAll(placeList);
		realPlaceList.addAll(cusPlaceList);
		if(whereInStr!=null && !"".equals(whereInStr)){
			if(!where.equals("")){
				where=where+" and "+whereInStr;
			}else{
				where="where "+whereInStr;
			}
		}
	
		String select="";
		if(cusSelect!=null && !"".equals(cusSelect)){
			select="select "+cusSelect+" from "+tableName+" "+where;
		}else{
			select="select * from "+tableName+" "+where;
		}
		//String orderSql="order by ";
		String orderSql="";
		if(cusSort!=null && !"".equals(cusSort)){
			orderSql="order by "+cusSort;
		}else if(sort!=null && !sort.equals("")){
			orderSql="order by "+sort+" "+order;
		}
/*		String orderSql="";
		if(sort!=null && !sort.equals("")){
			orderSql="order by "+sort+" "+order;
		}*/
/*		else{
			orderSql=orderSql+"id desc";
		}*/
		List infoList=null;
		String sql=select+" "+orderSql;
		if(limit>=0){

			infoList=getInnerDao().queryLimitObjJoinByCondition(sql,realPlaceList.toArray(),limit);
		}else{
			infoList=getInnerDao().queryObjJoinByCondition(sql,realPlaceList.toArray());			
		}

		

		if(infoList==null){
			return null;
		}
		CheckModelTypeUtil.addMetaCols(infoList);
		//CheckModelTypeUtil.changeDateCols(infoList);
		CheckModelTypeUtil.changeNoStrCols(infoList);
		return infoList;
	}
314319
def format_file_url_params(file_urls):
        '''
            
        '''
        file_urls_payload = {}
        if file_urls:
            for idx, fileurl in enumerate(file_urls):
                file_urls_payload["file_url[" + str(idx) + "]"] = fileurl
        return file_urls_payload
358009
public List<ValidationData> getValidationDatas(ParamType paramType, String key) {
        if (this.urlMap == null || this.validationDataRuleListMap == null) {
            log.info("url map is empty :: " + key );
            return null;
        }

        if (key == null || paramType == null) {
            throw new ValidationLibException("any parameter is null", HttpStatus.INTERNAL_SERVER_ERROR);
        }

        ReqUrl reqUrl = urlMap.get(key);
        if (reqUrl == null) {
            log.info("reqUrl is null :" + key);
            return null;
        }

        return validationDataRuleListMap.get(paramType.getUniqueKey(reqUrl.getUniqueKey()));
    }
516889
def get_encoded_query_params(self):
        """"""
        get_data = encode_items(self.request.GET.lists())
        return urlencode(get_data)
1187016
private Map<String, String[]> getParameterMap(String url) {

        Map<String, String[]> result = new HashMap<String, String[]>();
        if (CmsStringUtil.isNotEmpty(url)) {
            int pos = url.indexOf(CmsRequestUtil.URL_DELIMITER);
            if (pos >= 0) {
                result = CmsRequestUtil.createParameterMap(url.substring(pos + 1));
            }
        }
        return result;
    }
629831
def get_params(self, params, name_request):
        '''
        
        '''
        self.write('')
        for elem in params:
            request_type = elem['type'] if elem.get('type', None) else 'schema'
            name = elem['name']
            if elem.get('required', None):
                name += '(required)'
            schema = elem.get('schema', None)
            name = ':{} {} {}:'.format(name_request, request_type, name)
            if schema:
                definition = schema['$ref'].split('/')[-1]
                self.write(name + ' :ref:`{}`'.format(definition), 1)
                self.write('')
            else:
                desc = elem.get('description', '')
                self.write(name)
                self.write('{}'.format(desc), self.indent_depth + 1)
        self.write('')
906901
def _list(self, path, dim_key=None, **kwargs):
        """"""
        url_str = self.base_url + path
        if dim_key and dim_key in kwargs:
            dim_str = self.get_dimensions_url_string(kwargs[dim_key])
            kwargs[dim_key] = dim_str

        if kwargs:
            url_str += '?%s' % parse.urlencode(kwargs, True)

        body = self.client.list(
            path=url_str
        )

        return self._parse_body(body)