slthcore 0.0.4__tar.gz → 0.0.5__tar.gz

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

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

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

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

{slthcore-0.0.4 → slthcore-0.0.5}/slth/__init__.py

@@ -1,18 +1,23 @@
 import re
 import os
 import yaml
+import json
 import warnings
 from pathlib import Path
+from datetime import datetime
 from django.apps import apps
 from django.db import models
 from .queryset import QuerySet
 from django.db.models import manager
-from .serializer import Serializer
+from .serializer import Serializer, serialize
+from django.db.models.deletion import Collector
 from .factory import FormFactory
 import django.db.models.options as options
 from django.db.models.base import ModelBase
 from django.core.exceptions import FieldDoesNotExist
 from django.utils.autoreload import autoreload_started
+from django.core import serializers
+from .threadlocal import tl
 
 warnings.filterwarnings('ignore', module='urllib3')
 
@@ -89,6 +94,83 @@ class ModelMixin(object):
     
     def formfactory(self) -> FormFactory:
         return FormFactory(self)
+    
+    def pre_save(self):
+        pass
+
+    def post_save(self):
+        pass
+
+    def safe_delete(self, username=None):
+        from .models import Deletion
+        order = []
+        objects = []
+        collector = Collector('default')
+        qs = type(self).objects.filter(pk=self.pk)
+        collector.collect(qs)
+        for instances in collector.data.values():
+            for instance in instances:
+                if instance.__class__.__name__ not in ['Log'] and instance not in objects:
+                    objects.append(instance)
+                    if instance.__class__.__name__ not in order:
+                        order.append(instance.__class__.__name__)
+        for qs in collector.fast_deletes:
+            for instance in qs:
+                if instance.__class__.__name__ not in ['Log'] and instance not in objects:
+                    objects.append(instance)
+                    if instance.__class__.__name__ not in order:
+                        order.append(instance.__class__.__name__)
+        backup  = json.dumps(dict(order=order, objects=serializers.serialize("python", objects)))
+        instance = '{}.{}:{}'.format(self._meta.app_label, self._meta.model_name, self.pk)
+        Deletion.objects.create(username=username, datetime=datetime.now(), instance=instance, backup=backup)
+        return self.delete()
+
+
+def save_decorator(func):
+    
+    def decorate(self, *args, **kwargs):
+        diff = {}
+        if self.pk:
+            action = 'edit'
+            obj = type(self).objects.filter(pk=self.pk).first()
+            if obj:
+                for field in self._meta.fields:
+                    a = getattr(obj, field.name)
+                    b = getattr(self, field.name)
+                    if a != b:
+                        diff[field.verbose_name] = (serialize(a), serialize(b))
+        else:
+            action = 'add'
+            for field in self._meta.fields:
+                b = getattr(self, field.name)
+                if b is not None:
+                    diff[field.verbose_name] = (None, serialize(b))
+        func(self, *args, **kwargs)
+        if diff:
+            model = '{}.{}'.format(self._meta.app_label, self._meta.model_name)
+            log = dict(model=model, pk=self.pk, action=action, diff=diff)
+            context = getattr(tl, 'context', None)
+            if context:
+                context['logs'].append(log)
+
+    return decorate
+
+
+def delete_decorator(func):
+    def decorate(self, *args, **kwargs):
+        diff = {}
+        for field in self._meta.fields:
+            a = getattr(self, field.name)
+            diff[field.verbose_name] = (a, None)
+        log = dict(model='{}.{}'.format(
+            self._meta.app_label, self._meta.model_name), action='delete', diff=diff
+        )
+        context = getattr(tl, 'context', None)
+        if context:
+            context['logs'].append(log)
+        func(self, *args, **kwargs)
+
+    return decorate
 
 
 ___new___ = ModelBase.__new__
@@ -109,6 +191,9 @@ def __new__(mcs, name, bases, attrs, **kwargs):
     cls = ___new___(mcs, name, bases, attrs, **kwargs)
     if cls._meta.proxy_for_model:
         PROXIED_MODELS.append(cls._meta.proxy_for_model)
+    if name == 'Model':
+        cls.save = save_decorator(cls.save)
+        cls.delete = delete_decorator(cls.delete)
     return cls
 
 

slthcore-0.0.5/slth/cmd/configure/__main__.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import pathlib
+from slth.utils import parse_string_template
+from subprocess import Popen, PIPE
+
+
+USAGE = 'USAGE: python -m slth.cmd.configure [nginx|systemctl]'
+
+NGINX = '''server {
+ listen 80;
+ server_name {{ server_name }};
+ {% if ssl %}
+ listen 443 ssl;
+ ssl_certificate /etc/letsencrypt/live/{{ server_name }}/fullchain.pem;
+ ssl_certificate_key /etc/letsencrypt/live/{{ server_name }}/privkey.pem;
+ if ($scheme = http) { return 301 https://$server_name$request_uri; }
+ {% endif %}
+ location / {
+  proxy_pass http://127.0.0.1:{{ port }};
+ }
+}'''
+
+SERVICE_SCRIPT = '''#!/bin/bash
+source .venv/bin/activate
+
+export POSTGRES_HOST=localhost
+export POSTGRES_DB={{ name }}
+
+python manage.py sync
+gunicorn api.wsgi -b 0.0.0.0:8000 -w 3 --log-level info --reload --timeout 3600
+'''
+
+SERVICE_CONTENT = '''[Unit]
+Description={{ server_name }}
+
+[Service]
+User=www-data
+WorkingDirectory={{ dirname }}
+ExecStart=bash service.sh
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+'''
+
+def execute(command):
+    process = Popen(command.split(), stdout=PIPE, stderr=PIPE)
+    stdout, stderr = process.communicate()
+    #print(stdout, stderr)
+
+def print_content(file_path, content):
+    print()
+    print(file_path)
+    print('--------------------------')
+    print(content)
+    print('--------------------------')
+
+
+dirname = pathlib.Path().resolve()
+server_name = input('DOMAIN: ')
+name = server_name.split('.')[0]
+
+execute('createdb -U postgres {};'.format(name))
+
+ssl = input('SSL [y|N]: ').lower() == 'y'
+port = input('PORT [8000]: ') or '8000'
+nginx_file_path = f'/etc/nginx/conf.d/{server_name}.conf'
+nginx_file_content = parse_string_template(NGINX, server_name=server_name, ssl=ssl, port=port)
+print_content(nginx_file_path, nginx_file_content)
+
+service_script_path = os.path.join(dirname, 'service.sh')
+service_script_content = parse_string_template(SERVICE_SCRIPT, name=name)
+service_file_content = parse_string_template(SERVICE_CONTENT, server_name=server_name, dirname=dirname)
+service_file_path = f'/etc/systemd/system/{server_name}.service'
+print_content(service_script_path, service_script_content)
+print_content(service_file_path, service_file_content)
+save = input('SAVE [y|N]: ').lower() == 'y'
+if save:
+    with open(nginx_file_path, 'w') as file:
+        file.write(nginx_file_content)
+    with open(service_script_path, 'w') as file:
+        file.write(service_script_content)
+    with open(service_file_path, 'w') as file:
+        file.write(service_file_content)
+
+    execute('systemctl daemon-reload')

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

@@ -289,7 +289,7 @@ class Scheduler(dict):
     def __init__(
         self,
         start_time=7,
-        end_time=20,
+        end_time=23,
         chucks=2,
         start_day=None,
         days=14,

slthcore-0.0.5/slth/db/generic.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+import datetime
+import json
+from decimal import Decimal
+
+from django.apps import apps
+from django.db.models import *
+from django.db.models.query_utils import DeferredAttribute
+
+
+class GenericModelWrapper(object):
+    def __init__(self, obj):
+        self._wrapped_obj = obj
+
+    def __getattr__(self, attr):
+        if attr == 'prepare_database_save':
+            raise AttributeError()
+        return getattr(self._wrapped_obj, attr)
+
+    def __setattr__(self, attr, value):
+        if attr == '_wrapped_obj':
+            super().__setattr__(attr, value)
+        elif self._wrapped_obj is not None:
+            self._wrapped_obj.__setattr__(attr, value._wrapped_obj)
+
+    def __str__(self):
+        return self._wrapped_obj.__str__()
+
+    def __repr__(self):
+        return self._wrapped_obj.__repr__()
+
+
+class GenericValue(object):
+    def __init__(self, value):
+        self.value = value
+
+    def get_value(self):
+        if isinstance(self.value, str) and '::' in self.value:
+            value_type, value = self.value.split('::')
+            if '.' in value_type:
+                self.value = apps.get_model(value_type).objects.get(pk=value)
+            elif value_type == 'str':
+                self.value = value
+            elif value_type == 'int':
+                self.value = int(value)
+            elif value_type == 'Decimal':
+                self.value = Decimal(value)
+            elif value_type in ('date', 'datetime'):
+                self.value = datetime.datetime.strptime(value[0:10], '%Y-%m-%d')
+            elif value_type == 'float':
+                self.value = float(value)
+            elif value_type == 'bool':
+                self.value = value == 'True'
+            elif value_type == 'list':
+                self.value = json.loads(value)
+        return self.value
+
+    def dumps(self):
+        value = self.value
+        if value is not None:
+            if isinstance(value, Model):
+                value = GenericModelWrapper(value)
+            if isinstance(value, GenericModelWrapper):
+                return '{}.{}::{}'.format(
+                    value._meta.app_label, value._meta.model_name, value.pk
+                )
+            if hasattr(value, 'model'):
+                value = list(value.values_list('pk', flat=True))
+            if isinstance(value, list):
+                value = json.dumps(value)
+            return '{}::{}'.format(type(value).__name__, value)
+        return None
+
+
+class GenericFieldDescriptor(DeferredAttribute):
+    def __get__(self, instance, cls=None):
+        obj = super().__get__(instance, cls=cls)
+        if isinstance(obj.value, Model):
+            return GenericModelWrapper(obj.value)
+        return obj.get_value()
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.field.attname] = GenericValue(value)
+
+
+class GenericField(CharField):
+    descriptor_class = GenericFieldDescriptor
+
+    def __init__(self, *args, max_length=255, null=True, **kwargs):
+        super().__init__(*args, max_length=max_length, null=null, **kwargs)
+
+    def get_prep_value(self, value):
+        if value is not None:
+            if isinstance(value, GenericValue):
+                value = value.dumps()
+            else:
+                value = GenericValue(value).dumps()
+        return value

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

@@ -2,8 +2,11 @@ from uuid import uuid1
 from django.db.models import Model as DjangoModel
 from django.db.models import *
 from django.utils.translation import gettext_lazy as _
+from . import generic
 from .. import ModelMixin
 
+GenericField = generic.GenericField
+
 class CharField(CharField):
     def __init__(self, *args, **kwargs):
         self.mask = kwargs.pop('mask', None)
@@ -138,3 +141,11 @@ class ImageField(ImageField):
 class Model(DjangoModel, ModelMixin):
     class Meta:
         abstract = True
+
+class Filter:
+
+    def get_label(self):
+        return None
+    
+    def choices(self, queryset):
+        return queryset

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

@@ -1,7 +1,8 @@
 import json
 import types
 import inspect
-from .models import Token
+
+from .models import Token, Role, Log, Deletion
 from django.apps import apps
 from typing import TypeVar, Generic
 from django.core.cache import cache
@@ -13,6 +14,8 @@ 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.contrib.auth import authenticate
 from .forms import ModelForm, Form
 from .serializer import serialize, Serializer
@@ -27,10 +30,12 @@ from .components import (
 )
 from .exceptions import JsonResponseException
 from .utils import build_url, append_url
-from .models import PushSubscription, Profile, User
+from .models import PushSubscription, Profile, User, Log
 from slth.queryset import QuerySet
 from slth import APPLICATON, ENDPOINTS
 from . import oauth
+from .tasks import Task, TaskRunner
+from .threadlocal import tl
 
 
 T = TypeVar("T")
@@ -114,13 +119,20 @@ class Endpoint(metaclass=EnpointMetaclass):
         return apps.get_model(model).objects
 
     def get(self):
-        return {}
+        fields = []
+        for name in dir(self):
+            if isinstance(getattr(self, name), forms.Field):
+                fields.append(name)
+        return self.formfactory().fields(*fields) if fields else {}
 
     def post(self):
         return Response(message="Ação realizada com sucesso")
 
     def check_permission(self):
         return self.request.user.is_superuser
+    
+    def contribute(self, entrypoint):
+        return True
 
     def check_role(self, *names, superuser=True):
         if self.request.user.is_superuser and superuser:
@@ -169,7 +181,11 @@ class Endpoint(metaclass=EnpointMetaclass):
         return data
 
     def serialize(self):
-        return serialize(self.process())
+        output = self.process()
+        if isinstance(output, Task):
+            TaskRunner(output).start()
+            output = Response(f'Tarefa {output.key} iniciada.', task=output.key)
+        return serialize(output)
 
     def to_response(self):
         return ApiResponse(self.serialize(), safe=False)
@@ -225,7 +241,7 @@ class Endpoint(metaclass=EnpointMetaclass):
         args = inspect.getfullargspec(cls.__init__).args[1:]
         pattern = "{}/".format(cls.get_api_name())
         for arg in args:
-            pattern = "{}{}/".format(pattern, "<int:{}>".format(arg))
+            pattern = "{}{}/".format(pattern, "<str:{}>".format(arg))
         return pattern
 
     @classmethod
@@ -269,7 +285,29 @@ class Endpoint(metaclass=EnpointMetaclass):
 
     def get_verbose_name(self):
         return self.get_metadata("verbose_name")
+    
+    def get_instance(self):
+        return None
+    
+    def start_audit_trail(self):
+        instance = self.get_instance()
+        pk = instance.pk if isinstance(instance, Model) else None
+        tl.context = dict(
+            endpoint = self.get_api_name(), model=None, pk=pk,
+            datetime=datetime.now().strftime('%d/%m/%Y %H:%M:%S'),
+            user=self.request.user.username if self.request.user.is_authenticated else None,
+            url=self.request.get_full_path(), logs=[]
+        )
 
+    def finish_audit_trail(self):
+        if hasattr(tl, 'context') and tl.context['logs']:
+            pk = tl.context['pk']
+            instance = self.get_instance()
+            print(tl.context)
+            if pk or isinstance(instance, Model):
+                model = '{}.{}'.format(instance._meta.app_label, instance._meta.model_name)
+                tl.context.update(model=model, pk=pk or instance.pk)
+            Log.objects.create(data=tl.context)
 
 class PublicEndpoint(Endpoint):
     def check_permission(self):
@@ -308,7 +346,7 @@ class AdminEndpoint(Generic[T], ModelEndpoint):
 
 class ListEndpoint(Generic[T], ModelEndpoint):
     def get(self) -> QuerySet:
-        return self.model.objects.contextualize(self.request)
+        return self.model.objects#.contextualize(self.request)
 
 
 class AddEndpoint(Generic[T], ModelEndpoint):
@@ -317,10 +355,13 @@ class AddEndpoint(Generic[T], ModelEndpoint):
         self.instance = self.model()
 
     def get(self) -> FormFactory:
-        return self.model().formfactory()
+        return self.formfactory()
 
     def get_instance(self):
         return self.instance
+    
+    def formfactory(self):
+        return self.instance.formfactory()
 
 
 class ModelInstanceEndpoint(ModelEndpoint):
@@ -365,7 +406,7 @@ class DeleteEndpoint(Generic[T], ModelInstanceEndpoint):
         return self.formfactory(self.get_instance()).fields()
 
     def post(self):
-        self.get_instance().delete()
+        self.get_instance().safe_delete(self.request.user.username)
         return super().post()
 
 
@@ -467,7 +508,7 @@ class Login(PublicEndpoint):
             token = Token.objects.create(user=user)
             return Response(
                 message="Bem-vindo!",
-                redirect="/api/dashboard/",
+                redirect=self.request.GET.get("next", "/api/dashboard/"),
                 store=dict(token=token.key, application=None),
             )
         else:
@@ -493,13 +534,58 @@ class Logout(Endpoint):
 class Icons(PublicEndpoint):
     class Meta:
         modal = True
-        verbose_name = "Icons"
+        verbose_name = "Ícones"
 
     def get(self):
         return IconSet()
 
     def check_permission(self):
         return settings.DEBUG
+    
+    def contribute(self, entrypoint):
+        return self.request.user.is_authenticated
+    
+
+class Roles(ListEndpoint[Role]):
+    class Meta:
+        modal = False
+        verbose_name = 'Papéis dos Usuários'
+    
+    def get(self):
+        return super().get().all()
+
+class Logs(ListEndpoint[Log]):
+    class Meta:
+        modal = False
+        verbose_name = 'Histórico de Alterações'
+    
+    def get(self):
+        return super().get().all()
+    
+
+class Deletions(ListEndpoint[Deletion]):
+    class Meta:
+        modal = False
+        verbose_name = 'Exclusões'
+    
+    def get(self):
+        return super().get().all()
+
+
+class RestoreDeletion(InstanceEndpoint[Deletion]):
+    class Meta:
+        verbose_name = 'Restaurar'
+
+    def get(self):
+        return (super().formfactory().fields())
+    
+    def post(self):
+        self.instance.restore()
+        return super().post()
+    
+    def check_permission(self):
+        return super().check_permission() and not self.instance.restored
+
 
 
 class Search(Endpoint):
@@ -590,38 +676,35 @@ class Dashboard(Endpoint):
         verbose_name = ""
 
     def get(self):
-        if self.request.user.is_authenticated:
-            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")
-                        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():
-                        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]
-                    serializer.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")
+                    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():
+                    group.endpoint(
                         cls.get_metadata("verbose_name"), cls, wrap=False
                     )
-            return serializer
-        else:
-            self.redirect("/api/login/")
+            group.parent()
+        if APPLICATON["dashboard"]["center"]:
+            for endpoint in APPLICATON["dashboard"]["center"]:
+                cls = ENDPOINTS[endpoint]
+                serializer.endpoint(
+                    cls.get_metadata("verbose_name"), cls, wrap=False
+                )
+        return serializer
 
     def check_permission(self):
         return self.request.user.is_authenticated
@@ -646,14 +729,16 @@ class Application(PublicEndpoint):
         )
         for entrypoint in ["actions", "usermenu", "adder", "settings", "tools", "toolbar"]:
             if APPLICATON["dashboard"][entrypoint]:
-                for endpoint in APPLICATON["dashboard"][entrypoint]:
-                    cls = ENDPOINTS[endpoint]
-                    if cls().instantiate(self.request, self).check_permission():
+                for endpoint_name in APPLICATON["dashboard"][entrypoint]:
+                    cls = ENDPOINTS[endpoint_name]
+                    endpoint = cls().instantiate(self.request, self)
+                    if endpoint.check_permission() and endpoint.contribute(entrypoint):
                         label = cls.get_metadata("verbose_name")
                         url = build_url(self.request, cls.get_api_url())
                         modal = cls.get_metadata("modal", False)
                         icon = cls.get_metadata("icon", None)
                         navbar.add_action(entrypoint, label, url, modal, icon=icon)
+        
         if APPLICATON["menu"]:
             items = []
 
@@ -670,7 +755,8 @@ class Application(PublicEndpoint):
                 else:
                     cls = ENDPOINTS.get(v)
                     if cls:
-                        if cls().instantiate(self.request, self).check_permission():
+                        endpoint = cls().instantiate(self.request, self)
+                        if endpoint.check_permission() and endpoint.contribute("menu"):
                             icon, label = k.split(":") if ":" in k else (None, k)
                             url = build_url(self.request, cls.get_api_url())
                             return dict(dict(label=label, url=url, icon=icon))
@@ -806,3 +892,13 @@ class EditProfile(Endpoint):
 class About(PublicEndpoint):
     def get(self):
         return dict(version=APPLICATON["version"])
+    
+class TaskProgress(PublicEndpoint):
+
+    def __init__(self, key):
+        self.key = key
+        super().__init__()
+
+    def get(self):
+        return cache.get(self.key)
+

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

@@ -102,7 +102,7 @@ class FormFactory:
                 class Meta:
                     model = type(self._instance)
                     fields = () if self._empty else (fieldlist if self._fieldlist else '__all__')
-                
+        
         form = Form(instance=self._instance, endpoint=endpoint, initial=self._initial)
         form._key = endpoint.get_api_name()
         form._title = self._title