LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
import logging
from collections.abc import Callable
from contextlib import nullcontext
from typing import Any
from django.conf import settings
from django.contrib.auth import logout as django_logout
from django.db import connection, transaction
from django.db.utils import IntegrityError
from django.http import HttpRequest
from django.middleware import csrf
from django.shortcuts import redirect
from logs_helper.log_service import LogService
from rest_framework import status
from rest_framework.request import Request
from rest_framework.response import Response
from tenant_account_v2.models import OrganizationMember as OrganizationMember
from tenant_account_v2.organization_member_service import OrganizationMemberService
from utils.cache_service import CacheService
from utils.local_context import StateStore
from utils.user_context import UserContext
from utils.user_session import UserSessionUtils
from account_v2.authentication_helper import AuthenticationHelper
from account_v2.authentication_plugin_registry import AuthenticationPluginRegistry
from account_v2.authentication_service import AuthenticationService
from account_v2.constants import (
AuthorizationErrorCode,
Common,
Cookie,
ErrorMessage,
OrganizationMemberModel,
)
from account_v2.custom_exceptions import (
DuplicateData,
Forbidden,
MethodNotImplemented,
UserNotExistError,
)
from account_v2.dto import (
MemberInvitation,
OrganizationData,
UserInfo,
UserInviteResponse,
UserRoleData,
)
from account_v2.enums import UserRole
from account_v2.exceptions import OrganizationNotExist
from account_v2.models import Organization, User
from account_v2.organization import OrganizationService
from account_v2.organization_details import with_member_details
from account_v2.serializer import (
GetOrganizationsResponseSerializer,
OrganizationSerializer,
SetOrganizationsResponseSerializer,
)
from account_v2.user import UserService
from account_v2.user_profile import with_profile_overrides
logger = logging.getLogger(__name__)
class AuthenticationController:
"""Authentication Controller This controller class manages user
authentication processes.
"""
def __init__(self) -> None:
"""This method initializes the controller by selecting the appropriate
authentication plugin based on availability.
"""
self.authentication_helper = AuthenticationHelper()
if AuthenticationPluginRegistry.is_plugin_available():
self.auth_service: AuthenticationService = (
AuthenticationPluginRegistry.get_plugin()
)
else:
self.auth_service = AuthenticationService()
def user_login(
self,
request: Request,
) -> Any:
return self.auth_service.user_login(request)
def user_signup(self, request: Request) -> Any:
return self.auth_service.user_signup(request)
def authorization_callback(
self, request: Request, backend: str = settings.DEFAULT_MODEL_BACKEND
) -> Any:
"""Handle authorization callback.
This function processes the authorization callback from
an external service.
Args:
request (Request): Request instance
backend (str, optional): backend used to use login.
Defaults: settings.DEFAULT_MODEL_BACKEND.
Returns:
Any: Redirect response
"""
try:
return self.auth_service.handle_authorization_callback(
request=request, backend=backend
)
except Exception:
logger.exception("Error while handling authorization callback")
return redirect("/error")
def user_organizations(self, request: Request) -> Any:
"""List a user's organizations.
Args:
request: the authenticated request.
Returns:
Response with ``message`` and ``organizations`` (see
account_v2/ReadMe.md), or 412 with the session logged out if the
organizations can't be listed.
"""
try:
organizations = self.auth_service.user_organizations(request)
except Exception as ex:
#
self.user_logout(request)
response = Response(
status=status.HTTP_412_PRECONDITION_FAILED,
)
if hasattr(ex, "code") and ex.code in {
AuthorizationErrorCode.USF,
AuthorizationErrorCode.USR,
AuthorizationErrorCode.INE001,
AuthorizationErrorCode.INE002,
AuthorizationErrorCode.INS,
}: # type: ignore
response.data = {"domain": ex.data.get("domain"), "code": ex.code}
return response
# Return in case even if missed unknown exception in
# self.auth_service.user_organizations(request)
return response
user: User = request.user
org_ids = {org.id for org in organizations}
CacheService.set_user_organizations(user.user_id, list(org_ids))
# Under ATOMIC_REQUESTS a failed query aborts the request's
# transaction; a savepoint keeps the rest of the request usable.
guard = transaction.atomic() if connection.in_atomic_block else nullcontext()
try:
with guard:
listed: list[Any] = with_member_details(organizations, user)
except Exception:
# The details are optional; the list itself must still load.
logger.exception(
"Could not add member details to the organization list "
"for user %s (%d organizations)",
user.user_id,
len(organizations),
)
listed = organizations
serialized_organizations = GetOrganizationsResponseSerializer(
listed, many=True
).data
response = Response(
status=status.HTTP_200_OK,
data={
"message": "success",
"organizations": serialized_organizations,
},
)
if Cookie.CSRFTOKEN not in request.COOKIES:
csrf_token = csrf.get_token(request)
response.set_cookie(
Cookie.CSRFTOKEN,
csrf_token,
secure=settings.CSRF_COOKIE_SECURE,
httponly=False, # CSRF token needs to be readable by JS
samesite="Lax",
)
return response
def set_user_organization(self, request: Request, organization_id: str) -> Response:
user: User = request.user
new_organization = False
organization_ids = CacheService.get_user_organizations(user.user_id)
if not organization_ids:
z_organizations: list[OrganizationData] = (
self.auth_service.get_organizations_by_user_id(user.user_id)
)
organization_ids = {org.id for org in z_organizations}
if organization_id and organization_id in organization_ids:
# Set organization in user context
UserContext.set_organization_identifier(organization_id)
organization = OrganizationService.get_organization_by_org_id(organization_id)
if not organization:
try:
organization_data: OrganizationData = (
self.auth_service.get_organization_by_org_id(organization_id)
)
except ValueError:
raise OrganizationNotExist()
try:
organization = OrganizationService.create_organization(
organization_data.name,
organization_data.display_name,
organization_data.id,
)
new_organization = True
except IntegrityError:
raise DuplicateData(
f"{ErrorMessage.ORGANIZATION_EXIST}, \
{ErrorMessage.DUPLICATE_API}"
)
organization_member = self.create_tenant_user(
organization=organization, user=user
)
if new_organization:
self.authentication_helper.create_initial_platform_key(
user=user, organization=organization
)
try:
self.auth_service.frictionless_onboarding(
organization=organization, user=user
)
except MethodNotImplemented:
logger.info("frictionless_onboarding not implemented")
logger.info(
f"New organization created with Id {organization_id}",
)
else:
try:
self.auth_service.setup_default_adapters_for_user(
organization=organization, user=user
)
except MethodNotImplemented:
logger.info(
"setup_default_adapters_for_user not implemented, "
"default adapters will not be set for user %s",
user.email,
)
user_info: UserInfo | None = self.get_user_info(
request, organization_id=organization_id
)
serialized_user_info = SetOrganizationsResponseSerializer(user_info).data
organization_info = OrganizationSerializer(organization).data
response: Response = Response(
status=status.HTTP_200_OK,
data={
"is_new_org": new_organization,
"user": serialized_user_info,
"organization": organization_info,
f"{Common.LOG_EVENTS_ID}": StateStore.get(Common.LOG_EVENTS_ID),
},
)
current_organization_id = UserSessionUtils.get_organization_id(request)
if current_organization_id:
OrganizationMemberService.remove_user_membership_in_organization_cache(
user_id=user.user_id,
organization_id=current_organization_id,
)
UserSessionUtils.set_organization_id(request, organization_id)
UserSessionUtils.set_organization_member_role(request, organization_member)
OrganizationMemberService.set_user_membership_in_organization_cache(
user_id=user.user_id, organization_id=organization_id
)
return response
return Response(status=status.HTTP_403_FORBIDDEN)
def get_user_info(
self, request: Request, organization_id: str | None = None
) -> UserInfo | None:
"""The auth service's user info, with the locally edited name and photo.
Every auth plugin's result passes through here, so the edits show in the
profile and set-organization responses whichever provider signed the
user in. `organization_id` scopes the photo URL; it defaults to the
session's organization.
"""
user_info = self.auth_service.get_user_info(request)
user = getattr(request, "user", None)
if not user_info or not isinstance(user, User):
return user_info
return with_profile_overrides(
user_info,
user,
organization_id or UserSessionUtils.get_organization_id(request),
)
def is_admin_by_role(self, role: str) -> bool:
"""Check the role is act as admin in the context of authentication
plugin.
Args:
role (str): role
Returns:
bool: _description_
"""
return self.auth_service.is_admin_by_role(role=role)
def get_organization_info(self, org_id: str) -> Organization | None:
organization = OrganizationService.get_organization_by_org_id(org_id=org_id)
return organization
def make_organization_and_add_member(
self,
user_id: str,
user_name: str,
organization_name: str | None = None,
display_name: str | None = None,
) -> OrganizationData | None:
return self.auth_service.make_organization_and_add_member(
user_id, user_name, organization_name, display_name
)
def make_user_organization_name(self) -> str:
return self.auth_service.make_user_organization_name()
def make_user_organization_display_name(self, user_name: str) -> str:
return self.auth_service.make_user_organization_display_name(user_name)
def user_logout(self, request: Request) -> Response:
session_id: str = UserSessionUtils.get_session_id(request=request)
LogService.remove_logs_on_logout(session_id=session_id)
response = self.auth_service.user_logout(request=request)
organization_id = UserSessionUtils.get_organization_id(request)
user_id = UserSessionUtils.get_user_id(request)
if organization_id:
OrganizationMemberService.remove_user_membership_in_organization_cache(
user_id=user_id, organization_id=organization_id
)
django_logout(request)
return response
def get_organization_members_by_org_id(
self, organization_id: str | None = None
) -> list[OrganizationMember]:
members: list[OrganizationMember] = OrganizationMemberService.get_members()
return members
def get_organization_members_by_user(self, user: User) -> OrganizationMember:
"""Get organization member by user. This method will return
organization member object for given user.
Args:
user (User): UserEntity
Returns:
OrganizationMember: OrganizationMemberEntity
"""
member: OrganizationMember = OrganizationMemberService.get_user_by_id(id=user.id)
return member
def get_user_roles(self) -> list[UserRoleData]:
return self.auth_service.get_roles()
def get_user_invitations(self, organization_id: str) -> list[MemberInvitation]:
return self.auth_service.get_invitations(organization_id=organization_id)
def delete_user_invitation(self, organization_id: str, invitation_id: str) -> bool:
return self.auth_service.delete_invitation(
organization_id=organization_id, invitation_id=invitation_id
)
def reset_user_password(self, user: User) -> Response:
return self.auth_service.reset_user_password(user)
def invite_user(
self,
admin: User,
org_id: str,
user_list: list[dict[str, str | None]],
request: HttpRequest,
on_invited: Callable[[dict[str, str | None]], None] | None = None,
) -> list[UserInviteResponse]:
"""Invites users to join an organization.
Args:
admin (User): Admin user initiating the invitation.
org_id (str): ID of the organization to which users are invited.
user_list (list[dict[str, Union[str, None]]]):
List of user details for invitation.
on_invited: Called with each item the identity provider accepted,
as soon as it does, so a later item raising cannot lose the
record of the invitations already sent.
Returns:
list[UserInviteResponse]: List of responses for each
user invitation.
"""
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
self.authorize_invite(admin_user, [item.get("role") for item in user_list])
response = []
for user_item in user_list:
email = user_item.get("email")
role = user_item.get("role")
if email:
user = OrganizationMemberService.get_user_by_email(email=email)
user_response = {}
user_response["email"] = email
status = False
message = "User is already part of current organization"
# Check if user is already part of current organization
if not user:
status = self.auth_service.invite_user(
admin_user, org_id, email, role=role, request=request
)
message = "User invitation successful."
if status and on_invited:
on_invited(user_item)
response.append(
UserInviteResponse(
email=email,
status="success" if status else "failed",
message=message,
)
)
return response
def remove_users_from_organization(
self, request: Request, organization_id: str, user_emails: list[str]
) -> bool:
admin: User = request.user
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
user_ids = OrganizationMemberService.get_members_by_user_email(
user_emails=user_emails,
values_list_fields=[
OrganizationMemberModel.USER_ID,
OrganizationMemberModel.ID,
],
)
user_ids_list: list[str] = []
pk_list: list[str] = []
for user in user_ids:
user_ids_list.append(user[0])
pk_list.append(user[1])
if len(user_ids_list) > 0:
is_removed = self.auth_service.remove_users_from_organization(
admin=admin_user,
organization_id=organization_id,
user_ids=user_ids_list,
request=request,
)
else:
is_removed = False
if is_removed:
AuthenticationHelper.remove_users_from_organization_by_pks(pk_list)
for user_id in user_ids_list:
OrganizationMemberService.remove_user_membership_in_organization_cache(
user_id, organization_id
)
return is_removed
def _ensure_not_last_admin_demotion(self, email: str, new_role: str) -> None:
# Block demoting the only admin so the org never loses all admins.
# is_admin_by_role() defers to the active auth plugin's role semantics.
if self.is_admin_by_role(new_role):
return
target = OrganizationMemberService.get_user_by_email(email=email)
if target and self.is_admin_by_role(target.role):
admin_count = sum(
1
for m in OrganizationMemberService.get_members()
if self.is_admin_by_role(m.role)
)
if admin_count <= 1:
raise Forbidden("Cannot demote the only admin of the organization")
def _member_management_open(self, actor: OrganizationMember) -> bool:
"""Whether ``actor`` (not an admin) may manage members at all."""
from tenant_account_v2.capabilities import Capability, opened_to_members
return opened_to_members(
actor.user, UserContext.get_organization(), Capability.MANAGE_MEMBERS
)
def _refuse_members(self) -> None:
from tenant_account_v2.capabilities import SPECS_BY_KEY, Capability
raise Forbidden(SPECS_BY_KEY[Capability.MANAGE_MEMBERS].message())
def authorize_invite(self, actor: OrganizationMember | None, roles: list) -> None:
"""Admins invite with any role. A member may, when the org lets members
manage members, invite with the member role only.
"""
if actor is None: # not a member of this org
raise Forbidden()
if self.auth_service.is_organization_admin(actor):
return
if not self._member_management_open(actor):
self._refuse_members()
is_member_role = getattr(self.auth_service, "is_member_invite_role", None)
# A plugin that does not say which roles members may use refuses them
# (plugins need not inherit AuthenticationService).
if is_member_role is None or not all(is_member_role(role) for role in roles):
raise Forbidden("Members can invite with the user role only.")
def authorize_role_change(
self,
actor: OrganizationMember | None,
target: OrganizationMember,
role: str,
removing: bool = False,
) -> None:
"""Admins change any role. A member may, when the org lets members
manage members, grant a member-assignable role to another member who
is not an admin. Removing roles, granting admin, and changing one's own
role stay admin-only.
The check reads the target's role before the write without a lock, so
an admin promotion landing in between can be overwritten. Accepted: it
needs an admin and a member acting on the same person at once.
"""
if actor is None: # not a member of this org
raise Forbidden()
if self.auth_service.is_organization_admin(actor):
return
if not self._member_management_open(actor):
self._refuse_members()
if removing:
raise Forbidden("Only admins can remove a member's role.")
if target.user_id == actor.user_id:
raise Forbidden("You cannot change your own role.")
if self.is_admin_by_role(target.role):
raise Forbidden("Only admins can change an admin's role.")
is_assignable = getattr(self.auth_service, "is_member_assignable_role", None)
if is_assignable is None or not is_assignable(role):
raise Forbidden("Only admins can grant this role.")
def add_user_role(
self, request: Request, org_id: str, email: str, role: str
) -> str | None:
self._ensure_not_last_admin_demotion(email=email, new_role=role)
admin: User = request.user
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
user = OrganizationMemberService.get_user_by_email(email=email)
if user:
self.authorize_role_change(admin_user, user, role)
current_roles = self.auth_service.add_organization_user_role(
admin_user, org_id, user.user.user_id, [role], request
)
if current_roles:
self.save_organization_user_role(
user_uid=user.user.id, role=current_roles[0]
)
return current_roles[0]
else:
return None
def remove_user_role(
self, request: Request, org_id: str, email: str, role: str
) -> str | None:
if self.is_admin_by_role(role):
self._ensure_not_last_admin_demotion(
email=email, new_role=UserRole.USER.value
)
admin: User = request.user
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
organization_member = OrganizationMemberService.get_user_by_email(email=email)
if organization_member:
self.authorize_role_change(
admin_user, organization_member, role, removing=True
)
current_roles = self.auth_service.remove_organization_user_role(
admin_user, org_id, organization_member.user.user_id, [role], request
)
if current_roles:
self.save_organization_user_role(
user_uid=organization_member.user.id,
role=current_roles[0],
)
return current_roles[0]
else:
return None
def save_organization_user_role(self, user_uid: str, role: str) -> None:
organization_user = OrganizationMemberService.get_user_by_id(id=user_uid)
if organization_user:
# consider single role
organization_user.role = role
organization_user.save()
def create_tenant_user(
self, organization: Organization, user: User
) -> OrganizationMember:
existing_tenant_user = OrganizationMemberService.get_user_by_id(id=user.id)
# even if existing tenat user updat him with latest role from auth0 org
if existing_tenant_user:
user_roles = self.auth_service.get_organization_role_of_user(
user_id=existing_tenant_user.user.user_id,
organization_id=organization.organization_id,
)
existing_tenant_user.role = user_roles[0]
existing_tenant_user.save()
return existing_tenant_user
account_user = self.get_or_create_user(user=user)
if not account_user:
raise UserNotExistError()
logger.info(f"Creating account for {user.email}")
user_roles = self.auth_service.get_organization_role_of_user(
user_id=account_user.user_id,
organization_id=organization.organization_id,
)
user_role = user_roles[0]
try:
tenant_user: OrganizationMember = OrganizationMember(
user=user,
role=user_role,
is_login_onboarding_msg=False,
is_prompt_studio_onboarding_msg=False,
)
tenant_user.save()
logger.info(
f"{tenant_user.user.email} added in to the organization "
f"{organization.organization_id}"
)
return tenant_user
except IntegrityError:
logger.warning(f"Account already exists for {user.email}")
def get_or_create_user(self, user: User) -> User | OrganizationMember | None:
user_service = UserService()
if user.id:
account_user: User | None = user_service.get_user_by_id(user.id)
if account_user:
return account_user
elif user.email:
account_user = user_service.get_user_by_email(email=user.email)
if account_user:
return account_user
if user.user_id:
user.save()
return user
elif user.email and user.user_id:
account_user = user_service.create_user(
email=user.email, user_id=user.user_id
)
return account_user
return None