AngularJS is a MVC javascript framework mainly mantained by Google which primary goal is to aid in the development of single-page applications. It’s use on the Umbraco backoffice was the most notable change when Umbraco 7 was first released.

When the content manager selects one node pending approval we want him to be able to take three quick actions:

• get some information about that node;
• quickly access it in the content section;
• quickly publish it.

New Angular controllers and views must be placed in a specific Umbraco directory, following a specific directory structure:

• the main directory must reside at ~\App_Plugins\ApproveIt – the plugin name
• the views and controllers must reside at App_Plugins\ApproveIt\backoffice\approvalTree\ – the tree controller name

First things first:

Create a package manifest so that Umbraco knows there are new javascript files available, and place it in the root of App_Plugins\ApproveIt directory.

{
	javascript: [
		'~/App_Plugins/ApproveIt/backoffice/approvalTree/edit.controller.js',
		'~/App_Plugins/ApproveIt/approval.resource.js'
	]
}

Then we must create the javascript files referenced by the manifest and the respective angular view.

angular.module("umbraco.resources")
	.factory("approvalResource", function ($http) {
	    return {
	        getById: function (id) {
	            return $http.get("backoffice/ApproveIt/ApprovalApi/GetById?id=" + id);
	        },
	        publish: function (id) {
	            return $http.post("backoffice/ApproveIt/ApprovalApi/PostPublish?id=" + id);
	        }
	    };
	});

This javascript file provides a new Angular Service that can then be used by Angular controllers. This service is no more than a facade for the ApprovalApiController created on Part II. The methods it connects to are created further on.

angular.module("umbraco").controller("Approval.ApprovalEditController",
	function ($scope, $routeParams, approvalResource, notificationsService, navigationService) {

	    $scope.loaded = false;

	    if ($routeParams.id == -1) {
	        $scope.node = {};
	        $scope.loaded = true;
	    }
	    else {
	        approvalResource.getById($routeParams.id).then(function (response) {
	            $scope.node = response.data;
	            $scope.loaded = true;
	        });
	    }

	    $scope.publish = function (node) {
	        approvalResource.publish(node.Id).then(function (response) {
	            $scope.node = response.data;
	            $scope.contentForm.$dirty = false;
	            navigationService.syncTree({ tree: 'approvalTree', path: [-1, -1], forceReload: true });
	            notificationsService.success("Success", node.Name + " has been published");
	        });
	    };

	});

This Angular controller is called when the Approve It section is being used:

• If no node is selected (for instance, when we access this section for the first time) we do nothing;
• If a node is selected ($routeParams.id != -1) we request the node details through our approval.resource service facade
• Finally, the quick publish method is also implemented here. This methods calls the ApprovalResource service which then invokes the publish method of the ApprovalApiController.

<form name="contentForm"
      ng-controller="Approval.ApprovalEditController"
      ng-show="loaded"
      ng-submit="publish(node)"
      val-form-manager>
    <umb-panel>
        <umb-header>
            <div class="span7">
                <umb-content-name placeholder="@placeholders_entername"
                                  ng-model="node.Name" />
            </div>
            <div class="span5">
                <div class="btn-toolbar pull-right umb-btn-toolbar">
                    <umb-options-menu ng-show="currentNode"
                                      current-node="currentNode"
                                      current-section="{{currentSection}}">
                    </umb-options-menu>
                </div>
            </div>
        </umb-header>
        <div class="umb-panel-body umb-scrollable row-fluid">
            <div class="tab-content form-horizontal" style="padding-bottom: 90px">
                <div class="umb-pane">

                    <umb-control-group label="Name" description="Content's name">
                        <input type="text" class="umb-editor umb-textstring" ng-model="node.Name" required />
                    </umb-control-group>

                    <div class="umb-tab-buttons" detect-fold>
                        <div class="btn-group">
                            <a class="btn" ng-href="#/content/content/edit/{{node.Id}}">
                                Show
                            </a>
                        </div>
                        <div class="btn-group">
                            <button type="submit" data-hotkey="ctrl+s" class="btn btn-success">
                                Publish
                            </button>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </umb-panel>
</form>

The node view presents the waiting approval page name and two buttons: one to quickly navigate to it’s details and another to publish it.

Finally, we need to update the ApprovalApiController.cs to include two new methods:

public IContent GetById(int id)
{
    IContent content = ApplicationContext.Services.ContentService.GetById(id);
    return content;
}

public IContent PostPublish(int id)
{
    IContent node = ApplicationContext.Services.ContentService.GetById(id);
    ApplicationContext.Services.ContentService.Publish(node);

    return node;
}

• GetById: returns the node details to the angular view
• PostPublish: publishes the node being viewed

By following these steps we are able to create a complete new Umbraco backoffice section that provides us with a way to manage every site content waiting approval for publishing:

If you want to see how this plugin as been evolving, you can check its source code in github: https://github.com/ViGiLnT/ApproveIt. You can also download the plugin ready to be installed at Umbraco’s extensions repository: https://our.umbraco.org/projects/backoffice-extensions/approve-it/. Other Umbraco 7 tutorials and information can be found here: http://umbraco.github.io/Belle.

The post Building an Umbraco 7 backoffice extension – Part III appeared first on Blog IT.

To begin with, we must reference a few more assemblies (also available at the Umbraco’s installation bin directory):

• umbraco.dll
• cms.dll
• Umbraco.Core.dll
• System.Web.Http
• System.Net.Http.Formatting

Then we can populate our section with a tree containing content awaiting approval. To accomplish this we must extend an Umbraco class named TreeController and decorate it with information about our Approve It plugin:

[Tree("approveIt", "approvalTree", "Content for Approval")]
[PluginController("ApproveIt")]
public class ApprovalTreeController : TreeController
{
   protected override TreeNodeCollection GetTreeNodes(string id, FormDataCollection queryStrings)
   {
       var ctrl = new ApprovalApiController();
       var nodes = new TreeNodeCollection();

       IUser user = UmbracoContext.Security.CurrentUser;

       //check if we're rendering the root node's children
       if (id == Constants.System.Root.ToInvariantString())
       {
           foreach (IContent content in ctrl.GetAll(user))
           {
                var node = CreateTreeNode(
                    content.Id.ToString(),
                    "-1",
                    queryStrings,
                    content.Name,
                    "icon-document",
                    false);

               nodes.Add(node);
            }
       }

        return nodes;
    }

    protected override MenuItemCollection GetMenuForNode(string id, FormDataCollection queryStrings)
    {
        var menu = new MenuItemCollection();

        if (id == Constants.System.Root.ToInvariantString())
        {
            // root actions
            menu.Items.Add<RefreshNode, ActionRefresh>(
                ApplicationContext.Services.TextService.Localize(ActionRefresh.Instance.Alias));
        }

        return menu;
    }
}

To create a tree we must implement two methods:

1. GetTreeNodes: in here we call the GetAll method of the ApprovalApiController that we’ll create in the following. This GetAll method returns a list of content waiting approval and we just iterate through it all and create tree nodes;
2. GetMenuForNode: presents a dropdown menu when we right click the root node to refresh the list.

Next we create our custom WebAPI and name it ApprovalApiController. For it to be available in our site, we need only extend the UmbracoAuthorizedJsonController.

[PluginController("ApproveIt")]
public class ApprovalApiController : UmbracoAuthorizedJsonController
{
    public IList<IContent> UnpublishedContent { get; set; }

    public IEnumerable<IContent> GetAll(IUser user)
    {
        UnpublishedContent = new List<IContent>();

        IList<IContent> root = ApplicationContext.Services.ContentService.GetRootContent().ToList();

        foreach (IContent content in root)
        {
            GetNode(content);
        }

        return UnpublishedContent;
    }

    private void GetNode(IContent node)
    {
        if (!node.Published)
        {
            UnpublishedContent.Add(node);
        }

        foreach (IContent child in ApplicationContext.Services.ContentService.GetChildren(node.Id))
        {
            GetNode(child);
        }
    }
}

The GetAll method, iterates through all the nodes in the content section and finds the ones that are not published, that is, that are waiting approval.

With these two classes we are able to populate our section with a tree containing the content nodes that are waiting approval:

The next post in the series will show how to create the Angular view and controller that will enable content managers to actually manage the content waiting approval.

The Approve It extension can be found here: https://our.umbraco.org/projects/backoffice-extensions/approve-it/. The complete source code can be found here: https://github.com/ViGiLnT/ApproveIt.

The post Building an Umbraco 7 backoffice extension – Part II appeared first on Blog IT.

The next series of posts will show how to build plugins that extend the default Umbraco backoffice capabilities.

How is it built?

The release of Umbraco’s version 7 presented a completely redesigned backoffice. It went from a  typical MVC website to a single page application built using AngularJS. Umbraco custom WebAPIs are used by Angular controllers in order to read information from the backoffice.

How can we change it?

A typical Umbraco 7 backoffice extension requires:

1. Creation of Angular controllers, views and probably models;
2. Umbraco WebAPI extensions in order to access Umbraco’s backoffice and for custom server side development;
3. Extension of some Umbraco classes to customize common backoffice functionalities.

What to do?

These series of posts will gradually present a way to build a new backoffice section, that will provide content managers with a centralized area where they can approve changes made to content. This backoffice extension was named Approve It. Natively, Umbraco sends an email to each content approver when changes are made to content nodes but, if an approver wants to see what nodes were updated just by visiting the backoffice, he must traverse every node to see which ones present a change waiting approval. This gets harder as the number of content nodes increase, and the changed nodes can be difficult to spot as we can see from the image below:

Preparing the development environment

1. Download the latest and greatest version of Umbraco 7 (currently at v7.3.1): https://our.umbraco.org/contribute/releases/731/ 
2. Download and setup WebMatrix: http://www.microsoft.com/web/webmatrix/
3. Create a new web site in WebMatrix selecting the folder which contains Umbraco’s downloaded .zip file contents and go through the Setup
   1. Select customize
   2. Use a SQL CE database
   3. Choose any starter kit (I chose Txt Starter Kit)
4. Create a new Empty ASP.NET project in Visual Studio (I’m using VS2015) and add folders and core references for MVC

Creating a new backoffice section

Creating a new section in Umbraco is easy:

1. Add references to the following three assemblies available in the bin Umbraco directory:
   • businesslogic.dll
   • interfaces.dll
   • System.Web.Mvc.dll (need to replace the one Visual Studio automatically referenced)
2. Create a new .cs file in the project with the following code:

[Application("approveIt", "ApproveIt", "icon-people", 15)]
public class Section : IApplication
{
}

Simply implementing the IApplication interface, creates a new Umbraco backoffice section with the properties defined above.

The next step is translating the section name. If we don’t translate it, it will show up as [approveIt]. So, we must edit the file \Umbraco\Config\Lang\en.xml (for the UK version), and append the “approveIt” line in the “sections” area:

<area alias="sections">
  <key alias="concierge">Concierge</key>
  <key alias="content">Content</key>
  <key alias="courier">Courier</key>
  <key alias="developer">Developer</key>
  <key alias="installer">Umbraco Configuration Wizard</key>
  <key alias="media">Media</key>
  <key alias="member">Members</key>
  <key alias="newsletters">Newsletters</key>
  <key alias="settings">Settings</key>
  <key alias="statistics">Statistics</key>
  <key alias="translation">Translation</key>
  <key alias="users">Users</key>
  <key alias="help" version="7.0">Help</key>
  <key alias="forms">Forms</key>
  <key alias="analytics">Analytics</key>
  <key alias="approveIt">Approve It</key>
</area>

Note: for the new section to appear you must add it to the available sections your user can see. Furthermore, because of caching, you probably need to restart the website and open a browser window in private mode in order to see the new section.

This is how it looks:

So, we have a new section, but there’s nothing we can do with it. The next post in the series will show how we can add some content to this newly created Umbraco backoffice area.

The Approve It extension can be found here: https://our.umbraco.org/projects/backoffice-extensions/approve-it/. The complete source code can be found here: https://github.com/ViGiLnT/ApproveIt.

The post Building an Umbraco 7 backoffice extension – Part I appeared first on Blog IT.