What would you prefer me to do? Spend my time hacking around issues in older technologies like Internet Explorer 6 or would you like that time spent making the site look the best that it can on better desktop browsers, as well as on the iPhone, iPod Touch, iPad, Blackberry and a whole host of other mobile devices?

— Andy Clarke makes a very interesting point.

Marker Kentico Business Library

Marker have created a complete business layer facade for working across the kentico document apis. Why would we do such a crazy thing? Well, we found that on larger and more complex web applications that we had a certain amount of trouble with the standard approach.

When you use custom document types in Kentico, your rows are either returned as a CMS.TreeEngine.TreeNode or a System.Data.DataRow depending on what part of the api you are using. So the first main driver for our business layer was to be able to have a business entity class that mapped directly to a custom document type in Kentico. This means we know exactly  how a particular document type is represented in our application and know exactly what properties it has.

Also, you have different apis depending on whether or not you are using workflow/versioning or not.  All of the recommended development articles within the Kentico documentation generally assume you are working with published documents on your site which might not always be the case.

It should be noted that this approach is really for aspx template advocates looking to get the maximum control and performance from Kentico. This approach is likely overkill for smaller sites and is not applicable for the portal engine approach.

This article will focus on the basics of creating an entity class mapping to your custom document type and using the generic repository to perform some standard operations. There’s a lot of functionality in the MKB library beyond what is shown here and we doubt there is anything you can do with the kentico document api that you can’t do more easily and cleanly with the MKB library, if there is, let us know!

This library works against v5 with the 5.0.5 hot fix applied only. Just drop it in your bin folder and off you go..

Let’s create our first document entity class…

You can see a sample entity below which maps to a custom document type in our application. You will need to create this for each custom document type in your application. Note that we are currently working on code generation which will automatically generate these classes for you against the Kentico database. We think this would be a great feature to have within Kentico itself at some point.

Make sure you entity class inherits from the DocumentEntity class (Marker.Kentico.Business.Entities.DocumentEntity). This class includes all the core fields for a kentico document instance.

Next, you should apply a special table attribute. The table attribute allows you to set the class name (maps to kentico document type’s class name) and default alias path (the default alias path which forms the basis of all data access for the entity by default). In addition (not shown below) there is the possibility of setting the default site code (default site code for all data access for the entity by default if required with multi site solutions and also a default wildcard alias key (for automatically loading the entity based on a wildcard alias. If you don’t set this it’s the name of the entity lowercased, in this case ’supplier’).

Next, apply special field attributes for each property you want to map to a kentico document type. Note that your property names can be different from the underlying field if you want, and you can specific the nature of the binding (read, insert, update, all) as required.

This is all that is required to start using MKB, create a simply entity and move on to the next step, where the fun begins!

using Marker.Kentico.Business.Attributes;
using Marker.Kentico.Business.Enumeration
using Marker.Kentico.Business.Entitie

using Marker.Kentico.Business.Attributes;
using Marker.Kentico.Business.Enumerations;
using Marker.Kentico.Business.Entities;

    [Table("SMS.Supplier",@"/data/suppliers")]
    public class Supplier : DocumentEntity
    {

        private string _companyName = string.Empty;

        public Supplier()
        { }

        [Field("CustomerCode", FieldBindingType.All)]
        public string CustomerCode { get; set; }

        [Field("CompanyName", FieldBindingType.All)]
        public string CompanyName {
            get { return _companyName; }
            set
            {
                _companyName = value;
                this.DocumentName = value;
            }
        }

        [Field("ImageThumb", FieldBindingType.All)]
        public Guid ImageThumb { get; set; }

        [Field("Url", FieldBindingType.All)]
        public string Url { get; set; }

        [Field("Address", FieldBindingType.All)]
        public string Address { get; set; }

        [Field("Phone", FieldBindingType.All)]
        public string Phone { get; set; }

    }

Let's work with our entities using the document repository...

All you need to do is to put a using statement to the entities and repository namespaces


using Marker.Kentico.Business.Repository;
using Marker.Kentico.Business.Entities;


Then you can retrieve a strongly typed repository to work with your supplier entities as follows. This retrieves a singleton instance of the repository class, it could also be created using dependency injection if preferred, but this is the simplest api to be offered.


var repository = RepositoryFactory<DocumentRepository<Supplier>>.Instance;

Once you have your repository you can then load entities or get the current entity (if it is a supplier otherwise it will be null)

Supplier supplier = repository.Load(string aliasPath);
Supplier supplier = repository.GetCurrent();



Here are some other thigns you can do...



Saving and Deleting

Just update your entity's properties and call the save method



supplier.Url = "http://newurl.com";
repository.Save(supplier);


Deletion is just as easy: 

repository.Delete(supplier.DocumentID);


Custom Query Support with Paging!





You can see below that our repsitory enables querying with paging support (returning the total results)

var searchCriteria = new QueryFindCriteria();
searchCriteria.QueryName = "FindSuppliers"; // set the query name here
searchCriteria.SelectOnlyPublished = false; // let's include unpublished nodes
searchCriteria.Take = 10; // take 10 rows
searchCriteria.Skip = 10; // start at row 11
int totalCount = 0;
List<Supplier> suppliers = repository.Find(searchCriteria, out totalCount);

To support this you must be running SQL 2005 or above and simply structure your query as follows, noting the skeleton structure in highlighted yellow below.
WITH AllResults AS 
( 
 -- core paged query should go in here 
 select SupplierView.*, Row_Number() over (order by ##ORDERBY## as RowIndex  
 FROM View_SMS_Supplier_Joined as SupplierView 
 ##WHERE## 
)
 
SELECT  (SELECT COUNT(NodeID) FROM AllResults ) As TotalResults, *

FROM  AllResults

WHERE RowIndex > @skip AND RowIndex <= (@skip +  @take)
 
Criteria objects (not overloads)
You will likely have noticed that Kentico has dozens of overloads for it's core methods. MKB gets round this by having a limited number of overloads with criteria objects that contain properties with sensible defaults for all core operations.
For example, the QueryFindCriteria mentioned above has the following properties.


SiteName (defaults to current site)
CultureCode
Where
TopN
SelectOnlyPublished
OrderBy
CheckUserPermissions
QueryName
Parameters

And there is a simpler TreeFindCriteria accepted as an overload to the Find method on any repository with these properties:


SiteName (defaults to current site)
CultureCode
Where
TopN
SelectOnlyPublished
OrderBy
CheckUserPermissions
AliasPath
CombineWithDefaultCulture
MaxRelativeLevel
SelectLatestVersion - allows you to work with latest version of document under workflow, no need to change your api!


We hope you can see how much simpler this is as you just need to set the properties you explcitly need for any query rather than being forced to use a particular overload.



Conclusion

 We are sharing this library because we believe that it will be of value for kentico developers and partners to assess and make use of. We hope that it will also be useful for Kentico themselves who might consider the development of such an api to make it easier to work with Kentico. 
This code base is provided as is and we recommend you use it for testing purposes at this stage (although we feel the api coverage is pretty good). We'll support and answer questions as best we can. There's lots not covered here that is offered with the library that i'll cover in future posts if the interest is there!






Get the code!

We are providing a debug compiled version of our business assembly to solicit feedback on the apis offered. If there is sufficient interest we will release the code base on codeplex.

Download the latest version here: Marker.Kentico.Business.v3

Firstly, install the marvellous IIS 7.0 URL Rewrite Module
Get it here: http://www.iis.net/downloads/default.aspx?tabid=34&g=6&i=1692
Learn about it here: http://learn.iis.net/page.aspx/460/using-url-rewrite-module/

Now, all you have to do is tell Kentico not to use extensions on postback urls. I had to delve into the actual source code to locate this little gem of a setting. Set it to false and stick in AppSettings.config to ensure Kentico will not write out form actions which end in .aspx.

CMSUseExtensionOnPostback = false

Next, make sure Kentico is configured to not add friendly url extensions when it generates urls.

• Site Manager > Settings > Urls>
• Ensure the Friendly Url Extensions value is blank

Now all you need to do now is apply the rewriting rules  within the web.config, utilising the IIS Rewrite Module’s capabilities. (Note that you don’t need to do anything within IIS, you can manage everything within the web.config and simply deploy it out to target servers without worrying about any additional configuration).

For example, the EnforceTrailingSlash rule below will ensure that a trailing slash is added to all urls without extensions, performing a 301 redirect in the process. This is so to avoid multiple urls (ones with and without slashes) returning the same content which isn’t ideal from an SEO perspective.

The TrailingSlashToAspx rule below will ensure that a trailing slash is rewritten internally to .aspx, so that the kentico rewriting engine can take over. Note that the Kentico CMS folders are ignored (ones starting with CMS..)

<system.webServer>
<rewrite>
<rules>
<rule name=”EnforceTrailingSlash”>
<match url=”^(.*)$” ignoreCase=”false” />
<conditions>
<add input=”{REQUEST_FILENAME}” matchType=”IsFile” negate=”true” />
<add input=”{REQUEST_URI}” negate=”true” pattern=”(.*)\.([a-zA-Z]+)(/.*)?$” />
<add input=”{REQUEST_URI}” negate=”true” pattern=”(.*)\.([a-zA-Z]+)(\?.*)?$” />
<add input=”{REQUEST_URI}” negate=”true” pattern=”(.*)/(\?.*)?$”/>
</conditions>
<action type=”Redirect” url=”{R:1}/” redirectType=”Permanent” />
</rule>

<rule name=”TrailingSlashToAspx”>
<match url=”^(.*)/$” />
<conditions>
<add input=”{REQUEST_FILENAME}” matchType=”IsFile” negate=”true” />
<add input=”{REQUEST_URI}” negate=”true” pattern=”/cms(.*)$” />
<add input=”{REQUEST_URI}” negate=”true” pattern=”/getattachment/(.*)$”/>
<add input=”{REQUEST_URI}” negate=”true” pattern=”/getfile/(.*)$”/>
</conditions>
<action type=”Rewrite” url=”{R:1}.aspx” />
</rule>
</rules>
</rewrite>
</system.webServer>

And so there you have it, a relatively painless way to get yourself all SEOd with IIS 7.0 and Kentico CMS 5.0.

So what about the Kentico 5.0 SEO Features? mmm…maybe not

Kentico makes available 2 settings in v5.0 which are “Always apply trailing slash to urls” and “Always lower case url names” which in theory sound great, but i still recommend the above approach for control.

The first one only really makes sense if you are using extensionless urls anyway (which you need to configure separately from this setting, see below). When you set “Always apply trailing slash to urls” this ensures all urls generated by Kentico end with a trailing slash, which is a good thing. However, it also means that Kentico will attempt to add a trailing slash to our rewritten url above!

When this happens you get an infinite loop occuring where the rewrite module is attempting to rewrite the url to .aspx for Kentico to process and for some reason (and this is clearly in my view a bug) Kentico is attempting to put a trailing slash on a rewritten url which ends in an aspx. Kentico should IMHO leave this already rewritten url alone and only apply 301s and trailing slashes if the url actually requires it.

We’re still therefore waiting on a solution that just has Kentico generate all urls with trailing slashes and nothing else!

Upon investigation with support, Kentico still appear to recommend that you use the old IIS 6.x approach of assigning custom 404 error page to a Kentico handler page in order to implement extensionless urls. If you are using IIS 6, by all means use this approach if you must, but i don’t really like the extra configuration effort and it’s always felt a bit hacky to do this. 404 errors should be generated when a page is actually not found. This older approach is obviously not compatible with what i’m suggesting above.

Another problem we discovered with the Kentico SEO settings was when used in combination with aliasing. Aliasing is a Kentico feature wherby you can specifiy a url such as /articles/{article-title}, where {article-title} is any piece of text (the alias) and that these alias url requests all point to some underlying url such as /articles/article/.

If you switch on the “Always lower case url names” and you request a dynamic alias such as /articles/MY-ARTICLE/ it will redirect to the underlying url /articles/article/ breaking the aliasing approach. This appear to be a core bug in kentico 5.0.

]]> http://www.markerstudio.com/technical/2010/01/iis7-extensionless-urls-and-kentico-cms-5-0/feed/ 1 http://www.markerstudio.com/miscellaneous/2009/12/st-john-nz-cpr-iphone-app-top-app/ http://www.markerstudio.com/miscellaneous/2009/12/st-john-nz-cpr-iphone-app-top-app/#comments Tue, 22 Dec 2009 21:17:54 +0000 Jon Beattie http://www.markerstudio.com/?p=2167
The St John NZ CPR iPhone App that we have developed in partnership with St John is in the top 25 free apps overall, in the Apple App Store in New Zealand today.

Earlier this week we posted about being top in the Healthcare & Fitness category, however, to be in the top 25 overall is even more significant.

We appreciate all the feedback and will be looking to incorporate these suggestions into the next version.

We are pleased that people seem to like the app. We believe everyone should have this on your phone, just in case you need it.

The app has also been featured on TVNZ and Newstalk ZB this week.

The app is free for all iPhone and iPod touch users.

Other Links

• iPhone application could save lives
• Heart attack? Find an iPhone user
• St John NZ CPR app for the iPhone
• 11Alive.com

The St John NZ CPR iPhone App teaches the life saving skills of cardio-pulmonary resuscitation, commonly known as CPR. Knowing how to save a life of a family member, friend or colleague is vital, so why not get this application now so you have it on your phone.

If you have an iPhone or iPod touch, you can download the app for free.

You can read more on the St John website and also on Stuff.co.nz.

Here’s the code, we use a class to do the selection and the rel attribute to help define the validation group so we can only hide the button if the form has been validated successfully.

<asp:Button ID=”btnProceed” runat=”server” CssClass=”submit-once” rel=”UserProfile” ValidationGroup=”UserProfile”  Text=”Proceed” OnClick=”btnProceed_Click”  />

And here’s the sprinkling of jquery you will need (stick it in you base master page for example).

$(document).ready(function() {

// ensure that buttons are only clicked once with this class

$(”.submit-once”).click(function() {

if (Page_ClientValidate($(this).attr(”rel”))) {

$(this).after(”Please wait..”).hide();

}

});

});

Marker is Kentico Site of the Year Finalist

Marker is a finalist in the Kentico Site of the Year contest for our work on Yellow Maps.

We are the only Kiwi company in the battle for prizes so every vote counts in the online voting that will be carried out this month.

Please vote now, there are 12 categories to vote for and we are on Page 9 of 12 under the “Best Other/At Large Site” on the right hand side under ‘Yellow Maps’.

Culture Options – UI and Content Cultures

The Administration > Users section allows the setting of the Preferred content culture and the Preferred user interface culture. These values normally set at (default) but what does all this actually mean?

It is recommended to not explicitly set the culture for users and to let the defaults be used. Unless a user explicitly wishes to override, assuming this culture is supported.

Content Culture

Content cultures determine the actual content culture stored against Kentico documents as they are saved. If you have a multilingual site there are multiple documents stored for each culture against a single ‘node’.

N.B There is always a default content culture for a Kentico site.

List of all content cultures

The available list of all available content cultures are at Site Manager > Development > Cultures. All major cultures are provided here and you shouldn’t need to modify this list.

Setting the default content culture

You can set this in two ways (both have the same effect).

• Site Manager > Sites > [Site Instance] > Default content culture
• Site Manager -> Settings -> (select site) -> Web site -> Default culture of the content

What this means is that the default culture for all documents will be this value (e.g. en-NZ). If a user has (default) saved against their ‘Preferred content culture’ they will then see the default content culture for the Site they are viewing if they are logged in.

The default content culture should be set first in any Kentico implementation.

Setting the default visitor culture

You can set this in the following ways:

• Site Manager > Sites > [Site Instance] > Default visitor culture
• Site Manager > Sites > [Site Instance] > Domain Aliases > [Domain Alias Instance] > Default visitor culture

What this means is, if a user comes to the site anonymously, this is the culture that will be used by default to display to visitors and this can be managed on a domain alias level also.

For a site without multilingual capabilities it would normally be the same as the default content culture, but one may wish to have a French version of a site under a different domain in which case the default visitor culture setting would be set to French.

If this is not set, then the user’s browser settings will be used to determine the default visitor culture.

It is recommended that the default visitor culture always be set to match the default content culture by default.

Site manage > Sites > [Site Instance] > Cultures

This section allows you to set all the cultures that are being supported for a particular Kentico site. Note that this will affect the selectable cultures from within the cmsdesk administration interface for a particular website.

It is recommended that these values always be explicitly set when setting up a Kentico instance. If not a multilingual site allow only a single culture which matches the supported default content culture.

UI Culture

The UI Culture is the culture of the CMSDesk administration interface. Out of the box (OOTB), Kentico uses en-us (US English).

UI Cultures are stored within Site Manager > Development > UI Cultures. You will see there is an ‘English’ option, but this actually corresponds to en-us (US English). If you want to allow users to select between this and UK English for example within CMSDesk you should create a new UI Culture called English (NZ) and set the code to en-NZ.

If a user has (default) saved against their ‘Preferred user interface culture’ they will then see the CMS Desk interface using the culture defined in the AppSetting.config file for that website (there doesn’t appear to be a corresponding value within Site Manager). This value should be set to a sensible default to avoid users having to change it themselves. For a site managed from New Zealand it should be:

<add key=”CMSDefaultUICulture” value=”en-NZ”/>

It is recommended that this value always be explicitly set when setting up a Kentico instance.

Here’s some sample .net code to create a channel and user in justin.tv. The OAuthRequest wrapping class is then presented which acts as a core facade to justin.tv apis which secures the calls via a direct 2-legged request.

You should be able to modify the OAuthRequest and sample code for any OAuth based rest api as required.

Sample code to create new channel and user

// create new OAuthRequest and session
var oauthRequest = new OAuthRequest();
var oauthSession = oauthRequest.CreateSession();

// build up thepost  request
oauthSession.WithFormParameters(
	new
	{
		login = "[LOGIN]",
		password = "[PASSWORD]",
		birthday = "[DATEOFBIRTH]",
		email = "[EMAIL]",
		category = "[CATEGORY]",
		subcategory = "[SUBCATEGORY]",
		title = "[TITLE]",
		publisher_guard = "[PUBLISHER_GUARD]"
	}
);

// make the post request get the response as xml
HttpWebResponse results = oauthSession.Request().Post().ForUrl("http://api.justin.tv/api/channel/create.xml").ToWebResponse();
XDocument xdoc =oauthRequest.GetWebResponseAsXml(results);

// continue processing...

OAuthRequest facade class

using DevDefined.OAuth;
using DevDefined.OAuth.Consumer;
using DevDefined.OAuth.Framework;
using System.Xml;
using System.Xml.Linq;
using System.Net;
using System.IO;
using System.Text;

public class OAuthRequest
{
	private string requestUrl = "http://api.justin.tv/oauth/request_token";
	private string userAuthorizeUrl = "http://api.justin.tv/oauth/authorize";
	private string accessUrl = "http://api.justin.tv/oauth/access_token";

	public OAuthSession CreateSession()
	{
		var consumerContext = new OAuthConsumerContext
		{
			ConsumerKey = "YOURCONSUMERKEY",
			ConsumerSecret = "YOURCONSUMERSECRET",
			SignatureMethod = SignatureMethod.HmacSha1,
			UseHeaderForOAuthParameters = true
		};
		var session = new OAuthSession(consumerContext, requestUrl, userAuthorizeUrl, accessUrl);
		return session;
	}

	public XDocument GetWebResponseAsXml(HttpWebResponse response)
	{
		XmlReader xmlReader = XmlReader.Create(response.GetResponseStream());
		XDocument xdoc = XDocument.Load(xmlReader);
		xmlReader.Close();
		return xdoc;
	}

	public string GetWebResponseAsString(HttpWebResponse response)
	{
		Encoding enc = System.Text.Encoding.GetEncoding(1252);
		StreamReader loResponseStream = new
		StreamReader(response.GetResponseStream(), enc);
		return loResponseStream.ReadToEnd();
	}
}