< Summary - Syki

Line coverage
95%
Covered lines: 111
Uncovered lines: 5
Coverable lines: 116
Total lines: 389
Line coverage: 95.6%
Branch coverage
60%
Covered branches: 6
Total branches: 10
Branch coverage: 60%
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, UserType.Manager, SykiPermissions.ManageCampi)
 216            .AddSykiPolicy(GetCampus, UserType.Manager, SykiPermissions.ManageCampi)
 217            .AddSykiPolicy(CreateCampus, UserType.Manager, SykiPermissions.ManageCampi)
 218            .AddSykiPolicy(UpdateCampus, UserType.Manager, SykiPermissions.ManageCampi);
 19
 220        return builder;
 21    }
 22}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Classes.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 GetClasses = nameof(GetClasses);
 8    public const string CreateClass = nameof(CreateClass);
 9
 10    public static AuthorizationBuilder AddClassesPolicies(this AuthorizationBuilder builder)
 11    {
 212        builder
 213            .AddSykiPolicy(GetClasses, UserType.Manager, SykiPermissions.ManageClasses)
 214            .AddSykiPolicy(CreateClass, UserType.Manager, SykiPermissions.ManageClasses);
 15
 216        return builder;
 17    }
 18}

/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 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            .AddSykiPolicy(GetCourseCurriculum, UserType.Manager, SykiPermissions.ManageCourseCurriculums)
 216            .AddSykiPolicy(GetCourseCurriculums, UserType.Manager, SykiPermissions.ManageCourseCurriculums)
 217            .AddSykiPolicy(CreateCourseCurriculum, UserType.Manager, SykiPermissions.ManageCourseCurriculums)
 218            .AddSykiPolicy(EditCourseCurriculum, UserType.Manager, SykiPermissions.ManageCourseCurriculums);
 19
 220        return builder;
 21    }
 22}

/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, UserType.Manager, SykiPermissions.ManageCourseOfferings)
 214            .AddSykiPolicy(CreateCourseOffering, UserType.Manager, 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 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            .AddSykiPolicy(GetCourse, UserType.Manager, SykiPermissions.ManageCourses)
 221            .AddSykiPolicy(GetCourses, UserType.Manager, SykiPermissions.ManageCourses)
 222            .AddSykiPolicy(CreateCourse, UserType.Manager, SykiPermissions.ManageCourses)
 223            .AddSykiPolicy(UpdateCourse, UserType.Manager, SykiPermissions.ManageCourses);
 24
 225        builder
 226            .AddSykiPolicy(GetCourseDisciplines, UserType.Manager, SykiPermissions.ManageCourses)
 227            .AddSykiPolicy(AddCourseDisciplines, UserType.Manager, SykiPermissions.ManageCourses)
 228            .AddSykiPolicy(RemoveCourseDiscipline, UserType.Manager, SykiPermissions.ManageCourses)
 229            .AddSykiPolicy(GetCoursePotentialDisciplines, UserType.Manager, SykiPermissions.ManageCourses);
 30
 231        return builder;
 32    }
 33}

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

#LineLine coverage
 1namespace Syki.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            .AddSykiPolicy(GetHomeStats, UserType.Manager);
 11
 212        return builder;
 13    }
 14}

/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{
 8    /// <summary>
 9    /// Basta que o usuário esteja logado.
 10    /// </summary>
 11    public static AuthorizationBuilder AddSykiPolicy(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 AddSykiPolicy(this AuthorizationBuilder builder, string name, params SykiPermissi
 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 AddSykiPolicy(this AuthorizationBuilder builder, string name, UserType userType, 
 35    {
 23836        var ids = permissions.Select(x => x.Id).ToList();
 37
 24038        return builder.AddPolicy(name, policy => policy
 24039            .RequireAuthenticatedUser()
 476240            .RequireAssertion(x => x.User.Type == userType && x.User.Permissions.Any(p => ids.Contains(p)))
 24041            .AddAuthenticationSchemes(JwtBearerScheme.Name));
 42    }
 43}

/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 RemoveDisciplineCourse = nameof(RemoveDisciplineCourse);
 14    public const string GetDisciplinePotentialCourses = nameof(GetDisciplinePotentialCourses);
 15
 16    public static AuthorizationBuilder AddDisciplinesPolicies(this AuthorizationBuilder builder)
 17    {
 218        builder
 219            .AddSykiPolicy(GetDiscipline, UserType.Manager, SykiPermissions.ManageDisciplines)
 220            .AddSykiPolicy(GetDisciplines, UserType.Manager, SykiPermissions.ManageDisciplines)
 221            .AddSykiPolicy(CreateDiscipline, UserType.Manager, SykiPermissions.ManageDisciplines)
 222            .AddSykiPolicy(UpdateDiscipline, UserType.Manager, SykiPermissions.ManageDisciplines);
 23
 224        builder
 225            .AddSykiPolicy(AddDisciplineCourses, UserType.Manager, SykiPermissions.ManageDisciplines)
 226            .AddSykiPolicy(RemoveDisciplineCourse, UserType.Manager, SykiPermissions.ManageDisciplines)
 227            .AddSykiPolicy(GetDisciplinePotentialCourses, UserType.Manager, SykiPermissions.ManageDisciplines);
 28
 229        return builder;
 30    }
 31}

/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 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            .AddSykiPolicy(GetRole, UserType.Manager, SykiPermissions.ManageRoles)
 232            .AddSykiPolicy(GetRoles, UserType.Manager, SykiPermissions.ManageRoles)
 233            .AddSykiPolicy(CreateRole, UserType.Manager, SykiPermissions.ManageRoles)
 234            .AddSykiPolicy(UpdateRole, UserType.Manager, SykiPermissions.ManageRoles)
 235            .AddSykiPolicy(GetPermissions, UserType.Manager, SykiPermissions.ManageRoles)
 236            .AddSykiPolicy(GetDefaultRoles, UserType.Manager, SykiPermissions.ManageRoles)
 237            .AddSykiPolicy(GetInstitutionRoles, UserType.Manager, SykiPermissions.ManageRoles)
 238            .AddSykiPolicy(GetInstitutionRole, UserType.Manager, SykiPermissions.ManageRoles)
 239            .AddSykiPolicy(FilterInstitutionRoles, UserType.Manager, SykiPermissions.ManageRoles)
 240            .AddSykiPolicy(GetAvailableInstitutionRoles, UserType.Manager, SykiPermissions.ManageRoles);
 41
 242        builder
 243            .AddSykiPolicy(GetSsoConfiguration, UserType.Manager, SykiPermissions.ManageSso)
 244            .AddSykiPolicy(GetSsoConfigurations, UserType.Manager, SykiPermissions.ManageSso)
 245            .AddSykiPolicy(CreateSsoConfiguration, UserType.Manager, SykiPermissions.ManageSso)
 246            .AddSykiPolicy(UpdateSsoConfiguration, UserType.Manager, SykiPermissions.ManageSso);
 47
 248        builder
 249            .AddSykiPolicy(Logout)
 250            .AddSykiPolicy(SetupTwoFactor)
 251            .AddSykiPolicy(GetTwoFactorKey);
 52
 253        return builder;
 54    }
 55}

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

#LineLine coverage
 1namespace Syki.Back.Auth.Policies;
 2
 3public static partial class Policies
 4{
 5    public const string GetNotifications = nameof(GetNotifications);
 6    public const string MarkNotificationsAsViewed = nameof(MarkNotificationsAsViewed);
 7    public const string GetUnreadNotificationsCount = nameof(GetUnreadNotificationsCount);
 8
 9    public static AuthorizationBuilder AddNotificationsPolicies(this AuthorizationBuilder builder)
 10    {
 211        builder
 212            .AddSykiPolicy(GetNotifications)
 213            .AddSykiPolicy(MarkNotificationsAsViewed)
 214            .AddSykiPolicy(GetUnreadNotificationsCount);
 15
 216        return builder;
 17    }
 18}

/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, UserType.Manager, SykiPermissions.ManagePeriods)
 214            .AddSykiPolicy(CreateAcademicPeriod, UserType.Manager, 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 GetStudent = nameof(GetStudent);
 9    public const string CreateStudent = nameof(CreateStudent);
 10    public const string EnrollStudentInCourseOffering = nameof(EnrollStudentInCourseOffering);
 11
 12    public static AuthorizationBuilder AddStudentsPolicies(this AuthorizationBuilder builder)
 13    {
 214        builder
 215            .AddSykiPolicy(GetStudents, UserType.Manager, SykiPermissions.ManageStudents)
 216            .AddSykiPolicy(GetStudent, UserType.Manager, SykiPermissions.ManageStudents)
 217            .AddSykiPolicy(CreateStudent, UserType.Manager, SykiPermissions.ManageStudents)
 218            .AddSykiPolicy(EnrollStudentInCourseOffering, UserType.Manager, SykiPermissions.ManageStudents);
 19
 220        return builder;
 21    }
 22}

/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 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 static AuthorizationBuilder AddTeachersPolicies(this AuthorizationBuilder builder)
 17    {
 218        builder
 219            .AddSykiPolicy(GetTeacher, UserType.Manager, SykiPermissions.ManageTeachers)
 220            .AddSykiPolicy(GetTeachers, UserType.Manager, SykiPermissions.ManageTeachers)
 221            .AddSykiPolicy(CreateTeacher, UserType.Manager, SykiPermissions.ManageTeachers)
 222            .AddSykiPolicy(UpdateTeacher, UserType.Manager, SykiPermissions.ManageTeachers)
 223            .AddSykiPolicy(GetTeacherPotentialCampi, UserType.Manager, SykiPermissions.ManageTeachers)
 224            .AddSykiPolicy(GetTeacherPotentialDisciplines, UserType.Manager, SykiPermissions.ManageTeachers)
 225            .AddSykiPolicy(AssignCampiToTeacher, UserType.Manager, SykiPermissions.ManageTeachers)
 226            .AddSykiPolicy(AssignDisciplinesToTeacher, UserType.Manager, SykiPermissions.ManageTeachers);
 27
 228        return builder;
 29    }
 30}

/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}

/home/runner/work/syki/syki/Back/Auth/Policies/Policies.Webhooks.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 CreateWebhookSubscription = nameof(CreateWebhookSubscription);
 8    public const string GetWebhookSubscription = nameof(GetWebhookSubscription);
 9    public const string GetWebhookSubscriptions = nameof(GetWebhookSubscriptions);
 10    public const string UpdateWebhookSubscription = nameof(UpdateWebhookSubscription);
 11
 12    public static AuthorizationBuilder AddWebhooksPolicies(this AuthorizationBuilder builder)
 13    {
 214        builder
 215            .AddSykiPolicy(GetWebhookSubscription, UserType.Manager, SykiPermissions.ManageWebhooks)
 216            .AddSykiPolicy(GetWebhookSubscriptions, UserType.Manager, SykiPermissions.ManageWebhooks)
 217            .AddSykiPolicy(CreateWebhookSubscription, UserType.Manager, SykiPermissions.ManageWebhooks)
 218            .AddSykiPolicy(UpdateWebhookSubscription, UserType.Manager, SykiPermissions.ManageWebhooks);
 19
 220        return builder;
 21    }
 22}