< Summary - Syki

Line coverage
100%
Covered lines: 80
Uncovered lines: 0
Coverable lines: 80
Total lines: 278
Line coverage: 100%
Branch coverage
100%
Covered branches: 4
Total branches: 4
Branch coverage: 100%
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 Syki.Back.Auth.Permissions;
 2
 3namespace Syki.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            .AddSykiPolicy(GetCampi, SykiPermissions.ManageCampi)
 216            .AddSykiPolicy(GetCampus, SykiPermissions.ManageCampi)
 217            .AddSykiPolicy(CreateCampus, SykiPermissions.ManageCampi)
 218            .AddSykiPolicy(UpdateCampus, SykiPermissions.ManageCampi);
 19
 220        return builder;
 21    }
 22}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetCourseCurriculums = nameof(GetCourseCurriculums);
 8    public const string CreateCourseCurriculum = nameof(CreateCourseCurriculum);
 9
 10    public static AuthorizationBuilder AddCourseCurriculumsPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddSykiPolicy(GetCourseCurriculums, SykiPermissions.ManageCourseCurriculums)
 214            .AddSykiPolicy(CreateCourseCurriculum, SykiPermissions.ManageCourseCurriculums);
 15
 216        return builder;
 17    }
 18}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.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            .AddSykiPolicy(GetCourseOfferings, SykiPermissions.ManageCourseOfferings)
 214            .AddSykiPolicy(CreateCourseOffering, SykiPermissions.ManageCourseOfferings);
 15
 216        return builder;
 17    }
 18}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetCourses = nameof(GetCourses);
 8    public const string CreateCourse = nameof(CreateCourse);
 9    public const string UpdateCourse = nameof(UpdateCourse);
 10
 11    public const string GetCourseDisciplines = nameof(GetCourseDisciplines);
 12
 13    public static AuthorizationBuilder AddCoursesPolicies(this AuthorizationBuilder builder)
 14    {
 215        builder
 216            .AddSykiPolicy(GetCourses, SykiPermissions.ManageCourses)
 217            .AddSykiPolicy(CreateCourse, SykiPermissions.ManageCourses)
 218            .AddSykiPolicy(UpdateCourse, SykiPermissions.ManageCourses);
 19
 220        builder
 221            .AddSykiPolicy(GetCourseDisciplines, SykiPermissions.ManageCourses);
 22
 223        return builder;
 24    }
 25}

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

#LineLine coverage
 1using Syki.Back.Auth.Schemes;
 2using Syki.Back.Auth.Permissions;
 3
 4namespace Syki.Back.Auth.Policies;
 5
 6public static partial class Policies
 7{
 28    public static List<PolicyMetadata> All = [];
 9
 10    /// <summary>
 11    /// Basta que o usuário esteja logado.
 12    /// </summary>
 13    public static AuthorizationBuilder AddSykiPolicy(this AuthorizationBuilder builder, string name)
 14    {
 1615        All.Add(new() { Name = name, Permissions = [] });
 16
 3217        return builder.AddPolicy(name, policy => policy
 3218            .RequireAuthenticatedUser()
 3219            .AddAuthenticationSchemes(JwtBearerScheme.Name));
 20    }
 21
 22    /// <summary>
 23    /// O usuário precisa estar logado numa instituição onde seu perfil de acesso possui as permissões especificadas.
 24    /// </summary>
 25    public static AuthorizationBuilder AddSykiPolicy(this AuthorizationBuilder builder, string name, params SykiPermissi
 26    {
 7027        All.Add(new() { Name = name, Permissions = permissions.ToList() });
 28
 14029        var ids = permissions.Select(x => x.Id).ToList();
 30
 14031        return builder.AddPolicy(name, policy => policy
 14032            .RequireAuthenticatedUser()
 157633            .RequireAssertion(x => x.User.Permissions.Any(p => ids.Contains(p)))
 14034            .AddAuthenticationSchemes(JwtBearerScheme.Name));
 35    }
 36}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.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 GetDisciplinePotentialCourses = nameof(GetDisciplinePotentialCourses);
 14
 15    public static AuthorizationBuilder AddDisciplinesPolicies(this AuthorizationBuilder builder)
 16    {
 217        builder
 218            .AddSykiPolicy(GetDiscipline, SykiPermissions.ManageDisciplines)
 219            .AddSykiPolicy(GetDisciplines, SykiPermissions.ManageDisciplines)
 220            .AddSykiPolicy(CreateDiscipline, SykiPermissions.ManageDisciplines)
 221            .AddSykiPolicy(UpdateDiscipline, SykiPermissions.ManageDisciplines);
 22
 223        builder
 224            .AddSykiPolicy(AddDisciplineCourses, SykiPermissions.ManageDisciplines)
 225            .AddSykiPolicy(GetDisciplinePotentialCourses, SykiPermissions.ManageDisciplines);
 26
 227        return builder;
 28    }
 29}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetRoles = nameof(GetRoles);
 8    public const string CreateRole = nameof(CreateRole);
 9    public const string UpdateRole = nameof(UpdateRole);
 10    public const string GetDefaultRoles = nameof(GetDefaultRoles);
 11    public const string GetInstitutionRole = nameof(GetInstitutionRole);
 12    public const string GetInstitutionRoles = nameof(GetInstitutionRoles);
 13    public const string FilterInstitutionRoles = nameof(FilterInstitutionRoles);
 14    public const string GetAvailableInstitutionRoles = nameof(GetAvailableInstitutionRoles);
 15
 16    public const string CreateSsoConfiguration = nameof(CreateSsoConfiguration);
 17    public const string UpdateSsoConfiguration = nameof(UpdateSsoConfiguration);
 18    public const string GetSsoConfigurations = nameof(GetSsoConfigurations);
 19
 20    public const string SetupTwoFactor = nameof(SetupTwoFactor);
 21    public const string GetTwoFactorKey = nameof(GetTwoFactorKey);
 22
 23    public const string Logout = nameof(Logout);
 24    public const string GetPermissions = nameof(GetPermissions);
 25
 26    public static AuthorizationBuilder AddIdentityPolicies(this AuthorizationBuilder builder)
 27    {
 228        builder
 229            .AddSykiPolicy(GetRoles, SykiPermissions.ManageRoles)
 230            .AddSykiPolicy(CreateRole, SykiPermissions.ManageRoles)
 231            .AddSykiPolicy(UpdateRole, SykiPermissions.ManageRoles)
 232            .AddSykiPolicy(GetDefaultRoles, SykiPermissions.ManageRoles)
 233            .AddSykiPolicy(GetInstitutionRoles, SykiPermissions.ManageRoles)
 234            .AddSykiPolicy(GetInstitutionRole, SykiPermissions.ManageRoles)
 235            .AddSykiPolicy(FilterInstitutionRoles, SykiPermissions.ManageRoles)
 236            .AddSykiPolicy(GetAvailableInstitutionRoles, SykiPermissions.ManageRoles);
 37
 238        builder
 239            .AddSykiPolicy(CreateSsoConfiguration, SykiPermissions.ManageSso)
 240            .AddSykiPolicy(UpdateSsoConfiguration, SykiPermissions.ManageSso)
 241            .AddSykiPolicy(GetSsoConfigurations, SykiPermissions.ManageSso);
 42
 243        builder
 244            .AddSykiPolicy(SetupTwoFactor)
 245            .AddSykiPolicy(GetTwoFactorKey);
 46
 247        builder
 248            .AddSykiPolicy(Logout)
 249            .AddSykiPolicy(GetPermissions);
 50
 251        return builder;
 52    }
 53}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.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 static AuthorizationBuilder AddAcademicPeriodsPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddSykiPolicy(GetAcademicPeriods, SykiPermissions.ManagePeriods)
 214            .AddSykiPolicy(CreateAcademicPeriod, SykiPermissions.ManagePeriods);
 15
 216        return builder;
 17    }
 18}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetStudents = nameof(GetStudents);
 8    public const string CreateStudent = nameof(CreateStudent);
 9
 10    public static AuthorizationBuilder AddStudentsPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddSykiPolicy(GetStudents, SykiPermissions.ManageStudents)
 214            .AddSykiPolicy(CreateStudent, SykiPermissions.ManageStudents);
 15
 216        return builder;
 17    }
 18}

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

#LineLine coverage
 1using Syki.Back.Auth.Permissions;
 2
 3namespace Syki.Back.Auth.Policies;
 4
 5public static partial class Policies
 6{
 7    public const string GetTeachers = nameof(GetTeachers);
 8    public const string CreateTeacher = nameof(CreateTeacher);
 9
 10    public static AuthorizationBuilder AddTeachersPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddSykiPolicy(GetTeachers, SykiPermissions.ManageTeachers)
 214            .AddSykiPolicy(CreateTeacher, SykiPermissions.ManageTeachers);
 15
 216        return builder;
 17    }
 18}

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

#LineLine coverage
 1namespace Syki.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            .AddSykiPolicy(GetUserAccount)
 215            .AddSykiPolicy(UpdateUserAccount);
 16
 217        builder
 218            .AddSykiPolicy(GetUserFeedbacks)
 219            .AddSykiPolicy(CreateUserFeedback);
 20
 221        return builder;
 22    }
 23}