dotnet add package Constellation.Foundation.Data --version
NuGet\Install-Package Constellation.Foundation.Data -Version
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Constellation.Foundation.Data" Version="" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Constellation.Foundation.Data --version
#r "nuget: Constellation.Foundation.Data,"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Constellation.Foundation.Data as a Cake Addin
#addin nuget:?package=Constellation.Foundation.Data&version=

// Install Constellation.Foundation.Data as a Cake Tool
#tool nuget:?package=Constellation.Foundation.Data&version=

Requires Sitecore 10.3
Requires .NET 4.8

Constellation is a collection of utilities for .NET CMS implementers.
The Foundation.Data namespace contains an Item extension class that allows the developer to:
- Get an Item's ancestor based on Template
- Test an Item's Template inheritance
- Retrieve an Item's children based on a specific Template
- Retrieve the URL for the Item using the currently active LinkManager configuration.
- Determine if the Item is in the Context Site.
- Find or create an Item's child given a name and a Template ID.

Product Compatible and additional computed target framework versions.
.NET Framework net48 is compatible.  net481 was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (7)

Showing the top 5 NuGet packages that depend on Constellation.Foundation.Data:

Package Downloads

Requires Sitecore 10.3 Requires .NET 4.8 Constellation is a collection of utilities for .NET CMS implementers. The Foundation.ModelMapping library is inspired by AutoMapper and is designed to provide a quick, non-ORM method of mapping Sitecore Items to ViewModels. String properties on your ViewModel will be mapped to FieldRendered values from fields with the same names. Integer and DateTime property types can also be handled automatically, although you will not get page editor support for these types. There are a number of Attributes that you can assign to your ViewModel's properties to change the behavior of the Mapper. Usage: var modelMapper = (IModelMapper)ServiceLocator.ServiceProvider.GetService(typeof(IModelMapper)); // Dependency Injection of an IModelMapper is supported TModel viewModel = modelMapper.MapItemToNew<TModel>(sourceItem); Or: TModel viewmodel = item.MapToNew<TModel>(); Or: modelMapper.MapTo(item, model); When using Item or ItemList extensions for mapping, the context IModelMapper is requested from the ServiceLocator, so any moc objects you use for testing are supported with these extension methods. Constraints: - Your ViewModel must have a public, parameterless constructor. - Only Writable, Public Instance properties will be mapped. - Within Sitecore, your field names can be human-legible. ModelMapper will attempt to convert the field name to a valid Property name. Simpler names work best. You can use the Field's Display Name for better human legibility and keep the Field's actual name closer to a legit C# entity name. - ViewModel properties can be: - - Strings - - HtmlStrings (recommended for RichText and FieldRenderer) - - Integers - - Decimals - - DateTimes - - Other ViewModels (recommended for DropLink, DropTree) - - ICollection Generics of other ViewModels (recommended for Multilist, Treelist) - - ModelMapping.Model.ImageModel (for Image Fields, gives access to all field properties and permits generating different kinds of image URLs on the View.) - - ModelMapping.Model.GeneralLinkModel (for General Link fields, gives access to all field properties through a single object.) - - Random Plain Old Classes as long as they are Where T: class, new() The following Model properties are mapped to Item properties rather than Item fields: - ID - Maps to the Item.ID - Make sure you use Sitecore.Data.ID as the property type. - Name - Maps to the Item.Name - DisplayName - Maps to Item.DisplayName - Url - Should be a string, not a Uri. Causes the current context LinkManager to generate a Url for the Item. - Parent - Maps to the ViewModel you provide based on the Item.Parent. Support for XML Field Attributes - ImageField.Alt - use Model.FieldNameAlt - ImageField.Height - use Model.FieldNameHeight - GeneralLink.Target - use Model.FieldNameTarget - etc. Support for LinkField.TargetItem - use Model.FieldNameTargetItem and supply a class with public properties and a parameterless constructor. Support for MultilistField.GetItems - use Model.FieldName and supply a generic ICollection<T> where "T" is new() and has properties you can map. Extensible! See the Constellation.Foundation.ModelMapping.config file to change the way Fields are processed.


Requires Sitecore 10.3 Requires .NET 4.8 Constellation is a collection of utilities for .NET CMS implementers. The Foundation.Mvc assembly contains enhancements to Sitecore's MVC Rendering system: GenerateRenderingSpecificCacheKey Mvc.RenderRendering pipeline processor: Replaces the default GenerateCacheKey processor. Includes the ID of the Rendering in the cache key, this allows for multiple renderings with different presentation to use the same Datasource and be cached by Datasource without issues. MinifyAndAddRecordedHtmlToCache Mvc.RenderRendering pipeline processor: Replaces the default AddRecordedHtmlToCache processor. Uses the WebMarkupMin library to process the output HTML, Javascript, and CSS and minify it to improve page delivery time through file size reduction. The default settings are "safe" but effective, however WebMarkupMin offers far more aggressive minification settings for the bold. GetControllerRenderer Mvc.GetRenderer pipeline processor: Replaces the default GetControllerRenderer. Allows the developer to rely on the name of the Rendering to locate the appropriate controller to execute (convention over configuration). Very handy for Renderings that have a dedicated controller with one action that always produces the same output. ConventionController: Provides a good base-class controller for Sitecore implementations: * Forces the use of the Index() controller action (overrides possible) * Provides the programmer with immediate access to the Rendering's DataSource and ContextItem (PageContext) * Requires the programmer to assemble the model from the above Items. * Automatically finds the View based upon the Rendering's XPath location in Sitecore EditorCompatibleView: Replaces the stock MVC View, and provides methods for determining if the Page Mode "IsExperienceEditor" and "IsExperienceEditorEditing" which are of particular use if the View needs to change behavior to support editors. ViewPathResolver: Independent engine for locating a View based on the Rendering Item's path in Sitecore. It has configuration settings that allow the programmer to specify the location of Renderings in Sitecore and how they map to the location of the Views on disk. See the provided config file for details.


Requires Sitecore 10.3 Requires .NET 4.8 Constellation is a collection of utilities for .NET CMS implementers. The Foundation.Datasources library is an opinionated information architecture for Sitecore. It includes "base" templates and Item information rules to enforce the architecture. Core Architecture Concept: Web Site Items are one of the following types: Context Datasource: A "page" Item in Sitecore, has a URL, has presentation, loads a Layout and has placeholders for additional Renderings. Subcontent: A "page fragment" Item in Sitecore, specifically an Item designed to be used as the DataSource for a Rendering. It is required for the Rendering to render. Subcontent is optional page content, but is unique to the page it appears on. Widget: Also a "page fragment" Item in Sitecore, specifically an Item designed to be used as the DataSource for a Rendering. It is required for the Rendering to render. Widgets are optional page content, but are designed to be shared by multiple pages. The primary information architecture for this design involves the storage of SubContent vs Widgets. All Pages on a site should get a _subcontent folder beneath them which is where Items of type Subcontent should be stored. This allows for Renderings to specify their Datasource location as "./_subcontent" Widgets should be stored beneath the /tenant/site node (using Helix methodology) typically in a /widgets folder, possibly broken up by widget type or marketing intentions. You can use the following Rule Conditions to enforce this Information Architecture: * ItemIsContextDatasource * Item IsSubcontentDatasource * ItemIsWidgetDatasource * ItemSupportsSubcontent (in some cases Pages should not support subcontent, for example, wildcard pages or pages imported from an external system) You can use the following Rule Actions to enforce this Information Architecture: * CreateSubcontentFolder In general you need a rule like this: On Item Saved, if the Item Supports Subcontent, Create a Subcontent Folder (if none exists) An example is provided in the attached package. After setting up this rule, ensure that your Renderings are organized into Widgets and Subcontent with appropriate Datasources established. Installation: Add this NuGet package to a Web Application project. After building and deploying, this library will automatically install the Sitecore package containing the necessary rules and templates to support this architecture.


Requires Sitecore 10.3 Requires .NET Framework 4.8 Constellation is a collection of utilities for .NET CMS implementers. The Foundation.Mvc.Patterns library is an opinionated library that provides some base Controller and Repository classes for jumpstarting a Sitecore project. The purpose is to get developers to better separate data access logic from controllers and also to hide some uninteresting concerns. Repositories: Classes which accept a context to specify the conditions for accessing data in Sitecore along with facts for use in the query. The Repository is responsible for getting the results of a query, any caching, and any transformation into ViewModel output. Base Repositories: Repository - Just the basics of setting up the relationship between the repository and the controller. CachingRepository - Adds caching of the repository's output to the mix. SingleItemRepository - Includes both of above and is centered around queries that will retrieve a single Item. ItemListRepository - Includes the first two and is centered around queries taht will retrieve multiple Items. Controllers: Classes which are responsible for handling the transition from Sitecore to the View, including setting up a Repository Context, and getting the results from the Repository for sending to the View. Base Controllers: DatasourceRenderingController - Use when a Rendering has a Datasource Item and that Item is what's being rendered. ItemListController - Use when a Rendering will present a number of Items that have to be looked up in some fashion. On Sitecore startup, this package will scan all assemblies for IController and IRepository implementations and automatically add them to Dependency Injection. This feature can be disabled/changed via the config file for this package.


Requires Sitecore 10.3 Requires .NET Framework 4.8 Constellation is a collection of utilities for .NET CMS implementers. The Feature.ItemSorting library solves the frequently occurring problem of managing a collection of Items that users will not organize themselves, but which they expect to be organized. Examples include Events in an Event Calendar, Press Releases, and Employee Bios. Users want them sorted by date and dictionary order, but Sitecore offers little help beyond Subitems Sorting. Additionally, after a few dozen Items, users expect these entries to be grouped into folders. Enter this library! This library features two simple Rule Actions: - MoveToAlphabeticalFolder - MoveToDateFolder Included in /Installation-Packages/ is a Sitecore Package with the appropriate Rule definitions. The package should self-install after being deployed to your environment. Rule Actions: Move Item to Alphabetical Folder - Allows you to specify the template of the folder to use for creating the alphabetical folders. Move Item to Date Folder - Allows you to specify the template of the folder to use for creating the date folders. Requires you to specify the Field on the Item being processed that should be used for categorization. Requires you to specify the depth of the associated folder tree. Options are /Year/, /Year/Month/, /Year/Month/Day/ In all cases, the "root" of the classification folders is the first encountered Ancestor that is not of the specified folder type. Usage Details 1. Create your "list" page that will serve as the root of the classification. In our example we'll use "News" 2. For the Insert Options of your "list" page, include the ability to insert an Item of the type that requires classification. In our example, we'll use "Press Release" (Note that Press Release must have a date field to use for classification. In our example we'll use the custom field "Release Date". You can use "__Updated" or "__Created" too.) 3. Create a new Item Saved rule that specifies when an Item is of Template "Press Release" it should be moved to a Date Folder. Set the appropriate parameters. 4. Enjoy!

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated 5,831 6/16/2023 36,401 11/12/2021 28,636 3/4/2021 6,473 11/20/2020 24,557 8/4/2020 12,917 6/4/2020 43,741 4/11/2019 6,890 3/6/2019 13,751 12/6/2018 1,657 12/6/2018 731 12/6/2018 722 12/6/2018 13,206 10/20/2018 35,500 6/15/2018 3,312 5/25/2018 9,354 5/25/2018 10,125 2/12/2018 45,325 12/1/2017 7,061 11/24/2017 2,671 11/24/2017 13,997 5/18/2020

Updated Sitecore references minimum to Sitecore 10.3.