Codebase analysis · CoreStory V3

Orchard Core

An open-source modular application framework and content management system written in C# on ASP.NET Core. It covers content types, workflows, media, users, roles and multi-tenancy. Maintained by the Orchard Core project.

Maintained by
the Orchard Core project
License
BSD-3-Clause
Commit analyzed
54e2d3f02f98730171fc61d468951a1ec63a5d1c
Rules extracted
2026-11-15
Extracted by CoreStory V3
45480
accepted rules, each with a cited source quote
33
capabilities
6778
features
01 · Rules

Business rules, traced to source lines.

These 12 rules are a sample of the 45,480 CoreStory V3 extracted from Orchard Core. Each one links to the exact lines on GitHub at commit 54e2d3f. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.

authorization
src/OrchardCore.Modules/OrchardCore.Contents/Endpoints/Api/CreateEndpoint.cs

Before creating a new content item, the caller must be authorized for the PublishContent permission on the newly created item; otherwise the response challenges or forbids using the Api authentication scheme.

  • CommonPermissions.PublishContent — required permission
  • OrchardCoreConstants.AuthenticationSchemes.Api — authentication scheme used for challenge/forbid
if (!await authorizationService.AuthorizeAsync(httpContext.User, CommonPermissions.PublishContent, contentItem)) { return httpContext.ChallengeOrForbid(OrchardCoreConstants.AuthenticationSchemes.Api); }

Also cited: L66

limit
src/OrchardCore.Modules/OrchardCore.DataPipelines/Steps/Destinations/SendByEmailStep.cs

The total size of all attached files in bytes must not exceed MaxAttachmentSizeMegabytes (clamped to at least 1) multiplied by 1,048,576 bytes per megabyte; if it does, a DataPipelineDestinationException is thrown stating the files weigh more than the allowed limit.

  • 1 megabyte — minimum multiplier applied to MaxAttachmentSizeMegabytes
  • 1048576 bytes — bytes per megabyte conversion factor
  • The files weigh {0} MB, more than the {1} MB the attachments of the email can weigh. Raise the limit, or zip the files. — error message format when attachment total exceeds limit
  • 0.## — numeric format string for actual size
var size = files.Sum(file => file.Length); var maxSize = Math.Max(1, settings.MaxAttachmentSizeMegabytes) * BytesPerMegabyte; if (size > maxSize) { throw new DataPipelineDestinationException( S["The files weigh {0} MB, more than the {1} MB the attachments of the email can weigh. Raise the limit, or zip the files.", ((double)size / BytesPerMegabyte).ToString("0.##", CultureInfo.InvariantCulture), settings.MaxAttachmentSizeMegabytes]); }

Also cited: L25

policy
src/OrchardCore.Modules/OrchardCore.Users/Controllers/EmailConfirmationController.cs

A distributed cache entry keyed by the ResendCooldownCacheKeyPrefix plus the user id blocks resend requests for an absolute expiration of one minute; when present, a warning is shown and the response redirects to ConfirmEmailSent with the returnUrl. The cache entry is started before sending the email so the cooldown also applies while sending or if sending fails.

  • 1 minute — resend cooldown duration
  • 1 — distributed cache value stored for the cooldown
if (await _distributedCache.GetAsync(cooldownKey, HttpContext.RequestAborted) != null) { await _notifier.WarningAsync(H["A confirmation email was sent recently. Please wait a minute before requesting another one."]); return RedirectToAction(nameof(ConfirmEmailSent), new { returnUrl }); } // Start the cooldown before sending, so that it also applies while the email is being sent or when sending fails. await _distributedCache.SetAsync(cooldownKey, [1], new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = s_resendCooldown, }, HttpContext.RequestAborted);

Also cited: L23–L25, L124

validation
src/OrchardCore.Modules/OrchardCore.DataPipelines/Drivers/ShareDownloadLinkStepDisplayDriver.cs

The ExpiresAfterDays value must be between 1 and ShareDownloadLinkStep.MaxDays inclusive; otherwise a model error is added stating that a link works between 1 and {0} days, where {0} is ShareDownloadLinkStep.MaxDays. Regardless of validity, settings.ExpiresAfterDays is assigned the submitted model value.

  • 1 — minimum permitted expiration in days
if (model.ExpiresAfterDays is < 1 or > ShareDownloadLinkStep.MaxDays) { context.Updater.ModelState.AddModelError(Prefix, nameof(model.ExpiresAfterDays), S["A link works between 1 and {0} days.", ShareDownloadLinkStep.MaxDays]); }

Also cited: L50

validation
src/OrchardCore.Modules/OrchardCore.Media/Endpoints/Api/UploadMediaEndpoint.cs

Each uploaded file is rejected with the localizer message "This file extension is not allowed: {0}" when the extension of the normalized and resolved file name is not allowed by mediaOptions.IsFileExtensionAllowed(extension, canUploadRestrictedMedia), or when the requestedExtensions list is non-empty and does not contain that extension.

  • This file extension is not allowed: {0} — localized error message format for a disallowed file extension
if (!mediaOptions.IsFileExtensionAllowed(extension, canUploadRestrictedMedia) || (requestedExtensions.Count > 0 && !requestedExtensions.Contains(extension))) { result.Add(new UploadFileResultDto { Name = file.FileName, Size = file.Length, Folder = path, Error = localizer["This file extension is not allowed: {0}", extension].ToString(), });

Also cited: L66–L68, L74

validation
src/OrchardCore.Modules/OrchardCore.Autoroute/Models/AutoroutePartExtensions.cs

An AutoroutePart's Path is invalid if it contains any character from AutoroutePart.InvalidCharactersForPath (searched ordinal/case-sensitive), a space character, or the consecutive sequence "//"; when invalid, validation returns an error listing the invalid characters in quotes and stating no spaces or consecutive slashes are allowed, associated with the Path field.

  • // — disallowed consecutive slash sequence in permalink
  • , — separator used when joining the invalid characters for the error message
  • "{c}" — format used to quote each invalid character in the error message
if (HasInvalidCharacters(autoroute.Path)) { var invalidCharactersForMessage = string.Join(", ", AutoroutePart.InvalidCharactersForPath.Select(c => $"\"{c}\"")); yield return new ValidationResult(S["Please do not use any of the following characters in your permalink: {0}. No spaces, or consecutive slashes, are allowed (please use dashes or underscores instead).", invalidCharactersForMessage], new[] { nameof(autoroute.Path) }); }

Also cited: L27–L46

authorization
src/OrchardCore.Modules/OrchardCore.Contents/Security/ContentTypeAuthorizationHandler.cs

The owner variation of a permission is used only when an owner variation exists for the requirement's permission (via CommonPermissions.OwnerPermissionsByName) and the user is the owner of the content item; ownership is established when the user's ClaimTypes.NameIdentifier claim value equals the content item's Owner.

if (OwnerVariationExists(requirement.Permission) && HasOwnership(context.User, contentItem)) { permission = ownerVariation; }

Also cited: L87–L92

authorization
src/OrchardCore.Modules/OrchardCore.Settings/Services/SuperUserHandler.cs

In the SuperUserHandler authorization handler, if the current user's NameIdentifier claim equals the site's SuperUser value using an ordinal, case-insensitive comparison, then all PermissionRequirement requirements in the authorization context are marked as succeeded. This check applies only when a non-null user exists and a non-null NameIdentifier claim value exists; if the user is null or the NameIdentifier claim value is null, the handler returns without succeeding any requirements.

if (string.Equals(userId, site.SuperUser, StringComparison.OrdinalIgnoreCase)) { SucceedAllRequirements(context); }

Also cited: L42–L46, L56–L62

access control
src/OrchardCore.Modules/OrchardCore.Setup/Controllers/SetupController.cs

When shell setting "Secret" is non-empty/non-whitespace, access requires a token that is non-empty and is verifies as valid; otherwise the request must not proceed.

  • Secret — shell setting name holding the configured secret
if (!string.IsNullOrWhiteSpace(_shellSettings["Secret"])) { if (string.IsNullOrEmpty(token) || !await IsTokenValid(token)) { _logger.LogWarning("An attempt to access '{TenantName}' without providing a secret was made", _shellSettings.Name); return false; } }

Also cited: L63–L66, L88–L91

policy
src/OrchardCore.Modules/OrchardCore.Media/Middleware/MediaImageProcessingMiddleware.cs

For secure media requests, the Cache-Control header is "no-store" when MaxSecureFilesBrowserCacheDays equals 0; otherwise it is "public, must-revalidate, max-age=<seconds>" with seconds equal to TimeSpan.FromDays(MaxSecureFilesBrowserCacheDays).TotalSeconds.

  • 0 — MaxSecureFilesBrowserCacheDays value that forces no-store
  • no-store — Cache-Control value when secure cache days is zero
  • public, must-revalidate, max-age= — Cache-Control prefix for non-zero secure cache days
var cacheControl = context.IsSecureMediaRequested() ? options.MaxSecureFilesBrowserCacheDays == 0 ? "no-store" : $"public, must-revalidate, max-age={TimeSpan.FromDays(options.MaxSecureFilesBrowserCacheDays).TotalSeconds}" : $"public, max-age={TimeSpan.FromDays(options.MaxBrowserCacheDays).TotalSeconds}";
validation
src/OrchardCore.Modules/OrchardCore.RateLimits/Drivers/ConcurrencyRateLimiterDisplayDriver.cs

When editing a rate limiter whose source is the concurrency rate limiter, the permit limit must be at least 1; if the submitted permit limit is less than 1, a model error 'Permit limit must be greater than zero.' is added for the PermitLimit field.

  • 1 — exclusive lower bound for permit limit
if (model.PermitLimit < 1) { context.Updater.ModelState.AddModelError(Prefix, nameof(model.PermitLimit), S["Permit limit must be greater than zero."]); }

Also cited: L48–L51

validation
src/OrchardCore.Modules/OrchardCore.ContentFields/Handlers/MultiTextFieldHandler.cs

A required MultiTextField must have at least one value: when the field's settings have Required enabled and the field's Values array length is 0, validation fails with the message "A value is required for {0}." using the content part field definition's display name, attached to the field.Values member.

  • 0 — Values array length that triggers failure
  • Required — settings property that must be enabled
if (settings.Required && field.Values.Length == 0) { context.Fail(S["A value is required for {0}.", context.ContentPartFieldDefinition.DisplayName()], nameof(field.Values)); }

Also cited: L20

02 · Capabilities

What the application does

33 capabilities identified, grouping 303 of the 6,588 distinct features extracted. Most extracted features are not grouped under a capability, so this list is a partial view of the application. These are descriptions, not the cited rules above.

Content Management

Authoring, modeling, versioning, publishing, and querying of structured content items.

  • Content Authoring: Capability for users to author and manage site content including websites, categories, tags, and admin features.
  • Content Composition and Management: Capability to add and compose content parts and fields into a content item.
  • Content Field Management: Administrators can add, edit, and remove fields on content parts and types.
  • Content Indexing: Builds and maintains the search/content index for content items so they can be queried.
  • Content Item Creation: Creates content items asynchronously using content type definitions resolved from the content definition manager.
  • Content Item Indexing: Indexes content items (parts and fields) into the content index by coordinating content definitions, part/field index handlers, and index building.
  • Content Item Versioning: Tracking published and latest versions of a content item over time.
  • Content Listing: Display a paginated, searchable index of content items in the admin interface.
  • Content Management: Enables defining and managing content types and content items within the application.
  • Content Part Management: Administrators can list, create, edit, and remove content parts through the admin interface.
  • Content Publishing: Enables a user to publish content items, with the available content types determining what can be published.
  • Content Publishing & Unpublishing: Publishing drafts to make content live and unpublishing content to remove it from the published state.
  • Content Publishing and Unpublishing: Handles publishing, unpublishing, and versioning of content items through part handlers.
  • Content Type Definition: Allows a user to define and author new content types (with named parts) used as data structures within the application.
  • Content Type Management: Defines and configures content types and their parts, including per-part settings and behaviors such as versioning, drafting, and security.

Authorization & Permissions

Defining, checking, and enforcing permissions, roles, and claims across the system.

  • Admin Permission Management: Grants and governs whether a user is allowed to access administrative capabilities.
  • Anti-Forgery Protection: Protect users against cross-site request forgery on incoming requests.
  • Authorization: Checks whether the current user is permitted to perform an action.
  • Claims Management: Add, remove, replace, and query user claims, and find users by claim.
  • Content Permission Management: Content permissions by owner and access roles can be inspected and applied to gate content operations.
  • Permission Authorization: Enables checking and enforcing that a caller holds a required permission before an operation proceeds.
  • Permission Discovery: Exposes the set of available permissions that callers can query and depend on for authorization decisions.
  • Permission Enumeration: Exposes the set of permissions granted or available so callers can inspect access rights.
  • Permission Listing: Exposes the set of default permissions (and their stereotypes) for consumption by clients and GraphQL queries.
  • Permission Management: Exposes the set of permissions available in the system for clients to query.
  • Permission-Based Authorization: Evaluate permission requirements against a user's role-based permission grants to allow or deny access.
  • Role Management: Create, read, update, and delete roles with names and normalized names through the role store and custom role service.
  • Role Permission Management: Users can create roles and assign permissions to them.
  • Role and Permission Management: Users create roles and assign permissions, including allowing editors to manage menu items without publishing rights.

Admin Console & Navigation

The administrative UI shell: dashboard, admin menu, navigation, breadcrumbs, quick navigation, and settings.

  • Admin Dashboard: Provides the administrative interface for the OrchardCore Admin module, including its default layout, actions layout, and admin URL prefix.
  • Admin Menu: Provides a list-based administrative menu that users can access to navigate admin capabilities.
  • Admin Menu Display: A user-facing admin menu is constructed and rendered for administrative users.
  • Admin Menu Management: Create, edit, list, delete, and toggle admin menu items through the OrchardCore admin UI.
  • Admin Menu Navigation: Administrators navigate the admin UI and the correct menu item stays highlighted for the current page while direct navigation clears previous selections.
  • Admin Page Access: Serves the administrative page for the host by executing a shell request through the admin controller.
  • Admin Quick Navigation: Provides an admin quick navigation index that resolves navigation entry identifiers and replaces its entries.
  • Admin Settings Management: Allows administrators to view and modify system-wide settings.
  • Admin Theme Management: Allows administrators to retrieve and change the active admin theme, including resolving its display name.
  • Admin User Management: Administrators can create, edit, delete, enable, disable, and unlock user accounts.
  • Breadcrumb Navigation: Shows breadcrumb context for the current editor location.
  • Quick Navigation: Users can display a quick navigation control for jumping between areas of the application.
  • Site Settings Management: Allows reading, loading, updating, and retrieving defaults for a site's settings.

External Identity Providers

Sign-in through third-party OAuth/OIDC providers such as Google, Facebook, Microsoft, GitHub, and Twitter.

  • Azure AD Authentication: Enables users to sign in via Azure Active Directory through OrchardCore's Microsoft authentication module.
  • External Login: Allows users to sign in via external identity providers through the external login flow.
  • External Login (OAuth Provider Sign-In): Allows users to sign in or register using an external identity provider such as a social or OAuth provider.
  • External Login Linking: Allows users to register and link an external identity provider account to their local account.
  • External Login Linking & Unlinking: Lets an authenticated user associate an external provider login with their existing account or remove it.
  • Facebook Login: Enables users to authenticate via Facebook using configured deployment/source settings processed asynchronously.
  • GitHub Authentication: Enables users to authenticate with GitHub using client credentials and a stored client secret.
  • GitHub Sign-In: Enables users to authenticate using their GitHub account as an external login provider.
  • Google Authentication: Users can sign in using their Google account, with the capability configured through Google authentication settings.
  • Microsoft Account Authentication: Enables users to sign in with their Microsoft account using Microsoft Authentication constants and stored secrets such as the AAD app secret.
  • Microsoft Authentication: Enables users to sign in with their Microsoft account, including localized authentication UI text.
  • OpenID Connect Authentication: Provides OpenID Connect-based sign-in, authorization code flow, and logout endpoints for clients.
  • Twitter Sign-In: Allows a user to authenticate through Twitter via the Twitter sign-in service.

Authentication, Identity & Accounts

User login, registration, password recovery, two-factor authentication, and account administration.

  • Admin Login: Allows an administrator to log into the site.
  • Change Email: Allows a user to update the email address associated with their account.
  • Change Password: Allows a user to update their account password by supplying their current password, a new password, and a confirmation.
  • Email Confirmation: Allows users to confirm their email address via a confirmation link and to request a re-sent confirmation email through the EmailConfirmationController.
  • Password Recovery: Users can request a password reset email and complete the reset by submitting a new password via emailed confirmation links.
  • Password Reset: Allows users to reset their account password.
  • Two Factor Authentication: Provides two-factor authentication with email and SMS authenticator options, configurable and rate-limited per user.
  • User Account Management: Stores and maintains user account records including identity, contact details, credentials, and account state.
  • User Login: Authenticates a user by submitting login form credentials.
  • User Logout: A signed-in user can sign out, confirm or deny the logout, and be redirected back to the shell.
  • User Management: Provides management and administration capabilities for user accounts in OrchardCore.
  • User Registration: Enables new users to register an account within the system.

Feature & Extension Management

Discovering, enabling, toggling, and managing application features, modules, and themes.

  • Application Feature Discovery: Discovers and aggregates application features from registered feature providers so the system can enumerate the capabilities available in a shell.
  • Bulk Feature Management: Apply bulk actions (enable, disable, or none) to one or more selected features at once.
  • Extension Loading: Loads application extensions asynchronously from the filesystem or sources so they become available to the running system.
  • Extension Management: List and retrieve extensions and asynchronously load extensions into the system.
  • Feature Dependency Resolution: Determine the dependencies a feature relies on and the dependent features that rely on it.
  • Feature Discovery: Enumerate and retrieve the set of available features exposed by the system.
  • Feature Discovery and Dependency Resolution: Enumerate available features, their dependencies, and dependent features so hosts can determine what can be enabled together.
  • Feature Enablement: Allows a recipe step to enable one or more named shell features on the site.
  • Feature Management: Administrators can enable or disable named system features via the admin API.
  • Feature Toggle Management: Enables administrators or systems to query, enable, and disable features.
  • Theme Management: Capability to configure and manage site themes through a setup recipe that declares themes, steps, and variables.
  • Theme Selection: Allows a user or site to choose among available themes and exposes the current admin and site theme selection.

Caching

In-memory, distributed, and fragment caching with tagging, expiration, and invalidation.

  • Cache Expiration: A capability to specify when cached content expires via absolute, sliding, or relative-duration settings.
  • Cache Invalidation: Clear cached entries and remove stale cached data to keep the cache fresh.
  • Cache Storage: Store values in the dynamic cache under a key, including string-typed values, with configurable options.
  • Cache Tagging: Attach and remove tags on cache entries for grouping and later invalidation by tag.
  • Distributed Caching: Provides a distributed cache store for sharing cached data across application instances.
  • Dynamic Cache: Provides caching of rendered content fragments so repeated dynamic content can be served from cache.
  • Multi-tier Document Caching: Serve documents from in-memory then distributed caches and populate caches on misses for fast repeated access.
  • Redis Cache Integration: Registers Redis as a distributed cache backend for the application when Redis is configured, enabling caching behavior observable by the system and its users.
  • Shape Caching: Caches built shape results keyed by an identifier to reuse across requests.
  • Shape Output Caching: Caching of rendered shape output controlled by cache id, fixed/sliding durations, cache tag, and cache context.
  • Tag-Based Cache Invalidation: Associates cache entries with tags and invalidates them by removing tags or handling tag-removed events, enabling selective cache eviction.

Configuration & Settings

Binding, storing, and administrating application settings, secrets, and options.

  • Configuration Binding: Binds configuration values from a configuration section (with legacy-section fallback) into strongly-typed options for application startup.
  • Configuration Loading: Loads configuration data from sources into a node structure, synchronously or asynchronously.
  • Configuration Section Access: Retrieve configuration sections by key, with fallback lookups and reload change tracking exposed to consumers.
  • Options Configuration Binding: Binds configuration into options, supporting both legacy section configuration and section-value precedence, with enable/disable checks.
  • Secret Encryption: Encrypts secret values so they can be stored securely.
  • Secret Encryption At Rest: Encrypts secret payloads using an encryption service gated on the presence of an encryption key.
  • Secret Management: Administrators can create, edit, delete, and browse secrets of various types (text, RSA key, X.509) through an admin interface.
  • Secret Retrieval: Retrieve a secret value by name from an Azure Key Vault-backed secret store.
  • Settings Management: Allows users to retrieve, load, update, and validate application settings through a cohesive set of operations.
  • Shell Configuration: Application startup loads and applies shell settings via a configurable section, allowing the host to shape the shell's behaviour.
  • Site Configuration: Exposes and resolves site-wide settings such as site name, home route, time zone, super user, page title format and salt through a cached settings container.

Content Display & Rendering

Shape-based rendering pipeline that displays content, parts, fields, zones, and templates to users.

  • Content Display: Renders or shows a content item to the requesting user.
  • Content Display Rendering: Renders a model for viewing via display drivers that build and produce display shapes.
  • Content Field Display: Renders/display content fields in the UI via field display drivers.
  • Content Part Display: Represents and displays content parts with their differentiating attributes.
  • Display Management: Orchestrates building and updating display and editor shapes for a model through the display manager and its drivers.
  • Liquid Template Rendering: Renders Liquid templates for display via the Liquid part display driver and template manager.
  • Shape Display: Surfaces shape display events and asynchronous display operations so consumers can observe rendered shapes.
  • Shape Placement: Calculates and applies a default/positional placement for shapes so they are located on the canvas.
  • Shape Rendering: Render and display content shapes to the user with an associated shape display component.
  • Shape Table Display: Renders shape tables to HTML for display, resolving each shape's bindings and descriptors into a rendered output while tracking display events and slow-shape diagnostics.
  • Zone Rendering: Renders named layout zones so that shapes can be placed and displayed within designated regions of a page.

Data Pipelines & ETL

Designing, executing, and monitoring data pipelines that read, transform, aggregate, and deliver data.

  • Data Aggregation: Compute aggregate values (average, count, distinct count, min, max, median, sum) over a data source.
  • Data Export: Enables exporting data and remote instances to a target destination.
  • Data Import: Enables importing data into the system.
  • Data Pipeline Authoring: Users create and edit data pipeline definitions through a designer editor.
  • Data Pipeline Execution: Enables users to build and run data pipelines within the OrchardCore data pipelines module.
  • Data Pipeline Management: Users can view, create, and configure data pipelines with their settings, descriptions, and source URLs.
  • Data Pipeline Preview: Users can preview the outcome of a data pipeline, seeing the generated files, exposed ports, and row-level sample data before or without a full run.
  • Data Pipeline Run Execution: Users can trigger a data pipeline run and have the workflow suspend until the run completes or fails, resuming with the run's outcome.
  • Data Pipeline Run Management: Enables users or systems to queue, cancel, query, and list data pipeline runs through an asynchronous run manager.
  • Data Pipeline Step Execution: Executes configured data pipeline steps asynchronously, with each step optionally carrying descriptive metadata like name, display name, description, and category.
  • Data Pipeline Step Settings Management: Reads and writes configurable settings for a pipeline step.

Deployment & Recipes

Provisioning sites and transferring configuration/content across environments via recipes and deployment plans.

  • Content Deployment: Deploys content items as part of a deployment plan or setup recipe.
  • Deployment Execution: Executes a deployment by moving sources to destinations according to a deployment definition and tagged actions.
  • Deployment Package Import: Imports a deployment package so its contents can be deployed to targets.
  • Deployment Plan Creation: Creation and assembly of deployment plans that group steps to be executed for a deployment.
  • Deployment Plan Management: Users can view, create, edit, and delete deployment plans through the admin controller.
  • Feature Deployment: Deploys OrchardCore feature configuration as part of a deployment plan, including an all-features source.
  • Recipe Execution: Allows building and running setup or content recipes to provision and configure the application.
  • Remote Deployment Export: Exports a deployment plan and pushes it to a configured remote Orchard Core instance via HTTP.
  • Setup Recipe Application: Apply a setup recipe to provision the site's initial content and configuration.
  • Site Setup: Initialises the site's configured settings by handling the setup event through the settings services using the site service.
  • Site Setup / Installation: Collects site configuration (site name, time zone, database provider, connection string, table prefix, schema) plus an initial admin account to install and configure the application.

Email, SMS & Notifications

Composing and delivering email, SMS, and user notifications through configurable providers.

  • Email Notifications: Delivering notifications to users via email.
  • Email Provider Configuration: Configuring the email delivery provider and its connection settings, including Azure Communication Services.
  • Email Sending: Allows a caller to dispatch an email message asynchronously through an email service abstraction.
  • Notification Management: Provides retrieval, listing, and mutation of user notifications, including marking them read or unread.
  • Notification Preferences: Users can configure their notification preferences.
  • Notification Sending: A capability to send notifications through a notifier abstraction, exposed via an asynchronous add/send operation.
  • SMS Message Sending: Sends outbound SMS messages through an Azure-based SMS provider implementation.
  • SMS Sending: Send an SMS message through a configured SMS provider.
  • SMTP Email Delivery: Configuration and delivery of outgoing email via an SMTP host with credentials and encryption options.
  • Send Email: Compose and send an email message with recipients, subject, and body, optionally as HTML and with attachments.
  • Send SMS Message: Allows a caller to send an SMS message through the SMS service.

Markdown & HTML Authoring

Editing, rendering, sanitizing, and indexing Markdown and HTML content.

  • HTML Body Creation and Update: Create and update HTML body content with migration and warning support.
  • HTML Body Part Display: Renders the stored HTML body part of a content item for viewing on the front end.
  • HTML Field Editing: Provides the editing surface for HTML content fields, including updating the stored value.
  • HTML Sanitization: Ability to sanitize HTML content and configure which HTML elements/attributes are permitted, exposed through sanitization and field settings view models.
  • Markdown Body Part Editing: Provides editing of the Markdown body part by building its editor shape and persisting edits.
  • Markdown Editing: A Markdown editor surface with syntax-highlighted editing, fullscreen and side-by-side modes, and RTL/LTR direction support.
  • Markdown Processing: Provides markdown parsing and formatting capabilities so users can author and render markdown content.
  • Markdown Rendering: Converts Markdown input into rendered, sanitized HTML for display via the Markdownify filter.
  • Markdown to HTML Rendering: Renders Markdown content into sanitized HTML for display to users.
  • Shortcode Processing: Applies shortcode expansion within Markdown content as part of display rendering.
  • Slug Generation: Produces URL-friendly slug strings from input text using a configurable separator, exposed via a slug service interface.

Search & Indexing

Building and querying search indexes across content using Lucene, Elasticsearch, and Azure AI Search.

  • Azure AI Search: Provides a search capability backed by Azure AI that queries an index and returns matching document results.
  • Content Indexing: Builds and maintains the search/content index for content items so they can be queried.
  • Content Item Indexing: Indexes content items (parts and fields) into the content index by coordinating content definitions, part/field index handlers, and index building.
  • Content Search: Enables searching over application content.
  • Elasticsearch Index Management: Enables listing and management of Elasticsearch indexes for the search subsystem.
  • Full-Text Search: Provides full-text search capabilities with configurable analyzers and query-string based search.
  • Index Profile Management: Provides access to stored index profiles so search configuration can be managed.
  • Lucene Index Management: Provides the capability to manage (create, update, delete) Lucene search indexes.
  • Search Analyzer Management: Managing the set of Lucene analyzers available for full-text search, including creating and listing configured analyzers.
  • Search Index Management: Enables users to manage search indexing through the indexing startup capability.
  • Search Query: Executes a search against the Elasticsearch index using a search request and returns matching results with paging, index, analyzer and template context.

User Interface Components

Reusable UI building blocks: modals, menus, tabs, toasts, drag-and-drop, pagination, and theming controls.

  • Card Display: Renders a card UI container with configurable background color styling.
  • Drag and Drop: Enables users to drag items asynchronously and handle drop interactions through a shared helper.
  • Drag and Drop Interaction: Initiates a drag interaction on the file list, giving the user a direct manipulation affordance.
  • Dropdown Menu: A menu component that opens on focus, closes on outside interaction, and emits selection events.
  • Loading Spinners: Displays animated border and grow spinners to indicate loading state.
  • Menu Display: The application can present a navigation menu to users, including options for new menu entries.
  • Modal Dialog: Provides a modal dialog container for presenting request-related content to the user.
  • Navbar Display: Renders a navigation bar with brand, link, hover, disabled, and toggler styling states.
  • Pagination: Enables paged display of content with configurable page sizes, page size options, and paging limits.
  • Tab Navigation: Enables users to switch between and select tabs, with labels and icons, using keyboard or pointer interaction.
  • Toast Notifications: Displays transient toast notifications to the user, with a script-driven action that can push messages into the toast list.

Workflows & Automation

Authoring, executing, and managing workflow definitions with activities, variables, and event triggers.

  • Activity Library Browsing: Enables discovery of available activities and their categories through the activity library, letting users list and look up activities by name.
  • Workflow Activity Editing: Users can add, edit, and focus activities on a workflow canvas via drag-and-drop and quick-add interactions.
  • Workflow Definition: Users can define and persist workflows, including their type and designer configuration, as JSON-backed models.
  • Workflow Designer: Interactive canvas for authoring workflows, with activities, ports, edges, and an activity editing form.
  • Workflow Event Triggering: Emits named workflow events through the workflow manager so that subscribed workflow definitions can react to user-related activity.
  • Workflow Execution: Starting, executing, and completing workflow runs, including input/output handling and event triggering.
  • Workflow Instance Management: Users list, filter, and bulk-act on workflow instances, and open their details, journal, declared variables, and parent/child links.
  • Workflow Publishing: Users can publish a workflow and resolve publish conflicts or issues surfaced in a dialog.
  • Workflow Run & Retry: Users can execute a workflow instance and retry failed runs, supplying inputs and observing outputs.
  • Workflow Type Management: Users can create, edit, clone, version, compare, delete, and bulk-edit workflow type definitions through the controller.
  • Workflow Variables: Define and display named workflow variables with configurable types, a display name, and an editor, including boolean variables.

Localization & Translation

Multi-culture content and UI localization, translation catalogs, pluralization, and culture selection.

  • Content Culture Localization: Resolve and apply the appropriate culture for content via Orchard content localization helpers.
  • Content Localization: Provides localization of content items based on the request's culture, including an async localization handler that participates in the content lifecycle.
  • Culture Management: Manage the set of supported cultures and designate a default culture for localization.
  • Culture Selection: Lets a user choose their preferred culture/language from a list of supported cultures, with the current culture indicated.
  • Data Localization: Provides localized data storage and retrieval support for site data.
  • Localization: Provides localized content by selecting from configured localization sources.
  • Localization String Extraction: Analyzes C# source code to extract localizable strings and their arguments from localization calls.
  • Pluralization: Resolve plural forms of localized strings according to a plural rule.
  • Portable Object Localization: Enables applications to add Portable Object (PO) file-based localization for translating user-facing strings.
  • Translation Management: Manage and process translation data, supporting both legacy and current format representations.

Media Management

Uploading, storing, browsing, processing, caching, and serving media assets.

  • Image Resizing and Scaling: Resizes images using max, min, stretch, and crop modes, optionally honoring focal points, so sources fit target dimensions.
  • Media Caching: Capability to control browser and remote cache durations and CDN base URL for media assets.
  • Media Directory Management: Provides browsing, creation, and deletion of media directories.
  • Media File Management: Users can add, select, reorder, and delete media files within a collection.
  • Media File Upload: Users can add new media files to the collection.
  • Media Image Processing: Serves an image-processing endpoint that processes incoming media image requests through a middleware pipeline.
  • Media Management: Provides the media feature with caching, indexing, TUS uploads, SignalR notifications, slugification, and secure access.
  • Media Picker: Users can open a picker modal and choose media items to include.
  • Media Profile Management: Allows administrators to create, edit, list, and delete media profiles through the admin controller actions.
  • Media Token Generation: Generates signed, cache-keyed access tokens for protected media URLs so links can be shared and later validated.

Security Headers & Hardening

Applying HTTP security response headers and hardening policies such as CSP, HTTPS, and HSTS.

  • CORS Configuration: Enables administration of cross-origin resource sharing (CORS) policy settings for the application.
  • Content Security Policy: Capability to enforce a content security policy for served media content.
  • Forwarded Headers Processing: Enables the application to correctly interpret client and proxy information from X-Forwarded-* headers when running behind a reverse proxy.
  • HTTP Strict Transport Security: Enables and configures the Strict-Transport-Security policy for clients.
  • HTTPS Enforcement: Configures and applies HTTPS requirements, permanent redirects, SSL ports, and HSTS to secure incoming requests.
  • Permissions Policy: Configures a Permissions Policy that enables or disables browser feature capabilities such as camera, microphone, geolocation, and other device or sensor access.
  • Referrer Policy Control: Allows selection of a referrer policy value that governs how much referrer information is sent with requests.
  • Security Header Injection: Adds security-related HTTP response headers to outgoing responses via middleware registered on the application pipeline and used by the application.
  • Security Headers: Applies default HTTP security response headers (content security policy, content type options, permissions policy, referrer policy) to outgoing responses.
  • Security Headers Configuration: Allows users to configure and apply HTTP security response headers such as content security policy, content type options, permissions policy, and referrer policy to outgoing responses.

URL Routing & Rewriting

Autoroute generation, URL rewriting/redirect rules, and resolving request paths to content.

  • Alias Management: Attach and edit aliases on content parts.
  • Automatic Path Generation: Derives route paths and container-relative content item paths so content is addressable via human-readable URLs.
  • Content Alias Management: Allows content items to be addressed by user-defined aliases maintained via an alias index that updates asynchronously on content changes.
  • Content Item Route Management: Tracks and stores routing entries that map content items to their URL paths, including contained content items within a document.
  • URL Generation: Produces encoded tenant-facing URLs for users or other systems to consume.
  • URL Rewrite Rule Management: Administrators can create, edit, and asynchronously update URL rewriting/redirect rules through the admin driver layer.
  • URL Rewrite Rules: Define and apply URL rewriting rules, including pattern matching and optional case-insensitive matching, to transform request URLs.
  • URL Rewriting: Applies configurable URL rewrite rules to transform incoming URLs into their mapped destinations.
  • URL Routing / Autoroute: Provides route alias management for content items so they can be reached via friendly URLs.
  • URL Routing and Matching: Resolves incoming request paths against registered autoroute entries to select the matching endpoint and route values.

Auditing & Logging

Recording audit trails, event history, and structured diagnostics for accountability.

  • Audit Trail Event Handling: Enables consumers to register handlers that react to audit trail events.
  • Audit Trail Listing: Displays a filtered, paged list of audit trail entries for administrators.
  • Audit Trail Management: Records, retrieves, and trims audit trail events through the audit trail manager.
  • Audit Trail Recording: Records audit trail events capturing user actions for accountability and history.
  • Audit Trail Settings Configuration: Administrators configure audit trail behavior, including which event categories are recorded and whether client IP addresses are captured, via an Orchard Core settings container.
  • Audit Trail Trimming Configuration: Administrators can configure automatic trimming of the audit trail, including enabling/disabling it, setting a retention period, and viewing the last run time.
  • Content Audit Trail Recording: Captures and records an audit trail of content events through an asynchronous creation handler and its associated service.
  • Diagnostic Logging: Records log entries for downstream observation and assertion.
  • User Audit Trail: Authorization-gated capability to view a user's audit trail events.

Background Tasks & Scheduling

Scheduling, executing, monitoring, and managing recurring background tasks.

  • Background Service Lifecycle: Starts, initializes and stops the background service, waiting for running tasks to complete and reloading configuration on change tokens.
  • Background Task Execution: A background service executes recurring work via an async do-work entry point, as demonstrated by a test background task.
  • Background Task Listing: Displays a paged, monitored list of background tasks with their state and options for the user to review.
  • Background Task Management: Enables users to run, monitor, and control background tasks including viewing task state, editing, enabling, disabling, and bulk actions.
  • Background Task Run Request: Allows a user or system to trigger on-demand execution of a background task.
  • Background Task Scheduling: Enables registration and lookup of named background tasks with default scheduling settings.
  • Background Task State Query: Allows a user or system to retrieve the current state of background tasks, individually or in bulk.
  • Scheduled Background Tasks: Declares and schedules recurring background tasks with configurable lock and pipeline behavior.
  • Scheduled Task Execution: A background scheduler evaluates whether tasks are due and triggers their runs according to their schedules and enabled state.

GraphQL API

Exposing application and content data through a queryable GraphQL endpoint.

  • Dynamic Content Type GraphQL Schema: Builds GraphQL object types at runtime for content types, including their dynamic part fields, so clients can query content via a generated schema.
  • GraphQL API: Exposes a GraphQL query endpoint for clients to consume application data.
  • GraphQL Content Field Querying: Query content items by content fields via GraphQL, including multiple, similar-named, and collapsed content fields with collision prevention.
  • GraphQL Content Item Querying: Exposes content items through a GraphQL API so clients can resolve and filter them by index, alias, or field input.
  • GraphQL Content Query: Enables clients to query content items through GraphQL, with pre- and post-query processing hooks over a content management query container.
  • GraphQL Content Querying: Enables querying of content items through the GraphQL API using search terms and value predicates.
  • GraphQL Permission Enforcement: The GraphQL API surface constrains access to resources according to permissions by resolving permission contexts for queries and mutations.
  • GraphQL Query Execution: Executes a query step against the query manager and returns results using configured JSON serialization options.
  • GraphQL Schema Retrieval: Provides clients with the generated GraphQL schema for the application on request.

Liquid & Shape Templating

Rendering Liquid templates and shape templates with tags, filters, and layout zones.

  • Liquid Shape Display: Renders named shapes and their display types from Liquid templates, supporting synchronous and asynchronous rendering.
  • Liquid Tag Helper Rendering: Author-facing Liquid tags are rendered asynchronously into display output, including argument-block and argument-tag variants.
  • Liquid Template Rendering: Renders Liquid templates for display via the Liquid part display driver and template manager.
  • Liquid Template Shape Display: Provides Liquid template filtering that creates display shapes, enabling template authors to render dynamic shape output.
  • Liquid Templating: Provides Liquid template rendering capabilities to the application via startup and configuration.
  • Liquid View Templating: Enables Razor views to be authored in the Liquid template language and discovered/rendered by the display management system.
  • Liquid Zone Rendering Tag: A Liquid template tag that renders a named layout zone at a configurable position, letting themes and templates control where zones are emitted.
  • Shape Template Harvesting: Discovers and registers shape templates from views by parsing template file paths into harvestable shapes.
  • Shape Template Rendering: Renders display shapes by resolving them against shape templates and producing rendered output for display.

Scripting & Expressions

Evaluating JavaScript and Liquid expressions, managing scripting engines, and expression functions.

  • Expression Evaluation: Builds and evaluates arithmetic and unary expressions over parsed date/time values, producing resolved results relative to the clock and culture.
  • Expression Function Catalog: Provides a catalog of built-in expression functions that users can discover and invoke when authoring expressions.
  • Expression Parsing: Parses input text into an abstract syntax tree of expression nodes representing binary, unary, literal, field, and function operations.
  • Formula Evaluation: Evaluating a compiled formula to produce a result value across arithmetic, comparison, text/logic and date expressions, returning null instead of failing on invalid or missing input.
  • JavaScript Engine Pooling: Reuse and lifecycle management of pooled JavaScript interpreters, allowing callers to rent an engine, return it, create new interpreters, and have idle ones expired and swept automatically.
  • JavaScript Script Evaluation: Execute synchronous and asynchronous JavaScript scripts against a pooled engine with per-evaluation globals and lexical isolation.
  • Liquid Expression Evaluation: Provides evaluation of Liquid template expressions for workflows, with validation of the expression and asynchronous evaluation.
  • Script Evaluation: Evaluates user-provided script expressions within workflow contexts via a script evaluator component.
  • Scripting Engine: A capability that exposes a set of general-purpose scripting methods (including base64, gzip, and html helpers) discoverable by consumers through a common method container.

Spatial & Mapping

Rendering interactive maps with markers, layers, and geographic point fields.

  • GeoJSON Rendering: Render GeoJSON feature collections as map layers.
  • GeoPoint Field Display: Renders a stored geographic point value for the user through a dedicated field display driver.
  • GeoPoint Field Editing: Lets the user modify a geographic point value and persist the change asynchronously.
  • Layer Group Management: Group, add, and remove layers and feature groups on the map.
  • Layer Management: Provides the capability for users to manage and administer layers within the OrchardCore application.
  • Map Display: Renders interactive maps in the UI using the Leaflet library.
  • Marker Display: Place and render point markers on the map, including custom icons.
  • Spatial Field Indexing: Enables geographic point fields to be indexed for spatial search by building index values for GeoPoint content fields.
  • Spatial Leaflet Map Rendering: Renders a Leaflet spatial map component with its map JavaScript and associated image assets.

Testing & Continuous Integration

Unit, functional, browser-based, and integration test harnesses plus CI build pipelines.

  • Browser-Based Functional Testing: Runs end-to-end browser functional tests by caching and installing Playwright browsers with tracing support.
  • CI Build and Test: Continuous integration pipeline that builds the project and runs unit and functional test suites.
  • Continuous Integration Pipeline: Automated pull-request CI pipeline that builds the project and runs unit, functional (CMS and MVC), and localization extraction tests.
  • Frontend Unit Test Execution: Runs vitest unit test suites for multiple frontend packages as part of CI.
  • Functional Test Execution: Capability to run end-to-end functional tests, including bulk selection list scenarios.
  • Playwright Browser Caching: Caches and installs Playwright browsers to support browser-based test execution.
  • Playwright Browser Provisioning: Installs and caches Playwright browser binaries in CI for functional tests.
  • Test Execution: Runs the project's test suites against database backends to validate behavior.
  • Test Fixture Lifecycle: Initialize, configure, and dispose the Orchard test fixture including its SQLite connection pools and browser resources.

Theming & Static Resources

Managing themes and registering, versioning, and rendering scripts, styles, and other page resources.

  • Asset Bundling: Build or bundle client assets via the asset bundler tool.
  • CDN Delivery: Serves resources from a configurable CDN base URL to reduce origin load and improve client delivery.
  • Resource Management: Serves and configures front-end script/style resources with base path and environment awareness.
  • Resource Rendering: Renders registered scripts, styles, links and metas into the appropriate HTML markup for the page.
  • Resource Versioning: Appends cache-busting version identifiers to resource URLs so clients fetch updated assets.
  • Script Registration: Allows callers to register head and foot scripts so they can be rendered into the page.
  • Stylesheet Tag Registration and Rendering: Registers named and anonymous style tags with sources, dependencies, and placement, then renders them into the page output.
  • Theme Configuration: Allows themes to be configured and registered as available site themes.
  • Theme Detection: Determines whether a given theme is active or recognized, enabling callers to branch on the current theme.

Alerts & In-App Notifications

In-app notification inbox, alerts, and reminder surfacing within the UI.

  • Alert Messaging: Displays contextual user messages in multiple semantic styles, each with an accompanying action link.
  • Notification Display: Renders notifications for users by evaluating visibility and resolving notification display options within an HTTP request context.
  • Notification Filtering: Capability for users to filter and page through their notifications using criteria such as read state, reference, and paging limits.
  • Notification Message Display: Renders user-facing notification/alert messages through shapes and a notifier, with HTML encoding and layout integration.
  • Notification Read Status: Allows a user to check and toggle whether a notification is read or unread.
  • Notification User Selection: Presents a list of user names so an operator can choose which users to notify.
  • Notification Visibility Filtering: Filters batches of notifications by evaluating registered handlers to decide which notifications a user is permitted to see.
  • Notifications Inbox: Display and manage a user's notifications with count and listing options.

Concurrency & Distributed Locking

Coordinating exclusive access across processes via local and distributed locks.

  • Distributed File Locking: Coordinates exclusive access to media files across a distributed system by acquiring, holding, and releasing locks keyed by file identity.
  • Distributed Lock Acquisition: Acquire, try-acquire, and check the status of a named distributed lock scoped to a key.
  • Distributed Locking: Acquire, query, and release distributed locks backed by Redis so callers can coordinate exclusive access to a shared resource.
  • Exclusive Workflow Locking: Acquire distributed locks that serialize access to a workflow, a workflow type, or arbitrary workflow resources so concurrent operations cannot overlap.
  • Lock Acquisition: Acquire a named lock, optionally with timeout or exclusivity, and inspect whether it is currently held.
  • Lock Lifecycle Management: Gracefully dispose lock instances and their underlying resources via synchronous and asynchronous disposal.
  • Lock Release: Release an acquired lock so other holders can proceed, with support for releasing via disposal.
  • Named Lock Acquisition: Acquire a named lock or acquire a lock with a timeout so callers can serialize access to a shared resource.

Multi-Tenancy

Creating, configuring, isolating, and managing multiple tenant shells within one installation.

  • Multi-Tenant Management: Configure and host multiple tenants within a single OrchardCore installation, including request URL routing and table prefixing.
  • Shell Settings Management: Enables retrieval, updating, and removal of shell settings along with loading all available settings.
  • Tenant Creation: Allows a user to create or register a new tenant via an API by supplying tenant configuration details.
  • Tenant Database Configuration: Tenants' database configuration can be applied from presets and configured patterns, with the resulting connection string displayed.
  • Tenant Lifecycle Management: Create, edit, enable, disable, set up, and remove tenants with their configuration.
  • Tenant Management: Administrators can create, edit, enable, disable, and remove tenants through the tenant API controller.
  • Tenant Scope Management: Creation and management of tenant scopes, allowing each tenant to run with isolated shell settings and host context.
  • Tenant Setup: Configures a tenant's database, site, admin account, and hosting parameters through a validated setup options model.

OpenID/OAuth Server

Configuring and operating OpenID Connect authorization-server applications, scopes, tokens, and flows.

  • OAuth Token Issuance: A client exchanges authorization codes, refresh tokens, credentials, or passwords for access tokens.
  • OpenID Application Management: Administrators can create, edit, list, and delete OpenID applications through the admin controller.
  • OpenID Authorization Management: Represents and tracks an OpenID authorization record with its subject, scopes, status, and collection membership.
  • OpenID Connect Server Configuration: Allows operators to configure an OpenID Connect / OAuth 2.0 authorization server's endpoints, flows, token formats, and signing/encryption certificates.
  • OpenID Scope Management: Look up and retrieve an OpenID scope's identity by its physical ID through the scope manager service.
  • OpenID Server Configuration: Provides and exposes the configuration settings for the OpenID server, including applying server settings and reading them asynchronously.
  • OpenID Token Management: Manages OpenID tokens, including retrieving and finding tokens by physical identifier.
  • OpenID Token Storage: A persistence store for OpenID tokens supporting creation, retrieval, update, deletion, counting, listing, and pruning.

Secrets & Key Vaults

Managing, migrating, encrypting, and storing secrets including external vaults and certificates.

  • Azure Key Vault Secret Storage: Enables applications to store and retrieve secrets from Azure Key Vault through OrchardCore's secrets abstraction.
  • Certificate Management: Lifecycle management of server certificates including generation, retrieval, persistence, listing, and pruning.
  • Secret Creation: Lets users create new secrets with a name, type, description, and expiration.
  • Secret Encryption and Decryption: Provides a capability to encrypt and decrypt secrets through the secret encryption service.
  • Secret Listing: Enumerating metadata about all stored secrets.
  • Secret Migration: Migrates configuration secrets to a secure storage provider.
  • Secret Storage: Create or update named secrets in the Azure Key Vault store.
  • Secret Store Enumeration: List all stores configured in the secret manager.
03 · Size

What was analyzed

  • C# · 6,547 files · 341,245 lines
  • JavaScript · 943 files · 253,235 lines
  • CSS · 229 files · 158,485 lines
  • Markdown · 321 files · 43,677 lines
  • TypeScript · 498 files · 39,571 lines
  • Razor · 1,795 files · 39,388 lines
  • JSON · 335 files · 33,479 lines
  • SVG · 52 files · 23,764 lines
  • Vuejs Component · 77 files · 11,953 lines
  • SCSS · 150 files · 8,975 lines
  • MSBuild script · 263 files · 5,990 lines
  • Other (16 languages) · 198 files · 14,642 lines

Whole repository: 12,658 files. cloc 2.06 counts 974,404 lines of code in 11,408 of them (1,244,615 lines with comments and blanks).

04 · Source

Where this came from

Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit 54e2d3f on 2026-11-15. Capability descriptions are from the same run.

Code excerpts are from the upstream repository and remain under its BSD-3-Clause license. CoreStory is not affiliated with or endorsed by the Orchard Core project.

Want this for your own codebase?

Talk to us about mapping the business rules in your repositories.

Talk to an expert