django-spire 0.23.4__py3-none-any.whl

django_spire/auth/group/views/form_views.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from django.http import HttpResponseRedirect
+from django.shortcuts import get_object_or_404
+from django.urls import reverse
+
+import django_glue as dg
+
+from django_spire.auth.group import models, forms
+from django_spire.auth.group.utils import set_group_users
+from django_spire.auth.permissions.decorators import permission_required
+from django_spire.auth.user.models import AuthUser
+from django_spire.contrib.form.confirmation_forms import DeleteConfirmationForm
+from django_spire.contrib.form.utils import show_form_errors
+from django_spire.contrib.generic_views import portal_views
+from django_spire.core.shortcuts import get_object_or_null_obj
+from django_spire.history.activity.utils import add_form_activity
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.template.response import TemplateResponse
+
+
+@permission_required('django_spire_auth_group.change_authgroup')
+def form_view(
+    request: WSGIRequest,
+    pk: int = 0
+) -> TemplateResponse | HttpResponseRedirect:
+    group = get_object_or_null_obj(models.AuthGroup, pk=pk)
+
+    dg.glue_model_object(request, 'group', group)
+
+    if request.method == 'POST':
+        form = forms.GroupForm(request.POST, instance=group)
+
+        if form.is_valid():
+            group = form.save()
+            add_form_activity(group, pk, request.user)
+
+            return_url = reverse('django_spire:auth:group:page:list')
+            return HttpResponseRedirect(return_url)
+
+        show_form_errors(request, form)
+
+    form = forms.GroupForm(instance=group)
+
+    context_data = {'group': group}
+
+    return portal_views.model_form_view(
+        request,
+        form=form,
+        context_data=context_data,
+        template='django_spire/auth/group/page/form_page.html',
+        obj=group,
+    )
+
+
+@permission_required('django_spire_auth_group.add_authgroup')
+def user_form_view(
+    request: WSGIRequest,
+    pk: int
+) -> TemplateResponse | HttpResponseRedirect:
+    group = get_object_or_404(models.AuthGroup, pk=pk)
+    user_choices = AuthUser.services.get_user_choices()
+
+    selected_user_ids = list(
+        AuthUser.objects
+        .filter(groups=group)
+        .values_list('id', flat=True)
+        .distinct()
+    )
+
+    if request.method == 'POST':
+        form = forms.GroupUserForm(data=request.POST)
+
+        if form.is_valid():
+            user_list = form.cleaned_data.get('users')
+            set_group_users(group, user_list)
+
+            group.add_activity(
+                user=request.user,
+                verb='added',
+                information=(
+                    f'{request.user.get_full_name()} added {len(user_list)} users to '
+                    f'the group "{group.name}".'
+                )
+            )
+
+            return_url = reverse('django_spire:auth:group:page:detail', kwargs={'pk': pk})
+            return HttpResponseRedirect(return_url)
+
+        show_form_errors(request, form)
+
+    form = forms.GroupUserForm()
+
+    def crumbs(breadcrumbs) -> None:
+        breadcrumbs.add_breadcrumb(name='Edit Users')
+
+    context_data = {
+        'group': group,
+        'user_choices': user_choices,
+        'selected_user_ids': selected_user_ids
+    }
+
+    return portal_views.form_view(
+        request,
+        form=form,
+        obj=group,
+        template='django_spire/auth/group/page/group_user_form_page.html',
+        context_data=context_data,
+        breadcrumbs_func=crumbs,
+    )
+
+
+@permission_required('django_spire_auth_group.delete_authgroup')
+def delete_form_view(request: WSGIRequest, pk: int) -> TemplateResponse:
+    group = get_object_or_404(models.AuthGroup, pk=pk)
+    return_url = reverse('django_spire:auth:group:page:list')
+
+    return portal_views.delete_form_view(
+        request,
+        obj=group,
+        delete_func=group.delete,
+        activity_func=lambda: None,
+        return_url=return_url
+    )
+
+
+@permission_required('django_spire_auth_group.delete_authgroup')
+def group_remove_user_form_view(
+    request: WSGIRequest,
+    group_pk: int,
+    pk: int
+) -> HttpResponseRedirect | TemplateResponse:
+    group = get_object_or_404(models.AuthGroup, pk=group_pk)
+    user = get_object_or_404(AuthUser, pk=pk)
+
+    if request.method == 'POST':
+        form = DeleteConfirmationForm(request.POST, obj=user)
+
+        if form.is_valid():
+            user.groups.remove(group)
+
+            group.add_activity(
+                user=request.user,
+                verb='removed',
+                information=(
+                    f'{request.user.get_full_name()} removed {user.get_full_name()} '
+                    f'from the group "{group.name}".'
+                )
+            )
+
+            return HttpResponseRedirect(
+                reverse(
+                    'django_spire:auth:group:page:detail',
+                    kwargs={'pk': group_pk}
+                )
+            )
+
+    form = DeleteConfirmationForm(request.GET, obj=user)
+
+    def get_breadcrumbs(breadcrumbs) -> None:
+        breadcrumbs = group.breadcrumbs()
+        breadcrumbs.add_breadcrumb(name=user.get_full_name())
+        breadcrumbs.add_breadcrumb(name='Remove')
+
+    return portal_views.form_view(
+        request,
+        form=form,
+        verb=f'remove {user.get_full_name()} from',
+        obj=group,
+        breadcrumbs_func=get_breadcrumbs,
+        template = 'django_spire/page/delete_confirmation_form_page.html'
+    )

django_spire/auth/group/views/json_views.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from django.core.handlers.wsgi import WSGIRequest
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404
+from django.views.decorators.http import require_POST
+
+from django_spire.auth.group import models
+from django_spire.auth.group.utils import perm_level_to_int, perm_level_to_django_permission
+from django_spire.auth.permissions.decorators import permission_required
+from django_spire.auth.permissions.permissions import GroupPermissions
+from django_spire.auth.permissions.tools import generate_model_permissions, generate_model_key_permission_map
+from django_spire.core.shortcuts import process_request_body
+
+
+@require_POST
+@permission_required('django_spire_auth_group.change_authgroup')
+def permission_form_ajax(
+    request: WSGIRequest,
+    pk: int,
+    app_name: str
+) -> JsonResponse:
+    if request.method == 'POST':
+        error_message = 'App Does Not Exist.'
+
+        permission_map = generate_model_key_permission_map()
+
+        if app_name.lower() in permission_map:
+            model_permission = permission_map[app_name.lower()]
+            body = process_request_body(request, key=None)
+            perm_level = perm_level_to_int(body.get('perm_level'))
+            error_message = 'Please provide a valid permission level'
+
+            if isinstance(perm_level, int) and 4 >= perm_level >= 0:
+                group = get_object_or_404(models.AuthGroup, pk=pk)
+                group_perm_helper = GroupPermissions(group, model_permission=model_permission)
+
+                django_permission_verbose = perm_level_to_django_permission(
+                    perm_level=perm_level,
+                    app_label=group_perm_helper.model_permissions.app_label,
+                    model_name=group_perm_helper.model_permissions.model_name
+                )
+
+                error_message = 'You do not have permission to change this app.'
+
+                if request.user.has_perm(django_permission_verbose) or perm_level == 0:
+                    group_perm_helper.update_perms(perm_level)
+                    return JsonResponse({'message': 'Updated Successfully!', 'status': 200})
+
+    return JsonResponse({'message': error_message, 'status': 400})
+
+
+@require_POST
+@permission_required('django_spire_auth_group.change_authgroup')
+def special_role_form_ajax(
+    request: WSGIRequest,
+    pk: int,
+    app_name: str
+) -> JsonResponse:
+    if request.method == 'POST':
+        error_message = 'App Does Not Exist.'
+
+        permission_map = generate_model_key_permission_map()
+
+        if app_name.lower() in permission_map:
+            model_permission = permission_map[app_name.lower()]
+            body = process_request_body(request, key=None)
+            grant_special_role_access = body.get('grant_special_role_access')
+            codename = body.get('codename')
+            error_message = 'models.PortalUser does not have permission.'
+
+            if request.user.has_perm('django_spire_auth_group.change_authgroup'):
+                group = get_object_or_404(models.AuthGroup, pk=pk)
+                group_perm_helper = GroupPermissions(group, model_permission=model_permission)
+
+                if grant_special_role_access:
+                    group_perm_helper.add_special_role(codename)
+                else:
+                    group_perm_helper.remove_special_role(codename)
+
+                return JsonResponse({'message': 'Updated Successfully!', 'status': 200})
+
+    return JsonResponse({'message': error_message, 'status': 400})

django_spire/auth/group/views/page_views.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.shortcuts import get_object_or_404
+
+from django_spire.auth.group import models
+from django_spire.auth.permissions.decorators import permission_required
+from django_spire.auth.permissions.tools import generate_group_perm_data
+from django_spire.contrib.generic_views import portal_views
+from django_spire.contrib.pagination.pagination import paginate_list
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.template.response import TemplateResponse
+
+
+@permission_required('django_spire_auth_group.view_authgroup')
+def detail_view(request: WSGIRequest, pk: int) -> TemplateResponse:
+    group = get_object_or_404(models.AuthGroup, pk=pk)
+
+    active_user_list = group.user_set.filter(is_active=True).order_by('first_name', 'last_name')
+    inactive_user_list = group.user_set.filter(is_active=False).order_by('first_name', 'last_name')
+
+    paginated_active_user_list = paginate_list(active_user_list, page_number=request.GET.get('page', 1), per_page=10)
+    paginated_inactive_user_list = paginate_list(inactive_user_list, page_number=request.GET.get('page', 1), per_page=10)
+
+    context_data = {
+        'group': group,
+        'permission_data': generate_group_perm_data(group, with_special_role=True),
+        'active_user_list': paginated_active_user_list,
+        'inactive_user_list': paginated_inactive_user_list,
+    }
+
+    return portal_views.detail_view(
+        request,
+        context_data=context_data,
+        obj=group,
+        template='django_spire/auth/group/page/detail_page.html'
+    )
+
+
+@permission_required('django_spire_auth_group.view_authgroup')
+def list_view(request: WSGIRequest) -> TemplateResponse:
+    group_list = models.AuthGroup.objects.all().prefetch_related('permissions').order_by('name')
+
+    context_data = {
+        'group_list': group_list,
+        'group_list_permission_data': [
+            generate_group_perm_data(group)
+            for group in group_list
+        ]
+    }
+
+    return portal_views.list_view(
+        request,
+        context_data=context_data,
+        model=models.AuthGroup,
+        template='django_spire/auth/group/page/list_page.html'
+    )

django_spire/auth/mfa/admin.py

@@ -0,0 +1,21 @@
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.html import format_html
+
+from django_spire.auth.mfa import models
+
+
+@admin.register(models.MfaCode)
+class MfaCodeAdmin(admin.ModelAdmin):
+    list_display = (
+        'id', 'user_link', 'code', 'expiration_datetime', 'is_valid'
+    )
+    list_filter = ('expiration_datetime',)
+    search_fields = ('id', 'user__username', 'code')
+    ordering = ('-expiration_datetime',)
+
+    def user_link(self, mfa_code: models.MfaCode) -> str:
+        url = reverse('admin:auth_user_change', args=[mfa_code.user.id])
+        return format_html(f'<a href="{url}">{mfa_code.user.username}</a>')
+
+    user_link.short_description = 'User'

django_spire/auth/mfa/apps.py

@@ -0,0 +1,15 @@
+from django.apps import AppConfig
+
+from django_spire.utils import check_required_apps
+
+
+class MfaConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    label = 'django_spire_auth_mfa'
+    name = 'django_spire.auth.mfa'
+
+
+    REQUIRED_APPS = ('django_spire_core', 'django_spire_auth')
+
+    def ready(self) -> None:
+        check_required_apps(self.label)

django_spire/auth/mfa/forms.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from django import forms
+
+class MFAForm(forms.Form):
+    pass
+    # def __init__(self, generated_mfa_code, *args, **kwargs):
+    #     super().__init__(*args, **kwargs)
+    #
+    #     self.helper = FormHelper(self)
+    #     self.helper.include_media = False
+    #     self.generated_mfa_code = generated_mfa_code
+    #     self.fields['mfa_code'] = forms.CharField(max_length=6, label='Authentication Code')
+    #
+    #     self.helper.layout = Layout(
+    #         Row(
+    #             Column('mfa_code', css_class='form-group col-12'),
+    #         ),
+    #         HTML("{% include 'django_spire/contrib/form/form_submit_button.html' %}")
+    #     )
+
+    def clean(self) -> None:
+        cleaned_data = super().clean()
+
+        mfa_code = cleaned_data.get('mfa_code')
+
+        if mfa_code != self.generated_mfa_code.code:
+            self.add_error('mfa_code', 'Invalid MFA Code.')

django_spire/auth/mfa/migrations/0001_initial.py

@@ -0,0 +1,31 @@
+# Generated by Django 5.2 on 2025-04-23 17:23
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='MfaCode',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(editable=False, max_length=6, unique=True)),
+                ('expiration_datetime', models.DateTimeField(editable=False)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='mfa_codes', related_query_name='mfa_code', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'MFA Code',
+                'verbose_name_plural': 'MFA Codes',
+                'db_table': 'django_spire_authentication_mfa_code',
+            },
+        ),
+    ]

django_spire/auth/mfa/models.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import random
+
+from dateutil import relativedelta
+
+from django.contrib.auth.models import User
+from django.contrib.sites.models import Site
+from django.db import models
+from django.urls import reverse
+from django.utils.timezone import localtime
+
+from django_spire.notification.email.helper import SendGridEmailHelper
+from django_spire.auth.mfa.querysets import MfaCodeQuerySet
+
+
+class MfaCode(models.Model):
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_query_name='mfa_code', related_name='mfa_codes')
+    code = models.CharField(max_length=6, editable=False, unique=True)
+    expiration_datetime = models.DateTimeField(editable=False)
+
+    objects = MfaCodeQuerySet.as_manager()
+
+    def __str__(self):
+        return f'{self.expiration_datetime} - {self.code}'
+
+    def is_valid(self) -> bool:
+        return self.expiration_datetime > localtime()
+
+    def set_expired(self) -> None:
+        self.expiration_datetime = localtime()
+        self.save()
+
+    def send_notification(self):
+        user = self.user
+
+        context_data = {
+            'title': 'Authentication Code',
+            'body': f"Here is your multifactor authentication code: </br> <h3>{self.code}</h3>",
+            'name': user.first_name,
+            'button_url': f'{Site.objects.get_current()}/{reverse("authentication:redirect:login_redirect")[1:]}'
+        }
+
+        # Directly connecting to SendGrid to send MFA email faster
+        SendGridEmailHelper(
+            to=[user.email],
+            template_id='d-9ae6be6be95d4f79b0daad9055f03cc9',
+            template_data=context_data,
+            fail_silently=False
+        ).send()
+
+    @classmethod
+    def generate_code(cls, user):
+        return MfaCode.objects.create(
+            user=user,
+            code=int(''.join([str(random.randint(0, 9)) for _ in range(6)])),
+            expiration_datetime=localtime() + relativedelta.relativedelta(minutes=5)
+        )
+
+    class Meta:
+        db_table = 'django_spire_authentication_mfa_code'
+        verbose_name = 'MFA Code'
+        verbose_name_plural = 'MFA Codes'

django_spire/auth/mfa/querysets.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from django.db.models import QuerySet
+from django.utils.timezone import localtime
+
+
+class MfaCodeQuerySet(QuerySet):
+    def valid_code(self, user):
+        return self.filter(user=user, expiration_datetime__gte=localtime()).first()

django_spire/auth/mfa/urls/__init__.py

@@ -0,0 +1,9 @@
+from django.urls import include, path
+
+
+app_name = 'mfa'
+
+urlpatterns  = [
+    path('', include('django_spire.auth.mfa.urls.page_urls', namespace='page')),
+    path('', include('django_spire.auth.mfa.urls.redirect_urls', namespace='redirect')),
+]

django_spire/auth/mfa/urls/page_urls.py

@@ -0,0 +1,12 @@
+from django.urls import path
+
+from django_spire.auth.mfa.views import page_views
+
+
+app_name = 'page'
+
+urlpatterns = [
+    path('form/',
+         page_views.mfa_form_view,
+         name='form'),
+]

django_spire/auth/mfa/urls/redirect_urls.py

@@ -0,0 +1,12 @@
+from django.urls import path
+
+from django_spire.auth.mfa.views import redirect_views
+
+
+app_name = 'redirect'
+
+urlpatterns = [
+    path('notification/',
+         redirect_views.mfa_notification_redirect_view,
+         name='notification'),
+]

django_spire/auth/mfa/utils.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.auth.mfa.models import MfaCode
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+
+
+def get_or_generate_user_mfa_code(user: User) -> MfaCode:
+    mfa_code = MfaCode.objects.valid_code(user)
+
+    if mfa_code:
+        return mfa_code
+
+    return MfaCode.generate_code(user)

django_spire/auth/mfa/views/page_views.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from django.contrib import messages
+from django.http import HttpResponseRedirect
+from django.template.response import TemplateResponse
+from django.urls import reverse
+
+from django_spire.auth.mfa.utils import get_or_generate_user_mfa_code
+from django_spire.auth.mfa import forms
+
+
+def mfa_form_view(request):
+    mfa_code = get_or_generate_user_mfa_code(request.user)
+    profile = request.user.profile
+
+    if request.method == 'POST':
+        form = forms.MFAForm(mfa_code, request.POST)
+        if form.is_valid():
+            mfa_code.set_expired()
+            profile.set_mfa_grace_period()
+            return HttpResponseRedirect(reverse('home:page:home'))
+
+        if 'mfa_code' in form.errors:
+            messages.error(request, form.errors['mfa_code'][0])
+
+    context_data = {
+        'form': forms.MFAForm(mfa_code, initial=request.POST),
+        'form_description': 'An authentication code has been sent to your email. Please enter it below to continue.',
+    }
+
+    return TemplateResponse(
+        request,
+        context=context_data,
+        template='django_spire/auth/mfa/mfa_form.html'
+    )

django_spire/auth/mfa/views/redirect_views.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from django.contrib import messages
+from django.http import HttpResponseRedirect
+from django.urls import reverse
+
+from django_spire.auth.mfa.utils import get_or_generate_user_mfa_code
+
+
+def mfa_notification_redirect_view(request):
+    mfa_code = get_or_generate_user_mfa_code(request.user)
+
+    if request.GET.get('resend', False):
+        mfa_code.set_expired()
+        mfa_code = get_or_generate_user_mfa_code(request.user)
+
+    mfa_code.send_notification()
+    messages.info(request, 'A authentication code has been sent to your email.')
+
+    return HttpResponseRedirect(reverse('auth:mfa:page:form'))

django_spire/auth/permissions/consts.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from django_spire.auth.group.models import AuthGroup
+from django_spire.auth.user.models import AuthUser
+
+
+PERMISSIONS_LEVEL_CHOICES = (
+    (0, 'None'),
+    (1, 'View'),
+    (2, 'Add'),
+    (3, 'Change'),
+    (4, 'Delete'),
+)
+
+
+VALID_PERMISSION_LEVELS = Literal[0, 1, 2, 3, 4]
+
+
+# PERMISSION_MODELS_DICT = {
+#     'group': {
+#         'model': AuthGroup,
+#         'is_proxy_model': True
+#     },
+#     'user': {
+#         'model': AuthUser,
+#         'is_proxy_model': True
+#     }
+# }