public async Task List()

in src/OrchardCore.Modules/OrchardCore.Contents/Controllers/AdminController.cs [84:223]
111 lines of code
16 McCabe index (conditional complexity)

        public async Task<IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters, string contentTypeId = "")
        {
            var siteSettings = await _siteService.GetSiteSettingsAsync();
            var pager = new Pager(pagerParameters, siteSettings.PageSize);

            // This is used by the AdminMenus so needs to be passed into the options.
            if (!string.IsNullOrEmpty(contentTypeId))
            {
                model.Options.SelectedContentType = contentTypeId;
            }

            // Populate the creatable types.
            if (!string.IsNullOrEmpty(model.Options.SelectedContentType))
            {
                var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedContentType);
                if (contentTypeDefinition == null)
                {
                    return NotFound();
                }

                // Allows non creatable types to be created by another admin page.
                if (model.Options.CanCreateSelectedContentType)
                {
                    model.Options.CreatableTypes = new List<SelectListItem>
                    {
                        new SelectListItem(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name)
                    };
                }
            }

            if (model.Options.CreatableTypes == null)
            {
                var contentTypes = _contentDefinitionManager
                    .ListTypeDefinitions()
                    .Where(ctd => ctd.GetSettings<ContentTypeSettings>().Creatable)
                    .OrderBy(ctd => ctd.DisplayName);

                var creatableList = new List<SelectListItem>();
                if (contentTypes.Any())
                {
                    foreach (var contentTypeDefinition in contentTypes)
                    {
                        creatableList.Add(new SelectListItem(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name));
                    }
                }

                model.Options.CreatableTypes = creatableList;
            }

            // We populate the remaining SelectLists.
            model.Options.ContentStatuses = new List<SelectListItem>()
            {
                new SelectListItem() { Text = S["Latest"], Value = nameof(ContentsStatus.Latest) },
                new SelectListItem() { Text = S["Owned by me"], Value = nameof(ContentsStatus.Owner) },
                new SelectListItem() { Text = S["Published"], Value = nameof(ContentsStatus.Published) },
                new SelectListItem() { Text = S["Unpublished"], Value = nameof(ContentsStatus.Draft) },
                new SelectListItem() { Text = S["All versions"], Value = nameof(ContentsStatus.AllVersions) }
            };

            model.Options.ContentSorts = new List<SelectListItem>()
            {
                new SelectListItem() { Text = S["Recently created"], Value = nameof(ContentsOrder.Created) },
                new SelectListItem() { Text = S["Recently modified"], Value = nameof(ContentsOrder.Modified) },
                new SelectListItem() { Text = S["Recently published"], Value = nameof(ContentsOrder.Published) },
                new SelectListItem() { Text = S["Title"], Value = nameof(ContentsOrder.Title) }
            };

            model.Options.ContentsBulkAction = new List<SelectListItem>()
            {
                new SelectListItem() { Text = S["Publish Now"], Value = nameof(ContentsBulkAction.PublishNow) },
                new SelectListItem() { Text = S["Unpublish"], Value = nameof(ContentsBulkAction.Unpublish) },
                new SelectListItem() { Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove) }
            };

            var listableTypes = new List<ContentTypeDefinition>();
            foreach (var ctd in _contentDefinitionManager.ListTypeDefinitions())
            {
                if (ctd.GetSettings<ContentTypeSettings>().Listable)
                {
                    var authorized = await _authorizationService.AuthorizeAsync(User, Permissions.EditContent, await _contentManager.NewAsync(ctd.Name));
                    if (authorized)
                    {
                        listableTypes.Add(ctd);
                    }
                }
            }

            var contentTypeOptions = listableTypes
                .Select(ctd => new KeyValuePair<string, string>(ctd.Name, ctd.DisplayName))
                .ToList().OrderBy(kvp => kvp.Value);

            model.Options.ContentTypeOptions = new List<SelectListItem>
            {
                new SelectListItem() { Text = S["All content types"], Value = "" }
            };
            foreach (var option in contentTypeOptions)
            {
                model.Options.ContentTypeOptions.Add(new SelectListItem() { Text = option.Value, Value = option.Key });
            }

            // With the model populated we filter the query, allowing the filters to alter the model.
            var query = await _contentsAdminListQueryService.QueryAsync(model.Options, _updateModelAccessor.ModelUpdater);

            var maxPagedCount = siteSettings.MaxPagedCount;
            if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
                pager.PageSize = maxPagedCount;

            // We prepare the pager
            var routeData = new RouteData();
            routeData.Values.Add("DisplayText", model.Options.DisplayText);

            var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
            var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();

            // We prepare the content items SummaryAdmin shape
            var contentItemSummaries = new List<dynamic>();
            foreach (var contentItem in pageOfContentItems)
            {
                contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "SummaryAdmin"));
            }

            // Populate options pager summary values.
            var startIndex = (pagerShape.Page - 1) * (pagerShape.PageSize) + 1;
            model.Options.StartIndex = startIndex;
            model.Options.EndIndex = startIndex + contentItemSummaries.Count - 1;
            model.Options.ContentItemsCount = contentItemSummaries.Count;
            model.Options.TotalItemCount = pagerShape.TotalItemCount;

            var header = await _contentOptionsDisplayManager.BuildEditorAsync(model.Options, _updateModelAccessor.ModelUpdater, false);

            var shapeViewModel = await _shapeFactory.CreateAsync<ListContentsViewModel>("ContentsAdminList", viewModel =>
            {
                viewModel.ContentItems = contentItemSummaries;
                viewModel.Pager = pagerShape;
                viewModel.Options = model.Options;
                viewModel.Header = header;
            });

            return View(shapeViewModel);
        }