angular.module('appServices').factory('sessionService', ['$q',
    function ($q) {
        function getCurrentLoginSession() {
            var deferred = $q.defer();
            socialid.login.getConnectionStatus(function (response) {
                if (response.status === "success") {
                    deferred.resolve(response.data.connection_id);
                } else {
                    deferred.reject("Could not get info from the current login session.");
                }
            });
            return deferred.promise;
        }

        return {
            getCurrentLoginSession
        };
    }
]);
angular.module('appServices').factory('configService', ['$q', '$http', 'sessionService', 'cbtWorkflows',
    function ($q, $http, sessionService, cbtWorkflows) {
        var data = null;
        var promise = null;

        function get() {
            if (data) {
                return $q.resolve(data);
            }

            if (promise) {
                return promise;
            }

            var deferred = $q.defer();
            promise = deferred.promise;

            sessionService.getCurrentLoginSession().then(function (connectionId) {
                $http.post(cbtWorkflows.url + "/config", {
                    connection_id: connectionId
                }).then(function (response) {
                    deferred.resolve(response.data);
                });
            });

            return promise;
        }

        function reset() {
            data = null;
            promise = null;
        }

        return {
            get,
            reset
        };
    }
]);
// extend original currentUserService with currentUser.permissions

angular.module('appServices').factory('currentUserService', ['$q', 'emailHelperService', 'sidLoginService', 'userModelService', 'sidRaasService', 'configService',
    function ($q, emailHelper, sidLoginService, userModelService, sidRaasService, configService) {
        var currentUser;

        function get() {
            if (currentUser) {
                return $q.resolve(currentUser);
            } else {
                return $q.reject();
            }
        }

        function refresh() {
            return sidLoginService.getUserInfo().then(function (userInfo) {
                currentUser = userModelService.createFromUserInfo(userInfo);
                return sidLoginService.getConnectionStatus().then(function (connection) {
                    userModelService.updateWithConnection(currentUser, connection);
                    return sidLoginService.getUserDatastore().then(function (data) {
                        userModelService.updateWithData(currentUser, data);
                        return configService.get().then(function (config) {
                            currentUser.permissions = config.permissions;
                            return currentUser;
                        });
                    }, function (error) {
                        return currentUser;
                    });
                });
            });
        }

        function logout() {
            currentUser = null;
        }

        function update(user) {
            var extra = {
                confirmation_email: emailHelper.emailParams()
            };
            return sidRaasService.updateUser(currentUser.connection.connection_id, user.email_address, user.email_address_confirmation, user.username, user.data, extra);
        }

        return {
            get: get,
            logout: logout,
            refresh: refresh,
            update: update
        };
    }
]);

angular.module('appServices').factory('manageUserActionService', [
    '$http',
    'sessionService',
    'cbtWorkflows',
    function ($http, sessionService, cbtWorkflows) {

        function deleteUser(userId) {
            return sessionService.getCurrentLoginSession().then(function (connectionId) {
                return $http.delete(
                    cbtWorkflows.url + '/da/users/' + userId,
                    {
                        data: { connection_id: connectionId, user_id: userId  },
                        headers: { 'Content-Type': 'application/json' }
                    }
                );
            });
        }

        return {
            deleteUser: deleteUser
        };
    }
]);
var manageUserResolve = function ($route, manageUserService) {
    const userId = $route.current.params.id;
    return manageUserService.getManageUser(userId);
}

manageUserResolve.$inject = ['$route', 'manageUserService'];

function permissionGuard(resource, action) {
    return function ($q, $location, configService) {
        return configService.get().then(function (config) {

            if (config.permissions?.[resource]?.[action]) {
                return true;
            }

            $location.path('/profile');
            return $q.reject('not_authorized');
        });
    };
}

manageUsersCustomPortalRoutes = [
    {
        path: '/users/new',
        templateUrl: 'new_manage_user.html',
        controller: 'ManageNewUserController',
        resolve: {
            user: 'loggedInUser',
            permission: permissionGuard('manage_users', 'create')
        }
    },
    {
        path: '/users/:id/edit',
        templateUrl: 'manage_user_edit.html',
        controller: 'ManageEditUserController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'update')
        }
    },
    {
        path: '/users/:id/password',
        templateUrl: 'manage_user_password.html',
        controller: 'ManageUserPasswordController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'update')
        }
    },
    {
        path: '/users',
        templateUrl: 'manage_users.html',
        controller: 'ManageUsersController',
        resolve: {
            user: 'loggedInUser',
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id',
        templateUrl: 'manage_user.html',
        controller: 'ManageUserController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id/status',
        templateUrl: 'manage_user_status.html',
        controller: 'ManageUserStatusController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'update')
        }
    },
    {
        path: '/users/:id/data',
        templateUrl: 'manage_user_data.html',
        controller: 'ManageUserDataController',
        resolve: {
            user: 'loggedInUser',
            permission: permissionGuard('manage_users', 'update')
        }
    },
    {
        path: '/users/:id/groups',
        templateUrl: 'manage_user_groups.html',
        controller: 'ManageUserGroupsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id/groups/new',
        templateUrl: 'new_manage_user_group.html',
        controller: 'ManageNewUserGroupsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            groups: function (manageUserService) {
                return manageUserService.getGroups();
            },
            userGroups: function ($route, manageUserService) {
                const userId = $route.current.params.id;
                return manageUserService.getUserGroups(userId);
            },
            permission: permissionGuard('manage_users', 'update')
        }
    },
    {
        path: '/users/:id/roles',
        templateUrl: 'manage_user_roles.html',
        controller: 'ManageUserRolesController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id/roles/new',
        templateUrl: 'new_manage_user_role.html',
        controller: 'ManageNewUserRolesController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            userRoles: function ($route, manageUserService) {
                const userId = $route.current.params.id;
                return manageUserService.getUserRoles(userId);
            },
            permission: permissionGuard('manage_users', 'create')
        }
    },
    {
        path: '/users/:id/credentials',
        templateUrl: 'manage_user_credentials.html',
        controller: 'ManageUserCredentialsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id/credentials/:name/new',
        templateUrl: 'manage_user_new_credentials.html',
        controller: 'ManageUserNewCredentialsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'create')
        }
    },
    {
        path: '/users/:id/credentials/:name/:objectId',
        templateUrl: 'manage_user_edit_credentials.html',
        controller: 'ManageUserEditCredentialsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            permission: permissionGuard('manage_users', 'update')
        }
    }
];

customPortalRoutes.push(...manageUsersCustomPortalRoutes)

angular.module("appDirectives").directive("manageUsersResultTable",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_users_result_table.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUsersPath = attrs.manageUsersPath;
                scope.includeTarget = attrs.includeTarget == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageUsersSearchFilters", ['$location',
    function ($location) {
        return {
            restrict: "E",
            templateUrl: "templates/manage_users_search_filters.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.searchField = 'user.username';

                scope.updateParams = function () {
                    $location.search({
                        searchBy: scope.searchField,
                        searchValue: scope.searchQuery,
                        page: null
                    });

                    scope.searchManageUsers();
                };
            }
        }
    }
]);

angular.module("appDirectives").directive("manageUsersSearch",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_users_search.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.includeFilters = attrs.includeFilters == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageUserGroupsResultTable",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_user_groups_result_table.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserGroupsPath = attrs.manageUserGroupsPath;
                scope.includeTarget = attrs.includeTarget == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageUserGroupsSearchFilters", ['$location',
    function ($location) {
        return {
            restrict: "E",
            templateUrl: "templates/manage_user_groups_search_filters.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.searchField = 'name';

                scope.updateParams = function () {
                    $location.search({
                        searchBy: scope.searchField,
                        value: scope.searchQuery,
                        page: null
                    });
                };
            }
        }
    }
]);

angular.module("appDirectives").directive("manageUserGroupsSearch",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_user_groups_search.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserGroupsPath = attrs.manageUserGroupsPath;
                scope.resultsMode = attrs.resultsMode || "list";
                scope.includeTarget = attrs.includeTarget == "true";
                scope.includeFilters = attrs.includeFilters == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageUserRolesResultTable",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_user_roles_result_table.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserRolesPath = attrs.manageUserRolesPath;
                scope.includeTarget = attrs.includeTarget == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageUserRolesSearchFilters", ['$location',
    function ($location) {
        return {
            restrict: "E",
            templateUrl: "templates/manage_user_roles_search_filters.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.searchField = 'name';

                scope.updateParams = function () {
                    $location.search({
                        searchBy: scope.searchField,
                        value: scope.searchQuery,
                        page: null
                    });
                };
            }
        }
    }
]);

angular.module("appDirectives").directive("manageUserRolesSearch",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_user_roles_search.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserRolesPath = attrs.manageUserRolesPath;
                scope.resultsMode = attrs.resultsMode || "list";
                scope.includeTarget = attrs.includeTarget == "true";
                scope.includeFilters = attrs.includeFilters == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageAvailableUserGroupsResultTable",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_available_user_groups_result_table.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserGroupsPath = attrs.manageUserGroupsPath;
                scope.includeTarget = attrs.includeTarget == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageAvailableUserGroupsSearchFilters", ['$location',
    function ($location) {
        return {
            restrict: "E",
            templateUrl: "templates/manage_available_user_groups_search_filters.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.searchField = 'name';

                scope.updateParams = function () {
                    $location.search({
                        searchBy: scope.searchField,
                        value: scope.searchQuery,
                        page: null
                    });
                };
            }
        }
    }
]);

angular.module("appDirectives").directive("manageAvailableUserGroupsSearch",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_available_user_groups_search.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserGroupsPath = attrs.manageUserGroupsPath;
                scope.resultsMode = attrs.resultsMode || "list";
                scope.includeTarget = attrs.includeTarget == "true";
                scope.includeFilters = attrs.includeFilters == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageAvailableUserRolesResultTable",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_available_user_roles_result_table.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserRolesPath = attrs.manageUserRolesPath;
                scope.includeTarget = attrs.includeTarget == "true";
            }
        }
    }
);

angular.module("appDirectives").directive("manageAvailableUserRolesSearchFilters", ['$location',
    function ($location) {
        return {
            restrict: "E",
            templateUrl: "templates/manage_available_user_roles_search_filters.html",
            scope: true,
            link: function (scope) {
                scope.searchField = 'name';

                scope.updateParams = function () {
                    $location.search({
                        searchBy: scope.searchField,
                        value: scope.searchQuery,
                        page: null
                    });
                };
            }
        }
    }
]);

angular.module("appDirectives").directive("manageAvailableUserRolesSearch",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_available_user_roles_search.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUserRolesPath = attrs.manageUserRolesPath;
                scope.resultsMode = attrs.resultsMode || "list";
                scope.includeTarget = attrs.includeTarget == "true";
                scope.includeFilters = attrs.includeFilters == "true";
            }
        }
    }
);

angular.module('appDirectives').directive('manageUserCredentialsTable', function () {
    return {
        restrict: 'E',
        templateUrl: "templates/manage_user_credentials_table.html",
    };
});

angular.module('appDirectives').directive('manageUserAdForm', function () {
    return {
        restrict: 'E',
        templateUrl: 'templates/manage_user_ad_form.html'
    };
});

angular.module('appDirectives').directive('cbtTooltip', function () {
    return {
        restrict: 'A',
        link: function (scope, element, attrs) {
            $(element).tooltip({
                title: attrs.cbtTooltip,
                placement: attrs.placement || 'top'
            });

            scope.$on('$destroy', function () {
                $(element).tooltip('destroy');
            });
        }
    };
});

function isBlank(value) {
    return value === null || value === undefined || String(value).trim() === '';
}

function hasError(errors, field) {
    return errors.some(function (error) {
        return error.attribute === field;
    });
}

function userFieldRequiredValidation(field, code) {
    return function (user, errors) {
        if (hasError(errors, field)) { return; }

        if (!isBlank(user[field])) { return; }

        errors.push({
            attribute: field,
            code: code || 'blank'
        });
    };
}

function userFieldFormatValidation(field, format, code) {
    return function (user, errors) {
        if (hasError(errors, field)) { return; }

        var value = user[field];

        // ignora campo vazio (required cuida disso)
        if (isBlank(value)) { return; }

        if (format.test(String(value).trim())) { return; }

        errors.push({
            attribute: field,
            code: code || 'invalid_format'
        });
    };
}

function userFieldMinLengthValidation(field, min, code) {
    return function (user, errors) {
        if (hasError(errors, field)) { return; }

        var value = user[field];

        if (isBlank(value)) { return; }

        if (String(value).trim().length >= min) { return; }

        errors.push({
            attribute: field,
            code: code || 'min_length'
        });
    };
}

function userFieldMaxLengthValidation(field, max, code) {
    return function (user, errors) {
        if (hasError(errors, field)) { return; }

        var value = user[field];

        if (isBlank(value)) { return; }

        if (String(value).trim().length <= max) { return; }

        errors.push({
            attribute: field,
            code: code || 'max_length'
        });
    };
}

function userFieldExactLengthValidation(field, length, code) {
    return function (form, errors) {
        if (hasError(errors, field)) { return; }

        var value = form[field];

        if (isBlank(value)) { return; }
        if (String(value).trim().length === length) { return; }

        errors.push({
            attribute: field,
            code: code || 'invalid_length'
        });
    };
}

function userFieldDateAfterValidation(field, referenceField, code) {
    return function (user, errors) {

        if (hasError(errors, field)) { return; }

        var value = user[field];
        var reference = user[referenceField];

        if (isBlank(value) || isBlank(reference)) { return; }

        var dateValue = new Date(value);
        var dateReference = new Date(reference);

        if (dateValue > dateReference) { return; }

        errors.push({
            attribute: field,
            code: code || 'date_after'
        });
    };
}

angular.module('appServices').factory('customUserDataFormValidationService', ['$q', 'validationService',
    function ($q, validationService) {
        var validations = [];

        validations.push(userFieldRequiredValidation('primeiro_nome', 'blank'));
        validations.push(userFieldRequiredValidation('ultimo_nome', 'blank'));
        validations.push(userFieldRequiredValidation('cpf', 'blank'));
        validations.push(userFieldRequiredValidation('data_contratacao', 'blank'));
        validations.push(userFieldRequiredValidation('email_pessoal', 'blank'));

        validations.push(userFieldMinLengthValidation('primeiro_nome', 3, 'min_value'));
        validations.push(userFieldMinLengthValidation('ultimo_nome', 3, 'min_value'));

        validations.push(userFieldFormatValidation('email_pessoal', /^([a-z\d_\-.+]+)@(([a-z\d-]+\.)+[a-z]{2,})$/i, 'email_format'));

        validations.push(userFieldDateAfterValidation('data_desligamento', 'data_contratacao', 'after_contratacao'));

        return {
            validations: validations
        };
    }
]);

angular.module('appServices').factory('customUserFormValidationService', ['$q', 'validationService',
    function ($q, validationService) {
        var validations = [];

        validations.push(userFieldMinLengthValidation('username', 3, 'min_value'));
        validations.push(userFieldMinLengthValidation('password', 3, 'min_value'));
        validations.push(userFieldFormatValidation('email_address', /^([a-z\d_\-.+]+)@(([a-z\d-]+\.)+[a-z]{2,})$/i, 'email_format'));

        return {
            validations: validations
        };
    }
]);

angular.module('appServices').factory('customAppFormValidationService', ['$q', 'validationService',
    function ($q, validationService) {
        var validations = [];

        validations.push(validationService.userFieldPresenceValidation('name'));

        return {
            validations: validations
        };
    }
]);

angular.module('appServices').factory('customGroupFormValidationService', ['$q', 'validationService',
    function ($q, validationService) {
        var validations = [];

        validations.push(validationService.userFieldPresenceValidation('group_id'));

        return {
            validations: validations
        };
    }
]);

angular.module('appServices').factory('customRoleFormValidationService', ['$q', 'validationService',
    function ($q, validationService) {
        var validations = [];

        validations.push(validationService.userFieldPresenceValidation('role_id'));

        return {
            validations: validations
        };
    }
]);

angular.module('appServices').factory('manageUserService', ['$http', 'sessionService', '$route', 'errorService', 'cbtWorkflows',
    function ($http, sessionService, $route, errorService, cbtWorkflows) {
        function getManageUser(userId) {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.get(cbtWorkflows.url + '/da/users/' + userId, { params: { connection_id: connectionId } }
                    );
                })
                .then(function (response) {
                    return response.data;
                });
        }

        function getGroups() {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.get(cbtWorkflows.url + '/da/groups', { params: { connection_id: connectionId } })
                        .then((response) => {
                            return response.data;
                        });
                });
        }

        function getUserGroups(userId) {
            return sessionService.getCurrentLoginSession().then(function (connectionId) {
                function fetchPage(page, allResults) {
                    allResults = allResults || [];

                    return $http.get(
                        cbtWorkflows.url + '/da/users/' + userId + '/groups',
                        {
                            params: {
                                connection_id: connectionId,
                                page: page,
                                page_size: 100
                            }
                        }
                    ).then(function (response) {
                        var data = response.data;

                        var results = data && data.results ? data.results : [];
                        var mergedResults = allResults.concat(results);

                        var total = data && data.total ? data.total : mergedResults.length;
                        var pageSize = 100;

                        if (mergedResults.length >= total || results.length < pageSize) {
                            return {
                                results: mergedResults,
                                total: mergedResults.length
                            };
                        }

                        return fetchPage(page + 1, mergedResults);
                    });
                }

                return fetchPage(1, []);
            });
        }

        function getApps() {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.get(cbtWorkflows.url + '/da/apps/', { params: { connection_id: connectionId } })
                        .then((response) => {
                            return response.data;
                        });
                });
        }

        function getUserRoles(userId) {
            return sessionService.getCurrentLoginSession().then(function (connectionId) {
                function fetchPage(page, allResults) {
                    allResults = allResults || [];

                    return $http.get(
                        cbtWorkflows.url + '/da/users/' + userId + '/roles',
                        {
                            params: {
                                connection_id: connectionId,
                                page: page,
                                page_size: 100
                            }
                        }
                    ).then(function (response) {
                        var data = response.data;
                        var results = data && data.results ? data.results : [];

                        if (results.length > 0 && Array.isArray(results[0])) {
                            results = [].concat.apply([], results);
                        }

                        var mergedResults = allResults.concat(results);
                        var total = data && data.total ? data.total : mergedResults.length;
                        var pageSize = 100;

                        if (mergedResults.length >= total || results.length < pageSize) {
                            return {
                                results: mergedResults,
                                total: mergedResults.length
                            };
                        }

                        return fetchPage(page + 1, mergedResults);
                    });
                }

                return fetchPage(1, []);
            });
        }

        return {
            getManageUser: getManageUser,
            getGroups: getGroups,
            getApps: getApps,
            getUserGroups: getUserGroups,
            getUserRoles: getUserRoles
        };
    }
]);

angular.module('appServices').factory('adCredentialConfigService', [
    'cbtWorkflows',
    function (cbtWorkflows) {
        var emailDomains = [
            '3coracoes.com.br',
            'santaclara.com.br',
            'positiveco.com.br',
            '3caffi.com.br',
            'zaya.positiveco.com.br',
            'zayaflour.com'
        ];

        var groups = [
            'GSUITE-COLABORADORES',
            'GSUITE-LIDERES',
            'GSUITE-VENDEDORES',
            'INTERNET-B',
            'INTERNET-C',
            'INTERNET-F',
            'ZTNA_MOBILE_GESTAO',
            'ZTNA_PADRAO'
        ];

        var defaultObjectClass = [
            'top',
            'person',
            'organizationalPerson',
            'user'
        ];

        var adConfig = (((cbtWorkflows || {}).apps || {}).ad || {});
        var hiddenRoles = angular.copy(adConfig.hiddenRoles || []);

        var groupSearchConfig = {
            loginAppId: adConfig.loginAppId || null,
            searchBy: 'name',
            minLength: 3,
            initialPage: 1,
            initialPageSize: 30
        };

        function filterVisibleGroups(groupList) {
            return (groupList || []).filter(function (group) {
                return hiddenRoles.indexOf(group) === -1;
            });
        }

        function buildInitialForm() {
            return {
                wwwhomepage: 'www.3coracoes.com.br',
                mail_local_part: '',
                mail_domain: emailDomains[0],
                mail_domain_mode: 'select',
                mail: '',
                objectclass: angular.copy(defaultObjectClass),
                memberof: [],
                useraccountcontrol_accountdisable: false,
                account_type: 'SERVICE'
            };
        }

        return {
            emailDomains: emailDomains,
            groups: filterVisibleGroups(groups),
            hiddenRoles: hiddenRoles,
            defaultObjectClass: defaultObjectClass,
            buildInitialForm: buildInitialForm,
            groupSearchConfig: groupSearchConfig,
            filterVisibleGroups: filterVisibleGroups
        };
    }
]);

angular.module('appServices').factory('adCredentialFormService', [
    function () {

        function sanitizeSamAccountName(value) {
            return (value || '')
                .toLowerCase()
                .replace(/\s+/g, '')
                .replace(/[^a-z0-9._-]/g, '')
                .substring(0, 20);
        }

        function updateNameDerivedFields(form, samaccountnameManuallyEdited) {
            var firstName = (form.givenname || '').trim();
            var lastName = (form.sn || '').trim();
            var fullName = (firstName + ' ' + lastName).trim();
            var splitedFullName = fullName ? fullName.split(/\s+/) : [];
            var samAccountName = '';

            form.displayname = fullName;
            form.title = form.description;

            if (!samaccountnameManuallyEdited && splitedFullName.length > 1) {
                samAccountName = splitedFullName[0] + splitedFullName[splitedFullName.length - 1];
                form.samaccountname = sanitizeSamAccountName(samAccountName);
            }

            return form;
        }

        function updateAccountDerivedFields(form) {
            var samAccountName = sanitizeSamAccountName(form.samaccountname);
            var domain = (form.mail_domain || '').trim();

            form.samaccountname = samAccountName;
            form.mail_local_part = samAccountName;

            if (!samAccountName || !domain) {
                form.mail = '';
                form.userprincipalname = '';
                return form;
            }

            form.mail = samAccountName + '@' + domain;
            form.userprincipalname = form.mail;

            return form;
        }

        function buildDnSuggestion(form) {
            var fullName = form.displayname || '';
            var city = (form.l || '').trim();

            if (!fullName || !city) {
                return '';
            }

            return 'CN=' + fullName +
                ',OU=Softwares Restritos,OU=Users,OU=' + city +
                ',OU=Unidades,DC=santaclara,DC=com,DC=br';
        }

        function fillDn(form) {
            form.dn = buildDnSuggestion(form);
            return form;
        }

        function fillCn(form) {
            form.cn = form.displayname || '';
            return form;
        }

        function updateLocationDerivedFields(form) {
            fillCn(form);
            return form;
        }

        function toggleGroup(form, group) {
            var index = form.memberof.indexOf(group);

            if (index === -1) {
                form.memberof.push(group);
            } else {
                form.memberof.splice(index, 1);
            }

            return form;
        }

        function isGroupSelected(form, group) {
            return form.memberof.indexOf(group) !== -1;
        }

        function initializeFormState(scope, configService) {
            scope.samaccountname_manually_edited = false;
            scope.emailDomains = configService.emailDomains;
            scope.groups = angular.copy(configService.groups || []);
            scope.credential_form = configService.buildInitialForm();
            scope.dnSuggestion = buildDnSuggestion(scope.credential_form);

            normalizeMailDomainState(scope.credential_form, configService);
        }

        function registerWatchers(scope, deps) {
            var $timeout = deps.$timeout;
            var loadGroups = deps.loadGroups;

            var groupSearchPromise = null;

            scope.$watchGroup([
                'credential_form.givenname',
                'credential_form.sn',
                'credential_form.description'
            ], function () {
                updateNameDerivedFields(
                    scope.credential_form,
                    scope.samaccountname_manually_edited
                );
                updateAccountDerivedFields(scope.credential_form);
            });

            scope.$watchGroup([
                'credential_form.samaccountname',
                'credential_form.mail_domain'
            ], function () {
                updateAccountDerivedFields(scope.credential_form);
            });

            scope.$watchGroup([
                'credential_form.displayname',
                'credential_form.l'
            ], function () {
                updateLocationDerivedFields(scope.credential_form);
                scope.dnSuggestion = buildDnSuggestion(scope.credential_form);
            });

            scope.$watch('groupFilters.search', function (newValue, oldValue) {
                var normalizedValue = (newValue || '').trim();

                if (newValue === oldValue) {
                    return;
                }

                if (groupSearchPromise) {
                    $timeout.cancel(groupSearchPromise);
                }

                if (!normalizedValue) {
                    groupSearchPromise = $timeout(function () {
                        loadGroups('');
                    }, 300);
                    return;
                }

                if (normalizedValue.length < scope.groupSearchConfig.minLength) {
                    return;
                }

                groupSearchPromise = $timeout(function () {
                    loadGroups(normalizedValue);
                }, 300);
            });
        }

        function markSamAccountNameAsManual(scope) {
            scope.samaccountname_manually_edited = true;
        }

        function resetSamAccountNameManualControl(scope) {
            var currentValue = (scope.credential_form.samaccountname || '').trim();

            if (!currentValue) {
                scope.samaccountname_manually_edited = false;
            }
        }

        function sanitizeSamAccountNameFromScope(scope) {
            scope.credential_form.samaccountname = sanitizeSamAccountName(
                scope.credential_form.samaccountname
            );

            updateAccountDerivedFields(scope.credential_form);
            resetSamAccountNameManualControl(scope);
        }

        function buildAccountExpiresValue(value) {
            if (!value) {
                return '0';
            }

            return dateToAdFileTime(value);
        }

        function dateToAdFileTime(value) {
            if (!value) {
                return '0';
            }

            var date = value instanceof Date ? value : new Date(value);

            if (isNaN(date.getTime())) {
                return '0';
            }

            const FILETIME_EPOCH_OFFSET = 11644473600000;

            return String((date.getTime() + FILETIME_EPOCH_OFFSET) * 10000);
        }

        function adFileTimeToDate(value) {
            const FILETIME_NEVER_EXPIRES = '9223372036854775807';
            const FILETIME_EPOCH_OFFSET = 11644473600000;

            if (!value || value === '0' || value === 0 || value === FILETIME_NEVER_EXPIRES) {
                return null;
            }

            var fileTime = Number(value);

            if (isNaN(fileTime)) {
                return null;
            }

            
            var msSinceUnixEpoch = (fileTime / 10000) - FILETIME_EPOCH_OFFSET;
            var date = new Date(msSinceUnixEpoch);

            if (isNaN(date.getTime())) {
                return null;
            }

            return new Date(
                date.getUTCFullYear(),
                date.getUTCMonth(),
                date.getUTCDate()
            );
        }

        function buildCreatePayload(form) {
            return {
                givenname: form.givenname || null,
                sn: form.sn || null,
                displayname: form.displayname || null,
                description: form.description || null,
                physicaldeliveryofficename: form.physicaldeliveryofficename || null,
                telephonenumber: form.telephonenumber || null,
                mail: form.mail || null,
                wwwhomepage: form.wwwhomepage || null,
                samaccountname: form.samaccountname || null,
                userprincipalname: form.userprincipalname || null,
                useraccountcontrol_accountdisable: !!form.useraccountcontrol_accountdisable,
                accountexpires: buildAccountExpiresValue(form.accountexpires),
                info: form.info || null,
                title: form.title || null,
                department: form.department || null,
                company: form.company || null,
                manager: form.manager || null,
                streetaddress: form.streetaddress || null,
                l: form.l || null,
                st: form.st || null,
                postalcode: form.postalcode || null,
                c: form.c || null,
                dn: form.dn || null,
                objectclass: angular.copy(form.objectclass || []),
                employeeid: form.employeeid || null,
                cn: form.cn || null,
                memberof: angular.copy(form.memberof || []),
                account_type: form.account_type || 'SERVICE'
            };
        }

        function extractMailLocalPart(mail) {
            if (!mail || mail.indexOf('@') === -1) {
                return '';
            }

            return mail.split('@')[0];
        }

        function extractMailDomain(mail) {
            if (!mail || mail.indexOf('@') === -1) {
                return '';
            }

            return mail.split('@')[1];
        }

        function normalizeMailDomainState(form, configService) {
            var knownDomains = configService.emailDomains || [];
            var currentDomain = (form.mail_domain || '').trim();

            if (!currentDomain) {
                form.mail_domain = knownDomains[0] || '';
                form.mail_domain_mode = 'select';
                return form;
            }

            form.mail_domain_mode = knownDomains.indexOf(currentDomain) >= 0
                ? 'select'
                : 'manual';

            return form;
        }

        function buildEditForm(data, configService) {
            var form = angular.extend(
                {},
                configService.buildInitialForm(),
                angular.copy(data || {})
            );

            form.mail_local_part = extractMailLocalPart(form.mail);
            form.mail_domain = extractMailDomain(form.mail) || configService.emailDomains[0];
            form.memberof = angular.copy(form.memberof || []);
            form.objectclass = angular.copy(form.objectclass || configService.defaultObjectClass);
            form.original_samaccountname = form.samaccountname;
            form.accountexpires = adFileTimeToDate(form.accountexpires);
            form.account_type = form.account_type || 'SERVICE';

            normalizeMailDomainState(form, configService);

            return form;
        }

        function buildUpdatePayload(form) {
            return {
                givenname: form.givenname || null,
                sn: form.sn || null,
                displayname: form.displayname || null,
                description: form.description || null,
                physicaldeliveryofficename: form.physicaldeliveryofficename || null,
                telephonenumber: form.telephonenumber || null,
                mail: form.mail || null,
                wwwhomepage: form.wwwhomepage || null,
                samaccountname: form.original_samaccountname || form.samaccountname || null,
                userprincipalname: form.userprincipalname || null,
                useraccountcontrol_accountdisable: !!form.useraccountcontrol_accountdisable,
                accountexpires: buildAccountExpiresValue(form.accountexpires),
                info: form.info || null,
                title: form.title || null,
                department: form.department || null,
                company: form.company || null,
                manager: form.manager || null,
                streetaddress: form.streetaddress || null,
                l: form.l || null,
                st: form.st || null,
                postalcode: form.postalcode || null,
                c: form.c || null,
                dn: form.dn || null,
                objectclass: angular.copy(form.objectclass || []),
                employeeid: form.employeeid || null,
                cn: form.cn || null,
                memberof: angular.copy(form.memberof || [])
            };
        }

        function buildVisibleGroups(selectedGroups, availableGroups) {
            var selected = angular.copy(selectedGroups || []);
            var available = angular.copy(availableGroups || []);

            return selected.concat(available).filter(function (group, index, list) {
                return !!group && list.indexOf(group) === index;
            });
        }

        return {
            sanitizeSamAccountName: sanitizeSamAccountName,
            updateNameDerivedFields: updateNameDerivedFields,
            updateAccountDerivedFields: updateAccountDerivedFields,
            updateLocationDerivedFields: updateLocationDerivedFields,
            fillDn: fillDn,
            fillCn: fillCn,
            toggleGroup: toggleGroup,
            isGroupSelected: isGroupSelected,
            initializeFormState: initializeFormState,
            registerWatchers: registerWatchers,
            markSamAccountNameAsManual: markSamAccountNameAsManual,
            resetSamAccountNameManualControl: resetSamAccountNameManualControl,
            sanitizeSamAccountNameFromScope: sanitizeSamAccountNameFromScope,
            buildCreatePayload: buildCreatePayload,
            buildUpdatePayload: buildUpdatePayload,
            buildEditForm: buildEditForm,
            buildVisibleGroups: buildVisibleGroups
        };
    }
]);

angular.module('appServices').factory('credentialPayloadService', [
    'adCredentialFormService',
    function (adCredentialFormService) {

        var payloadBuilders = {
            create: {
                ad_data: function (form) {
                    return adCredentialFormService.buildCreatePayload(form);
                }
            },
            update: {
                ad_data: function (form) {
                    return adCredentialFormService.buildUpdatePayload(form);
                }
            }
        };

        function build(operation, credentialName, form) {
            var builderGroup = payloadBuilders[operation] || {};
            var builder = builderGroup[credentialName] || function (currentForm) {
                return angular.copy(currentForm);
            };

            return builder(form);
        }

        return {
            build: build
        };
    }
]);

angular.module('appServices').factory('manageUserCredentialService', [
    '$http',
    'sessionService',
    'cbtWorkflows',
    function ($http, sessionService, cbtWorkflows) {

        function createCredential(userId, credentialName, credentialForm) {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.post(
                        cbtWorkflows.url + '/uc/users/' + userId + '/credentials/' + credentialName,
                        credentialForm,
                        {
                            params: {
                                connection_id: connectionId
                            }
                        }
                    );
                })
                .then(function (response) {
                    return response.data;
                })
        }

        function getCredential(userId, credentialName, objectId) {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.get(
                        cbtWorkflows.url + '/uc/users/' + userId + '/credentials/' + credentialName + '/' + objectId,
                        {
                            params: {
                                connection_id: connectionId
                            }
                        }
                    );
                })
                .then(function (response) {
                    return response.data;
                });
        }

        function updateCredential(userId, credentialName, objectId, credentialForm) {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.put(
                        cbtWorkflows.url + '/uc/users/' + userId + '/credentials/' + credentialName + '/' + objectId,
                        credentialForm,
                        {
                            params: {
                                connection_id: connectionId
                            }
                        }
                    );
                })
                .then(function (response) {
                    return response.data;
                });
        }

        function fetchRoles(params) {
            return sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    return $http.get(cbtWorkflows.url + '/uc/users/roles', {
                        params: {
                            connection_id: connectionId,
                            search_by: params.search_by || null,
                            value: params.value || null,
                            login_app_id: params.login_app_id,
                            page: params.page || 1,
                            page_size: params.page_size || 20
                        }
                    });
                })
                .then(function (response) {
                    return response.data;
                });
        }

        return {
            createCredential: createCredential,
            getCredential: getCredential,
            updateCredential: updateCredential,
            fetchRoles: fetchRoles
        };
    }
]);

angular.module('appServices').factory('customAdCredentialFormValidationService', [
    function () {
        var validations = [];

        validations.push(userFieldRequiredValidation('givenname', 'blank'));
        validations.push(userFieldRequiredValidation('sn', 'blank'));
        validations.push(userFieldRequiredValidation('description', 'blank'));
        validations.push(userFieldRequiredValidation('employeeid', 'blank'));
        validations.push(userFieldRequiredValidation('samaccountname', 'blank'));
        validations.push(userFieldRequiredValidation('l', 'blank'));

        validations.push(userFieldMinLengthValidation('givenname', 3, 'min_length'));
        validations.push(userFieldMinLengthValidation('sn', 3, 'min_length'));
        validations.push(userFieldMaxLengthValidation('samaccountname', 20, 'max_length'));
        validations.push(userFieldMaxLengthValidation('employeeid', 11, 'max_length'));
        validations.push(userFieldExactLengthValidation('employeeid', 11, 'cpf_length'));

        validations.push(
            userFieldFormatValidation(
                'mail',
                /^([a-z\d_\-.+]+)@(([a-z\d-]+\.)+[a-z]{2,})$/i,
                'email_format'
            )
        );

        validations.push(
            userFieldFormatValidation(
                'userprincipalname',
                /^([a-z\d_\-.+]+)@(([a-z\d-]+\.)+[a-z]{2,})$/i,
                'email_format'
            )
        );

        function validate(form) {
            var errors = [];

            validations.forEach(function (validation) {
                validation(form, errors);
            });

            return errors;
        }

        return {
            validations: validations,
            validate: validate
        };
    }
]);

angular.module('appServices').factory('credentialValidationService', [
    'customAdCredentialFormValidationService',
    function (customAdCredentialFormValidationService) {

        var validators = {
            ad_data: function (form) {
                return customAdCredentialFormValidationService.validate(form);
            }
        };

        function validate(credentialName, form) {
            var validator = validators[credentialName] || function () {
                return [];
            };

            return validator(form);
        }

        return {
            validate: validate
        };
    }
]);

angular.module('appServices').factory('manageUserCredentialPresenterService', [
    function () {

        function formatAccountType(result) {
            return result.account_type || '-';
        }

        function formatLogin(schemaName, result) {
            var loginMap = {
                ad_data: result.samaccountname,
                sgu_data: result.login,
                sap_data: result.bname
            };

            return loginMap[schemaName] || result.samaccountname || result.login || '-';
        }

        function formatActive(schemaName, result) {
            var activeMap = {
                ad_data: result.useraccountcontrol_accountdisable === false
            };

            if (Object.prototype.hasOwnProperty.call(activeMap, schemaName)) {
                return activeMap[schemaName];
            }

            return null;
        }

        function buildRow(schemaName, result) {
            return {
                schema_name: schemaName,
                object_id: result.object_id,
                login: formatLogin(schemaName, result),
                created_at: result.created_at,
                account_type: formatAccountType(result),
                active: formatActive(schemaName, result),
                raw: result
            };
        }

        function present(payload, allowedCredentials) {
            return (payload || [])
                .filter(function (schema) {
                    return allowedCredentials.indexOf(schema.name) !== -1;
                })
                .reduce(function (rows, schema) {
                    var schemaRows = (schema.results || []).map(function (result) {
                        return buildRow(schema.name, result);
                    });

                    return rows.concat(schemaRows);
                }, []);
        }

        return {
            present: present
        };
    }
]);

angular.module('appControllers').controller('ManageNewUserController', ['$scope', '$location', '$q', 'user', 'alertService', 'i18nService', 'errorService', '$http', 'sessionService', 'customUserFormValidationService', 'cbtWorkflows', '$route',
    function ($scope, $location, $q, user, alertService, i18n, errorService, $http, sessionService, customUserFormValidationService, cbtWorkflows, $route) {
        function onInit() {
            $scope.form = {};
            $scope.user = user;
            $scope.alerts = alertService.get();
            $scope.showPassword = false;
        };

        $scope.createUserAction = function () {
            alertService.clear();
            if (!$scope.user.permissions.manage_users.create) {
                return;
            }
            validateForm().then(function () {
                sessionService.getCurrentLoginSession().
                    then(function (connectionId) {
                        $http.post(cbtWorkflows.url + "/da/users", { connection_id: connectionId, data: $scope.form }).
                            then((response) => {
                                alertService.add(i18n.t('manage_user.user_page.created_successfully'));
                                $location.path('/users');
                            }).catch(function (errors) {

                                if (errors.data == "Create User error: email_address has already been taken") {
                                    const error = { "attribute": "email_address", "code": "has_already_been_taken" };
                                    errorService.handle(error, 'errors.manage_user');
                                } else {
                                    errorService.handle(i18n.t(errors.data), '');
                                }
                                $location.path('/users/new');
                            });
                    });
            }).catch(function (errors) {
                if (errors.length > 0) {
                    errors.forEach(function (error) {
                        errorService.handle(error, 'errors.manage_user');
                    });
                }
                $location.path('/users/new');
            });
        };

        function validateForm() {
            var deferred = $q.defer();
            var errors = [];

            angular.forEach(customUserFormValidationService.validations, function (validation) {
                validation($scope.form, errors);
            });

            (errors.length > 0) ? deferred.reject(errors) : deferred.resolve();

            return deferred.promise;
        }

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUsersController', ['$scope', '$location', '$http', 'paginationService', 'user', 'sessionService', 'cbtWorkflows', 'manageUserActionService', 'alertService', 'errorService', '$route',
    function ($scope, $location, $http, paginationService, user, sessionService, cbtWorkflows, manageUserActionService, alertService, errorService, $route) {
        function onInit() {
            $scope.user = user;
            $scope.searchManageUsers();
            $scope.alerts = alertService.get();
        }

        $scope.$on('$locationChangeSuccess', function () {
            var currentParams = $location.search();
            if (!currentParams || Object.keys(currentParams).length === 0) {
                return;
            }
            $scope.searchManageUsers();
        });

        $scope.searchManageUsers = function () {
            $scope.manage_users_search = null;
            var params = $location.search();
            var page = parseInt(params.page, 10) || 1;
            var pageSize = parseInt(params.pageSize, 10) || 10;
            var searchBy = params.searchBy || null;
            var searchValue = params.searchValue || null;
            alertService.clear();

            sessionService.getCurrentLoginSession().
                then(function (connectionId) {
                    $scope.manage_users_search_params = { connection_id: connectionId, page: page, page_size: pageSize, search_by: searchBy, search_value: searchValue };
                    $http.get(cbtWorkflows.url + "/da/users", { params: $scope.manage_users_search_params }).
                        then((response) => {
                            $scope.manage_users_search = response.data;
                            //TODO: This needs to be fixed on the backend.
                            $scope.pagination = paginationService.build(response.data, $scope.manage_users_search_params);
                        });
                });
        };

        $scope.deleteUser = function (userId) {
            if (!$scope.user.permissions.manage_users.delete) {
                return;
            }
            if (!window.confirm('Tem certeza que deseja remover este usuário?')) {
                return;
            }

            manageUserActionService.deleteUser(userId)
                .then(function () {
                    alertService.add('Usuário removido com sucesso.');
                    $route.reload();
                })
                .catch(function (error) {
                    errorService.handle(error, 'manage_user.delete');
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserController', ['$scope', 'user', '$routeParams', 'manageUser', 'alertService',
    function ($scope, user, $routeParams, manageUser, alertService) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.alerts = alertService.get();
        }

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserStatusController', ['$scope', '$location', '$http', 'user', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', '$route', 'manageUser', 'cbtWorkflows',
    function ($scope, $location, $http, user, sessionService, $routeParams, alertService, errorService, i18n, $route, manageUser, cbtWorkflows) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.form = {
                status: manageUser.active
            };
            $scope.alerts = alertService.get();
        }

        $scope.updateUserStatusAction = function () {
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }

            alertService.clear();

            sessionService.getCurrentLoginSession().
                then(function (connectionId) {
                    $http.put(cbtWorkflows.url + "/da/users/" + $scope.manage_user.id + "/status", { connection_id: connectionId, data: $scope.form }).
                        then((response) => {
                            alertService.add(i18n.t('manage_user.status_updated_successfully'));
                            $location.path('/users/' + $scope.manage_user.id);
                            $route.reload();
                        });
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserDataController', ['$scope', '$location', '$http', '$q', 'user', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', '$route', 'customUserDataFormValidationService', 'cbtWorkflows',
    function ($scope, $location, $http, $q, user, sessionService, $routeParams, alertService, errorService, i18n, $route, customUserDataFormValidationService, cbtWorkflows) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.form = {};
            $scope.searchManageUser();
            $scope.alerts = alertService.get();
            $scope.situacoes = {
                "A": "Ativo",
                "F": "Férias",
                "D": "Demitido",
                "C": "Contrato de Trabalho Suspenso",
                "E": "Licença Mater.",
                "L": "Licença s/venc",
                "M": "Serv.Militar",
                "O": "Doença Ocupacional",
                "P": "Af.Previdencia",
                "T": "Af.Ac.Trabalho",
                "W": "Licença Mater. Compl. 180 dias",
                "Y": "Licença Paternidade"
            };
            $scope.tiposFuncionario = {
                "N": "Normal",
                "T": "Terceiro"
            };
            $scope.$watch('form.id_situacao', function (newVal) {
                $scope.form.nome_situacao = newVal ? $scope.situacoes[newVal] : null;
            });

            $scope.$watch('form.id_tipo_funcionario', function (newVal) {
                $scope.form.nome_tipo_funcionario = newVal ? $scope.tiposFuncionario[newVal] : null;
            });
        }

        $scope.searchManageUser = function () {
            sessionService.getCurrentLoginSession().
                then(function (connectionId) {
                    $http.get(cbtWorkflows.url + "/da/users/" + $scope.userId + "/data", { params: { connection_id: connectionId } }).
                        then((response) => {
                            response.data.data_nascimento = parseDate(response.data.data_nascimento);
                            response.data.data_contratacao = parseDate(response.data.data_contratacao);
                            response.data.data_desligamento = parseDate(response.data.data_desligamento);

                            $scope.manage_user = response.data;
                            $scope.form = $scope.manage_user;
                        });
                });
        };

        $scope.updateUserDataAction = function () {
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }

            document.querySelectorAll('.form-group.has-error').forEach(function (el) {
                el.classList.remove('has-error');
            });

            alertService.clear();
            validateForm().then(function () {
                sessionService.getCurrentLoginSession().
                    then(function (connectionId) {
                        $http.put(cbtWorkflows.url + "/da/users/" + $scope.manage_user.user_id + "/data", { connection_id: connectionId, data: $scope.form }).
                            then((response) => {
                                alertService.add(i18n.t('manage_user.updated_successfully'));
                                $location.path('/users/' + $scope.manage_user.user_id);
                                $route.reload();
                            });
                    });
            }).catch(function (errors) {
                if (errors.length > 0) {
                    errors.forEach(function (error) {
                        errorService.handle(error, 'errors.manage_user');
                    });
                }

                $location.path('/users/' + $scope.manage_user.user_id + '/data');
            });
        };

        function parseDate(value) {
            return value ? new Date(value) : null;
        }

        function validateForm() {
            var deferred = $q.defer();
            var errors = [];

            angular.forEach(customUserDataFormValidationService.validations, function (validation) {
                validation($scope.form, errors);
            });

            if (errors.length > 0) {
                deferred.reject(errors);
            } else {
                deferred.resolve();
            }

            return deferred.promise;
        }

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserGroupsController', ['$scope', '$location', '$http', 'user', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', '$route', 'paginationService', 'manageUser', 'cbtWorkflows', 'permission',
    function ($scope, $location, $http, user, sessionService, $routeParams, alertService, errorService, i18n, $route, paginationService, manageUser, cbtWorkflows, permission) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.searchManageUserGroups();
            $scope.manage_user = manageUser;
            $scope.alerts = alertService.get();
            $scope.permission = permission;
        }

        $scope.$on('$locationChangeSuccess', function () {
            var currentParams = $location.search();
            if (!currentParams || Object.keys(currentParams).length === 0) {
                return;
            }
            $scope.searchManageUserGroups();
        });

        $scope.searchManageUserGroups = function () {
            var params = $location.search();
            var page = parseInt(params.page, 10) || 1;
            var pageSize = parseInt(params.pageSize, 10) || 10;
            var searchBy = params.searchBy || null;
            var value = params.value || null;

            sessionService.getCurrentLoginSession().
                then(function (connectionId) {
                    $scope.manage_user_groups_search_params = { connection_id: connectionId, page: page, page_size: pageSize, search_by: searchBy, value: value };
                    $http.get(cbtWorkflows.url + "/da/users/" + $scope.userId + "/groups", { params: $scope.manage_user_groups_search_params }).
                        then((response) => {
                            $scope.manage_user_groups_search = response.data.results;
                            $scope.pagination = paginationService.build(response.data, $scope.manage_user_groups_search_params);
                        }).catch((error) => {
                            console.error("Error fetching data:", error);
                        });
                }).catch(function (error) {
                    console.error("Error:", error);
                });
        };

        $scope.removeGroup = function (group_id) {
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }
            alertService.clear();
            sessionService.getCurrentLoginSession().
                then(function (connectionId) {
                    $http.delete(cbtWorkflows.url + "/da/users/" + $scope.manage_user.id + "/groups/" + group_id, { data: { connection_id: connectionId }, headers: { 'Content-Type': 'application/json' } }).
                        then((response) => {
                            alertService.add(i18n.t('manage_user.remove_group_successfully'));
                            $location.path('/users/' + $scope.manage_user.id + '/groups');
                            $route.reload();
                        }).catch((errors) => {
                            errorService.handle(i18n.t(errors.data), 'manage_user');
                            $location.path('/users/' + $scope.manage_user.id + '/groups');
                            $route.reload();
                        });
                }).catch(function (errors) {
                    errorService.handle(errors[0], 'errors.manage_user');
                    $location.path('/users/' + $scope.manage_user.id + '/groups');
                    $route.reload();
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserRolesController', ['$scope', '$location', '$http', 'user', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', '$route', 'paginationService', 'manageUser', 'cbtWorkflows',
    function ($scope, $location, $http, user, sessionService, $routeParams, alertService, errorService, i18n, $route, paginationService, manageUser, cbtWorkflows) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.alerts = alertService.get();
            $scope.searchManageUserRoles();
        }

        $scope.$on('$locationChangeSuccess', function () {
            var currentParams = $location.search();
            if (!currentParams || Object.keys(currentParams).length === 0) {
                return;
            }
            $scope.searchManageUserRoles();
        });

        $scope.searchManageUserRoles = function () {
            var params = $location.search();
            var page = parseInt(params.page, 10) || 1;
            var pageSize = parseInt(params.pageSize, 10) || 10;
            var searchBy = params.searchBy || null;
            var value = params.value || null;

            sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    $scope.manage_user_roles_search_params = {
                        connection_id: connectionId,
                        page: page,
                        page_size: pageSize,
                        search_by: searchBy,
                        value: value
                    };

                    $http.get(
                        cbtWorkflows.url + "/da/users/" + $scope.userId + "/roles",
                        { params: $scope.manage_user_roles_search_params }
                    ).then(function (response) {
                        $scope.manage_user_roles_search = response.data && response.data.results
                            ? response.data.results
                            : [];

                        $scope.pagination = paginationService.build(
                            response.data,
                            $scope.manage_user_roles_search_params
                        );
                    }).catch(function (error) {
                        console.error("Error fetching data:", error);
                    });
                }).catch(function (error) {
                    console.error("Error:", error);
                });
        };

        $scope.removeRole = function (role_id) {
            alertService.clear();
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }
            sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    $http.delete(
                        cbtWorkflows.url + "/da/users/" + $scope.manage_user.id + "/roles/" + role_id,
                        {
                            data: { connection_id: connectionId },
                            headers: { 'Content-Type': 'application/json' }
                        }
                    ).then(function () {
                        alertService.add(i18n.t('manage_user.remove_role_successfully'));
                        $location.path('/users/' + $scope.manage_user.id + '/roles');
                        $route.reload();
                    }).catch(function (errors) {
                        errorService.handle(i18n.t(errors.data), 'manage_user');
                        $location.path('/users/' + $scope.manage_user.id + '/roles');
                        $route.reload();
                    });
                }).catch(function (errors) {
                    errorService.handle(errors[0], 'manage_user');
                    $location.path('/users/' + $scope.manage_user.id + '/roles');
                    $route.reload();
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageNewUserGroupsController', ['$scope', '$location', '$http', 'user', 'sessionService', 'alertService', 'errorService', 'i18nService', '$routeParams', 'paginationService', 'manageUser', 'cbtWorkflows',
    function ($scope, $location, $http, user, sessionService, alertService, errorService, i18n, $routeParams, paginationService, manageUser, cbtWorkflows) {
        function onInit() {
            $scope.user = user;
            $scope.userId = $routeParams.id;
            $scope.alerts = alertService.get();
            $scope.manage_user = manageUser;

            $scope.searchAvailableGroups();
        }

        $scope.$on('$locationChangeSuccess', function () {
            var currentParams = $location.search();
            if (!currentParams || Object.keys(currentParams).length === 0) {
                return;
            }

            $scope.searchAvailableGroups();
        });

        $scope.searchAvailableGroups = function () {
            var params = $location.search();
            var page = parseInt(params.page, 10) || 1;
            var pageSize = parseInt(params.pageSize, 10) || 10;
            var searchBy = params.searchBy || null;
            var value = params.value || null;

            sessionService.getCurrentLoginSession().then(function (connectionId) {
                $scope.available_user_groups_search_params = {
                    connection_id: connectionId,
                    page: page,
                    page_size: pageSize,
                    search_by: searchBy,
                    value: value
                };

                $http.get(
                    cbtWorkflows.url + "/da/groups",
                    { params: $scope.available_user_groups_search_params }
                ).then(function (response) {
                    var groups = response.data && response.data.results
                        ? response.data.results
                        : [];

                    $scope.available_user_groups_search = groups;

                    $scope.pagination = paginationService.build(
                        response.data,
                        $scope.available_user_groups_search_params
                    );
                }).catch(function (error) {
                    console.error("Error fetching available groups:", error);
                });
            }).catch(function (error) {
                console.error("Error:", error);
            });
        };

        $scope.addGroupAction = function (groupId) {
            alertService.clear();
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }
            sessionService.getCurrentLoginSession().then(function (connectionId) {
                $http.post(
                    cbtWorkflows.url + "/da/users/" + $scope.manage_user.id + "/groups",
                    {
                        connection_id: connectionId,
                        data: { group_id: groupId }
                    }
                ).then(function () {
                    alertService.add(i18n.t('manage_user.add_group_successfully'));
                    $location.url('/users/' + $scope.manage_user.id + "/groups");
                }).catch(function (errors) {
                    errorService.handle(i18n.t(errors.data), 'manage_user');
                });
            }).catch(function (errors) {
                errorService.handle(errors[0], 'errors.manage_user');
            });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageNewUserRolesController', ['$scope', '$location', '$http', 'user', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', 'manageUser', 'cbtWorkflows', 'paginationService',
    function ($scope, $location, $http, user, sessionService, $routeParams, alertService, errorService, i18n, manageUser, cbtWorkflows, paginationService) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.alerts = alertService.get();
            $scope.manage_user = manageUser;

            $scope.searchAvailableRoles();
        }

        $scope.$on('$locationChangeSuccess', function () {
            var currentParams = $location.search();
            if (!currentParams || Object.keys(currentParams).length === 0) {
                return;
            }

            $scope.searchAvailableRoles();
        });

        $scope.searchAvailableRoles = function () {
            var params = $location.search();
            var page = parseInt(params.page, 10) || 1;
            var pageSize = parseInt(params.pageSize, 10) || 10;
            var searchBy = params.searchBy || null;
            var value = params.value || null;

            sessionService.getCurrentLoginSession().then(function (connectionId) {
                $http.get(cbtWorkflows.url + "/da/roles", {
                    params: {
                        connection_id: connectionId,
                        page: page,
                        page_size: pageSize,
                        search_by: searchBy,
                        value: value
                    }
                }).then(function (response) {
                    $scope.available_user_roles_search = response.data && response.data.results
                        ? response.data.results
                        : (response.data || []);

                    $scope.pagination = paginationService.build(
                        response.data,
                        {
                            connection_id: connectionId,
                            page: page,
                            page_size: pageSize,
                            search_by: searchBy,
                            value: value
                        }
                    );
                }).catch(function (error) {
                    console.error("Error fetching roles:", error);
                });
            }).catch(function (error) {
                console.error("Error:", error);
            });
        };

        $scope.addRoleAction = function (roleId) {
            alertService.clear();
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }
            sessionService.getCurrentLoginSession().then(function (connectionId) {
                $http.post(
                    cbtWorkflows.url + "/da/users/" + $scope.manage_user.id + "/roles",
                    {
                        connection_id: connectionId,
                        data: { role_id: roleId }
                    }
                ).then(function () {
                    alertService.add(i18n.t('manage_user.add_role_successfully'));
                    $location.url('/users/' + $scope.manage_user.id + "/roles");
                }).catch(function (errors) {
                    errorService.handle(i18n.t(errors.data), 'manage_user');
                });
            }).catch(function (errors) {
                errorService.handle(errors[0], 'manage_user');
            });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageEditUserController', ['$scope', '$location', '$http', '$q', 'user', 'manageUser', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', '$route', 'customUserFormValidationService', 'cbtWorkflows',
    function ($scope, $location, $http, $q, user, manageUser, sessionService, $routeParams, alertService, errorService, i18n, $route, customUserFormValidationService, cbtWorkflows) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.manageUser = manageUser;
            $scope.form = $scope.form = {
                username: manageUser?.username ? manageUser.username : '',
                email_address: manageUser?.email_address ? manageUser.email_address : ''
            };
            $scope.alerts = alertService.get();
        }

        $scope.updateUserAction = function () {
            alertService.clear();
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }
            validateForm().then(function () {
                sessionService.getCurrentLoginSession().then(function (connectionId) {
                    $http.put(
                        cbtWorkflows.url + '/da/users/' + $scope.userId,
                        {
                            connection_id: connectionId,
                            data: $scope.form
                        }
                    ).then(function () {
                        alertService.add(i18n.t('manage_user.updated_successfully'));
                        $location.path('/users/' + $scope.userId);
                    }).catch(function (errors) {
                        errorService.handle(i18n.t(errors.data), '');
                        $location.path('/users/' + $scope.userId + '/edit');
                    })
                });
            }).catch(function (errors) {
                errors.forEach(function (error) {
                    errorService.handle(error, 'errors.manage_user');
                });
            });
        };

        function validateForm() {
            var deferred = $q.defer();
            var errors = [];

            angular.forEach(customUserFormValidationService.validations, function (validation) {
                validation($scope.form, errors);
            });

            if (errors.length > 0) {
                deferred.reject(errors);
            } else {
                deferred.resolve();
            }

            return deferred.promise;
        }

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserPasswordController', ['$scope', '$location', '$http', '$q', 'user', 'manageUser', 'sessionService', '$routeParams', 'alertService', 'errorService', 'i18nService', '$route', 'customUserFormValidationService', 'cbtWorkflows',
    function ($scope, $location, $http, $q, user, manageUser, sessionService, $routeParams, alertService, errorService, i18n, $route, customUserFormValidationService, cbtWorkflows) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.manageUser = manageUser;
            $scope.showPassword = false;
            $scope.form = {
                password: ''
            };
            $scope.alerts = alertService.get();
        }

        $scope.updateUserPasswordAction = function () {
            alertService.clear();
            if (!$scope.user.permissions.manage_users.update) {
                return;
            }
            validateForm().then(function () {
                sessionService.getCurrentLoginSession().then(function (connectionId) {
                    $http.put(
                        cbtWorkflows.url + '/da/users/' + $scope.userId + '/password',
                        {
                            connection_id: connectionId,
                            data: $scope.form
                        }
                    ).then(function () {
                        alertService.add(i18n.t('manage_user.password_updated_successfully'));
                        $location.path('/users/' + $scope.userId);
                        $route.reload();
                    }).catch(function (errors) {
                        errorService.handle(i18n.t(errors.data), '');
                        $location.path('/users/' + $scope.userId + '/password');
                    });
                });
            }).catch(function (errors) {
                errors.forEach(function (error) {
                    errorService.handle(error, 'errors.manage_user');
                });
            });
        };

        function validateForm() {
            var deferred = $q.defer();
            var errors = [];

            angular.forEach(customUserFormValidationService.validations, function (validation) {
                validation($scope.form, errors);
            });

            if (errors.length > 0) {
                deferred.reject(errors);
            } else {
                deferred.resolve();
            }

            return deferred.promise;
        }

        onInit();
    }
]);
angular.module('appControllers').controller('ManageUserCredentialsController', [ '$scope', '$http', 'user', 'manageUser', 'sessionService', 'cbtWorkflows', 'alertService', 'errorService', '$route', 'manageUserCredentialPresenterService',
    function ($scope, $http, user, manageUser, sessionService, cbtWorkflows, alertService, errorService, $route, manageUserCredentialPresenterService
    ) {

        function onInit() {
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.credentials = [];
            $scope.alerts = alertService.get();

            $scope.allowed_credentials = [
                'ad_data'
            ];

            $scope.fetchCredentials();
        }

        $scope.fetchCredentials = function () {

            sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    $scope.manage_search_params = {
                        connection_id: connectionId,
                        credentials: $scope.allowed_credentials
                    };

                    return $http.get(
                        cbtWorkflows.url + '/uc/users/' + $scope.manage_user.id + '/credentials',
                        {
                            params: $scope.manage_search_params
                        }
                    );
                })
                .then(function (response) {
                    $scope.credentials = manageUserCredentialPresenterService.present(
                        response.data,
                        $scope.allowed_credentials
                    );
                })
                .catch(function (response) {
                    errorService.handle(response);
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserNewCredentialsController', ['$scope', 'user', 'manageUser', 'alertService', 'errorService', '$routeParams', '$location', '$timeout', 'adCredentialConfigService', 'adCredentialFormService', 'manageUserCredentialService', 'credentialPayloadService', 'credentialValidationService',
    function ($scope, user, manageUser, alertService, errorService, $routeParams, $location, $timeout, adCredentialConfigService, adCredentialFormService, manageUserCredentialService, credentialPayloadService, credentialValidationService
    ) {
        var groupSearchPromise = null;

        function onInit() {
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.alerts = alertService.get();
            $scope.userId = $routeParams.id;
            $scope.credential_name = $routeParams.name;
            $scope.isEditMode = false;

            adCredentialFormService.initializeFormState($scope, adCredentialConfigService);
            adCredentialFormService.registerWatchers($scope, {
                $timeout: $timeout,
                loadGroups: loadGroups
            });

            $scope.groups = angular.copy(adCredentialConfigService.groups || []);
            $scope.groupFilters = {
                search: ''
            };
            $scope.groupsLoading = false;
            $scope.groupSearchConfig = angular.copy(adCredentialConfigService.groupSearchConfig);

            loadGroups('');
        }

        function loadGroups(searchValue) {
            var normalizedValue = (searchValue || '').trim();

            $scope.groupsLoading = true;

            manageUserCredentialService.fetchRoles({
                login_app_id: $scope.groupSearchConfig.loginAppId,
                search_by: normalizedValue ? $scope.groupSearchConfig.searchBy : null,
                value: normalizedValue || null,
                page: $scope.groupSearchConfig.initialPage,
                page_size: $scope.groupSearchConfig.initialPageSize
            })
                .then(function (response) {
                    var results = response && response.results ? response.results : [];
                    var searchedGroups = results.map(function (role) {
                        return role.name;
                    });

                    searchedGroups = adCredentialConfigService.filterVisibleGroups(searchedGroups);

                    $scope.groups = adCredentialFormService.buildVisibleGroups(
                        $scope.credential_form.memberof,
                        searchedGroups
                    );
                })
                .catch(function () {
                    $scope.groups = adCredentialFormService.buildVisibleGroups(
                        $scope.credential_form.memberof,
                        adCredentialConfigService.groups || []
                    );
                })
                .finally(function () {
                    $scope.groupsLoading = false;
                });
        }

        $scope.onGroupSearchChange = function () {
            var normalizedValue = ($scope.groupSearch || '').trim();

            // 1 ou 2 caracteres: não chama backend
            if (normalizedValue.length < $scope.groupSearchConfig.minLength) {
                return;
            }

            if (groupSearchPromise) {
                $timeout.cancel(groupSearchPromise);
            }

            // sem texto: volta para carga inicial
            if (!normalizedValue) {
                groupSearchPromise = $timeout(function () {
                    loadGroups('');
                }, 300);
                return;
            }

            // 3+ caracteres: chama backend
            groupSearchPromise = $timeout(function () {
                loadGroups(normalizedValue);
            }, 300);
        };

        $scope.markSamAccountNameAsManual = function () {
            adCredentialFormService.markSamAccountNameAsManual($scope);
        };

        $scope.sanitizeSamAccountName = function () {
            adCredentialFormService.sanitizeSamAccountNameFromScope($scope);
        };

        $scope.toggleGroup = function (group) {
            adCredentialFormService.toggleGroup($scope.credential_form, group);

            $scope.groups = adCredentialFormService.buildVisibleGroups(
                $scope.credential_form.memberof,
                $scope.groups
            );
        };

        $scope.isGroupSelected = function (group) {
            return adCredentialFormService.isGroupSelected($scope.credential_form, group);
        };

        $scope.createCredentialAction = function () {
            var errors;
            var payload;

            alertService.clear();

            errors = credentialValidationService.validate(
                $scope.credential_name,
                $scope.credential_form
            );

            if (errors.length > 0) {
                errors.forEach(function (error) {
                    errorService.handle(error, 'errors.manage_user');
                });
                return;
            }

            payload = credentialPayloadService.build(
                'create',
                $scope.credential_name,
                $scope.credential_form
            );

            manageUserCredentialService.createCredential(
                $scope.userId,
                $scope.credential_name,
                payload
            )
                .then(function () {
                    alertService.add('success', 'Credential created successfully.');
                    $location.path('/users/' + $scope.userId + '/credentials');
                })
                .catch(function (response) {
                    errorService.handle(response.data, '');
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserEditCredentialsController', ['$scope', 'user', 'manageUser', 'alertService', 'errorService', '$routeParams', '$timeout', 'adCredentialConfigService', 'adCredentialFormService', 'manageUserCredentialService', 'credentialValidationService', 'credentialPayloadService', '$location', 'i18nService',
    function ($scope, user, manageUser, alertService, errorService, $routeParams, $timeout, adCredentialConfigService, adCredentialFormService, manageUserCredentialService, credentialValidationService, credentialPayloadService, $location, i18n) {

        function onInit() {
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.alerts = alertService.get();
            $scope.userId = $routeParams.id;
            $scope.credential_name = $routeParams.name;
            $scope.object_id = $routeParams.objectId;
            $scope.loading = true;
            $scope.isEditMode = true;

            $scope.emailDomains = adCredentialConfigService.emailDomains;
            $scope.groups = angular.copy(adCredentialConfigService.groups || []);
            $scope.groupFilters = {
                search: ''
            };
            $scope.groupsLoading = false;
            $scope.groupSearchConfig = angular.copy(adCredentialConfigService.groupSearchConfig);
            $scope.samaccountname_manually_edited = false;
            $scope.credential_form = adCredentialConfigService.buildInitialForm();

            fetchCredential();
        }

        function loadGroups(searchValue) {
            var normalizedValue = (searchValue || '').trim();

            $scope.groupsLoading = true;

            manageUserCredentialService.fetchRoles({
                login_app_id: $scope.groupSearchConfig.loginAppId,
                search_by: normalizedValue ? $scope.groupSearchConfig.searchBy : null,
                value: normalizedValue || null,
                page: $scope.groupSearchConfig.initialPage,
                page_size: $scope.groupSearchConfig.initialPageSize
            })
                .then(function (response) {
                    var results = response && response.results ? response.results : [];
                    var searchedGroups = results.map(function (role) {
                        return role.name;
                    });

                    searchedGroups = adCredentialConfigService.filterVisibleGroups(searchedGroups);

                    $scope.groups = adCredentialFormService.buildVisibleGroups(
                        $scope.credential_form.memberof,
                        searchedGroups
                    );
                })
                .catch(function () {
                    $scope.groups = adCredentialFormService.buildVisibleGroups(
                        $scope.credential_form.memberof,
                        adCredentialConfigService.groups || []
                    );
                })
                .finally(function () {
                    $scope.groupsLoading = false;
                });
        }

        function fetchCredential() {
            alertService.clear();

            manageUserCredentialService.getCredential(
                $scope.userId,
                $scope.credential_name,
                $scope.object_id
            )
                .then(function (credential) {
                    $scope.credential_form = adCredentialFormService.buildEditForm(
                        credential,
                        adCredentialConfigService
                    );

                    $scope.samaccountname_manually_edited = true;

                    adCredentialFormService.registerWatchers($scope, {
                        $timeout: $timeout,
                        loadGroups: loadGroups
                    });

                    loadGroups('');
                })
                .catch(function (response) {
                    errorService.handle(response);
                })
                .finally(function () {
                    $scope.loading = false;
                });
        }

        $scope.markSamAccountNameAsManual = function () {
            adCredentialFormService.markSamAccountNameAsManual($scope);
        };

        $scope.sanitizeSamAccountName = function () {
            adCredentialFormService.sanitizeSamAccountNameFromScope($scope);
        };

        $scope.toggleGroup = function (group) {
            adCredentialFormService.toggleGroup($scope.credential_form, group);

            $scope.groups = adCredentialFormService.buildVisibleGroups(
                $scope.credential_form.memberof,
                $scope.groups
            );
        };

        $scope.isGroupSelected = function (group) {
            return adCredentialFormService.isGroupSelected($scope.credential_form, group);
        };

        $scope.updateCredentialAction = function () {
            var errors;
            var payload;

            alertService.clear();

            errors = credentialValidationService.validate(
                $scope.credential_name,
                $scope.credential_form
            );

            if (errors.length > 0) {
                errors.forEach(function (error) {
                    errorService.handle(error, 'errors.manage_user');
                });
                return;
            }

            payload = credentialPayloadService.build(
                'update',
                $scope.credential_name,
                $scope.credential_form
            );

            manageUserCredentialService.updateCredential(
                $scope.userId,
                $scope.credential_name,
                $scope.object_id,
                payload
            )
                .then(function () {
                    alertService.add(
                        i18n.t('manage_user.credential.' + $scope.credential_name + '.updated_successfully')
                    );
                    $location.path('/users/' + $scope.userId + '/credentials');
                })
                .catch(function (response) {
                    errorService.handle(response.data, '');
                });
        };

        onInit();
    }
]);

angular.module('appConstants').constant('cbtWorkflows', {
    url: "https://3coracoes-iga-staging.workflows.coffeebeantech.com",
    apps: {
        ad: {
            loginAppId: 2857, // local (substituído por env em runtime)
            hiddenRoles: [
                'Acesso - Active Directory',
            ]
        }
    }
});