slthcore 0.0.5__tar.gz → 0.0.7__tar.gz

{slthcore-0.0.5/slthcore.egg-info → slthcore-0.0.7}/PKG-INFO

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

{slthcore-0.0.5 → slthcore-0.0.7}/setup.py

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

{slthcore-0.0.5 → slthcore-0.0.7}/slth/components.py

@@ -170,9 +170,10 @@ class Table(dict):
 
 
 class TemplateContent(dict):
-    def __init__(self, name, context):
+    def __init__(self, name, context, autoreload=None):
         self["type"] = "html"
         self["content"] = render_to_string(name, context)
+        self["autoreload"] = autoreload * 1000 if autoreload else None
 
 
 class Banner(dict):
@@ -284,11 +285,11 @@ class Grid(dict):
 
 
 class Scheduler(dict):
-    INTERVALS = {1: ["00"], 2: ["00", "30"]}
+    INTERVALS = {1: ["00"], 2: ["00", "30"], 3: ["00", "20", "40"]}
 
     def __init__(
         self,
-        start_time=7,
+        start_time=0,
         end_time=23,
         chucks=2,
         start_day=None,
@@ -296,19 +297,37 @@ class Scheduler(dict):
         single_selection=False,
         input_name="schedule",
         readonly=False,
+        title=None,
+        watch=[],
+        url=None,
+        selectable=None,
+        weekly=False
     ):
         self["type"] = "scheduler"
+        self["title"] = title
         self["single_selection"] = single_selection
         self["input_name"] = input_name
         self["readonly"] = readonly
-        self.end_day = start_day or datetime.now()
-        self.end_day = datetime(self.end_day.year, self.end_day.month, self.end_day.day)
+        self["watch"] = watch
+        self["url"] = url
+        self["selectable"] = ['{} {}'.format(obj.strftime("%d/%m/%Y"), obj.strftime("%H:%M")) for obj in selectable] if selectable is not None else None
+        self["weekly"] = weekly
+        if weekly:
+            self.end_day = datetime.now()
+            while self.end_day.weekday() > 0:
+                self.end_day = self.end_day - timedelta(days=1)
+            days = 7
+        else:
+            self.end_day = start_day or datetime.now()
+            self.end_day = datetime(self.end_day.year, self.end_day.month, self.end_day.day)
         self.times = []
         for hour in range(start_time, end_time + 1):
             for minute in Scheduler.INTERVALS[chucks]:
                 self.times.append("{}:{}".format(str(hour).rjust(2, "0"), minute))
         self.days = []
         for n in range(0, days):
+            if n == 0:
+                self.start_day = self.end_day
             self.days.append(self.end_day.strftime("%d/%m/%Y"))
             self.end_day = self.end_day + timedelta(days=1)
         self.end_day = datetime(self.end_day.year, self.end_day.month, self.end_day.day, 23, 59, 59)
@@ -327,13 +346,20 @@ class Scheduler(dict):
                 row.append(self["slots"][day][time])
             self["matrix"].append(row)
 
-    def append(self, date_time, text, icon='check'):
-        day = date_time.strftime("%d/%m/%Y")
-        time = date_time.strftime("%H:%M")
-        value = dict(text=text, icon=icon)
-        self["slots"][day][time] = value
-        j = self.days.index(day) + 1 if day in self.days else -1
-        x = self.times.index(time) + 1 if time in self.times else -1
-        self["matrix"][x][j] = value
-
-        
+    def append(self, date_time, text=None, icon='check'):
+        if date_time.strftime("%d/%m/%Y") in self.days:
+            day = date_time.strftime("%d/%m/%Y")
+            time = date_time.strftime("%H:%M")
+            value = dict(text=text, icon=icon)
+            self["slots"][day][time] = value
+            j = self.days.index(day) + 1 if day in self.days else -1
+            x = self.times.index(time) + 1 if time in self.times else -1
+            self["matrix"][x][j] = value
+
+    def append_weekday(self, weekday, hour, minute):
+        date_time = self.start_day
+        while date_time < self.end_day + timedelta(days=-1):
+            if date_time.weekday() == int(weekday):
+                self.append(datetime(date_time.year, date_time.month, date_time.day, hour, minute, 0))
+            date_time += timedelta(days=1)
+    

{slthcore-0.0.5 → slthcore-0.0.7}/slth/db/models.py

@@ -10,22 +10,26 @@ GenericField = generic.GenericField
 class CharField(CharField):
     def __init__(self, *args, **kwargs):
         self.mask = kwargs.pop('mask', None)
+        self.pick = kwargs.pop('pick', False)
         kwargs.setdefault('max_length', 255)
         super().__init__(*args, **kwargs)
 
     def formfield(self, *args, **kwargs):
         field = super().formfield(*args, **kwargs)
         field.mask = self.mask
+        field.pick = self.pick
         return field
     
 class IntegerField(IntegerField):
     def __init__(self, *args, **kwargs):
         self.mask = kwargs.pop('mask', None)
+        self.pick = kwargs.pop('pick', False)
         super().__init__(*args, **kwargs)
 
     def formfield(self, *args, **kwargs):
         field = super().formfield(*args, **kwargs)
         field.mask = self.mask
+        field.pick = self.pick
         return field
 
 class ForeignKey(ForeignKey):

{slthcore-0.0.5 → slthcore-0.0.7}/slth/endpoints.py

@@ -1,7 +1,9 @@
+import io
 import json
 import types
 import inspect
-
+import requests
+from weasyprint import HTML
 from .models import Token, Role, Log, Deletion
 from django.apps import apps
 from typing import TypeVar, Generic
@@ -9,13 +11,14 @@ from django.core.cache import cache
 from django.conf import settings
 from django.utils.text import slugify
 from django.db import models
-from django.http import JsonResponse
+from django.http import JsonResponse, HttpResponse
 from django.views.decorators.csrf import csrf_exempt
 from .factory import FormFactory
 from django.core.exceptions import ValidationError
 from slth import forms
 from django.db.models import Model
 from datetime import datetime
+from django.template.loader import render_to_string
 from django.contrib.auth import authenticate
 from .forms import ModelForm, Form
 from .serializer import serialize, Serializer
@@ -27,8 +30,9 @@ from .components import (
     Response,
     Boxes,
     IconSet,
+    TemplateContent,
 )
-from .exceptions import JsonResponseException
+from .exceptions import JsonResponseException, ReadyResponseException
 from .utils import build_url, append_url
 from .models import PushSubscription, Profile, User, Log
 from slth.queryset import QuerySet
@@ -148,6 +152,29 @@ class Endpoint(metaclass=EnpointMetaclass):
 
     def redirect(self, url):
         raise JsonResponseException(dict(type="redirect", url=url))
+    
+    def render(self, data, template=None, pdf=False, autoreload=None):
+        base_url='http://localhost:8000'
+        data.update(base_url=base_url)
+        if template is None:
+            template = '{}.html'.format(template or self.__class__.__name__.lower())
+        if pdf:
+            buffer = io.BytesIO()
+            if isinstance(template, str):
+                templates = template,
+            else:
+                templates = template
+            pages = []
+            for template in templates:
+                html = render_to_string(template, data)
+                if pdf:
+                    doc = HTML(string=html).render()
+                    pages.extend(doc.pages)
+            new_doc = doc.copy(pages=pages)
+            new_doc.write_pdf(buffer, base_url=base_url, stylesheets=[])
+            buffer.seek(0)
+            raise ReadyResponseException(HttpResponse(buffer, content_type='application/pdf'))
+        return TemplateContent(template, data, autoreload=autoreload)
 
     def getform(self, form):
         return form
@@ -309,11 +336,26 @@ class Endpoint(metaclass=EnpointMetaclass):
                 tl.context.update(model=model, pk=pk or instance.pk)
             Log.objects.create(data=tl.context)
 
+    def absolute_url(self, relative_url):
+        return "{}://{}{}".format(self.request.META.get('X-Forwarded-Proto', self.request.scheme), self.request.get_host(), relative_url)
+
+
 class PublicEndpoint(Endpoint):
     def check_permission(self):
         return True
 
 
+class ReportEndpoint(Endpoint):
+
+    def process(self):
+        data = super().process()
+        template = '{}.html'.format(self.__class__.__name__.lower())
+        html = render_to_string(template, data)
+        headers = {'Content-type': 'text/html'}
+        response = requests.post('http://weasyprint.aplicativo.click/pdf', headers=headers, data=html)
+        raise ReadyResponseException(HttpResponse(response.content, content_type='application/pdf'))
+
+
 class ModelEndpoint(Endpoint):
     def __init__(self):
         self.model = self.__orig_bases__[0].__args__[0]
@@ -418,6 +460,27 @@ class ChildEndpoint(Endpoint):
 
     def check_permission(self):
         return True
+    
+class RelationEndpoint(Generic[T], ModelEndpoint):
+    def __init__(self):
+        super().__init__()
+        self.instance = self.model()
+        
+    def get(self) -> FormFactory:
+        return self.formfactory()
+
+    def get_instance(self):
+        return self.instance
+    
+    def formfactory(self):
+        return super().formfactory(self.instance)
+    
+    @classmethod
+    def is_child(cls):
+        return True
+
+    def check_permission(self):
+        return True
 
 
 class Add(ChildEndpoint):

slthcore-0.0.7/slth/exceptions.py

@@ -0,0 +1,11 @@
+
+class JsonResponseException(Exception):
+
+    def __init__(self, data, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.data = data
+
+class ReadyResponseException(Exception):
+    def __init__(self, response, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.response = response

{slthcore-0.0.5 → slthcore-0.0.7}/slth/factory.py

@@ -18,6 +18,7 @@ class FormFactory:
         self._redirect = None
         self._message = None
         self._dispose = False
+        self._image = None
 
     def _append_field(self, field_name):
         if ':' in field_name:
@@ -25,6 +26,10 @@ class FormFactory:
             self._actions[field_name] = action_name
         self._fieldlist.append(field_name)
         return field_name
+    
+    def image(self, image) -> 'FormFactory':
+        self._image = image
+        return self
 
     def fields(self, *names, **values) -> 'FormFactory':
         not_str = {name for name in names if not isinstance(name, str)}
@@ -112,6 +117,7 @@ class FormFactory:
         form._message = self._message
         form._redirect = self._redirect
         form._dispose = self._dispose
+        form._image = self._image
         for name in self._fieldlist:
             if name not in form.fields:
                 form.fields[name] = getattr(endpoint, name)

{slthcore-0.0.5 → slthcore-0.0.7}/slth/forms.py

@@ -166,6 +166,7 @@ class FormMixin:
             style=self.get_metadata("style"),
             url=absolute_url(self.request),
             info=self._info,
+            image=self._image,
         )
         data.update(
             controls=self.controller.controls, width=self.get_metadata("width", "100%")
@@ -337,21 +338,21 @@ class FormMixin:
             for word in ("password", "senha"):
                 if word in name:
                     data.update(type="password")
+            pick = getattr(field, "pick", False)
             if isinstance(field, CharField) or isinstance(field, IntegerField):
                 mask = getattr(field, "mask", None)
                 if mask:
                     data.update(mask=mask)
-            if isinstance(field, CharField) and isinstance(field.widget, Textarea):
+            if isinstance(field.widget, Textarea):
                 data.update(type="textarea")
             if ftype == "decimal":
                 data.update(mask="decimal")
             elif ftype == "scheduler":
                 data.update(scheduler=field.scheduler)
-            elif ftype == "choice":
+            elif ftype == "choice" or pick:
                 if name in self.request.GET and not choices_field_name:
                     data.update(type="hidden", value=self.request.GET[name])
                 else:
-                    pick = getattr(field, "pick", False)
                     if choices_field_name == fname or (isinstance(field.choices, ModelChoiceIterator) and not pick):
                         if choices_field_name == fname:
                             qs = field.choices.queryset
@@ -466,6 +467,13 @@ class FormMixin:
                     if field_name not in inline_fields
                 }
             )
+            for attr_name in dir(self._endpoint):
+                if attr_name.startswith('clean_'):
+                    try:
+                        getattr(self._endpoint, attr_name)(data)
+                    except ValidationError as e:
+                        fieldname = attr_name.replace('clean_', '')
+                        raise JsonResponseException(dict(type="error", text="Por favor, corrija os erros.", errors={fieldname: ''.join(e.messages)}))
             with transaction.atomic():
                 self.cleaned_data = data
                 if isinstance(self, DjangoModelForm):
@@ -506,6 +514,7 @@ class Form(DjangoForm, FormMixin):
         self._display = []
         self._endpoint = endpoint
         self._info = None
+        self._image = None
         self._message = None
         self._redirect = None
         self._dispose = False
@@ -540,6 +549,7 @@ class ModelForm(DjangoModelForm, FormMixin):
         self._display = []
         self._endpoint = endpoint
         self._info = None
+        self._image = None
         self._message = None
         self._redirect = None
         self._dispose = False
@@ -568,6 +578,9 @@ class ModelForm(DjangoModelForm, FormMixin):
             kwargs.update(files=self.request.FILES or None)
         super().__init__(instance=instance, **kwargs)
 
+    def is_valid(self):
+        valid = super().is_valid()
+        return valid
 
 class InlineFormField(Field):
     def __init__(self, *args, form=None, min=1, max=3, **kwargs):
@@ -691,7 +704,7 @@ class SchedulerField(CharField):
         self.scheduler = scheduler or Scheduler()
         super().__init__(*args, **kwargs)
 
-    def clean(self, value):
+    def to_python(self, value):
         values = dict(select=[], deselect=[])
         if value:
             data = json.loads(value)
@@ -699,7 +712,17 @@ class SchedulerField(CharField):
                 for date, hour in data[key]:
                     data_string = "{} {}".format(date, hour)
                     values[key].append(datetime.datetime.strptime(data_string, "%d/%m/%Y %H:%M"))
-        return values
+        if self.scheduler["single_selection"]:
+            return values['select'][0] if values['select'] else None
+        else:
+            return values
+    
+    def clean(self, value):
+        value = self.to_python(value)
+        if self.scheduler["single_selection"]:
+            if self.required and value is None:
+                raise ValidationError('Este campo é obrigatório.')
+        return value
 
 
 FIELD_TYPES = {

{slthcore-0.0.5 → slthcore-0.0.7}/slth/models.py

@@ -95,7 +95,7 @@ class Role(models.Model):
         return APPLICATON['groups'].get(self.name, self.name)
 
     def get_scope_value(self):
-        return apps.get_model(self.model).objects.get(pk=self.value) if self.model else None
+        return apps.get_model(self.model).objects.filter(pk=self.value).first() if self.model else None
 
     @meta('Descrição')
     def get_description(self):

{slthcore-0.0.5 → slthcore-0.0.7}/slth/notifications.py

@@ -6,6 +6,7 @@ from slth import APPLICATON
 def send_push_web_notification(user, title, message, url=None, icon=None):
     icon = icon or APPLICATON['icon']
     for subscription in user.pushsubscription_set.all():
+        print(subscription.user, subscription.device, subscription.data, title, message, url)
         data = webpush(
             subscription_info=subscription.data,
             data=json.dumps(dict(title=title, message=message, url=url, icon=icon)),

slthcore-0.0.7/slth/printer.py

@@ -0,0 +1,70 @@
+import io
+import qrcode
+import base64
+from datetime import datetime
+from weasyprint import HTML
+from django.conf import settings
+from django.template.loader import render_to_string
+
+
+class Signature:
+    def __init__(self, date, validation_url, verify_code=None, auth_code=None):
+        self.date = date
+        if validation_url.startswith('http'):
+            self.validation_url = validation_url
+        else:
+            self.validation_url = '{}{}'.format(settings.SITE_URL, validation_url)
+        self.verify_code = verify_code
+        self.auth_code = auth_code
+        self.signers = []
+        self.qrcode = qrcode_base64(self.validation_url)
+
+    def add_signer(self, identifier, signature_date=None):
+        self.signers.append((identifier, signature_date))
+
+
+def qrcode_base64(texto):
+    qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=4)
+    qr.add_data(texto)
+    qr.make(fit=True)
+    img = qr.make_image(fill_color="black", back_color="white")
+    buffered =io.BytesIO()
+    img.save(buffered, format="JPEG")
+    img_str = base64.b64encode(buffered.getvalue()).decode()
+    return img_str
+
+def image_base64(image_bytes):
+    return 'data:image/png;base64, {}'.format(base64.b64encode(image_bytes).decode())
+
+
+def to_pdf(data, template, file_name=None, signature=None):
+    templates = []
+    buffer = io.BytesIO()
+    templates.append(template)
+    if signature:
+        data.update(signature=signature)
+        templates.append('signature.html')
+    pages = []
+    for template in templates:
+        data.update(page=len(pages)+1)
+        html = render_to_string(template, data)
+        doc = HTML(string=html).render()
+        pages.extend(doc.pages)
+    doc = doc.copy(pages=pages) if len(templates) > 1 else doc
+    doc.write_pdf(file_name or buffer, base_url=settings.SITE_URL, stylesheets=[])
+    buffer.seek(0)
+    return buffer
+
+def test():
+    data = dict(lines=range(50))
+    signature = Signature(date=datetime.now(), validation_url='/', verify_code=123, auth_code=123)
+    signature.add_signer('Carlos Silva', datetime.now())
+    signature.add_signer('Juca Silva', None)
+    to_pdf(data, 'report.html', '/Users/breno/Downloads/a.pdf', signature=signature)
+
+def test2():
+    data = dict(lines=range(50))
+    signature = Signature(date=datetime.now(), validation_url='https://validar.iti.gov.br/')
+    signature.add_signer('Carlos Silva (075.803.982-90)', None)
+    signature.add_signer('Juca Silva (075.803.982-90)', None)
+    to_pdf(data, 'report.html', '/Users/breno/Downloads/a.pdf', signature=signature)

{slthcore-0.0.5 → slthcore-0.0.7}/slth/queryset.py

@@ -22,6 +22,7 @@ class QuerySet(models.QuerySet):
 
     def __init__(self, *args, **kwargs):
         self.metadata = {}
+        self.instance = None
         self.request = None
         super().__init__(*args, **kwargs)
 
@@ -36,6 +37,7 @@ class QuerySet(models.QuerySet):
 
     def _clone(self):
         qs = super()._clone()
+        qs.instance = self.instance
         qs.request = self.request
         for k, v in self.metadata.items():
             v = self.metadata[k]

{slthcore-0.0.5 → slthcore-0.0.7}/slth/serializer.py

@@ -288,7 +288,7 @@ class Serializer:
                             value = attr().filter()
                         else:
                             value = attr.filter()
-                    
+                        value.instance = self.obj
                         path = self.path + [key]
                         if lazy:
                             data = dict(type='queryset', title=title, key=key)