slthcore 0.2.0__tar.gz → 0.2.2__tar.gz

{slthcore-0.2.0/slthcore.egg-info → slthcore-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slthcore
-Version: 0.2.0
+Version: 0.2.2
 Summary: API generator based on yml file
 Home-page: https://github.com/brenokcc
 Author: Breno Silva

{slthcore-0.2.0 → slthcore-0.2.2}/setup.py

@@ -5,7 +5,7 @@ install_requires = []
 
 setup(
     name='slthcore',
-    version='0.2.0',
+    version='0.2.2',
     packages=find_packages(),
     install_requires=install_requires,
     include_package_data=True,

slthcore-0.2.2/slth/apps.py

@@ -0,0 +1,9 @@
+from django.conf import settings
+from django.apps import AppConfig
+
+
+class AppConfig(AppConfig):
+    name = 'slth'
+
+    def ready(self):
+        settings.SLOTH = True

{slthcore-0.2.0 → slthcore-0.2.2}/slth/db/models.py

@@ -1,5 +1,8 @@
 from uuid import uuid1
-from django.db.models import Model as DjangoModel
+import pytz
+from datetime import datetime, timedelta
+from django.utils import timezone
+from django.db.models import Model as DjangoModel, fields as DjangoFields
 from django.db.models import *
 from django.utils.translation import gettext_lazy as _
 from . import generic
@@ -107,6 +110,16 @@ class TextField(TextField):
         self.formatted= kwargs.pop('formatted', False)
         super().__init__(*args, **kwargs)
 
+
+class DateTimeField(DateTimeField):
+
+    def get_db_prep_value(self, value, *args, **kwargs):
+        return pytz.timezone(timezone.get_current_timezone_name()).localize(value).astimezone(timezone.get_default_timezone()).replace(tzinfo=None) if value else None
+    
+    def from_db_value(self, value, *args, **kwargs):
+        return pytz.timezone(timezone.get_default_timezone_name()).localize(value).astimezone(timezone.get_current_timezone()).replace(tzinfo=None) if value else None
+
+
 class FileField(FileField):
     def __init__(self, *args, extensions=('pdf',), max_size=5, **kwargs):
         self.extensions= extensions

{slthcore-0.2.0 → slthcore-0.2.2}/slth/endpoints.py

@@ -34,7 +34,7 @@ from .components import (
 )
 from .exceptions import JsonResponseException, ReadyResponseException
 from .utils import build_url, append_url
-from .models import PushSubscription, Profile, User, Log
+from .models import PushSubscription, Profile, User, Log, Email
 from slth.queryset import QuerySet
 from slth import APPLICATON, ENDPOINTS
 from . import oauth
@@ -62,41 +62,9 @@ class EnpointMetaclass(type):
             name not in ("Endpoint", "ChildEndpoint")
             and "_ChildEndpoint" not in bases_names
         ):
-            ENDPOINTS[cls.__name__.lower()] = cls
-        if "AdminEndpoint" in bases_names[0:1]:
-            model = cls.__orig_bases__[0].__args__[0]
-            items = (
-                ("Cadastrar", AddEndpoint[model], "plus", "add"),
-                ("Editar", EditEndpoint[model], "pen", "edit"),
-                ("Visualizar", ViewEndpoint[model], "eye", "view"),
-                ("Excluir", DeleteEndpoint[model], "trash", "delete"),
-            )
-            for prefix, base, icon, action in items:
-                endpoint = types.new_class(f"{prefix}{model.__name__}", (base,), {})
-                endpoint.__admin__ = cls
-                endpoint.__action__ = action
-                endpoint.check_permission = lambda self: (
-                    getattr(self.__admin__.instantiate(self.request, self), f'check_{self.__action__}_permission')()
-                )
-                endpoint.Meta = type(
-                    "Meta",
-                    (),
-                    dict(
-                        icon=icon,
-                        modal=prefix != "Visualizar",
-                        verbose_name=f"{prefix} {model._meta.verbose_name}",
-                    ),
-                )
-            if "Meta" not in attrs:
-                cls.Meta = type(
-                    "Meta",
-                    (),
-                    dict(
-                        icon=getattr(model._meta, "icon", None),
-                        modal=False,
-                        verbose_name=f"{model._meta.verbose_name_plural}",
-                    ),
-                )
+            module = cls.__module__.split('.')[-1]
+            key = cls.__name__.lower() if module == 'endpoints' else f'{module}.{cls.__name__.lower()}'
+            ENDPOINTS[key] = cls
         return cls
 
 
@@ -203,7 +171,7 @@ class Endpoint(metaclass=EnpointMetaclass):
                 data = form
         elif isinstance(data, Form) or isinstance(data, ModelForm):
             data = data.settitle(title)
-        elif self.request.method == "POST" and not data:
+        elif self.request.method == "POST":# and not data:
             return self.post()
         return data
 
@@ -230,12 +198,34 @@ class Endpoint(metaclass=EnpointMetaclass):
     @classmethod
     def get_api_name(cls):
         return cls.__name__.lower()
+    
+    @classmethod
+    def get_key_name(cls):
+        module = cls.__module__.split('.')[-1]
+        if module == 'endpoints':
+            return cls.get_api_name()
+        else:
+            return "{}.{}".format(module, cls.get_api_name())
+    
+    @classmethod
+    def get_default_actions(cls):
+        actions = ['add', 'view', 'edit', 'delete']
+        module = cls.__module__.split('.')[-1]
+        if module == 'endpoints':
+            return actions
+        else:
+            return [f'{module}.{name}' for name in actions if f'{module}.{name}' in ENDPOINTS]
 
     @classmethod
     def get_api_url(cls, arg=None):
+        module = cls.__module__.split('.')[-1]
+        if module == 'endpoints':
+            url = "/api/{}/".format(cls.get_api_name())
+        else:
+            url = "/api/{}/{}/".format(module, cls.get_api_name())
         if arg:
-            return f"/api/{cls.get_api_name()}/{arg}/"
-        return f"/api/{cls.get_api_name()}/"
+            url = f"{url}{arg}/"
+        return url
 
     @classmethod
     def get_pretty_name(cls):
@@ -246,10 +236,6 @@ class Endpoint(metaclass=EnpointMetaclass):
             name.append(c)
         return "".join(name)
 
-    @classmethod
-    def get_qualified_name(cls):
-        return "{}.{}".format(cls.__module__, cls.__name__).lower()
-
     @classmethod
     def instantiate(cls, request, source):
         args = ()
@@ -266,28 +252,31 @@ class Endpoint(metaclass=EnpointMetaclass):
     @classmethod
     def get_api_url_pattern(cls):
         args = inspect.getfullargspec(cls.__init__).args[1:]
-        pattern = "{}/".format(cls.get_api_name())
+        module = cls.__module__.split('.')[-1]
+        if module == 'endpoints':
+            pattern = "{}/".format(cls.get_api_name())
+        else:
+            pattern = "{}/{}/".format(module, cls.get_api_name())
         for arg in args:
             pattern = "{}{}/".format(pattern, "<str:{}>".format(arg))
         return pattern
 
-    @classmethod
-    def get_api_metadata(cls, request, base_url, pk=None):
-        action_name = cls.get_metadata("verbose_name")
-        icon = cls.get_metadata("icon")
-        modal = cls.get_metadata("modal")
-        if cls.is_child():
-            url = append_url(base_url, f"action={cls.get_api_name()}")
+    def get_api_metadata(self, request, base_url, pk=None):
+        action_name = self.get_verbose_name()
+        icon = self.get_metadata("icon")
+        modal = self.get_metadata("modal")
+        if self.is_child():
+            url = append_url(base_url, f"action={self.get_key_name()}")
             url = f"{url}&id={pk}" if pk else url
         else:
-            url = build_url(request, f"/api/{cls.get_api_name()}/")
+            url = build_url(request, self.get_api_url())
             url = f"{url}{pk}/" if pk else url
         return dict(
             type="action",
             title=action_name,
             name=action_name,
             url=url,
-            key=cls.get_api_name(),
+            key=self.get_api_name(),
             icon=icon,
             modal=modal,
         )
@@ -299,8 +288,6 @@ class Endpoint(metaclass=EnpointMetaclass):
         if metaclass:
             value = getattr(metaclass, key, None)
         if value is None:
-            if key == "verbose_name":
-                value = cls.get_pretty_name()
             if key == "modal":
                 value = (
                     issubclass(cls, EditEndpoint)
@@ -313,6 +300,9 @@ class Endpoint(metaclass=EnpointMetaclass):
     def get_verbose_name(self):
         return self.get_metadata("verbose_name")
     
+    def get_icon(self):
+        return self.get_metadata("icon")
+    
     def get_instance(self):
         return None
     
@@ -362,6 +352,9 @@ class ModelEndpoint(Endpoint):
             self.model = self.objects(self.model).get(pk=self.pk)
         super().__init__()
 
+    def get_icon(self):
+        return self.model._meta.icon or super().get_icon()
+
 
 class AdminEndpoint(Generic[T], ModelEndpoint):
 
@@ -385,12 +378,33 @@ class AdminEndpoint(Generic[T], ModelEndpoint):
         return self.check_permission()
 
 
+class QuerySetEndpoint(Generic[T], ModelEndpoint):
+    class Meta:
+        modal = False
+
+    def get(self) -> QuerySet:
+        return self.model.objects.contextualize(self.request)
+    
+    def get_verbose_name(self):
+        return self.get_metadata('verbose_name', self.model._meta.verbose_name_plural)
+
+
 class ListEndpoint(Generic[T], ModelEndpoint):
+    class Meta:
+        modal = False
+
     def get(self) -> QuerySet:
-        return self.model.objects#.contextualize(self.request)
+        return self.model.objects.all().contextualize(self.request).actions(*self.get_default_actions())
+    
+    def get_verbose_name(self):
+        return self.get_metadata('verbose_name', self.model._meta.verbose_name_plural)
 
 
 class AddEndpoint(Generic[T], ModelEndpoint):
+    class Meta:
+        icon = 'plus'
+        modal = True
+
     def __init__(self):
         super().__init__()
         self.instance = self.model()
@@ -403,6 +417,9 @@ class AddEndpoint(Generic[T], ModelEndpoint):
     
     def formfactory(self):
         return self.instance.formfactory()
+    
+    def get_verbose_name(self):
+        return f'Cadastrar {self.model._meta.verbose_name}'
 
 
 class ModelInstanceEndpoint(ModelEndpoint):
@@ -428,21 +445,28 @@ class ViewEndpoint(Generic[T], ModelInstanceEndpoint):
     class Meta:
         icon = "eye"
         modal = False
-        verbose_name = "Visualizar"
+        verbose_name = 'Visualizar'
 
     def get(self) -> Serializer:
         return self.get_instance().serializer().contextualize(self.request)
 
-    def get_verbose_name(self):
-        return str(self.get_instance())
-
 
 class EditEndpoint(Generic[T], ModelInstanceEndpoint):
+    class Meta:
+        modal = True
+        icon = 'pen'
+        verbose_name = 'Editar'
+        
     def get(self) -> FormFactory:
         return self.get_instance().formfactory()
 
 
 class DeleteEndpoint(Generic[T], ModelInstanceEndpoint):
+    class Meta:
+        modal = True
+        icon = 'trash'
+        verbose_name = 'Excluir'
+
     def get(self) -> FormFactory:
         return self.formfactory(self.get_instance()).fields()
 
@@ -741,28 +765,28 @@ class Dashboard(Endpoint):
         serializer = Serializer(request=self.request)
         if APPLICATON["dashboard"]["boxes"]:
             boxes = Boxes("Acesso Rápido")
-            for endpoint in APPLICATON["dashboard"]["boxes"]:
-                cls = ENDPOINTS[endpoint]
-                if cls().contextualize(self.request).check_permission():
-                    icon = cls.get_metadata("icon", "check")
-                    label = cls.get_metadata("verbose_name")
+            for name in APPLICATON["dashboard"]["boxes"]:
+                cls = ENDPOINTS[name]
+                endpoint = cls().contextualize(self.request)
+                if endpoint.check_permission():
+                    icon = endpoint.get_icon() or "check"
+                    label = endpoint.get_verbose_name()
                     url = build_url(self.request, cls.get_api_url())
                     boxes.append(icon, label, url)
             serializer.append("Acesso Rápido", boxes)
         if APPLICATON["dashboard"]["top"]:
             group = serializer.group("Top")
-            for endpoint in APPLICATON["dashboard"]["top"]:
-                cls = ENDPOINTS[endpoint]
-                if cls.instantiate(
-                    self.request, self.request.user
-                ).check_permission():
+            for name in APPLICATON["dashboard"]["top"]:
+                cls = ENDPOINTS[name]
+                endpoint = cls.instantiate(self.request, self.request.user)
+                if endpoint.check_permission():
                     group.endpoint(
                         cls.get_metadata("verbose_name"), cls, wrap=False
                     )
             group.parent()
         if APPLICATON["dashboard"]["center"]:
-            for endpoint in APPLICATON["dashboard"]["center"]:
-                cls = ENDPOINTS[endpoint]
+            for name in APPLICATON["dashboard"]["center"]:
+                cls = ENDPOINTS[name]
                 serializer.endpoint(
                     cls.get_metadata("verbose_name"), cls, wrap=False
                 )
@@ -891,7 +915,12 @@ class PushSubscribe(Endpoint):
         return True
 
 
-class PushSubscriptions(ListEndpoint[PushSubscription]):
+class Emails(AdminEndpoint[Email]):
+    class Meta:
+        verbose_name = "E-mails"
+
+
+class PushSubscriptions(AdminEndpoint[PushSubscription]):
     class Meta:
         verbose_name = "Notificações"
 

{slthcore-0.2.0 → slthcore-0.2.2}/slth/forms.py

@@ -386,9 +386,10 @@ class FormMixin:
             data["onchange"] = absolute_url(self.request, f"on_change={name}")
         if name in self._actions:
             cls = ENDPOINTS[self._actions[name]]
-            if cls.instantiate(self.request, self).check_permission():
+            endpoint = cls.instantiate(self.request, self)
+            if endpoint.check_permission():
                 data.update(
-                    action=cls.get_api_metadata(
+                    action=endpoint.get_api_metadata(
                         self.request, absolute_url(self.request)
                     )
                 )

slthcore-0.2.2/slth/middleware/timezone.py

@@ -0,0 +1,25 @@
+import pytz
+from datetime import datetime
+from django.utils import timezone
+
+class Middleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        tz = request.path[0] == '/' and (request.META.get('HTTP_TZ') or request.META.get('TZ'))
+        if tz:
+            timezone.activate(pytz.timezone(tz))
+        response = self.get_response(request)
+        if tz:
+            timezone.deactivate()
+        return response
+
+def now():
+    return datetime.now().astimezone(timezone.get_current_timezone()).replace(tzinfo=None)
+
+def today():
+    return now().date()
+
+def local_datetime(dt, tz):
+    pass

slthcore-0.2.2/slth/migrations/0008_alter_deletion_datetime_alter_log_datetime.py

@@ -0,0 +1,24 @@
+# Generated by Django 4.2.6 on 2024-09-09 07:10
+
+from django.db import migrations
+import slth.db.models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('slth', '0007_deletion_log'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='deletion',
+            name='datetime',
+            field=slth.db.models.DateTimeField(null=True, verbose_name='Data/Hora'),
+        ),
+        migrations.AlterField(
+            model_name='log',
+            name='datetime',
+            field=slth.db.models.DateTimeField(null=True, verbose_name='Data/Hora'),
+        ),
+    ]

slthcore-0.2.2/slth/migrations/0009_remove_email_from_email_email_action_email_attempt_and_more.py

@@ -0,0 +1,43 @@
+# Generated by Django 5.1.1 on 2024-09-16 11:01
+
+import slth.db.models
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('slth', '0008_alter_deletion_datetime_alter_log_datetime'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='email',
+            name='from_email',
+        ),
+        migrations.AddField(
+            model_name='email',
+            name='action',
+            field=slth.db.models.CharField(max_length=255, null=True, verbose_name='Ação'),
+        ),
+        migrations.AddField(
+            model_name='email',
+            name='attempt',
+            field=slth.db.models.IntegerField(default=0, verbose_name='Tentativa de Envio'),
+        ),
+        migrations.AddField(
+            model_name='email',
+            name='error',
+            field=slth.db.models.TextField(null=True, verbose_name='Erro'),
+        ),
+        migrations.AddField(
+            model_name='email',
+            name='send_at',
+            field=slth.db.models.DateTimeField(null=True, verbose_name='Data/Hora'),
+        ),
+        migrations.AddField(
+            model_name='email',
+            name='url',
+            field=slth.db.models.CharField(max_length=255, null=True, verbose_name='URL'),
+        ),
+    ]

{slthcore-0.2.0 → slthcore-0.2.2}/slth/models.py

@@ -1,6 +1,7 @@
 import os
 import json
 import binascii
+import traceback
 from .db import models, meta
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _
@@ -10,6 +11,7 @@ from django.apps import apps
 from datetime import datetime
 from django.utils.html import strip_tags
 from django.core import serializers
+from django.template.loader import render_to_string
 from django.core.mail import EmailMultiAlternatives
 from .notifications import send_push_web_notification
 from slth import APPLICATON
@@ -103,15 +105,6 @@ class Role(models.Model):
         return '{} - {}'.format(self.get_verbose_name(), scope_value) if scope_value else self.get_verbose_name()
 
 
-class EmailManager(models.Manager):
-    def all(self):
-        return self.order_by('-id')
-
-    def send(self, to, subject, content, from_email=None):
-        to = [to] if isinstance(to, str) else list(to)
-        return self.create(from_email=from_email or 'no-replay@mail.com', to=', '.join(to), subject=subject, content=content)
-
-
 class PushSubscription(models.Model):
     user = models.ForeignKey('auth.user', verbose_name='Usuário', on_delete=models.CASCADE)
     device = models.CharField(verbose_name='Dispositivo')
@@ -144,12 +137,27 @@ class Error(models.Model):
         verbose_name_plural = 'Erros'
 
 
+class EmailManager(models.Manager):
+    def all(self):
+        return self.order_by('-id')
+
+    def send(self, to, subject, content, send_at=None, action=None, url=None):
+        to = [to] if isinstance(to, str) else list(to)
+        return self.create(to=', '.join(to), subject=subject, content=content, send_at=send_at, action=action, url=url)
+
+
 class Email(models.Model):
-    from_email = models.EmailField('Remetente')
     to = models.TextField('Destinatário', help_text='Separar endereços de e-mail por ",".')
     subject = models.CharField('Assunto')
     content = models.TextField('Conteúdo', formatted=True)
+    send_at = models.DateTimeField('Data/Hora', null=True)
     sent_at = models.DateTimeField('Data/Hora', null=True)
+    attempt = models.IntegerField('Tentativa de Envio', default=0)
+    
+    action = models.CharField('Ação', null=True)
+    url = models.CharField('URL', null=True)
+
+    error = models.TextField('Erro', null=True)
 
     objects = EmailManager()
 
@@ -161,13 +169,32 @@ class Email(models.Model):
         return self.subject
 
     def save(self, *args, **kwargs):
+        self.from_email = settings.DEFAULT_FROM_EMAIL
+        if 1 or self.sent_at is None:
+            self.send()
+        super().save(*args, **kwargs)
+    
+    def send(self):
         to = [email.strip() for email in self.to.split(',')]
         msg = EmailMultiAlternatives(self.subject, strip_tags(self.content), self.from_email, to)
-        msg.attach_alternative(self.content, "text/html")
-        if self.sent_at is None:
-            msg.send(fail_silently=True)
-            self.sent_at = datetime.now()
-        super().save(*args, **kwargs)
+        content = render_to_string('email.html', dict(email=self, title=APPLICATON['title']))
+        msg.attach_alternative(content, "text/html")
+        self.send_at = datetime.now()
+        self.attempt = self.attempt + 1
+        try:
+            msg.send(fail_silently=False)
+            self.sent_at = self.send_at
+        except Exception as e:
+            self.error = str(e)
+            traceback.print_exc()
+        super().save()
+
+    def formfactory(self):
+        return super().formfactory().fieldset(
+            'Dados Gerais', ('subject', 'to', 'content')
+        ).fieldset(
+            'Botão', ('action', 'url')
+        )
 
 
 class Profile(models.Model):

{slthcore-0.2.0 → slthcore-0.2.2}/slth/pdf/__init__.py

@@ -28,6 +28,9 @@ class PdfWriter:
     def render(self, template_name, context):
         context.update(base_url=settings.SITE_URL)
         html = render_to_string(template_name, context)
+        self.write(html)
+
+    def write(self, html):
         self.pdf.write_html(html, tag_styles=STYLE, font_family="Courier")
 
     def save(self, path):
@@ -45,14 +48,14 @@ class PdfSigner:
         self.offset = len(self.content)
         self.byterange = []
         self.path = path.split('.')[0]
-        self.startxref = [int(x[9:].strip()) for x in re.findall(b'startxref[\n\r ]*\d+', self.content)]
+        self.startxref = [int(x[9:].strip()) for x in re.findall(b'startxref[\n\r ]*\\d+', self.content)]
         self.objects = {}
-        for xref in re.findall(b'xref[\n\r\w\d ]*trailer', self.content[self.startxref[0]:]):
-            for offset in sum([[int(n) for n in re.findall(b'\d{10}', xref) if int(n)]], []):
+        for xref in re.findall(b'xref[\n\r\\w\\d ]*trailer', self.content[self.startxref[0]:]):
+            for offset in sum([[int(n) for n in re.findall(b'\\d{10}', xref) if int(n)]], []):
                 self.objects[b' '.join(self.content[offset:offset + 15].split()[0:2]).decode()] = offset
         self.trailer = self.content[self.startxref[-1]:].split(b'trailer')[1].split(b'startxref')[0].strip()
-        self.root = root = re.findall(b'/Root \d+ \d+ R', self.trailer)[-1][6:-2].decode()
-        self.size = int(re.findall(b'/Size \d+', self.trailer)[-1][5:].strip())
+        self.root = root = re.findall(b'/Root \\d+ \\d+ R', self.trailer)[-1][6:-2].decode()
+        self.size = int(re.findall(b'/Size \\d+', self.trailer)[-1][5:].strip())
         self.page()
 
     def obj(self, key=None):

{slthcore-0.2.0 → slthcore-0.2.2}/slth/queryset.py

@@ -261,9 +261,10 @@ class QuerySet(models.QuerySet):
                 queryset_actions.append(cls)
 
         for cls in queryset_actions:
-            if cls.instantiate(self.request, self).check_permission():
-                action = cls.get_api_metadata(self.request, base_url)
-                action['name'] = action['name'].replace(" {}".format(self.model._meta.verbose_name.title()), "")
+            endpoint = cls.instantiate(self.request, self)
+            if endpoint.check_permission():
+                action = endpoint.get_api_metadata(self.request, base_url)
+                #action['name'] = action['name'].replace(" {}".format(self.model._meta.verbose_name.title()), "")
                 if relations and cls.get_metadata('modal'):
                         params = '&'.join(f'{k}={v}' for k, v in relations.items())
                         action['url'] = append_url(action['url'], params)
@@ -357,8 +358,9 @@ class QuerySet(models.QuerySet):
                 serializer.obj = obj
                 serialized = serializer.serialize(forward_exception=True)
                 for cls in instance_actions:
-                    if cls.instantiate(self.request, obj).check_permission():
-                        action = cls.get_api_metadata(self.request, base_url, obj.pk)
+                    endpoint = cls.instantiate(self.request, obj)
+                    if endpoint.check_permission():
+                        action = endpoint.get_api_metadata(self.request, base_url, obj.pk)
                         action['name'] = action['name'].replace(" {}".format(self.model._meta.verbose_name), "")
                         if relations and cls.get_metadata('modal'):
                             params = '&'.join(f'{k}={v}' for k, v in relations.items())