slthcore 0.4.7__tar.gz → 0.4.9__tar.gz

{slthcore-0.4.7/slthcore.egg-info → slthcore-0.4.9}/PKG-INFO

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

{slthcore-0.4.7 → slthcore-0.4.9}/setup.py

@@ -1,11 +1,10 @@
-import os
 from setuptools import find_packages, setup
 
 install_requires = []
 
 setup(
     name='slthcore',
-    version='0.4.7',
+    version='0.4.9',
     packages=find_packages(),
     install_requires=install_requires,
     include_package_data=True,

{slthcore-0.4.7 → slthcore-0.4.9}/slth/__init__.py

@@ -1,6 +1,3 @@
-import re
-import os
-import yaml
 import json
 import warnings
 from pathlib import Path
@@ -15,6 +12,7 @@ import django.db.models.options as options
 from django.db.models.base import ModelBase
 from django.db.models import Model
 from django.core.exceptions import FieldDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist
 from django.utils.autoreload import autoreload_started
 from django.core import serializers
 from django.utils import autoreload
@@ -29,15 +27,6 @@ FILENAME = 'application.yml'
 ENDPOINTS = {}
 PROXIED_MODELS = []
 THREADS = []
-APPLICATON = None
-
-if APPLICATON is None and os.path.exists(FILENAME):
-    with open(FILENAME) as file:
-        content = file.read()
-        for variable in re.findall(r'\$[a-zA-z0-9_]+', content):
-            content = content.replace(variable, os.environ.get(variable[1:], ''))
-    APPLICATON = yaml.safe_load(content).get('application')
-
 
 class JSONEncoder(json.JSONEncoder):
     def default(self, obj):
@@ -185,13 +174,19 @@ def save_decorator(func):
             if obj:
                 for field in self._meta.fields:
                     a = getattr(obj, field.name)
-                    b = getattr(self, field.name)
+                    try:
+                        b = getattr(self, field.name)
+                    except ObjectDoesNotExist:
+                        b = None
                     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)
+                try:
+                    b = getattr(self, field.name)
+                except ObjectDoesNotExist:
+                    b = None
                 if b is not None:
                     diff[field.verbose_name] = (None, serialize(b))
         func(self, *args, **kwargs)

slthcore-0.4.9/slth/application.py

@@ -0,0 +1,178 @@
+
+from slth import ENDPOINTS
+from .utils import build_url
+from django.conf import settings
+from django.apps import apps
+
+APPLICATION_CLASS = None
+
+
+class Style():
+    def __init__(self, color="black", background="inherite", border="none"):
+        self.update(color=color, background=background, border=border)
+
+    def update(self, color=None, background=None, border=None):
+        if color:
+            self.color = color
+        if background:
+            self.background = background
+        if border:
+            self.border = border
+
+
+class Theme():
+    def __init__(self):
+        self.primary:Style = Style("#1351b4")
+        self.secondary:Style = Style("#071e41")
+        self.auxiliary:Style = Style("#2670e8")
+        self.highlight:Style = Style("#0c326f")
+
+        self.info:Style = Style("#1351b4", "#d4e5ff")
+        self.success:Style = Style("#1351b4")
+        self.warning:Style = Style("#fff5c2")
+        self.danger:Style = Style("#e52207")
+
+
+class Groups(dict):
+    def add(self, **kwargs):
+        self.update(**kwargs)
+
+class Menu(dict):
+    def add(self, arg):
+        self.update(arg)
+
+    def process(self, request):
+        items = []
+
+        def get_item(k, v):
+            if isinstance(v, dict):
+                icon, label = k.split(":") if ":" in k else (None, k)
+                subitems = []
+                for k1, v1 in v.items():
+                    subitem = get_item(k1, v1)
+                    if subitem:
+                        subitems.append(subitem)
+                if subitems:
+                    return dict(dict(icon=icon, label=label, items=subitems))
+            else:
+                cls = ENDPOINTS.get(v)
+                if cls:
+                    endpoint = cls().instantiate(request, None)
+                    if endpoint.check_permission() and endpoint.contribute("menu"):
+                        icon, label = k.split(":") if ":" in k else (None, k)
+                        url = build_url(request, cls.get_api_url())
+                        return dict(dict(label=label, url=url, icon=icon))
+
+        for k, v in self.items():
+            item = get_item(k, v)
+            if item:
+                items.append(item)
+        
+        return items
+
+class Oauth(list):
+    def add(self, name, client_id, client_secret, redirect_uri, authorize_url, access_token_url, user_data_url, user_logout_url, user_scope, user_create, user_username, user_email):
+        super().append(dict(name=name, client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri, authorize_url=authorize_url, access_token_url=access_token_url, user_data_url=user_data_url, user_logout_url=user_logout_url, user_scope=user_scope, user_create=user_create, user_username=user_username, user_email=user_email))
+
+    def serialize(self):
+        data = []
+        for provider in self:
+            redirect_uri = "{}{}".format(settings.SITE_URL, provider['redirect_uri'])
+            authorize_url = '{}?response_type=code&client_id={}&redirect_uri={}'.format(
+                provider['authorize_url'], provider['client_id'], redirect_uri
+            )
+            if provider.get('scope'):
+                authorize_url = '{}&scope={}'.format(authorize_url, provider.get('scope'))
+            data.append(dict(label=f'Entrar com {provider["name"]}', url=authorize_url))
+        return data
+
+class List(list):
+
+    def add(self, *names):
+        super().extend(names)
+
+
+class Dashboard():
+    def __init__(self):
+        self.actions:List = List()
+        self.toolbar:List = List()
+        self.top:List = List()
+        self.center:List = List()
+        self.boxes:List = List()
+        self.search:List = List()
+        self.usermenu:List = List()
+        self.adder:List = List()
+        self.tools:List = List()
+        self.settings:List = List()
+        self.index = "dashboard"
+
+
+class ApplicationMetaclass(type):
+    
+    def __new__(mcs, name, bases, attrs):
+        global APPLICATION_CLASS
+        cls = super().__new__(mcs, name, bases, attrs)
+        APPLICATION_CLASS = cls
+        return cls
+
+
+class Application(metaclass=ApplicationMetaclass):
+    
+    def __init__(self):
+        self.lang = "pt-br"
+        self.title = "Sloth"
+        self.subtitle = "Take your time!"
+        self.icon = "/static/images/logo.png"
+        self.logo = "/static/images/logo.png"
+        self.version =  "0.0.1"
+        self.oauth:Oauth = Oauth()
+        self.groups:Groups = Groups()
+        self.menu:Menu = Menu()
+        self.dashboard = Dashboard()
+        self.theme:Theme = Theme()
+
+    def load(self):
+        pass
+
+    def serialize(self, request):
+        icon = build_url(request, self.icon)
+        logo = build_url(request, self.logo)
+        if request.user.is_authenticated:
+            user = request.user.username.split()[0].split("@")[0]
+            profile = apps.get_model("slth", "profile").objects.filter(user=request.user).first()
+            photo = profile and profile.photo and build_url(request, profile.photo.url) or None
+        else:
+            user = profile = photo = None
+        endpoints = {"actions": [], "usermenu": [], "adder": [], "settings": [], "tools": [], "toolbar": []}
+        for entrypoint in endpoints:
+            for endpoint_name in getattr(self.dashboard, entrypoint):
+                cls = ENDPOINTS[endpoint_name]
+                endpoint = cls().instantiate(request, None)
+                if endpoint.check_permission() and endpoint.contribute(entrypoint):
+                    name = endpoint.get_verbose_name()
+                    url = build_url(request, cls.get_api_url())
+                    modal = cls.get_metadata("modal", False)
+                    icon = cls.get_metadata("icon", None)
+                    endpoints[entrypoint].append(dict(name=name, url=url, modal=modal, icon=icon))
+        return dict(
+            type="application",
+            icon=icon,
+            navbar=dict(
+                type="navbar", title=self.title, subtitle=self.subtitle, logo=logo, user=user, **endpoints
+            ),
+            menu=dict(
+                type="menu", items=self.menu.process(request), user=user, image=photo
+            ),
+            footer=dict(
+                type="footer", version=self.version
+            ),
+            oauth=self.oauth.serialize(),
+            sponsors=[]
+        )
+    
+    @staticmethod
+    def get_instance():
+        instance = APPLICATION_CLASS()
+        instance.load()
+        return instance
+

slthcore-0.4.9/slth/cmd/init/boilerplate/backend/api/__init__.py

@@ -0,0 +1,27 @@
+from slth.application import Application
+
+
+class ApiApplication(Application):
+    def __init__(self):
+        super().__init__()
+        self.groups.add(administrador="Administrador", operador="Operador")
+        self.dashboard.usermenu.add(
+            "dev.icons",
+            "user.users",
+            "log.logs",
+            "email.emails",
+            "pushsubscription.pushsubscriptions",
+            "job.jobs",
+            "deletion.deletions",
+            "auth.logout",
+        )
+        self.dashboard.boxes.add("user.users")
+        self.dashboard.actions.add()
+        self.dashboard.toolbar.add()
+        self.dashboard.top.add()
+        self.dashboard.center.add()
+        self.dashboard.search.add()
+        self.dashboard.adder.add()
+        self.dashboard.tools.add()
+        self.dashboard.settings.add()
+        self.menu.add({"Sair": "auth.logout"})

{slthcore-0.4.7 → slthcore-0.4.9}/slth/db/models.py

@@ -36,6 +36,7 @@ class IntegerField(IntegerField):
         field.pick = self.pick
         return field
 
+
 class ForeignKey(ForeignKey):
     def __init__(self, to, on_delete=None, **kwargs):
         self.pick = kwargs.pop('pick', False)

{slthcore-0.4.7 → slthcore-0.4.9}/slth/endpoints/__init__.py

@@ -1,5 +1,4 @@
 import io
-import json
 import inspect
 from ..models import Log
 from django.apps import apps
@@ -19,20 +18,16 @@ from django.template.loader import render_to_string
 from ..forms import ModelForm, Form
 from ..serializer import serialize, Serializer
 from ..components import (
-    Application as Application_,
-    Navbar,
-    Menu,
-    Footer,
     Response,
     Boxes,
     TemplateContent,
 )
+from slth.application import Application as ApplicationConfig
 from ..exceptions import JsonResponseException, ReadyResponseException
 from ..utils import build_url, append_url
-from ..models import Profile, Log, Job
+from ..models import Log, Job
 from slth.queryset import QuerySet
-from slth import APPLICATON, ENDPOINTS
-from .. import oauth
+from slth import ENDPOINTS
 from ..threadlocal import tl
 from ..tasks import Task
 
@@ -68,6 +63,7 @@ class Endpoint(metaclass=EnpointMetaclass):
     cache = cache
 
     def __init__(self):
+        self.form: Form | ModelForm = None
         self.base_url = None
         self.request = None
         self.source = None
@@ -153,15 +149,15 @@ class Endpoint(metaclass=EnpointMetaclass):
         elif isinstance(data, Serializer):
             data = data.contextualize(self.request).settitle(title)
         elif isinstance(data, FormFactory):
-            form = self.getform(data.settitle(title).form(self))
-            if self.request.method == "POST" or (title and self.request.GET.get("form") == form._key):
+            self.form = self.getform(data.settitle(title).build(self))
+            if self.request.method == "POST" or (title and self.request.GET.get("form") == self.form._key):
                 try:
                     if isinstance(self, DeleteEndpoint):
                         return self.post()
                     else:
-                        self.cleaned_data = form.submit()
-                        if form._message or form._redirect or form._dispose:
-                            return Response(form._message, form._redirect, dispose=form._dispose)
+                        self.cleaned_data = self.form.submit()
+                        if self.form._message or self.form._redirect or self.form._dispose:
+                            return Response(self.form._message, self.form._redirect, dispose=self.form._dispose)
                         else:
                             return self.post()
                 except ValidationError as e:
@@ -169,7 +165,7 @@ class Endpoint(metaclass=EnpointMetaclass):
                         dict(type="error", text="\n".join(e.messages), errors={})
                     )
             else:
-                data = form
+                data = self.form
         elif isinstance(data, Form) or isinstance(data, ModelForm):
             data = data.settitle(title)
         elif self.request.method == "POST":# and not data:
@@ -340,7 +336,6 @@ class PublicEndpoint(Endpoint):
         return True
 
 
-
 class ModelEndpoint(Endpoint):
     def __init__(self):
         self.model = self.__orig_bases__[0].__args__[0]
@@ -506,14 +501,52 @@ class ChildInstanceEndpoint(ChildEndpoint):
         return Serializer(self.get_instance()).contextualize(self.request)
 
 
+class RelationEditEndpoint(Generic[T], ChildEndpoint):
+
+    def __init__(self, instance):
+        self.source = instance
+        
+    def get(self) -> FormFactory:
+        return self.formfactory()
+    
+    def formfactory(self) -> FormFactory:
+        return FormFactory(self.get_instance())
+
+    def get_instance(self):
+        return self.__orig_bases__[0].__args__[0].objects.get(pk=self.request.GET['id'])
+
+
+class RelationDeleteEndpoint(Generic[T], ChildEndpoint):
+
+    def __init__(self, instance):
+        self.model = self.__orig_bases__[0].__args__[0]
+        self.source = instance
+        
+    def get(self) -> FormFactory:
+        return FormFactory(self.get_instance()).fields()
+
+    def post(self):
+        self.get_instance().safe_delete(self.request.user.username)
+        return super().post()
+    
+    def formfactory(self) -> FormFactory:
+        return FormFactory(self.get_instance())
+
+    def get_instance(self):
+        return self.model.objects.get(pk=self.request.GET['id'])
+
+
+
+
 class Search(Endpoint):
     def get(self):
         key = "_options_"
         options = self.cache.get(key, [])
         term = self.request.GET.get("term")
-        if options is None and APPLICATON["dashboard"]["search"]:
+        application = ApplicationConfig.get_instance()
+        if options is None and application.dashboard.search:
             options = []
-            for name in APPLICATON["dashboard"]["search"]:
+            for name in application.dashboard.search:
                 cls = ENDPOINTS[name]
                 endpoint = cls.instantiate(self.request, self)
                 if endpoint.check_permission():
@@ -531,13 +564,13 @@ class Search(Endpoint):
         return result[0:10]
 
 
-
 class Home(PublicEndpoint):
     class Meta:
         verbose_name = ""
 
     def get(self):
-        cls = ENDPOINTS[APPLICATON["index"]]
+        application = ApplicationConfig.get_instance()
+        cls = ENDPOINTS[application.dashboard.index]
         self.redirect(cls.get_api_url())
 
 
@@ -546,10 +579,11 @@ class Dashboard(Endpoint):
         verbose_name = ""
 
     def get(self):
+        application = ApplicationConfig.get_instance()
         serializer = Serializer(request=self.request)
-        if APPLICATON["dashboard"]["boxes"]:
+        if application.dashboard.boxes:
             boxes = Boxes("Acesso Rápido")
-            for name in APPLICATON["dashboard"]["boxes"]:
+            for name in application.dashboard.boxes:
                 cls = ENDPOINTS[name]
                 endpoint = cls().contextualize(self.request)
                 if endpoint.check_permission():
@@ -558,9 +592,9 @@ class Dashboard(Endpoint):
                     url = build_url(self.request, cls.get_api_url())
                     boxes.append(icon, label, url)
             serializer.append("Acesso Rápido", boxes)
-        if APPLICATON["dashboard"]["top"]:
+        if application.dashboard.top:
             group = serializer.group("Top")
-            for name in APPLICATON["dashboard"]["top"]:
+            for name in application.dashboard.top:
                 cls = ENDPOINTS[name]
                 endpoint = cls.instantiate(self.request, self)
                 if endpoint.check_permission():
@@ -568,8 +602,8 @@ class Dashboard(Endpoint):
                         endpoint.get_verbose_name(), cls, wrap=False
                     )
             group.parent()
-        if APPLICATON["dashboard"]["center"]:
-            for name in APPLICATON["dashboard"]["center"]:
+        if application.dashboard.center:
+            for name in application.dashboard.center:
                 cls = ENDPOINTS[name]
                 endpoint = cls.instantiate(self.request, self)
                 if endpoint.check_permission():
@@ -584,79 +618,7 @@ class Dashboard(Endpoint):
 
 class Application(PublicEndpoint):
     def get(self):
-        user = None
-        photo = None
-        navbar = None
-        menu = None
-        icon = build_url(self.request, APPLICATON["logo"])
-        logo = build_url(self.request, APPLICATON["logo"])
-        if self.request.user.is_authenticated:
-            user = self.request.user.username.split()[0].split("@")[0]
-            profile = Profile.objects.filter(user=self.request.user).first()
-            photo = profile and profile.photo and build_url(self.request, profile.photo.url) or None
-
-        navbar = Navbar(
-            title=APPLICATON["title"],
-            subtitle=APPLICATON["subtitle"],
-            logo=logo,
-            user=user,
-            photo=photo,
-            search=False,
-            roles=' | '.join((str(role) for role in self.objects('slth.role').filter(username=self.request.user.username)))
-        )
-        for entrypoint in ["actions", "usermenu", "adder", "settings", "tools", "toolbar"]:
-            if APPLICATON["dashboard"][entrypoint]:
-                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 = endpoint.get_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 = []
-
-            def get_item(k, v):
-                if isinstance(v, dict):
-                    icon, label = k.split(":") if ":" in k else (None, k)
-                    subitems = []
-                    for k1, v1 in v.items():
-                        subitem = get_item(k1, v1)
-                        if subitem:
-                            subitems.append(subitem)
-                    if subitems:
-                        return dict(dict(icon=icon, label=label, items=subitems))
-                else:
-                    cls = ENDPOINTS.get(v)
-                    if cls:
-                        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))
-
-            for k, v in APPLICATON["menu"].items():
-                item = get_item(k, v)
-                if item:
-                    items.append(item)
-            profile = (
-                Profile.objects.filter(user=self.request.user).first() if user else None
-            )
-            photo_url = (
-                profile.photo.url
-                if profile and profile.photo
-                else "/static/images/user.svg"
-            )
-            menu = Menu(items, user=user, image=build_url(self.request, photo_url))
-
-        footer = Footer(APPLICATON["version"])
-        return Application_(
-            icon=icon, navbar=navbar, menu=menu, footer=footer, oauth=oauth.providers(),
-            sponsors=APPLICATON.get("sponsors", ())
-        )
+        return ApplicationConfig.get_instance().serialize(self.request)
 
 
 class Manifest(PublicEndpoint):
@@ -665,17 +627,18 @@ class Manifest(PublicEndpoint):
         verbose_name = "Manifest"
 
     def get(self):
+        application = ApplicationConfig.get_instance()
         return dict(
             {
-                "name": APPLICATON["title"],
-                "short_name": APPLICATON["title"],
+                "name": application.title,
+                "short_name": application.title,
                 "lang": "pt-BR",
                 "start_url": build_url(self.request, "/app/home/"),
                 "scope": build_url(self.request, "/app/"),
                 "display": "standalone",
                 "icons": [
                     {
-                        "src": build_url(self.request, APPLICATON["icon"]),
+                        "src": build_url(self.request, application.icon),
                         "sizes": "192x192",
                         "type": "image/png",
                     }
@@ -689,5 +652,5 @@ class Manifest(PublicEndpoint):
 
 class About(PublicEndpoint):
     def get(self):
-        return dict(version=APPLICATON["version"])
-
+        application = ApplicationConfig.get_instance()
+        return dict(version=application.version)

{slthcore-0.4.7 → slthcore-0.4.9}/slth/factory.py

@@ -3,7 +3,7 @@ from .serializer import Serializer
 
 
 class FormFactory:
-    def __init__(self, instance, endpoint=None, method='POST'):
+    def __init__(self, instance, method='POST'):
         self._instance = instance
         self._fieldsets = {}
         self._values = {}
@@ -48,7 +48,7 @@ class FormFactory:
                 self._append_field(field_name)
         for k in values:
             self._append_field(k)
-            self.setvalue(**values)
+            self.values(**values)
         self._empty = not self._fieldlist
         return self
 
@@ -84,7 +84,7 @@ class FormFactory:
         self._actions.update(kwargs)
         return self
     
-    def setvalue(self, **kwargs) -> 'FormFactory':
+    def values(self, **kwargs) -> 'FormFactory':
         self._values.update(kwargs)
         return self
     
@@ -106,7 +106,7 @@ class FormFactory:
             self._redirect = '.'
         return self
 
-    def form(self, endpoint):
+    def build(self, endpoint):
         from .forms import ModelForm, Form
         
         if isinstance(self._instance, Model):
@@ -135,7 +135,7 @@ class FormFactory:
         for name, queryset in self._choices.items():
             form.fields[name].queryset = queryset
         form.fieldsets = self._fieldsets
-        form.setvalue(**self._values)
+        form.values(**self._values)
         if self._display:
             serializer = Serializer(self._instance, request=endpoint.request)
             for title, fields in self._display.items():