public class Global : UmbracoApplication, IContainerProviderAccessor // IContentProviderAccessor is required for WebForms dependency injection
{
    protected override void OnApplicationError(object sender, EventArgs e)
    {
        var exception = Server.GetLastError();
        var httpException = exception as HttpException;
        if (httpException != null && httpException.GetHttpCode() >= 500)
        {
            Log.Error(httpException, "Application error");
        }
    }
    protected override IBootManager GetBootManager()
    {
        return new WebBootManager(this);
    }

    static IContainerProvider _containerProvider;
    public IContainerProvider ContainerProvider
    {
        get { return _containerProvider; }
    }

    // Equivalent of Application_Start
    protected override void OnApplicationStarted(object sender, EventArgs e)
    {
        base.OnApplicationStarted(sender, e);

        var runtimeEnvironment = ConfigurationManager.AppSettings["Environment"];
        var seqUrl = ConfigurationManager.AppSettings["SeqUrl"];

        var log = new LoggerConfiguration()
            .MinimumLevel.Is(LogEventLevel.Debug)
            .Enrich.WithProcessId()
            .Enrich.WithProperty("MachineName", Environment.MachineName)
            .Enrich.WithProperty("Source", "Umbraco Web")
            .Enrich.WithProperty("Environment", runtimeEnvironment)
            .Enrich.With<UserNameEnricher>()
            .Enrich.With<HttpRequestUrlEnricher>()
            .Enrich.With<HttpRequestUserAgentEnricher>()
            .Enrich.With<HttpSessionIdEnricher>()
            .Enrich.With<HttpRequestIdEnricher>()
            .Enrich.FromLogContext()
            .WriteTo.Seq(seqUrl)
            .CreateLogger();
        Log.Logger = log;

        var builder = new ContainerBuilder();
        var config = GlobalConfiguration.Configuration;

        // Register Umbraco Context, MVC Controllers and API Controllers.
        builder.Register(c => UmbracoContext.Current).AsSelf();
        builder.Register(c => ApplicationContext.Current.Services.ContentService).As<Umbraco.Core.Services.IContentService>();

        builder.RegisterControllers(Assembly.GetExecutingAssembly()); // Register our MVC controllers
        builder.RegisterApiControllers(typeof(UmbracoApplication).Assembly); // Register umbraco backoffice controllers
        builder.RegisterApiControllers(typeof(Global).Assembly); // Register our API controllers

        builder.RegisterInstance(log).As<ILogger>();
        builder.Register(c => new HttpContextWrapper(HttpContext.Current)).As<HttpContextBase>();
        //builder.RegisterType<PagingService>().As<IPagingService>();
        //builder.RegisterType<WebApiCsvGenerator>().As<IWebApiCsvGenerator>();

        var container = builder.Build();
        _containerProvider = new ContainerProvider(container);
        config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

        RouteConfig.RegisterRoutes(RouteTable.Routes);
        DependencyResolver.SetResolver(new AutofacDependencyResolver(_containerProvider.ApplicationContainer));

        AppDomain.CurrentDomain.UnhandledException += (s, args) =>
        {
            var exp = (Exception)args.ExceptionObject;
            Log.Error(exp, "Unhandled exception");
        };

        Log.Information("Website Started.");
    }
}

$siteRoot = $OctopusParameters['Octopus.Action[Deploy Step Name].Output.Package.InstallationDirectoryPath']
$siteName = $OctopusParameters["Site name"]
$configPath = Join-Path $siteRoot 'config'
$appDataPath = Join-Path $siteRoot 'App_Data'

Write-Host $SiteName

$acl = Get-ACL $configPath
$accessRule= New-Object System.Security.AccessControl.FileSystemAccessRule(`
    "IIS APPPOOL\$siteName", `
    "full", `
    "ContainerInherit,Objectinherit", `
    "InheritOnly", `
    "Allow")
$acl.AddAccessRule($accessRule)
Set-Acl $configPath $acl

$acl2 = Get-ACL $appDataPath
$accessRule2= New-Object System.Security.AccessControl.FileSystemAccessRule(`
    "IIS APPPOOL\$siteName", `
    "full", `
    "ContainerInherit,Objectinherit", `
    "InheritOnly", `
    "Allow")
$acl.AddAccessRule($accessRule2)
Set-Acl $appDataPath $acl2

[Application("CommerceManagement", "CommerceManagement", "management.gif", 15)]
public class CommerceManagementApplication : IApplication
{
}

[PluginController("CustomSection")]
[Umbraco.Web.Trees.Tree("CustomSection", "CustomSectionTree", "Custom Section", iconClosed: "icon-doc")]
public class CommerceManagementTreeController : TreeController
{
    protected override TreeNodeCollection GetTreeNodes(string id, FormDataCollection queryStrings)
    {
        var nodes = new TreeNodeCollection();

        // Create a new node in the menu tree, that will open the specified url
        var item = this.CreateTreeNode("1a", id, queryStrings, "Find Custom Item", "developerMacro.gif", false, "CustomSection/CustomSectionTree/FindItem/0");
        nodes.Add(item);

        return nodes;
    }
    protected override MenuItemCollection GetMenuForNode(string id, FormDataCollection queryStrings)
    {
        var menu = new MenuItemCollection();
        menu.DefaultMenuAlias = ActionNew.Instance.Alias;
        return menu;
    }
}

angular.module('umbraco.resources').factory('customItemResource',
    function ($q, $http, umbRequestHelper) {
        //the factory object returned
        return {
            getItem: function () {
                return umbRequestHelper.resourcePromise(
                    $http.get("backoffice/api/CustomItem/GetItems"),
                    "Failed to retrieve Items");
            },
            getItemsCsv: function () {
                return $http.get("backoffice/api/CustomItem/GetItemsCsv");
            },
            getItem: function (id) {
                return umbRequestHelper.resourcePromise(
                    $http.get("backoffice/api/CustomItem/GetItem/" + id),
                    "Failed to retrieve CustomItem");
            },
            updateItem: function (id, updatedCustomItem) {
                return umbRequestHelper.resourcePromise(
                    $http.get("backoffice/api/Brand/CustomItem/" + id, updatedCustomItem),
                    "Failed to update CustomItem");
            },
        }
    });

<div class="umb-panel umb-editor-wrapper" ng-controller="CustomSection.ListCustomItemController as vm">
    <form name="mySectionForm" novalidate ng-submit="vm.search()">
        <umb-editor-view>
            <umb-editor-header name="vm.pageName"
                               hide-alias="true"
                               hide-description="true"
                               hide-icon="true"
                               name-locked="true">
            </umb-editor-header>

            <umb-editor-container>
                <div class="form-horizontal">
                    <umbraco-property title="Search Criteria">
                        <input type="text" ng-model="vm.searchCriteria.searchProperty" />
                    </umbraco-property>
                    <button type="submit" class="btn">Search</button>
                    <button type="button" class="btn" ng-click="vm.clear()">Clear</button>
                    <record-count total-items="vm.totalItems" page-number="vm.page" page-count="vm.pageCount"></record-count>

                    <umb-load-indicator ng-if="vm.loading">
                    </umb-load-indicator>
                    <div ng-if="!vm.loading">
                        <table class="table table-striped" cellspacing="0" cellpadding="5px">
                            <thead>
                                <tr>
                                    <th class="firstCol"><a ng-click="vm.sortBy('id')">Id</a></th>
                                    <th class="big-col"><a ng-click="vm.sortBy('name')">Name</a></th>
                                    <th class="small-col">Edit</th>
                                </tr>
                            </thead>
                            <tbody>
                                <tr ng-repeat="searchResult in vm.searchResults">
                                    <td class="firstCol"></td>

                                    <td></td>
                                    <td><a ng-href="#/CustomSection/CustomSectionTree/EditCustomItem/">Edit</a></td>
                                </tr>
                            </tbody>
                        </table>
                        <umb-pagination ng-if="vm.pageCount"
                                        page-number="vm.currentPage"
                                        total-pages="vm.pageCount"
                                        on-go-to-page="vm.goToPage"
                                        on-next="vm.next"
                                        on-prev="vm.prev">
                        </umb-pagination>

                    </div>
                </div>
            </umb-editor-container>
        </umb-editor-view>
    </form>
</div>

<div class="custom-editor" ng-controller="CustomSection.EditCustomItemController as vm">
    <form name="editForm" val-form-manager novalidate>
        <umb-editor-view>
            <umb-editor-header name="vm.pageName"
                               hide-alias="true"
                               hide-description="true"
                               hide-icon="true"
                               name-locked="true">
            </umb-editor-header>
            <umb-editor-container>
                <div class="form-horizontal">
                    <umb-load-indicator ng-if="vm.loading">
                    </umb-load-indicator>
                    <div ng-if="!vm.loading">
                        <div class="well">
                            <p>Sample editing page</p>
                        </div>
                        <div class="form-horizontal">
                            <umbraco-property title="Item Id">
                                
                            </umbraco-property>
                            <umbraco-property title="Name">
                                <input type="text" ng-model="vm.customItem.Name"/>
                            </umbraco-property>
                        </div>
                    </div>
                </div>
            </umb-editor-container>
            <umb-editor-footer>
                <umb-editor-footer-content-left>
                    <a href="#/CustomSection/CustomSectionTree/ListCustomItem/0">Back to search</a>
                </umb-editor-footer-content-left>
                <umb-editor-footer-content-right>
                    <button type="button" class="btn btn-success" ng-disabled="!editForm.$valid || vm.loading" ng-click="vm.save(editForm)" hotkey="ctrl+s">Save</button>
                </umb-editor-footer-content-right>
            </umb-editor-footer>
        </umb-editor-view>
    </form>
</div>

public class PagingService : IPagingService
{
    public int GetLastPage(int totalItems, PagedRequest request)
    {
        return (int)Math.Ceiling((decimal)totalItems / request.PageSize);
    }

    public int BoundPageNumber(int totalItems, int page, int lastPage)
    {
        if (page > lastPage)
            page = lastPage;
        if (page < 1)
            page = 1;
        return page;
    }
}

public enum SortDirection
{
    ASC,
    DESC
}

public class PagedRequest
{
    public PagedRequest()
    {
        Page = 1;
        SortBy = string.Empty;
        SortDirection = SortDirection.ASC;
        PageSize = Constants.DefaultPageSize;
    }

    public int Page { get; set; }
    public string SortBy { get; set; }
    public SortDirection SortDirection { get; set; }
    public int PageSize { get; set; }
}

public class PagedListResponse<T>
{
    public PagedListResponse(List<T> list, int pageNumber, int pageCount, int totalItems)
    {
        List = list;
        PageNumber = pageNumber;
        PageCount = pageCount;
        TotalItems = totalItems;
    }

    public List<T> List { get;  } 
    public int PageNumber { get; }
    public int PageCount { get; }
    public int TotalItems { get;  }
}

public abstract class BackofficeApiController : UmbracoAuthorizedJsonController
{
    private readonly IPagingService _pagingService;

    protected BackofficeApiController(IPagingService pagingService)
    {
        _pagingService = pagingService;
    }

    protected PagedListResponse<T> GetResponse<T>(PagedRequest request, int totalItems, IEnumerable<T> results)
    {
        var lastPage = _pagingService.GetLastPage(totalItems, request);
        var list = results.ToList();
        var pageNumber = _pagingService.BoundPageNumber(totalItems, request.Page, lastPage);

        return new PagedListResponse<T>(list, pageNumber, lastPage, totalItems);
    }
}

public class CustomItemRequest : PagedRequest
{
    public string SearchProperty { get; set; }
}

public class CustomItemController : BackofficeApiController
{
    private List<CustomItem> _items = new List<CustomItem>();


    public CustomItemController(IPagingService pagingService) : base(pagingService)
    {
        for (int i = 0; i < 100; i++)
        {
            _items.Add(new CustomItem
            {
                Id = i,
                Name = $"Item {i}"
            });
        }
    }

    [HttpGet]
    public PagedListResponse<CustomItem> GetCustomItems([FromUri]CustomItemRequest request)
    {
        IEnumerable<CustomItem> results = _items;
        if (!string.IsNullOrWhiteSpace(request.SearchProperty))
        {
            results = results.Where(r => r.Name.Contains(request.SearchProperty));
        }
        var totalItemCount = results.Count();
        var startAt = (request.Page - 1) * request.PageSize;

        var pageResult = results.Skip(startAt).Take(request.PageSize);

        return GetResponse(request, totalItemCount, pageResult);
    }

    [HttpGet]
    public CustomItem GetCustomItem(int id)
    {
        return _items.FirstOrDefault(i => i.Id == id);
    }

    [HttpPost]
    public void UpdateCustomItem(int id, CustomItem model)
    {
        // Not actually updating anything
    }
}