@cause-911/management/fesm2015/cause-911-management.js

Run `npm install @cause-911/management --save` to add this library to your project

import { Injectable, ɵɵdefineInjectable, ɵɵinject, Component, Input, NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { CoreService, CauseCoreModule } from '@cause-911/core';
import { BreakpointObserver } from '@angular/cdk/layout';
import { map } from 'rxjs/operators';
import { BrowserModule } from '@angular/platform-browser';
import { DxListModule, DxTagBoxModule, DxCheckBoxModule } from 'devextreme-angular';
import { CauseDxModule } from '@cause-911/devextreme';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ManagementUserService {
    /**
     * @param {?} coreService
     * @param {?} http
     */
    constructor(coreService, http) {
        this.http = http;
        this.config = coreService.getConfig();
    }
    /**
     * @template TUser
     * @return {?}
     */
    getAll() {
        return this.http.get(`${this.config.apiUrl}UserManagement`);
    }
    /**
     * @template TUser
     * @param {?} idUser
     * @return {?}
     */
    get(idUser) {
        return this.http.get(`${this.config.apiUrl}UserManagement/${idUser}`);
    }
    /**
     * @param {?} idUser
     * @return {?}
     */
    getGroup(idUser) {
        return this.http.get(`${this.config.apiUrl}UserManagement/${idUser}/groups`);
    }
    /**
     * @param {?} userGroup
     * @return {?}
     */
    addGroup(userGroup) {
        return this.http.post(`${this.config.apiUrl}UserManagement/group`, userGroup);
    }
    /**
     * @param {?} idUserGroup
     * @return {?}
     */
    deleteGroup(idUserGroup) {
        return this.http.delete(`${this.config.apiUrl}UserManagement/groups/${idUserGroup}`);
    }
    /**
     * @param {?} userPermission
     * @return {?}
     */
    addPermission(userPermission) {
        return this.http.post(`${this.config.apiUrl}UserManagement/permission`, userPermission);
    }
    /**
     * @param {?} idUserPermission
     * @return {?}
     */
    deletePermission(idUserPermission) {
        return this.http.delete(`${this.config.apiUrl}UserManagement/groups/${idUserPermission}`);
    }
    /**
     * @template TUser
     * @param {?} user
     * @return {?}
     */
    save(user) {
        return this.http.post(`${this.config.apiUrl}UserManagement`, user);
    }
    /**
     * @param {?} idUser
     * @return {?}
     */
    delete(idUser) {
        return this.http.delete(`${this.config.apiUrl}UserManagement/${idUser}`);
    }
    /**
     * @template TUser
     * @param {?} user
     * @return {?}
     */
    hasExistingUserName(user) {
        return this.http.post(`${this.config.apiUrl}UserManagement/UserNameAlreadyExist`, user);
    }
}
ManagementUserService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
ManagementUserService.ctorParameters = () => [
    { type: CoreService },
    { type: HttpClient }
];
/** @nocollapse */ ManagementUserService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ManagementUserService_Factory() { return new ManagementUserService(ɵɵinject(CoreService), ɵɵinject(HttpClient)); }, token: ManagementUserService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ManagementGroupService {
    /**
     * @param {?} coreService
     * @param {?} http
     */
    constructor(coreService, http) {
        this.http = http;
        this.config = coreService.getConfig();
    }
    /**
     * @return {?}
     */
    getAll() {
        return this.http.get(`${this.config.apiUrl}GroupManagement`);
    }
    /**
     * @param {?} idGroup
     * @return {?}
     */
    get(idGroup) {
        return this.http.get(`${this.config.apiUrl}GroupManagement/${idGroup}`);
    }
    /**
     * @param {?} group
     * @return {?}
     */
    save(group) {
        return this.http.post(`${this.config.apiUrl}GroupManagement`, group);
    }
    /**
     * @param {?} idGroup
     * @return {?}
     */
    delete(idGroup) {
        return this.http.delete(`${this.config.apiUrl}GroupManagement/${idGroup}`);
    }
    /**
     * @param {?} group
     * @return {?}
     */
    hasExistingGroupName(group) {
        return this.http.post(`${this.config.apiUrl}GroupManagement/GroupNameAlreadyExist`, group);
    }
}
ManagementGroupService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
ManagementGroupService.ctorParameters = () => [
    { type: CoreService },
    { type: HttpClient }
];
/** @nocollapse */ ManagementGroupService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ManagementGroupService_Factory() { return new ManagementGroupService(ɵɵinject(CoreService), ɵɵinject(HttpClient)); }, token: ManagementGroupService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class UserModel {
    constructor() {
        this.userName = '';
        this.firstName = '';
        this.lastName = '';
        this.password = '';
        this.email = '';
        this.isActive = true;
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class UserGroupModel {
    constructor() {
        this.idUserGroup = '';
        this.idGroup = '';
        this.idUser = '';
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class UserPermissionModel {
    constructor() {
        this.idUserPermission = '';
        this.isAllowed = false;
        this.idUser = '';
        this.idModulePermission = '';
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class GroupModel {
    constructor() {
        this.name = '';
        this.users = [];
        this.permissions = [];
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class GroupPermissionModel {
    constructor() {
        this.idGroupPermission = '';
        this.isAllowed = false;
        this.idGroup = '';
        this.idModulePermission = '';
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ManagementPermissionService {
    /**
     * @param {?} coreService
     * @param {?} http
     */
    constructor(coreService, http) {
        this.http = http;
        this.config = coreService.getConfig();
    }
    /**
     * @return {?}
     */
    getAll() {
        return this.http.get(`${this.config.apiUrl}PermissionManagement`);
    }
    /**
     * @param {?} idPermission
     * @return {?}
     */
    get(idPermission) {
        return this.http.get(`${this.config.apiUrl}PermissionManagement/${idPermission}`);
    }
    /**
     * @param {?} permission
     * @return {?}
     */
    save(permission) {
        return this.http.post(`${this.config.apiUrl}PermissionManagement`, permission);
    }
    /**
     * @param {?} idPermission
     * @return {?}
     */
    delete(idPermission) {
        return this.http.delete(`${this.config.apiUrl}PermissionManagement/${idPermission}`);
    }
}
ManagementPermissionService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
ManagementPermissionService.ctorParameters = () => [
    { type: CoreService },
    { type: HttpClient }
];
/** @nocollapse */ ManagementPermissionService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ManagementPermissionService_Factory() { return new ManagementPermissionService(ɵɵinject(CoreService), ɵɵinject(HttpClient)); }, token: ManagementPermissionService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CauseManagementGroupComponent {
    /**
     * @param {?} managementGroupService
     * @param {?} managementUserService
     * @param {?} managementPermissionService
     * @param {?} breakpointObserver
     */
    constructor(managementGroupService, managementUserService, managementPermissionService, breakpointObserver) {
        this.managementGroupService = managementGroupService;
        this.managementUserService = managementUserService;
        this.managementPermissionService = managementPermissionService;
        this.hoverStatePermission = true;
        this.groups = [];
        this.users = [];
        this.permissions = [];
        this.userFullName = {};
        this.showColumn = true;
        this.showColumnXS = true;
        this.translations = [];
        this.calculateUsersCellValue = (/**
         * @param {?} e
         * @return {?}
         */
        (e) => {
            /** @type {?} */
            const users = (e.users ? (/** @type {?} */ (e.users)) : []);
            /** @type {?} */
            let usersNames = [];
            users.forEach((/**
             * @param {?} user
             * @return {?}
             */
            user => {
                /** @type {?} */
                const userGroup = this.users.filter((/**
                 * @param {?} u
                 * @return {?}
                 */
                u => u.id === user.idUser));
                if (userGroup && userGroup[0]) {
                    usersNames.push(userGroup[0].firstName + ' ' + userGroup[0].lastName);
                }
            }));
            usersNames = usersNames.sort((/**
             * @param {?} one
             * @param {?} two
             * @return {?}
             */
            (one, two) => (one < two ? -1 : 1)));
            return usersNames.join(', ');
        });
        this.groupNameAlreadyUsedValidation = (/**
         * @param {?} e
         * @return {?}
         */
        (e) => {
            return this.managementGroupService.hasExistingGroupName(e.data).pipe(map((/**
             * @param {?} exist
             * @return {?}
             */
            (exist) => {
                return !exist;
            }))).toPromise();
        });
        breakpointObserver.observe(['(max-width: 1000px)']).subscribe((/**
         * @param {?} result
         * @return {?}
         */
        result => {
            this.showColumn = !result.matches;
        }));
        breakpointObserver.observe(['(max-width: 600px)']).subscribe((/**
         * @param {?} result
         * @return {?}
         */
        result => {
            this.showColumnXS = !result.matches;
        }));
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.managementUserService.getAll().subscribe((/**
         * @param {?} data
         * @return {?}
         */
        data => {
            this.users = data;
            this.users.forEach((/**
             * @param {?} user
             * @return {?}
             */
            user => {
                if (user.isActive) {
                    if (user.firstName !== '' && user.lastName !== '') {
                        this.userFullName[user.id] = `${user.firstName} ${user.lastName}`;
                    }
                }
            }));
        }));
        this.managementPermissionService.getAll().subscribe((/**
         * @param {?} permissions
         * @return {?}
         */
        permissions => {
            /** @type {?} */
            const permissionIndex = permissions.findIndex((/**
             * @param {?} c
             * @return {?}
             */
            c => {
                return c.tag === 'CanAccessPermissions';
            }));
            if (permissionIndex !== -1) {
                permissions.splice(permissionIndex, 1);
            }
            permissions.sort((/**
             * @param {?} a
             * @param {?} b
             * @return {?}
             */
            (a, b) => {
                if (a.name < b.name) {
                    return -1;
                }
                if (a.name > b.name) {
                    return 1;
                }
                return 0;
            }));
            this.permissions = permissions;
        }));
        this.getGroups();
    }
    /**
     * @param {?} data
     * @return {?}
     */
    fullName(data) {
        if (!data) {
            return '';
        }
        return `${data.firstName} ${data.lastName}`;
    }
    /**
     * @param {?} field
     * @param {?} e
     * @return {?}
     */
    getGroupUser(field, e) {
        /** @type {?} */
        const users = [];
        if (this.groupUsers) {
            this.groupUsers.forEach((/**
             * @param {?} user
             * @return {?}
             */
            user => {
                users.push(user.idUser);
            }));
        }
        e.component.option('value', users);
    }
    /**
     * @param {?} field
     * @param {?} e
     * @return {?}
     */
    setGroupUser(field, e) {
        /** @type {?} */
        const groupUser = [];
        e.value.forEach((/**
         * @param {?} idUser
         * @return {?}
         */
        idUser => {
            /** @type {?} */
            const groupIndex = (field.data.users || []).findIndex((/**
             * @param {?} g
             * @return {?}
             */
            g => g.idUser === idUser));
            if (groupIndex === -1) {
                groupUser.push((/** @type {?} */ ({ idUser, })));
            }
            else {
                groupUser.push(field.data.users[groupIndex]);
            }
        }));
        field.setValue(JSON.parse(JSON.stringify(groupUser)));
    }
    /**
     * @param {?} field
     * @param {?} e
     * @return {?}
     */
    setGroupPermission(field, e) {
        /** @type {?} */
        const groupUser = [];
        e.value.forEach((/**
         * @param {?} idUser
         * @return {?}
         */
        idUser => {
            groupUser.push((/** @type {?} */ ({
                idUser,
            })));
        }));
        field.setValue(JSON.parse(JSON.stringify(groupUser)));
    }
    /**
     * @param {?} field
     * @param {?} permission
     * @param {?} e
     * @return {?}
     */
    getPermissionStatus(field, permission, e) {
        /** @type {?} */
        const groupPermission = (field.value || []).find((/**
         * @param {?} p
         * @return {?}
         */
        p => p.idModulePermission === permission.id));
        if (groupPermission) {
            e.component.option('value', groupPermission.isAllowed);
        }
        else {
            e.component.option('value', undefined);
        }
    }
    /**
     * @param {?} field
     * @param {?} permission
     * @param {?} e
     * @return {?}
     */
    checkBoxToggled(field, permission, e) {
        if (e.component.skipOnValueChanged) {
            e.component.skipOnValueChanged = false;
            return;
        }
        if (e.component.setUndefinedNextTime) {
            e.component.setUndefinedNextTime = false;
            e.component.skipOnValueChanged = true;
            e.component.option('value', undefined);
            this.setPermissionStatus(field, permission, undefined);
            return;
        }
        if (e.value === false) {
            e.component.setUndefinedNextTime = true;
        }
        this.setPermissionStatus(field, permission, e.value);
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onRowInserted(e) {
        this.saveGroup((/** @type {?} */ (e.data)));
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onRowUpdated(e) {
        this.saveGroup((/** @type {?} */ (e.data)));
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onRowRemoved(e) {
        /** @type {?} */
        const group = ((/** @type {?} */ (e.data)));
        this.managementGroupService.delete(group.id).subscribe((/**
         * @param {?} data
         * @return {?}
         */
        data => {
            this.getGroups();
        }));
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onEditingStart(e) {
        this.groupUsers = e.data.users;
    }
    /**
     * @return {?}
     */
    onInitNewRow() {
        this.groupUsers = [];
    }
    /**
     * @private
     * @param {?} field
     * @param {?} permission
     * @param {?} value
     * @return {?}
     */
    setPermissionStatus(field, permission, value) {
        /** @type {?} */
        const groupPermissions = field.value || [];
        /** @type {?} */
        const groupIndex = groupPermissions.findIndex((/**
         * @param {?} p
         * @return {?}
         */
        p => p.idModulePermission === permission.id));
        if (groupIndex > -1) {
            groupPermissions[groupIndex].isAllowed = value;
        }
        else {
            groupPermissions.push((/** @type {?} */ ({
                idModulePermission: permission.id,
                isAllowed: value,
            })));
        }
        field.setValue(JSON.parse(JSON.stringify(groupPermissions)));
    }
    /**
     * @private
     * @param {?} group
     * @return {?}
     */
    saveGroup(group) {
        this.removePermissionUndefined(group);
        if (group.users) {
            group.users.forEach((/**
             * @param {?} userGroup
             * @return {?}
             */
            (userGroup) => {
                userGroup.idGroup = group.id;
            }));
        }
        if (group.permissions) {
            group.permissions.forEach((/**
             * @param {?} groupPermission
             * @return {?}
             */
            (groupPermission) => {
                groupPermission.idGroup = group.id;
            }));
        }
        this.managementGroupService.save(group).subscribe((/**
         * @return {?}
         */
        () => {
            this.getGroups();
        }));
        this.groupUsers = [];
    }
    /**
     * @private
     * @param {?} group
     * @return {?}
     */
    removePermissionUndefined(group) {
        group.permissions = group.permissions.filter((/**
         * @param {?} permission
         * @return {?}
         */
        (permission) => permission.isAllowed !== undefined));
    }
    /**
     * @private
     * @return {?}
     */
    getGroups() {
        this.managementGroupService.getAll().subscribe((/**
         * @param {?} data
         * @return {?}
         */
        data => this.groups = data));
    }
}
CauseManagementGroupComponent.decorators = [
    { type: Component, args: [{
                selector: 'cause-management-group',
                template: "<cause-dx-data-grid\n        keyExpr=\"id\"\n        [dataSource]=\"groups\"\n        (onRowInserted)=\"onRowInserted($event)\"\n        (onInitNewRow)=\"onInitNewRow()\"\n        (onRowUpdated)=\"onRowUpdated($event)\"\n        (onEditingStart)=\"onEditingStart($event)\"\n        (onRowRemoved)=\"onRowRemoved($event)\">\n\n    <dxi-column dataField=\"name\" [caption]=\"'management.name' | translate\">\n        <dxi-validation-rule type=\"async\" [message]=\"'management.groupNameAlreadyUsed' | translate\" [validationCallback]=\"groupNameAlreadyUsedValidation\"></dxi-validation-rule>\n    </dxi-column>\n    <dxi-column\n            dataField=\"users\"\n            [caption]=\"'management.users' | translate\"\n            editCellTemplate=\"usersEditTemplate\"\n            [calculateCellValue]=\"calculateUsersCellValue\">\n    </dxi-column>\n    <dxi-column\n            dataField=\"permissions\"\n            [caption]=\"'management.permissions' | translate\"\n            [visible]=\"false\"\n            editCellTemplate=\"permissionsEditTemplate\">\n    </dxi-column>\n    <dxo-export [enabled]=\"false\"></dxo-export>\n    <dxo-editing mode=\"popup\" [allowAdding]=\"true\" [allowUpdating]=\"true\" [allowDeleting]=\"true\" [useIcons]=\"true\">\n        <dxo-popup [showTitle]=\"true\" [title]=\"'management.group' | translate\" [fullScreen]=\"!showColumn\"></dxo-popup>\n        <dxo-form colCount=\"1\" [labelLocation]=\"showColumnXS ? 'left' : 'top'\">\n            <dxi-item dataField=\"name\" [isRequired]=\"true\"></dxi-item>\n            <dxi-item dataField=\"users\"></dxi-item>\n            <dxi-item dataField=\"permissions\"></dxi-item>\n        </dxo-form>\n    </dxo-editing>\n\n    <div *dxTemplate=\"let field of 'usersEditTemplate'\">\n        <dx-tag-box\n                valueExpr=\"id\"\n                [displayExpr]=\"fullName\"\n                [dataSource]=\"users\"\n                (onInitialized)=\"getGroupUser(field, $event)\"\n                (onValueChanged)=\"setGroupUser(field, $event)\">\n        </dx-tag-box>\n    </div>\n    <div *dxTemplate=\"let field of 'permissionsEditTemplate'\">\n        <dx-list\n                [dataSource]=\"permissions\"\n                itemTemplate=\"rowTemplate\"\n                [searchEnabled]=\"true\"\n                [searchExpr]=\"['name', 'tag']\"\n                [hoverStateEnabled]=\"hoverStatePermission\">\n            <div *dxTemplate=\"let permission of 'rowTemplate'\">\n                <dx-check-box\n                        [dataSource]=\"[true, false, undefined]\"\n                        [text]=\"permission.name\"\n                        (onInitialized)=\"getPermissionStatus(field, permission, $event)\"\n                        (onValueChanged)=\"checkBoxToggled(field, permission, $event)\">\n                </dx-check-box>\n            </div>\n        </dx-list>\n    </div>\n</cause-dx-data-grid>\n",
                styles: [""]
            }] }
];
/** @nocollapse */
CauseManagementGroupComponent.ctorParameters = () => [
    { type: ManagementGroupService },
    { type: ManagementUserService },
    { type: ManagementPermissionService },
    { type: BreakpointObserver }
];
CauseManagementGroupComponent.propDecorators = {
    hoverStatePermission: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ManagementService {
    constructor() { }
}
ManagementService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
ManagementService.ctorParameters = () => [];
/** @nocollapse */ ManagementService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ManagementService_Factory() { return new ManagementService(); }, token: ManagementService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CauseManagementComponent {
    constructor() { }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
}
CauseManagementComponent.decorators = [
    { type: Component, args: [{
                selector: 'cause-management',
                template: "<div>{{'core.noGenericComponentOnThisLibrary' | translate}}</div>"
            }] }
];
/** @nocollapse */
CauseManagementComponent.ctorParameters = () => [];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CauseManagementUserComponent {
    /**
     * @param {?} managementUserService
     * @param {?} breakpointObserver
     */
    constructor(managementUserService, breakpointObserver) {
        this.managementUserService = managementUserService;
        this.users = [
            new UserModel()
        ];
        this.showColumnXS = true;
        this.userNameAlreadyUsedValidation = (/**
         * @param {?} e
         * @return {?}
         */
        (e) => {
            return this.managementUserService.hasExistingUserName(e.data).pipe(map((/**
             * @param {?} exist
             * @return {?}
             */
            (exist) => {
                return !exist;
            }))).toPromise();
        });
        breakpointObserver.observe(['(max-width: 600px)']).subscribe((/**
         * @param {?} result
         * @return {?}
         */
        result => {
            this.showColumnXS = !result.matches;
        }));
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.getUsers();
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onRowInserted(e) {
        this.saveGroup((/** @type {?} */ (e.data)));
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onRowUpdated(e) {
        this.saveGroup((/** @type {?} */ (e.key)));
    }
    /**
     * @param {?} e
     * @return {?}
     */
    onRowRemoved(e) {
        /** @type {?} */
        const user = ((/** @type {?} */ (e.data)));
        this.managementUserService.delete(user.id).subscribe((/**
         * @param {?} data
         * @return {?}
         */
        data => {
            this.getUsers();
        }));
    }
    /**
     * @private
     * @param {?} user
     * @return {?}
     */
    saveGroup(user) {
        this.managementUserService.save(user).subscribe((/**
         * @return {?}
         */
        () => {
            this.getUsers();
        }));
    }
    /**
     * @private
     * @return {?}
     */
    getUsers() {
        this.managementUserService.getAll().subscribe((/**
         * @param {?} data
         * @return {?}
         */
        data => this.users = data));
    }
}
CauseManagementUserComponent.decorators = [
    { type: Component, args: [{
                selector: 'cause-management-user',
                template: "<cause-dx-data-grid\n        keyExpr=\"id\"\n        [dataSource]=\"users\"\n        (onRowInserted)=\"onRowInserted($event)\"\n        (onRowUpdated)=\"onRowUpdated($event)\"\n        (onRowRemoved)=\"onRowRemoved($event)\">\n\n    <dxi-column dataField=\"userName\" [caption]=\"'management.userName' | translate\">\n        <dxi-validation-rule type=\"async\" [message]=\"'management.userNameAlreadyUsed' | translate\" [validationCallback]=\"userNameAlreadyUsedValidation\"></dxi-validation-rule>\n    </dxi-column>\n    <dxi-column dataField=\"isActive\" [caption]=\"'management.isActive' | translate\" [visible]=\"false\"></dxi-column>\n    <dxi-column dataField=\"firstName\" [caption]=\"'management.firstName' | translate\"></dxi-column>\n    <dxi-column dataField=\"lastName\" [caption]=\"'management.lastName' | translate\"></dxi-column>\n    <dxi-column dataField=\"groups\" [caption]=\"'management.group' | translate\"></dxi-column>\n\n    <dxo-editing mode=\"popup\" [allowAdding]=\"true\" [allowUpdating]=\"true\" [allowDeleting]=\"true\" [useIcons]=\"true\">\n        <dxo-popup [showTitle]=\"true\" [title]=\"'management.group' | translate\"></dxo-popup>\n        <dxo-form colCount=\"2\" [labelLocation]=\"showColumnXS ? 'left' : 'top'\">\n            <dxi-item dataField=\"userName\" [isRequired]=\"true\"></dxi-item>\n            <dxi-item dataField=\"isActive\"></dxi-item>\n            <dxi-item dataField=\"firstName\"></dxi-item>\n            <dxi-item dataField=\"lastName\"></dxi-item>\n            <dxi-item dataField=\"group\"></dxi-item>\n        </dxo-form>\n    </dxo-editing>\n</cause-dx-data-grid>\n",
                styles: [""]
            }] }
];
/** @nocollapse */
CauseManagementUserComponent.ctorParameters = () => [
    { type: ManagementUserService },
    { type: BreakpointObserver }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CauseManagementModule {
}
CauseManagementModule.decorators = [
    { type: NgModule, args: [{
                declarations: [
                    CauseManagementComponent,
                    CauseManagementUserComponent,
                    CauseManagementGroupComponent,
                ],
                exports: [
                    CauseManagementComponent,
                    CauseManagementUserComponent,
                    CauseManagementGroupComponent,
                ],
                imports: [
                    BrowserModule,
                    CauseCoreModule,
                    CauseDxModule,
                    DxListModule,
                    DxTagBoxModule,
                    DxCheckBoxModule,
                ],
                schemas: [CUSTOM_ELEMENTS_SCHEMA],
            },] }
];

export { CauseManagementComponent, CauseManagementGroupComponent, CauseManagementModule, GroupModel, GroupPermissionModel, ManagementGroupService, ManagementService, ManagementUserService, UserGroupModel, UserModel, UserPermissionModel, ManagementPermissionService as ɵa, CauseManagementUserComponent as ɵb };
//# sourceMappingURL=cause-911-management.js.map