< Summary - Estud

Line coverage
96%
Covered lines: 127
Uncovered lines: 5
Coverable lines: 132
Total lines: 438
Line coverage: 96.2%
Branch coverage
58%
Covered branches: 7
Total branches: 12
Branch coverage: 58.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Campi.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetCampi = nameof(GetCampi);
 8    public const string GetCampus = nameof(GetCampus);
 9    public const string CreateCampus = nameof(CreateCampus);
 10    public const string UpdateCampus = nameof(UpdateCampus);
 11
 12    public static AuthorizationBuilder AddCampiPolicies(this AuthorizationBuilder builder)
 13    {
 214        builder
 215            .AddEstudPolicy(GetCampi, UserType.Manager, EstudPermissions.ManageCampi)
 216            .AddEstudPolicy(GetCampus, UserType.Manager, EstudPermissions.ManageCampi)
 217            .AddEstudPolicy(CreateCampus, UserType.Manager, EstudPermissions.ManageCampi)
 218            .AddEstudPolicy(UpdateCampus, UserType.Manager, EstudPermissions.ManageCampi);
 19
 220        return builder;
 21    }
 22}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Classes.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetClasses = nameof(GetClasses);
 8    public const string CreateClass = nameof(CreateClass);
 9    public const string ReleaseClassForEnrollment = nameof(ReleaseClassForEnrollment);
 10
 11    public static AuthorizationBuilder AddClassesPolicies(this AuthorizationBuilder builder)
 12    {
 213        builder
 214            .AddEstudPolicy(GetClasses, UserType.Manager, EstudPermissions.ManageClasses)
 215            .AddEstudPolicy(CreateClass, UserType.Manager, EstudPermissions.ManageClasses)
 216            .AddEstudPolicy(ReleaseClassForEnrollment, UserType.Manager, EstudPermissions.ManageClasses);
 17
 218        return builder;
 19    }
 20}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Classrooms.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetClassrooms = nameof(GetClassrooms);
 8    public const string CreateClassroom = nameof(CreateClassroom);
 9
 10    public static AuthorizationBuilder AddClassroomsPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddEstudPolicy(GetClassrooms, UserType.Manager, EstudPermissions.ManageClassrooms)
 214            .AddEstudPolicy(CreateClassroom, UserType.Manager, EstudPermissions.ManageClassrooms);
 15
 216        return builder;
 17    }
 18}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.CourseCurriculums.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetCourseCurriculum = nameof(GetCourseCurriculum);
 8    public const string GetCourseCurriculums = nameof(GetCourseCurriculums);
 9    public const string CreateCourseCurriculum = nameof(CreateCourseCurriculum);
 10    public const string EditCourseCurriculum = nameof(EditCourseCurriculum);
 11
 12    public static AuthorizationBuilder AddCourseCurriculumsPolicies(this AuthorizationBuilder builder)
 13    {
 214        builder
 215            .AddEstudPolicy(GetCourseCurriculum, UserType.Manager, EstudPermissions.ManageCourseCurriculums)
 216            .AddEstudPolicy(GetCourseCurriculums, UserType.Manager, EstudPermissions.ManageCourseCurriculums)
 217            .AddEstudPolicy(CreateCourseCurriculum, UserType.Manager, EstudPermissions.ManageCourseCurriculums)
 218            .AddEstudPolicy(EditCourseCurriculum, UserType.Manager, EstudPermissions.ManageCourseCurriculums);
 19
 220        return builder;
 21    }
 22}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.CourseOfferings.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetCourseOfferings = nameof(GetCourseOfferings);
 8    public const string CreateCourseOffering = nameof(CreateCourseOffering);
 9
 10    public static AuthorizationBuilder AddCourseOfferingsPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddEstudPolicy(GetCourseOfferings, UserType.Manager, EstudPermissions.ManageCourseOfferings)
 214            .AddEstudPolicy(CreateCourseOffering, UserType.Manager, EstudPermissions.ManageCourseOfferings);
 15
 216        return builder;
 17    }
 18}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Courses.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetCourse = nameof(GetCourse);
 8    public const string GetCourses = nameof(GetCourses);
 9    public const string CreateCourse = nameof(CreateCourse);
 10    public const string UpdateCourse = nameof(UpdateCourse);
 11
 12    public const string GetCourseDisciplines = nameof(GetCourseDisciplines);
 13    public const string AddCourseDisciplines = nameof(AddCourseDisciplines);
 14    public const string RemoveCourseDiscipline = nameof(RemoveCourseDiscipline);
 15    public const string GetCoursePotentialDisciplines = nameof(GetCoursePotentialDisciplines);
 16
 17    public static AuthorizationBuilder AddCoursesPolicies(this AuthorizationBuilder builder)
 18    {
 219        builder
 220            .AddEstudPolicy(GetCourse, UserType.Manager, EstudPermissions.ManageCourses)
 221            .AddEstudPolicy(GetCourses, UserType.Manager, EstudPermissions.ManageCourses)
 222            .AddEstudPolicy(CreateCourse, UserType.Manager, EstudPermissions.ManageCourses)
 223            .AddEstudPolicy(UpdateCourse, UserType.Manager, EstudPermissions.ManageCourses);
 24
 225        builder
 226            .AddEstudPolicy(GetCourseDisciplines, UserType.Manager, EstudPermissions.ManageCourses)
 227            .AddEstudPolicy(AddCourseDisciplines, UserType.Manager, EstudPermissions.ManageCourses)
 228            .AddEstudPolicy(RemoveCourseDiscipline, UserType.Manager, EstudPermissions.ManageCourses)
 229            .AddEstudPolicy(GetCoursePotentialDisciplines, UserType.Manager, EstudPermissions.ManageCourses);
 30
 231        return builder;
 32    }
 33}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Cross.cs

#LineLine coverage
 1namespace Estud.Back.Auth.Policies;
 2
 3public static partial class Policies
 4{
 5    public const string GetHomeStats = nameof(GetHomeStats);
 6
 7    public static AuthorizationBuilder AddCrossPolicies(this AuthorizationBuilder builder)
 8    {
 29        builder
 210            .AddEstudPolicy(GetHomeStats, UserType.Manager);
 11
 212        return builder;
 13    }
 14}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.cs

#LineLine coverage
 1using Estud.Back.Auth.Schemes;
 2using Estud.Back.Auth.Permissions;
 3
 4namespace Estud.Back.Auth.Policies;
 5
 6public static partial class Policies
 7{
 8    /// <summary>
 9    /// Basta que o usuário esteja logado.
 10    /// </summary>
 11    public static AuthorizationBuilder AddEstudPolicy(this AuthorizationBuilder builder, string name)
 12    {
 4013        return builder.AddPolicy(name, policy => policy
 4014            .RequireAuthenticatedUser()
 4015            .AddAuthenticationSchemes(JwtBearerScheme.Name));
 16    }
 17
 18    /// <summary>
 19    /// O usuário precisa estar logado e seu perfil de acesso deve possuir as permissões especificadas.
 20    /// </summary>
 21    public static AuthorizationBuilder AddEstudPolicy(this AuthorizationBuilder builder, string name, params EstudPermis
 22    {
 023        var ids = permissions.Select(x => x.Id).ToList();
 24
 025        return builder.AddPolicy(name, policy => policy
 026            .RequireAuthenticatedUser()
 027            .RequireAssertion(x => x.User.Permissions.Any(p => ids.Contains(p)))
 028            .AddAuthenticationSchemes(JwtBearerScheme.Name));
 29    }
 30
 31    /// <summary>
 32    /// O usuário precisa estar logado e seu perfil de acesso deve possuir o tipo base e as permissões especificadas.
 33    /// </summary>
 34    public static AuthorizationBuilder AddEstudPolicy(this AuthorizationBuilder builder, string name, UserType userType,
 35    {
 27436        var ids = permissions.Select(x => x.Id).ToList();
 37
 28038        return builder.AddPolicy(name, policy => policy
 28039            .RequireAuthenticatedUser()
 1323040            .RequireAssertion(x => x.User.Type == userType && (ids.Count == 0 || x.User.Permissions.Any(p => ids.Contain
 28041            .AddAuthenticationSchemes(JwtBearerScheme.Name));
 42    }
 43}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Disciplines.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetDiscipline = nameof(GetDiscipline);
 8    public const string GetDisciplines = nameof(GetDisciplines);
 9    public const string CreateDiscipline = nameof(CreateDiscipline);
 10    public const string UpdateDiscipline = nameof(UpdateDiscipline);
 11
 12    public const string AddDisciplineCourses = nameof(AddDisciplineCourses);
 13    public const string RemoveDisciplineCourse = nameof(RemoveDisciplineCourse);
 14    public const string GetDisciplinePotentialCourses = nameof(GetDisciplinePotentialCourses);
 15
 16    public static AuthorizationBuilder AddDisciplinesPolicies(this AuthorizationBuilder builder)
 17    {
 218        builder
 219            .AddEstudPolicy(GetDiscipline, UserType.Manager, EstudPermissions.ManageDisciplines)
 220            .AddEstudPolicy(GetDisciplines, UserType.Manager, EstudPermissions.ManageDisciplines)
 221            .AddEstudPolicy(CreateDiscipline, UserType.Manager, EstudPermissions.ManageDisciplines)
 222            .AddEstudPolicy(UpdateDiscipline, UserType.Manager, EstudPermissions.ManageDisciplines);
 23
 224        builder
 225            .AddEstudPolicy(AddDisciplineCourses, UserType.Manager, EstudPermissions.ManageDisciplines)
 226            .AddEstudPolicy(RemoveDisciplineCourse, UserType.Manager, EstudPermissions.ManageDisciplines)
 227            .AddEstudPolicy(GetDisciplinePotentialCourses, UserType.Manager, EstudPermissions.ManageDisciplines);
 28
 229        return builder;
 30    }
 31}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Identity.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetRole = nameof(GetRole);
 8    public const string GetRoles = nameof(GetRoles);
 9    public const string CreateRole = nameof(CreateRole);
 10    public const string UpdateRole = nameof(UpdateRole);
 11    public const string GetDefaultRoles = nameof(GetDefaultRoles);
 12    public const string GetInstitutionRole = nameof(GetInstitutionRole);
 13    public const string GetInstitutionRoles = nameof(GetInstitutionRoles);
 14    public const string FilterInstitutionRoles = nameof(FilterInstitutionRoles);
 15    public const string GetAvailableInstitutionRoles = nameof(GetAvailableInstitutionRoles);
 16
 17    public const string GetSsoConfiguration = nameof(GetSsoConfiguration);
 18    public const string GetSsoConfigurations = nameof(GetSsoConfigurations);
 19    public const string CreateSsoConfiguration = nameof(CreateSsoConfiguration);
 20    public const string UpdateSsoConfiguration = nameof(UpdateSsoConfiguration);
 21
 22    public const string SetupTwoFactor = nameof(SetupTwoFactor);
 23    public const string GetTwoFactorKey = nameof(GetTwoFactorKey);
 24
 25    public const string Logout = nameof(Logout);
 26    public const string GetPermissions = nameof(GetPermissions);
 27
 28    public static AuthorizationBuilder AddIdentityPolicies(this AuthorizationBuilder builder)
 29    {
 230        builder
 231            .AddEstudPolicy(GetRole, UserType.Manager, EstudPermissions.ManageRoles)
 232            .AddEstudPolicy(GetRoles, UserType.Manager, EstudPermissions.ManageRoles)
 233            .AddEstudPolicy(CreateRole, UserType.Manager, EstudPermissions.ManageRoles)
 234            .AddEstudPolicy(UpdateRole, UserType.Manager, EstudPermissions.ManageRoles)
 235            .AddEstudPolicy(GetPermissions, UserType.Manager, EstudPermissions.ManageRoles)
 236            .AddEstudPolicy(GetDefaultRoles, UserType.Manager, EstudPermissions.ManageRoles)
 237            .AddEstudPolicy(GetInstitutionRoles, UserType.Manager, EstudPermissions.ManageRoles)
 238            .AddEstudPolicy(GetInstitutionRole, UserType.Manager, EstudPermissions.ManageRoles)
 239            .AddEstudPolicy(FilterInstitutionRoles, UserType.Manager, EstudPermissions.ManageRoles)
 240            .AddEstudPolicy(GetAvailableInstitutionRoles, UserType.Manager, EstudPermissions.ManageRoles);
 41
 242        builder
 243            .AddEstudPolicy(GetSsoConfiguration, UserType.Manager, EstudPermissions.ManageSso)
 244            .AddEstudPolicy(GetSsoConfigurations, UserType.Manager, EstudPermissions.ManageSso)
 245            .AddEstudPolicy(CreateSsoConfiguration, UserType.Manager, EstudPermissions.ManageSso)
 246            .AddEstudPolicy(UpdateSsoConfiguration, UserType.Manager, EstudPermissions.ManageSso);
 47
 248        builder
 249            .AddEstudPolicy(Logout)
 250            .AddEstudPolicy(SetupTwoFactor)
 251            .AddEstudPolicy(GetTwoFactorKey);
 52
 253        return builder;
 54    }
 55}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Notifications.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string CreateNotification = nameof(CreateNotification);
 8
 9    public const string GetInstitutionNotifications = nameof(GetInstitutionNotifications);
 10
 11    public const string GetNotifications = nameof(GetNotifications);
 12    public const string MarkNotificationsAsViewed = nameof(MarkNotificationsAsViewed);
 13    public const string GetUnreadNotificationsCount = nameof(GetUnreadNotificationsCount);
 14
 15    public static AuthorizationBuilder AddNotificationsPolicies(this AuthorizationBuilder builder)
 16    {
 217        builder
 218            .AddEstudPolicy(CreateNotification, UserType.Manager, EstudPermissions.ManageNotifications)
 219            .AddEstudPolicy(GetInstitutionNotifications, UserType.Manager, EstudPermissions.ManageNotifications);
 20
 221        builder
 222            .AddEstudPolicy(GetNotifications)
 223            .AddEstudPolicy(MarkNotificationsAsViewed)
 224            .AddEstudPolicy(GetUnreadNotificationsCount);
 25
 226        return builder;
 27    }
 28}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Periods.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetAcademicPeriods = nameof(GetAcademicPeriods);
 8    public const string CreateAcademicPeriod = nameof(CreateAcademicPeriod);
 9
 10    public const string GetEnrollmentPeriods = nameof(GetEnrollmentPeriods);
 11    public const string CreateEnrollmentPeriod = nameof(CreateEnrollmentPeriod);
 12
 13    public static AuthorizationBuilder AddAcademicPeriodsPolicies(this AuthorizationBuilder builder)
 14    {
 215        builder
 216            .AddEstudPolicy(GetAcademicPeriods, UserType.Manager, EstudPermissions.ManagePeriods)
 217            .AddEstudPolicy(CreateAcademicPeriod, UserType.Manager, EstudPermissions.ManagePeriods);
 18
 219        builder
 220            .AddEstudPolicy(GetEnrollmentPeriods, UserType.Manager, EstudPermissions.ManagePeriods)
 221            .AddEstudPolicy(CreateEnrollmentPeriod, UserType.Manager, EstudPermissions.ManagePeriods);
 22
 223        return builder;
 24    }
 25}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Students.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetStudent = nameof(GetStudent);
 8    public const string GetStudents = nameof(GetStudents);
 9    public const string CreateStudent = nameof(CreateStudent);
 10    public const string EnrollStudentInCourseOffering = nameof(EnrollStudentInCourseOffering);
 11
 12    public const string GetStudentAgenda = nameof(GetStudentAgenda);
 13
 14    public static AuthorizationBuilder AddStudentsPolicies(this AuthorizationBuilder builder)
 15    {
 216        builder
 217            .AddEstudPolicy(GetStudents, UserType.Manager, EstudPermissions.ManageStudents)
 218            .AddEstudPolicy(GetStudent, UserType.Manager, EstudPermissions.ManageStudents)
 219            .AddEstudPolicy(CreateStudent, UserType.Manager, EstudPermissions.ManageStudents)
 220            .AddEstudPolicy(EnrollStudentInCourseOffering, UserType.Manager, EstudPermissions.ManageStudents);
 21
 222        builder
 223            .AddEstudPolicy(GetStudentAgenda, UserType.Student);
 24
 225        return builder;
 26    }
 27}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Teachers.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetTeacher = nameof(GetTeacher);
 8    public const string GetTeachers = nameof(GetTeachers);
 9    public const string CreateTeacher = nameof(CreateTeacher);
 10    public const string UpdateTeacher = nameof(UpdateTeacher);
 11    public const string GetTeacherPotentialCampi = nameof(GetTeacherPotentialCampi);
 12    public const string GetTeacherPotentialDisciplines = nameof(GetTeacherPotentialDisciplines);
 13    public const string AssignCampiToTeacher = nameof(AssignCampiToTeacher);
 14    public const string AssignDisciplinesToTeacher = nameof(AssignDisciplinesToTeacher);
 15
 16    public const string GetTeacherAgenda = nameof(GetTeacherAgenda);
 17
 18    public static AuthorizationBuilder AddTeachersPolicies(this AuthorizationBuilder builder)
 19    {
 220        builder
 221            .AddEstudPolicy(GetTeacher, UserType.Manager, EstudPermissions.ManageTeachers)
 222            .AddEstudPolicy(GetTeachers, UserType.Manager, EstudPermissions.ManageTeachers)
 223            .AddEstudPolicy(CreateTeacher, UserType.Manager, EstudPermissions.ManageTeachers)
 224            .AddEstudPolicy(UpdateTeacher, UserType.Manager, EstudPermissions.ManageTeachers)
 225            .AddEstudPolicy(GetTeacherPotentialCampi, UserType.Manager, EstudPermissions.ManageTeachers)
 226            .AddEstudPolicy(GetTeacherPotentialDisciplines, UserType.Manager, EstudPermissions.ManageTeachers)
 227            .AddEstudPolicy(AssignCampiToTeacher, UserType.Manager, EstudPermissions.ManageTeachers)
 228            .AddEstudPolicy(AssignDisciplinesToTeacher, UserType.Manager, EstudPermissions.ManageTeachers);
 29
 230        builder
 231            .AddEstudPolicy(GetTeacherAgenda, UserType.Teacher);
 32
 233        return builder;
 34    }
 35}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Users.cs

#LineLine coverage
 1namespace Estud.Back.Auth.Policies;
 2
 3public static partial class Policies
 4{
 5    public const string GetUserAccount = nameof(GetUserAccount);
 6    public const string UpdateUserAccount = nameof(UpdateUserAccount);
 7
 8    public const string GetUserFeedbacks = nameof(GetUserFeedbacks);
 9    public const string CreateUserFeedback = nameof(CreateUserFeedback);
 10
 11    public static AuthorizationBuilder AddUsersPolicies(this AuthorizationBuilder builder)
 12    {
 213        builder
 214            .AddEstudPolicy(GetUserAccount)
 215            .AddEstudPolicy(UpdateUserAccount);
 16
 217        builder
 218            .AddEstudPolicy(GetUserFeedbacks)
 219            .AddEstudPolicy(CreateUserFeedback);
 20
 221        return builder;
 22    }
 23}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Webhooks.cs

#LineLine coverage
 1using Estud.Back.Auth.Permissions;
 2
 3namespace Estud.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetWebhookCalls = nameof(GetWebhookCalls);
 8    public const string GetWebhookSubscription = nameof(GetWebhookSubscription);
 9    public const string GetWebhookSubscriptions = nameof(GetWebhookSubscriptions);
 10    public const string CreateWebhookSubscription = nameof(CreateWebhookSubscription);
 11    public const string UpdateWebhookSubscription = nameof(UpdateWebhookSubscription);
 12
 13    public static AuthorizationBuilder AddWebhooksPolicies(this AuthorizationBuilder builder)
 14    {
 215        builder
 216            .AddEstudPolicy(GetWebhookCalls, UserType.Manager, EstudPermissions.ManageWebhooks)
 217            .AddEstudPolicy(GetWebhookSubscription, UserType.Manager, EstudPermissions.ManageWebhooks)
 218            .AddEstudPolicy(GetWebhookSubscriptions, UserType.Manager, EstudPermissions.ManageWebhooks)
 219            .AddEstudPolicy(CreateWebhookSubscription, UserType.Manager, EstudPermissions.ManageWebhooks)
 220            .AddEstudPolicy(UpdateWebhookSubscription, UserType.Manager, EstudPermissions.ManageWebhooks);
 21
 222        return builder;
 23    }
 24}

Methods/Properties

AddCampiPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddClassesPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddClassroomsPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddCourseCurriculumsPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddCourseOfferingsPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddCoursesPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddCrossPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddEstudPolicy(Microsoft.AspNetCore.Authorization.AuthorizationBuilder,System.String)
AddEstudPolicy(Microsoft.AspNetCore.Authorization.AuthorizationBuilder,System.String,Estud.Back.Auth.Permissions.EstudPermission[])
AddEstudPolicy(Microsoft.AspNetCore.Authorization.AuthorizationBuilder,System.String,Estud.Back.Domain.Enums.UserType,Estud.Back.Auth.Permissions.EstudPermission[])
AddDisciplinesPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddIdentityPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddNotificationsPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddAcademicPeriodsPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddStudentsPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddTeachersPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddUsersPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)
AddWebhooksPolicies(Microsoft.AspNetCore.Authorization.AuthorizationBuilder)