/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* global define, module, require, exports */

(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        define(['jquery',
                'd3',
                'nf.ErrorHandler',
                'nf.Common',
                'nf.Dialog',
                'nf.Storage',
                'nf.Client',
                'nf.Settings',
                'nf.UniversalCapture',
                'nf.CustomUi',
                'nf.CanvasUtils',
                'nf.Processor'],
            function ($, d3, nfErrorHandler, nfCommon, nfDialog, nfStorage, nfClient, nfSettings, nfUniversalCapture, nfCustomUi, nfCanvasUtils, nfProcessor) {
                return (nf.ControllerService = factory($, d3, nfErrorHandler, nfCommon, nfDialog, nfStorage, nfClient, nfSettings, nfUniversalCapture, nfCustomUi, nfCanvasUtils, nfProcessor));
            });
    } else if (typeof exports === 'object' && typeof module === 'object') {
        module.exports = (nf.ControllerService =
            factory(require('jquery'),
                require('d3'),
                require('nf.ErrorHandler'),
                require('nf.Common'),
                require('nf.Dialog'),
                require('nf.Storage'),
                require('nf.Client'),
                require('nf.Settings'),
                require('nf.UniversalCapture'),
                require('nf.CustomUi'),
                require('nf.CanvasUtils'),
                require('nf.Processor')));
    } else {
        nf.ControllerService = factory(root.$,
            root.d3,
            root.nf.ErrorHandler,
            root.nf.Common,
            root.nf.Dialog,
            root.nf.Storage,
            root.nf.Client,
            root.nf.Settings,
            root.nf.UniversalCapture,
            root.nf.CustomUi,
            root.nf.CanvasUtils,
            root.nf.Processor);
    }
}(this, function ($, d3, nfErrorHandler, nfCommon, nfDialog, nfStorage, nfClient, nfSettings, nfUniversalCapture, nfCustomUi, nfCanvasUtils, nfProcessor) {
    'use strict';

    var nfControllerServices, nfReportingTask;

    var config = {
        edit: 'edit',
        readOnly: 'read-only',
        serviceOnly: 'SERVICE_ONLY',
        serviceAndReferencingComponents: 'SERVICE_AND_REFERENCING_COMPONENTS',
        urls: {
            api: '../nifi-api'
        }
    };

    /**
     * Determines whether the user has made any changes to the controller service configuration
     * that needs to be saved.
     */
    var isSaveRequired = function () {
        var entity = $('#controller-service-configuration').data('controllerServiceDetails');

        // determine if any controller service settings have changed

        if ($('#controller-service-name').val() !== entity.component['name']) {
            return true;
        }
        if ($('#controller-service-comments').val() !== entity.component['comments']) {
            return true;
        }

        // defer to the properties
        return $('#controller-service-properties').propertytable('isSaveRequired');
    };

    /**
     * Marshals the data that will be used to update the contr oller service's configuration.
     */
    var marshalDetails = function () {
        // properties
        var properties = $('#controller-service-properties').propertytable('marshalProperties');

        // create the controller service dto
        var controllerServiceDto = {};
        controllerServiceDto['id'] = $('#controller-service-id').text();
        controllerServiceDto['name'] = $('#controller-service-name').val();
        controllerServiceDto['comments'] = $('#controller-service-comments').val();

        // set the properties
        if ($.isEmptyObject(properties) === false) {
            controllerServiceDto['properties'] = properties;
        }

        // create the controller service entity
        var controllerServiceEntity = {};
        controllerServiceEntity['disconnectedNodeAcknowledged'] = nfStorage.isDisconnectionAcknowledged();
        controllerServiceEntity['component'] = controllerServiceDto;

        // return the marshaled details
        return controllerServiceEntity;
    };

    /**
     * Validates the specified details.
     *
     * @argument {object} details       The details to validate
     */
    var validateDetails = function (details) {
        return true;
    };

    /**
     * Reloads the specified controller service if we have read permissions. It's referencing and referenced
     * components are NOT reloaded.
     *
     * @param {jQuery} serviceTable
     * @param {string} id
     */
    var reloadControllerService = function (serviceTable, id) {
        // get the table and update the row accordingly
        var controllerServiceGrid = serviceTable.data('gridInstance');
        var controllerServiceData = controllerServiceGrid.getData();
        var controllerServiceEntity = controllerServiceData.getItemById(id);

        // this may happen if controller service A references another controller
        // service B that has been removed. attempting to enable/disable/remove A
        // will attempt to reload B which is no longer a known service. also ensure
        // we have permissions to reload the service
        if (nfCommon.isUndefined(controllerServiceEntity) || controllerServiceEntity.permissions.canRead === false) {
            return $.Deferred(function (deferred) {
                deferred.reject();
            }).promise();
        }

        return $.ajax({
            type: 'GET',
            url: controllerServiceEntity.uri,
            dataType: 'json'
        }).done(function (response) {
            renderControllerService(serviceTable, response);
        }).fail(nfErrorHandler.handleAjaxError);
    };

    /**
     * Renders the specified controller service.
     *
     * @param {object} serviceTable
     * @param {object} controllerServiceEntity
     */
    var renderControllerService = function (serviceTable, controllerServiceEntity) {
        // get the table and update the row accordingly
        var controllerServiceGrid = serviceTable.data('gridInstance');
        var controllerServiceData = controllerServiceGrid.getData();
        var currentControllerServiceEntity = controllerServiceData.getItemById(controllerServiceEntity.id);
        controllerServiceData.updateItem(controllerServiceEntity.id, $.extend({
            type: 'ControllerService',
            bulletins: currentControllerServiceEntity.bulletins
        }, controllerServiceEntity));
    };

    /**
     * Reloads the specified controller services and all of its referencing
     * and referenced components.
     *
     * @param {jQuery} serviceTable
     * @param {type} controllerService
     */
    var reloadControllerServiceAndReferencingComponents = function (serviceTable, controllerService) {
        reloadControllerService(serviceTable, controllerService.id).done(function (response) {
            reloadControllerServiceReferences(serviceTable, response.component);
        });
    };

    /**
     * Reloads components that reference this controller service as well as
     * other services that this controller service references.
     *
     * @param {jQuery} serviceTable
     * @param {object} controllerService
     */
    var reloadControllerServiceReferences = function (serviceTable, controllerService) {
        // reload all dependent processors if they are currently visible
        $.each(controllerService.referencingComponents, function (_, referencingComponentEntity) {
            // ensure we can read the referencing component prior to reloading
            if (referencingComponentEntity.permissions.canRead === false) {
                return;
            }

            var reference = referencingComponentEntity.component;
            if (reference.referenceType === 'Processor') {
                // reload the processor on the canvas if appropriate
                if (nfCanvasUtils.getGroupId() === reference.groupId) {
                    nfProcessor.reload(reference.id);
                }

                // update the current active thread count
                $('div.' + reference.id + '-active-threads').text(reference.activeThreadCount);

                // update the current state of this processor
                var referencingComponentState = $('div.' + reference.id + '-state');
                if (referencingComponentState.length) {
                    updateReferencingSchedulableComponentState(referencingComponentState, reference);
                }
            } else if (reference.referenceType === 'ReportingTask') {
                // reload the referencing reporting tasks
                nfReportingTask.reload(reference.id);

                // update the current active thread count
                $('div.' + reference.id + '-active-threads').text(reference.activeThreadCount);

                // update the current state of this reporting task
                var referencingComponentState = $('div.' + reference.id + '-state');
                if (referencingComponentState.length) {
                    updateReferencingSchedulableComponentState(referencingComponentState, reference);
                }
            } else {
                // reload the referencing services
                reloadControllerService(serviceTable, reference.id);

                // update the current state of this service
                var referencingComponentState = $('div.' + reference.id + '-state');
                if (referencingComponentState.length) {
                    updateReferencingServiceState(referencingComponentState, reference);
                }

                // consider it's referencing components if appropriate
                if (reference.referenceCycle === false) {
                    reloadControllerServiceReferences(serviceTable, reference);
                }
            }
        });

        // see if this controller service references another controller service
        // in order to update the referenced service referencing components
        nfControllerService.reloadReferencedServices(serviceTable, controllerService);
    };

    /**
     * Adds a border to the controller service referencing components if necessary.
     *
     * @argument {jQuery} referenceContainer
     */
    var updateReferencingComponentsBorder = function (referenceContainer) {
        // determine if it is too big
        var tooBig = referenceContainer.get(0).scrollHeight > Math.round(referenceContainer.innerHeight()) ||
            referenceContainer.get(0).scrollWidth > Math.round(referenceContainer.innerWidth());

        // draw the border if necessary
        if (referenceContainer.is(':visible') && tooBig) {
            referenceContainer.css('border-width', '1px');
        } else {
            referenceContainer.css('border-width', '0px');
        }
    };

    /**
     * Updates the specified bulletinIcon with the specified bulletins if necessary.
     *
     * @param {array} bulletins
     * @param {jQuery} bulletinIcon
     */
    var updateBulletins = function (bulletins, bulletinIcon) {
        var currentBulletins = bulletinIcon.data('bulletins');

        // update the bulletins if necessary
        if (nfCommon.doBulletinsDiffer(currentBulletins, bulletins)) {
            bulletinIcon.data('bulletins', bulletins);

            // format the new bulletins
            var formattedBulletins = nfCommon.getFormattedBulletins(bulletins);

            // if there are bulletins update them
            if (bulletins.length > 0) {
                var list = nfCommon.formatUnorderedList(formattedBulletins);

                // update existing tooltip or initialize a new one if appropriate
                if (bulletinIcon.data('qtip')) {
                    bulletinIcon.qtip('option', 'content.text', list);
                } else {
                    bulletinIcon.addClass('has-bulletins').show().qtip($.extend({},
                        nfCanvasUtils.config.systemTooltipConfig,
                        {
                            content: list
                        }));
                }
            } else if (bulletinIcon.data('qtip')) {
                bulletinIcon.removeClass('has-bulletins').removeData('bulletins').hide().qtip('api').destroy(true);
            }
        }
    };

    /**
     * Updates the referencingComponentState using the specified referencingComponent.
     *
     * @param {jQuery} referencingComponentState
     * @param {object} referencingComponent
     */
    var updateReferencingSchedulableComponentState = function (referencingComponentState, referencingComponent) {
        referencingComponentState.removeClass('disabled stopped running invalid').addClass(function () {
            var icon = $(this);

            var state = referencingComponent.state.toLowerCase();
            if (state === 'stopped' && !nfCommon.isEmpty(referencingComponent.validationErrors)) {
                state = 'invalid';

                // add tooltip for the warnings
                var list = nfCommon.formatUnorderedList(referencingComponent.validationErrors);
                if (icon.data('qtip')) {
                    icon.qtip('option', 'content.text', list);
                } else {
                    icon.qtip($.extend({},
                        nfCanvasUtils.config.systemTooltipConfig,
                        {
                            content: list
                        }));
                }
            } else if (icon.data('qtip')) {
                icon.qtip('api').destroy(true);
            }
            return state;
        });
    };

    /**
     * Updates the referencingServiceState using the specified referencingService.
     *
     * @param {jQuery} referencingServiceState
     * @param {object} referencingService
     */
    var updateReferencingServiceState = function (referencingServiceState, referencingService) {
        referencingServiceState.removeClass('disabled enabled invalid').addClass(function () {
            var icon = $(this);

            var state = referencingService.state === 'ENABLED' ? 'enabled' : 'disabled';
            if (state === 'disabled' && !nfCommon.isEmpty(referencingService.validationErrors)) {
                state = 'invalid';

                // add tooltip for the warnings
                var list = nfCommon.formatUnorderedList(referencingService.validationErrors);
                if (icon.data('qtip')) {
                    icon.qtip('option', 'content.text', list);
                } else {
                    icon.qtip($.extend({},
                        nfCanvasUtils.config.systemTooltipConfig,
                        {
                            content: list
                        }));
                }
            } else if (icon.data('qtip')) {
                icon.qtip('api').destroy(true);
            }
            return state;
        });
    };

    /**
     * Updates the bulletins for all referencing components.
     *
     * @param {array} bulletins
     */
    var updateReferencingComponentBulletins = function (bulletins) {
        var bulletinsBySource = d3.nest()
            .key(function (d) {
                return d.sourceId;
            })
            .map(bulletins, d3.map);

        bulletinsBySource.each(function (sourceBulletins, sourceId) {
            $('div.' + sourceId + '-bulletins').each(function () {
                updateBulletins(sourceBulletins, $(this));
            });
        });
    };

    /**
     * Adds the specified reference for this controller service.
     *
     * @param {jQuery} serviceTable
     * @param {jQuery} referenceContainer
     * @param {object} controllerServiceEntity
     */
    var createReferencingComponents = function (serviceTable, referenceContainer, controllerServiceEntity) {

        if (controllerServiceEntity.permissions.canRead === false) {
            referenceContainer.append('<div class="unset">Unauthorized</div>');
            return;
        }

        var referencingComponents = controllerServiceEntity.component.referencingComponents;
        if (nfCommon.isEmpty(referencingComponents)) {
            referenceContainer.append('<div class="unset">No referencing components.</div>');
            return;
        }

        // toggles the visibility of a container
        var toggle = function (twist, container) {
            if (twist.hasClass('expanded')) {
                twist.removeClass('expanded').addClass('collapsed');
                container.hide();
            } else {
                twist.removeClass('collapsed').addClass('expanded');
                container.show();
            }
        };

        var processors = $('<ul class="referencing-component-listing clear"></ul>');
        var services = $('<ul class="referencing-component-listing clear"></ul>');
        var tasks = $('<ul class="referencing-component-listing clear"></ul>');
        var unauthorized = $('<ul class="referencing-component-listing clear"></ul>');
        $.each(referencingComponents, function (_, referencingComponentEntity) {
            // check the access policy for this referencing component
            if (referencingComponentEntity.permissions.canRead === false) {
                var unauthorizedReferencingComponent = $('<div class="unset"></div>').text(referencingComponentEntity.id);
                unauthorized.append(unauthorizedReferencingComponent);
            } else {
                var referencingComponent = referencingComponentEntity.component;

                if (referencingComponent.referenceType === 'Processor') {
                    var processorLink = $('<span class="referencing-component-name link"></span>').text(referencingComponent.name).on('click', function () {
                        // show the component
                        nfCanvasUtils.showComponent(referencingComponent.groupId, referencingComponent.id);

                        // close the dialog and shell
                        referenceContainer.closest('.dialog').modal('hide');
                        $('#shell-close-button').click();
                    });

                    // state
                    var processorState = $('<div class="referencing-component-state"></div>').addClass(referencingComponent.id + '-state');
                    updateReferencingSchedulableComponentState(processorState, referencingComponent);

                    // bulletin
                    var processorBulletins = $('<div class="referencing-component-bulletins"></div>').addClass(referencingComponent.id + '-bulletins');
                    if (!nfCommon.isEmpty(referencingComponentEntity.bulletins)) {
                        updateBulletins(referencingComponentEntity.bulletins, processorBulletins);
                    }

                    // type
                    var processorType = $('<span class="referencing-component-type"></span>').text(referencingComponent.type);

                    // active thread count
                    var processorActiveThreadCount = $('<span class="referencing-component-active-thread-count"></span>').addClass(referencingComponent.id + '-active-threads');
                    if (nfCommon.isDefinedAndNotNull(referencingComponent.activeThreadCount) && referencingComponent.activeThreadCount > 0) {
                        processorActiveThreadCount.text('(' + referencingComponent.activeThreadCount + ')');
                    }

                    // processor
                    var processorItem = $('<li></li>').append(processorState).append(processorBulletins).append(processorLink).append(processorType).append(processorActiveThreadCount);
                    processors.append(processorItem);
                } else if (referencingComponent.referenceType === 'ControllerService') {
                    var serviceLink = $('<span class="referencing-component-name link"></span>').text(referencingComponent.name).on('click', function () {
                        var controllerServiceGrid = serviceTable.data('gridInstance');
                        var controllerServiceData = controllerServiceGrid.getData();

                        // select the selected row
                        var row = controllerServiceData.getRowById(referencingComponent.id);
                        controllerServiceGrid.setSelectedRows([row]);
                        controllerServiceGrid.scrollRowIntoView(row);

                        // close the dialog and shell
                        referenceContainer.closest('.dialog').modal('hide');
                    });

                    // container for this service's references
                    var referencingServiceReferencesContainer = $('<div class="referencing-component-references hidden"></div>');
                    var serviceTwist = $('<div class="service expansion-button collapsed pointer"></div>').on('click', function () {
                        if (serviceTwist.hasClass('collapsed')) {
                            // create the markup for the references
                            if (referencingComponent.referenceCycle === true) {
                                referencingServiceReferencesContainer.append('<div class="unset">Reference cycle detected.</div>');
                            } else {
                                var controllerServiceGrid = serviceTable.data('gridInstance');
                                var controllerServiceData = controllerServiceGrid.getData();

                                // get the controller service and expand its referencing services
                                getControllerService(referencingComponent.id, controllerServiceData).done(function (controllerServiceEntity) {
                                    createReferencingComponents(serviceTable, referencingServiceReferencesContainer, controllerServiceEntity);
                                });
                            }
                        } else {
                            referencingServiceReferencesContainer.empty();
                        }

                        // toggle visibility
                        toggle(serviceTwist, referencingServiceReferencesContainer);

                        // update borders as necessary
                        updateReferencingComponentsBorder(referenceContainer);
                    });

                    // state
                    var serviceState = $('<div class="referencing-component-state"></div>').addClass(referencingComponent.id + '-state');
                    updateReferencingServiceState(serviceState, referencingComponent);

                    // bulletin
                    var serviceBulletins = $('<div class="referencing-component-bulletins"></div>').addClass(referencingComponent.id + '-bulletins');
                    if (!nfCommon.isEmpty(referencingComponentEntity.bulletins)) {
                        updateBulletins(referencingComponentEntity.bulletins, serviceBulletins);
                    }

                    // type
                    var serviceType = $('<span class="referencing-component-type"></span>').text(referencingComponent.type);

                    // service
                    var serviceItem = $('<li></li>').append(serviceTwist).append(serviceState).append(serviceBulletins).append(serviceLink).append(serviceType).append(referencingServiceReferencesContainer);

                    services.append(serviceItem);
                } else if (referencingComponent.referenceType === 'ReportingTask') {
                    var reportingTaskLink = $('<span class="referencing-component-name link"></span>').text(referencingComponent.name).on('click', function () {
                        var reportingTaskGrid = $('#reporting-tasks-table').data('gridInstance');
                        var reportingTaskData = reportingTaskGrid.getData();

                        // select the selected row
                        var row = reportingTaskData.getRowById(referencingComponent.id);
                        reportingTaskGrid.setSelectedRows([row]);
                        reportingTaskGrid.scrollRowIntoView(row);

                        // select the reporting task tab
                        $('#settings-tabs').find('li:nth-child(3)').click();

                        // close the dialog and shell
                        referenceContainer.closest('.dialog').modal('hide');
                    });

                    // state
                    var reportingTaskState = $('<div class="referencing-component-state"></div>').addClass(referencingComponent.id + '-state');
                    updateReferencingSchedulableComponentState(reportingTaskState, referencingComponent);

                    // bulletins
                    var reportingTaskBulletins = $('<div class="referencing-component-bulletins"></div>').addClass(referencingComponent.id + '-bulletins');
                    if (!nfCommon.isEmpty(referencingComponentEntity.bulletins)) {
                        updateBulletins(referencingComponentEntity.bulletins, reportingTaskBulletins);
                    }

                    // type
                    var reportingTaskType = $('<span class="referencing-component-type"></span>').text(nfCommon.substringAfterLast(referencingComponent.type, '.'));

                    // active thread count
                    var reportingTaskActiveThreadCount = $('<span class="referencing-component-active-thread-count"></span>').addClass(referencingComponent.id + '-active-threads');
                    if (nfCommon.isDefinedAndNotNull(referencingComponent.activeThreadCount) && referencingComponent.activeThreadCount > 0) {
                        reportingTaskActiveThreadCount.text('(' + referencingComponent.activeThreadCount + ')');
                    }

                    // reporting task
                    var reportingTaskItem = $('<li></li>').append(reportingTaskState).append(reportingTaskBulletins).append(reportingTaskLink).append(reportingTaskType).append(reportingTaskActiveThreadCount);
                    tasks.append(reportingTaskItem);
                }
            }
        });

        // create the collapsable listing for each type
        var createReferenceBlock = function (titleText, list) {
            if (list.is(':empty')) {
                list.remove();
                return;
            }

            var twist = $('<div class="expansion-button expanded"></div>');
            var title = $('<span class="referencing-component-title"></span>').text(titleText);
            var count = $('<span class="referencing-component-count"></span>').text('(' + list.children().length + ')');

            // create the reference block
            $('<div class="referencing-component-block pointer unselectable"></div>').on('click', function () {
                // toggle this block
                toggle(twist, list);

                // update the border if necessary
                updateReferencingComponentsBorder(referenceContainer);
            }).append(twist).append(title).append(count).appendTo(referenceContainer);

            // add the listing
            list.appendTo(referenceContainer);
        };

        // create blocks for each type of component
        createReferenceBlock('Processors', processors);
        createReferenceBlock('Reporting Tasks', tasks);
        createReferenceBlock('Controller Services', services);
        createReferenceBlock('Unauthorized', unauthorized);

        // now that the dom elements are in place, we can show the bulletin icons.
        $('div.referencing-component-bulletins.has-bulletins').show();
    };

    /**
     * Sets whether the specified controller service is enabled.
     *
     * @param {jQuery} serviceTable
     * @param {object} controllerServiceEntity
     * @param {boolean} enabled
     * @param {function} pollCondition
     */
    var setEnabled = function (serviceTable, controllerServiceEntity, enabled, pollCondition) {
        // build the request entity
        var updateControllerServiceEntity = {
            'revision': nfClient.getRevision(controllerServiceEntity),
            'disconnectedNodeAcknowledged': nfStorage.isDisconnectionAcknowledged(),
            'state': enabled ? 'ENABLED' : 'DISABLED'
        };

        var updated = $.ajax({
            type: 'PUT',
            url: controllerServiceEntity.uri + '/run-status',
            data: JSON.stringify(updateControllerServiceEntity),
            dataType: 'json',
            contentType: 'application/json'
        }).done(function (response) {
            renderControllerService(serviceTable, response);
        }).fail(nfErrorHandler.handleAjaxError);

        // wait until the polling of each service finished
        return $.Deferred(function (deferred) {
            updated.done(function () {
                if (controllerServiceEntity.permissions.canRead === false) {
                    // Can not use GET request to wait for completion. Just resolve blindly. The PUT request has been finished anyway.
                    deferred.resolve();
                    return;
                }

                var serviceUpdated = pollService(controllerServiceEntity, function (latestControllerServiceEntity, bulletins) {
                    if ($.isArray(bulletins)) {
                        if (enabled) {
                            updateBulletins(bulletins, $('#enable-controller-service-bulletins'));
                        } else {
                            updateBulletins(bulletins, $('#disable-controller-service-bulletins'));
                        }
                    }

                    // the condition is met once the service is (ENABLING or ENABLED)/DISABLED
                    var runStatus = latestControllerServiceEntity.status.runStatus;
                    if (enabled) {
                        return runStatus === 'ENABLING' || runStatus === 'ENABLED';
                    } else {
                        return runStatus === 'DISABLED';
                    }
                }, function (service) {
                    return nfCanvasUtils.queryBulletins([controllerServiceEntity.id]);
                }, pollCondition);

                // once the service has updated, resolve and render the updated service
                serviceUpdated.done(function () {
                    deferred.resolve();
                }).fail(function () {
                    deferred.reject();
                });
            }).fail(function () {
                deferred.reject();
            });
        }).promise();
    };

    /**
     * Gets the id's of all controller services referencing the specified controller service.
     *
     * @param {object} controllerService
     */
    var getReferencingControllerServiceIds = function (controllerService) {
        var ids = d3.set();
        ids.add(controllerService.id);

        var checkReferencingServices = function (referencingComponents) {
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'ControllerService') {
                    // add the id
                    ids.add(referencingComponent.id);

                    // consider it's referencing components if appropriate
                    if (referencingComponent.referenceCycle === false) {
                        checkReferencingServices(referencingComponent.referencingComponents);
                    }
                }
            });
        };

        // check the referencing services
        checkReferencingServices(controllerService.referencingComponents);
        return ids;
    };

    /**
     * Gathers all referencing component revisions.
     *
     * @param referencingComponents
     * @param referencingComponentRevisions
     * @param serviceOnly - true includes only services, false includes only schedulable components
     */
    var getReferencingComponentRevisions = function (referencingComponents, referencingComponentRevisions, serviceOnly) {
        // include the revision of each referencing component
        $.each(referencingComponents, function (_, referencingComponentEntity) {
            var referencingComponent = referencingComponentEntity.component;

            if (serviceOnly) {
                if (referencingComponent.referenceType === 'ControllerService') {
                    referencingComponentRevisions[referencingComponentEntity.id] = nfClient.getRevision(referencingComponentEntity);
                }
            } else {
                if (referencingComponent.referenceType !== 'ControllerService') {
                    referencingComponentRevisions[referencingComponentEntity.id] = nfClient.getRevision(referencingComponentEntity);
                }
            }

            // recurse
            getReferencingComponentRevisions(referencingComponent.referencingComponents, referencingComponentRevisions, serviceOnly);
        });
    };

    /**
     * Updates the scheduled state of the processors/reporting tasks referencing
     * the specified controller service.
     *
     * @param {jQuery} serviceTable
     * @param {object} controllerServiceEntity
     * @param {boolean} running
     * @param {function} pollCondition
     */
    var updateReferencingSchedulableComponents = function (serviceTable, controllerServiceEntity, running, pollCondition) {
        var referencingRevisions = {};
        getReferencingComponentRevisions(controllerServiceEntity.component.referencingComponents, referencingRevisions, false);

        var referenceEntity = {
            'id': controllerServiceEntity.id,
            'state': running ? 'RUNNING' : 'STOPPED',
            'referencingComponentRevisions': referencingRevisions,
            'disconnectedNodeAcknowledged': nfStorage.isDisconnectionAcknowledged()
        };

        // issue the request to update the referencing components
        var updated = $.ajax({
            type: 'PUT',
            url: controllerServiceEntity.uri + '/references',
            data: JSON.stringify(referenceEntity),
            dataType: 'json',
            contentType: 'application/json'
        }).fail(nfErrorHandler.handleAjaxError);

        // Note: updated revisions will be retrieved after updateReferencingSchedulableComponents is invoked

        // wait until the polling of each service finished
        return $.Deferred(function (deferred) {
            updated.done(function (response) {
                // update the controller service
                controllerServiceEntity.component.referencingComponents = response.controllerServiceReferencingComponents;

                // if we're just starting schedulable components we're done when the update is finished
                if (running) {
                    deferred.resolve();
                } else {
                    // identify all referencing services
                    var services = getReferencingControllerServiceIds(controllerServiceEntity.component);

                    // get the controller service grid
                    var controllerServiceGrid = serviceTable.data('gridInstance');
                    var controllerServiceData = controllerServiceGrid.getData();

                    // start polling for each controller service
                    var polling = [];
                    services.each(function (controllerServiceId) {
                        getControllerService(controllerServiceId, controllerServiceData).done(function(controllerServiceEntity) {
                            polling.push(stopReferencingSchedulableComponents(controllerServiceEntity, pollCondition));
                        });
                    });

                    // wait until polling has finished
                    $.when.apply(window, polling).done(function () {
                        deferred.resolve();
                    }).fail(function () {
                        deferred.reject();
                    });
                }
            }).fail(function () {
                deferred.reject();
            });
        }).promise();
    };

    /**
     * Gets the controller service with the specified id. If the service is present in the specified
     * controllerServiceData it will be used. Otherwise it will query for it.
     *
     * @param controllerServiceId   service id
     * @param controllerServiceData service table data
     * @returns {deferred} the controller service entity
     */
    var getControllerService = function (controllerServiceId, controllerServiceData) {
        var controllerServiceEntity = controllerServiceData.getItemById(controllerServiceId);
        if (nfCommon.isDefinedAndNotNull(controllerServiceEntity)) {
            return $.Deferred(function (deferred) {
                deferred.resolve(controllerServiceEntity);
            });
        } else {
            return $.ajax({
                type: 'GET',
                url: '../nifi-api/controller-services/' + encodeURIComponent(controllerServiceId),
                dataType: 'json'
            }).fail(nfErrorHandler.handleAjaxError);
        }
    };

    /**
     * Polls the specified services referencing components to see if the
     * specified condition is satisfied.
     *
     * @param {object} controllerServiceEntity
     * @param {function} completeCondition
     * @param {function} bulletinDeferred
     * @param {function} pollCondition
     */
    var pollService = function (controllerServiceEntity, completeCondition, bulletinDeferred, pollCondition) {
        var controllerService = controllerServiceEntity.component;

        // we want to keep polling until the condition is met
        return $.Deferred(function (deferred) {
            var current = 2;
            var getTimeout = function () {
                var val = current;

                // update the current timeout for the next time
                current = Math.min(current * 2, 4);

                return val * 1000;
            };

            // polls for the current status of the referencing components
            var poll = function () {
                var bulletins = bulletinDeferred(controllerService);
                var service = $.ajax({
                    type: 'GET',
                    url: controllerServiceEntity.uri,
                    dataType: 'json'
                });

                $.when(bulletins, service).done(function (bulletinResponse, serviceResult) {
                    var latestControllerServiceEntity = serviceResult[0];
                    conditionMet(latestControllerServiceEntity, bulletinResponse.bulletinBoard.bulletins);
                }).fail(function (xhr, status, error) {
                    deferred.reject();
                    nfErrorHandler.handleAjaxError(xhr, status, error);
                });
            };

            // tests to if the condition has been met
            var conditionMet = function (latestControllerServiceEntity, bulletins) {
                if (completeCondition(latestControllerServiceEntity, bulletins)) {
                    deferred.resolve();
                } else {
                    if (typeof pollCondition === 'function' && pollCondition()) {
                        setTimeout(poll, getTimeout());
                    } else {
                        deferred.reject();
                    }
                }
            };

            // poll for the status of the referencing components
            bulletinDeferred(controllerService).done(function (response) {
                conditionMet(controllerServiceEntity, response.bulletinBoard.bulletins);
            }).fail(function (xhr, status, error) {
                deferred.reject();
                nfErrorHandler.handleAjaxError(xhr, status, error);
            });
        }).promise();
    };

    /**
     * Continues to poll the specified controller service until all referencing schedulable
     * components are stopped (not scheduled and 0 active threads).
     *
     * @param {object} controllerServiceEntity
     * @param {function} pollCondition
     */
    var stopReferencingSchedulableComponents = function (controllerServiceEntity, pollCondition) {
        // continue to poll the service until all schedulable components have stopped
        return pollService(controllerServiceEntity, function (latestControllerServiceEntity, bulletins) {
            var referencingComponents = latestControllerServiceEntity.component.referencingComponents;

            var stillRunning = false;
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'Processor' || referencingComponent.referenceType === 'ReportingTask') {
                    if (referencingComponent.state === 'RUNNING' || referencingComponent.activeThreadCount > 0) {
                        stillRunning = true;
                    }

                    // update the current active thread count
                    $('div.' + referencingComponent.id + '-active-threads').text(referencingComponent.activeThreadCount);

                    // update the current state of this component
                    var referencingComponentState = $('div.' + referencingComponent.id + '-state');
                    updateReferencingSchedulableComponentState(referencingComponentState, referencingComponent);
                }
            });

            // query for the bulletins
            updateReferencingComponentBulletins(bulletins);

            // condition is met once all referencing are not running
            return stillRunning === false;
        }, function (service) {
            var referencingSchedulableComponents = [];

            var referencingComponents = service.referencingComponents;
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'Processor' || referencingComponent.referenceType === 'ReportingTask') {
                    referencingSchedulableComponents.push(referencingComponent.id);
                }
            });

            return nfCanvasUtils.queryBulletins(referencingSchedulableComponents);
        }, pollCondition);
    };

    /**
     * Continues to poll until all referencing services are enabled.
     *
     * @param {object} controllerServiceEntity
     * @param {function} pollCondition
     */
    var enableReferencingServices = function (controllerServiceEntity, pollCondition) {
        // continue to poll the service until all referencing services are enabled
        return pollService(controllerServiceEntity, function (latestControllerServiceEntity, bulletins) {
            var referencingComponents = latestControllerServiceEntity.component.referencingComponents;

            var notEnabled = false;
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'ControllerService') {
                    if (referencingComponent.state !== 'ENABLING' && referencingComponent.state !== 'ENABLED') {
                        notEnabled = true;
                    }

                    // update the state of the referencing service
                    var referencingServiceState = $('div.' + referencingComponent.id + '-state');
                    updateReferencingServiceState(referencingServiceState, referencingComponent);
                }
            });

            // query for the bulletins
            updateReferencingComponentBulletins(bulletins);

            // condition is met once all referencing are not disabled
            return notEnabled === false;
        }, function (service) {
            var referencingSchedulableComponents = [];

            var referencingComponents = service.referencingComponents;
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'ControllerService') {
                    referencingSchedulableComponents.push(referencingComponent.id);
                }
            });

            return nfCanvasUtils.queryBulletins(referencingSchedulableComponents);
        }, pollCondition);
    };

    /**
     * Continues to poll until all referencing services are disabled.
     *
     * @param {object} controllerServiceEntity
     * @param {function} pollCondition
     */
    var disableReferencingServices = function (controllerServiceEntity, pollCondition) {
        // continue to poll the service until all referencing services are disabled
        return pollService(controllerServiceEntity, function (latestControllerServiceEntity, bulletins) {
            var referencingComponents = latestControllerServiceEntity.component.referencingComponents;

            var notDisabled = false;
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'ControllerService') {
                    if (referencingComponent.state !== 'DISABLED') {
                        notDisabled = true;
                    }

                    // update the state of the referencing service
                    var referencingServiceState = $('div.' + referencingComponent.id + '-state');
                    updateReferencingServiceState(referencingServiceState, referencingComponent);
                }
            });

            // query for the bulletins
            updateReferencingComponentBulletins(bulletins);

            // condition is met once all referencing are not enabled
            return notDisabled === false;
        }, function (service) {
            var referencingSchedulableComponents = [];

            var referencingComponents = service.referencingComponents;
            $.each(referencingComponents, function (_, referencingComponentEntity) {
                var referencingComponent = referencingComponentEntity.component;
                if (referencingComponent.referenceType === 'ControllerService') {
                    referencingSchedulableComponents.push(referencingComponent.id);
                }
            });

            return nfCanvasUtils.queryBulletins(referencingSchedulableComponents);
        }, pollCondition);
    };

    /**
     * Updates the referencing services with the specified state.
     *
     * @param {jQuery} serviceTable
     * @param {object} controllerServiceEntity
     * @param {boolean} enabled
     * @param {function} pollCondition
     */
    var updateReferencingServices = function (serviceTable, controllerServiceEntity, enabled, pollCondition) {
        var referencingRevisions = {};
        getReferencingComponentRevisions(controllerServiceEntity.component.referencingComponents, referencingRevisions, true);

        // build the reference entity
        var referenceEntity = {
            'id': controllerServiceEntity.id,
            'state': enabled ? 'ENABLED' : 'DISABLED',
            'referencingComponentRevisions': referencingRevisions,
            'disconnectedNodeAcknowledged': nfStorage.isDisconnectionAcknowledged()
        };

        // issue the request to update the referencing components
        var updated = $.ajax({
            type: 'PUT',
            url: controllerServiceEntity.uri + '/references',
            data: JSON.stringify(referenceEntity),
            dataType: 'json',
            contentType: 'application/json'
        }).fail(nfErrorHandler.handleAjaxError);

        // Note: updated revisions will be retrieved after updateReferencingServices is invoked

        // wait unil the polling of each service finished
        return $.Deferred(function (deferred) {
            updated.done(function (response) {
                // update the controller service
                controllerServiceEntity.component.referencingComponents = response.controllerServiceReferencingComponents;

                // identify all referencing services
                var services = getReferencingControllerServiceIds(controllerServiceEntity.component);

                // get the controller service grid
                var controllerServiceGrid = serviceTable.data('gridInstance');
                var controllerServiceData = controllerServiceGrid.getData();

                // start polling for each controller service
                var polling = [];
                services.each(function (controllerServiceId) {
                    getControllerService(controllerServiceId, controllerServiceData).done(function(controllerServiceEntity) {
                        if (enabled) {
                            polling.push(enableReferencingServices(controllerServiceEntity, pollCondition));
                        } else {
                            polling.push(disableReferencingServices(controllerServiceEntity, pollCondition));
                        }
                    });
                });

                $.when.apply(window, polling).done(function () {
                    deferred.resolve();
                }).fail(function () {
                    deferred.reject();
                });
            }).fail(function () {
                deferred.reject();
            });
        }).promise();
    };

    /**
     * Shows the dialog for disabling a controller service.
     *
     * @argument {object} controllerService The controller service to disable
     */
    var showDisableControllerServiceDialog = function (serviceTable, controllerServiceEntity) {
        // populate the disable controller service dialog
        $('#disable-controller-service-id').text(controllerServiceEntity.id);
        $('#disable-controller-service-name').text(nfCommon.getComponentName(controllerServiceEntity));

        // load the controller referencing components list
        var referencingComponentsContainer = $('#disable-controller-service-referencing-components');
        createReferencingComponents(serviceTable, referencingComponentsContainer, controllerServiceEntity);

        // build the button model
        var buttons = [{
            buttonText: 'Disable',
            color: {
                base: '#728E9B',
                hover: '#004849',
                text: '#ffffff'
            },
            handler: {
                click: function () {
                    disableHandler(serviceTable);
                }
            }
        }, {
            buttonText: 'Cancel',
            color: {
                base: '#E3E8EB',
                hover: '#C7D2D7',
                text: '#004849'
            },
            handler: {
                click: closeModal
            }
        }];

        // show the dialog
        $('#disable-controller-service-dialog').modal('setButtonModel', buttons).modal('show');

        // load the bulletins
        nfCanvasUtils.queryBulletins([controllerServiceEntity.id]).done(function (response) {
            updateBulletins(response.bulletinBoard.bulletins, $('#disable-controller-service-bulletins'));
        });

        // update the border if necessary
        updateReferencingComponentsBorder(referencingComponentsContainer);
    };

    /**
     * Shows the dialog for enabling a controller service.
     *
     * @param {object} serviceTable
     * @param {object} controllerService
     */
    var showEnableControllerServiceDialog = function (serviceTable, controllerServiceEntity) {
        // populate the disable controller service dialog
        $('#enable-controller-service-id').text(controllerServiceEntity.id);
        $('#enable-controller-service-name').text(nfCommon.getComponentName(controllerServiceEntity));

        // load the controller referencing components list
        var referencingComponentsContainer = $('#enable-controller-service-referencing-components');
        createReferencingComponents(serviceTable, referencingComponentsContainer, controllerServiceEntity);

        // build the button model
        var buttons = [{
            buttonText: 'Enable',
            color: {
                base: '#728E9B',
                hover: '#004849',
                text: '#ffffff'
            },
            handler: {
                click: function () {
                    enableHandler(serviceTable);
                }
            }
        }, {
            buttonText: 'Cancel',
            color: {
                base: '#E3E8EB',
                hover: '#C7D2D7',
                text: '#004849'
            },
            handler: {
                click: closeModal
            }
        }];

        // show the dialog
        $('#enable-controller-service-dialog').modal('setButtonModel', buttons).modal('show');

        // load the bulletins
        nfCanvasUtils.queryBulletins([controllerServiceEntity.id]).done(function (response) {
            updateBulletins(response.bulletinBoard.bulletins, $('#enable-controller-service-bulletins'));
        });

        // update the border if necessary
        updateReferencingComponentsBorder(referencingComponentsContainer);
    };

    /**
     * Used to handle closing a modal dialog
     */
    var closeModal = function () {
        $(this).modal('hide');
    };

    /**
     * Handles the disable action of the disable controller service dialog.
     *
     * @param {jQuery} serviceTable
     */
    var disableHandler = function (serviceTable) {
        var disableDialog = $('#disable-controller-service-dialog');
        var canceled = false;

        // only provide a cancel option
        disableDialog.modal('setButtonModel', [{
            buttonText: 'Cancel',
            color: {
                base: '#E3E8EB',
                hover: '#C7D2D7',
                text: '#004849'
            },
            handler: {
                click: function () {
                    canceled = true;
                    disableDialog.modal('setButtonModel', []);
                    $('#disable-controller-service-dialog div.controller-service-canceling').show();
                }
            }
        }]);

        // show the progress
        $('#disable-controller-service-scope-container').hide();
        $('#disable-controller-service-progress-container').show();

        // get the controller service
        var controllerServiceId = $('#disable-controller-service-id').text();
        var controllerServiceGrid = serviceTable.data('gridInstance');
        var controllerServiceData = controllerServiceGrid.getData();
        var controllerServiceEntity = controllerServiceData.getItemById(controllerServiceId);
        var controllerService = controllerServiceEntity.component;

        // whether or not to continue polling
        var continuePolling = function () {
            return canceled === false;
        };

        // sets the close button on the dialog
        var setCloseButton = function () {
            $('#disable-controller-service-dialog div.controller-service-canceling').hide();
            disableDialog.modal('setButtonModel', [{
                buttonText: 'Close',
                color: {
                    base: '#728E9B',
                    hover: '#004849',
                    text: '#ffffff'
                },
                handler: {
                    click: closeModal
                }
            }]);
        };

        // ensure we have access to all referencing components before attempting the sequence
        if (hasUnauthorizedReferencingComponent(controllerServiceEntity)) {
            setCloseButton();

            nfDialog.showOkDialog({
                headerText: 'Controller Service',
                dialogContent: controllerServiceEntity.permissions.canRead === false
                                    // Unknown references.
                                    ? 'Unable to disable due to a lack of read permission to see referencing components.'
                                    // Unauthorized references.
                                    : 'Unable to disable due to unauthorized referencing components.'
            });
            return;
        }

        $('#disable-progress-label').text('Steps to disable ' + nfCommon.getComponentName(controllerServiceEntity));
        var disableReferencingSchedulable = $('#disable-referencing-schedulable').addClass('ajax-loading');

        $.Deferred(function (deferred) {
            // stop all referencing schedulable components
            var stopped = updateReferencingSchedulableComponents(serviceTable, controllerServiceEntity, false, continuePolling);

            // once everything has stopped
            stopped.done(function () {
                disableReferencingSchedulable.removeClass('ajax-loading').addClass('ajax-complete');
                var disableReferencingServices = $('#disable-referencing-services').addClass('ajax-loading');

                // disable all referencing services
                var disabled = updateReferencingServices(serviceTable, controllerServiceEntity, false, continuePolling);

                // everything is disabled
                disabled.done(function () {
                    disableReferencingServices.removeClass('ajax-loading').addClass('ajax-complete');
                    var disableControllerService = $('#disable-controller-service').addClass('ajax-loading');

                    // disable this service
                    setEnabled(serviceTable, controllerServiceEntity, false, continuePolling).done(function () {
                        deferred.resolve();
                        disableControllerService.removeClass('ajax-loading').addClass('ajax-complete');
                    }).fail(function () {
                        deferred.reject();
                        disableControllerService.removeClass('ajax-loading').addClass('ajax-error');
                    });
                }).fail(function () {
                    deferred.reject();
                    disableReferencingServices.removeClass('ajax-loading').addClass('ajax-error');
                });
            }).fail(function () {
                deferred.reject();
                disableReferencingSchedulable.removeClass('ajax-loading').addClass('ajax-error');
            });
        }).always(function () {
            if (controllerServiceEntity.permissions.canRead === true) {
                reloadControllerServiceAndReferencingComponents(serviceTable, controllerService);
            }
            setCloseButton();

            // inform the user if the action was canceled
            if (canceled === true && $('#nf-ok-dialog').not(':visible')) {
                nfDialog.showOkDialog({
                    headerText: 'Controller Service',
                    dialogContent: 'The request to disable has been canceled. Parts of this request may have already completed. Please verify the state of this service and all referencing components.'
                });
            }
        });
    };

    /**
     * Determines if any of the specified referencing components are not authorized to enable/disable.
     *
     * @param {object} ControllerServiceEntity having referencingComponents referencing components
     * @returns {boolean}
     */
    var hasUnauthorizedReferencingComponent = function (controllerServiceEntity) {

        if (controllerServiceEntity.permissions.canRead === false
                || (controllerServiceEntity.permissions.canWrite === false && controllerServiceEntity.operatePermissions.canWrite === false)) {
            return true;
        }

        var hasUnauthorized = false;
        var referencingComponents = controllerServiceEntity.component.referencingComponents;
        $.each(referencingComponents, function (_, referencingComponentEntity) {
            if (hasUnauthorizedReferencingComponent(referencingComponentEntity)) {
                hasUnauthorized = true;
                return false;
            }
        });

        return hasUnauthorized;
    };

    /**
     * Handles the enable action of the enable controller service dialog.
     *
     * @param {jQuery} serviceTable
     */
    var enableHandler = function (serviceTable) {
        var enableDialog = $('#enable-controller-service-dialog');
        var canceled = false;

        // get the controller service
        var controllerServiceId = $('#enable-controller-service-id').text();
        var controllerServiceGrid = serviceTable.data('gridInstance');
        var controllerServiceData = controllerServiceGrid.getData();
        var controllerServiceEntity = controllerServiceData.getItemById(controllerServiceId);
        var controllerService = controllerServiceEntity.component;

        // determine if we want to also activate referencing components
        var scope = $('#enable-controller-service-scope').combo('getSelectedOption').value;

        // update visibility
        if (scope === config.serviceOnly) {
            $('#enable-controller-service-progress li.referencing-component').hide();
        }

        // only provide a cancel option
        enableDialog.modal('setButtonModel', [{
            buttonText: 'Cancel',
            color: {
                base: '#E3E8EB',
                hover: '#C7D2D7',
                text: '#004849'
            },
            handler: {
                click: function () {
                    canceled = true;
                    enableDialog.modal('setButtonModel', []);
                    $('#enable-controller-service-dialog div.controller-service-canceling').show();
                }
            }
        }]);

        // show the progress
        $('#enable-controller-service-scope-container').hide();
        $('#enable-controller-service-progress-container').show();


        // whether or not to continue polling
        var continuePolling = function () {
            return canceled === false;
        };

        // sets the button to close
        var setCloseButton = function () {
            $('#enable-controller-service-dialog div.controller-service-canceling').hide();
            enableDialog.modal('setButtonModel', [{
                buttonText: 'Close',
                color: {
                    base: '#728E9B',
                    hover: '#004849',
                    text: '#ffffff'
                },
                handler: {
                    click: closeModal
                }
            }]);
        };

        // ensure appropriate access
        if (scope === config.serviceAndReferencingComponents && hasUnauthorizedReferencingComponent(controllerServiceEntity)) {
            setCloseButton();

            nfDialog.showOkDialog({
                headerText: 'Controller Service',
                dialogContent: controllerServiceEntity.permissions.canRead === false
                                    // Unknown references.
                                    ? 'Unable to enable due to a lack of read permission to see referencing components.'
                                    // Unauthorized references.
                                    : 'Unable to enable due to unauthorized referencing components.'
            });
            return;
        }

        $('#enable-progress-label').text('Steps to enable ' + nfCommon.getComponentName(controllerServiceEntity));
        var enableControllerService = $('#enable-controller-service').addClass('ajax-loading');

        $.Deferred(function (deferred) {
            // enable this controller service
            var enable = setEnabled(serviceTable, controllerServiceEntity, true, continuePolling);

            if (scope === config.serviceAndReferencingComponents) {
                // once the service is enabled, activate all referencing components
                enable.done(function () {
                    enableControllerService.removeClass('ajax-loading').addClass('ajax-complete');
                    var enableReferencingServices = $('#enable-referencing-services').addClass('ajax-loading');

                    // enable the referencing services
                    var servicesEnabled = updateReferencingServices(serviceTable, controllerServiceEntity, true, continuePolling);

                    // once all the referencing services are enbled
                    servicesEnabled.done(function () {
                        enableReferencingServices.removeClass('ajax-loading').addClass('ajax-complete');
                        var enableReferencingSchedulable = $('#enable-referencing-schedulable').addClass('ajax-loading');

                        // start all referencing schedulable components
                        updateReferencingSchedulableComponents(serviceTable, controllerServiceEntity, true, continuePolling).done(function () {
                            deferred.resolve();
                            enableReferencingSchedulable.removeClass('ajax-loading').addClass('ajax-complete');
                        }).fail(function () {
                            deferred.reject();
                            enableReferencingSchedulable.removeClass('ajax-loading').addClass('ajax-error');
                        });
                    }).fail(function () {
                        deferred.reject();
                        enableReferencingServices.removeClass('ajax-loading').addClass('ajax-error');
                    });
                }).fail(function () {
                    deferred.reject();
                    enableControllerService.removeClass('ajax-loading').addClass('ajax-error');
                });
            } else {
                enable.done(function () {
                    deferred.resolve();
                    enableControllerService.removeClass('ajax-loading').addClass('ajax-complete');
                }).fail(function () {
                    deferred.reject();
                    enableControllerService.removeClass('ajax-loading').addClass('ajax-error');
                });
            }
        }).always(function () {
            if (controllerServiceEntity.permissions.canRead === true) {
                reloadControllerServiceAndReferencingComponents(serviceTable, controllerService);
            }
            setCloseButton();

            // inform the user if the action was canceled
            if (canceled === true && $('#nf-ok-dialog').not(':visible')) {
                nfDialog.showOkDialog({
                    headerText: 'Controller Service',
                    dialogContent: 'The request to enable has been canceled. Parts of this request may have already completed. Please verify the state of this service and all referencing components.'
                });
            }
        });
    };

    /**
     * Gets a property descriptor for the controller service currently being configured.
     *
     * @param {type} propertyName
     */
    var getControllerServicePropertyDescriptor = function (propertyName) {
        var controllerServiceEntity = $('#controller-service-configuration').data('controllerServiceDetails');
        return $.ajax({
            type: 'GET',
            url: controllerServiceEntity.uri + '/descriptors',
            data: {
                propertyName: propertyName
            },
            dataType: 'json'
        }).fail(nfErrorHandler.handleAjaxError);
    };

    /**
     * Gets the parameters for the specified property descriptor and group.
     *
     * @param propertyDescriptor    The property descriptor in question
     * @param groupId               The group in question
     * @returns {deferred}
     */
    var getParameters = function (propertyDescriptor, groupId) {
        return $.Deferred(function (deferred) {
            if (nfCommon.isDefinedAndNotNull(groupId)) {
                var parameterContext;

                // attempt to identify the parameter context id, conditional based on whether
                // the user is configuring the current process group
                if (groupId === nfCanvasUtils.getGroupId()) {
                    parameterContext = nfCanvasUtils.getParameterContext();
                } else {
                    var parentProcessGroup = nfCanvasUtils.getComponentByType('ProcessGroup').get(groupId);
                    parameterContext = parentProcessGroup.parameterContext;
                }

                if (nfCommon.isDefinedAndNotNull(parameterContext)) {
                    $.ajax({
                        type: 'GET',
                        url: '../nifi-api/parameter-contexts/' + encodeURIComponent(parameterContext.id),
                        dataType: 'json'
                    }).done(function (response) {
                        var sensitive = nfCommon.isSensitiveProperty(propertyDescriptor);

                        deferred.resolve(response.component.parameters.map(function (parameterEntity) {
                            return parameterEntity.parameter;
                        }).filter(function (parameter) {
                            return parameter.sensitive === sensitive;
                        }));
                    }).fail(function () {
                        deferred.resolve([]);
                    });
                } else {
                    deferred.resolve([]);
                }
            } else {
                deferred.resolve([]);
            }
        }).promise();
    };

    /**
     * Goes to a service configuration from the property table.
     *
     * @param {jQuery} serviceTable
     */
    var goToServiceFromProperty = function (serviceTable) {
        return $.Deferred(function (deferred) {
            // close all fields currently being edited
            $('#controller-service-properties').propertytable('saveRow');

            // determine if changes have been made
            if (isSaveRequired()) {
                // see if those changes should be saved
                nfDialog.showYesNoDialog({
                    headerText: 'Save',
                    dialogContent: 'Save changes before going to this Controller Service?',
                    noHandler: function () {
                        deferred.resolve();
                    },
                    yesHandler: function () {
                        var controllerServiceEntity = $('#controller-service-configuration').data('controllerServiceDetails');
                        saveControllerService(serviceTable, controllerServiceEntity).done(function () {
                            deferred.resolve();
                        }).fail(function () {
                            deferred.reject();
                        });
                    }
                });
            } else {
                deferred.resolve();
            }
        }).promise();
    };

    var getParameterContext = function (groupId) {
        if (_.isNil(groupId)) {
            return null;
        }

        var parameterContext;

        // attempt to identify the parameter context, conditional based on whether
        // the user is configuring the current process group
        if (groupId === nfCanvasUtils.getGroupId()) {
            parameterContext = nfCanvasUtils.getParameterContext();
        } else {
            var parentProcessGroup = nfCanvasUtils.getComponentByType('ProcessGroup').get(groupId);
            parameterContext = parentProcessGroup.parameterContext;
        }

        return parameterContext;
    };

    var saveControllerService = function (serviceTable, controllerServiceEntity) {
        // marshal the settings and properties and update the controller service
        var updatedControllerService = marshalDetails();

        // ensure details are valid as far as we can tell
        if (validateDetails(updatedControllerService)) {
            updatedControllerService['revision'] = nfClient.getRevision(controllerServiceEntity);

            var previouslyReferencedServiceIds = [];
            $.each(identifyReferencedServiceDescriptors(controllerServiceEntity.component), function (_, descriptor) {
                var modifyingService = !nfCommon.isUndefined(updatedControllerService.component.properties) && !nfCommon.isUndefined(updatedControllerService.component.properties[descriptor.name]);
                var isCurrentlyConfigured = nfCommon.isDefinedAndNotNull(controllerServiceEntity.component.properties[descriptor.name]);

                // if we are attempting to update a controller service reference
                if (modifyingService && isCurrentlyConfigured) {

                    // record the current value if set
                    previouslyReferencedServiceIds.push(controllerServiceEntity.component.properties[descriptor.name]);
                }
            });

            // update the selected component
            return $.ajax({
                type: 'PUT',
                data: JSON.stringify(updatedControllerService),
                url: controllerServiceEntity.uri,
                dataType: 'json',
                contentType: 'application/json'
            }).done(function (response) {
                // reload the controller service
                renderControllerService(serviceTable, response);

                // reload all previously referenced controller services
                $.each(previouslyReferencedServiceIds, function (_, oldServiceReferenceId) {
                    reloadControllerService(serviceTable, oldServiceReferenceId);
                });
            }).fail(nfErrorHandler.handleConfigurationUpdateAjaxError);
        } else {
            return $.Deferred(function (deferred) {
                deferred.reject();
            }).promise();
        }
    };

    /**
     * Identifies the descriptors that identify controller services.
     *
     * @param {object} component
     */
    var identifyReferencedServiceDescriptors = function (component) {
        var referencedServiceDescriptors = [];

        $.each(component.descriptors, function (_, descriptor) {
            if (nfCommon.isDefinedAndNotNull(descriptor.identifiesControllerService)) {
                referencedServiceDescriptors.push(descriptor);
            }
        });

        return referencedServiceDescriptors;
    };

    /**
     * Identifies descriptors that reference controller services.
     *
     * @param {object} component
     */
    var getReferencedServices = function (component) {
        var referencedServices = [];

        $.each(identifyReferencedServiceDescriptors(component), function (_, descriptor) {
            var referencedServiceId = component.properties[descriptor.name];

            // ensure the property is configured
            if (nfCommon.isDefinedAndNotNull(referencedServiceId) && $.trim(referencedServiceId).length > 0) {
                referencedServices.push(referencedServiceId);
            }
        });

        return referencedServices;
    };

    /**
     * Track the current table
     */
    var currentTable;

    var nfControllerService = {
        /**
         * Initializes the controller service configuration dialog.
         */
        init: function (nfControllerServicesRef, nfReportingTaskRef) {
            nfControllerServices = nfControllerServicesRef;
            nfReportingTask = nfReportingTaskRef;

            // initialize the configuration dialog tabs
            $('#controller-service-configuration-tabs').tabbs({
                tabStyle: 'tab',
                selectedTabStyle: 'selected-tab',
                scrollableTabContentStyle: 'scrollable',
                tabs: [{
                    name: 'Settings',
                    tabContentId: 'controller-service-standard-settings-tab-content'
                }, {
                    name: 'Properties',
                    tabContentId: 'controller-service-properties-tab-content'
                }, {
                    name: 'Comments',
                    tabContentId: 'controller-service-comments-tab-content'
                }],
                select: function () {
                    // remove all property detail dialogs
                    nfUniversalCapture.removeAllPropertyDetailDialogs();

                    // update the property table size in case this is the first time its rendered
                    if ($(this).text() === 'Properties') {
                        $('#controller-service-properties').propertytable('resetTableSize');
                    }

                    // close all fields currently being edited
                    $('#controller-service-properties').propertytable('saveRow');

                    // show the border around the processor relationships if necessary
                    var referenceContainer = $('#controller-service-referencing-components');
                    updateReferencingComponentsBorder(referenceContainer);
                }
            });

            // initialize the conroller service configuration dialog
            $('#controller-service-configuration').modal({
                headerText: 'Configure Controller Service',
                scrollableContentStyle: 'scrollable',
                handler: {
                    close: function () {
                        // empty the referencing components list
                        var referencingComponents = $('#controller-service-referencing-components');
                        nfCommon.cleanUpTooltips(referencingComponents, 'div.referencing-component-state');
                        nfCommon.cleanUpTooltips(referencingComponents, 'div.referencing-component-bulletins');
                        referencingComponents.css('border-width', '0').empty();

                        // cancel any active edits
                        $('#controller-service-properties').propertytable('cancelEdit');

                        // clear the tables
                        $('#controller-service-properties').propertytable('clear');

                        // clear the comments
                        nfCommon.clearField('read-only-controller-service-comments');

                        // clear the compatible apis
                        $('#controller-service-compatible-apis').empty();

                        // removed the cached controller service details
                        $('#controller-service-configuration').removeData('controllerServiceDetails');
                    },
                    open: function () {
                        nfCommon.toggleScrollable($('#' + this.find('.tab-container').attr('id') + '-content').get(0));
                    }
                }
            });

            // initialize the disable service dialog
            $('#disable-controller-service-dialog').modal({
                headerText: 'Disable Controller Service',
                scrollableContentStyle: 'scrollable',
                handler: {
                    close: function () {
                        var disableDialog = $(this);

                        // reset visibility
                        $('#disable-controller-service-scope-container').show();
                        $('#disable-controller-service-progress-container').hide();

                        // clear the dialog
                        $('#disable-controller-service-id').text('');
                        $('#disable-controller-service-name').text('');

                        // bulletins
                        $('#disable-controller-service-bulletins').removeClass('has-bulletins').removeData('bulletins').hide();
                        nfCommon.cleanUpTooltips($('#disable-controller-service-service-container'), '#disable-controller-service-bulletins');

                        // reset progress
                        $('div.disable-referencing-components').removeClass('ajax-loading ajax-complete ajax-error');

                        // referencing components
                        var referencingComponents = $('#disable-controller-service-referencing-components');
                        nfCommon.cleanUpTooltips(referencingComponents, 'div.referencing-component-state');
                        nfCommon.cleanUpTooltips(referencingComponents, 'div.referencing-component-bulletins');
                        referencingComponents.css('border-width', '0').empty();
                    }
                }
            });

            // initialize the enable scope combo
            $('#enable-controller-service-scope').combo({
                options: [{
                    text: 'Service only',
                    value: config.serviceOnly,
                    description: 'Enable only this controller service'
                }, {
                    text: 'Service and referencing components',
                    value: config.serviceAndReferencingComponents,
                    description: 'Enable this controller service and enable/start all referencing components'
                }]
            });

            // initialize the enable service dialog
            $('#enable-controller-service-dialog').modal({
                headerText: 'Enable Controller Service',
                scrollableContentStyle: 'scrollable',
                handler: {
                    close: function () {
                        var enableDialog = $(this);

                        // reset visibility
                        $('#enable-controller-service-scope-container').show();
                        $('#enable-controller-service-progress-container').hide();
                        $('#enable-controller-service-progress li.referencing-component').show();

                        // clear the dialog
                        $('#enable-controller-service-id').text('');
                        $('#enable-controller-service-name').text('');

                        // bulletins
                        $('#enable-controller-service-bulletins').removeClass('has-bulletins').removeData('bulletins').hide();
                        nfCommon.cleanUpTooltips($('#enable-controller-service-service-container'), '#enable-controller-service-bulletins');

                        // reset progress
                        $('div.enable-referencing-components').removeClass('ajax-loading ajax-complete ajax-error');

                        // referencing components
                        var referencingComponents = $('#enable-controller-service-referencing-components');
                        nfCommon.cleanUpTooltips(referencingComponents, 'div.referencing-component-state');
                        nfCommon.cleanUpTooltips(referencingComponents, 'div.referencing-component-bulletins');
                        referencingComponents.css('border-width', '0').empty();
                    }
                }
            });
        },

        /**
         * Shows the configuration dialog for the specified controller service.
         *
         * @argument {jQuery} serviceTable                 The controller service table
         * @argument {object} controllerServiceEntity      The controller service
         */
        showConfiguration: function (serviceTable, controllerServiceEntity) {
            if (nfCommon.isUndefined(currentTable)) {
                currentTable = serviceTable;
            }
            var controllerServiceDialog = $('#controller-service-configuration');

            controllerServiceDialog.find('.dialog-header .dialog-header-text').text('Configure Controller Service');
            if (controllerServiceDialog.data('mode') !== config.edit || currentTable !== serviceTable) {
                // update the visibility
                $('#controller-service-configuration .controller-service-read-only').hide();
                $('#controller-service-configuration .controller-service-editable').show();

                // conditionally get the parameter deferred function
                var getParameterDeferred = null;
                if (nfCommon.isDefinedAndNotNull(controllerServiceEntity.parentGroupId)) {
                    getParameterDeferred = getParameters;
                }

                // initialize the property table
                $('#controller-service-properties').propertytable('destroy').propertytable({
                    readOnly: false,
                    supportsGoTo: true,
                    dialogContainer: '#new-controller-service-property-container',
                    descriptorDeferred: getControllerServicePropertyDescriptor,
                    parameterDeferred: getParameterDeferred,
                    controllerServiceCreatedDeferred: function (response) {
                        var controllerServicesUri;

                        // calculate the correct uri
                        var createdControllerService = response.component;
                        if (nfCommon.isDefinedAndNotNull(createdControllerService.parentGroupId)) {
                            controllerServicesUri = config.urls.api + '/flow/process-groups/' + encodeURIComponent(createdControllerService.parentGroupId) + '/controller-services';
                        } else {
                            controllerServicesUri = config.urls.api + '/flow/controller/controller-services';
                        }

                        // load the controller services accordingly
                        return nfControllerServices.loadControllerServices(controllerServicesUri, serviceTable);
                    },
                    goToServiceDeferred: function () {
                        return goToServiceFromProperty(serviceTable);
                    },
                    getParameterContext: function (groupId) {
                        return getParameterContext(groupId);
                    }
                });

                // update the mode
                controllerServiceDialog.data('mode', config.edit);
            }

            //track the current table
            currentTable = serviceTable;

            // reload the service in case the property descriptors have changed
            var reloadService = $.ajax({
                type: 'GET',
                url: controllerServiceEntity.uri,
                dataType: 'json'
            });

            // get the controller service history
            var loadHistory = $.ajax({
                type: 'GET',
                url: '../nifi-api/flow/history/components/' + encodeURIComponent(controllerServiceEntity.id),
                dataType: 'json'
            });

            // once everything is loaded, show the dialog
            $.when(reloadService, loadHistory).done(function (serviceResponse, historyResponse) {
                // get the updated controller service
                controllerServiceEntity = serviceResponse[0];
                var controllerService = controllerServiceEntity.component;

                // get the controller service history
                var controllerServiceHistory = historyResponse[0].componentHistory;

                // record the controller service details
                controllerServiceDialog.data('controllerServiceDetails', controllerServiceEntity);

                // populate the controller service settings
                nfCommon.populateField('controller-service-id', controllerService['id']);

                nfCommon.populateField('controller-service-type', nfCommon.formatType(controllerService));
                $('#controller-service-configuration').modal('setSubtitle', nfCommon.formatType(controllerService));

                nfCommon.populateField('controller-service-bundle', nfCommon.formatBundle(controllerService['bundle']));
                $('#controller-service-name').val(controllerService['name']);
                $('#controller-service-comments').val(controllerService['comments']);

                // set the implemented apis
                if (!nfCommon.isEmpty(controllerService['controllerServiceApis'])) {
                    var formattedControllerServiceApis = nfCommon.getFormattedServiceApis(controllerService['controllerServiceApis']);
                    var serviceTips = nfCommon.formatUnorderedList(formattedControllerServiceApis);
                    $('#controller-service-compatible-apis').append(serviceTips);
                } else {
                    $('#controller-service-compatible-apis').append('<span class="unset">None</span>');
                }

                // get the reference container
                var referenceContainer = $('#controller-service-referencing-components');

                // load the controller referencing components list
                createReferencingComponents(serviceTable, referenceContainer, controllerServiceEntity);

                var buttons = [{
                    buttonText: 'Apply',
                    color: {
                        base: '#728E9B',
                        hover: '#004849',
                        text: '#ffffff'
                    },
                    handler: {
                        click: function () {
                            // close all fields currently being edited
                            $('#controller-service-properties').propertytable('saveRow');

                            // save the controller service
                            saveControllerService(serviceTable, controllerServiceEntity).done(function (response) {
                                reloadControllerServiceReferences(serviceTable, response.component);

                                // close the details panel
                                controllerServiceDialog.modal('hide');
                            });
                        }
                    }
                }, {
                    buttonText: 'Cancel',
                    color: {
                        base: '#E3E8EB',
                        hover: '#C7D2D7',
                        text: '#004849'
                    },
                    handler: {
                        click: function () {
                            controllerServiceDialog.modal('hide');
                        }
                    }
                }];

                // determine if we should show the advanced button
                if (nfCommon.isDefinedAndNotNull(controllerService.customUiUrl) && controllerService.customUiUrl !== '') {
                    buttons.push({
                        buttonText: 'Advanced',
                        clazz: 'fa fa-cog button-icon',
                        color: {
                            base: '#E3E8EB',
                            hover: '#C7D2D7',
                            text: '#004849'
                        },
                        handler: {
                            click: function () {
                                var openCustomUi = function () {
                                    // reset state and close the dialog manually to avoid hiding the faded background
                                    controllerServiceDialog.modal('hide');

                                    // close the settings dialog since the custom ui is also opened in the shell
                                    $('#shell-close-button').click();

                                    // show the custom ui
                                    nfCustomUi.showCustomUi(controllerServiceEntity, controllerService.customUiUrl, true).done(function () {
                                        // once the custom ui is closed, reload the controller service
                                        reloadControllerServiceAndReferencingComponents(serviceTable, controllerService);

                                        // show the settings
                                        nfSettings.showSettings();
                                    });
                                };

                                // close all fields currently being edited
                                $('#controller-service-properties').propertytable('saveRow');

                                // determine if changes have been made
                                if (isSaveRequired()) {
                                    // see if those changes should be saved
                                    nfDialog.showYesNoDialog({
                                        headerText: 'Save',
                                        dialogContent: 'Save changes before opening the advanced configuration?',
                                        noHandler: openCustomUi,
                                        yesHandler: function () {
                                            saveControllerService(serviceTable, controllerServiceEntity).done(function () {
                                                // open the custom ui
                                                openCustomUi();
                                            });
                                        }
                                    });
                                } else {
                                    // if there were no changes, simply open the custom ui
                                    openCustomUi();
                                }
                            }
                        }
                    });
                }

                // set the button model
                controllerServiceDialog.modal('setButtonModel', buttons);

                // load the property table
                $('#controller-service-properties')
                    .propertytable('setGroupId', controllerService.parentGroupId)
                    .propertytable('loadProperties', controllerService.properties, controllerService.descriptors, controllerServiceHistory.propertyHistory);

                // show the details
                controllerServiceDialog.modal('show');

                // show the border if necessary
                updateReferencingComponentsBorder(referenceContainer);

                $('#controller-service-properties').propertytable('resetTableSize');
            }).fail(nfErrorHandler.handleAjaxError);
        },

        /**
         * Shows the controller service details in a read only dialog.
         *
         * @param {jQuery} serviceTable
         * @param {object} controllerServiceEntity
         */
        showDetails: function (serviceTable, controllerServiceEntity) {
            var controllerServiceDialog = $('#controller-service-configuration');

            controllerServiceDialog.find('.dialog-header .dialog-header-text').text('Controller Service Details');
            if (controllerServiceDialog.data('mode') !== config.readOnly) {
                // update the visibility
                $('#controller-service-configuration .controller-service-read-only').show();
                $('#controller-service-configuration .controller-service-editable').hide();

                // initialize the property table
                $('#controller-service-properties').propertytable('destroy').propertytable({
                    supportsGoTo: true,
                    readOnly: true,
                    getParameterContext: function (groupId) {
                        return getParameterContext(groupId);
                    }
                });

                // update the mode
                controllerServiceDialog.data('mode', config.readOnly);
            }

            // reload the service in case the property descriptors have changed
            var reloadService = $.ajax({
                type: 'GET',
                url: controllerServiceEntity.uri,
                dataType: 'json'
            });

            // get the controller service history
            var loadHistory = $.ajax({
                type: 'GET',
                url: '../nifi-api/flow/history/components/' + encodeURIComponent(controllerServiceEntity.id),
                dataType: 'json'
            });

            // once everything is loaded, show the dialog
            $.when(reloadService, loadHistory).done(function (serviceResponse, historyResponse) {
                // get the updated controller service
                controllerServiceEntity = serviceResponse[0];
                var controllerService = controllerServiceEntity.component;

                // get the controller service history
                var controllerServiceHistory = historyResponse[0].componentHistory;

                // record the controller service details
                controllerServiceDialog.data('controllerServiceDetails', controllerServiceEntity);

                // populate the controller service settings
                nfCommon.populateField('controller-service-id', controllerService['id']);
                nfCommon.populateField('controller-service-type', nfCommon.formatType(controllerService));
                nfCommon.populateField('controller-service-bundle', nfCommon.formatBundle(controllerService['bundle']));
                nfCommon.populateField('read-only-controller-service-name', controllerService['name']);
                nfCommon.populateField('read-only-controller-service-comments', controllerService['comments']);

                // set the implemented apis
                if (!nfCommon.isEmpty(controllerService['controllerServiceApis'])) {
                    var formattedControllerServiceApis = nfCommon.getFormattedServiceApis(controllerService['controllerServiceApis']);
                    var serviceTips = nfCommon.formatUnorderedList(formattedControllerServiceApis);
                    $('#controller-service-compatible-apis').append(serviceTips);
                } else {
                    $('#controller-service-compatible-apis').append('<span class="unset">None</span>');
                }

                // get the reference container
                var referenceContainer = $('#controller-service-referencing-components');

                // load the controller referencing components list
                createReferencingComponents(serviceTable, referenceContainer, controllerServiceEntity);

                var buttons = [{
                    buttonText: 'Ok',
                    color: {
                        base: '#728E9B',
                        hover: '#004849',
                        text: '#ffffff'
                    },
                    handler: {
                        click: function () {
                            // hide the dialog
                            controllerServiceDialog.modal('hide');
                        }
                    }
                }];

                // determine if we should show the advanced button
                if (nfCommon.isDefinedAndNotNull(nfCustomUi) && nfCommon.isDefinedAndNotNull(controllerService.customUiUrl) && controllerService.customUiUrl !== '') {
                    buttons.push({
                        buttonText: 'Advanced',
                        clazz: 'fa fa-cog button-icon',
                        color: {
                            base: '#E3E8EB',
                            hover: '#C7D2D7',
                            text: '#004849'
                        },
                        handler: {
                            click: function () {
                                // reset state and close the dialog manually to avoid hiding the faded background
                                controllerServiceDialog.modal('hide');

                                // close the settings dialog since the custom ui is also opened in the shell
                                $('#shell-close-button').click();

                                // show the custom ui
                                nfCustomUi.showCustomUi(controllerServiceEntity, controllerService.customUiUrl, false).done(function () {
                                    nfSettings.showSettings();
                                });
                            }
                        }
                    });
                }

                // show the dialog
                controllerServiceDialog.modal('setButtonModel', buttons);

                // load the property table
                $('#controller-service-properties')
                    .propertytable('setGroupId', controllerService.parentGroupId)
                    .propertytable('loadProperties', controllerService.properties, controllerService.descriptors, controllerServiceHistory.propertyHistory);

                // show the details
                controllerServiceDialog.modal('show');

                // show the border if necessary
                updateReferencingComponentsBorder(referenceContainer);

                $('#controller-service-properties').propertytable('resetTableSize');
            });
        },

        /**
         * Enables the specified controller service.
         *
         * @param {jQuery} serviceTable
         * @param {object} controllerServiceEntity
         */
        enable: function (serviceTable, controllerServiceEntity) {
            showEnableControllerServiceDialog(serviceTable, controllerServiceEntity);
        },

        /**
         * Disables the specified controller service.
         *
         * @param {jQuery} serviceTable
         * @param {object} controllerServiceEntity
         */
        disable: function (serviceTable, controllerServiceEntity) {
            showDisableControllerServiceDialog(serviceTable, controllerServiceEntity);
        },

        /**
         * Reloads the services that the specified comonent references. This is
         * necessary because the specified component state is reflected in the
         * referenced service referencing components.
         *
         * @param {jQuery} serviceTable
         * @param {object} component
         */
        reloadReferencedServices: function (serviceTable, component) {
            $.each(getReferencedServices(component), function (_, referencedServiceId) {
                reloadControllerService(serviceTable, referencedServiceId);
            });
        },

        /**
         * Prompts the user before attempting to delete the specified controller service.
         *
         * @param {jQuery} serviceTable
         * @param {object} controllerServiceEntity
         */
        promptToDeleteController: function (serviceTable, controllerServiceEntity) {
            // prompt for deletion
            nfDialog.showYesNoDialog({
                headerText: 'Delete Controller Service',
                dialogContent: 'Delete controller service \'' + nfCommon.escapeHtml(controllerServiceEntity.component.name) + '\'?',
                yesHandler: function () {
                    nfControllerService.remove(serviceTable, controllerServiceEntity);
                }
            });
        },

        /**
         * Deletes the specified controller service.
         *
         * @param {jQuery} serviceTable
         * @param {object} controllerServiceEntity
         */
        remove: function (serviceTable, controllerServiceEntity) {
            // prompt for removal?

            var revision = nfClient.getRevision(controllerServiceEntity);
            $.ajax({
                type: 'DELETE',
                url: controllerServiceEntity.uri + '?' + $.param({
                    'version': revision.version,
                    'clientId': revision.clientId,
                    'disconnectedNodeAcknowledged': nfStorage.isDisconnectionAcknowledged()
                }),
                dataType: 'json'
            }).done(function (response) {
                // remove the service
                var controllerServiceGrid = serviceTable.data('gridInstance');
                var controllerServiceData = controllerServiceGrid.getData();
                controllerServiceData.deleteItem(controllerServiceEntity.id);

                // reload the as necessary
                if (controllerServiceEntity.permissions.canRead) {
                    reloadControllerServiceReferences(serviceTable, controllerServiceEntity.component);
                }
            }).fail(nfErrorHandler.handleAjaxError);
        }
    };

    return nfControllerService;
}));