List data stores

@ManagerRoute("list")
329916
public function listAction()
    {
        /** @var FeatureTypeService $featureService */
        $featureService = $this->container->get("features");
        $featureTypes   = $featureService->getFeatureTypeDeclarations();

        return new JsonResponse(array(
            'list' => $featureTypes,
        ));
    }
182096
function () {
		var self = this;
		var routes;

		this.getRouteFromDirectory(this.routeBasePath(), function (err, dataRoute) {
			if (err) return console.dir(err);

			routes = dataRoute.routes;

			if (dataRoute.dirs && dataRoute.dirs.length > 0) {
				var listRouteFromDir = [];

				dataRoute.dirs.forEach(function (dir) {
					if (dir) listRouteFromDir.push(function (cb) { self.getRouteFromDirectory(self.routeBasePath() + '/' + dir, dir, cb); });
				});

				async.parallel(listRouteFromDir, function (err, asyncData){
					if (err) return console.dir(err);

					listRouteFromDir = [];

					if (asyncData.length > 0) {
						asyncData.forEach(function (data) {
							data.dirs.forEach(function (dir) {
								if (dir)
									listRouteFromDir.push(function (cb) {
										self.getRouteFromDirectory(data.pathDir + '/' + dir, data.rootApiPath + '/' + dir, cb);
									});
							});
						});

						async.parallel(listRouteFromDir, function (err, asyncDataVer){
							if (err) return console.dir(err);

							self.setTempRoutes(asyncData, routes);
							self.setTempRoutes(asyncDataVer, routes);
							self.__init__middleware(routes);
						});
					}
				});
			} else {
				self.__init__middleware(routes);
			}
		});
	}
1031577
def file_list(ref)
      if (sha = @access.ref_to_sha(ref))
        commit = @access.commit(sha)
        tree_map_for(sha).inject([]) do |list, entry|
          next list if entry.name.start_with?('_')
          next list if @page_class.valid_page_name?(entry.name)
          list << entry.file(self, commit)
        end
      else
        []
      end
    end
973068
function(list){
            localStorage.setItem(localStorageKey, JSON.stringify(list));
            // if we used a real database, we would likely do the below in a callback
            this.list = list;
            this.trigger(list); // sends the updated list to all listening components (TodoApp)
        }
657360
function listItemsController(path) {
    restController.call(this, 'get', path);

    var ctrl = this;

    /**
     * Ignore empty by default on list controller
     * because parameters are most likly for search
     */
    ctrl.ignoreEmptyParams = true;

    /**
     * Method to paginate a mongoose query
     * @param {Integer} total
     * @param {Query} query
     * @param {Integer} [itemsPerPage=50]
     *
     * @return {Query}
     */
    this.paginate = function(total, query, itemsPerPage) {


        var paginate = require('node-paginate-anything');
        var p = paginate(ctrl.req, ctrl.res, total, itemsPerPage || 50);

        if (!p) {
            return query;
        }

        query.limit(p.limit);
        query.skip(p.skip);

        return query;
    };


    /**
     * List controller use this method to output a service as a rest
     * service
     *
     * This default method is paginated
     *
     * @param {apiService} service
     *
     * @return {Promise}
     */
    this.jsonService = function(service) {

        var params = ctrl.getServiceParameters(ctrl.req);

        var promise = service.getResultPromise(params, ctrl.paginate);

        ctrl.outputJsonFromPromise(service, promise);

        return promise;
    };
}
929676
public function listStore()
    {
        $this->actionListStore();
        $this->setTitleListStore();
        $this->setBreadcrumbListStore();
        $this->setFilterListStore();
        $this->setPagerListStore();

        $this->setData('stores', $this->getListStore());
        $this->setData('default_store', $this->store->getDefault());

        $this->outputListStore();
    }
482733
function action_list()
    {
        $_model = $this->model;
        $gets = $this->gets;
        $gets['page'] = empty($_REQUEST[self::$page_key]) ? 1 : $_REQUEST[self::$page_key];
        $gets['pagesize'] = empty($_REQUEST[self::$pagesize_key]) ? self::$pagesize_default : $_REQUEST[self::$pagesize_key];

        /**
         * @var Pager
         */
        $pager = null;
        $this->vars['list'] = $this->model->gets($gets, $pager);
        $this->vars['pager'] = array(
            'total' => $pager->total,
            'render' => $pager->render(),
            'pagesize' => $pager->pagesize,
            'totalpage' => $pager->totalpage,
            'nowpage' => $pager->page
        );
        $this->swoole->tpl->ref('pager', $this->vars['pager']);
        $this->swoole->tpl->ref('list', $this->vars['list']);
    }
553721
def list(self, limit=None, marker=None, name=None, visibility=None,
            member_status=None, owner=None, tag=None, status=None,
            size_min=None, size_max=None, sort_key=None, sort_dir=None):
        
        return self._manager.list(limit=limit, marker=marker, name=name,
                visibility=visibility, member_status=member_status,
                owner=owner, tag=tag, status=status, size_min=size_min,
                size_max=size_max, sort_key=sort_key, sort_dir=sort_dir)
1064917
function List(value, path) {

    if (process.env.NODE_ENV === 'production') {
      if (identity) {
        return value; // just trust the input if elements must not be hydrated
      }
    }

    if (process.env.NODE_ENV !== 'production') {
      path = path || [displayName];
      assert(isArray(value), function () { return 'Invalid value ' + assert.stringify(value) + ' supplied to ' + path.join('/') + ' (expected an array of ' + typeNameCache + ')'; });
    }

    var idempotent = true; // will remain true if I can reutilise the input
    var ret = []; // make a temporary copy, will be discarded if idempotent remains true
    for (var i = 0, len = value.length; i < len; i++ ) {
      var actual = value[i];
      var instance = create(type, actual, ( process.env.NODE_ENV !== 'production' ? path.concat(i + ': ' + typeNameCache) : null ));
      idempotent = idempotent && ( actual === instance );
      ret.push(instance);
    }

    if (idempotent) { // implements idempotency
      ret = value;
    }

    if (process.env.NODE_ENV !== 'production') {
      Object.freeze(ret);
    }

    return ret;
  }
514002
function beforeList (controller, args, fields, title, form, links, defaultQueryArgs) {
    // get model from controller
    var model = controller.model
    // set limit
    var limit = args.limit || controller.defaultLimit
    var offset = args.offset || 0
    // set to true to show clear option for filters/sort
    var clear = false
    // set minimum limit to 2
    if (limit < 2) {
        limit = 2
    }
    // build arguments for query
    var query = {
        session: args.session,
    }
    // if query args are passed use them
    if (defined(defaultQueryArgs)) {
        _.merge(query, defaultQueryArgs)
    }
    // add order if set
    if (defined(args.orderColumn)) {
        query.order = [args.orderColumn]
        // if custom order is set add clear option
        clear = true
        // add direction if set
        if (defined(args.orderDirection)) {
            query.order.push(args.orderDirection)
        }
    }
    // add where if set
    if (defined(args.where)) {
        query.where = JSON.parse(args.where)
    }
    // included deleted records
    if (defined(args.deleted)) {
        // create where query if not set
        if (!defined(query.where)) {
            query.where = {}
        }
        // include deleted records - if argument is only then only deleted
        query.where.isDeleted = args.deleted === 'only'
            ? true: null
    }
    // add extra columns as query param options
    _.each(model.extraColumns, (spec, name) => {
        // if param is set in args add to where query
        if (typeof args[name] === 'string') {
            // create where query if not set
            if (!defined(query.where)) {
                query.where = {}
            }
            // if query is quoted then do exact match
            var queryArg = args[name].charAt(0) === '"' && args[name].charAt(args[name].length - 1) === '"'
                // strip leading and trailing quotes
                ? args[name].substr(1, args[name].length - 2)
                // add wildcards to string
                : `%${args[name]}%`
            // set like query
            query.where[name] = {like: queryArg}
            // if filter is set add clear option
            clear = true
            // and param to sort links
            _.each(fields, field => {
                if (field.orderAscUrl) {
                    field.orderAscUrl += '&'+name+'='+args[name]
                }
                if (field.orderDescUrl) {
                    field.orderDescUrl += '&'+name+'='+args[name]
                }
            })
        }
    })
    // if originalId set add to query
    if (args.originalId) {
        // create where query if not set
        if (!query.where) {
            query.where = {}
        }
        // set originalId in query
        query.where.originalId = {eq: args.originalId}
    }
    // do database query
    return model.query(query)
    // prepare args for primary method
    .then(result => {
        // remove session from query args for presentation
        delete query.session
        // fetch records
        return result.fetch(limit, offset)
        // resolve with result and record data
        .then(records => {
            // add actions to records
            _.each(records, record => {
                buildActions(controller, record)
            })
            // return data that will be merged into args for primary method
            return {
                clear: clear,
                fields: fields,
                form: form,
                links: links,
                query: query,
                records: records,
                result: {
                    length: result.length,
                },
                title: title,
            }
        })
    })
}
219748
def project_list_folder(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/listFolder' % object_id, input_params, always_retry=always_retry, **kwargs)
1156881
function getList(getList, list, cb) {
			
			/* set route from config and run middleware */
			debug.sockets('run list', getList.key);
			
			if(globalOnlyRoutes && globalOnlyRoutes.indexOf(getList.key) < 0) {
				return cb({
					path: getList.path, 
					success: false, 
					error: 'Not Allowed'
				});
			}
			
			if(globalExcludeRoutes && globalExcludeRoutes.indexOf(getList.key) > -1) {
				return cb({
					path: getList.path, 
					success: false, 
					error: 'Not Allowed'
				});
			}
			
			var listConfig = opts.lists[getList.key];
			
			if(_.isObject(listConfig)) {
				var excludes = listConfig.exclude ? listConfig.exclude.split(/[\s,]+/) : [];
				if(excludes.indexOf('list') > -1) {
					return cb({
						path: getList.path, 
						success: false, 
						error: 'Not Allowed'
					});
				}
			}
			
			var me = configMe(opts, getList.key, 'list', false,  live);
			
			debug.sockets('runAction for me', me);
											
			list.list = getList;
			// add opts
			list.list.apiOptions = opts;
			
			runAction.call(live, me, list, socket, function(err) {
				debug.sockets('## runAction callback for ' + list.list.key);
				if(err) {
					debug.sockets( '#### Err  ', err);
					cb({
						path: getList.path, 
						success: false, 
						error: err.message
					});
				} else {
					me.route.call(live, list, req, socket, function(err, docs) {
						debug.sockets('got docs from list... run postware',list.list.key, err);
						if(docs) {
							runPostware.call(live, list.list.path, docs, socket, me.postware, function(err, a, manipulatedDocs, b) {
								debug.sockets('done.. send docs',list.list.key, err);
								// send data to listeners
								cb({
									path: getList.path, 
									data: manipulatedDocs || docs, 
									success: true
								});
							});
						} else {
							// fail
							debug.sockets('## FAIL ## in route call');
							cb({
								path: getList.path, 
								success: false, 
								error: err.message
							});
						}
					});
				}
			});
		}
425109
public function listCommand()
    {
        $this->outputLine('Currently registered routes:');
        /** @var Route $route */
        foreach ($this->router->getRoutes() as $index => $route) {
            $uriPattern = $route->getUriPattern();
            $this->outputLine(str_pad(($index + 1) . '. ' . $uriPattern, 80) . $route->getName());
        }
    }
1243307
def list(gandi, id, vhosts, dates, fqdns, limit):
    
    justify = 10
    options = {'items_per_page': limit, 'state': 'created'}

    output_keys = []

    if id:
        output_keys.append('id')

    output_keys.append('subject')

    if dates:
        output_keys.extend(['date_created', 'date_expire'])
        justify = 12

    if fqdns:
        output_keys.append('fqdns')

    if vhosts:
        output_keys.append('vhosts')

    result = gandi.hostedcert.list(options)

    for num, hcert in enumerate(result):
        if num:
            gandi.separator_line()

        if fqdns or vhosts:
            hcert = gandi.hostedcert.info(hcert['id'])

        output_hostedcert(gandi, hcert, output_keys, justify)

    return result
5331
def list_pages(location_id, opts = {})
      data, _status_code, _headers = list_pages_with_http_info(location_id, opts)
      return data
    end
1032892
protected function execList()
    {
        //check if parent primary key is into route
        if(!empty($this->ancestors)) {
            end($this->ancestors);
            $parentPrimaryKey = current($this->ancestors);
        } else {
            $parentPrimaryKey = [];
        }
        //get records
        $this->templateParameters['records'] = $this->get($parentPrimaryKey);
        // form translations
        $this->loadTranslations('list', sprintf('private/global/locales/%s/list.ini', LANGUAGE));
        //get table filter
        $this->templateParameters['table_filter'] = [];
        $this->templateParameters['table_filter']['field'] = $this->cookies->get(sprintf('table_filter_%s_field', $this->name));
        $this->templateParameters['table_filter']['input'] = $this->cookies->get(sprintf('table_filter_%s_input', $this->name));
        //render
        $this->renderTemplate();
    }
110432
function listRemote(store, attrs) {
      // TODO - Check connection and work on local data if disconnected
      // Replace previous list params from url
      var listObj = {};
      listObj[store.listParam] = JSON.stringify(attrs);
      store.url = vcomet.util.replaceParam(store.url, {
        list: JSON.stringify(attrs)
      });
      // Get request
      StoreRest.restXhr(store, store.url, "onListRemote");
    }