zango 0.2.0__py3-none-any.whl

zango/__init__.py

@@ -0,0 +1,3 @@
+from zango.core import internal_requests
+
+__version__ = "0.2.0"

zango/api/app_auth/profile/v1/serializers.py

@@ -0,0 +1,9 @@
+from rest_framework import serializers
+
+from zango.apps.appauth.models import AppUserModel
+
+
+class ProfileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = AppUserModel
+        fields = ["name", "email", "mobile"]

zango/api/app_auth/profile/v1/urls.py

@@ -0,0 +1,10 @@
+from django.urls import re_path
+
+from .views import ProfileViewAPIV1, PasswordChangeViewAPIV1
+
+urlpatterns = [
+    re_path(
+        r"change_password", PasswordChangeViewAPIV1.as_view(), name="change_password"
+    ),
+    re_path(r"", ProfileViewAPIV1.as_view(), name="profile"),
+]

zango/api/app_auth/profile/v1/utils.py

@@ -0,0 +1,149 @@
+import re
+
+from django.conf import settings
+from django.shortcuts import redirect
+
+
+class PasswordValidationMixin(object):
+    MIN_LENGTH = settings.PASSWORD_MIN_LENGTH
+    oldpassword_model = None
+    num_specialChar_regex = re.compile(r"[!@#$%^&*()_+-/=~]")
+    numeric_regex = re.compile(r"\d")
+    uppercase_regex = re.compile(r"[ABCDEFGHIJKLMNOPQRSTUVWXYZ]")
+    lowercase_regex = re.compile(r"[abcdefghijklmnopqrstuvwqyz]")
+
+    @staticmethod
+    def is_password_matching(password, password2):
+        """
+        Checks if both passwords are equal
+        """
+        validation = password == password2
+        if not validation:
+            msg = "The two passwords didn't match!"
+        else:
+            msg = None
+        return {"validation": validation, "msg": msg}
+
+    def check_password_length(self, password):
+        if len(password) < self.MIN_LENGTH:
+            validation = False
+            msg = (
+                f"The new password must be at least {self.MIN_LENGTH} characters long."
+            )
+
+        else:
+            validation = True
+            msg = None
+        return {"validation": validation, "msg": msg}
+
+    @staticmethod
+    def is_first_alpha(password):
+        """
+        First character must be alphabet
+        """
+        validation = password[0].isalpha()
+        if not validation:
+            msg = "The first letter of your password must be an alphabet!"
+        else:
+            msg = None
+        return {"validation": validation, "msg": msg}
+
+    def check_uppercase_char(self, password):
+        if not self.uppercase_regex.search(password):
+            validation = False
+            msg = "The new password must contain at least one upper case character"
+        else:
+            validation = True
+            msg = None
+        return {"msg": msg, "validation": validation}
+
+    def check_lowercase_char(self, password):
+        if not self.lowercase_regex.search(password):
+            validation = False
+            msg = "The new password must contain at least one lower case character"
+        else:
+            validation = True
+            msg = None
+        return {"msg": msg, "validation": validation}
+
+    def verify_old_password(self, user, old_password):
+        if not user.check_password(old_password):
+            msg = "Current password does not match. Please try again!"
+            validation = False
+        else:
+            msg = ""
+            validation = True
+        return {"validation": validation, "msg": msg}
+
+    def check_special_character(self, password):
+        msg = ""
+        validation = True
+        if not self.num_specialChar_regex.search(password):
+            validation = False
+            msg = "The new password must contain at least one numeric and one special character e.g. ! @ # $ %..."
+        if not self.numeric_regex.search(password):
+            validation = False
+            msg = "The new password must contain at least one numeric and one special character e.g. ! @ # $ %..."
+        return {"msg": msg, "validation": validation}
+
+    @staticmethod
+    def match_old_password(user, password):
+        validation = True
+        if user.check_password_validity(password):
+            msg = (
+                "Sorry, but your new password must not match one of your \
+        old passwords from the previous %s days. Please try \
+        again!"
+                % (settings.PASSWORD_NO_REPEAT_DAYS)
+            )
+            validation = False
+        else:
+            msg = ""
+        return {"validation": validation, "msg": msg}
+
+    @staticmethod
+    def match_password_username(user, password):
+        validation = True
+        msg = None
+        if password.lower() == user.email.lower():
+            validation = False
+        if not validation:
+            msg = "Your password must be different from your username."
+        return {"msg": msg, "validation": validation}
+
+    def run_all_validations(
+        self, user, password, repeat_password=None, old_password=None
+    ):
+        if repeat_password:
+            if not self.is_password_matching(password, repeat_password).get(
+                "validation"
+            ):
+                return self.is_password_matching(password, repeat_password)
+
+        if old_password:
+            if not self.verify_old_password(user, old_password).get("validation"):
+                return self.verify_old_password(user, old_password)
+
+        if not self.check_password_length(password).get("validation"):
+            return self.check_password_length(password)
+
+        elif not self.is_first_alpha(password).get("validation"):
+            return self.is_first_alpha(password)
+
+        elif not self.check_uppercase_char(password).get("validation"):
+            return self.check_uppercase_char(password)
+
+        elif not self.check_lowercase_char(password).get("validation"):
+            return self.check_lowercase_char(password)
+
+        elif not self.check_special_character(password).get("validation"):
+            return self.check_special_character(password)
+
+        elif not self.match_old_password(user, password).get("validation"):
+            return self.match_old_password(user, password)
+
+        elif not self.match_password_username(user, password).get("validation"):
+            return self.match_password_username(user, password)
+
+        else:
+            return {"validation": True, "msg": "Password validations passed"}

zango/api/app_auth/profile/v1/views.py

@@ -0,0 +1,77 @@
+from django.contrib.auth import authenticate
+from django.core.exceptions import ValidationError
+
+from zango.core.api import (
+    get_api_response,
+    ZangoGenericAppAPIView,
+    ZangoSessionAppAPIView,
+)
+from zango.api.app_auth.profile.v1.utils import PasswordValidationMixin
+from zango.apps.appauth.models import OldPasswords
+
+from .serializers import ProfileSerializer
+
+
+class ProfileViewAPIV1(ZangoGenericAppAPIView):
+    def get(self, request, *args, **kwargs):
+        serializer = ProfileSerializer(request.user)
+        success = True
+        response = {"message": "success", "profile_data": serializer.data}
+        status = 200
+        return get_api_response(success, response, status)
+
+    def put(self, request, *args, **kwargs):
+        response = request.user.update_user(request.data)
+        success = response.pop("success")
+        if success:
+            status = 200
+        else:
+            status = 400
+        return get_api_response(success, response, status)
+
+
+class PasswordChangeViewAPIV1(ZangoSessionAppAPIView, PasswordValidationMixin):
+    def clean_password(self, email, password):
+        """
+        Validates that the email is not already in use.
+        """
+        try:
+            user = authenticate(username=email, password=password)
+        except:
+            raise ValidationError(
+                "The current password you have entered is wrong. Please try again!"
+            )
+
+    def clean_password2(self, user, current_password, new_password):
+        """method to validate password"""
+        password2 = new_password
+        validation = self.run_all_validations(
+            user, new_password, password2, current_password
+        )
+        if not validation.get("validation"):
+            raise ValidationError(validation.get("msg"))
+        return True
+
+    def put(self, request, *args, **kwargs):
+        current_password = request.data.get("current_password")
+        new_password = request.data.get("new_password")
+        success = False
+        try:
+            self.clean_password(request.user.email, current_password)
+            self.clean_password2(request.user, current_password, new_password)
+            request.user.set_password(new_password)
+            request.user.save()
+            obj = OldPasswords.objects.create(user=request.user)
+            obj.setPasswords(request.user.password)
+            obj.save()
+            success = True
+            response = {}
+            status = 200
+            return get_api_response(success, response, status)
+        except ValidationError as e:
+            response = {"message": e.message}
+        if success:
+            status = 200
+        else:
+            status = 400
+        return get_api_response(success, response, status)

zango/api/app_auth/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path, include
+
+from .profile.v1 import urls as profile_v1_urls
+
+urlpatterns = [
+    path("v1/profile/", include(profile_v1_urls)),
+]

zango/api/platform/auditlogs/v1/serializers.py

@@ -0,0 +1,63 @@
+import importlib
+
+from rest_framework import serializers
+
+from zango.api.platform.tenancy.v1.serializers import AppUserModelSerializerModel
+from zango.apps.auditlogs.models import LogEntry
+from zango.core.utils import get_datetime_str_in_tenant_timezone, get_current_request
+
+
+class AuditLogSerializerModel(serializers.ModelSerializer):
+    actor = serializers.SerializerMethodField()
+    actor_type = serializers.SerializerMethodField()
+    timestamp = serializers.SerializerMethodField()
+    action = serializers.SerializerMethodField()
+    object_uuid = serializers.SerializerMethodField()
+    object_type = serializers.SerializerMethodField()
+
+    def get_action(self, obj):
+        return obj.get_action_display().capitalize()
+
+    def get_timestamp(self, obj):
+        return get_datetime_str_in_tenant_timezone(
+            obj.timestamp, self.context["tenant"]
+        )
+
+    def get_actor(self, obj):
+        return (
+            obj.tenant_actor.name
+            if obj.tenant_actor
+            else obj.platform_actor.name
+            if obj.platform_actor
+            else None
+        )
+
+    def get_actor_type(self, obj):
+        return (
+            "tenant_actor"
+            if obj.tenant_actor
+            else "platform_actor"
+            if obj.platform_actor
+            else None
+        )
+
+    def get_object_uuid(self, obj):
+        if obj.object_ref is not None:
+            return str(obj.object_ref.object_uuid)
+
+    def get_object_type(self, obj):
+        return obj.content_type.model
+
+    class Meta:
+        model = LogEntry
+        fields = [
+            "id",
+            "actor",
+            "actor_type",
+            "action",
+            "object_id",
+            "object_uuid",
+            "object_type",
+            "timestamp",
+            "changes",
+        ]

zango/api/platform/auditlogs/v1/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from .views import AuditLogViewAPIV1
+
+urlpatterns = [
+    path(
+        "",
+        AuditLogViewAPIV1.as_view(),
+        name="auditlog-apiv1-auditloglistview",
+    ),
+]

zango/api/platform/auditlogs/v1/views.py

@@ -0,0 +1,182 @@
+import traceback
+import csv
+from datetime import datetime
+import json
+import pytz
+
+from django.db.models import Q
+from django.contrib.contenttypes.models import ContentType
+from django.db import connection
+from django.utils.decorators import method_decorator
+
+from zango.core.api import get_api_response, ZangoGenericPlatformAPIView
+from zango.core.api.utils import ZangoAPIPagination
+from zango.core.permissions import IsSuperAdminPlatformUser
+from zango.core.utils import get_search_columns
+from zango.apps.shared.tenancy.models import TenantModel
+from zango.apps.auditlogs.models import LogEntry
+from zango.core.common_utils import set_app_schema_path
+
+from .serializers import AuditLogSerializerModel
+
+
+@method_decorator(set_app_schema_path, name="dispatch")
+class AuditLogViewAPIV1(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={}, model_type=None):
+        field_name_query_mapping = {
+            "tenant_actor": "tenant_actor__name__icontains",
+            "platform_actor": "platform_actor__name__icontains",
+            "object_id": "object_id",
+            "id": "id",
+            "object_repr": "object_repr__icontains",
+            "changes": "changes__icontains",
+            "object_uuid": "object_ref__object_uuid__icontains",
+        }
+        search_filters = {
+            "id": self.process_id,
+            "object_id": self.process_id,
+            "timestamp": self.process_timestamp,
+        }
+        if model_type == "dynamic_models":
+            records = (
+                LogEntry.objects.all()
+                .order_by("-id")
+                .filter(content_type__app_label=model_type)
+            )
+        elif model_type == "core_models":
+            records = (
+                LogEntry.objects.all()
+                .order_by("-id")
+                .exclude(content_type__app_label="dynamic_models")
+            )
+        else:
+            records = LogEntry.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:
+                    filters |= Q(**{query: search})
+        records = records.filter(filters).distinct()
+        if columns.get("timestamp"):
+            processed = self.process_timestamp(
+                columns.get("timestamp"), tenant.timezone
+            )
+            if processed is not None:
+                records = records.filter(
+                    timestamp__gte=processed["start"], timestamp__lte=processed["end"]
+                )
+        if columns.get("action"):
+            records = records.filter(action=columns.get("action"))
+        if columns.get("object_type"):
+            records = records.filter(
+                content_type=ContentType.objects.get(id=columns.get("object_type"))
+            )
+        return records
+
+    def get_dropdown_options(self, model_type=None):
+        options = {}
+        options["action"] = [
+            {
+                "id": "0",
+                "label": "Create",
+            },
+            {
+                "id": "1",
+                "label": "Update",
+            },
+            {
+                "id": "2",
+                "label": "Delete",
+            },
+        ]
+        options["object_type"] = []
+        if model_type == "dynamic_models":
+            object_types = list(
+                LogEntry.objects.all()
+                .values_list("content_type_id", "content_type__model")
+                .order_by("content_type__model")
+                .distinct()
+                .filter(content_type__app_label__contains="dynamic_models")
+            )
+        elif model_type == "core_models":
+            object_types = list(
+                LogEntry.objects.all()
+                .values_list("content_type_id", "content_type__model")
+                .order_by("content_type__model")
+                .distinct()
+                .exclude(content_type__app_label__contains="dynamic_models")
+            )
+        else:
+            object_types = list(
+                LogEntry.objects.all()
+                .values_list("content_type_id", "content_type__model")
+                .order_by("content_type__model")
+                .distinct()
+            )
+        for object_type in object_types:
+            options["object_type"].append(
+                {
+                    "id": object_type[0],
+                    "label": object_type[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")
+            model_type = request.GET.get("model_type", None)
+            search = request.GET.get("search", None)
+            columns = get_search_columns(request)
+            audit_logs = self.get_queryset(search, tenant, columns, model_type)
+            paginated_audit_logs = self.paginate_queryset(
+                audit_logs, request, view=self
+            )
+            serializer = AuditLogSerializerModel(
+                paginated_audit_logs, many=True, context={"tenant": tenant}
+            )
+            auditlogs = self.get_paginated_response_data(serializer.data)
+            success = True
+            response = {
+                "audit_logs": auditlogs,
+                "message": "Audit logs fetched successfully",
+            }
+            if include_dropdown_options:
+                response["dropdown_options"] = self.get_dropdown_options(model_type)
+            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/api/platform/auth/v1/serializers.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+from zango.apps.shared.platformauth.models import PlatformUserModel
+from zango.api.platform.tenancy.v1.serializers import TenantSerializerModel
+
+
+class PlatformUserSerializerModel(serializers.ModelSerializer):
+    apps = TenantSerializerModel(many=True)
+
+    class Meta:
+        model = PlatformUserModel
+        fields = [
+            "id",
+            "name",
+            "email",
+            "apps",
+            "is_superadmin",
+            "is_active",
+            "last_login",
+            "created_at",
+        ]

zango/api/platform/auth/v1/urls.py

@@ -0,0 +1,22 @@
+from django.urls import re_path
+
+from .views import (
+    PlatformUserViewAPIV1,
+    PlatformUserDetailViewAPIV1,
+    AppPanelDetailsView,
+)
+
+
+urlpatterns = [
+    re_path(
+        r"^platform-users/$",
+        PlatformUserViewAPIV1.as_view(),
+        name="platformauth-apiv1-userview",
+    ),
+    re_path(
+        r"^platform-users/(?P<user_id>[\w-]+)/$",
+        PlatformUserDetailViewAPIV1.as_view(),
+        name="platformauth-apiv1-userdetailview",
+    ),
+    re_path("app-initalization-details/", AppPanelDetailsView.as_view()),
+]