zango 0.2.1b0__tar.gz → 0.2.2.dev0__tar.gz

zango-0.2.2.dev0/MANIFEST.in

@@ -0,0 +1 @@
+include requirements/base.txt

{zango-0.2.1b0 → zango-0.2.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zango
-Version: 0.2.1b0
+Version: 0.2.2.dev0
 Summary: Zango: multi-tenant Django framework for building business apps
 Home-page: https://github.com/Healthlane-Technologies/zelthy3
 Author: Zelthy ("Healthlane Technologies")
@@ -48,6 +48,7 @@ Requires-Dist: python3-saml==1.16.0
 Requires-Dist: django-ipware==7.0.1
 Requires-Dist: django-decorator-include==3.0
 Requires-Dist: setuptools==70.1.1
+Requires-Dist: django-axes==6.4.0
 
 <h1 align="center">
     <a target="_blank" href="https://www.zelthy.com/framework?referer=zelthy3-repo-landing"> 

zango-0.2.1b0/src/zango.egg-info/requires.txt → zango-0.2.2.dev0/requirements/base.txt

@@ -34,3 +34,4 @@ python3-saml==1.16.0
 django-ipware==7.0.1
 django-decorator-include==3.0
 setuptools==70.1.1
+django-axes==6.4.0

{zango-0.2.1b0 → zango-0.2.2.dev0}/setup.py

@@ -8,7 +8,7 @@ REQUIREMENTS_DIR = os.path.join(PROJECT_DIR, "requirements")
 
 README = os.path.join(PROJECT_DIR, "README.md")
 
-PLATFORM_VERSION = "0.2.1.beta"
+PLATFORM_VERSION = "0.2.2.dev"
 
 
 def get_requirements(env):

{zango-0.2.1b0 → zango-0.2.2.dev0}/src/zango/__init__.py

@@ -1,3 +1,3 @@
 from zango.core import internal_requests
 
-__version__ = "0.2.1"
+__version__ = "0.2.2.dev"

zango-0.2.2.dev0/src/zango/api/platform/accesslogs/v1/serializers.py

@@ -0,0 +1,47 @@
+from rest_framework import serializers
+
+from zango.apps.accesslogs.models import AppAccessLog
+from zango.core.utils import get_datetime_str_in_tenant_timezone
+
+
+class AccessLogSerializerModel(serializers.ModelSerializer):
+    user = serializers.SerializerMethodField()
+    role = serializers.SerializerMethodField()
+    attempt_time = serializers.SerializerMethodField()
+    session_expired_at = serializers.SerializerMethodField()
+
+    def get_attempt_time(self, obj):
+        if obj.attempt_time:
+            return get_datetime_str_in_tenant_timezone(
+                obj.attempt_time, self.context["tenant"]
+            )
+        return "NA"
+
+    def get_session_expired_at(self, obj):
+        if obj.session_expired_at:
+            return get_datetime_str_in_tenant_timezone(
+                obj.session_expired_at, self.context["tenant"]
+            )
+
+        return "NA"
+
+    def get_user(self, obj):
+        return f"{obj.user.name} ({obj.user.id})" if obj.user else "NA"
+
+    def get_role(self, obj):
+        return obj.role.name if obj.role else "NA"
+
+    class Meta:
+        model = AppAccessLog
+        fields = [
+            "id",
+            "ip_address",
+            "user",
+            "username",
+            "attempt_type",
+            "attempt_time",
+            "role",
+            "user_agent",
+            "is_login_successful",
+            "session_expired_at",
+        ]

zango-0.2.2.dev0/src/zango/api/platform/accesslogs/v1/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from zango.api.platform.accesslogs.v1.views import AccessLogViewAPIV1
+
+urlpatterns = [
+    path(
+        "",
+        AccessLogViewAPIV1.as_view(),
+        name="accesslog-apiv1-accessloglistview",
+    ),
+]

zango-0.2.2.dev0/src/zango/api/platform/accesslogs/v1/views.py

@@ -0,0 +1,183 @@
+import csv
+import json
+import pytz
+import traceback
+from datetime import datetime
+
+from django.db.models import Q
+from django.utils.decorators import method_decorator
+
+from zango.core.utils import get_search_columns
+from zango.core.api.utils import ZangoAPIPagination
+from zango.apps.accesslogs.models import AppAccessLog
+from zango.core.common_utils import set_app_schema_path
+from zango.apps.shared.tenancy.models import TenantModel
+from zango.core.api import get_api_response, ZangoGenericPlatformAPIView
+
+from zango.api.platform.accesslogs.v1.serializers import AccessLogSerializerModel
+
+
+@method_decorator(set_app_schema_path, name="dispatch")
+class AccessLogViewAPIV1(ZangoGenericPlatformAPIView, ZangoAPIPagination):
+    pagination_class = ZangoAPIPagination
+
+    def process_timestamp(self, timestamp, timezone):
+        try:
+            ts = json.loads(timestamp)
+            tz = pytz.timezone(timezone)
+            ts["start"] = tz.localize(
+                datetime.strptime(ts["start"] + "-" + "00:00", "%Y-%m-%d-%H:%M"),
+                is_dst=None,
+            )
+            ts["end"] = tz.localize(
+                datetime.strptime(ts["end"] + "-" + "23:59", "%Y-%m-%d-%H:%M"),
+                is_dst=None,
+            )
+            return ts
+        except Exception:
+            return None
+
+    def process_id(self, id):
+        try:
+            return int(id)
+        except ValueError:
+            return None
+
+    def get_queryset(self, search, tenant, columns={}):
+        field_name_query_mapping = {
+            "id": "id",
+            "user": "user__name__icontains",
+            "username": "username__icontains",
+            "user_agent": "user_agent__icontains",
+            "ip_address": "ip_address__icontains",
+            "attempt_type": "attempt_type__icontains",
+            "role": "role__name__icontains",
+            "user_id": "user_id",
+        }
+        search_filters = {
+            "id": self.process_id,
+            "attempt_time": self.process_timestamp,
+            "session_expired_at": self.process_timestamp,
+        }
+
+        records = AppAccessLog.objects.all().order_by("-id")
+
+        if search == "" and columns == {}:
+            return records
+
+        filters = Q()
+        for field_name, query in field_name_query_mapping.items():
+            if search:
+                if search_filters.get(field_name, None):
+                    filters |= Q(**{query: search_filters[field_name](search)})
+                else:
+                    if field_name == "user_id":
+                        try:
+                            filters |= Q(**{query: int(search)})
+                        except ValueError:
+                            pass
+                    else:
+                        filters |= Q(**{query: search})
+        records = records.filter(filters).distinct()
+
+        if columns.get("attempt_time"):
+            processed = self.process_timestamp(
+                columns.get("attempt_time"), tenant.timezone
+            )
+            if processed is not None:
+                records = records.filter(
+                    attempt_time__gte=processed["start"],
+                    attempt_time__lte=processed["end"],
+                )
+
+        if columns.get("session_expired_at"):
+            processed = self.process_timestamp(
+                columns.get("session_expired_at"), tenant.timezone
+            )
+            if processed is not None:
+                records = records.filter(
+                    session_expired_at__gte=processed["start"],
+                    session_expired_at__lte=processed["end"],
+                )
+        if columns.get("attempt_type"):
+            records = records.filter(attempt_type=columns.get("attempt_type"))
+
+        if columns.get("is_login_successful") != None:
+            if columns.get("is_login_successful") == "successful":
+                records = records.filter(is_login_successful=True)
+            elif columns.get("is_login_successful") == "failed":
+                records = records.filter(is_login_successful=False)
+
+        if columns.get("role"):
+            records = records.filter(role=columns.get("role"))
+
+        return records
+
+    def get_dropdown_options(self):
+        options = {"role": []}
+        options["attempt_type"] = [
+            {
+                "id": "login",
+                "label": "Login",
+            },
+            {
+                "id": "switch_role",
+                "label": "Switch Role",
+            },
+        ]
+        options["is_login_successful"] = [
+            {
+                "id": "successful",
+                "label": "Successful",
+            },
+            {
+                "id": "failed",
+                "label": "Failed",
+            },
+        ]
+        role_list = list(
+            AppAccessLog.objects.all()
+            .values_list("role__id", "role__name")
+            .order_by("role__name")
+            .distinct()
+        )
+        for user_role in role_list:
+            options["role"].append(
+                {
+                    "id": user_role[0],
+                    "label": user_role[1],
+                }
+            )
+        return options
+
+    def get(self, request, *args, **kwargs):
+        try:
+            app_uuid = kwargs.get("app_uuid")
+            tenant = TenantModel.objects.get(uuid=app_uuid)
+            include_dropdown_options = request.GET.get("include_dropdown_options")
+            search = request.GET.get("search", None)
+            columns = get_search_columns(request)
+            access_logs = self.get_queryset(search, tenant, columns)
+            paginated_access_logs = self.paginate_queryset(
+                access_logs, request, view=self
+            )
+            serializer = AccessLogSerializerModel(
+                paginated_access_logs, many=True, context={"tenant": tenant}
+            )
+            accesslogs = self.get_paginated_response_data(serializer.data)
+            success = True
+            response = {
+                "access_logs": accesslogs,
+                "message": "Access logs fetched successfully",
+            }
+            if include_dropdown_options:
+                response["dropdown_options"] = self.get_dropdown_options()
+
+            status = 200
+
+        except Exception as e:
+            traceback.print_exc()
+            success = False
+            response = {"message": str(e)}
+            status = 500
+        return get_api_response(success, response, status)

{zango-0.2.1b0 → zango-0.2.2.dev0}/src/zango/api/platform/tenancy/v1/urls.py

@@ -16,6 +16,7 @@ from zango.api.platform.packages.v1 import urls as packages_v1_urls
 from zango.api.platform.tasks.v1 import urls as tasks_v1_urls
 from zango.api.platform.codeassist.v1 import urls as codeassist_v1_urls
 from zango.api.platform.auditlogs.v1 import urls as auditlog_v1_urls
+from zango.api.platform.accesslogs.v1 import urls as accesslog_v1_urls
 
 
 urlpatterns = [
@@ -59,5 +60,6 @@ urlpatterns = [
     re_path(r"^(?P<app_uuid>[\w-]+)/tasks/", include(tasks_v1_urls)),
     re_path(r"^(?P<app_uuid>[\w-]+)/code-assist/", include(codeassist_v1_urls)),
     re_path(r"^(?P<app_uuid>[\w-]+)/auditlog/", include(auditlog_v1_urls)),
+    re_path(r"^(?P<app_uuid>[\w-]+)/access-logs/", include(accesslog_v1_urls)),
     path("", include(permissions_v1_urls)),
 ]

zango-0.2.2.dev0/src/zango/apps/accesslogs/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class AccesslogsAppConfig(AppConfig):
+
+    name = "zango.apps.accesslogs"
+
+    def ready(self):
+        import zango.apps.accesslogs.signals

zango-0.2.2.dev0/src/zango/apps/accesslogs/migrations/0001_accesslogs.py

@@ -0,0 +1,86 @@
+# Generated by Django 4.2.11 on 2024-04-12 09:20
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("appauth", "0006_appusermodel_app_objects"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="AppAccessLog",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "user_agent",
+                    models.CharField(
+                        db_index=True, max_length=255, verbose_name="User Agent"
+                    ),
+                ),
+                (
+                    "ip_address",
+                    models.GenericIPAddressField(
+                        db_index=True, null=True, verbose_name="IP Address"
+                    ),
+                ),
+                (
+                    "username",
+                    models.CharField(
+                        db_index=True,
+                        max_length=255,
+                        null=True,
+                        verbose_name="Username",
+                    ),
+                ),
+                (
+                    "http_accept",
+                    models.CharField(max_length=1025, verbose_name="HTTP Accept"),
+                ),
+                ("path_info", models.CharField(max_length=255, verbose_name="Path")),
+                (
+                    "attempt_time",
+                    models.DateTimeField(
+                        auto_now_add=True, verbose_name="Attempt Time"
+                    ),
+                ),
+                ("attempt_type", models.CharField(max_length=20, null=True)),
+                ("is_login_successful", models.BooleanField(default=False)),
+                ("session_expired_at", models.DateTimeField(blank=True, null=True)),
+                (
+                    "role",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="appauth.userrolemodel",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="appauth.appusermodel",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["-attempt_time"],
+                "abstract": False,
+            },
+        ),
+    ]

zango-0.2.2.dev0/src/zango/apps/accesslogs/models.py

@@ -0,0 +1,18 @@
+from django.db import models
+from axes.models import AccessBase
+
+from zango.apps.appauth.models import AppUserModel, UserRoleModel
+
+
+class AppAccessLog(AccessBase):
+
+    user = models.ForeignKey(AppUserModel, null=True, on_delete=models.CASCADE)
+    role = models.ForeignKey(
+        UserRoleModel, null=True, blank=True, on_delete=models.CASCADE
+    )
+    attempt_type = models.CharField(max_length=20, null=True)
+    is_login_successful = models.BooleanField(default=False)
+    session_expired_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta(AccessBase.Meta):
+        app_label = "accesslogs"

zango-0.2.2.dev0/src/zango/apps/accesslogs/signals.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+from datetime import datetime
+
+from django.db import connection
+from ipware import get_client_ip
+from django.dispatch import receiver
+from axes.helpers import get_client_user_agent
+from django.contrib.auth.signals import (
+    user_logged_out,
+    user_login_failed,
+    user_logged_in,
+)
+
+from zango.apps.accesslogs.models import AppAccessLog
+from zango.apps.appauth.models import UserRoleModel
+from zango.core.utils import get_current_request
+
+
+@receiver(user_login_failed)
+def login_failure_handler(sender, **kwargs):
+    if connection.tenant.tenant_type == "app":
+        creds = kwargs.get("credentials", {})
+        request = kwargs.get("request", get_current_request())
+        client_ip, is_routable = get_client_ip(request)
+        access_log = AppAccessLog.objects.create(
+            ip_address=client_ip,
+            http_accept=request.META.get("HTTP_ACCEPT", "<unknown>"),
+            path_info=request.META.get("PATH_INFO", "<unknown>"),
+            user_agent=get_client_user_agent(request),
+            username=creds.get("username"),
+            attempt_time=datetime.now(),
+            attempt_type="login",
+            is_login_successful=False,
+        )
+
+
+@receiver(user_logged_in)
+def user_logged_in_handler(sender, request, user, **kwargs):
+    if connection.tenant.tenant_type == "app":
+        try:
+            client_ip, is_routable = get_client_ip(request)
+            username = request.user.email if request.user.email else request.user.mobile
+            user_role = None
+            access_log = AppAccessLog.objects.create(
+                ip_address=client_ip,
+                http_accept=request.META.get("HTTP_ACCEPT", "<unknown>"),
+                path_info=request.META.get("PATH_INFO", "<unknown>"),
+                username=username,
+                user_agent=get_client_user_agent(request),
+                attempt_time=datetime.now(),
+                attempt_type="login",
+                is_login_successful=True,
+                user=user,
+            )
+
+            if getattr(request, "selected_role_id", ""):
+                user_role = UserRoleModel.objects.filter(
+                    id=getattr(request, "selected_role_id")
+                ).last()
+
+            if user_role:
+                access_log.role = user_role
+                access_log.save()
+        except:
+            import traceback
+
+            print(traceback.format_exc())
+
+
+@receiver(user_logged_out)
+def user_logged_out_handler(sender, user, **kwargs):
+    if connection.tenant.tenant_type == "app":
+        access_log = AppAccessLog.objects.filter(
+            user=user, session_expired_at__isnull=True
+        ).order_by("-id").first()
+
+        if access_log:
+            access_log.session_expired_at = datetime.now()
+            access_log.save()

zango-0.2.2.dev0/src/zango/apps/accesslogs/utils.py

@@ -0,0 +1,76 @@
+import re
+
+from django.contrib.auth import signals
+from django.db import connection
+from axes.handlers.proxy import AxesProxyHandler
+from django.http import HttpResponseForbidden, HttpResponse
+
+from zango.apps.appauth.models import AppUserModel
+
+
+def capture_failed_login_attempt(request, credentials):
+    """
+    Capture and handle a failed login attempt.
+    Parameters:
+    - request (HttpRequest): The HTTP request object.
+    - credentials (dict): A dictionary containing the login credentials, with the username as the key.
+    Returns:
+    None
+    """
+
+    try:
+
+        username_type, username = "", credentials.get("username", "")
+        if re.match(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$", username):
+            username_type = "email"
+
+        elif re.match(r"^\+[1-9]\d{1,14}$", username):
+            username_type = "mobile"
+
+        if username_type:
+            filter_query = {username_type: username}
+            app_user = AppUserModel.objects.filter(**filter_query).last()
+            if app_user:
+                signals.user_login_failed.send(
+                    sender=app_user,
+                    request=request,
+                    credentials=credentials,
+                )
+    except:
+        import traceback
+
+        print(traceback.format_exc())
+
+
+def user_authentication_failed(request, credentials):
+    """
+    This function handles the case when user authentication fails.
+    It captures the failed login attempt by calling the 'capture_failed_login_attempt' function with
+    the given request and credentials.
+    Parameters:
+    - request: The HTTP request object.
+    - credentials: A dictionary containing the user's credentials.
+    Returns:
+    If the request is not allowed by the AxesProxyHandler, it returns a dictionary with the following keys:
+    - 'is_locked': True
+    - 'message': "Account locked"
+    - 'status': The HTTP status code for HttpResponseForbidden
+    If the request is allowed by the AxesProxyHandler, it returns a dictionary with the following keys:
+    - 'is_locked': False
+    - 'message': "This account is permitted to log in"
+    - 'status': The HTTP status code for HttpResponse
+    """
+    capture_failed_login_attempt(request, credentials)
+
+    if not AxesProxyHandler.is_allowed(request):
+        return {
+            "is_locked": True,
+            "message": "Account locked",
+            "status": HttpResponseForbidden.status_code,
+        }
+    else:
+        return {
+            "is_locked": False,
+            "message": "This account is permitted to log in",
+            "status": HttpResponse.status_code,
+        }

{zango-0.2.1b0 → zango-0.2.2.dev0}/src/zango/apps/appauth/auth_backend.py

@@ -1,4 +1,5 @@
 """Defines which authentication backend for app users."""
+
 from django.contrib.auth.backends import ModelBackend
 from django.db.models import Q
 from django.db import connection
@@ -9,16 +10,15 @@ from django.contrib.auth.models import User
 
 class AppUserModelBackend(ModelBackend):
     def authenticate(self, request, username=None, password=None):
-
-        try:
-            user = AppUserModel.objects.get(Q(email=username) | Q(mobile=username))
-            pwd_valid = user.check_password(password)
-            if pwd_valid and user.is_active:
-                return user
-            return None
-        except AppUserModel.DoesNotExist:
-            return None
-
+        if request and request.tenant.tenant_type == "app":
+            try:
+                user = AppUserModel.objects.get(Q(email=username) | Q(mobile=username))
+                pwd_valid = user.check_password(password)
+                if pwd_valid and user.is_active:
+                    return user
+                return None
+            except AppUserModel.DoesNotExist:
+                return None
 
     def get_user(self, user_id):
         """

{zango-0.2.1b0 → zango-0.2.2.dev0}/src/zango/apps/appauth/views.py

@@ -2,8 +2,10 @@ from django.shortcuts import redirect
 from django.views.generic import View
 
 from django.contrib.auth import logout
+from django.utils.decorators import method_decorator
 
-
+from axes.decorators import axes_dispatch
+@method_decorator(axes_dispatch, name='dispatch')
 class AppLogoutView(View):
     def add_protocol(self, request, url):
         if request.is_secure():

{zango-0.2.1b0 → zango-0.2.2.dev0}/src/zango/apps/dynamic_models/views.py

@@ -8,6 +8,7 @@ from django.conf import settings
 
 from django.views.generic import View
 from django.http import Http404
+from axes.decorators import axes_dispatch
 
 from zango.core.utils import get_current_role
 from zango.apps.dynamic_models.permissions import is_platform_user
@@ -44,6 +45,7 @@ def default_landing_view(request):
 
 
 @method_decorator(csrf_exempt, name="dispatch")
+@method_decorator(axes_dispatch, name="dispatch")
 class DynamicView(View, PermMixin):
     """
     this class is responsible for building the

{zango-0.2.1b0 → zango-0.2.2.dev0}/src/zango/apps/shared/platformauth/templates/app_panel/app_panel_login.html

@@ -76,29 +76,19 @@
             maxlength="150" placeholder="Enter Username" class="textinput form-control" required="">
           <input type="password" name="password" autofocus="" autocapitalize="none" autocomplete="password"
             maxlength="150" placeholder="Email Password" class="textinput form-control" required="">
+          {% if error_message %}
+            <p style="color: red; text-align: left; font-size: 11px;
+            color: #d52918;
+            font-weight: 700;
+            line-height: 16px;
+            letter-spacing: 0.2px;
+            ">{{ error_message }}</p>
+          {% endif %}
           <button type="submit"
             style="width: 100%; background: rgb(80, 72, 237); border-radius: 4px; color: white; padding: 9px; margin: 12px 0px 0px; border: none; cursor: pointer; font-weight: 700; font-size: 16px; line-height: 24px;">
             Login
           </button>
-
-          {% comment %} <table>
-            {{ wizard.management_form }}
-            {% crispy wizard.form %}
-          </table> {% endcomment %}
-
         </form>
-        {% comment %} <div id="messageListContainer" class="messageList" style="display: none;">
-          <p style="font-weight: 700; font-size: 14px;">Error</p>
-          {% if messages %}
-          <div id="list_div" class="display-message" style='text-align: center;'>
-            <ul style='list-style: none;'>
-              {% for message in messages %}
-              <li><span style=" ">{{ message }}</span></li>
-              {% endfor %}
-            </ul>
-          </div>
-          {% endif %}
-        </div> {% endcomment %}
       </div>
     </div>
     <div class="footer"