Orchardcore Lists

Orchard Core Lists - Prompt Templates

Working with ListPart

You are an Orchard Core expert. Generate code and configuration for list-based content types using ListPart in Orchard Core.

Guidelines

• ListPart is provided by the OrchardCore.Lists module and associates child content items with a parent container.
• A classic example is a Blog (parent) containing BlogPost items (children).
• ListPart stores child items as separate content items linked via ContainedPart, unlike BagPart which embeds items inline.
• Configure ContainedContentTypes in ListPartSettings to restrict which content types can be added to the list.
• Enable ordering via EnableOrdering in ListPartSettings for drag-and-drop reordering.
• Set PageSize in ListPartSettings to control pagination.
• Use the list_items and list_count Liquid filters to load list items in templates.
• Every contained item has a ContainedPart with ListContentItemId and Order properties for indexing.
• Always wrap recipe JSON in { "steps": [...] }.
• All C# classes must use the sealed modifier except View Models.
• Use file-scoped namespaces in C# examples.

Enabling List Features

{
  "steps": [
    {
      "name": "Feature",
      "enable": [
        "OrchardCore.Lists"
      ],
      "disable": []
    }
  ]
}

Creating a Blog with ListPart

public sealed class Migrations : DataMigration
{
    private readonly IContentDefinitionManager _contentDefinitionManager;

    public Migrations(IContentDefinitionManager contentDefinitionManager)
    {
        _contentDefinitionManager = contentDefinitionManager;
    }

    public async Task<int> CreateAsync()
    {
        await _contentDefinitionManager.AlterTypeDefinitionAsync("Blog", type => type
            .Creatable()
            .Listable()
            .WithPart("TitlePart", part => part.WithPosition("0"))
            .WithPart("AutoroutePart", part => part
                .WithPosition("1")
                .WithSettings(new AutoroutePartSettings
                {
                    Pattern = "{{ Model.ContentItem | display_text | slugify }}",
                    AllowRouteContainedItems = true,
                })
            )
            .WithPart("ListPart", part => part
                .WithPosition("2")
                .WithSettings(new ListPartSettings
                {
                    PageSize = 10,
                    EnableOrdering = true,
                    ContainedContentTypes = ["BlogPost"],
                })
            )
        );

        await _contentDefinitionManager.AlterTypeDefinitionAsync("BlogPost", type => type
            .Draftable()
            .Versionable()
            .WithPart("TitlePart", part => part.WithPosition("0"))
            .WithPart("AutoroutePart", part => part
                .WithPosition("1")
                .WithSettings(new AutoroutePartSettings
                {
                    Pattern = "{{ Model.ContentItem | container | display_text | slugify }}/{{ Model.ContentItem | display_text | slugify }}",
                })
            )
            .WithPart("HtmlBodyPart", part => part
                .WithPosition("2")
                .WithEditor("Trumbowyg")
            )
        );

        return 1;
    }
}

ListPartViewModel Properties

ListPartSettings Properties

Liquid Tags for Lists

list_items - Load Published List Items

The list_items filter loads published content items for a given content item or content item ID:

{% assign blogPosts = Model.ContentItem | list_items %}
{% for post in blogPosts %}
    {{ post | shape_build_display: "Summary" | shape_render }}
{% endfor %}

Load by content item ID:

{% assign blogPosts = "4j42fxryjcpqkkacmg6cwz3pr5" | list_items %}
{% for post in blogPosts %}
    <h2>{{ post.DisplayText }}</h2>
{% endfor %}

list_count - Count Published List Items

{% assign count = Model.ContentItem | list_count %}
<p>Total posts: {{ count }}</p>

Templating a ListPart with Liquid

Override the list rendering for a specific content type by creating a template named Blog-ListPart.liquid:

{% for item in Model.ContentItems %}
    {{ item | shape_build_display: "Summary" | shape_render }}
{% endfor %}

{% assign previousText = "Newer Posts" | t %}
{% assign nextText = "Older Posts" | t %}
{% assign previousClass = "previous" %}
{% assign nextClass = "next" %}

{% shape_pager Model.Pager previous_text: previousText, next_text: nextText,
    previous_class: previousClass, next_class: nextClass %}

{{ Model.Pager | shape_render }}

Templating a ListPart with Razor

Create a file named Blog-ListPart.cshtml:

@model OrchardCore.Lists.ViewModels.ListPartViewModel

@foreach (var item in Model.ContentItems)
{
    var shape = await ContentItemDisplayManager.BuildDisplayAsync(item, Model.Context.Updater, "Summary");
    @await DisplayAsync(shape)
}

@await DisplayAsync(Model.Pager)

Shape Alternates for ListPart

Razor Helpers

The OrchardCore.Lists module provides helpers for querying list items programmatically:

ContainedPart Indexing

Every content item contained in a list has a ContainedPart with indexable properties:

Recipe: Creating a Blog with Posts

{
  "steps": [
    {
      "name": "Content",
      "data": [
        {
          "ContentItemId": "4j42fxryjcpqkkacmg6cwz3pr5",
          "ContentType": "Blog",
          "DisplayText": "My Blog",
          "Latest": true,
          "Published": true,
          "TitlePart": {
            "Title": "My Blog"
          },
          "AutoroutePart": {
            "Path": "blog"
          }
        },
        {
          "ContentItemId": "[js:uuid()]",
          "ContentType": "BlogPost",
          "DisplayText": "First Post",
          "Latest": true,
          "Published": true,
          "TitlePart": {
            "Title": "First Post"
          },
          "HtmlBodyPart": {
            "Html": "<p>Welcome to my first blog post!</p>"
          },
          "ContainedPart": {
            "ListContentItemId": "4j42fxryjcpqkkacmg6cwz3pr5",
            "Order": 0
          }
        }
      ]
    }
  ]
}