Releases: Orckestra/C1-CMS-Foundation
C1 CMS 6.4
C1 CMS 6.4 (6.4.6639.31891)
Download
What’s new in C1 CMS 6.4?
This is a minor release, that provides some bug fixes.
.NET Framework version 4.7.1 is now required.
Composite.dll meta data now includes hash/branch information for easier support.
Bug fixes
#547 Empty placeholder content is shown after for a newly added page version
#539 An exception when adding pages when HttpContext is not available
#543 Scheduled [un]publishing doesn't work with debug builds of Composite.dll
#544 Published C1 pages with unpublished ancestor pages should not show up in search results
Fixing package installer failing to locale zip entries in sub folders in some of the packages
CAPTCHA code no longer uses Environment.ManchineName as a part of the encryption key, as that prevents it from being used in load balancing scenarios.
C1 CMS 6.3
C1 CMS 6.3 (6.3.6599.29375)
This release contains bug fixes and performance improvements as well as introduces a few extension points such as IPageContentFilter that enables developers to implement post processing for C1 pages.
With this new version it is also possible to use the new premium package - Orckestra.Media.CdnPublisher that enables configuring a C1 CMS website to serve static and media files via a reverse proxy cache service, like Azure CDN.
Download
What’s new in C1 CMS 6.3?
Dev Features
IPageContentFilter is an interface that allows post processing of C1 pages - modifying the HTML of the final page. It can be used, for example, to replace or augment certain URLs, replace img tags with the new HTML 5 picture tags, update certain words in the content etc.
Documentation link pending
Orckestra.Media.CdnPublisher package
The Orckestra.Media.CdnPublisher add-on allows integration with Azure CDN, or any other reverse proxy caching server. Using a CDN both allows the deployments to handle a much higher load, reduce hosting costs and possibly improve performance.
Console
The DLL version information is now visible in the C1 Console when browsing files in the System perspective.
Bug fixes
#504 [Chrome] Input fields loosing focus if login/password information is preserved in browser
#506 [Chrome] Function call editor - text is not visible in the second column input fields.
#490 Transparency artifacts in Chrome
#535 Custom 404 page resolution does not take language specified in URL into account
#507 Console doesn't work if ~/bin/Composite.Generated.dll is missing
Inline search in dropdown selectors is not enabled for Edge and is aligned properly.
Compatibility fixes related to EntityToken deserialization.
Fixing user permissions upgrade failing when there are permissions connected to no longer existing users/user groups.
Fixing an exception in PageObjectCacheFunction that was preventing caching an XML fragment
Fixing exceptions in the code handling the externally added workflows
Fixing "Undo Changes" action not working for page folder data types
Performance fixes/improvements:
XmlDataProvider - removing excessive locking that was limiting website performance.
PageObjectCache - blocking execution only when the same element to be cached is rendered.
Increasing the default max size for the "Page placeholders" cache.
Media handler - fixed performance issues that were occurring under heavy load.
C1 CMS 6.2
C1 CMS 6.2 (6.2.6436.18972)
This release brings about new features in the CMS Console and Content Search areas and overall performance and memory optimizations, giving an all around speed improvement and critical performance improvements for sites with a vey large amount of pages.
Also, a previously commercial feature - the ability to manage multiple sub-sites with unique host names - is now part of the open source project.
Download
What’s new in C1 CMS 6.2?
Host name management / multi-site support
The previously commercial feature that allowed admins to manage multiple host names / sub-sites is now part of the open source project. This allow you to associate host names with specific localized sub sites, manage 404 pages per host name and more.
Also - not previously available - “Always use HTTPS” support added for host name settings, enabling you to auto redirect all http requests to https.
See https://docs.c1.orckestra.com/Configuration/UrlConfiguration for more.
Console
The CMS Console browser show PDF, HTML and text file previews when browsing the Media perspective. Code files (.config, .css, .cshtml, .aspx etc.) are shown in the browser as well, when browsing website file structures (Layout and System perspectives).
Resource File (.resx) editor added to the CMS Console, enabling editing and translating .resx files.
The perspective buttons (left side, Content, Media etc.) now offer a context menu on right click, allowing you to set permissions for the perspective. Other commands attached do perspective elements will also show up. Also, clicking the icon for an already active perspective, will focus the perspective’s main browser.
Dev features
The build in page performance profiler improved - performance trace show a more detailed breakdown and allow you to order by memory usage.
New CMS Console widget available, Hierarchical Tree Selector, allowing users to select X items from a tree structure.
ee8721e
Tree Definition files now support formatting dates, ints and decimals in labels.
#442
Content Search
Search now support facetted search on reference fields on data types. Improved quality of keyword highlighting for text excerpts in search results.
Performance optimizations and fixes
Performance optimization for XML based sites – DateTime, Guid, bool and decimal values were always parsed from underlying string value, now the parsed value is cached.
Performance optimizations across the board for Console security resolving. For sites with larger more complex content trees, this can yield a visible performance improvement.
Memory handling fixes, removing unneeded object finalizers and ensuring IDisposable are disposed of in an orderly fashion. Memory optimizations.
Fixes around our use of the Roslyn Compiler – fixing issues where App_Resources were not compiled for non-default language, some Web Form code on websites would not compile and XSLT inline C# compilation failed.
Critical fix: Chrome v60 update broke setup wizard, preventing CMS install using this browser.
Several other UI improvements, optimizations and bug fixes.
The method for serializing “entity token” and “data source id” changes from escaped string custom format to JSON. This make reading such tokens a lot easier.
C1 CMS 6.1
C1 CMS 6.1 (6.1.6325.31805)
This is a minor release, primarily stabilizing the 6.0 release and bringing the Search features introduced as beta in 6.0 to release level in terms of stability, performance and features.
Download
What’s new in C1 CMS 6.1?
This release allows developers to use C# 7.0 features, the build-in content search has been expanded to the point, where front-end facing search can be serviced and customized to meet a wide range of needs. The release also contains several fixes and performance improvements.
Latest Roslyn compiler in use
Developers can now use C# 7.0 features in Razor Functions, MVC view code files, WebForm files etc.
Search improvements
Stemming, search results highlighting, indexing output of the cms functions.
Support for indexing content of media files (e.g. PDF and DOCX) with the Orcksetra.Search.MediaContentIndexing package.
API support for filtering search results to specific websites/media folders.
API support for implementing and filtering by custom fields (e.g. by extranet permissions).
Localizable user friendly names for MIME types when searching for media in the console.
Greatly reduced index building time.
Other
Media files now have a Tags field enabling users to add tags (keywords) to media files.
New service IMailer for sending mails (enable replacing the default mailer SmtpClient with other implementation).
Performance fixes
- deleting multiple CMS Pages at the same time
- using the Orckestra.VersioningVersionPublication package
- improved caching of data from SqlDataProvider
Breaking changes:
Security change – the “visible perspectives” settings for users/groups are now included in the calculation of inherited access. Previously having access to a perspective did not influence the inheritance of rights, meaning that any global access would flow down to all perspectives and elements, unless explicitly removed at a lower level. Now access will not be inherited onto perspectives the users cannot access.
A typical scenario where this become visible will be non-admin users unable to insert CMS Functions *getting an empty tree to choose from( – this can be solved by setting explicit read permissions on the “All Functions” element or by allowing read permissions to be inherited past hidden perspectives, see below.
You can control this behavior using the attribute inheritGlobalReadPermissionOnHiddenPerspectives in ~/App_Data/Composite/Composite.config. Setting this attribute to true will allow users with global read access to read structures like the CMS Functions tree, even though they have now been granted access to the Function perspective.
Notable bug fixes:
#435 Latest Firefox and Chrome will break the Function Call editor in the Visual Editor
#403 MVC links are not resolved correctly
#404 Page type restrictions are not resolved properly
#422 Checkbox will reset to initial state when other form widgets on same form does postback
#426 Components window is empty when site is running in subfolder
#417 [FireFox][Search,Components] WebSocket connection is not reopened automatically if website restarts
Fixes in relation to SQL support of Orckestra.Versioning.VersionPublication
C1 CMS 6.0
C1 CMS 6.0 (6.0.6248.33161)
We are super excited to announce this release – delivering major improvements for end-users, website builders and developers - built in search, a new visual components feature, more ways to customize the console and valuable tooling like WAMP, React/Redux and built in DI support.
Also, we are getting back to our open source roots, putting C1 back into the project name. We here at Orckestra are still driving the development and provide services, premium features and commerce integration on top.
Download
What’s new in C1 CMS 6.0?
With this release end-users can search for content and media files from within the console and there is now a much better experience when inserting functions, thanks to a new feature we call Components.
Website builders can add sophisticated search features to websites, manage canvas styling for WYSIWYG editors depending on what section a user edits and control where Components can be inserted.
Developers can hook in to our Dependency Injection framework, build search providers and leverage the new WebSocket based WAMP router and new client-side framework for building custom UI, based on ReactJS, Redux and Wampy.
There is also support for creating completely custom perspectives, deep linking to items in the console trees and more.
All the featured that have been driving this release has been released as open source, some via packages in our https://github.com/Orckestra/CMS-Packages repo.
IIS8+ / WebSockets required for full console feature support
The system requirements have changed for this release. You now need IIS8 or later and WebSockets must be enabled on your IIS server.
Search
You can now find pages, data and media files in the console by searching. The feature is installable as a package (available in preview) and currently we have an Lucene.NET based search provider ready and available as open source (see https://github.com/Orckestra/CMS-Packages/tree/search/Orckestra.Search.LuceneNET)
To get search on this release, install the package Orckestra.Search.LuceneNET.
Under the hood are new APIs that enable you to execute searches against content and create your own search provider, should you need it.
The search is integrated with the data type system in C1, meaning that the search will include core and custom C1 data, provided you declare you want this, either through UI or code.
For UI based data types, you will find new options when you edit your data type, enabling you to have a data type made searchable and giving you control over how fields can be searched.
For code based data types, you can attach the attributes [SearchableTypeAttribute()] to types and [SearchableFieldAttribute()] to fields.
You can read more about search and extensibility in this preview documentation.
Components
Components are a new way to insert functions – it is a lot more intuitive to use and it can do a lot more tricks, like insert HTML blocks and generate markup at insert time.
To create a component, simply add a xml file to ~/App_Data/Components with the desired markup. You can augment the file with attributes and customize title, group, images and more.
<html pal:title="YouTube Video"
pal:description="Insert responsive YouTube video."
pal:tags="media"
pal:icon="camera-video"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:pal="http://www.composite.net/ns/components/1.0">
<head>
</head>
<body>
<f:function name="Composite.Media.YouTube" xmlns:f="http://www.composite.net/ns/function/1.0">
</f:function>
</body>
</html>The above component will be presented to the user using the values specified with the pal:* attributes. The content of the body is what will be inserted. In the above case this will simply add the function Composite.Media.YouTube like you can do via the existing "Insert Function" feature, but with components the user experience is a lot more easy and intuitive and you can mix in static html and more than one function in the inside the body and this use this feature to do a lot more.
Beside from html documents – which will be copy to content as is - you can make function documents, which will prompt the user to fill in function parameters, and then insert the result of the function execution.
<f:function name="Orckestra.Web.Html.Grid.Columns"
pal:title="Social columns..."
pal:description="Create a set of columns, teasing your social networks"
pal:tags="social"
pal:icon="page"
xmlns:f="http://www.composite.net/ns/function/1.0" xmlns="http://www.w3.org/1999/xhtml" xmlns:pal="http://www.composite.net/ns/components/1.0">
<f:param name="Column1">
<html>
<head></head>
<body>
<f:function name="Orckestra.Web.Html.TeaserCards.IconTeaser">
<f:param name="Icon" value="facebook-square" />
<f:param name="IconColor" value="primary" />
<f:param name="Title" value="Facebook" />
<f:param name="Description" value="Find us on Facebook - contact us or like our page to keep up to date with news." />
<f:param name="ReadMoreUrl" value="http://www.facebook.com/OrckestraCMS" />
</f:function>
</body>
</html>
</f:param>
<f:param name="Column2">
<html>
<head></head>
<body>
<f:function name="Orckestra.Web.Html.TeaserCards.IconTeaser">
<f:param name="Icon" value="twitter-square" />
<f:param name="IconColor" value="primary" />
<f:param name="Title" value="Twitter" />
<f:param name="Description" value="Find us on Twitter - engage with us or follow us to get our short news tweets." />
<f:param name="ReadMoreUrl" value="http://www.twitter.com/OrckestraCMS" />
</f:function>
</body>
</html>
</f:param>
</f:function>You can augment components with container class names (see below) and there by limit where a component can be inserted. For instance, you can limit a component to only be available in the WYSIWYG editor when users are editing a specific placeholder or the content for a given page type.
Container classes
You can attach class names to placeholders in the CMS, both at template level and per page type.
Doing so will have two effects: the class names will be attached to the body of the WYSIWYG editor’s canvas, enabling you to have custom styling for individual placeholders. Also, the components that are available for user selection will be filtered according to the active container classes and filter rules defined on the component (if any).
[Placeholder(Id = "content", ContainerClasses="primary,wide", Title = "Content", IsDefault = true)]
public XhtmlDocument Content { get; set; }For page types, if you add a Placeholder Content element to it, you will find a new field “Container classes” on the Settings tab, where you can add one or more container classes.
If classes are specified at both template and page type level, the combination of both sets is used. If you want one class to rule out another (for instance, ensure "wide" and "narrow" cannot coexist) you can define this in ~/App_Data/Composite/Configuration/AntonymClassDefinitions.xml
If you are using the Visual Editor on for function parameters or data fields, you can configure what container classes are sent to the editor via a new parameter ContainerClasses on the Composite.Widgets.XhtmlDocument.VisualXhtmlEditor widget.
Dependency Injection
We have used the DI framework from ASP.NET Core – described in depth here https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection
Getting a service
To request a service, use Composite.Core.ServiceLocator – for services registered with the locator, you add the required services to your class constructor, as described in the ASP.NET Core documentation.
var indexUpdater = ServiceLocator.GetService<ISearchIndexUpdater>();
Registering a Service
You can register services during the startup of C1 CMS – to do so, create a class marked with the ApplicationStartup attribute and implement the ConfigureServices method as shown below.
The IServiceCollection that is passed to you, let you resister your service as singleton, transient or scoped (shared per request).
[ApplicationStartup]
internal class WampRouterResolverRegistry
{
public void ConfigureServices(IServiceCollection serviceCollection)
{
serviceCollection.Add(ServiceDescriptor.Singleton(new WampRouter()));
}
}
Function Parameter construction via Dependency Injection
When editing/executing Functions (Razor Functions, MVC Functions, C# Functions etc.) that have one or more parameters of a type that the DI Service Locator can provide, we will hide those parameters from the user UI and dynamically populate the parameter by getting instances from ServiceLocator.
This enable you to extend DI use to Functions in C1.
NuGet Feed
We have a new Nu...
Orckestra CMS 5.5
This is a service release with minor improvements:
- CMS Function previews in the Visual Editor are more stable.
- Setting up the CMS for the first time is a lot faster (typically 1 minute removed from setup time)
- You can now install packages that include data update (#297). Package Creator now also support exporting such packages.
Orckestra CMS 5.4
Orckestra CMS 5.4 (5.4.6150.25005)
This is a minor release, following up on the 5.3 released 14 days ago. In this version we introduce support for bulk uploading files to the website file system. On the stability side there are a few fixes.
Download
"Upload and Extract Zip" command for bulk upload
Developers and web masters that need to upload a larger number of files and folders to the website, can now do so through the CMS Console. Trees exposing the file structure (the "/" folder on the System perspective and the "/Frontend" folder on the Layout perspective) now have a "Upload and Extract ZIP" command on folders. This allow you to upload a ZIP and have it extracted to the given folder.
Minor Changes
Hierarchical Tree Selector widget now display number of selections made.
Adding "setFileFieldValue" command to nightwatch api (easy test of file uploads)
Bug fixes
"Add data" broken for Page Datafolders with publication flow active #276
Certain packages containing dynamic data types may hang during install #282
Function links in the C1 Page Speed view not working #270
A validation message on a required XHTML editor field (tab) shows up beyond the Console area #266
Orckestra CMS 5.3
Orckestra CMS 5.3 (5.3.6135.33075)
This release is our first as Orckestra CMS, after changing name from Composite C1. We've added the ability to duplicate pages and data, bumped up the .NET version requirement, added automated end-to-end testing and been fixing reported issues.
Download
Product name update
As advertised last month, we are renaming the product to Orckestra CMS - the open source project is named Orckestra CMS Foundation.
Duplicate Pages and Data
You can now create copies of pages and other content items via the new Duplicate action.
For tree structures created you have created with the Tree Definition XML format, you can selectively include the command on items using the element <DuplicateDataAction />
Upgrading .NET Framework to 4.6.1
To keep up with the improvements of .NET Framework we have upgraded to 4.6.1.
For customers using our Azure Cloud Services (WebRole), be aware you should obtain an updated package from us, which ensure .NET 4.6.1 is available on the machine.
Automated end-to-end testing with Nightwatch.js
We have added "Nightwatch.js, Node.js powered End-to-End testing framework" and extended it with an API tailored for writing tests for the CMS Console, giving you commands like browser.selectPerspective("Content").openTreeNode("Venus Starter Site").selectTreeNodeAction("Getting Started", "Duplicate Page")
Our build environment is executing these tests automatically after each build. This should ensure even more stable releases and automatic quality control on nightly builds.
To create a new test, add a .js file below ~/Website/test/e2e/suite - a sample test is shown below.
module.exports = {
'@tags': ['Duplicate'],
beforeEach: function (browser) {
browser.url(browser.launchUrl + '/Composite/top.aspx');
var content = browser.page.content();
content
.prepare();
},
'can duplicate simple page': function (browser) {
browser
.selectPerspective("Content")
.openTreeNode("Venus Starter Site")
.selectTreeNodeAction("Getting Started", "Duplicate Page")
.assertTreeNodeHasChild('Websites', 'Venus Starter Site')
.assertTreeNodeHasChild('Venus Starter Site', 'Copy of Getting Started');
browser
.selectPerspective("Content")
.selectTreeNodeAction("Copy of Getting Started","Delete")
.clickDialogButton("OK")
.assertTreeNodeHasNoChild("Copy of Getting Started")
},
afterEach: function (browser, done) {
done();
}
}
Support for Version Publication (commercial add-on)
With this release customers that are using the Business and Premium editions can install the Version Publication add-on and create multiple versions of a page publish according to a schedule.
For details, see https://cms.orckestra.com/Add-ons/All/Orckestra.Versioning.VersionPublication
Minor Changes
- Added an author column to the unpublished list
- Using non-blocking synchronization in DataCachingFacade to avoid file watcher buffer overflows and timeout exceptions during website installation
- Making DataFacade.BuildNew working in unit tests on release builds
Bug fixes
- Fixing an exception in SqlLoggerTextWriter when a query parameter isn't parsed correctly
- Fixing the Undo Changes action on pages
- Fixing a primary key update in relation to version fields
- Fixing pre-filling of a parent element reference when adding new data items
- Properly logging exceptions related to invalid XML markup referenced in tree definitions
- Fixing exceptions in the log caused by grouping elements
- The tree won't show data elements placed at the root
- Saving a page does not update the Console browser if the page was in "draft" state
- Fixing message broadcast without body text in the Console
- Fixing an upgrade bug caused by presence of existing dynamic page meta data types
- Fixing a DynamicDataTypePackageFragmentInstaller compile error
- Fixing an exception in routing code when making requests to a language without published pages
- Can't change the page type on pages
- Strings on options get cleared when the function properties window gets updated
- Fixing MultiKeySelector in compact mode not preserving the selection order
- Fixing the issue where tree element labels that JS can evaluate into a numeric or Boolean would break the Console
- Fixing the issue where the namespace of new Razor functions is present with different casing
- Fixing the issue where packages could not be installed from the package info view
- Catching and logging unhandled exceptions in FileChangeNotificator
- Fixing an issue where deleting a page version would select the root element and the version name would still stay in the selector
- Fixing an exception when adding meta data via the API without a logged-in user
- Fix adding a page folder data when a page that has more than one version causes an error
Composite C1 5.2
Composite C1 5.2 (5.2.6093.24082)
New name: September 21st we changed our project name from Composite C1 to Orckestra CMS Foundation. Existing releases (like this v5.2 release) have not been renamed.
Download
Download Composite C1 5.2, pre-compiled
What's new?
This release introduce a number of API level features and data layer changes in the core to enable support for storing multiple versions of data. This enable developers to create sophisticated multi version content publication features via add-ins.
Scheduled publication removed from the core
The feature driving the multiple data version changes is a more sophisticated “scheduled page publication” add-on that will be commercially available soon. The bad news is that we removed the original timed publication feature from the core to avoid clashes between the old and new models. This means you can no longer schedule page publishing on the open source version, at least not until we (or someone in the community) provide an add-on to fill in the gap. If this is affecting you, please raise an issue so we may dose the right amount of attention to this.
New interface IVersioned to signify a data type can be versioned
By implementing this new interface on a data type, you get a new Guid field VersionId, which will be part of the physical key of your data, but not the logical key.
If no other changes are made this mean you can receive multiple rows when you query for data on a specific logical key. This you may want in administrative lists, but to ensure a specific version is delivered - for instance on the public website - you can register a DataInterceptor to filter at data layer level, and eliminate the need for client code to be aware of data versioning.
DataInterceptors has existed for some years, and allow you to intercept queries for data and change the query (and thus the result). See the DataInterceptor class and the SetDataInterceptor method on DataFacade for info on this topic.
This interface has been added to the data types IPage and IPagePlaceholderContent and the base interface IPageMetaData – enabling data of these types to be versioned.
In case you want to add versioning features to a data type, but for some reason don't want to do this using the IVersioned interface, look at the property VersionKeyPropertyName below.
New Attribute for data interfaces [VersionKeyPropertyName(“somefield”)] to specify extra physical key field
Previously data types have had one or more key fields, which uniquely identified the data, both at data store level and logical level. To allow for multiple versions of a data to exist with the same logical key, we expand the physical key (like the Primary Key on a SQL table) with a second field to signify a sub version.
You can use the VersionKeyPropertyName attribute if you for some reason do not want to use the IVersioned interface to add versioning support, but you want to manage this aspect yourself.
Introducing data scope lifetime services
Data scopes now contain a way to register a service with the same lifespan as the data scope. This can be used in conjunction with data interceptors, to configure their behavior on a per connection (scope) basis.
Hooking in a service at connection scope level:
using (var con = new DataConnection())
{
con.AddService(MyService);
}
Hooking in a default service (to be used as fallback):
DataScopeServicesFacade.RegisterDefaultService(MyService);
You can disable all services you added to a connection (scope) using DisableServices() on the connection object. This will reset to underlying services that existed before your connection was created.
using (var con = new DataConnection())
{
con.AddService(MyService);
var filterdPages = con.Get<IPage>();
con.DisableServices();
var noneFilteredPages = con.Get<IPage>();
}
We mostly expect data scope lifetime services to be used to data interceptors – below is how you would register a data interceptor.
if (!DataFacade.HasGlobalDataInterceptor<IMyType>())
{
DataFacade.SetGlobalDataInterceptor< IMyType >(new MyFilteringDataInterceptor();
}
In your data interceptor, you can retrieve a service like this:
using (var con = new DataConnection())
{
object MyService = con.GetService(typeof (MyService));
}
As the code above imply, services are passed on to nested (child) scopes.
The concept being that your data interceptor with filter in different ways, depending on what has been added to the service.
Auxiliary URL / EntiryToken mapper support
In order to support URLs that address a specific version of a data, while keeping the existing URL / EntiryToken mapper engine, we introduced a new interface IServiceUrlToEntityTokenMapper which given a base URL and an EntityToken can ”specialize” the URL (append path info) and visa versa (given a URL with extra path info and a EntityToken matching the base path, specialize the EntityToken).
You can register your auxillary mapper like this:
UrlToEntityTokenFacade.Register(new MyUrlToEntityTokenMapper());
Despite the name ‘Service’ in this interface, this is not the place to inject services for data interceptors - for this a HTTP Module can do the trick.
ElementVisualizedData class now take ElementBundle and BundleElementName
For element providers (delivering the tree structures in the console) to allow users to interact with different versions of a data item, you can now define ‘bundles’ of elements, to be presented as a single node in the tree.
You define a bundle by having two or more elements share an ElementBundle value. You allow members in the bundle to be addressable by giving each of them a BundleElementName.
In the console, you will see a bundle as a single element. The first element in the bundle will be displayed by default. In the browser view a selector will appear, enumerating all the BundleElementName in the bundle. If the user change the selection, the selected element will be displayed in the tree and the associated URL for the selected element will be shown in the browser view.
var element = new Element(_elementProviderContext.CreateElementHandle(entityToken))
{
VisualData = new ElementVisualizedData
{
// ...
ElementBundle = data.Id.ToString(),
BundleElementName = data.VersionName
}
};
Versioned data helpers
To enable versioning features to be add-in based allow you to have custom columns to show up in existing views like “Bulk Publishing” and to support localized version naming (ex in the Version selector drop down in the browser) we introduced support for registering a helper class that can provide localized version name for data and extra columns to dynamically add in list views.
Your helper should inherit from VersionedDataHelperContract and can be registered like this:
VersionedDataHelper.RegisterVersionHelper(new MyVersionedDataHelper());
Form markup now support tooltips on document tabs
We’ve added support for controlling tooltip texts via the form markup. For situations where a user has multiple editors running with different versions of the same data, and each version share a title, the tooltip can be helpful to identify what version is running in a given tab, without having to focus it.
<?xml version="1.0" encoding="utf-8"?>
<cms:formdefinition ....>
<cms:bindings>
.....
<cms:binding name="Tooltip" type="System.String" optional="true" />
</cms:bindings>
<cms:layout iconhandle="...">
<cms:layout.tooltip>
<cms:read source="Tooltip" />
</cms:layout.tooltip>
....
</cms:layout>
<cms:formdefinition>
Other changes
Performance optimizations on data providers, C1 Console tree server rendering and “Bulk Publishing” view.
Method DataFacade.BuildNew() now works in unit test environment.
Client input validation messages are now localizable (ex. "required", "invalid number", etc.).
Composite C1 5.1
Composite C1 5.1 (5.1.6072.17836)
Download
Download Composite C1 5.1, pre-compiled
What's new?
Version 5.1 is a service release, which brings bulk publishing, time zone support and UI enhancements to users, fixes for issues found in the v5 release and other minor improvements and optimizations.
With v5.1 developers can override the UI and logic used for add/edit/publish/... actions on pages/data, use dependency injection for parameters in the Function system, use new widgets and create Packages that can update existing data.
Bulk Publishing
Users can now execute content workflow actions, like publish and approve, in bulk. The feature is available on the “Websites” node via the “List Unpublished Pages” command.
Time Zone setting support
You can now override the time zone used for managing date time values in the administrative interface. The setting can be changed from the “Global Settings” menu. When not configured, the time zone of the web server is used.
You can preview / browse to pages and content items when you link to them
The internal link selection dialog provides you with a rendering of the page / media you are about to link to, giving you a visual confirmation. You can also navigate to the element you want to by browsing to it, in addition to selecting it in the tree.
Add Page now a drop down where users select the page type
The ability to select a specific page type when creating new pages was added. Users will now see a drop down button with page type options, and select a page type via this drop down.
Customizing the flows of data actions (like “add page”)
Developers can now attach customized add/edit/delete workflows to a specific data type, making them either default or conditional based on data field values. This allows developers to do things like customizing the “Add Page” experience, presenting the user with a wizard customized to the type of page they are creating.
For details please see http://docs.composite.net/Console/Override-Data-Actions
Hierarchical Selector, new widget
A new widget that lets users select N elements from a hierarchical structure was added.
The widget is fed preselected values and a hierarchical structure – in the form markup you can invoke it using the following:
<cms:binding name="SelectedKeys" type="System.Collections.Generic.IEnumerable`1[System.Object]"/>
<cms:binding name="TreeNodes" type="System.Collections.Generic.IEnumerable`1[Composite.C1Console.Forms.CoreUiControls.SelectionTreeNode]"/>
…
<HierarchicalSelector AutoSelectChildren="true" Required="true">
<HierarchicalSelector.SelectedKeys>
<cms:bind source="SelectedKeys" />
</HierarchicalSelector.SelectedKeys>
<HierarchicalSelector.TreeNodes>
<cms:read source="TreeNodes" />
</HierarchicalSelector.TreeNodes>
</HierarchicalSelector>Icon Selector, new widget
A new widget enables users to select an icon from an SVG sprite sheet. The widget is configured with a path to the SVG file containing icons.
Example of an SVG sprite file:
<svg xmlns="http://www.w3.org/2000/svg">
<defs>
<g id="accept-green" viewBox="0 0 32 32" stroke="none" fill="green">
<polygon points="4,16 8,12 14,18 26,6 30,10 14,26 "/>
</g>
<g id="accept" viewBox="0 0 32 32" stroke="none">
<polygon points="4,16 8,12 14,18 26,6 30,10 14,26 "/>
</g>
</defs>
</svg> Example of form markup to invoke widget:
<SvgIconSelector Label="Icon" SvgSpritePath="~/Frontend/sprite.svg">
<SvgIconSelector.Selected>
<cms:bind source="bindingVariableNameHere" />
</SvgIconSelector.Selected>
</SvgIconSelector>The widget will enumerate all /svg/defs/g elements (which has an id attribute) – in the above example, this is 2 elements.
A specialized widget - ConsoleIconSelector – has also been introduced. This is a specialized version of SvgIconSelector, preset to display the icons available in the Console.
Package Installer features – support for data default values and data update
Making DataPackageFragmentInstaller (the component typically responsible for adding data as part of a package install) take default value attributes into account when validating data to install. This allows you to skip data for columns that has a default value specified on them, and also enables older packages to install on a new data schema, provided added columns have default values.
DataPackageFragmentInstaller also respects two new attributes when configured in the install.xml script: Setting "allowOverwrite" to true will ensure that a data item – if already existing – will be updated (and otherwise added). Setting "onlyUpdate" to true will explicitly require that the data item should be already existing, and it will be updated by the package.
<mi:Add installerType="Composite.Core.PackageSystem.PackageFragmentInstallers.DataPackageFragmentInstaller, Composite" uninstallerType="Composite.Core.PackageSystem.PackageFragmentInstallers.DataPackageFragmentUninstaller, Composite">
<Types>
<Type type="Composite.Community.Blog.Tags" allowOverwrite="true" onlyUpdate="false">
<Data dataScopeIdentifier="public" locale="?" dataFilename="~\Datas\Composite.Community.Blog.Tagss_public.xml" />
</Type>
</Types>
</mi:Add>Function previews – optional and more responsive UI
The images that represent Function calls in Visual Editor – previews of the HTML generated by the function – are now optional and can be globally disabled via the configuration. Locate the “functionPreviewEnabled” in Composite.config and set it to 'false' to use generic function representations.
The process generating function preview images have been optimized in a number of ways:
- support for external images has been added
- Console user cookies are now passed to the process
- old images are used while updates are generated (calmer UI experience),
- and logging in case of issues has improved.
Startup code can force an abort
The ApplicationStartupAttribute used to mark that code in a class should be executed as part of the application startup now accepts the parameter “AbortStartupOnException”, which makes the core re-throw exceptions from the startup code and effectively block the system from starting.
[ApplicationStartup(AbortStartupOnException = true)]
public static class SampleStartupClass
{
public static void OnBeforeInitialize()
{
}
public static void OnInitialized()
{
}
}Dependency Injection support for function parameters
Developers who wish to use DI to set Functions' parameters can now do so, using a new service collection. When your Function is invoked with unset parameters, the service collection is probed for the same type (typically interface based) and an object is retrieved/constructed and assigned to the function parameter.
A typical use case for this is abstracting implementation away from the Function code and instead, letting them communicate via an interface. During the application startup, you register said interfaces with concrete implementations. You can switch these implementations later on, if the environment (like staging or live) or external dependencies (like a data source) changes.
The UI for defining Function calls will treat parameters that can be invoked via the service container as optional (hidden) and thus allow users to add such functions.
See http://docs.composite.net/Functions/Dependency-Injections-on-Parameters for more information.
The Service Container is based on Microsoft.Extensions.DependencyInjection.
Fixed Issues
The following issues reported on GitHub were fixed in this release:
- Multiple functions on a page never stops loading
- 'String not found' on the SQL Connection form
- Password Policy validation messages are not distinctive
- Can't log in and no validation message when password policy enhanced
- No visual indication when TABbing the fields
- A validation error on a page's Metadata tab not indicated when saving the page
- An empty tab on a dynamic data form when a postback occurs on another tab
- Enforced password history allows passwords still in history
- Can't disable access to the C1 Console
- The "Languages" node collapsed and not selected when a language is removed
-...