Beispiel #1
0
        public async Task <bool> CanUserEditRoleAsync(string userId, int personnelRoleId)
        {
            var department = await _departmentsService.GetDepartmentByUserIdAsync(userId);

            var role = await _personnelRolesService.GetRoleByIdAsync(personnelRoleId);

            if (department == null || role == null)
            {
                return(false);
            }

            if (role.DepartmentId != department.DepartmentId)
            {
                return(false);
            }

            if (department.IsUserAnAdmin(userId))
            {
                return(true);
            }

            return(false);
        }
        public async Task <IActionResult> Index()
        {
            var model = new NotificationIndexView();

            model.Notifications = await _notificationService.GetNotificationsByDepartmentAsync(DepartmentId);

            var unitTypes = await _unitsService.GetUnitTypesForDepartmentAsync(DepartmentId);

            var allRoles = await _personnelRolesService.GetRolesForDepartmentAsync(DepartmentId);

            model.CustomStates = await _customStateService.GetAllActiveCustomStatesForDepartmentAsync(DepartmentId);

            foreach (var notification in model.Notifications)
            {
                if (notification.Everyone)
                {
                    model.NotifyUsers.Add(notification.DepartmentNotificationId, "Everyone");
                }
                else if (notification.DepartmentAdmins)
                {
                    model.NotifyUsers.Add(notification.DepartmentNotificationId, "Department Admins");
                }
                else if (notification.SelectedGroupsAdminsOnly)
                {
                    model.NotifyUsers.Add(notification.DepartmentNotificationId, "Selected Group(s) Admins");
                }
                else
                {
                    var sb = new StringBuilder();

                    if (!String.IsNullOrWhiteSpace(notification.RolesToNotify))
                    {
                        var roles = notification.RolesToNotify.Split(char.Parse(","));
                        foreach (var roleId in roles)
                        {
                            var role = await _personnelRolesService.GetRoleByIdAsync(int.Parse(roleId));

                            if (role != null)
                            {
                                if (sb.Length > 0)
                                {
                                    sb.Append("," + role.Name);
                                }
                                else
                                {
                                    sb.Append(role.Name);
                                }
                            }
                        }
                    }

                    if (!String.IsNullOrWhiteSpace(notification.GroupsToNotify))
                    {
                        var groups = notification.GroupsToNotify.Split(char.Parse(","));
                        foreach (var groupId in groups)
                        {
                            var group = await _departmentGroupsService.GetGroupByIdAsync(int.Parse(groupId), false);

                            if (group != null)
                            {
                                if (sb.Length > 0)
                                {
                                    sb.Append("," + group.Name);
                                }
                                else
                                {
                                    sb.Append(group.Name);
                                }
                            }
                        }
                    }

                    if (!String.IsNullOrWhiteSpace(notification.UsersToNotify))
                    {
                        var users = notification.UsersToNotify.Split(char.Parse(","));
                        foreach (var userId in users)
                        {
                            var user = _usersService.GetUserById(userId);

                            if (sb.Length > 0)
                            {
                                sb.Append("," + UserHelper.GetFullNameForUser(user.UserId));
                            }
                            else
                            {
                                sb.Append(UserHelper.GetFullNameForUser(user.UserId));
                            }
                        }
                    }

                    model.NotifyUsers.Add(notification.DepartmentNotificationId, sb.ToString());
                }

                if (notification.EventType == (int)EventTypes.RolesInGroupAvailabilityAlert || notification.EventType == (int)EventTypes.RolesInDepartmentAvailabilityAlert)
                {
                    if (!String.IsNullOrWhiteSpace(notification.Data) && allRoles.Any(x => x.PersonnelRoleId == int.Parse(notification.Data)))
                    {
                        model.NotifyData.Add(notification.DepartmentNotificationId, allRoles.First(x => x.PersonnelRoleId == int.Parse(notification.Data)).Name);
                    }
                }
                else if (notification.EventType == (int)EventTypes.UnitTypesInGroupAvailabilityAlert || notification.EventType == (int)EventTypes.UnitTypesInDepartmentAvailabilityAlert)
                {
                    if (!String.IsNullOrWhiteSpace(notification.Data) && unitTypes.Any(x => x.UnitTypeId == int.Parse(notification.Data)))
                    {
                        model.NotifyData.Add(notification.DepartmentNotificationId, unitTypes.First(x => x.UnitTypeId == int.Parse(notification.Data)).Type);
                    }
                }
            }

            return(View(model));
        }