oxutils 0.1.1__py3-none-any.whl → 0.1.5__py3-none-any.whl

oxutils/pdf/utils.py

@@ -0,0 +1,94 @@
+import logging
+import mimetypes
+import os
+from functools import lru_cache
+from pathlib import Path
+from urllib.parse import urlparse
+
+import weasyprint
+
+from django.conf import settings
+from django.contrib.staticfiles.finders import find
+from django.contrib.staticfiles.storage import staticfiles_storage
+from django.core.files.storage import default_storage
+from django.urls import get_script_prefix
+
+
+log = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=None)
+def get_reversed_hashed_files():
+    return {v: k for k, v in staticfiles_storage.hashed_files.items()}
+
+
+def django_url_fetcher(url, *args, **kwargs):
+    # attempt to load file:// paths to Django MEDIA or STATIC files directly from disk
+    if url.startswith('file:'):
+        log.debug('Attempt to fetch from %s', url)
+        mime_type, encoding = mimetypes.guess_type(url)
+        url_path = urlparse(url).path
+        data = {
+            'mime_type': mime_type,
+            'encoding': encoding,
+            'filename': Path(url_path).name,
+        }
+
+        default_media_url = settings.MEDIA_URL in ('', get_script_prefix())
+        if not default_media_url and url_path.startswith(settings.MEDIA_URL):
+            log.debug('URL contains MEDIA_URL (%s)', settings.MEDIA_URL)
+            cleaned_media_root = str(settings.MEDIA_ROOT)
+            if not cleaned_media_root.endswith('/'):
+                cleaned_media_root += '/'
+            absolute_path = url_path.replace(settings.MEDIA_URL, cleaned_media_root, 1)
+            log.debug('Cleaned path: %s', absolute_path)
+            data['file_obj'] = default_storage.open(absolute_path, 'rb')
+            data['redirected_url'] = 'file://' + absolute_path
+            return data
+
+        # path looks like a static file based on configured STATIC_URL
+        elif settings.STATIC_URL and url_path.startswith(settings.STATIC_URL):
+            log.debug('URL contains STATIC_URL (%s)', settings.STATIC_URL)
+            # strip the STATIC_URL prefix to get the relative filesystem path
+            relative_path = url_path.replace(settings.STATIC_URL, '', 1)
+            # detect hashed files storage and get path with un-hashed filename
+            if not settings.DEBUG and hasattr(staticfiles_storage, 'hashed_files'):
+                log.debug('Hashed static files storage detected')
+                relative_path = get_reversed_hashed_files()[relative_path]
+                data['filename'] = Path(relative_path).name
+            log.debug('Cleaned path: %s', relative_path)
+            # find the absolute path using the static file finders
+            absolute_path = find(relative_path)
+            log.debug('Static file finder returned: %s', absolute_path)
+            if absolute_path:
+                log.debug('Loading static file: %s', absolute_path)
+                data['file_obj'] = open(absolute_path, 'rb')  # noqa: PTH123
+                data['redirected_url'] = 'file://' + absolute_path
+                return data
+
+    # Fall back to weasyprint default fetcher for http/s: and file: paths
+    # that did not match MEDIA_URL or STATIC_URL.
+    log.debug('Forwarding to weasyprint.default_url_fetcher: %s', url)
+    return weasyprint.default_url_fetcher(url, *args, **kwargs)
+
+
+def get_stylesheet_path(relative_path):
+    if settings.DEBUG:
+        path = find(relative_path)
+        if path:
+            return path
+    print('Le DEBUG est False')
+    static_root_path = os.path.join(settings.STATIC_ROOT, relative_path)
+    if os.path.exists(static_root_path):
+        return static_root_path
+    
+    return None
+
+
+def get_stylesheets(*relative_paths):
+    stylesheets = []
+    for path in relative_paths:
+        resolved = get_stylesheet_path(path)
+        if resolved:
+            stylesheets.append(resolved)
+    return stylesheets

oxutils/pdf/views.py

@@ -0,0 +1,208 @@
+import weasyprint
+
+from django.conf import settings
+from django.template.response import TemplateResponse
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+from oxutils.pdf.utils import django_url_fetcher
+
+
+class WeasyTemplateResponse(TemplateResponse):
+    def __init__(
+            self,
+            request,
+            template,
+            context=None,
+            content_type=None,
+            status=None,
+            charset=None,
+            using=None,
+            headers=None,
+            filename=None,
+            attachment=True,
+            stylesheets=None,
+            options=None,
+        ):
+        """
+        An HTTP response class with template and context rendered to a PDF document.
+
+        Django TemplateResponse arguments:
+
+        :param request: the request object
+        :param template: template to use to render the response
+        :param context: context to use to render the response
+        :param content_type: content type of the response (default: 'application/pdf')
+        :param status: status code of the response (default: 200)
+        :param charset: character set of the response (default: settings.DEFAULT_CHARSET)
+        :param using: template engine to use (default: 'django')
+        :param headers: dictionary of headers to use in the response
+
+        WeasyPrint specific arguments:
+
+        :param filename: set `Content-Disposition` to use this filename
+        :param attachment: set `Content-Disposition` 'attachment';
+            A `filename` must be given to enable this even if set to `True`.
+            (default: `True`)
+        :param stylesheets: list of additional stylesheets
+        :param options: dictionary of options passed to WeasyPrint
+        """
+        self._stylesheets = stylesheets or []
+        self._options = options.copy() if options else {}
+
+        kwargs = dict(
+            context=context,
+            content_type=content_type or WeasyTemplateResponseMixin.content_type,
+            status=status,
+            charset=charset,
+            using=using,
+            headers=headers,
+        )
+        super().__init__(request, template, **kwargs)
+
+        if filename:
+            display = 'attachment' if attachment else 'inline'
+            self['Content-Disposition'] = f'{display};filename="{filename}"'
+
+    def get_base_url(self):
+        """
+        Determine base URL to fetch CSS or other files referenced with relative
+        paths in the HTML files using the `WEASYPRINT_BASEURL` setting or
+        fall back to using the root path of the URL used in the request.
+        """
+        return getattr(
+            settings, 'WEASYPRINT_BASEURL',
+            self._request.build_absolute_uri('/')
+        )
+
+    def get_url_fetcher(self):
+        """
+        Determine the URL fetcher to fetch CSS, images, fonts, etc. from.
+        """
+        return django_url_fetcher
+
+    def get_font_config(self):
+        """
+        A FreeType font configuration to handle @font-config rules.
+        """
+        return weasyprint.text.fonts.FontConfiguration()
+
+    def get_css(self, base_url, url_fetcher, font_config):
+        """
+        Load additional stylesheets.
+        """
+        return [
+            weasyprint.CSS(
+                value,
+                base_url=base_url,
+                url_fetcher=url_fetcher,
+                font_config=font_config,
+            )
+            for value
+            in self._stylesheets
+        ]
+
+    def get_document(self):
+        """
+        Returns a :class:`~document.Document` object which provides
+        access to individual pages and various meta-data.
+
+        See :meth:`weasyprint.HTML.render` and
+        :meth:`weasyprint.document.Document.write_pdf` on how to generate a
+        PDF file.
+        """
+        base_url = self.get_base_url()
+        url_fetcher = self.get_url_fetcher()
+        font_config = self.get_font_config()
+
+        html = weasyprint.HTML(
+            string=super().rendered_content,
+            base_url=base_url,
+            url_fetcher=url_fetcher,
+        )
+
+        self._options.setdefault(
+            'stylesheets',
+            self.get_css(base_url, url_fetcher, font_config),
+        )
+
+        return html.render(
+            font_config=font_config,
+            **self._options,
+        )
+
+    @property
+    def rendered_content(self):
+        """
+        Returns rendered PDF pages.
+        """
+        document = self.get_document()
+        return document.write_pdf(**self._options)
+
+
+class WeasyTemplateResponseMixin(TemplateResponseMixin):
+    """
+    Mixin for a CBV creating a ``WeasyTemplateResponse`` using the configured template.
+    """
+    response_class = WeasyTemplateResponse
+    content_type = 'application/pdf'
+    pdf_filename = None
+    pdf_attachment = True
+    pdf_stylesheets = []
+    pdf_options = {}
+
+    def get_pdf_filename(self):
+        """
+        Returns :attr:`pdf_filename` value by default.
+
+        If left blank the browser will display the PDF inline.
+        Otherwise it will pop up the "Save as.." dialog.
+
+        :rtype: :func:`str`
+        """
+        return self.pdf_filename
+
+    def get_pdf_stylesheets(self):
+        """
+        Returns a list of stylesheet filenames to use when rendering.
+
+        :rtype: :func:`list`
+        """
+        return self.pdf_stylesheets
+
+    def get_pdf_options(self):
+        """
+        Returns dictionary of WeasyPrint options.
+        """
+        return self.pdf_options
+
+    def render_to_response(self, context, **response_kwargs):
+        """
+        Renders PDF document and prepares response by calling on
+        :attr:`response_class` (default: :class:`WeasyTemplateResponse`).
+
+        :returns: Django HTTP response
+        :rtype: :class:`django.http.HttpResponse`
+        """
+        response_kwargs.update({
+            'attachment': self.pdf_attachment,
+            'filename': self.get_pdf_filename(),
+            'stylesheets': self.get_pdf_stylesheets(),
+            'options': self.get_pdf_options(),
+        })
+        return super().render_to_response(
+            context, **response_kwargs
+        )
+
+
+class WeasyTemplateView(WeasyTemplateResponseMixin, ContextMixin, View):
+    """
+    Concrete view for serving PDF files.
+
+    .. code-block:: python
+
+        class HelloPDFView(WeasyTemplateView):
+            template_name = "hello.html"
+    """
+    def get(self, request, *args, **kwargs):
+        context = self.get_context_data(**kwargs)
+        return self.render_to_response(context)

oxutils/s3/storages.py

@@ -53,7 +53,7 @@ class PublicMediaStorage(S3Boto3Storage):
             self.access_key = oxi_settings.default_s3_access_key_id
             self.secret_key = oxi_settings.default_s3_secret_access_key
             self.bucket_name = oxi_settings.default_s3_storage_bucket_name
-            self.custom_domain = oxi_settings.default_s3_s3_custom_domain
+            self.custom_domain = oxi_settings.default_s3_custom_domain
         
         self.location = oxi_settings.default_s3_location
         self.default_acl = oxi_settings.default_s3_default_acl
@@ -79,7 +79,7 @@ class PrivateMediaStorage(S3Boto3Storage):
         self.access_key = oxi_settings.private_s3_access_key_id
         self.secret_key = oxi_settings.private_s3_secret_access_key
         self.bucket_name = oxi_settings.private_s3_storage_bucket_name
-        self.custom_domain = oxi_settings.private_s3_s3_custom_domain
+        self.custom_domain = oxi_settings.private_s3_custom_domain
         self.location = oxi_settings.private_s3_location
         self.default_acl = oxi_settings.private_s3_default_acl
         self.file_overwrite = False
@@ -107,12 +107,12 @@ class LogStorage(S3Boto3Storage):
             self.access_key = oxi_settings.private_s3_access_key_id
             self.secret_key = oxi_settings.private_s3_secret_access_key
             self.bucket_name = oxi_settings.private_s3_storage_bucket_name
-            self.custom_domain = oxi_settings.private_s3_s3_custom_domain
+            self.custom_domain = oxi_settings.private_s3_custom_domain
         else:
             self.access_key = oxi_settings.log_s3_access_key_id
             self.secret_key = oxi_settings.log_s3_secret_access_key
             self.bucket_name = oxi_settings.log_s3_storage_bucket_name
-            self.custom_domain = oxi_settings.log_s3_s3_custom_domain
+            self.custom_domain = oxi_settings.log_s3_custom_domain
         
         self.location = f'{oxi_settings.log_s3_location}/{oxi_settings.service_name}'
         self.default_acl = oxi_settings.log_s3_default_acl

oxutils/settings.py

@@ -21,6 +21,8 @@ class OxUtilsSettings(BaseSettings):
 
     # Service
     service_name: Optional[str] = 'Oxutils'
+    site_name: Optional[str] = 'Oxiliere'
+    site_domain: Optional[str] = 'oxiliere.com'
 
     # Auth JWT Settings (JWT_SIGNING_KEY)
     jwt_signing_key: Optional[str] = None
@@ -52,7 +54,7 @@ class OxUtilsSettings(BaseSettings):
     default_s3_secret_access_key: Optional[str] = None
     default_s3_storage_bucket_name: Optional[str] = None
     default_s3_default_acl: str = Field('public-read')
-    default_s3_s3_custom_domain: Optional[str] = None
+    default_s3_custom_domain: Optional[str] = None
     default_s3_location: str = Field('media')
     default_s3_storage: str = Field('oxutils.s3.storages.PublicMediaStorage')
 
@@ -62,7 +64,7 @@ class OxUtilsSettings(BaseSettings):
     private_s3_secret_access_key: Optional[str] = None
     private_s3_storage_bucket_name: Optional[str] = None
     private_s3_default_acl: str = Field('private')
-    private_s3_s3_custom_domain: Optional[str] = None
+    private_s3_custom_domain: Optional[str] = None
     private_s3_location: str = Field('private')
     private_s3_storage: str = Field('oxutils.s3.storages.PrivateMediaStorage')
 
@@ -73,7 +75,7 @@ class OxUtilsSettings(BaseSettings):
     log_s3_secret_access_key: Optional[str] = None
     log_s3_storage_bucket_name: Optional[str] = None
     log_s3_default_acl: str = Field('private')
-    log_s3_s3_custom_domain: Optional[str] = None
+    log_s3_custom_domain: Optional[str] = None
     log_s3_location: str = Field('oxi_logs')
     log_s3_storage: str = Field('oxutils.s3.storages.LogStorage')
 
@@ -102,7 +104,7 @@ class OxUtilsSettings(BaseSettings):
                     self.default_s3_access_key_id,
                     self.default_s3_secret_access_key,
                     self.default_s3_storage_bucket_name,
-                    self.default_s3_s3_custom_domain
+                    self.default_s3_custom_domain
                 )
             elif not self.use_static_s3:
                 raise ValueError(
@@ -116,7 +118,7 @@ class OxUtilsSettings(BaseSettings):
                 self.private_s3_access_key_id,
                 self.private_s3_secret_access_key,
                 self.private_s3_storage_bucket_name,
-                self.private_s3_s3_custom_domain
+                self.private_s3_custom_domain
             )
         
         # Validate log S3
@@ -127,7 +129,7 @@ class OxUtilsSettings(BaseSettings):
                     self.log_s3_access_key_id,
                     self.log_s3_secret_access_key,
                     self.log_s3_storage_bucket_name,
-                    self.log_s3_s3_custom_domain
+                    self.log_s3_custom_domain
                 )
             elif not self.use_private_s3:
                 raise ValueError(
@@ -166,11 +168,11 @@ class OxUtilsSettings(BaseSettings):
         """Validate required S3 configuration fields."""
         missing_fields = []
         if not access_key:
-            missing_fields.append(f'OXI_{name.upper()}_ACCESS_KEY_ID')
+            missing_fields.append(f'OXI_{name.upper()}_S3_ACCESS_KEY_ID')
         if not secret_key:
-            missing_fields.append(f'OXI_{name.upper()}_SECRET_ACCESS_KEY')
+            missing_fields.append(f'OXI_{name.upper()}_S3_SECRET_ACCESS_KEY')
         if not bucket:
-            missing_fields.append(f'OXI_{name.upper()}_STORAGE_BUCKET_NAME')
+            missing_fields.append(f'OXI_{name.upper()}_S3_STORAGE_BUCKET_NAME')
         if not domain:
             missing_fields.append(f'OXI_{name.upper()}_S3_CUSTOM_DOMAIN')
         
@@ -194,7 +196,7 @@ class OxUtilsSettings(BaseSettings):
                 # Use static S3 credentials but keep default_s3 specific values (location, etc.)
                 domain = self.static_s3_custom_domain
             else:
-                domain = self.default_s3_s3_custom_domain
+                domain = self.default_s3_custom_domain
             return f'https://{domain}/{self.default_s3_location}/'
         
         raise ImproperlyConfigured(
@@ -207,7 +209,7 @@ class OxUtilsSettings(BaseSettings):
             raise ImproperlyConfigured(
                 "Private S3 is not enabled. Set OXI_USE_PRIVATE_S3=True."
             )
-        return f'https://{self.private_s3_s3_custom_domain}/{self.private_s3_location}/'
+        return f'https://{self.private_s3_custom_domain}/{self.private_s3_location}/'
     
     def get_log_storage_url(self) -> str:
         """Get log storage URL."""
@@ -217,9 +219,9 @@ class OxUtilsSettings(BaseSettings):
             )
         if self.use_private_s3_as_log:
             # Use private S3 credentials but keep log_s3 specific values (location, etc.)
-            domain = self.private_s3_s3_custom_domain
+            domain = self.private_s3_custom_domain
         else:
-            domain = self.log_s3_s3_custom_domain
+            domain = self.log_s3_custom_domain
         return f'https://{domain}/{self.log_s3_location}/{self.service_name}/'
 
 

oxutils/users/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

oxutils/users/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class UsersConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'users'

oxutils/users/models.py

@@ -0,0 +1,88 @@
+from django.db import models
+
+from django.contrib.auth.models import AbstractUser, BaseUserManager
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from safedelete.models import SafeDeleteModel
+from safedelete.models import SOFT_DELETE_CASCADE
+from auditlog.registry import auditlog
+from oxutils.models import BaseModelMixin
+
+
+
+class UserManager(BaseUserManager):
+    """
+    Gestionnaire personnalisé pour le modèle User
+    """
+    def create_user(self, email, oxi_id, **extra_fields):
+        """
+        Crée et sauvegarde un utilisateur avec l'email et l'oxi_id donnés.
+        """
+        if not email:
+            raise ValueError(_('The Email field must be set'))
+        if not oxi_id:
+            raise ValueError(_('The oxi_id field must be set'))
+        
+        email = self.normalize_email(email)
+        user = self.model(email=email, oxi_id=oxi_id, **extra_fields)
+        user.save(using=self._db)
+        return user
+
+    def create_superuser(self, email, oxi_id, **extra_fields):
+        """
+        Crée et sauvegarde un superutilisateur avec l'email et l'oxi_id donnés.
+        """
+        extra_fields.setdefault('is_staff', True)
+        extra_fields.setdefault('is_superuser', True)
+        extra_fields.setdefault('is_active', True)
+
+        if extra_fields.get('is_staff') is not True:
+            raise ValueError(_('Superuser must have is_staff=True.'))
+        if extra_fields.get('is_superuser') is not True:
+            raise ValueError(_('Superuser must have is_superuser=True.'))
+
+        return self.create_user(email, oxi_id, **extra_fields)
+
+
+class User(AbstractUser, SafeDeleteModel, BaseModelMixin):
+    """
+    Modèle d'utilisateur personnalisé qui utilise l'email comme identifiant unique
+    et intègre la suppression sécurisée (soft delete)
+    """
+    _safedelete_policy = SOFT_DELETE_CASCADE
+    
+    # Suppression du champ username qui est obligatoire dans AbstractUser
+    username = None
+    password = None # Don't need password
+
+    oxi_id = models.UUIDField(unique=True)  # id venant de auth.oxi.com
+    email = models.EmailField(unique=True)
+    is_active = models.BooleanField(default=True)
+    subscription_plan = models.CharField(max_length=255, null=True, blank=True)
+    subscription_status = models.CharField(max_length=255, null=True, blank=True)
+    subscription_end_date = models.DateTimeField(null=True, blank=True)
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = []
+
+    def __str__(self):
+        return self.email
+    
+    objects = UserManager()
+    
+    class Meta:
+        verbose_name = _('utilisateur')
+        verbose_name_plural = _('utilisateurs')
+        ordering = ['-created_at']
+        indexes = [
+            models.Index(fields=['oxi_id']),
+            models.Index(fields=['email']),
+        ]
+    
+    def __str__(self):
+        return self.email
+
+
+
+# Enregistrement du modèle User pour l'audit logging
+auditlog.register(User)

oxutils/users/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

oxutils/users/utils.py

@@ -0,0 +1,15 @@
+from django.contrib.auth import get_user_model
+
+
+def update_user(oxid: str, data: dict):
+    user = get_user_model().objects.get(oxi_id=oxid)
+    changes = False
+    if data:
+        for key, value in data.items():
+            if hasattr(user, key):
+                setattr(user, key, value)
+                changes = True
+    if changes:
+        user.save()
+
+    return user