(function () {   'use strict';  angular.module('.config', []) .constant('API_ENDPOINT', 'https://api-dot-celbrea.appspot.com/API').constant('DEMO_MODE', undefined).constant('ENDPOINT_BASE', 'https://api-dot-celbrea.appspot.com/').constant('MEDIAKIT_ENDPOINT', 'https://storage.googleapis.com/prod-celbrea/mk/PressKit.zip').constant('PROJECT', 'WELWAZE');})();
;(function() {
    'use strict'

    angular.module('core', ['ui.router']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider.state({
                name: 'home',
                url: '/',
                views: {
                    base: {
                        templateUrl: '/ngtemplates/core/views/home.html',
                        controller: 'HomeController',
                    },
                },
            })
        },
    ])
})()

;(function() {
    'use strict'

    function HomeController($scope, $state, $http, API_ENDPOINT) {
        // Redirect if token not valid
        var urlChecking =
            API_ENDPOINT + '/InvestmentReports?PageIndex=1&PageSize=1'
        var headers = {
            Authorization: 'Bearer ' + localStorage.getItem('token'),
        }

        $http.get(urlChecking, { headers: headers }).then(
            function(response) {
                checkResponse(response)
            },
            function(err) {
                checkResponse(err)
            }
        )

        function checkResponse(response) {
            if (response.status == 401) {
                localStorage.removeItem('token')
                localStorage.removeItem('refreshToken')
                localStorage.removeItem('user')
                $state.go('login')
            }
        }
    }

    angular
        .module('core')
        .controller('HomeController', [
            '$scope',
            '$state',
            '$http',
            'API_ENDPOINT',
            HomeController,
        ])
})()

;(function() {
    'use strict'

    function ConfirmModalController($scope) {
        var params = {}
        $scope.displayModal = false

        $scope.confirm = function() {
            $scope.callbackSuccess(params)
            $scope.displayModal = false
        }

        $scope.cancel = function() {
            $scope.displayModal = false
        }

        $scope.$on('_showConfirmModal_' + $scope.idModal, function(_, attr) {
            if (attr.params) {
                params = attr.params
            }
            $scope.displayModal = true

            if (attr.params.updateCycle) {
                $scope.$apply()
            }
        })
    }

    angular.module('core').directive('confirmModalComponent', function() {
        return {
            restrict: 'E',
            templateUrl: 'ngtemplates/core/directives/confirm-modal.html',
            scope: {
                callbackSuccess: '=',
                message: '=',
                idModal: '=',
            },
            controller: ['$scope', ConfirmModalController],
        }
    })
})()

;(function() {
    'use strict'

    angular.module('core').directive('copyClipboard', [
        'ToastMessage',
        function(ToastMessage) {
            return {
                restrict: 'A',
                scope: {
                    valueToCopy: '=?',
                    domElement: '@?',
                    messageCopy: '=',
                },
                link: function($scope, elem, attr) {
                    $scope.copyToClipboard = function() {
                        if ($scope.domElement) {
                            var targetEl = document.querySelector(
                                '#link-invite'
                            )
                            $scope.valueToCopy = targetEl.text
                        }

                        if ($scope.valueToCopy) {
                            var txtArea = document.createElement('textarea')
                            txtArea.style = 'display=none'
                            txtArea.value = $scope.valueToCopy
                            document.body.appendChild(txtArea)
                            txtArea.select()

                            document.execCommand('copy')
                            txtArea.remove()

                            ToastMessage.showMessage($scope.messageCopy, 'info')
                        }
                    }

                    elem.bind('click', $scope.copyToClipboard)
                },
            }
        },
    ])
})()

;(function() {
    'use strict'

    function headerComponentCtrl($scope, $state, $http, API_ENDPOINT) {
        var url = API_ENDPOINT + '/BackOfficeUsers/me'

        $scope.logout = function() {
            localStorage.removeItem('token')
            localStorage.removeItem('username')
            $state.go('login')
        }

        $scope.getUsername = function() {
            var name = localStorage.getItem('username')
            if (!name) {
                name = ''
            }
            return name
        }

        $scope.userName = $scope.getUsername()

        $scope.loadUserName = function() {
            var token = localStorage.getItem('token')

            $http
                .get(url, {
                    headers: {
                        Authorization: 'Bearer ' + token,
                    },
                })
                .then(
                    function(resp) {
                        $scope.userName = resp.data.firstName
                        localStorage.setItem('username', $scope.userName)
                    },
                    function(err) {
                        console.error(err)
                    }
                )
        }

        $scope.loadUserName()
    }

    function HeaderComponent() {
        return {
            restrict: 'E',
            templateUrl: 'ngtemplates/core/directives/header-backoffice.html',
            controller: [
                '$scope',
                '$state',
                '$http',
                'API_ENDPOINT',
                headerComponentCtrl,
            ],
        }
    }

    angular.module('core').directive('headerBackOffice', HeaderComponent)
})()

;(function() {
    angular.module('core').directive('ngInputFile', function() {
        return {
            restrict: 'E',
            templateUrl: '/ngtemplates/core/directives/ng-input-file.html',
            scope: {
                labelName: '=',
                inputModel: '=',
                inputName: '=',
                fileLoaded: '=?',
                fileNameLoaded: '=?',
            },
            link: function(scope, elem, attr) {
                scope.fileChanged = function(ev) {
                    scope.inputModel = elem.find('input')[0].files[0]
                    // FIXME: Fix illegal invocation and update model file
                    scope.$apply()
                }
            },
        }
    })
})()

;(function () {
    'use strict'

    function pageNavigationController($scope, $http, AuthService) {
        let limitPage = -1
        $scope.disabledPrev = true
        $scope.disabledNext = false
        $scope.itemsNext = []

        $scope.getPrevItems = function () {
            if ($scope.currentPage > 1) {
                $scope.currentPage--
                $scope.disabledPrev = false
                $scope.disabledNext = false
                $scope.callItems()

                if ($scope.currentPage === 1) {
                    $scope.disabledPrev = true
                }
            }
        }

        $scope.getNextItems = function () {
            if (
                $scope.itemsNext.length &&
                (limitPage === -1 ||
                    (limitPage !== -1 && $scope.currentPage < limitPage))
            ) {
                $scope.currentPage++
                $scope.disabledNext = false
                $scope.disabledPrev = false
                $scope.callItems()

                if (limitPage !== -1 && $scope.currentPage === limitPage) {
                    $scope.disabledNext = true
                }
            }
        }

        $scope.callItems = function () {
            $scope
                .callback(
                    $scope.currentPage,
                    $scope.pageSize,
                    $scope.orderBy,
                    $scope.order
                )
                .then(function () {
                    $scope.callNextItems()
                })
        }

        $scope.callNextItems = function () {
            var urlNext = $scope.urlHttp
                .replace('X', $scope.currentPage + 1)
                .replace('Y', $scope.pageSize)
                .replace('Z', $scope.orderBy)
                .replace('W', $scope.order)
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            $http({method: 'GET', url: urlNext, headers: headers}).then(
                function (r) {
                    $scope.itemsNext = r.data
                    if (!$scope.itemsNext.length) {
                        limitPage = $scope.currentPage
                        $scope.disabledNext = true
                    } else if (
                        $scope.itemsNext.length > 0 &&
                        $scope.itemsNext.length < $scope.pageSize
                    ) {
                        limitPage = $scope.currentPage + 1
                    }
                }
            )
        }

        var $$urlHTTPwatcher = $scope.$watch('urlHttp', function (v) {
            if (!v) return

            $$urlHTTPwatcher()
            $scope.callNextItems()
        })

        var $$listItemsWatcher = $scope.$watch('listItems', function (v) {
            if (!v || !v.length) return

            $$listItemsWatcher()
            if (
                $scope.currentPage == 1 &&
                (v.length == 0 || v.length < $scope.pageSize)
            ) {
                $scope.disabledNext = true
                limitPage = 1
            }
        })
    }

    angular.module('core').directive('pageNavigator', function () {
        return {
            restrict: 'E',
            templateUrl: 'ngtemplates/core/directives/page-navigation.html',
            scope: {
                callback: '=',
                listItems: '=',
                urlHttp: '=',
                currentPage: '=',
                pageSize: '=',
                orderBy: '=',
                order: '=',
            },
            controller: [
                '$scope',
                '$http',
                'AuthService',
                pageNavigationController,
            ],
        }
    })
})()

;(function() {
    'use strict'

    angular.module('core').directive('projectClassnameLoader', [
        'PROJECT',
        function(PROJECT) {
            return {
                restrict: 'A',
                link: function($scope, elem, attr) {
                    var className = PROJECT.toLowerCase() + '_view'
                    elem.addClass(className)
                },
            }
        },
    ])
})()

;(function() {
    'use strict'

    function SideBarDirective() {
        return {
            restrict: 'E',
            templateUrl: '/ngtemplates/core/directives/sidebar.html',
            controller: [
                '$scope',
                '$state',
                'PROJECT',
                function($scope, $state, PROJECT) {
                    $scope.$state = $state
                    $scope.PROJECT = PROJECT
                    $scope.oneAtATime = true
                    $scope.status = {
                        isOpenRelease: false,
                        isOpenReports: false,
                    }

                    $scope.openAccordion = function(statusName) {
                        $scope.status[statusName] = !$scope.status[statusName]
                    }

                    $scope.switchMenu = function($event) {
                        var parentMenu = $($event.currentTarget.parentElement)
                        var arrow = parentMenu.find('.glyphicon')

                        if (parentMenu.hasClass('opened-sub-menu')) {
                            parentMenu.removeClass('opened-sub-menu')
                            arrow.addClass('glyphicon-chevron-right')
                            arrow.removeClass('glyphicon-chevron-down')
                        } else {
                            parentMenu.addClass('opened-sub-menu')
                            arrow.addClass('glyphicon-chevron-down')
                            arrow.removeClass('glyphicon-chevron-right')
                        }
                    }
                },
            ],
        }
    }

    angular.module('core').directive('sidebarBackOffice', SideBarDirective)
})()

;(function() {
    'use strict'

    angular.module('core').directive('spinnerLoader', function() {
        return {
            restrict: 'E',
            templateUrl: '/ngtemplates/core/directives/spinner-loader.html',
            scope: {
                showSpinner: '=',
            },
        }
    })
})()

;(function() {
    'use strict'

    angular
        .module('core')
        .filter('humanDate', function() {
            return function(date) {
                return moment(date).format('MM/DD/YYYY')
            }
        })
        .filter('fullHumanDate', function() {
            return function(date) {
                return moment(date).format('YYYY/MM/DD hh:mm:ss a')
            }
        })
})()

;(function() {
    'use strict'

    angular
        .module('core')
        .filter('humanQuarter', function() {
            var humanQuarter = {
                Quarter1: 'Quarter 1',
                Quarter2: 'Quarter 2',
                Quarter3: 'Quarter 3',
                Quarter4: 'Quarter 4',
            }

            return function(quarter) {
                return humanQuarter[quarter]
            }
        })
        .filter('humanTypeReport', function() {
            var humanTypeReport = {
                ProfitAndLoss: 'Profit & Loss',
                BalanceSheet: 'Balance Sheet',
                CashFlow: 'Cash Flow',
                BudgetVsActual: 'Budget Vs Actual',
                InvestorsUpdate: 'Investors Update',
                Annual: 'Annual',
            }

            return function(typeReport) {
                return humanTypeReport[typeReport]
            }
        })
})()

;(function() {
    'use strict'

    function ErrorFormatting() {
        this.formatMessage = function(errorObj) {
            var message = 'Error: '
            if (errorObj.hasOwnProperty('data')) {
                var errorData = errorObj['data']

                if (typeof errorData == 'object') {
                    message = 'Error: '
                    Object.keys(errorData).forEach(function(item, index) {
                        message += errorData[item]
                        if (errorData[item][0].indexOf('.') === -1) {
                            message += '. '
                        }
                    })
                } else {
                    message += errorData
                }
            } else {
                return errorObj
            }

            return message
        }
    }

    angular.module('core').service('ErrorFormattingService', [ErrorFormatting])
})()

;(function() {
    'use strict'

    function ExportCSVService() {
        var _this = this

        this.exportToCSV = function(data, filename) {
            if (!filename) {
                filename = 'export'
            }

            var json_d = []

            if (typeof data === 'object') {
                json_d = [data]
            } else {
                json_d = data
            }

            var strData = _this.exportFromJSONToCSV(data)

            var blob = new Blob([strData], { type: 'text/plain;charset=utf-8' })
            saveAs(blob, filename + '.csv')
        }

        this.exportFromJSONToCSV = function(json_data) {
            var str_exp = ''
            var keys = Object.keys(json_data[0])
            // Remove $$hashKey object
            keys.pop()

            str_exp += keys.join(',')
            str_exp += '\n'

            for (var x = 0; x < json_data.length; x++) {
                var row = json_data[x]
                var rowVal = Object.values(row)

                // Remove $$object:id angular
                rowVal.pop()

                str_exp += rowVal.join(',')
                str_exp += '\n'
            }

            return str_exp
        }
    }

    angular.module('core').service('ExportCSVService', [ExportCSVService])
})()

;(function() {
    'use strict'

    function ToastMessageService() {
        this.init = function() {
            toastr.options.progressBar = false
            toastr.options.positionClass = 'toast-top-right'
            toastr.options.preventDuplicates = true
            toastr.options.showDuration = 500
            toastr.options.hideDuration = 750
            toastr.options.timeOut = 6500
            toastr.options.showEasing = 'swing'
            toastr.options.hideEasing = 'linear'
            toastr.options.showMethod = 'fadeIn'
            toastr.options.hideMethod = 'fadeOut'
        }

        this.showMessage = function(message, type) {
            var callbackToast = toastr[type]
            if (callbackToast) {
                callbackToast(message)
            }
        }

        this.init()
    }

    angular.module('core').service('ToastMessage', [ToastMessageService])
})()

;(function() {
    'use strict'

    angular
        .module('auth', ['ui.router', 'ngMessages', 'core', '.config'])
        .config([
            '$stateProvider',
            'PROJECT',
            function($stateProvider, PROJECT) {
                var states = $stateProvider.state({
                    name: 'login',
                    url: '/login',
                    views: {
                        base: {
                            templateUrl: '/ngtemplates/auth/views/login.html',
                            controller: 'LoginController',
                        },
                    },
                })

                if (PROJECT == 'WELWAZE') {
                    states
                        .state({
                            name: 'users',
                            url: '/users',
                            views: {
                                base: {
                                    templateUrl:
                                        '/ngtemplates/auth/views/users-list.html',
                                    controller: 'UsersList',
                                },
                            },
                        })
                        .state({
                            name: 'users-crud',
                            url: '/users/create',
                            views: {
                                base: {
                                    templateUrl:
                                        '/ngtemplates/auth/views/users-crud.html',
                                    controller: 'UserCRUDController',
                                },
                            },
                        })
                        .state({
                            name: 'invite-user',
                            url: '/invite',
                            views: {
                                base: {
                                    templateUrl:
                                        '/ngtemplates/auth/views/invite-user.html',
                                    controller: 'InviteUserController',
                                },
                            },
                        })
                }
            },
        ])
})()

;(function() {
    'use strict'

    function InviteUserController(
        $scope,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage,
        ErrorFormattingService
    ) {
        var inviteInvestorEndpoint = '/BackOfficeUsers/investors/invite'
        var inviteAdministratorEndpoint =
            '/BackOfficeUsers/administrators/invite'
        var UNAUTHORIZED_REQUEST = 401
        var headers = {
            Authorization: 'Bearer ' + AuthService.getToken(),
            'Content-Type': 'application/json',
        }

        $scope.copyClipText = 'Link copy to clipboard'
        $scope.formTouched = false
        $scope.showSpinner = false
        $scope.invitedLinkGenerated = false
        $scope.invitedLink = ''
        $scope.typeUser = ''

        $scope.userData = {
            firstName: '',
            lastName: '',
            email: '',
        }

        AuthService.checkAuthValid(null, $state)

        $scope.resetForm = function() {
            $scope.formTouched = false
            $scope.showSpinner = false
            $scope.invitedLinkGenerated = false
            $scope.invitedLink = ''
            $scope.typeUser = ''

            $scope.userData = {
                firstName: '',
                lastName: '',
                email: '',
            }
        }

        $scope.inviteUser = function() {
            $scope.formTouched = true
            var url = API_ENDPOINT + inviteInvestorEndpoint
            if ($scope.typeUser == 'administrator') {
                url = API_ENDPOINT + inviteAdministratorEndpoint
            }

            if ($scope.inviteUserForm.$valid) {
                $scope.showSpinner = true
                $http({
                    url: url,
                    method: 'POST',
                    data: $scope.userData,
                    headers: headers,
                }).then(
                    function(resp) {
                        $scope.showSpinner = false
                        $scope.invitedLink = resp.data.inviteCodeLink
                        $scope.invitedLinkGenerated = true
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }
    }

    angular
        .module('auth')
        .controller('InviteUserController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            'ErrorFormattingService',
            InviteUserController,
        ])
})()

;(function() {
    'use strict'

    function LoginController(
        $scope,
        $http,
        AuthService,
        API_ENDPOINT,
        $state,
        ToastMessage,
        PROJECT
    ) {
        var loginUrl = API_ENDPOINT + '/BackOfficeUsers/login'
        var UNSUCCESSFUL_LOGIN = 401
        var ERROR_FIELD_USER = 400

        $scope.PROJECT = PROJECT
        $scope.formSubmitted = false
        $scope.showSpinner = false
        $scope.session = {
            email: '',
            password: '',
        }

        $scope.loginEnter = function($event) {
            var keyCodeEnter = 13

            if ($event.keyCode == keyCodeEnter) {
                $scope.login()
            }
        }

        $scope.login = function() {
            $scope.formSubmitted = true

            if ($scope.loginForm.$valid) {
                $scope.showSpinner = true
                $http.post(loginUrl, $scope.session).then(
                    function(resp) {
                        $scope.formSubmitted = false
                        AuthService.saveSession(
                            resp.data.token,
                            resp.data.refreshToken,
                            resp.data.userId
                        )
                        $scope.showSpinner = false
                        $state.go('home')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNSUCCESSFUL_LOGIN) {
                            ToastMessage.showMessage(
                                'Email or password provided does not exist.',
                                'error'
                            )
                        } else if (err.status == ERROR_FIELD_USER) {
                            var message = 'Error on fields: '
                            Object.keys(err.data).forEach(function(
                                item,
                                index
                            ) {
                                message += err.data[item].pop()
                            })
                            ToastMessage.showMessage(message, 'error')
                        } else {
                            ToastMessage.showMessage(err.statusText, 'error')
                        }
                    }
                )
            }
        }
    }

    angular
        .module('auth')
        .controller('LoginController', [
            '$scope',
            '$http',
            'AuthService',
            'API_ENDPOINT',
            '$state',
            'ToastMessage',
            'PROJECT',
            LoginController,
        ])
})()

;(function() {
    'use strict'

    function UserCRUDController(
        $scope,
        $http,
        AuthService,
        $state,
        API_ENDPOINT,
        ToastMessage,
        ErrorFormattingService
    ) {
        var userInvestor = '/BackOfficeUsers/investors'
        var userAdmin = '/BackOfficeUsers/administrators'
        var UNAUTHORIZED_REQUEST = 401

        $scope.user = {
            firstname: '',
            lastname: '',
            email: '',
            password: '',
        }
        $scope.typeUser = ''
        $scope.showSpinner = false
        $scope.formTouched = false

        var headers = {
            'Content-Type': 'application/json',
            Authorization: 'Bearer ' + AuthService.getToken(),
        }

        AuthService.checkAuthValid(null, $state)
        $scope.createUser = function() {
            $scope.formTouched = true

            var url = API_ENDPOINT + userInvestor
            if ($scope.typeUser == 'administrator') {
                url = API_ENDPOINT + userAdmin
            }

            if ($scope.userForm.$valid) {
                $scope.showSpinner = true
                $http({
                    url: url,
                    method: 'POST',
                    data: $scope.user,
                    headers: headers,
                }).then(
                    function(data) {
                        ToastMessage.showMessage(
                            'User was created successfully',
                            'success'
                        )
                        $scope.showSpinner = false
                        $state.go('users')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }
    }

    angular
        .module('auth')
        .controller('UserCRUDController', [
            '$scope',
            '$http',
            'AuthService',
            '$state',
            'API_ENDPOINT',
            'ToastMessage',
            'ErrorFormattingService',
            UserCRUDController,
        ])
})()

;(function() {
    'use strict'

    function UsersListController(
        $scope,
        API_ENDPOINT,
        AuthService,
        $state,
        $http,
        ToastMessage,
        ErrorFormattingService
    ) {
        var UNAUTHORIZED_REQUEST = 401
        var pageIndexDefault = 1
        var userListUrl =
            '/BackOfficeUsers?PageIndex=X&PageSize=Y&OrderBy=Z&Order=W'

        $scope.users = []
        $scope.urlBase = API_ENDPOINT + userListUrl
        $scope.pageSizeDefault = 10
        $scope.currentPage = pageIndexDefault
        $scope.showSpinner = true
        $scope.copyClipText = 'Link copy to clipboard'
        $scope.orderBy = 'firstname'
        $scope.order = 'asc'

        $scope.setOrdering = function (orderBy) {
            if ($scope.orderBy == orderBy) {
                if ($scope.order == 'desc') {
                    $scope.order = 'asc'
                } else {
                    $scope.order = 'desc'
                }
            } else {
                $scope.orderBy = orderBy
            }
            $scope.getUsers($scope.currentPage)
        }

        $scope.getUsers = function (page) {
            $scope.showSpinner = true

            if (!page || isNaN(page)) {
                page = pageIndexDefault
            }
            $scope.currentPage = page

            var headers = {
                'Content-Type': 'application/json',
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            var url =
                API_ENDPOINT +
                userListUrl
                    .replace('X', $scope.currentPage)
                    .replace('Y', $scope.pageSizeDefault)
                    .replace('Z', $scope.orderBy)
                    .replace('W', $scope.order)
            return $http({
                url: url,
                method: 'GET',
                headers: headers,
            }).then(
                function (r) {
                    $scope.users = r.data
                    $scope.showSpinner = false
                },
                function (err) {
                    $scope.showSpinner = false
                    if (err.status == UNAUTHORIZED_REQUEST) {
                        $state.go('login')
                    } else {
                        var message = ErrorFormattingService.formatMessage(err)
                        ToastMessage.showMessage(message, 'error')
                    }
                }
            )
        }

        $scope.reInviteUser = function (userId) {
            const url = API_ENDPOINT + '/BackOfficeUsers/' + userId + '/regenerateInvite';
            const headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
                'Content-Type': 'application/json',
            }
            $scope.showSpinner = true
            $http({
                method: 'POST',
                url: url,
                headers: headers,
            }).then(
                function (r) {
                    $scope.getUsers()
                    ToastMessage.showMessage('User invite regenerated', 'info')
                },
                function (e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }


        $scope.sendResetPasswordEmail = function(userId) {
            var url = API_ENDPOINT + '/BackOfficeUsers/' + userId + '/reset'
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
                'Content-Type': 'application/json',
            }

            $scope.showSpinner = true
            $http({
                method: 'POST',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.getUsers()
                    ToastMessage.showMessage('Reset password email sent', 'info')
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.switchEnableUser = function(userId, status) {
            var action = 'disable'
            if (!status) {
                action = 'enable'
            }
            var url = API_ENDPOINT + '/BackOfficeUsers/' + userId + '/' + action
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
                'Content-Type': 'application/json',
            }

            $scope.showSpinner = true
            $http({
                method: 'POST',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.getUsers()
                    var messageEnable = status ? 'disabled' : 'enabled'

                    ToastMessage.showMessage('User ' + messageEnable, 'info')
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        AuthService.checkAuthValid($scope.getUsers, $state)
    }

    angular
        .module('auth')
        .controller('UsersList', [
            '$scope',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            '$http',
            'ToastMessage',
            'ErrorFormattingService',
            UsersListController,
        ])
})()

;(function() {
    'use strict'

    function AuthService($http, API_ENDPOINT) {
        var _this = this

        this.saveSession = function(token, refreshToken, user) {
            localStorage.setItem('token', token)
            localStorage.setItem('refreshToken', refreshToken)
            localStorage.setItem('user', user)
        }

        this.getToken = function() {
            return localStorage.getItem('token')
        }

        this.checkAuthValid = function(callback, $stateService) {
            var urlChecking =
                API_ENDPOINT + '/InvestmentReports?PageIndex=1&PageSize=1'
            if (!callback) {
                callback = function() {}
            }

            $http
                .get(urlChecking, {
                    headers: {
                        Authorization: 'Bearer ' + _this.getToken(),
                    },
                })
                .then(callback, function(err) {
                    if (err.status == 401) {
                        _this.removeToken()
                        $stateService.go('login')
                    }
                })
        }

        this.removeToken = function() {
            localStorage.removeItem('token')
            localStorage.removeItem('refreshToken')
            localStorage.removeItem('user')
        }
    }

    angular
        .module('auth')
        .service('AuthService', ['$http', 'API_ENDPOINT', AuthService])
})()

;(function() {
    'use strict'

    angular.module('media-kit', ['core']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider.state({
                name: 'media-kit',
                url: '/media-kit',
                views: {
                    base: {
                        templateUrl:
                            '/ngtemplates/media-kit/views/media-kit.html',
                        controller: 'MediaKitController',
                    },
                },
            })
        },
    ])
})()

;(function() {
    'use strict'

    function MediaKitController(
        $scope,
        $http,
        API_ENDPOINT,
        $state,
        AuthService,
        ToastMessage,
        MEDIAKIT_ENDPOINT
    ) {
        var fakeUrl = '/api/fake'
        var templateDragItem =
            '<div class="tour-item-container">' +
            '<!--<div class="remove-element-from-container">' +
            '<img src="/dist/img/cross_2.png" alt="Close" />' +
            '</div>-->' +
            '<div class="parent-container">' +
            '{{ template }}' +
            '</div>' +
            '</div>'
        var mediaKitUrl = '/mediakit/upload'
        var UNAUTHORIZED_REQUEST = 401
        $scope.mediaFiles = []
        $scope.showSpinner = true
        $scope.MEDIAKIT_ENDPOINT = MEDIAKIT_ENDPOINT

        // Redirect if token not valid
        var callbackSuccess = function() {
            $scope.showSpinner = false
            $scope.addMediaItem()
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.addMediaItem = function() {
            var modelFile = {
                label: 'File',
                name: 'file',
                loadFile: false,
                fileName: '',
                model: null,
            }
            $scope.mediaFiles.push(modelFile)
        }

        $scope.submitFiles = function() {
            var mediaUrl = API_ENDPOINT + mediaKitUrl
            var fileForm = new FormData()
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
                'Content-Type': undefined,
            }
            $scope.mediaFiles.forEach(function(item, index) {
                if (item.model) {
                    fileForm.append('files', item.model)
                }
            })

            if (Array.from(fileForm.entries()).length) {
                $scope.showSpinner = true
                $http
                    .post(mediaUrl, fileForm, {
                        transformRequest: angular.identity,
                        headers: headers,
                    })
                    .then(
                        function(r) {
                            ToastMessage.showMessage(
                                'Media Kit was uploaded successfully',
                                'success'
                            )
                            $scope.showSpinner = false
                            $state.go('home')
                        },
                        function(err) {
                            if (err.status == UNAUTHORIZED_REQUEST) {
                                $state.go('login')
                            }

                            ToastMessage.showMessage(err, 'error')
                            $scope.showSpinner = false
                        }
                    )
            } else {
                ToastMessage.showMessage(
                    'You must select at least one file to upload a Media Kit',
                    'error'
                )
            }
        }

        $scope.loadDropZone = function() {
            $scope.dropzoneMediaKit = new Dropzone('#dropzone-media-kit', {
                url: fakeUrl,
                autoProcessQueue: false,
                dictDefaultMessage: 'Drop your files here to upload',
            })

            var originalTemplate =
                $scope.dropzoneMediaKit.options.previewTemplate
            $scope.dropzoneMediaKit.options.previewTemplate = templateDragItem.replace(
                '{{ template }}',
                originalTemplate
            )
        }
    }

    angular
        .module('media-kit')
        .controller('MediaKitController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            '$state',
            'AuthService',
            'ToastMessage',
            'MEDIAKIT_ENDPOINT',
            MediaKitController,
        ])
})()

;(function() {
    'use strict'

    angular.module('products', ['ui.router', 'core', '.config']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider
                .state({
                    name: 'products',
                    url: '/products',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/products/views/products-list.html',
                            controller: 'ProductsListController',
                        },
                    },
                })
                .state({
                    name: 'products-create',
                    url: '/products/create',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/products/views/products-edit.html',
                            controller: 'ProductsEditController',
                        },
                    },
                })
                .state({
                    name: 'products-edit',
                    url: '/products/:id/edit',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/products/views/products-edit.html',
                            controller: 'ProductsEditController',
                        },
                    },
                })
        },
    ])
})()

;(function() {
    'use strict'

    function ProductsDetail(
        $scope,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage,
        ErrorFormattingService
    ) {
        var productEndpoint = '/Products'
        var UNAUTHORIZED_REQUEST = 401

        $scope.formTouched = false
        $scope.showSpinner = true
        $scope.productImages = []
        $scope.loadImages = false
        $scope.product = {
            description: '',
            price: 0,
            title: '',
            name: '',
        }

        // Redirect if token not valid
        var callbackSuccess = function() {
            if ($state.params.id) {
                var url =
                    API_ENDPOINT + productEndpoint + '/' + $state.params.id
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                }

                $http({ url: url, method: 'GET', headers: headers }).then(
                    function(r) {
                        $scope.product = r.data
                        $scope.productImages = $scope.product.images
                        $scope.loadImages = true
                        $scope.showSpinner = false
                    }
                )
            } else {
                $scope.showSpinner = false
            }
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.saveProduct = function() {
            $scope.formTouched = true
            var url = API_ENDPOINT + productEndpoint
            var method = 'POST'

            if ($scope.productsEditForm.$valid) {
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                }

                if ($scope.product.productId) {
                    var method = 'PATCH'
                    url += '/' + $scope.product.productId
                }

                $scope.showSpinner = true
                $http({
                    method: method,
                    url: url,
                    headers: headers,
                    data: $scope.product,
                }).then(
                    function(resp) {
                        var prodId = null
                        var statusItem = 'created'
                        if (method == 'POST') {
                            prodId = resp.data.productId
                        } else {
                            prodId = $scope.product.productId
                            statusItem = 'updated'
                        }

                        $scope.productImages.forEach(function(el, index) {
                            $scope.savePicture(prodId, el)
                        })

                        $scope.showSpinner = false
                        ToastMessage.showMessage(
                            'Product was successfully ' + statusItem,
                            'success'
                        )
                        $state.go('products')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }

        $scope.savePicture = function(id, fileObj) {
            var url = API_ENDPOINT + productEndpoint + '/' + id + '/images'
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }
            var request = null

            if (fileObj.status == 'CREATE') {
                var formPict = new FormData()
                var meta = {
                    transformRequest: angular.identity,
                    headers: headers,
                }

                headers['Content-Type'] = undefined

                formPict.append('file', fileObj.file)
                formPict.append('order', fileObj.order)

                request = $http.post(url, formPict, meta)
            } else if (fileObj.status == 'DELETE') {
                url += '/' + fileObj.imageId
                request = $http({
                    method: 'DELETE',
                    url: url,
                    headers: headers,
                })
            } else if (fileObj.status == 'UPDATE') {
                var imgData = {
                    order: fileObj.order,
                }
                url += '/' + fileObj.imageId
                request = $http({
                    method: 'PATCH',
                    url: url,
                    data: imgData,
                    headers: headers,
                })
            }

            if (fileObj.status != 'LOADED') {
                request.then(
                    function(r) {
                        console.log(r)
                    },
                    function(err) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(err.data, 'error')
                    }
                )
            }
        }
    }

    angular
        .module('products')
        .controller('ProductsEditController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            'ErrorFormattingService',
            ProductsDetail,
        ])
})()

;(function() {
    'use strict'

    function ProductsList(
        $scope,
        DEMO_MODE,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage
    ) {
        var prodListUrl = '/Products'
        var pageIndexDefault = 1
        var UNAUTHORIZED_REQUEST = 401

        $scope.productList = []
        $scope.showSpinner = true
        $scope.modalRemove = {
            id: 'removeProduct',
            message: 'Remove?',
        }

        $scope.pageSizeDefault = 10
        $scope.urlBase = API_ENDPOINT + prodListUrl

        // Redirect if token not valid
        var callbackSuccess = function(r) {
            $scope.getProducts()
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.getProducts = function(page) {
            var currentPage = page
            var currentSize = $scope.pageSizeDefault
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            if (!currentPage) {
                currentPage = pageIndexDefault
            }

            $scope.showSpinner = true
            var url = API_ENDPOINT + prodListUrl
            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.productList = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.removeProductConfirm = function(id) {
            $scope.$broadcast('_showConfirmModal_removeProduct', {
                params: { id: id },
            })
        }

        $scope.removeProduct = function(params) {
            var id = params.id
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            $scope.showSpinner = true
            var url = API_ENDPOINT + prodListUrl + '/' + id
            return $http({
                method: 'DELETE',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.getProducts()
                    $scope.showSpinner = false
                    ToastMessage.showMessage(
                        'Product was removed successfully.',
                        'success'
                    )
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.editProduct = function(id) {
            $state.go('products-edit', { id: id })
        }
    }

    angular
        .module('products')
        .controller('ProductsListController', [
            '$scope',
            'DEMO_MODE',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            ProductsList,
        ])
})()

;(function() {
    'use strict'

    function ImageLoaderCtrl($scope, $timeout, $http, $q) {
        var $hiddenInputFile = null
        $scope.modalRemove = {
            id: 'removePicture',
            message: 'Are you sure?',
        }

        $scope.loadDropZone = function() {
            $scope.imgDropZone = new Dropzone('#dropzone-image-loader', {
                url: '/api/fake',
                autoProcessQueue: false,
                acceptedFiles: 'image/*',
                dictDefaultMessage: 'Drop your files here to upload',
                thumbnail: thumbnailLoadImg,
                complete: completeLoadImg,
                error: errorLoadImg,
            })

            $hiddenInputFile = $($scope.imgDropZone.hiddenFileInput)
            Sortable.create(document.getElementById('dropzone-image-loader'), {
                animation: 150,
                draggable: '.dz-preview',
                group: 'grid-gallery-group',
                ghostClass: 'ghost',
                fallbackTolerance: 3,
                forceFallback: true,
                onUpdate: function(evt) {
                    $scope.updateOrderPictures()
                },
                onEnd: function(evt) {
                    $hiddenInputFile.attr('disabled', true)
                    $timeout(function() {
                        $($scope.imgDropZone.hiddenFileInput).removeAttr(
                            'disabled'
                        )
                    }, 500)
                },
            })
        }

        $scope.updateOrderPictures = function() {
            $('.dz-preview').each(function(index, el) {
                var pictStatus = $scope.images[index].status
                $scope.images[index].order = index

                if (
                    pictStatus == 'UPDATE' ||
                    (pictStatus == 'LOADED' &&
                        $scope.images[index].order != index)
                ) {
                    $scope.images[index].status = 'UPDATE'
                }

                operateAttrOrder($(el), index)
            })
        }

        $scope.loadPictures = function() {
            var pictPromises = []

            $scope.images.forEach(function(el, index) {
                var imgUrl = el['uri']
                var imgName = el['imageId']

                var promise = $http
                    .get(imgUrl, { responseType: 'blob' })
                    .then(function(response) {
                        var fileInstance = new File([response.data], imgName, {
                            type: response.data.type,
                        })

                        fileInstance.loaded = true
                        fileInstance.orderFile = el['order']

                        $scope.images[index].file = fileInstance
                        $scope.images[index].status = 'LOADED'
                        $scope.imgDropZone.emit('addedfile', fileInstance)
                        $scope.imgDropZone.emit(
                            'thumbnail',
                            fileInstance,
                            response.config.url
                        )
                    })
                pictPromises.push(promise)
            })

            return pictPromises
        }

        var $$loadImgWatcher = $scope.$watch('loadImages', function(v) {
            if (!v) return

            $$loadImgWatcher()
            var prom = $scope.loadPictures()
            $q.all(prom).then(function() {
                $scope.updateOrderPictures()
            })
        })

        /*************************/
        /*      Callbacks        */
        /*************************/

        function loadPictureInDropzone(response) {
            var fileInstance = new File([response.data], fileName, {
                type: response.data.type,
            })

            fileInstance.loaded = true

            $scope.images[index].file = fileInstance
            $scope.images[index].status = 'LOADED'
            $scope.imgDropZone.emit('addedfile', fileInstance)
            $scope.imgDropZone.emit(
                'thumbnail',
                fileInstance,
                response.config.url
            )
        }

        function operateAttrOrder($el, order) {
            if (!order && isNaN(order)) {
                return parseInt($el.attr('data-order'), 10)
            } else {
                $el.attr('data-order', order)
            }
        }

        function removeImgConfirm(ev) {
            $scope.$broadcast('_showConfirmModal_removePicture', {
                params: {
                    removeEvent: ev,
                    updateCycle: true,
                },
            })
        }

        function removeImg(params) {
            var $el = $(params.removeEvent.currentTarget)
            var $parent = $el.parent()
            var order = operateAttrOrder($parent)
            $parent.remove()

            if ($scope.images[order].status == 'CREATE') {
                $scope.images.splice(order, 1)
            } else {
                $scope.images[order].status = 'DELETE'
            }

            $scope.updateOrderPictures()
        }

        function completeLoadImg(file) {
            Dropzone.prototype.defaultOptions.complete(file)
            var $el = $(file.previewElement)
            var $elErr = $el.find('.dz-error-mark')
            $elErr.click(removeImgConfirm)

            if (!file.loaded) {
                operateAttrOrder($el, $scope.images.length)
                $scope.images.push({
                    file: file,
                    order: $scope.images.length,
                    status: 'CREATE',
                })
            } else {
                operateAttrOrder($el, file.orderFile)
            }
        }

        function thumbnailLoadImg(file, dataUrl) {
            var _this = this
            Dropzone.prototype.defaultOptions.thumbnail(file, dataUrl)

            $timeout(function() {
                var $previewEl = $(file.previewElement)[0]
                $previewEl.classList.add('dz-success')
                _this.emit('complete', file)
            }, 1)
        }

        function errorLoadImg(file, error) {
            Dropzone.prototype.defaultOptions.error(file, error)
        }

        $scope.removeImg = removeImg
        $scope.loadDropZone()
    }

    angular.module('products').directive('imageLoader', function() {
        return {
            restrict: 'E',
            templateUrl: '/ngtemplates/products/directives/image-loader.html',
            scope: {
                images: '=',
                loadImages: '=?',
            },
            controller: ['$scope', '$timeout', '$http', '$q', ImageLoaderCtrl],
        }
    })
})()

;(function() {
    'use strict'

    angular.module('newsletter', ['ui.router', 'core', '.config']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider.state({
                name: 'newsletter-list',
                url: '/newsletter',
                views: {
                    base: {
                        templateUrl:
                            '/ngtemplates/newsletter/views/newsletter-list.html',
                        controller: 'NewsLetterListController',
                    },
                },
            })
        },
    ])
})()

;(function() {
    'use strict'

    // TODO: Remove $timeout on API integration
    function NewsLetterListController(
        $scope,
        ExportCSVService,
        $timeout,
        AuthService,
        $state,
        API_ENDPOINT,
        ToastMessage,
        $http
    ) {
        var newsletterURL =
            '/NewsletterMails?pageNumber=X&pageSize=Y&orderBy=date'
        var UNAUTHORIZED_REQUEST = 401
        var pageIndexDefault = 1
        var headers = {
            Authorization: 'Bearer ' + AuthService.getToken(),
        }

        $scope.showSpinner = true
        $scope.newsletterList = []
        $scope.urlBase = API_ENDPOINT + newsletterURL
        $scope.pageSizeDefault = 5
        $scope.modalRemove = {
            id: 'removeNews',
            message: 'Remove?',
        }

        $scope.removeNewsletterItemConfirm = function(email) {
            $scope.$broadcast('_showConfirmModal_removeNews', {
                params: { email: email },
            })
        }

        $scope.removeNewsletterItem = function(params) {
            var email = params.email
            if (email) {
                var url = API_ENDPOINT + '/NewsletterMails/' + email

                $scope.showSpinner = true
                $http({
                    method: 'DELETE',
                    url: url,
                    headers: headers,
                }).then(
                    function(r) {
                        $scope.loadNewsLetterList()
                        ToastMessage.showMessage(
                            'Newsletter ' + email + ' removed successfully',
                            'success'
                        )
                    },
                    function(e) {
                        $scope.showSpinner = false
                        if (e.status == UNAUTHORIZED_REQUEST) {
                            ToastMessage.showMessage(e.statusText, 'error')
                            $state.go('login')
                        } else {
                            ToastMessage.showMessage(e.data, 'error')
                        }
                    }
                )
            }
        }

        $scope.exportToCSV = function() {
            ExportCSVService.exportToCSV(
                $scope.newsletterList,
                'newsletter-report'
            )
        }

        $scope.loadNewsLetterList = function(page) {
            var currentPage = page
            var currentSize = $scope.pageSizeDefault

            if (!currentPage) {
                currentPage = pageIndexDefault
            }

            var url =
                API_ENDPOINT +
                newsletterURL
                    .replace('X', currentPage)
                    .replace('Y', currentSize)

            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.newsletterList = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        AuthService.checkAuthValid($scope.loadNewsLetterList, $state)
    }

    angular
        .module('newsletter')
        .controller('NewsLetterListController', [
            '$scope',
            'ExportCSVService',
            '$timeout',
            'AuthService',
            '$state',
            'API_ENDPOINT',
            'ToastMessage',
            '$http',
            NewsLetterListController,
        ])
})()

;(function() {
    'use strict'

    angular.module('early-access', ['ui.router', 'core', '.config']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider.state({
                name: 'early-access-list',
                url: '/early-access',
                views: {
                    base: {
                        templateUrl:
                            '/ngtemplates/early-access/views/betatest.html',
                        controller: 'BetaTestListController',
                    },
                },
            })
        },
    ])
})()

;(function() {
    'use strict'

    // TODO: Remove $timeout on API integration
    function BetaTestListController(
        $scope,
        ExportCSVService,
        $timeout,
        AuthService,
        $state,
        API_ENDPOINT,
        ToastMessage,
        $http
    ) {
        var earlyAccessURL =
            '/EarlyAccessMails?pageNumber=X&pageSize=Y&orderBy=date'
        var UNAUTHORIZED_REQUEST = 401
        var pageIndexDefault = 1
        var headers = {
            Authorization: 'Bearer ' + AuthService.getToken(),
        }

        $scope.showSpinner = true
        $scope.earlyAccessList = []
        $scope.urlBase = API_ENDPOINT + earlyAccessURL
        $scope.pageSizeDefault = 5
        $scope.modalRemove = {
            id: 'removeEA',
            message: 'Remove?',
        }

        $scope.removeEarlyAccessItemConfirm = function(email) {
            $scope.$broadcast('_showConfirmModal_removeEA', {
                params: { email: email },
            })
        }

        $scope.removeEarlyAccessItem = function(params) {
            var email = params.email
            if (email) {
                var url = API_ENDPOINT + '/EarlyAccessMails/' + email

                $scope.showSpinner = true
                $http({
                    method: 'DELETE',
                    url: url,
                    headers: headers,
                }).then(
                    function(r) {
                        $scope.loadEarlyAccess()
                        ToastMessage.showMessage(
                            'Early Access ' + email + ' removed successfully',
                            'success'
                        )
                    },
                    function(e) {
                        $scope.showSpinner = false
                        if (e.status == UNAUTHORIZED_REQUEST) {
                            ToastMessage.showMessage(e.statusText, 'error')
                            $state.go('login')
                        } else {
                            ToastMessage.showMessage(e.data, 'error')
                        }
                    }
                )
            }
        }

        $scope.exportToCSV = function() {
            ExportCSVService.exportToCSV(
                $scope.earlyAccessList,
                'access-list-report'
            )
        }

        $scope.loadEarlyAccess = function(page) {
            var currentPage = page
            var currentSize = $scope.pageSizeDefault

            if (!currentPage) {
                currentPage = pageIndexDefault
            }

            var url =
                API_ENDPOINT +
                earlyAccessURL
                    .replace('X', currentPage)
                    .replace('Y', currentSize)

            $scope.showSpinner = true
            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.earlyAccessList = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        AuthService.checkAuthValid($scope.loadEarlyAccess, $state)
    }

    angular
        .module('early-access')
        .controller('BetaTestListController', [
            '$scope',
            'ExportCSVService',
            '$timeout',
            'AuthService',
            '$state',
            'API_ENDPOINT',
            'ToastMessage',
            '$http',
            BetaTestListController,
        ])
})()

;(function() {
    'use strict'

    angular.module('releases', ['ui.router', 'core', '.config']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider
                .state({
                    name: 'releases',
                    url: '/releases',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/releases/views/releases-list.html',
                            controller: 'ReleasesListController',
                        },
                    },
                })
                .state({
                    name: 'releases-create',
                    url: '/releases/create',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/releases/views/releases-create.html',
                            controller: 'ReleasesDetailController',
                        },
                    },
                })
                .state({
                    name: 'release-detail',
                    url: '/releases/:id',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/releases/views/release-new-display.html',
                            controller: 'ReleaseDisplayViewController',
                        },
                    },
                })
        },
    ])
})()

;(function() {
    'use strict'

    function ReleaseDisplayViewController(
        $scope,
        $http,
        $state,
        AuthService,
        API_ENDPOINT,
        ENDPOINT_BASE,
        ToastMessage
    ) {
        var releaseEndpoint = '/PressReleases'
        var url = API_ENDPOINT + releaseEndpoint
        var headers = {
            Authorization: 'Bearer ' + AuthService.getToken(),
        }

        $scope.releaseNewData = {}
        $scope.showSpinner = false
        $scope.ENDPOINT_BASE = ENDPOINT_BASE

        // Redirect if token not valid
        var callbackSuccess = function() {
            if ($state.params.id) {
                $scope.showSpinner = true
                url += '/' + $state.params.id
                $http({ url: url, method: 'GET', headers: headers }).then(
                    function(response) {
                        $scope.releaseNewData = response.data
                        $scope.showSpinner = false
                    },
                    function(e) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(e, 'error')
                    }
                )
            }
        }
        AuthService.checkAuthValid(callbackSuccess, $state)
    }

    angular
        .module('releases')
        .controller('ReleaseDisplayViewController', [
            '$scope',
            '$http',
            '$state',
            'AuthService',
            'API_ENDPOINT',
            'ENDPOINT_BASE',
            'ToastMessage',
            ReleaseDisplayViewController,
        ])
})()

;(function() {
    'use strict'

    function ReleasesDetail(
        $scope,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage,
        ErrorFormattingService
    ) {
        var releaseEndpoint = '/PressReleases'
        var UNAUTHORIZED_REQUEST = 401

        $scope.options = {
            showWeeks: false,
            dateDisabled: function(date, mode) {
                return false
            },
            minDate: new Date('January 01, 1970 00:00:00'),
            maxDate: new Date('December 31, 2040 23:59:59'),
        }

        $scope.showSpinner = false
        $scope.formTouched = false
        $scope.releaseNewInformation = {
            date: new Date(),
            title: '',
            file: null,
            image: null,
        }

        $scope.releaseImage = {
            label: 'Image (355px x 240px)',
            name: 'releaseimage',
            loadFile: false,
            fileName: '',
        }
        $scope.releasePdfFile = {
            label: 'PDF File',
            name: 'releasepdffile',
            loadFile: false,
            fileName: '',
        }

        // Redirect if token not valid
        var callbackSuccess = function() {
            if ($state.params.id) {
                var url =
                    API_ENDPOINT + releaseEndpoint + '/' + $state.params.id
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                }

                $http({ url: url, method: 'GET', headers: headers }).then(
                    function(r) {
                        $scope.releaseNewInformation = r.data

                        // Load files
                        $scope.releasePdfFile.fileName = r.data.fileName
                        $scope.releaseImage.fileName = r.data.imgName

                        // Enable files
                        $scope.releasePdfFile.loadFile = true
                        $scope.releaseImage.loadFile = true
                    }
                )
            }
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.hasReleasePDF = function() {
            return $scope.releaseNewInformation.file
        }

        $scope.hasReleaseImage = function() {
            return $scope.releaseNewInformation.image
        }

        $scope.saveReleaseInformation = function() {
            $scope.formTouched = true

            if (!$scope.hasReleasePDF()) {
                $scope.releaseForm.releasepdffile.$error.pdfrequired = true
                $scope.releaseForm.$valid = false
            }

            if (!$scope.hasReleaseImage()) {
                $scope.releaseForm.releaseimage.$error.imagerequired = true
                $scope.releaseForm.$valid = false
            }

            if ($scope.releaseForm.$valid) {
                var url = API_ENDPOINT + releaseEndpoint
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                    'Content-Type': undefined,
                }
                var formData = new FormData()
                var callbackHttp = $http.post
                formData.append(
                    'Date',
                    moment($scope.releaseNewInformation.date).format(
                        'MM/DD/YYYY'
                    )
                )
                formData.append('Title', $scope.releaseNewInformation.title)
                formData.append('file', $scope.releaseNewInformation.file)
                formData.append('Image', $scope.releaseNewInformation.image)

                if ($scope.releaseNewInformation.pressReleaseId) {
                    var callbackHttp = $http.patch
                }

                $scope.showSpinner = true
                callbackHttp(url, formData, {
                    transformRequest: angular.identity,
                    headers: headers,
                }).then(
                    function(r) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(
                            'Release new was successfully created.',
                            'success'
                        )
                        $state.go('releases')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }

        $scope.$watch(
            'releaseNewInformation',
            function(val) {
                if (val.file) {
                    $scope.releaseForm.releasepdffile.$error.pdfrequired = false
                }

                if (val.image) {
                    $scope.releaseForm.releaseimage.$error.imagerequired = false
                }
            },
            true
        )
    }

    angular
        .module('releases')
        .controller('ReleasesDetailController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            'ErrorFormattingService',
            ReleasesDetail,
        ])
})()

;(function() {
    'use strict'

    function ReleasesList(
        $scope,
        DEMO_MODE,
        $http,
        API_ENDPOINT,
        ENDPOINT_BASE,
        AuthService,
        $state,
        ToastMessage
    ) {
        var releaseListUrl = '/PressReleases?PageIndex=X&PageSize=Y'
        var pageIndexDefault = 1
        var UNAUTHORIZED_REQUEST = 401

        $scope.releaseNewsList = []
        $scope.showSpinner = true
        $scope.ENDPOINT_BASE = ENDPOINT_BASE
        $scope.currentPage = pageIndexDefault
        $scope.pageSizeDefault = 10
        $scope.urlBase = API_ENDPOINT + releaseListUrl

        // Redirect if token not valid
        var callbackSuccess = function() {
            $scope.getReleases()
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.getReleases = function(page) {
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }
            if (!page || isNaN(page)) {
                page = pageIndexDefault
            }
            $scope.currentPage = page

            var url =
                API_ENDPOINT +
                releaseListUrl
                    .replace('X', $scope.currentPage)
                    .replace('Y', $scope.pageSizeDefault)
            $scope.showSpinner = true
            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.releaseNewsList = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.switchEnableRelease = function(releaseId, status) {
            var url = API_ENDPOINT + '/PressReleases/' + releaseId
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            $scope.showSpinner = true
            $http({
                method: 'PATCH',
                url: url,
                headers: headers,
                data: {
                    Active: !status,
                },
            }).then(
                function(r) {
                    $scope.getReleases()
                    var messageEnable = status ? 'disabled' : 'enabled'

                    ToastMessage.showMessage('Release ' + messageEnable, 'info')
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.viewRelease = function(releaseId) {
            $state.go('release-detail', { id: releaseId })
        }
    }

    angular
        .module('releases')
        .controller('ReleasesListController', [
            '$scope',
            'DEMO_MODE',
            '$http',
            'API_ENDPOINT',
            'ENDPOINT_BASE',
            'AuthService',
            '$state',
            'ToastMessage',
            ReleasesList,
        ])
})()

;(function() {
    'use strict'

    angular.module('reports', ['ui.router', 'core', '.config']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider
                .state({
                    name: 'reports',
                    url: '/reports',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/reports/views/reports-list.html',
                            controller: 'ReportsListController',
                        },
                    },
                })
                .state({
                    name: 'reports-create',
                    url: '/reports/create',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/reports/views/reports-create.html',
                            controller: 'ReportsDetailController',
                        },
                    },
                })
                .state({
                    name: 'report-detail',
                    url: '/reports/:id',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/reports/views/report-display.html',
                            controller: 'ReportDisplayViewController',
                        },
                    },
                })
        },
    ])
})()

;(function() {
    'use strict'

    function ReportDisplayViewController(
        $scope,
        $http,
        $state,
        AuthService,
        API_ENDPOINT,
        ENDPOINT_BASE,
        ToastMessage
    ) {
        var reportEndpoint = '/InvestmentReports'
        var url = API_ENDPOINT + reportEndpoint
        var headers = {
            Authorization: 'Bearer ' + AuthService.getToken(),
        }

        $scope.reportData = {}
        $scope.showSpinner = false
        $scope.ENDPOINT_BASE = ENDPOINT_BASE

        // Redirect if token not valid
        var callbackSuccess = function() {
            if ($state.params.id) {
                $scope.showSpinner = true
                var reqUrl = url + ('/' + $state.params.id)
                $http({ url: reqUrl, method: 'GET', headers: headers }).then(
                    function(response) {
                        $scope.reportData = response.data
                        $scope.showSpinner = false
                    },
                    function(e) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(e, 'error')
                    }
                )
            } else {
                $state.go('reports')
            }
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.downloadReport = function($event) {
            $event.preventDefault()
            var dUrl =
                url +
                '/' +
                String($scope.reportData.investmentReportId) +
                '/download?hash=' +
                AuthService.getToken()
            window.open(dUrl)
        }
    }

    angular
        .module('reports')
        .controller('ReportDisplayViewController', [
            '$scope',
            '$http',
            '$state',
            'AuthService',
            'API_ENDPOINT',
            'ENDPOINT_BASE',
            'ToastMessage',
            ReportDisplayViewController,
        ])
})()

;(function() {
    'use strict'

    function ReportsDetail(
        $scope,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage,
        ErrorFormattingService
    ) {
        var reportEndpoint = '/InvestmentReports'
        var UNAUTHORIZED_REQUEST = 401
        $scope.menuOptions = {
            quarters: ['Quarter1', 'Quarter2', 'Quarter3', 'Quarter4'],
            months: {
                Quarter4: ['October', 'November', 'December'],
                Quarter3: ['July', 'August', 'September'],
                Quarter2: ['April', 'May', 'June'],
                Quarter1: ['January', 'February', 'March'],
            },
            reportTypes: [
                'ProfitAndLoss',
                'BalanceSheet',
                'CashFlow',
                'BudgetVsActual',
                'InvestorsUpdate',
                'Annual',
            ],
        }

        $scope.formTouched = false
        $scope.showSpinner = false
        $scope.reportInvestmentInfo = {
            year: new Date().getFullYear(),
            quarter: '',
            title: '',
            month: '',
            type: '',
            file: null,
            active: true,
        }
        $scope.reportFile = {
            label: 'File report',
            name: 'filereport',
            loadFile: false,
            required: true,
            fileName: '',
        }

        // Redirect if token not valid
        var callbackSuccess = function() {
            if ($state.params.id) {
                var url = API_ENDPOINT + reportEndpoint + '/' + $state.params.id
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                }

                $http({ url: url, method: 'GET', headers: headers }).then(
                    function(r) {
                        var data = r.data
                        $scope.reportInvestmentInfo = data
                        $scope.reportFile.fileName = data.fileName
                        $scope.reportFile.loadFile = true
                    }
                )
            }
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.isMonthInQuarter = function() {
            var month = $scope.reportInvestmentInfo.month
            var quarter = $scope.reportInvestmentInfo.quarter

            if (quarter && month) {
                return $scope.menuOptions.months[quarter].indexOf(month) != -1
            }
            return true
        }

        $scope.hasReportFile = function() {
            return $scope.reportInvestmentInfo.file
        }

        $scope.createReport = function() {
            $scope.formTouched = true
            var url = API_ENDPOINT + reportEndpoint
            var formData = new FormData()
            var callbackHttp = $http.post

            if ($scope.reportInvestmentInfo.type == 'Annual') {
                $scope.reportInvestmentInfo.quarter = ''
                $scope.reportInvestmentInfo.month = ''
            }

            if (!$scope.isMonthInQuarter()) {
                $scope.reportsCreateForm.month.$error.monthnotinquarter = true
                $scope.reportsCreateForm.$valid = false
            }

            if (!$scope.hasReportFile()) {
                $scope.reportsCreateForm.filereport.$error.filerequired = true
                $scope.reportsCreateForm.$valid = false
            }

            if ($scope.reportsCreateForm.$valid) {
                formData.append('Year', $scope.reportInvestmentInfo.year)
                formData.append(
                    'Quarter',
                    $scope.reportInvestmentInfo.quarter.toLowerCase()
                )
                formData.append('Title', $scope.reportInvestmentInfo.title)
                formData.append(
                    'Month',
                    $scope.reportInvestmentInfo.month.toLowerCase()
                )
                formData.append('Type', $scope.reportInvestmentInfo.type)
                formData.append('File', $scope.reportInvestmentInfo.file)
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                    'Content-Type': undefined,
                }

                if ($scope.reportInvestmentInfo.investmentReportId) {
                    var callbackHttp = $http.patch
                }

                $scope.showSpinner = true
                callbackHttp(url, formData, {
                    transformRequest: angular.identity,
                    headers: headers,
                }).then(
                    function(resp) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(
                            'Report investment was successfully created',
                            'success'
                        )
                        $state.go('reports')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }

        $scope.$watch(
            'reportInvestmentInfo',
            function(val) {
                if (val.month && val.quarter && $scope.isMonthInQuarter()) {
                    $scope.reportsCreateForm.month.$error.monthnotinquarter = false
                }

                if (val.file) {
                    $scope.reportsCreateForm.filereport.$error.filerequired = false
                }
            },
            true
        )
    }

    angular
        .module('reports')
        .controller('ReportsDetailController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            'ErrorFormattingService',
            ReportsDetail,
        ])
})()

;(function() {
    'use strict'

    function ReportsList(
        $scope,
        DEMO_MODE,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage
    ) {
        var reportsListUrl = '/InvestmentReports?PageIndex=X&PageSize=Y'
        var pageIndexDefault = 1
        var UNAUTHORIZED_REQUEST = 401

        $scope.reportsInvestList = []
        $scope.showSpinner = true
        $scope.currentPage = pageIndexDefault
        $scope.pageSizeDefault = 10
        $scope.urlBase = API_ENDPOINT + reportsListUrl

        // Redirect if token not valid
        var callbackSuccess = function(r) {
            $scope.getReports()
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.getReports = function(page) {
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            if (!page || isNaN(page)) {
                page = pageIndexDefault
            }
            $scope.currentPage = page

            $scope.showSpinner = true
            var url =
                API_ENDPOINT +
                reportsListUrl
                    .replace('X', $scope.currentPage)
                    .replace('Y', $scope.pageSizeDefault)
            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.reportsInvestList = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.switchEnableReport = function(reportId, status) {
            var url = API_ENDPOINT + '/InvestmentReports/' + reportId
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            $scope.showSpinner = true
            $http({
                method: 'PATCH',
                url: url,
                headers: headers,
                data: {
                    Active: !status,
                },
            }).then(
                function(r) {
                    $scope.getReports()
                    var messageEnable = status ? 'disabled' : 'enabled'

                    ToastMessage.showMessage('Report ' + messageEnable, 'info')
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.viewReport = function(reportId) {
            $state.go('report-detail', { id: reportId })
        }
    }

    angular
        .module('reports')
        .controller('ReportsListController', [
            '$scope',
            'DEMO_MODE',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            ReportsList,
        ])
})()

;(function() {
    'use strict'

    angular.module('tokens', ['ui.router', 'core', '.config']).config([
        '$stateProvider',
        function($stateProvider) {
            $stateProvider
                .state({
                    name: 'token-edit',
                    url: '/tokens/:id',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/tokens/views/token-edition.html',
                            controller: 'TokenEditController',
                        },
                    },
                })
                .state({
                    name: 'token-list',
                    url: '/tokens',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/tokens/views/token-list.html',
                            controller: 'TokenListController',
                        },
                    },
                })
                .state({
                    name: 'tokens-per-event-list',
                    url: '/tokens/events',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/tokens/views/token-event-list.html',
                            controller: 'TokensPerEventListController',
                        },
                    },
                })
                .state({
                    name: 'tokens-per-event-edit',
                    url: '/tokens/events/:id/edit',
                    views: {
                        base: {
                            templateUrl:
                                '/ngtemplates/tokens/views/token-event-edit.html',
                            controller: 'TokensPerEventEditController',
                        },
                    },
                })
        },
    ])
})()

;(function() {
    'use strict'

    function TokenEditController(
        $scope,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage
    ) {
        var tokenUrl = '/TokenArbitrations'
        var UNAUTHORIZED_REQUEST = 401

        $scope.formTouched = false
        $scope.showSpinner = true
        $scope.token = {
            price: 0.1,
            minimunToConsume: 1,
        }

        if ($state.params.id) {
            var url = API_ENDPOINT + tokenUrl + '/' + $state.params.id
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            $http({ url: url, method: 'GET', headers: headers }).then(
                function(r) {
                    $scope.token.price = r.data.price
                    $scope.token.minimunToConsume = r.data.minimunToConsume
                    $scope.showSpinner = false
                },
                function(e) {
                    console.error(e)
                    $scope.showSpinner = false
                }
            )
        }

        $scope.saveToken = function() {
            $scope.formTouched = true

            if ($scope.tokenForm.$valid) {
                var url = API_ENDPOINT + tokenUrl
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                }

                $scope.showSpinner = true
                $http({
                    url: url,
                    method: 'POST',
                    data: $scope.token,
                    headers: headers,
                }).then(
                    function(resp) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(
                            'Token was successfully updated',
                            'success'
                        )
                        $state.go('token-list')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }
    }

    angular
        .module('tokens')
        .controller('TokenEditController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            TokenEditController,
        ])
})()

;(function() {
    'use strict'

    function TokenListController(
        $scope,
        ENDPOINT_BASE,
        API_ENDPOINT,
        $state,
        ToastMessage,
        AuthService,
        $http
    ) {
        var tokenEventsListUrl = '/TokenArbitrations'
        var UNAUTHORIZED_REQUEST = 401

        $scope.tokenArbitrations = []
        $scope.showSpinner = true
        $scope.ENDPOINT_BASE = ENDPOINT_BASE
        $scope.urlBase = API_ENDPOINT + tokenEventsListUrl

        // Redirect if token not valid
        var callbackSuccess = function() {
            $scope.getTokenArbitrations()
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.getTokenArbitrations = function() {
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            var url = API_ENDPOINT + tokenEventsListUrl
            $scope.showSpinner = true
            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.tokenArbitrations = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.editToken = function() {
            var lastToken =
                $scope.tokenArbitrations[$scope.tokenArbitrations.length - 1]
            var tokenId = null
            if (lastToken) {
                tokenId = lastToken.tokenArbitrationId
                $scope.redirectTokenEdit(tokenId)
            }
        }

        $scope.redirectTokenEdit = function(eventId) {
            $state.go('token-edit', { id: eventId })
        }
    }

    angular
        .module('tokens')
        .controller('TokenListController', [
            '$scope',
            'ENDPOINT_BASE',
            'API_ENDPOINT',
            '$state',
            'ToastMessage',
            'AuthService',
            '$http',
            TokenListController,
        ])
})()

;(function() {
    'use strict'

    function TokensPerEventEdit(
        $scope,
        $http,
        API_ENDPOINT,
        AuthService,
        $state,
        ToastMessage
    ) {
        var tokenEventUrl = '/EventTokenArbitrations'
        var UNAUTHORIZED_REQUEST = 401

        $scope.event = {
            description: '',
            eventKind: '',
            eventTokenArbitrationId: '',
            tokens: 0,
        }
        $scope.showSpinner = true
        $scope.formTouched = false

        if ($state.params.id) {
            var url = API_ENDPOINT + tokenEventUrl + '/' + $state.params.id
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            $http({ url: url, method: 'GET', headers: headers }).then(
                function(r) {
                    $scope.event = r.data
                    $scope.showSpinner = false
                },
                function(e) {
                    console.error(e)
                    $scope.showSpinner = false
                }
            )
        }

        $scope.updateEventToken = function() {
            $scope.formTouched = true

            if ($scope.tokenEvForm.$valid) {
                var data = {
                    Tokens: $scope.event.tokens,
                }
                var url = API_ENDPOINT + tokenEventUrl + '/' + $state.params.id
                var headers = {
                    Authorization: 'Bearer ' + AuthService.getToken(),
                }

                $scope.showSpinner = true
                $http({
                    url: url,
                    method: 'PUT',
                    data: data,
                    headers: headers,
                }).then(
                    function(resp) {
                        $scope.showSpinner = false
                        ToastMessage.showMessage(
                            'Event arbitration was successfully updated',
                            'success'
                        )
                        $state.go('tokens-per-event-list')
                    },
                    function(err) {
                        $scope.showSpinner = false
                        if (err.status == UNAUTHORIZED_REQUEST) {
                            $state.go('login')
                        } else {
                            var message = ErrorFormattingService.formatMessage(
                                err
                            )
                            ToastMessage.showMessage(message, 'error')
                        }
                    }
                )
            }
        }
    }

    angular
        .module('tokens')
        .controller('TokensPerEventEditController', [
            '$scope',
            '$http',
            'API_ENDPOINT',
            'AuthService',
            '$state',
            'ToastMessage',
            TokensPerEventEdit,
        ])
})()

;(function() {
    'use strict'

    function TokensPerEventList(
        $scope,
        ENDPOINT_BASE,
        API_ENDPOINT,
        $state,
        ToastMessage,
        AuthService,
        $http
    ) {
        var tokenEventsListUrl = '/EventTokenArbitrations'
        var UNAUTHORIZED_REQUEST = 401

        $scope.events = []
        $scope.showSpinner = true
        $scope.ENDPOINT_BASE = ENDPOINT_BASE
        $scope.urlBase = API_ENDPOINT + tokenEventsListUrl

        // Redirect if token not valid
        var callbackSuccess = function() {
            $scope.getTokenEvents()
        }
        AuthService.checkAuthValid(callbackSuccess, $state)

        $scope.getTokenEvents = function() {
            var headers = {
                Authorization: 'Bearer ' + AuthService.getToken(),
            }

            var url = API_ENDPOINT + tokenEventsListUrl
            $scope.showSpinner = true
            return $http({
                method: 'GET',
                url: url,
                headers: headers,
            }).then(
                function(r) {
                    $scope.events = r.data
                    $scope.showSpinner = false
                    return r
                },
                function(e) {
                    $scope.showSpinner = false
                    if (e.status == UNAUTHORIZED_REQUEST) {
                        ToastMessage.showMessage(e.statusText, 'error')
                        $state.go('login')
                    } else {
                        ToastMessage.showMessage(e.data, 'error')
                    }
                }
            )
        }

        $scope.editTokenEvent = function(eventId) {
            $state.go('tokens-per-event-edit', { id: eventId })
        }
    }

    angular
        .module('tokens')
        .controller('TokensPerEventListController', [
            '$scope',
            'ENDPOINT_BASE',
            'API_ENDPOINT',
            '$state',
            'ToastMessage',
            'AuthService',
            '$http',
            TokensPerEventList,
        ])
})()

;(function() {
    'use strict'

    let project = 'WELWAZE'
    let deps = ['ui.router', 'ngMessages', 'ui.bootstrap', 'core', 'auth']

    if (project.localeCompare('WELWAZE') === 0) {
        deps.push('reports')
        deps.push('releases')
        deps.push('media-kit')
    } else if (project.localeCompare('CELBREA') === 0) {
        deps.push('early-access')
        deps.push('newsletter')
        deps.push('products')
        deps.push('tokens')
    }
    console.log(deps)
    angular.module('app', deps).config([
        '$urlRouterProvider',
        '$locationProvider',
        function($urlRouterProvider, $locationProvider) {
            $urlRouterProvider.otherwise('/')
            $locationProvider.html5Mode(true)
        },
    ])
})()