(function () {
    'use strict';
    var app = angular.module('taskAdmin');
    var templatePath = modulesSharedResourcesUrl + 'Modules/TaskAdmin/Views/';


    //a directive that renders the task classes list
    app.directive('taskClassList', ['taskAdminDataContext', 'taskAdminService', 'common', '$location', '$modal', function (taskAdminDataContext, taskAdminService, common, $location, $modal) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'taskclasslist.html',
            link: link
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("taskClass", "success");
            var logError = getLogFn("taskClass", "error");

            // Get all the task classes for the user
            function getTaskClasses() {
                taskAdminService.getTaskClasses().then(function (data) {
                    $scope.taskClasses = data;
                    $scope.taskClassesLoaded = true;
                });
            }

            // function to delete a task class
            $scope.deleteTaskClass = function (taskClass) {
                taskAdminService.deleteTaskClass(taskClass).then(function (data) {
                    logSuccess("Task class successfully deleted");
                    getTaskClasses();
                });
            }

            // Function to manage a task class
            $scope.manageTaskClass = function (taskClass) {
                if (taskClass) {
                    taskAdminService.setCurrentTaskClass(taskClass);
                    $location.path('/manageclass');
                } else {
                    taskAdminService.setCurrentTaskClass(null);
                    $location.path('/manageclass');
                }
            }

            getTaskClasses();
 
        }
    }]);

    //a directive that enables the management of a task class
    app.directive('manageTaskClass', ['taskAdminDataContext', 'taskAdminService', 'common', '$location', '$modal', function (taskAdminDataContext, taskAdminService, common, $location, $modal) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'managetaskclass.html',
            link: link
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("taskClass", "success");
            var logError = getLogFn("taskClass", "error");

            $scope.changesMadeToTaskClass = false;
            $scope.fontAwesomeClasses = taskAdminService.getTaskClassIcons();
           
            //get the selected task class if exists in the service
            $scope.currentTaskClass = taskAdminService.getCurrentTaskClass();
          
            // Get the available response types
            function getResponseTypes() {
                taskAdminService.getResponseTypes().then(function (data) {
                    $scope.responseTypes = data;
                });
            }
            getResponseTypes();

            //if it doesn't exist use the service to create a blank task class
            if (!$scope.currentTaskClass) {
                $scope.currentTaskClass = taskAdminService.createBlankTaskClass();
            }

            if ($scope.currentTaskClass.isInUse) {
                $scope.isInUse = true;
            }

            // Watch for changes to the task class
            $scope.$watchCollection('currentTaskClass', function (newValue, oldValue) {
                if (newValue !== oldValue) {
                    $scope.changesMadeToTaskClass = true;
                }
            }, true);

            // Function to go back to the task classes list
            $scope.goBack = function () {
                $location.path('/taskclass');
            };

            // Set the selected response type id
            $scope.responseTypeSelected = function (responseTypeId) {
                for (i in $scope.currentTaskClass.taskClassResponseTypes) {
                    if ($scope.currentTaskClass.taskClassResponseTypes[i].taskResponseId == responseTypeId) {
                        return true;
                    }
                }
                return false;
            }

            // function to create or save a task class
            $scope.saveTaskClass = function () {
                if (!$scope.currentTaskClass.id) {
                    taskAdminService.createTaskClass($scope.currentTaskClass).then(function (data) {
                        logSuccess("Task class successfully created");
                        $location.path('/taskclass');
                    });
                } else {
                    taskAdminService.updateTaskClass($scope.currentTaskClass).then(function (data) {
                        logSuccess("Task class successfully updated");
                        $location.path('/taskclass');
                    });
                }
            }

            // function to publish a task class
            $scope.publishTaskClass = function () {
                $scope.currentTaskClass.status = 1;
                if ($scope.currentTaskClass.id) {
                    taskAdminService.updateTaskClass($scope.currentTaskClass).then(function (data) {
                        logSuccess("Task class successfully published");
                        $location.path('/taskclass');
                    });
                } else {
                    taskAdminService.createTaskClass($scope.currentTaskClass).then(function (data) {
                        logSuccess("Task class successfully created and published");
                        $location.path('/taskclass');
                    });
                }
            }

            // function to withdraw a task class
            $scope.withdrawTaskClass = function () {
                $scope.currentTaskClass.status = 2;
                taskAdminService.updateTaskClass($scope.currentTaskClass).then(function (data) {
                    logSuccess("Task class successfully withdrawn");
                    $location.path('/taskclass');
                });
            }

            // function to clear down selected values that relate to a disabled function
            $scope.dynamicSelector = function () {
                if (!$scope.currentTaskClass.completionNotifier) {
                    $scope.currentTaskClass.completionBadgeIssuing = false;
                    $scope.currentTaskClass.completionDeliverableRequired = false;
                    $scope.currentTaskClass.markingSchemeRequired = false;
                    $scope.currentTaskClass.taskClassResponseTypes = [];
                }
                if (!$scope.currentTaskClass.completionDeliverableRequired) {
                    $scope.currentTaskClass.taskClassResponseTypes = [];
                }
            }
        }
    }]);

    //a directive that renders the task classes list
    app.directive('taskList', ['taskAdminDataContext', 'taskAdminService', 'common', '$location', '$modal', function (taskAdminDataContext, taskAdminService, common, $location, $modal) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'tasklist.html',
            link: link
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("taskClass", "success");
            var logError = getLogFn("taskClass", "error");


            // Define the status filters
            $scope.filters = [
              { name: 'Draft', value: 0 },
              { name: 'Published', value: 1 },
              { name: 'Withdrawn', value: 2 }
            ];

            // Set the initail filter values
            $scope.filterValues = [0, 1];

            // Apply the status filters
            $scope.applyStatusFilter = function (value, index) {
                return $scope.filterValues.indexOf(value.status) !== -1;
            }

            // Get all the task classes for the user
            function getTasks() {
                taskAdminService.getAllTasks().then(function (data) {
                    $scope.tasks = data;
                    $scope.tasksLoaded = true;
                });
            }

            $scope.createTask = function () {
                taskAdminService.getDefaultTaskClass().then(function (data) {
                    $scope.task = taskAdminService.createBlankTask();
                    $scope.task.taskClassId = data.id;
                    $scope.task.taskClass = data;
                    taskAdminService.setCurrentTask($scope.task);
                    $location.path('/managetask');
                });          
            }

            //// call the create task modal
            //$scope.createTaskModal = function () {
            //    $modal.open({
            //        templateUrl: templatePath + '/chooseclass.html',
            //        controller: typeController,
            //        size: 'sm',
            //        backdrop: 'static'
            //    });
            //}


            //var typeController = function (common, $scope, $modalInstance) {              
            //    // Get all the task classes for the user
            //    function getTaskClasses() {
            //        taskAdminService.getTaskClasses().then(function (data) {
            //            $scope.taskClasses = data;
            //            $scope.taskClassesLoaded = true;
            //        });
            //    }

            //    getTaskClasses();

            //    // function to create a task
            //    $scope.createTask = function (taskClass) {
            //        $scope.task = taskAdminService.createBlankTask();
            //        $scope.task.taskClassId = taskClass.id;
            //        $scope.task.taskClass = taskClass;
            //        taskAdminService.setCurrentTask($scope.task);
            //        $location.path('/managetask');
            //        $modalInstance.dismiss('cancel');
            //    }

            //    //close the modal
            //    $scope.cancel = function () {
            //        $modalInstance.dismiss('cancel');
            //    };
            //}

            // function to delete a task class
            $scope.deleteTask = function (task) {
                taskAdminService.deleteTask(task).then(function (data) {
                    logSuccess("Task successfully deleted");
                    getTasks();
                });
            }

            // function to manage a task class
            $scope.manageTask = function (task) {
                taskAdminService.getTaskRecord(task).then(function () {
                    $location.path('/managetask');
                });
            }

            getTasks();
        }
    }]);

    //a directive that enables the management of a task class
    app.directive('manageTask', ['taskAdminDataContext', 'taskAdminService', 'myBadgesSelectorDataContext', 'markingSchemeAdminDataContext', 'markingSchemeAdminService', 'OrganisationAdminService', 'myFormsAdminDataContext', 'myUsersDataContext', 'fileUpload', 'common', '$location', '$modal', '$filter', 'rulesAdminDataContext', function (taskAdminDataContext, taskAdminService, myBadgesSelectorDataContext, markingSchemeAdminDataContext, markingSchemeAdminService, OrganisationAdminService, myFormsAdminDataContext, myUsersDataContext, fileUpload, common, $location, $modal, $filter, rulesAdminDataContext) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'managetask.html',
            link: link,
            scope: {
                autoComplete: '='
            },
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("taskClass", "success");
            var logError = getLogFn("taskClass", "error");
            $scope.anyForm = true;
            $scope.newValue = {};
            $scope.changesMadeToTask = false;
           
            //Get form types but exclude CPD and Quiz
            $scope.formTypes = taskAdminService.getFormTypes();       
            $scope.formTypes = $filter('filter')($scope.formTypes, function(formType){
                return formType.name != 'CPD' && formType.name != 'Quiz'
            });


         


            // function to get back to the task definitions list
            $scope.goBack = function () {
                $location.path('#!/tasks');
            };

            //get the selected task from the service
            $scope.currentTask = taskAdminService.getCurrentTask();

            if (!$scope.currentTask) {
                $location.path('/tasks');
            } else {

                if ($scope.currentTask.autoCompleteBadgeId)
                    $scope.currentTask.autoCompleteBadges = [{
                        badgeId: $scope.currentTask.autoCompleteBadgeId,
                        automaticIssue: false
                    }];
                else
                    $scope.currentTask.autoCompleteBadges = [];
            }

            // Watch for changes to the task class
            $scope.$watchCollection('currentTask', function (newValue, oldValue) {
                if (newValue !== oldValue) {
                    $scope.changesMadeToTask = true;
                }
            }, true);

            // Watch for changes to the task marking schemes
            $scope.$watchCollection('currentTask.taskMarkingSchemes', function (newValue, oldValue) {
                if (newValue !== oldValue) {
                    $scope.changesMadeToTask = true;
                }
            }, true);

            // Watch for changes to the task badges
            $scope.$watchCollection('currentTask.taskBadges', function (newValue, oldValue) {
                if (newValue !== oldValue) {
                    $scope.changesMadeToTask = true;
                }
            }, true);

            // Watch for changes to the task steps
            $scope.$watchCollection('currentTask.taskSteps', function (newValue, oldValue) {
                if (newValue !== oldValue) {
                    $scope.changesMadeToTask = true;
                }
            }, true);

            // Watch for changes to the task badges
            $scope.$watchCollection('currentTask.autoCompleteBadges', function (newValue, oldValue) {
                if (newValue !== oldValue) {
                    $scope.changesMadeToTask = true;
                    if (newValue.length > 0)
                        $scope.currentTask.autoCompleteBadgeId = newValue[0].badgeId
                    else 
                        $scope.currentTask.autoCompleteBadgeId = null
                }
            }, true);

            // Change between the tabs
            $scope.changeTab = function (tab) {
                $scope.detail = false;
                $scope.steps = false;
                $scope.responsetype = false;
                $scope.ms = false;
                $scope.badges = false;
                $scope.autocomplete = false;
                if (tab == 'description') {
                    $scope.detail = true;
                }
                if (tab == 'steps') {
                    $scope.steps = true;
                }
                if (tab == 'response') {
                    $scope.responsetype = true;
                }
                if (tab == 'schemes') {
                    $scope.ms = true;
                }
                if (tab == 'badges') {
                    $scope.badges = true;
                }
                if (tab == 'autocomplete') {
                    $scope.autocomplete = true;
                }
            }

            // Get all the marking scemes for the user
            function getAvailableMarkingSchemes() {
                markingSchemeAdminDataContext.getAllMarkingSchemes().then(function (data) {
                    $scope.markingSchemes = [];
                    for (i in data) {
                        if (data[i].status == 1) {
                            $scope.markingSchemes.push(data[i]);
                        }
                    }
                    $scope.markingSchemesLoaded = true;
                });
            }

            getAvailableMarkingSchemes();

            // Get all the available forms for a user
            function getAvailableForms() {
                myFormsAdminDataContext.getTemplatesICanManage().then(function (data) {
                    $scope.availableForms = [];
                    for (i in data) {
                        if (data[i].isPublished && data[i].formType != 5) { //don't include activity types
                            $scope.availableForms.push(data[i]);
                        }
                    }
                    $scope.availableFormsLoaded = true;
                });            
            }

            //Set the form template as the response type
            $scope.setSelectedForm = function (selectedForm) {
                $scope.selectedForm = selectedForm;
                $scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties = [];
                if (selectedForm) {
                    $scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties.push({
                        name: 'formTemplateId',
                        value: selectedForm.id
                    });
                }
            }

            // Get the selected form if one has already been associated with the task
            $scope.getSelectedForm = function () {
                if (!$scope.currentTask) {
                    return;
                }
                if ($scope.currentTask.taskResponseTypes.length>0) {
                    if ($scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties.length > 0) {
                        if ($scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties[0].name == 'formTemplateId') {
                            getAvailableForms();
                            $scope.specificForm = true;
                            $scope.anyForm = false;
                            myFormsAdminDataContext.getFormTemplate($scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties[0].value).then(function (data) {
                                $scope.selectedForm = data;
                                $scope.availableFormsLoaded = true;
                            });
                        }
                        if ($scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties[0].name == 'formType') {
                            $scope.Types = true;
                            $scope.formType = parseInt($scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties[0].value);
                            $scope.specificForm = false;
                            $scope.anyForm = false;
                        }
                    }
                }                      
            }

            // Set the form response type
            $scope.setFormResponseType = function (type) {
                if (type == 'any') {
                    $scope.anyForm = true;
                    $scope.specificForm = false;
                    $scope.Types = false;
                    $scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties = [];
                }
                if (type == 'specific') {
                    $scope.anyForm = false;
                    $scope.specificForm = true;
                    $scope.Types = false;
                    getAvailableForms();
                }
                if (type == 'type') {
                    $scope.anyForm = false;
                    $scope.specificForm = false;
                    $scope.Types = true;
                }
            }

            //Get the already set marking schemes
            $scope.getMarkingScheme = function (markingScheme) {
                markingSchemeAdminDataContext.getMarkingScheme(markingScheme.markingSchemeId).then(function (data) {
                    markingScheme.markingScheme = data;
                    return markingScheme;
                });
            }

            $scope.autoCompleteChange = function (checked) {
                if (checked) {
                    $scope.currentTask.taskMarkingSchemes = [];
                };
            }

            // Get the already selected badge details
            $scope.getBadgeDetails = function (badge) {
                if (badge.badgeId) {
                    taskAdminDataContext.getTemplate(badge.badgeId).then(function (data) {
                        badge.badge = data;
                        return badge;
                    });
                } else if (badge.value) {
                    taskAdminDataContext.getTemplate(badge.value).then(function (data) {
                        badge.badge = data;
                        return badge;
                    });
                }
            }

            // Get the already selected badge details
            $scope.getAutoCompleteBadgeDetails = function () {
                taskAdminDataContext.getTemplate($scope.currentTask.autoCompleteBadgeId).then(function (data) {
                    $scope.currentTask.autoCompleteBadge = data;
                });
            }

            // Function to add a new value to the marking schemes values
            $scope.addNewStep = function (nameForm, descriptionForm) {
                $scope.currentTask.taskSteps.push({
                    name: $scope.newValue.newStepName,
                    description: $scope.newValue.newStepDescription,
                    ordinal: $scope.currentTask.taskSteps.length
                });
                $scope.newValue.newStepName = '';
                $scope.newValue.newStepDescription = '';
                nameForm.$setPristine()
                descriptionForm.$setPristine()
            }
     
            // Add a marking scheme to the task
            $scope.addMarkingScheme = function (schemeId) {
                $scope.isAdding = true;
                markingSchemeAdminDataContext.getMarkingScheme(schemeId).then(function (data) {
                    if(data){
                        var exists = false;
                        data.markingSchemeId = schemeId;
                        data.taskMarkingSchemeValues = data.markingSchemeValues;
                        for (i in $scope.currentTask.taskMarkingSchemes) {
                            if ($scope.currentTask.taskMarkingSchemes[i].markingSchemeId == data.markingSchemeId) {
                                exists = true;
                                $scope.markingSchemeError = 'This grading system has already been added.';
                            }
                        }
                        if (!exists) {
                            data.ordinal = $scope.currentTask.taskMarkingSchemes.length
                            data.markingSchemeType = data.type;
                            $scope.currentTask.taskMarkingSchemes.push(data);
                        }
                        $scope.currentTask.autoComplete = false;
                    }
                    $scope.isAdding = false;
                }).catch(function(ex){
                    $scope.isAdding = false; 
                });
            }

            // Set the selected marking scheme
            $scope.setMarkingSchemeToAdd = function () {
                $scope.markingSchemeError = null;
            }

            // Set the marking scheme values in the correct order
            $scope.setSchemeValueOrdinal = function (value, scheme) {
                for (var j = 0; j < scheme.markingSchemeValues.length; j++) {
                    if (value.name == scheme.markingSchemeValues[j].name) {
                        value.ordinal = scheme.markingSchemeValues[j].ordinal;
                    }
                }
            }

            // determine which response type has been selected
            $scope.responseTypeSelected = function (responseType) {
                for (i in $scope.currentTask.taskResponseTypes) {
                    if ($scope.currentTask.taskResponseTypes[i].taskClassResponseTypeId == responseType.id) {
                        if (responseType.name == 'Form') {
                            $scope.showFormResponse = true;
                            $scope.showShowcaseResponse = false;
                        }
                        if (responseType.name == 'Showcase') {
                            $scope.showShowcaseResponse = true;
                            $scope.showFormResponse = false;
                        }
                        return true;
                    }
                }
                return false;
            }

            // Set the selected response type
            $scope.setResponseType = function (responseType) {
				$scope.showFormResponse = false;
                $scope.showShowcaseResponse = false;
			    $scope.currentTask.taskResponseTypes = [];
				$scope.selectedForm = null;
				$scope.anyForm = false;
                $scope.specificForm = false;
                $scope.Types = false;
				
                if ($scope.currentTask.responseSelected) {
                    if (responseType.name == 'Form') {
                        $scope.showFormResponse = true;
                        $scope.showShowcaseResponse = false;
                    }
                    if (responseType.name == 'Showcase') {
                        $scope.showShowcaseResponse = true;
                        $scope.showFormResponse = false;
                    }
                    $scope.currentTask.taskResponseTypes = [];
                    $scope.currentTask.taskResponseTypes.push({
                        taskClassResponseTypeId: responseType.id,
                        taskResponseTypeProperties: []
                    });
                } 
            }

            // Modal to add badges to the overall task
            $scope.addBadges = function () {
                myBadgesSelectorDataContext.showSelectorModal($scope.currentTask.taskBadges, false, true); //singleSelect: false, publishedOnly: true
            }

            $scope.addAutoCompleteBadges = function () {
                myBadgesSelectorDataContext.showSelectorModal($scope.currentTask.autoCompleteBadges, true, true); //singleSelect: false, publishedOnly: true
            }

            // Modal to add badges to marking scheme values
            $scope.addMarkingSchemeBadges = function (markingSchemeValue) {
                $modal.open({
                    templateUrl: templatePath + 'addbadges.html',
                    controller: addMarkingSchemeBadgesController,
                    size: 'lg',
                    backdrop: 'static',
                    resolve: {
                        markingSchemeValue: function () {
                            return markingSchemeValue;
                        },
                        changesMade: function () {
                            return $scope.changesMadeToTask;
                        }
                    }
                });
            }

            // Controller for adding badges to task marking schemes
            var addMarkingSchemeBadgesController = function (common, $scope, $modalInstance, markingSchemeValue, changesMade) {
                $scope.markingSchemeValue = markingSchemeValue;
                $scope.changesMadeToTask = changesMade;
                OrganisationAdminService.getAdministrationOrgs().then(function (data) {
                    //TODO This will be depreciated soon due to moving organisations into mybadges
                    var orgIds = [];
                    for (i in data) {
                        orgIds.push(data[i].id);
                    };
                    taskAdminDataContext.getPublishedTemplatesByOrgs(orgIds).then(function (data) {
                        $scope.badges = data;
                        $scope.badgesLoaded = true;
                    });
                });

                $scope.selectBadge = function (badge) {
                    $scope.changesMadeToTask = true;
                    $scope.markingSchemeValue.taskMarkingSchemeValueProperties = [];
                    if (badge.selected) {
                        $scope.markingSchemeValue.taskMarkingSchemeValueProperties.push({
                            name: 'badgeId',
                            value: badge.id,
                        });
                    } else {
                        return;
                    }
                }

                $scope.isSelected = function (badgeId) {
                    if ($scope.markingSchemeValue.taskMarkingSchemeValueProperties) {
                        if ($scope.markingSchemeValue.taskMarkingSchemeValueProperties.length > 0) {
                            if ($scope.markingSchemeValue.taskMarkingSchemeValueProperties[0].value == badgeId) {
                                return true;
                            }
                        }
                    }
                    return false;
                }

                //close the modal
                $scope.cancel = function () {
                    $modalInstance.dismiss('cancel');
                };
            }

            // Function to go back to the task classes list
            $scope.goBack = function () {
                $location.path('/tasks');
            };

            // function to save a task class
            $scope.saveTask = function () {
                $scope.isSaving = true;
                $scope.numberOfFiles = 0;
                if ($scope.currentTask.taskAttachments.length > 0) {
                    for (i in $scope.currentTask.taskAttachments) {
                        if (!$scope.currentTask.taskAttachments[i].id) {
                            $scope.numberOfFiles = $scope.numberOfFiles + 1
                        }
                    }
                    for (i in $scope.currentTask.taskAttachments) {
                        if ($scope.currentTask.taskAttachments[i].file) {
                            //make sure the filename is valid - remove any % and ; symbols
                            var fileName = $scope.currentTask.taskAttachments[i].file.fileName.replace(/[%;&()#\s]/g, '');
                            $scope.currentTask.taskAttachments[i].file.fileName = fileName;
                            //$scope.currentTask.taskAttachments[i].file.name = fileName;
                            fileUpload.uploadFile($scope.currentTask.taskAttachments[i].file, $scope.currentTask.taskAttachments[i].file, fileUploadSuccess, UploadProgress, UploadError, 'task-resources');
                        }
                        if ($scope.numberOfFiles > 0) {
                            $scope.uploading = true;
                        }
                    }
                }

                if (!$scope.uploading) {
                    if ($scope.currentTask.id) {
                        taskAdminDataContext.updateTask($scope.currentTask).then(function (data) {
                            logSuccess("Task successfully updated");
                            $location.path('/tasks');
                            $scope.isSaving = false;
                        });
                    } else {
                        taskAdminDataContext.createTask($scope.currentTask).then(function (data) {
                            logSuccess("Task successfully created");
                            $location.path('/tasks');
                            $scope.isSaving = false;
                        });
                    }
                }
            }

            // function to publish a task
            $scope.publishTask = function (assign) {
                $scope.isSaving = true;
				$scope.isFirstPublish = $scope.currentTask.status === 0;
                $scope.assign = assign;
                $scope.numberOfFiles = 0;
                $scope.currentTask.status = 1;
                $scope.assigning = true;

                if ($scope.currentTask.taskAttachments.length > 0) {
                    for (i in $scope.currentTask.taskAttachments) {
                        if (!$scope.currentTask.taskAttachments[i].id) {
                            $scope.numberOfFiles = $scope.numberOfFiles + 1
                        }
                    }
                    for (i in $scope.currentTask.taskAttachments) {
                        if ($scope.currentTask.taskAttachments[i].file) {
                            var fileName = $scope.currentTask.taskAttachments[i].file.fileName.replace(/[%;&()#\s]/g, '');
                            $scope.currentTask.taskAttachments[i].file.fileName = fileName;
                            fileUpload.uploadFile($scope.currentTask.taskAttachments[i].file, $scope.currentTask.taskAttachments[i].file, fileUploadSuccess, UploadProgress, UploadError, 'task-resources');
                        }
                        if ($scope.numberOfFiles > 0) {
                            $scope.uploading = true;
                        }
                    }
                }

                if (!$scope.uploading) { 
                    if ($scope.currentTask.id) {
                        taskAdminService.updateTask($scope.currentTask).then(function (data) {
                            logSuccess("Task successfully published");

                            if ($scope.currentTask.autoComplete && $scope.currentTask.autoCompleteBadgeId && $scope.isFirstPublish) {
                                $scope.createTaskRule($scope.currentTask.id);
                            }

                            if (!$scope.assign) {
                                $location.path('/tasks');
                            } else {
                                $scope.publishAssignTask($scope.currentTask);
                            }
                        });
                    } else {
                        taskAdminService.createTask($scope.currentTask).then(function (data) {
                            $scope.currentTask.id = data.id;

                            if ($scope.currentTask.autoComplete && $scope.currentTask.autoCompleteBadgeId && $scope.isFirstPublish) {
                                $scope.createTaskRule(data.id);
                            }

                            logSuccess("Task successfully published");
                            if (!$scope.assign) {
                                $location.path('/tasks');
                            } else {
                                $scope.publishAssignTask(data);
                            }
                        });
                    }

                  
                }
            }

            $scope.createTaskRule = function (taskId) {
                var shortName = $scope.currentTask.name.match(/\b\w/g) || [];
                shortName = ((shortName.shift() || '') + (shortName.pop() || '')).toUpperCase();
                var rule = {
                    name: $scope.currentTask.name,
                    shortName: shortName,
                    description: $scope.currentTask.description,
                    enabled: true,
                    readOnly: true,
                    rule: {
                        collection: [
                            {
                                activityId: taskId,
                                condition: {
                                    type: "exists",
                                },
                                type: "singular",
                            }
                        ],
                        logicType: "and",
                        type: "collection"
                    },
                    outcomes: [
                        {
                            ordinal: 0,
                            itemId: $scope.currentTask.autoCompleteBadgeId,
                            type: "badge"
                        }
                    ]
                };
                rulesAdminDataContext.createRule(rule);
            }

            $scope.publishAssignTask = function (task) {
                $modal.open({
                    templateUrl: templatePath + 'assignmodal.html',
                    controller: publishAssignTaskController,
                    size: 'lg',
                    resolve: {
                        task: function () {
                            return task;
                        }
                    },
                    backdrop: 'static'
                });
            }

            var publishAssignTaskController = function (common, $scope, $modalInstance, task) {
                $scope.selectedTask = task;
                $scope.chosenOrganisations = [];

                $scope.assignTask = function () {
                    $scope.isSaving = true;
                    $scope.assigning = true;
                    var assignment = {
                        taskRecordId: $scope.selectedTask.id,
                        assigneeIds: $scope.chosenOrganisations,
                        groupWork: false,
                        deadline: $scope.selectedTask.deadline,
                        taskAssignmentType: 1,
                        autoComplete: $scope.selectedTask.autoComplete

                    }
                    taskAdminService.assignTaskToGroup(assignment).then(function (data) {
                        logSuccess("Tasks successfully assigned");
                        $modalInstance.dismiss('cancel');
                        $location.path('/assignedtask/' + data.id);
                    }); 
                }

                //close the modal
                $scope.cancel = function () {
                    $modalInstance.dismiss('cancel');
                };

                $scope.tomorrow = new Date();
                $scope.tomorrow.setDate($scope.tomorrow.getDate() + 1);
            }

            // function to withdraw a task class
            $scope.withdrawTask = function () {
                $scope.currentTask.status = 2;
                taskAdminService.updateTask($scope.currentTask).then(function (data) {
                    logSuccess("Task successfully withdrawn");
                    $location.path('/tasks');
                });
            }

            // Check the task forms validility
            $scope.checkTaskValidility = function (saveOnly) {
                if ($scope.currentTask) {
                    if ($scope.createTaskForm.$invalid) {
                        return false;
                    }
                    if ($scope.createTaskFormDetails.$invalid && !saveOnly) {
                        return false;
                    }
                    if ($scope.specificForm && $scope.currentTask.taskResponseTypes[0] && !$scope.selectedForm && !saveOnly) {
                        return false;
                    }
                    if ($scope.specificForm && $scope.currentTask.taskResponseTypes[0] && !$scope.selectedForm && !saveOnly) {
                        return false;
                    }
                    if ($scope.Types && $scope.currentTask.taskResponseTypes[0] && $scope.currentTask.taskResponseTypes[0].taskResponseTypeProperties.length == 0 && !saveOnly) {
                        return false;
                    }
                    //if ($scope.currentTask.taskClass) {
                    //    if ($scope.currentTask.taskClass.completionDeliverableRequired && $scope.currentTask.taskResponseTypes.length == 0 && !saveOnly) {
                    //        return false;
                    //    }
                    //}
                    if ($scope.currentTask.taskSteps && $scope.currentTask.taskSteps.length) {
                        for (i in $scope.currentTask.taskSteps) {
                            if ($scope.currentTask.taskSteps[i].editing) {
                                return false;
                            }
                        }
                    }
                    return true;
                }
            }

            $scope.setStepOrder = function (evt) {
                for (i in $scope.currentTask.taskSteps) {
                    if ($scope.currentTask.taskSteps[i].ordinal == evt.newIndex) {
                        $scope.currentTask.taskSteps[i].ordinal = evt.oldIndex;
                    }
                    if ($scope.currentTask.taskSteps[i].name == evt.model.name) {
                        $scope.currentTask.taskSteps[i].ordinal = evt.newIndex;
                    }
                }
            }

            $scope.setMarkingOrder = function (evt) {
                for (i in $scope.currentTask.taskMarkingSchemes) {
                    if ($scope.currentTask.taskMarkingSchemes[i].ordinal == evt.newIndex) {
                        $scope.currentTask.taskMarkingSchemes[i].ordinal = evt.oldIndex;
                    }
                    if ($scope.currentTask.taskMarkingSchemes[i].name == evt.model.name) {
                        $scope.currentTask.taskMarkingSchemes[i].ordinal = evt.newIndex;
                    }
                }
            }
          
            $scope.changeTaskClassModal = function () {
                $modal.open({
                    templateUrl: templatePath + 'chooseclass.html',
                    controller: changeTaskClassController,
                    size: 'sm',
                    resolve: {
                        task: function () {
                            return $scope.currentTask;
                        }
                    }
                });
            }

            var changeTaskClassController = function (common, $scope, $modalInstance, task) {
                $scope.task = task;
                $scope.isChanging = true;

                // Get all the task classes for the user
                function getTaskClasses() {
                    taskAdminService.getTaskClasses().then(function (data) {
                        $scope.taskClasses = data;
                        $scope.taskClassesLoaded = true;
                    });
                }

                $scope.createTask = function (taskClass) {
                    $scope.task.taskClass = taskClass;
                    $scope.task.taskClassId = taskClass.id;
                    $modalInstance.dismiss('cancel');
                }

                //close the modal
                $scope.cancel = function () {
                    $modalInstance.dismiss('cancel');
                };

                getTaskClasses();

            }

            // Called when image file has been selected
            $scope.onFileSelect = function (files) {
                if (files) {
                    $scope.errorMessage = null;
                    $scope.file = files[0];
                    if($scope.file != null){
                        $scope.file.fileName = $scope.file.name;
                        if ($scope.file.size > 40000000) {
                            $scope.errorMessage = 'File size is too large, max 40MB';
                            return;
                        }
                        if ($scope.currentTask.taskAttachments == null) {
                            $scope.currentTask.taskAttachments = [];
                        }
                        $scope.currentTask.taskAttachments.unshift({
                            file: $scope.file,
                            name: '',
                            description: '',
                            fileExtension: $scope.file.type,
                            fileUrl: '',
                            fileType: 2,
                            fileName: $scope.file.name,
                            visibility: true
                        });
                    }
                }
            }

            //called when a logo is uploaded
            function fileUploadSuccess(files, data) {
                handleUploadResponse(files, data);
                return;
            }

            function handleUploadResponse(files, response) {
                $scope.numberOfFiles = $scope.numberOfFiles - 1;
				$scope.isFirstPublish = $scope.currentTask.status === 0;
				
                for (i in $scope.currentTask.taskAttachments) {
                    if ($scope.currentTask.taskAttachments[i].file) {
                        if ($scope.currentTask.taskAttachments[i].file.lastModified == files.lastModified) {
                            $scope.currentTask.taskAttachments[i].fileUrl = files.fileUrl;
                        }
                    }
                }

                if ($scope.numberOfFiles == 0) {
                    if (!$scope.currentTask.id) {
                        taskAdminService.createTask($scope.currentTask).then(function (data) {
                            logSuccess("Task successfully created");
							
							if ($scope.currentTask.autoComplete && $scope.currentTask.autoCompleteBadgeId && $scope.isFirstPublish) {
                                $scope.createTaskRule(data.id);
                            }

                            if (!$scope.assign) {
                                $location.path('/tasks');
                            } else {
                                $scope.publishAssignTask(data);
                            }
                        });
                    } else {
                        taskAdminService.updateTask($scope.currentTask).then(function (data) {
                            logSuccess("Task successfully updated");
							
							if ($scope.currentTask.autoComplete && $scope.currentTask.autoCompleteBadgeId && $scope.isFirstPublish) {
                                $scope.createTaskRule($scope.currentTask.id);
                            }
							
                            if (!$scope.assign) {
                                $location.path('/tasks');
                            } else {
                                $scope.publishAssignTask($scope.currentTask);
                            }
                        });
                    }
                }
            }

            // Generate the image upload process percentage
            function UploadProgress(percentComplete) {
                $scope.progress = percentComplete;
                $scope.uploadStatus = "Uploading... " + percentComplete + "%";
            }

            function UploadError() {
                // Throw an error
            }

            $scope.removeAttachment = function (file) {
                for (i in $scope.currentTask.taskAttachments) {
                    if (file.id) {
                        if ($scope.currentTask.taskAttachments[i].id == file.id) {
                            $scope.currentTask.taskAttachments.splice(i, 1);
                            return;
                        }
                    } else {
                        if ($scope.currentTask.taskAttachments[i].file) {
                            if ($scope.currentTask.taskAttachments[i].file.lastModified == file.file.lastModified) {
                                $scope.currentTask.taskAttachments.splice(i, 1);
                                return;
                            }
                        }
                    }
                }
            }
        }
    }]);


    //a directive that allows the ability to assign a task
    app.directive('assignTask', ['taskAdminDataContext', 'taskAdminService', 'common', '$location', '$modal', function (taskAdminDataContext, taskAdminService, common, $location, $modal) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'assigntask.html',
            link: link
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("assignTask", "success");
            var logError = getLogFn("assignTask", "error");

            $scope.selectedTasks = [];
            $scope.chosenOrganisations = [];
            
            //Tomorrow's date value is used to restrict the minimum deadline date
            $scope.tomorrow = new Date();
            $scope.tomorrow.setDate($scope.tomorrow.getDate() + 1);

            // Get all the task classes for the user
            function getTasks() {
                taskAdminService.getAllTasks().then(function (data) {
                    $scope.tasks = data;
                    $scope.tasksLoaded = true;
                });
            }



            $scope.assignTask = function () {
                $scope.isSaving = true;
                for (var j = 0; j <  $scope.selectedTasks.length; j++) {
                    var assignment = {
                        taskRecordId: $scope.selectedTasks[j].id,
                        assigneeIds: $scope.chosenOrganisations,
                        groupWork: false,
                        deadline: $scope.selectedTasks[j].deadline,
                        taskAssignmentType: 1,
                        autoComplete: $scope.selectedTasks[j].autoComplete
                    }
                    taskAdminService.assignTaskToGroup(assignment).then(function (data) {
                        logSuccess("Tasks successfully assigned");
                        $location.path('/assignedtasks');
                    });                
                }
            }

            getTasks();
        }
    }]);

    //a directive that allows the ability to assign a task
    app.directive('assignedTasks', ['taskAdminDataContext', 'taskAdminService', 'common', '$location', '$modal', function (taskAdminDataContext, taskAdminService, common, $location, $modal) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'assignedtasks.html',
            link: link,
            scope: {
                autoComplete: '='
            }
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("assignedTasks", "success");
            var logError = getLogFn("assignedTasks", "error");

            // Define the status filters
            $scope.filters = [
              { name: 'Open', value: 0 },
              { name: 'Recalled', value: 1 }
            ];

            $scope.filterValues = [0];

            // Apply the status filters
            $scope.applyStatusFilter = function (value, index) {
                return $scope.filterValues.indexOf(value.status) !== -1;
            }

            // Get all the task classes for the user
            function getAssignedTasks() {
                taskAdminService.getAssignedTasksSimple().then(function (data) {
                    $scope.assignedTasks = data;
                    $scope.assignedTasksLoaded = true;
                });
            }

            // Function to manage a task class
            $scope.manageAssignedTask = function (assignedTask) {
                //taskAdminService.setCurrentAssignedTask(assignedTask);
                $location.path('/assignedtask/' + assignedTask.id);
            }

            $scope.getAssignerDetails = function (assigner) {
                if (assigner) {
                    user.getUserProfile(assigner.createdBy).then(function (data) {
                        assigner.user = data;
                    });
                }
            }

            getAssignedTasks();
        }
    }]);

    //a directive that allows the ability to assign a task
    app.directive('viewAssignedTask', ['taskAdminDataContext', 'taskAdminService', 'myUsersDataContext', 'markingSchemeAdminDataContext', 'myFormsDataContext', '$routeParams', 'common', 'user', '$location', '$filter', function (taskAdminDataContext, taskAdminService, myUsersDataContext, markingSchemeAdminDataContext, myFormsDataContext, $routeParams, common, user, $location, $filter) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'viewassignedtask.html',
            link: link
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("viewAssignedTask", "success");
            var logError = getLogFn("viewAssignedTask", "error");
            //get the selected task from the service
            $scope.assignedTaskId = $routeParams.assignedTaskId;
            $scope.currentAssignedTask = null;
            $scope.noResponseCount = 0;
            $scope.toReviewCount = 0;
            $scope.inProgressCount = 0;
            $scope.underReviewCount = 0;
            $scope.reviewedCount = 0;
            $scope.returnedCount = 0;
            $scope.completedCount = 0;
            $scope.visibleUserCount = 20;

            $scope.orderByPredicate = 'assignment.latestResponse.dateCreated';
            $scope.assignedUsers = [];
            $scope.userAssignments = [];

            $scope.currentAssignedTask = taskAdminService.getCurrentAssignedTask();

            if (!$scope.assignedTaskId) {
                $location.path('/assignedtasks');
            }
            else {
                $scope.recipients = true;
                getUser();
                getAssignedTask();
            }

            $scope.getFormTypeName = function (type) {
                type = parseInt(type);
                var typeName = taskAdminService.getFormTypeName(type);
                return typeName;
            }

            $scope.showMoreUsers = function () {
                $scope.visibleUserCount = $scope.visibleUserCount + 4;
            }

            function getAssignedTask () {
                taskAdminService.getAssignedTask($scope.assignedTaskId).then(function (data) {
                    taskAdminService.setCurrentAssignedTask(data);
                    $scope.currentAssignedTask = data;
                    getAssignedUsers()
                });
            };

            $scope.showAllGrades = function (showAll) {
                if (showAll) {
                    for (i in $scope.users) {
                        if ($scope.users[i])
                            $scope.users[i].showMarks = true;
                    }
                } else {
                    for (i in $scope.users) {
                        if ($scope.users[i])
                            $scope.users[i].showMarks = false;
                    }
                }
            }

            function getUser() {
                user.getProfile().then(function (user) {
                    $scope.reviewer = user;
                });
            }

            $scope.getFormDetail = function(formId) {
                myFormsDataContext.getFormTemplate(formId).then(function (form) {
                    $scope.selectedForm = form;
                });
            }

            // Define the status filters
            $scope.filters = [
              { name: 'No response', value: 0 },
              { name: 'Recalled', value: 1 },
              { name: 'To review', value: 4 },
              { name: 'Under review', value: 5 },
              { name: 'Returned', value: 7 },
              { name: 'Reviewd', value: 6 },
              { name: 'Completed', value: 8 },
              { name: 'In progress', value: 9 }
            ];

            $scope.filterValues = [0, 4, 5, 6, 7, 8, 9];

            $scope.filterSelectAll = function (value) {
                if ($scope.filterValues.length === 8) {
                    $scope.filterValues = "unassigned";
                } else {
                    $scope.filterValues = [0, 1, 4, 5, 6, 7, 8, 9];
                }
            }

            $scope.filterSelectAll();

            // Apply the status filters
            $scope.applyStatusFilter = function (value, index) {
                if ($scope.filterValues == "unassigned") {
                    return !value.assigned;
                }
                if (value != null && value.assignment)
                    return $scope.filterValues.indexOf(value.assignment.status) !== -1;

            }

            function getAssignedUsers() {

                user.getUserProfile($scope.currentAssignedTask.createdBy).then(function (data) {
                    $scope.currentAssignedTask.user = data;
                });

                taskAdminService.getAssignedUsers($scope.currentAssignedTask).then(function (users) {
                    $scope.toReviewCount = 0;
                    $scope.inProgressCount = 0;
                    $scope.underReviewCount = 0;
                    $scope.reviewedCount = 0;
                    $scope.returnedCount = 0;
                    $scope.noResponseCount = 0;
                    $scope.completedCount = 0;
                    $scope.users = users;

                    //The users that have been assigned (they might have joined the group after the assignment)
                    var assigned = $filter('filter')(users, {assigned: true});
                    $scope.numAssigned = assigned.length;

                    for (var j = 0; j < $scope.users.length; j++) {
                        if($scope.users[j] != null ){
                            if (!$scope.users[j].assigned) {
                                $scope.containsUnassigneUsers = true;
                            }
                            for (var i = 0; i < $scope.currentAssignedTask.taskIndividualAssignments.length; i++) {
                                if ($scope.users[j].id == $scope.currentAssignedTask.taskIndividualAssignments[i].ownerId) {
                                    $scope.users[j].assignment = $scope.currentAssignedTask.taskIndividualAssignments[i];
                                    if($scope.currentAssignedTask.taskRecord.taskResponseTypes.length > 0){
                                        switch ($scope.currentAssignedTask.taskIndividualAssignments[i].status) {
                                            case 4:
                                                $scope.toReviewCount++;
                                                break;
                                            case 5:
                                                $scope.underReviewCount++;
                                                break;
                                            case 6:
                                                $scope.reviewedCount++;
                                                break;
                                            case 7:
                                                $scope.returnedCount++;
                                                break;
                                            case 8:
                                                $scope.completedCount++;
                                                break;
                                            case 9:
                                                $scope.inProgressCount++;
                                                break;
                                            case 0:
                                                $scope.noResponseCount++;
                                                break;
                                        }
                                    }
                                }
                            }       
                        }               
                    }
                    for (var j = 0; j < $scope.users.length; j++) {
                        if($scope.users[j] != null ){
                            if (!$scope.users[j].assignment) {
                                if ($scope.users[j].assigned) {
                                    $scope.noResponseCount++;
                                }
                                $scope.users[j].assignment = {
                                    status: 0
                                };
                            }
                        }
                    }
                    $scope.usersLoaded = true;
                });
            }

            // Function to go back to the task classes list
            $scope.goBack = function () {
                $location.path('/assignedtasks');
            };

            // Get the already selected badge details
            $scope.getBadgeDetails = function (badge) {
                if (badge.value) {
                    badge.badgeId = badge.value;
                }
                taskAdminDataContext.getTemplate(badge.badgeId).then(function (data) {
                    badge.badge = data;
                    return badge;
                });
            }

            //Get the already set marking schemes
            $scope.getMarkingScheme = function (markingScheme) {
                markingSchemeAdminDataContext.getMarkingScheme(markingScheme.markingSchemeId).then(function (data) {
                    markingScheme.markingScheme = data;
                    return markingScheme;
                });
            }

            //Get the already set marking schemes
            $scope.assignAssignedTask = function (user) {
                var assignment = {
                    ownerId: user.id,
                    taskAssignmentId: $scope.currentAssignedTask.id,
                    taskName: $scope.currentAssignedTask.taskRecord.name
                }
                //taskAdminDataContext.assignIndividualTask(assign).then(function (data) {
                taskAdminService.assignTaskToIndividual(assignment).then(function(data){
                    $scope.usersLoaded = false;
                    logSuccess("Task assigned");
                    getAssignedUsers();
                });
            }

       
            $scope.closeTask = function () {
                taskAdminService.closeAssignedTask($scope.currentAssignedTask).then(function (data) {
                    logSuccess("Tasks assignment successfully closed");
                    $location.path('/assignedtasks');
                });
            }

            $scope.recallTask = function () {
                taskAdminService.recallAssignedTask($scope.currentAssignedTask).then(function (data) {
                    logSuccess("Tasks assignment successfully recalled");
                    $location.path('/assignedtasks');
                });
            }

            $scope.getUserDetails = function (assignedUser) {
                if (assignedUser) {
                    user.getUserProfile(assignedUser.id).then(function (data) {
                        return assignedUser.user = data;
                    });
                }
            }

            $scope.getReviewerDetails = function(review) {
                if (review) {
                    user.getUserProfile(review.createdBy).then(function (data) {
                        return review.user = data;
                    });
                }
            }

            $scope.reviewAssignedTask = function (response) {
                taskAdminService.setCurrentTasksResponse(response);
                $location.path('/reviewtask');
            }
        }
    }]);

    //a directive that allows the ability to review an assigned task
    app.directive('reviewAssignedTask', ['taskAdminDataContext', 'taskAdminService', 'myUsersDataContext', 'commentsDataContext', 'myFormsDataContext', 'markingSchemeAdminDataContext', 'myBadgesAdminDataContext', 'common', 'user', '$location', '$modal', 'userAuth', '$filter', 'OrganisationAdminService', '$window', function (taskAdminDataContext, taskAdminService, myUsersDataContext, commentsDataContext, myFormsDataContext, markingSchemeAdminDataContext, myBadgesAdminDataContext, common, user, $location, $modal, userAuth, $filter, OrganisationAdminService, $window) {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'reviewassignedtask.html',
            link: link
        };

        function link($scope, elem, attrs) {
            var getLogFn = common.logger.getLogFn;
            var logSuccess = getLogFn("reviewAssignedTask", "success");
            var logError = getLogFn("reviewAssignedTask", "error");
 
            $scope.token = userAuth.getAuthToken();
            $scope.myShowcaseUrl = myShowcaseSiteUrl;
            $scope.comment = {
                content: '',
                isPrivate: false,
            }
			
			$scope.getBadgeCollectionUrl = function (collectionId) {
				return $scope.myShowcaseUrl + 'view/#!/collection?collectionid=' + collectionId + '&preview=true';
			}

            // Function to go back to the task classes list
            $scope.goBack = function () {
                taskAdminService.getAssignedTask($scope.currentAssignedTask.id).then(function (data) {
                    data.activeTab = 1;
                    taskAdminService.setCurrentAssignedTask(data);
                    $location.path('/assignedtask/' + $scope.currentAssignedTask.id);
                });
            };

        
            $scope.currentAssignedTask = taskAdminService.getCurrentAssignedTask();
            $scope.currentTaskResponse = taskAdminService.getCurrentTasksResponse();

            if (!$scope.currentAssignedTask) {
                $location.path('/assignedtask');
            } else {
                getUserDetails($scope.currentTaskResponse);
                getComment();
                getUser();
                if ($scope.currentAssignedTask.taskRecord.taskResponseTypes.length > 0) {
                    if ($scope.currentAssignedTask.taskRecord.taskResponseTypes[0].taskClassResponseType.name == 'Showcase') {
                        $scope.responseType = 'Showcase';
                        var deliverable = $scope.currentTaskResponse.latestResponse.taskAssignmentResponseDeliverables[0];
                        if(deliverable != null)
                            getShowcaseDetail(deliverable.value);
                    }
                    if ($scope.currentAssignedTask.taskRecord.taskResponseTypes[0].taskClassResponseType.name == 'Form') {      
                        $scope.responseType = 'Form';
                        $scope.formId = $scope.currentTaskResponse.latestResponse.taskAssignmentResponseDeliverables[0].value;
                        getFormDetail($scope.formId)
                    }

                    if ($scope.currentAssignedTask.taskRecord.taskResponseTypes[0].taskClassResponseType.name == 'Stuff item') {
                        $scope.responseType = 'Stuff item';
                        $scope.itemSource = $scope.currentTaskResponse.latestResponse.taskAssignmentResponseDeliverables[0].value;
                        getItemDetail($scope.itemSource)
                    }

                } else {
                    $scope.completionOnly = true;
                }

                if ($scope.currentTaskResponse.latestResponse.latestReview) {
                    $scope.reviewInProgress = true;
                }
                if ($scope.currentTaskResponse.latestResponse.latestReview) {
                    setMarkingSchemeMarks();
                }
                
            }

            function getUser() {
                user.getProfile().then(function (user) {
                    $scope.reviewer = user;
                });
            }
            function getUserDetails(userResponse) {
                if (userResponse.latestResponse) {
                    return user.getUserProfile(userResponse.latestResponse.createdBy).then(function (data) {
                        userResponse.user = data;
                    });
                }
                if (userResponse) {
                    return user.getUserProfile(userResponse.createdBy).then(function (data) {
                        userResponse.user = data;
                    });
                }
            }

            $scope.startResponseReview = function() {
                taskAdminService.createResponseReview($scope.currentTaskResponse.latestResponse.id).then(function (data) {
                    $scope.currentTaskResponse.latestResponse.latestReview = data;
                    setMarkingSchemeMarks();
                });  
            }

            function setMarkingSchemeMarks() {
                $scope.currentAssignedTask.taskRecord.taskMarkingSchemes = $filter('orderBy')($scope.currentAssignedTask.taskRecord.taskMarkingSchemes, 'name');
                for (var i = 0; i < $scope.currentAssignedTask.taskRecord.taskMarkingSchemes.length; i++) {
                    for (var j = 0; j < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings.length; j++) {
                        if ($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].taskMarkingSchemeId == $scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].id) {
                            $scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].marks = $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].marks;
                        }
                    }
                    if (!$scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].marks) {
                        if($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings != undefined){
                            // var value = '';
                            // //Set the default value in a number range scheme to the lowest available number
                            // if($scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].markingScheme != null && 
                            //     $scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].markingScheme.numericRangeLower != null){
                            //     value = $scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].markingScheme.numericRangeLower;
                            
                            //     if($scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].markingScheme.type == 3){ //percentage type
                            //         value = 0; //default to 0%
                            //     }
                            // }
                            $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings.push({
                                taskMarkingSchemeId: $scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].id,
                                marks: [{
                                    value: ''
                                }]
                            })
                        }
                    }
                }
            }

            $scope.getResponseMarkingIndex = function (schemeId) {
                if ($scope.currentTaskResponse.latestResponse.latestReview) {
                    for (var j = 0; j < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings.length; j++) {
                        if ($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].taskMarkingSchemeId == schemeId) {
                            return j;
                        }
                    }
                }
            }

            function getComment() {
                if ($scope.currentTaskResponse.latestResponse.latestReview) {
                    if ($scope.currentTaskResponse.latestResponse.latestReview.commentId !== "00000000-0000-0000-0000-000000000000") {
                        commentsDataContext.getCommentById($scope.currentTaskResponse.latestResponse.latestReview.commentId).then(function (comment) {
                            $scope.comment = comment;
                        });
                    }
                }
            }

            function getShowcaseDetail(showcaseId) {
                taskAdminDataContext.getShowcase(showcaseId).then(function (showcase) {
                    $scope.showcase = showcase;
                });
            }

            function getFormDetail(formId) {
                myFormsDataContext.getForm(formId).then(function (form) {
                    $scope.formType = taskAdminService.getFormTypeName(form.formType);
                });
            }

            function getItemDetail(source) {
                taskAdminDataContext.getStuffItem(source).then(function (item) {
                    $scope.item = item;
                });
            }

            $scope.setAlphabeticalRange = function (start, stop) {
                var result = [];
                for (var idx = start.charCodeAt(0), end = stop.charCodeAt(0) ; idx <= end; ++idx) {
                    result.push(String.fromCharCode(idx));
                }
                return result;
            }

            $scope.setSelectedAlphabeticalMark = function(value, scheme){
                var responseMarkingsIndex = $scope.getResponseMarkingIndex(scheme.id);
                $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[responseMarkingsIndex].marks[0].value = value;
            
            }

            $scope.alphabeticalMarkIsSelected = function(index, value, scheme){
                var latestReview = $scope.currentTaskResponse.latestResponse.latestReview;
                if(latestReview){
                    var alphaRange = [];
                    for (var idx=scheme.scheme.alphabeticRangeLower.charCodeAt(0),end=scheme.scheme.alphabeticRangeUpper.charCodeAt(0); idx <=end; ++idx){
                        alphaRange.push(String.fromCharCode(idx));
                    }

                    var mark = alphaRange[index];
                    var responseMarkingsIndex = $scope.getResponseMarkingIndex(scheme.id);
                    var markings = latestReview.taskAssignmentResponseMarkings[responseMarkingsIndex];
                    if(markings && markings.marks){
                        return mark == markings.marks[0].value;
                    }
                }
            }

            $scope.valueMarkIsSelected = function(value, scheme){
                if ($scope.currentTaskResponse.latestResponse.latestReview) {
                    var responseMarkingsIndex = $scope.getResponseMarkingIndex(scheme.id);
                    var marking = $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[responseMarkingsIndex];
                    if(marking){
                        return value == marking.marks[0].value;
                    }
                }
                return false;
            }

            $scope.saveReview = function () {
                delete $scope.comment.id;
                commentsDataContext.createComment($scope.comment).then(function (data) {
                    $scope.currentTaskResponse.latestResponse.latestReview.commentId = data.id;

                    //Set the status to 'In Progress'
                    $scope.currentTaskResponse.latestResponse.latestReview.status = 0;
                    
                    taskAdminService.saveResponseReview($scope.currentTaskResponse.latestResponse.latestReview).then(function (data) {
                        $scope.goBack();
                        logSuccess("Review successfully saved");
                    });
                });                
            }

            $scope.reopenReview = function () {
                $scope.currentTaskResponse.latestResponse.latestReview.status = 0;
                $scope.currentTaskResponse.status = 5;
                taskAdminService.saveResponseReview($scope.currentTaskResponse.latestResponse.latestReview).then(function (data) {
                    logSuccess("Review successfully reopened");
                });
            
            }

            $scope.returnResponse = function () {
                $scope.comment.content = '';
                if (!$scope.currentTaskResponse.latestResponse.latestReview) {
                    taskAdminService.createResponseReview($scope.currentTaskResponse.latestResponse.id).then(function (data) {
                        $scope.currentTaskResponse.latestResponse.latestReview = data;
                        $scope.returnToUser = true;
                    });
                } else {
                    $scope.returnToUser = true;
                }
            }

            $scope.returnTheResponse = function () {
                delete $scope.comment.id;
                commentsDataContext.createComment($scope.comment).then(function (data) {
                    $scope.currentTaskResponse.latestResponse.latestReview.commentId = data.id;
                    $scope.currentTaskResponse.latestResponse.latestReview.status = 2;
                    taskAdminService.saveResponseReview($scope.currentTaskResponse.latestResponse.latestReview).then(function (data) {
                        $scope.goBack();
                        logSuccess("Review successfully returned");
                    });
                });
            }

            // Get the already selected badge details
            $scope.getBadgeDetails = function (badge) {
                badge.badgeId = badge.value;
                if ($scope.currentTaskResponse.latestResponse.latestReview) {
                    for (i in $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges) {
                        if (badge.id == $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges[i].taskBadgeId) {
                            badge.issue = true;
                        }
                    }
                }
                taskAdminDataContext.getTemplate(badge.badgeId).then(function (data) {
                    badge.badge = data;
                    return badge;
                });
            }

            $scope.getAwardedBadgeDetails = function (badge) {
                for (var j = 0; j < $scope.currentAssignedTask.taskRecord.taskBadges.length; j++) {
                    if (badge.taskBadgeId == $scope.currentAssignedTask.taskRecord.taskBadges[j].id) {
                        badge.badge = $scope.currentAssignedTask.taskRecord.taskBadges[j];
                    }
                }
            }

            $scope.addBadgeForIssuing = function(badge) {
                if (badge.issue) {
                    // Add the badge for issuing
                    $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges.push({
                        taskBadgeId: badge.id,
                        taskBadge: badge,
                        issued: false
                    });
                } else {
                    // Remove the badge for issuing
                    for (i in $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges) {
                        if (badge.id == $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges[i].taskBadgeId) {
                            $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges.splice(i, 1);
                        }
                    }
                }
            }

            $scope.getMarkingSchemeDetails = function (markingScheme) {
                markingSchemeAdminDataContext.getMarkingScheme(markingScheme.markingSchemeId).then(function (data) {
                    markingScheme.scheme = data;
                    var values = markingScheme.taskMarkingSchemeValues;
                    markingScheme.scheme.taskMarkingSchemeValues = values;
                    if(values.length){
                        for(var i in values){
                            var properties = values[i].taskMarkingSchemeValueProperties;
                            setMarkingPropertiesBadges(properties);
                        }
                    }
                });
            }

            function setMarkingPropertiesBadges(properties){
                for(var j in properties){
                    return taskAdminDataContext.getTemplate(properties[j].value).then(function (data) {
                        return properties[j].badge = data;
                    });
                }
            }

            $scope.setSchemeValueOrdinal = function (value, scheme) {
                if(scheme){
                    for (var j = 0; j < scheme.markingSchemeValues.length; j++) {
                        if (value.name == scheme.markingSchemeValues[j].name) {
                            value.ordinal = scheme.markingSchemeValues[j].ordinal;
                        }
                    }
                }
            }
          
            $scope.reviewTaskConfirm = function () {
                $modal.open({
                    templateUrl: templatePath + 'reviewtaskconfirm.html',
                    controller: reviewTaskConfirmController,
                    size: 'lg',
                    backdrop: 'static',
                    resolve: {
                        currentTaskResponse: function () {
                            return $scope.currentTaskResponse;
                        },
                        comment: function () {
                            return $scope.comment
                        },
                        currentAssignedTask: function () {
                            return $scope.currentAssignedTask;
                        },
                        goBack: function () {
                            return $scope.goBack;
                        },
                        reviewer: function() {
                            return $scope.reviewer;
                        }
                    }
                });
            }

            $scope.downloadFile = function (fileUrl, fileName) {
                var url;
                user.getUploadBucketSasForUser($scope.currentTaskResponse.createdBy).then(function (sas) {
                    $scope.sasToken = sas.sas;
                    $scope.requiresAuth = true;
                    //set the sas token start and end dates
                    $scope.tokenStart = new Date().getTime();
                    $scope.tokenEnd = $scope.tokenStart + 1800000;
                    url = fileUrl + $scope.sasToken;
                    $window.open(url);
                });
            }

            var reviewTaskConfirmController = function (common, $scope, $modalInstance, currentTaskResponse, comment, currentAssignedTask, goBack, reviewer) {
                $scope.comment = comment;
                $scope.currentAssignedTask = currentAssignedTask;
                $scope.currentTaskResponse = currentTaskResponse;
                $scope.reviewer = reviewer;

                $scope.setBadgeDetails = function (badge) {
                    for (var j = 0; j < $scope.currentAssignedTask.taskRecord.taskBadges.length; j++) {
                        if (badge.taskBadgeId == $scope.currentAssignedTask.taskRecord.taskBadges[j].id) {
                            badge.taskBadge = $scope.currentAssignedTask.taskRecord.taskBadges[j];
                        }
                    }
                }

                $scope.getMarkingSchemeDetails = function (markingScheme) {
                    markingSchemeAdminDataContext.getMarkingScheme(markingScheme.markingSchemeId).then(function (data) {
                        markingScheme.scheme = data;
                    });
                }

                $scope.getResponseMarkingIndex = function (schemeId) {
                    if ($scope.currentTaskResponse.latestResponse.latestReview) {
                        for (var j = 0; j < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings.length; j++) {
                            if ($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].taskMarkingSchemeId == schemeId) {
                                return j;
                            }
                        }
                    }
                }

                $scope.addPrecentToMark = function (value) {
                    if (value.toString().includes("%"))
                        return value.toString()
                    else {
                        value = value.toString() + '%';
                        return value;
                    }
                }

                $scope.submitReview = function () {
                    $scope.submittingReview = true;

                    if ($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges.length > 0) {
                        $scope.badgesToIssue = $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges.length;
                        for (var i = 0; i < $scope.currentAssignedTask.taskRecord.taskMarkingSchemes.length; i++) {
                            for (var j = 0; j < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings.length; j++) {
                                if ($scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].id == $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].taskMarkingSchemeId) {
                                    for (var l = 0; l < $scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].taskMarkingSchemeValues.length; l++) {
                                        if ($scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].taskMarkingSchemeValues[l].id == $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].marks[0].value) {
                                            if ($scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].taskMarkingSchemeValues[l].taskMarkingSchemeValueProperties.length>0) {
                                                $scope.badgesToIssue = $scope.badgesToIssue + 1;
                                                $scope.issueBadge($scope.currentAssignedTask.taskRecord.taskMarkingSchemes[i].taskMarkingSchemeValues[l].taskMarkingSchemeValueProperties[0].badgeId);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        for (var j = 0; j < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges.length; j++) {
                            $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges[j].issued = true;
                            $scope.issueBadge($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentReviewBadges[j].taskBadge.badge.id);
                        }
                    }
                    else {

                        //Use the marking schemes on this task to find out if any badges have been set on any marking scheme mark values
                        var taskMarkingSchemes = $scope.currentAssignedTask.taskRecord.taskMarkingSchemes;

                        //Check if the selected mark on a value grading system has a badge and if so, issue it
                        var chosenMarks = $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings;
                        var goToNextChosenMark = false;
                        
                        //Begin looping through the chosen marks , finding out if there are any badges associated with them
                        for(var i = 0; i < chosenMarks.length; i++){
                            var chosenMark = chosenMarks[i];

                            //Match the marking scheme mark value to the chosen mark value
                            if(chosenMark != null){
                                var chosenMarkValue = chosenMark.marks[0];
                                if(chosenMarkValue != null){

                                    //The goToNextChosenMark escape clause prevents us from looping through every marking scheme for every chosen mark, 
                                    //if we've already matched and issued a badge for it
                                    for(var j = 0; j < taskMarkingSchemes.length; j ++){
                                        if(goToNextChosenMark){
                                            goToNextChosenMark = false;
                                            break;
                                        }
                                        var taskMarkingScheme = taskMarkingSchemes[j];

                                        //See which mark was selected in the marking scheme
                                        var valueToMatch = chosenMarkValue.value;
                                        for(var k = 0; k < taskMarkingScheme.taskMarkingSchemeValues.length; k++){
                                            var taskMarkingSchemeValue = taskMarkingScheme.taskMarkingSchemeValues[k];
                                            if(valueToMatch == taskMarkingSchemeValue.name){
                                                goToNextChosenMark = true;

                                                //Get the badge id from the markingscheme mark value property
                                                var valueProperties = taskMarkingSchemes[j].taskMarkingSchemeValues[k].taskMarkingSchemeValueProperties;
                                                if(valueProperties != null){
                                                    for(var l = 0; l < valueProperties.length; l++){
                                                        if(valueProperties[l] != null &&
                                                            valueProperties[l].name == 'badgeId'){
                                                                $scope.issueBadge(valueProperties[l].value);
                                                            }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    
                                }
                            }
                        }
                        $scope.finishUpReview();
                    }                   
                }

                $scope.finishUpReview = function () {
                    $scope.currentTaskResponse.latestResponse.latestReview.status = 1;
                    commentsDataContext.createComment($scope.comment).then(function (data) {
                        $scope.currentTaskResponse.latestResponse.latestReview.commentId = data.id;
                        taskAdminService.saveResponseReview($scope.currentTaskResponse.latestResponse.latestReview).then(function (data) {
                            $modalInstance.dismiss('cancel');
                            goBack();
                            logSuccess("Review successfully submitted");
                        });
                    });
                }

                $scope.issueBadge = function (badgeId) {

                    OrganisationAdminService.getTopLevelOrg().then(function (data) {
                        // new issue record template
                        var issuee = {
                            email: $scope.currentTaskResponse.user.email.email,
                            name: $scope.currentTaskResponse.user.firstName + ' ' + $scope.currentTaskResponse.user.lastName,
                            badgeTemplateId: badgeId,
                            createdBy: $scope.reviewer.userId,
                            status: 0,
                            organisationId: data.id,// 0 - Not baked    1 - Baked
                            customData: [{
                                label: 'Task',
                                value: $scope.currentAssignedTask.taskRecord.name
                            }]
                        };

                        myBadgesAdminDataContext.issueBadge(issuee).then(function (data) {
                            // Call the baking service with a group of issue ids
                            myBadgesAdminDataContext.bakeAndIssue([data.id], $scope.reviewer.firstName + " " + $scope.reviewer.lastName).then(function (data) {
                                // We call these to tell the user that all badges have been issued and turn the issuing state to false
                                $scope.badgesToIssue = $scope.badgesToIssue - 1;
                                if ($scope.badgesToIssue === 0) {
                                    $scope.finishUpReview();
                                }
                            });
                        });
                    })
                }

                //close the modal
                $scope.cancel = function() {
                    $modalInstance.dismiss('cancel');
                };
            }

            $scope.checkReviewsValidility = function () {
                //If marking schemes present
                if ($scope.currentAssignedTask.taskRecord.taskMarkingSchemes.length > 0) {
                    for (var j = 0; j < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings.length; j++) {
                        for (var l = 0; l < $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].marks.length; l++) {
                            if ($scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].marks[l].value == '' &&
                                $scope.currentTaskResponse.latestResponse.latestReview.taskAssignmentResponseMarkings[j].marks[l].value != 0) {
                                return true;
                            }
                        }
                    }                                        
                }
            }
        }
    }]);


    // embed
    app.directive('itemEmbedded', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/embed.html'
        };
    });

    //prezi
    app.directive('itemPrezi', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/embedprezi.html'
        };
    });

    //Evernote
    app.directive('itemEvernote', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/evernote.html'
        };
    });

    // Rich text / HTML block
    app.directive('itemStatus', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/status.html'
        };
    });
    // Uploaded file
    app.directive('itemFile', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/file.html'
        };
    });
    // Uploaded image
    app.directive('itemImage', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/image.html'
        };
    });

    // Uploaded video
    app.directive('itemVideo', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/video.html',
            link: function (scope, elm, attr) {
                scope.cloudinaryVideoBaseUrl = cloudinaryVideoBaseUrl;
            }
        };
    });

    // Uploaded badge
    app.directive('itemBadge', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/badge.html'
        };
    });

    // Added form
    app.directive('itemForm', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/form.html'
        };
    });

    // Added badge collection
    app.directive('itemBadgeCollection', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/badge-collection.html'
        };
    });

    // Form styles
    app.directive('formStyles', function () {
        return {
            restrict: 'E',
            templateUrl: '/modules/MyFormsCompleted/views/styles.html'
        };
    });

    // Uploaded weblink
    app.directive('itemWeblink', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/weblink.html',
            link: link

        };
        function link(scope, element, attrs) {
            scope.baseWebLinkImageUrl = baseWebLinkImageUrl;
        }
    });

    // MyProgress Assessment items
    app.directive('itemAssessment', function () {
        return {
            restrict: 'E',
            templateUrl: templatePath + 'templates/assessment2.html',
            scope: {
                myShowcaseItem: '=',
                accessToken: '=',
                hideDate: '='
            },
            link: function ($scope, element, attrs) {

                function lowerFirstLetterObjectKeys(input) {
                    if (typeof input !== 'object' || input == null) return input;
                    if (Array.isArray(input)) return input.map(lowerFirstLetterObjectKeys);
                    return Object.keys(input).reduce(function (newObj, key) {
                        let val = input[key];
                        let newVal = (typeof val === 'object') ? lowerFirstLetterObjectKeys(val) : val;
                        newObj[key.replace(key[0], key[0].toLowerCase())] = newVal;
                        return newObj;
                    }, {});
                }

                function parseResponse(jsonResponse) {
                    //Parse json, restoring properties to PascalCase where needed
                    var parsedResponse = JSON.parse(jsonResponse, function (key, value) {
                        if (key.length < 2 || key[0] === key[0].toUpperCase()
                            || key === "allocatedAssessmentGuid" || key === "publishedResourceId" || key === "responseIdentifier"
                            || key === "usingEmail" || key === "data" || key === "type" || key === "width" || key === "height"
                            || key === "src") {
                            return value;
                        } else {
                            var newKey = key.replace(key[0], key[0].toUpperCase());
                            this[newKey] = value;
                            return undefined; //removes old key
                        }
                    });

                    //recursively return result properties to camel case. We can't do this in the reviver function when parsing
                    //because only properties in the result object hierarchy should be changed, and some share names with properties
                    //in other objects
                    parsedResponse.Result = lowerFirstLetterObjectKeys(parsedResponse.Result);

                    //StreamedResource.Type is an exception to the rule that all 'type' properties are lowercase
                    parsedResponse.StreamedResources.forEach(function (resource) {
                        if (resource.Type == undefined && resource.type != undefined) {
                            resource.Type = resource.type;
                        }
                    });

                    return parsedResponse;
                }
				
				$scope.myShowcaseItem.jsonResponse = parseResponse($scope.myShowcaseItem.jsonResponse);
				
				if (!$scope.myShowcaseItem.itemId)
					$scope.myShowcaseItem.itemId = $scope.myShowcaseItem.id;
				
                $scope.getLetter = function (index) {
                    if (0 <= index && index <= 25) {
                        return String.fromCharCode(65 + index);
                    }
                    else if (26 <= index <= 51) {
                        return String.fromCharCode(71 + index);
                    }
                    else {
                        return '';
                    }
                }

                $scope.getAssessmentItemResultFromCustomText = function (customText) {
                    var assessmentItemIdentifier = $scope.getAssessmentItemIdentifier(customText);
                    if (assessmentItemIdentifier.length > 0) {
                        var result = $scope.getAssessmentItemResult(assessmentItemIdentifier);
                        return result;
                    }
                    return null;
                }
                $scope.getAssessmentItemResult = function (assessmentItemIdentifier) {

                    var resultArray = $scope.myShowcaseItem.jsonResponse.Result.itemResults.filter(function (assessmentItemResult) {
                        return assessmentItemResult.identifier === assessmentItemIdentifier;
                    })

                    if (resultArray.length > 0) {
                        return resultArray[0];
                    }
                    else {
                        return null;
                    }

                }

                $scope.getAssessmentItemIdentifier = function (customText) {
                    var identifierString = 'identifier:';
                    if (customText && customText.length > 0 && customText.indexOf(identifierString) > -1) {
                        var startIndex = customText.indexOf(identifierString) + identifierString.length;
                        return customText.substring(startIndex);
                    }
                    return '';
                }

                $scope.isAssessmentItemHidden = function (customText) {
                    if (customText && customText.length > 0) {
                        for (var i = 0; i < $scope.myShowcaseItem.jsonResponse.HiddenAssessmentItemIdentifiers.length; i++) {
                            if (customText.includes($scope.myShowcaseItem.jsonResponse.HiddenAssessmentItemIdentifiers[i])) {
                                return true;
                            }
                        }
                    }
                    return false;
                }

            }
        };

    });

    app.directive('myprogressAssessmentItem', function ($http) {
        return {
            restrict: 'E',
            templateUrl: 'assessmentResponseItem.html',
            scope: {
                myShowcaseItem: '=',
                assessmentItem: '=',
                itemResult: '=',
                accessToken: '=',
                hideDate: '='
            },
            link: function ($scope, element, attrs) {

                $scope.getSelectedInteractionOptions = function (assessmentItemResult, responseIdentifier) {

                    if (assessmentItemResult) {
                        var responseValues = assessmentItemResult.responseValues.filter(function (responseValue) {
                            return responseValue.identifier === responseIdentifier;
                        })

                        if (responseValues.length > 0) {
                            return responseValues[0].values;
                        }
                        else {
                            return null;
                        }
                    }
                    else {
                        return null;
                    }
                }

                $scope.getSingleResponseValue = function (assessmentItemResult, responseIdentifier) {
                    if (assessmentItemResult && responseIdentifier) {
                        var responseValues = assessmentItemResult.responseValues.filter(function (responseValue) {
                            return responseValue.identifier === responseIdentifier;
                        })

                        if (responseValues && responseValues.length > 0) {
                            var responseValueArray = responseValues[0].values;
                            if (responseValueArray && responseValueArray.length > 0) {
                                return responseValueArray[0];
                            }
                            else {
                                return null;
                            }
                        }
                        else {
                            return null;
                        }
                    }
                    else {
                        return null;
                    }
                }

                $scope.isInCorrectValues = function (responseValue, correctValues, correctValue, correctDate, correctTime, dateFormat) {
                    return responseValue && responseValue.length && (correctValues && correctValues.length > 0 && correctValues.includes(responseValue))
                        || (correctValue && correctValue.length > 0 && correctValue == responseValue)
                        || (correctDate && correctDate.length > 0 && $scope.compareDateStrings(correctDate, responseValue, dateFormat))
                        || (correctTime && correctTime.length > 0 && $scope.compareTimeStrings(correctTime, responseValue));
                }
                $scope.compareTimeStrings = function (time1, time2) {
                    if (time1 && time2) {
                        var t1 = time1.split(':');
                        var t2 = time2.split(':');
                        var h1 = parseInt(t1[0]);
                        var h2 = parseInt(t2[0]);
                        var m1 = parseInt(t1[1]);
                        var m2 = parseInt(t2[1]);

                        return (h1 == h2 && m1 == m2);
                    } else {
                        return false;
                    }
                }
                $scope.compareDateStrings = function (correctDate, responseDate, dateFormat) {
                    var dateCorrect = new Date(correctDate);
                    var dayCorrect = dateCorrect.getDate();
                    var monthCorrect = (dateCorrect.getMonth() + 1).toString();
                    if (monthCorrect.length == 1) {
                        monthCorrect = '0' + monthCorrect;
                    }
                    var yearCorrect = dateCorrect.getFullYear().toString();
                    var stringCorrect = '';

                    if (dateFormat == 'DATE') {
                        stringCorrect = dayCorrect + '/' + monthCorrect + '/' + yearCorrect;
                    }
                    else {
                        var hoursCorrect = dateCorrect.getHours().toString();
                        var minutesCorrect = dateCorrect.getMinutes().toString();

                        if (hoursCorrect.length == 1) {
                            hoursCorrect = '0' + hoursCorrect;
                        }
                        if (minutesCorrect.length == '1') {
                            minutesCorrect = '0' + minutesCorrect;
                        }

                        stringCorrect = dayCorrect + '/' + monthCorrect + '/' + yearCorrect + ' ' + hoursCorrect + ':' + minutesCorrect;
                    }

                    return stringCorrect == responseDate
                }
            }
        };
    });

    app.directive('myprogressInteractionChoice', function () {
        return {
            restrict: 'E',
            templateUrl: 'assessmentResponseChoice.html',
            scope: {
                simpleChoice: '=',
                selectedValues: '=',
                correctValues: '='
            },
            link: function ($scope, element, attrs) {
                $scope.isSelected = function () {
                    return $scope.selectedValues && $scope.selectedValues.length > 0 && $scope.selectedValues.includes($scope.simpleChoice.Identifier);
                }
                $scope.isCorrect = function () {
                    return $scope.correctValues && $scope.correctValues.length > 0 && $scope.correctValues.includes($scope.simpleChoice.Identifier);
                }
                $scope.isIncorrect = function () {
                    //value is incorrect only if there are defined correct values
                    return $scope.correctValues && $scope.correctValues.length > 0 && !$scope.correctValues.includes($scope.simpleChoice.Identifier);
                }
            }
        };
    });

    app.directive('myProgressInteractionGrid', function () {
        return {
            restrict: 'E',
            templateUrl: 'assessmentResponseGrid.html',
            scope: {
                sourceItems: '=',
                targetItems: '=',
                selectedValues: '='
            },
            link: function ($scope, element, attrs) {
                $scope.isSelected = function (sourceId, targetId) {
                    return $scope.selectedValues && $scope.selectedValues.length > 0 && $scope.selectedValues.includes(sourceId + ' ' + targetId);
                }
            }
        }
    });

    //
    app.directive('myProgressInteractionFile', ['$http', '$timeout', function ($http, $timeout) {
        return {
            restrict: 'E',
            templateUrl: 'assessmentResponseFile.html',
            scope: {
                myShowcaseItemId: '=',
                streamedResourceData: '=',
                responseString: '=',
                accessToken: '='
            },
            link: function ($scope, element, attrs) {

                function fileNameFromResponse() {
                    if ($scope.responseString && $scope.responseString.indexOf(',') > 0) {
                        return $scope.responseString.substring($scope.responseString.indexOf(',') + 1)
                    }
                    else {
                        return '';
                    }
                }

                function fileGuidFromResponse() {
                    if ($scope.responseString && $scope.responseString.indexOf(',') > 0) {
                        return $scope.responseString.substring(0, $scope.responseString.indexOf(','))
                    }
                    else {
                        return '';
                    }
                }

                $scope.fileName = fileNameFromResponse();
                $scope.fileGuid = fileGuidFromResponse();

                //&userid=9F33C4E1-7A70-47B4-9C1C-A46A40B67D8D
                function fileDownloadUrl() {
                    if ($scope.fileGuid && $scope.fileGuid.length > 0 && $scope.fileName && $scope.fileName.length > 0) {
                        return myShowcaseSiteUrl + '/api/myitem/' + $scope.myShowcaseItemId
                            + '/zipcontents?name=' + $scope.fileGuid
                            + '&originalName=' + $scope.fileName;
                    }
                    return '';
                }

                function resourceIsImage() {
                    if ($scope.streamedResourceData) {
                        var isImage = false;
                        for (var i = 0; i < $scope.streamedResourceData.length; i++) {
                            if ($scope.streamedResourceData[i].ResourceId == $scope.fileGuid) {
                                isImage = ($scope.streamedResourceData[i].Type.toLowerCase().indexOf('image') >= 0);
                                break;
                            }
                        }
                        return isImage;
                    }
                }

                function getResourceType() {
                    if ($scope.streamedResourceData) {
                        var rType = '';
                        for (var i = 0; i < $scope.streamedResourceData.length; i++) {
                            if ($scope.streamedResourceData[i].ResourceId == $scope.fileGuid) {
                                rType = $scope.streamedResourceData[i].Type;
                                break;
                            }
                        }
                        return rType;
                    }
                }

                $scope.fileUrl = fileDownloadUrl();
                $scope.isImage = resourceIsImage();
                $scope.resourceType = getResourceType();

                //$scope.downloadFile = function (event) {
                //    //var maxSizeForBase64 = 1048576; //1024 * 1024

                //    if ($scope.responseString) {

                //        var anchor = angular.element('<a></a>'); //angular.element(event.currentTarget);
                //        //only get data again if base64Url hasn't been generated
                //        if (!$scope.base64Url || $scope.base64Url.length == 0) {

                //            var request = $http({
                //                method: "get",
                //                url: $scope.fileUrl,
                //                headers: {
                //                    Authorization: 'Bearer ' + $scope.accessToken
                //                },
                //                responseType: 'arraybuffer'
                //            });

                //            return (request.then(function (response) {

                //                var str = response.data;
                //                var windowUrl = window.URL || window.webkitURL;
                //                if (typeof windowUrl.createObjectURL === 'function') {
                //                    var blob = new Blob([response.data], { type: $scope.resourceType });
                //                    var url = window.URL.createObjectURL(blob);
                //                    //anchor.prop('href', url);
                //                    //anchor.prop('download', $scope.fileName);
                //                    anchor.attr({
                //                        href: url,
                //                        download: $scope.fileName,
                //                    });

                //                    anchor.get(0).click();
                //                    windowUrl.revokeObjectURL(url);
                //                }
                //                else {
                //                    //use base64 encoding when less than set limit or file API is not available
                //                    anchor.attr({
                //                        href: $scope.base64Url,
                //                        download: $scope.fileName,
                //                    });
                //                    anchor.get(0).click();
                //                }


                //            }, $scope.handleError));

                //        }
                //        else {
                //            //anchor.attr({
                //            //    href: $scope.base64Url,
                //            //    download: $scope.fileName,
                //            //});

                //            anchor.prop('href', $scope.base64Url);
                //            anchor.prop('download', $scope.fileName);

                //            //$timeout(function () {
                //            anchor.get(0).click();
                //            //}, 0, false);
                //        }
                //    }
                //}

                function getResourceAsBase64Url() {
                    var maxSizeForBase64 = 3000050;  //4Gb max data url for IE - 50 bytes for metadata 

                    var url = $scope.fileUrl;

                    var request = $http({
                        method: "get",
                        url: url,
                        headers: {
                            Authorization: 'Bearer ' + $scope.accessToken
                        },
                        responseType: 'arraybuffer'
                    });

                    return (request.then(function (response) {
                        var arrayBuffer = response.data;
                        if (arrayBuffer) {
                            var u8 = new Uint8Array(arrayBuffer);
                            if (u8.length <= maxSizeForBase64) {
                                var len = u8.byteLength;
                                var binary = '';
                                for (var i = 0; i < len; i++) {
                                    binary += String.fromCharCode(u8[i]);
                                }
                                var b64encoded = window.btoa(binary);
                                var mimetype = $scope.resourceType;
                                return "data:" + mimetype + ";base64," + b64encoded;
                            }
                            else {
                                return '';
                            }
                        }
                        else {
                            return '';
                        }
                    }, $scope.handleError));
                }

                $scope.handleError = function (response) {
                    console.log(response);
                }

                $scope.handleSuccess = function (response) {
                    return (response.data);
                }

                function downloadFileUrl() {
                    //var maxSizeForBase64 = 1048576; //1024 * 1024

                    //use dataurl if it exists - only get data again if base64Url hasn't been generated
                    //if (!$scope.base64Url || $scope.base64Url.length == 0) {

                    var request = $http({
                        method: "get",
                        url: $scope.fileUrl,
                        headers: {
                            Authorization: 'Bearer ' + $scope.accessToken
                        },
                        responseType: 'arraybuffer'
                    });

                    return (request.then(function (response) {

                        var str = response.data;
                        var windowUrl = window.URL || window.webkitURL;
                        if (typeof windowUrl.createObjectURL === 'function') {
                            var blob = new Blob([str], { type: $scope.resourceType });
                            var url = windowUrl.createObjectURL(blob);
                            return url;
                        }
                        else {
                            return '';
                        }

                    }, $scope.handleError));

                    //}
                    //else {

                    //    return new Promise(function(resolve, reject) {
                    //        return resolve($scope.base64Url);
                    //        //return reject('error');
                    //    })
                    //}

                }

                //getResourceAsBase64Url().then(function (response) {
                //    $scope.base64Url = response;
                //    downloadFileUrl().then(function (response) {
                //        $scope.downloadFileLocation = response;
                //    })
                //})

                downloadFileUrl().then(function (response) {
                    $scope.downloadFileLocation = response;
                })

                $scope.useIEDownload = window.navigator.msSaveOrOpenBlob;

                $scope.doIEDownload = function () {

                    var request = $http({
                        method: "get",
                        url: $scope.fileUrl,
                        headers: {
                            Authorization: 'Bearer ' + $scope.accessToken
                        },
                        responseType: 'arraybuffer'
                    });

                    return (request.then(function (response) {

                        var str = response.data;
                        var windowUrl = window.URL || window.webkitURL;
                        if (typeof windowUrl.createObjectURL === 'function') {
                            var blob = new Blob([str], { type: $scope.resourceType });
                            window.navigator.msSaveOrOpenBlob(blob, $scope.fileName);
                        }
                        else {
                            return '';
                        }

                    }, $scope.handleError));

                }
            }
        }
    }]);

    app.filter('dateOrTime', function () {
        return function (input, responseType) {
            if (input && responseType === "date") {
                var parts = input.split(" ");
                if (parts.length > 0) {
                    return parts[0];
                }
                else {
                    return input;
                }


            } else if (input && responseType === "time") {
                var parts = input.split(" ");
                if (parts.length > 1) {
                    return parts[1];
                }
                else {
                    return input;
                }

            } else {
                //default is to handle as for responseType === "datetime", i.e. return unmodified
                return input;
            }
        }
    });


})();