Just a small blogpost to announce that I’ve just made a new release of the Package Action Contrib project. The following actions are added to the project:

• AddConfigurationSection
• PermissionForApp
• AddLanguageFileKey
• MoveFile
• UpdateAppTree

You can download the new release and documentation from codeplex. I’ve also updated the WIKI page on our.umbraco.org.

Many thanks to the contributors of this release, Simon Dingley, Chris Houston, Dirk de Grave and Søren Spelling Lund for submitting their code!

This forum post  triggered me to share some code that I had. A while back I was building a site which  let the customers define their own custom overviews One requirement was that users could define the sort by property . To do this you can use the property picker but it wasn’t friendly enough for my case so I ended up building a custom macro parameter type.

To start you need to create a new class library and add references to the following assemblies:

• Businesslogic
• Cms
• Interfaces
• Umbraco
• System.web

In the example below I’ve created a class that inherits from dropdownlist. This was the easiest way since I needed a dropdownlist and didn’t want to play with the control tree, Now more important is that this class inherits from the IMacroGuiRendering Interface.  This add two properties ShowCaption, to show the caption on the parameters tab and more important value which holds the selected value . 

             1: 
            using System;

             2: 
            using System.Collections.Generic;

             3: 
            using System.Text;

             4: 
            using System.Web.UI.WebControls;

             5: 
            using umbraco.interfaces;

             6:  

             7: 
            namespace MacroRenderDemo

             8: {

             9: 
            public
            class OrderBy
: DropDownList, IMacroGuiRendering

             10:  {

             11: 
            protected
            override
            void OnLoad(EventArgs
e)

             12:  {

             13: 
            base.OnLoad(e);

             14: 
            if (this.Items.Count
== 0)

             15:  {

             16: 
            this.Items.Add(new ListItem("Title", "nodeName"));

             17: 
            this.Items.Add(new ListItem("Date", "createDate"));

             18:  }

             19:  }

             20:  

             21: 
            #region IMacroGuiRendering
Members

             22:  

             23: 
            public
            bool ShowCaption

             24:  {

             25:  get { returntrue;
}

             26:  }

             27:  

             28: 
            public
            string Value

             29:  {

             30:  get

             31:  {

             32: 
            return
            this.SelectedValue;

             33:  }

             34:  set

             35:  {

             36: 
            this.SelectedValue
= value;

             37:  }

             38:  }

             39:  

             40: 
            #endregion
          

             41:  }

             42: }

When you build the project and add the binary into the bin folder of your Umbraco site you still can’t select the new type from the parameter type list. First we need to register the class  in the database. Below you’ll see the database table that holds all the Macro property types.

It is important that you add the Assemblyname  including the namespace to the macroPropertyTypeRenderAssembly column and add the name of your class to the  macroPropertyTypeRenderAssembly column .

Now we can use the parameter in our macro’s

and off course we can now use the new parameter in our template when we select the macro

Another example how flexible Umbraco is. If a requirement isn’t available out of the box, usuallyall it takes is to implement an interface and write a few lines of code.

Let’s start with wishing you all the best for 2010. 2009 was an insane year for me, I had given myself one year  being successful in business running my own Umbraco  projects instead of being a .net contractor. That turned out great, I’ve got a lot of new customers, have build a few great sites for my customers  and did a few Umbraco consulting jobs. So now it’s time to make plans for 2010.  First thing is that I’m moving to a real office instead of working from home. I’m really excited about this because I’m moving to an office building with lots of small companies, I think that’s really inspiring.

When I’ve started investigating Umbraco back in 2008 we had a small amount of companies in the Netherlands (mostly freelancers) that where building websites based on Umbraco. Nowadays I see new companies that build Umbraco websites every week, not only small shops but also really big agencies. For this year my focus will be on helping companies (worldwide) being successful implementing Umbraco sites for their clients by offering consultancy services and custom package development  instead of building sites from front to end.

As you might know I’m also working for a long time on UmbImport PRO. My plan was to release this package last year. It’s the top prio on my todolist for Q1 this year. Also another package will see the light this year, UmbLinkChecker. As the name says this will be a package that checks every link in your published site, not only in content but also hard coded links in your templates etc., I will build a free and Pro version. Since Umbraco has more than 75000 active installs I think it’s profitable to build commercial packages for Umbraco and we will see more and more commercial packages from different vendors. Hope the Umbraco store will be back up in 2010 and filled with great products.

The last year I couldn’t find enough time to blog or write WIKI’s and helping the community with their problems on the forum. I’m hoping this year that will change, since I’ve got a lot of info that I’d like to share.

Have a great 2010!

Usually I develop websites that require login functionality for one or more roles, now this is all cool for my clients but it’s a nightmare for me because I simply can’t remember all the login and passwords. To make my life and other developers life’s a little bit easier I’ve developed the Memberswitcher package. This package let's you easily login members and switch between members by simply selecting a member from a pull down list instead of enter the username and password. It’s using a lower level asp.net membership method to login the member based on the username and is fully compatible with all the asp.net Membership controls. Also the methods to fill the Membergroup and Member pulldowns are using Membership methods, so it will work with the Umbraco members but also with other membership providers.

Once installed, an extra macro is added to the list. In your template select the Memberswitcher macro, optional specify a node to redirect to once logged in and that’s it.
<umbraco:Macro RedirectToNodeAfterLogin="" Alias="MemberSwitcher" runat="server"></umbraco:Macro>

When you visit the website you’ll see the control in action. First select the Membergroup and Member.

 
When you click the Login selected member button you’ll be logged in as you can see in the following screenshot that is using the asp.net LoginStatus control.

Needless to say:
DO NOT USE THIS PACKAGE IN A PRODUCTION ENVIRONMENT!!

Download the package here

A few weeks back I had this  issue when deploying a site. I needed to modify a documenttype to add a few properties and after a few minutes an error was raised and the only thing I could see when I deleted the property and saved the documenttype again, or opened a document based on that document type was the following error message (thanks Dan for the picture). 

Did I make a backup? ehh no, so I needed to fix this. Okay let’s look at  the error message again. An Object reference not set error is thrown while deleting the property. Love that Umbraco is open source and I can have a look at the source code. Below you see the method that is responsible for deleting the property from the documenttype.

             1: 
            public
            void delete()

             2:  {

             3: 
            // flush cache
          

             4:  FlushCache();

             5:  

             6: 
            // Delete all properties of
propertytype
          

             7: 
            foreach(Content c in Content.getContentOfContentType(new ContentType(_contenttypeid)))

             8:  {

             9:  c.getProperty(this).delete();

             10:  }

             11: 
            // Delete PropertyType ..
          

             12:  SqlHelper.ExecuteNonQuery("Delete
from cmsPropertyType where id = " + this.Id);

             13: 
            this.InvalidateCache();

             14:  }

As you might have seen there is no check for null values on the 9 (c.getProperty(this).delete();). This is what caused the error while deleting the property. I assume it's sort of the same issue when opening a document. Now that I know this I can work on a solution. As I mentioned earlier, I needed to add properties to the document type. Below you find the code I’ve used to do that.

             1:  ContentType ct = ContentType.GetByAlias("_advertiser");

             2: 
            foreach (PropertyType
i in ct.PropertyTypes)

             3:  {

             4: 
            if (i.Alias == "linkToSpecial")

             5:  {

             6: 
            // Delete all properties of
propertytype
          

             7: 
            foreach (umbraco.cms.businesslogic.Content
c in umbraco.cms.businesslogic.Content.getContentOfContentType(ct))

             8:  {

             9: 
            if (c.getProperty("linkToSpecial")
== null)

             10:  {

             11:  c.addProperty(i, c.Version);

             12:  c.Save();

             13:  }

             14:  }

             15: 
            //Remove comment to delete
the property from the doctype
          

             16: 
            //i.delete();
          

             17: 
            //ct.Save();
          

             18:  }

             19:  }

As you can see, I’ve used a  few hard coded values. _advertiser is the alias of the document type and linkToSpecial is the alias of the property that I wanted to add on the Document type. If you want to delete the property  remove  lines 9-13 and remove the comment on line 16 and 17. You can use this code in a usercontrol and use that usercontrol as a dashboard control. Needless to say, this code comes without a warranty.

I’ve added the issue to codeplex, please vote for it!. Hope this post is a nice work around for the issue.

Just a little quick tip. When you install Umbraco v4.0.2.1 (don't know about other versions) without runway and you publish your site, you will see a blank screen. This is because the data/umbraco.config file contains the runway site as you can see in the sample xml below. 

          <!
          DOCTYPE
          umbraco[
&lt;!ELEMENTnodesANY><!ELEMENTnodeANY><!ATTLISTnodeidID #REQUIRED> ]><rootid="-1"><nodeid="1048"version="6f0d47e7-8cf1-43e5-a5ad-c687e0b78331"parentID="-1"level="1"writerID="0"
creatorID="0"nodeType="1045"template="1042"sortOrder="2"
createDate="2008-05-02T09:52:36"updateDate="2009-02-18T10:19:26"nodeName="Runway
Homepage"
urlName="runway-homepage"writerName="Administrator"
creatorName="Administrator"nodeTypeAlias="RunwayHomepage"path="-1,1048"><dataalias="bodyText"><![CDATA[<p>Runway
gives you a bare-bones website that introduces you to a set of 


well-defined conventions for building an umbraco website.</p><p>The
Runway website is very simple in form and provided without any design or functionality. 


By installing Runway, you&rsquo;
ll begin with a minimal site built on best practices. You&rsquo;ll
also enjoy the benefits of 


speaking the same &ldquo;language&rdquo;

as the rest of the umbraco community by using common properties and naming conventions.</p><p>Now
that you know what Runway is, it is time to get started using Runway.</p>]]></data><dataalias="siteName">Runway</data><dataalias="siteDescription"><![CDATA[Off
to a great start]]></data> ..................... </node></root>

Work around for this issue is to republish the entire site first. I've added this issue to codeplex. Please vote here.

I'm very pleased to announce that I finally released the V1 version of UmbImport. For those of you who don't know what UmbImport is:

UmbImport helps you import content or members from any datasource into Umbraco. The following datasources are supported by default:

• SQL Server
• CSV file
• XML file

You can also create your own custom DataAdapter. Check out the following links to screencasts to see the power of UmbImport. 

• Import content 
• Import members

The package is added to our.umbraco.org the new Umbraco community site , so you can download it there or use the UmbImport site. On our.umbraco.org you will find a forum also where you can drop your questions/feature requests/ bugs etc. In August I will release a manual also. If you find any issues please report it on the forum or comment on this post.

In February I wrote this blogpost which describes the process of how to add a menu item to the context menu using the Umbraco V4 Event system. In UmbImport PRO I've used this mechanism. When I was testing this I came across a bug in my code when using a pagepicker, this was showing an empty tree in the node picker.

Then I got a little flashback to the level 2 course I attended last November where Niels told us to check if there was a menu attached to the node (which is not the case for the pagepicker) before adding menu items to it, otherwise an exception is thrown what will result in an empty tree. This is what happened in my case. In the example below I've only added node.Menu!= null check and now everything is working fine.

             1: 
            using System;

             2: 
            using umbraco.BusinessLogic;

             3: 
            using umbraco.cms.presentation.Trees;

             4: 
            using umbraco.interfaces;

             5:  

             6: 
            namespace UnpublishAction

             7: {

             8: 
            /// <summary>
          

             9: 
            /// Add unpublish to the menu
item
          

             10: 
            /// </summary>
          

             11: 
            public
            class AddUnpublishActionEvent
:ApplicationBase

             12:  {

             13: 
            public AddUnpublishActionEvent()

             14:  {

             15:  BaseContentTree.BeforeNodeRender += new BaseTree.BeforeNodeRenderEventHandler(BaseTree_BeforeNodeRender);

             16:  }

             17:  

             18: 
            /// <summary>
          

             19: 
            /// Before a menu item gets
rendered we will add the unpublish action if the document is published
          

             20: 
            /// </summary>
          

             21: 
            private
            void BaseTree_BeforeNodeRender(ref XmlTree
sender, ref XmlTreeNode node, EventArgs e)

             22:  {

             23: 
            ///Only unpublish when published
          

             24: 
            if (node.Menu!= null &&
!node.NotPublished.GetValueOrDefault(true))

             25:  {

             26: 
            //Find the publish action and
add 1 for the index
          

             27: 
            int index = node.Menu.FindIndex(delegate(IAction
a) { return a.Alias == "publish";
})+1;

             28:  

             29: 
            //Insert unpublish action
          

             30:  node.Menu.Insert(index, UnpublishAction.Instance);

             31:  }

             32:  }

             33:  }

             34: }

             35:  

Download Source

Hope it didn't get you into trouble, sorry if it did.

As I mentioned earlier it's possible to create a custom data adapter which can be plugged into umbImport. The free edition supports one custom data adapter, the pro edition will support multiple adapters.  In this multi part series I will demonstrate how you can create your own data adapter by building an RSS import adapter. In this first part we will create the basic adapter in later post we will refine the functionality. For this first part I've installed Umbraco 4.0.1 and the packages Blog4Umbraco and UmbImport beta 1.

Create the adapter

You can create a custom data adapter by deriving from two classes:

• UmbImportLibrary.BaseTypes.ImportDataAdapter.
• UmbImportLibrary.BaseTypes.ImportDataUI.

The ImportDataAdapter class provides the real communication to the datasource and holds a reference to the ImportDataUI class which is responsible for the user input. For our RSS import adapter we will start by creating the UI class.

             1: 
            public
            class RSSDataAdapterUI
: ImportDataUI

             2:  {

             3: 
            private Panel _rssContentPanel
= new Panel();

             4: 
            private Literal _selectRssSourceLiteral
= new Literal();

             5: 
            private TextBox _rssLocation
= new TextBox();

             6:  

             7: 
            protected
            override
            void OnInit(EventArgs
e)

             8:  {

             9: 
            base.OnInit(e);

             10:  

             11:  _rssContentPanel.ID = "RssContentPanel";

             12:  _selectRssSourceLiteral.ID = "SelectRssSourceLiteral";

             13:  _selectRssSourceLiteral.Text = "Specify
the RSSLocation";

             14:  _rssLocation.ID = "RssLocation";

             15:  _rssLocation.Width = 400;

             16:  _rssContentPanel.Controls.Add(new LiteralControl("<table><tr><td
width=\"150\">"));

             17:  _rssContentPanel.Controls.Add(_selectRssSourceLiteral);

             18:  _rssContentPanel.Controls.Add(new LiteralControl("</td><td>"));

             19:  _rssContentPanel.Controls.Add(_rssLocation);

             20:  _rssContentPanel.Controls.Add(new LiteralControl("
example http://feeds.feedburner.com/umbracoblog </td></tr></table>"));

             21:  

             22: 
            this.Controls.Add(_rssContentPanel);

             23:  }

             24:  

             25: 
            /// <summary>
          

             26: 
            /// Returns the Datasource
          

             27: 
            /// </summary>
          

             28: 
            public
            override
            string DataSource

             29:  {

             30:  get

             31:  {

             32: 
            return _rssLocation.Text;

             33:  

             34:  }

             35:  }

             36:  }

The OnInit method generates the form. The only real interesting thing in this class is the datasource property. This will be used in UmbImport to initialize the import with the selected datasource.

               1: 
              public
              class RSSDataAdapter
: ImportDataAdapter

               2:  {

               3: 
              private ImportDataUI
_xmlImportUI;

               4:  

               5: 
              /// <summary>
            

               6: 
              /// Alias of the import adapter
            

               7: 
              /// </summary>
            

               8: 
              public
              override
              string Alias

               9:  {

               10:  get { return"RssImport";
}

               11:  }

               12:  

               13: 
              /// <summary>
            

               14: 
              /// Get XML Data
            

               15: 
              /// </summary>
            

               16: 
              /// <returns></returns>
            

               17: 
              public
              override IDataReader
GetData()

               18:  {

               19: 
              return XmlToDataReader(DataSource, "//item");

               20:  }

               21:  

               22: 
              /// <summary>
            

               23: 
              /// Validates the selected
datasource
            

               24: 
              /// </summary>
            

               25: 
              public
              override
              bool Validate()

               26:  {

               27: 
              bool result = false;

               28: 
              try
            

               29:  {

               30: 
              using (IDataReader
datareader = XmlToDataReader(DataSource, "//item"))

               31:  {

               32:  result = true;

               33:  }

               34:  }

               35: 
              catch
            

               36:  {

               37:  result = false;

               38:  }

               39: 
              return result;

               40:  }

               41:  

               42: 
              /// <summary>
            

               43: 
              /// Holds a reference to the
UI control of the adapter
            

               44: 
              /// </summary>
            

               45: 
              public
              override ImportDataUI
UIControl

               46:  {

               47:  get

               48:  {

               49: 
              if (_xmlImportUI == null)

               50:  {

               51:  _xmlImportUI = new RSSDataAdapterUI();

               52:  _xmlImportUI.ID = "RssImport";

               53:  }

               54: 
              return _xmlImportUI;

               55:  }

               56:  }

               57:  }

The Alias property will return the unique alias that we can use to select our adapter during the Import process. The GetData method will return a datareader initialized with the datasource. When importing XML it needs to be converted to a datareader first. The ImportDataAdapter Base class has a method XmlToDataReader what will convert the xml file to  a datareader. The Validate method will check if the selected datasource is valid. The UIControl property holds a reference to the RSSDataAdapterUI class. The ImportDataAdapter base class has more properties/methods that you can override but for this data adapter we are done.

When you compile the project and put the DLL in the bin folder of the Umbraco install the DLL will be picked up automatically by UmbImport.

Using the RSS import adapter

When you start UmbImport you will see in step 2 that you can select the RssImport data adapter

In the next step we will see the form that we have created in the RSSDataAdapterUI class. Here we can specify the RSS location.

In the Next step we can specify the location where to store the blogposts (Note: When using the Blog package blogposts will be arranged by data automatically) and we select the blogpost as document type.  In step 5 we will create the mapping between the fields from the RSS feed and the Umbraco Document Properties. You will see a lot of other fields from the RSS Feed. Just ignore them for now. In a later post we will filter the columns.

The result

When you click next and next again on the confirm screen the RSS feed will be imported.

In the next post I will show you how to Import the comment data with the same Adapter. I will also show you how to filter the columns for the property mapping dropdowns. When you want to play with this import adapter then  download the source here.

Last week I had a meeting with Nico Lubbers and we discussed the possibility of adding Dictionary Items on the fly. You can read in this post from Tim that it's been done before, but we want to make sure that it works in every situation (Template, Usercontrol and Xslt) and we don't want a baseclass for just adding items to the dictionary . Also we want logical keys (like savebuttonText, companynameLabel etc.) instead of generated keys. Basically we want the pain of adding  the dictionary items in the templates, usercontrols and xslt's  but we don't want the pain of adding  the dictionary items in Umbraco manually. Now before your read on I must warn you that the solution is not based on an architecture ;-)

What happens if Umbraco can't find a dictionary item?

When you add a dictionary item on a template, usercontrol or XSLT and Umbraco can't find it an exception is thrown. Umbraco will catch that exception and write it to the tracelog. For this blogpost I've used a standard Umbraco 4.0.1 instance with Runway and the modules contact form and standard navigation installed. In the example below I'be added a few non existing Dictionary items to my code.

Template

          <
          umbraco:Item
          field
          ="#Template_DetailHeader"
          runat
          ="server"
          ></
          umbraco:Item
          >
        

XSLT

          <
          xsl:value-of
          select
          ="umbraco.library:GetDictionaryItem('XSLT_FromDictionary')"
          />
        

Usercontrol Markup

          <%=umbraco.library.GetDictionaryItem("UserControl_Details") %>

Usercontrol Codebehind

lb_name.Text = umbraco.library.GetDictionaryItem("UserControl_LabelCaption"); 

Now when you view the page you will see empty places instead of the dictionary values. What's more interesting is to view the page with the queryparameter ?umbdebugshowtrace=true what shows you the trace info of the page like the image below.

How can we get that data?

While it's nice that we can view the data, it would be great if we can parse the trace info and automatically add the missing dictionary items. This can be done using a Trace Listener, when an item is added to the trace you can configure 1 or more trace listeners that recieve the message then we can parse. In the  Class below I derive from the TraceListener class. The TraceListener methods calls the AddItemUnknown method which check the message with a regular expression. If the message can be parsed the unknow dictionary key is retrieved from the message and will be added to Umbraco. To ensure we will see the value when we refresh the page the key will also be added as the value for every language.

             1: 
            using System;

             2: 
            using System.Diagnostics;

             3: 
            using System.Text.RegularExpressions;

             4: 
            using umbraco.BusinessLogic;

             5: 
            using umbraco.cms.businesslogic.language;

             6:  

             7: 
            namespace SoetemanSoftware.Tools

             8: {

             9: 
            public
            class AddUnknownDictionaryItemsListener
: TraceListener

             10:  {

             11: 
            public
            override
            void Fail(string message)

             12:  {

             13:  AddItemWhenUnknown(message);

             14:  }

             15:  

             16: 
            public
            override
            void Fail(string message, string detailMessage)

             17:  {

             18:  AddItemWhenUnknown(message);

             19:  }

             20:  

             21: 
            public
            override
            void Write(string message)

             22:  {

             23:  AddItemWhenUnknown(message);

             24:  }

             25:  

             26: 
            public
            override
            void WriteLine(string message)

             27:  {

             28:  AddItemWhenUnknown(message);

             29:  }

             30: 
            public
            override
            void WriteLine(string message, string category)

             31:  {

             32:  AddItemWhenUnknown(message);

             33:  }

             34:  

             35: 
            /// <summary>
          

             36: 
            /// Parse at the message 
          

             37: 
            /// </summary>
          

             38: 
            /// <param name="message"></param>
          

             39: 
            private
            void AddItemWhenUnknown(string message)

             40:  {

             41: 
            try
          

             42:  {

             43:  Match match = Regex.Match(message, "(Error
returning dictionary item ')(.*)(' --)", RegexOptions.Multiline);

             44: 
            if (match.Groups.Count
> 1)

             45:  {

             46: 
            //Get key from the mach collection
          

             47: 
            string key = match.Groups[2].Value;

             48: 
            //Check if key is allready
in Umbraco
          

             49: 
            if (!umbraco.cms.businesslogic.Dictionary.DictionaryItem.hasKey(key))

             50:  {

             51: 
            //Add new key with default
value to Umbraco
          

             52: 
            int dictionaryID =
umbraco.cms.businesslogic.Dictionary.DictionaryItem.addKey(key, string.Format("[{0}]",
key));

             53:  

             54:  var dictionaryItem = new umbraco.cms.businesslogic.Dictionary.DictionaryItem(dictionaryID);

             55: 
            foreach (Language l in Language.getAll)

             56:  {

             57:  dictionaryItem.setValue(l.id, string.Format("[{0}]",
key));

             58:  }

             59:  dictionaryItem.Save();

             60:  }

             61:  }

             62:  }

             63: 
            catch (Exception ex)

             64:  {

             65: 
            //Logic may never break on
this Listener
          

             66:  Log.Add(LogTypes.Error, -1, string.Format("Error
in Dictionary listener when adding item to dictionary {0} ", ex.Message));

             67:  }

             68:  }

             69:  }

             70: }

Configure the TraceListener

When you want to use the TraceListener you have to configure it in the web.config. Add the following section to your web.config file.

          <
          system.diagnostics
          >
          <
          trace
          autoflush
          ="true"
          indentsize
          ="4"
          >
          <
          listeners
          >
          <
          remove
          name
          ="Default"
          />
          <
          add
          name
          ="AddDictionaryListener"
          type
          ="SoetemanSoftware.Tools.AddUnknownDictionaryItemsListener,AddUnknownDictionaryItemsListener"
          />
          </
          listeners
          >
          </
          trace
          >
          </
          system.diagnostics
          >
        

Also modify the existing Trace element by adding the writeToDiagnosticsTrace="true". This will forward the ASP.NET trace messages to our AddUnknownDictionaryItemsListener. Simply set this attribute to false if you don't want the items to be added automatically.

          <
          trace
          enabled
          ="true"
          requestLimit
          ="10"
          pageOutput
          ="false"
          traceMode
          ="SortByTime"
          localOnly
          ="true"
          writeToDiagnosticsTrace
          ="true"
          /> 

View the output

When you configured the trace listener and hit the page again the missing dictionary items are added to Umbraco.

Refresh the page again and you will see the following output

Sometimes you will encounter caching issues. When you want to avoid that use the umbdebugshowtrace=true querystring parameter which will prevent caching.

Download

You can download the DLL here. You can also dowload the source here.