petites modifs

src/djangotools/common/auto_path.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from django.http import HttpRequest, HttpResponse
 from django.urls import path
 
-from djangotools.common import response
+from djangotools.common import response, errors
 from djangotools.common.path import PointPath, ConstPath, AttributePath, UrlPath, ModelPath
 from djangotools.common.route import RegisteredRoute, Post, Delete, Route, Get, Put
 from djangotools.common import models
@@ -28,6 +28,7 @@ class AutoPathManager:
         return self
 
     def add(self, registerd_route, override=True):
+        print(registerd_route)
         for method in registerd_route.route.method:
             path = registerd_route.route.path.get_path()
             if method in self.routes[path]:
@@ -49,9 +50,18 @@ class AutoPathManager:
                 method = req.method
                 if method not in methods:
                     return response.serv_json_not_found(f"Method {method} on {req.path}")
+
+                if "bind_user" in methods[method].options:
+                    kwargs["user"] = req.user
+
                 ret = methods[method](req, *args, **kwargs)
                 if isinstance(ret, HttpResponse):
                     return ret
+                if isinstance(ret, errors.CustomException):
+                    return ret.get_error()
+                if isinstance(ret, Exception):
+                    return response.serv_json(500, 500, err.__class__.__name__, str(err))
+
                 return response.serv_json_ok(ret)
 
             pathes.append(path(route, wrapper))
@@ -67,31 +77,40 @@ class AutoPath:
     _key_ = "id"
     _registered_ = []
     _inited = False
+    _bind_user_ = False
 
 
-    def _auto_path_update(self, req):
-
-        self.update(json.loads(req.body))
+    def _auto_path_update(self, req, **kwargs):
+        ret = self.update(json.loads(req.body))
         self.save()
-        return self
+        return ret
 
-    def _auto_path_get(self, req):
+    def _auto_path_get(self, req, **kwargs):
         return self
-    def _auto_path_list(self, req):
+
+    def _auto_path_list(self, req, **kwargs):
+        if "user" in kwargs and hasattr(self, "user"):
+            return self.filter(user=kwargs["user"])
+
         return self.all()
 
-    def _auto_path_delete(self, req):
+    def _auto_path_delete(self, req, **kwargs):
         self.delete()
         return True
-    def _auto_path_create(self, req):
+
+    def _auto_path_create(self, req, **kwargs):
         try:
-            return self.create(**json.loads(req.body))
+            return self.create(**json.loads(req.body), **kwargs)
         except Exception as err:
             return err
 
     @classmethod
     def init(cls, manager):
         if cls._inited: return
+        route_options = {}
+        if cls._bind_user_:
+            route_options["bind_user"] = True
+
 
         root = cls._path_
         if root is None:
@@ -99,9 +118,9 @@ class AutoPath:
 
         root = root / ConstPath(cls.__name__.lower()) / AttributePath(cls, cls._key_)
 
-        manager.add(RegisteredRoute(Post(root), cls._auto_path_update))
-        manager.add(RegisteredRoute(Delete(root), cls._auto_path_delete))
-        manager.add(RegisteredRoute(Get(root), cls._auto_path_get))
+        manager.add(RegisteredRoute(Post(root, **route_options), cls._auto_path_update))
+        manager.add(RegisteredRoute(Delete(root, **route_options), cls._auto_path_delete))
+        manager.add(RegisteredRoute(Get(root, **route_options), cls._auto_path_get))
 
         for k in dir(cls):
             v = getattr(cls, k)
@@ -113,8 +132,8 @@ class AutoPath:
             _root.liste = root.liste[:-1]
             _root = _root / ModelPath(cls)
 
-        manager.add(RegisteredRoute(Get(_root), cls._auto_path_list, True))
-        manager.add(RegisteredRoute(Put(_root), cls._auto_path_create, True))
+        manager.add(RegisteredRoute(Get(_root, **route_options), cls._auto_path_list, True))
+        manager.add(RegisteredRoute(Put(_root, **route_options), cls._auto_path_create, True))
 
         for k in  dir(cls.objects):
             v = getattr(cls.objects, k)

src/djangotools/common/models.py

@@ -40,9 +40,9 @@ def iter_models_items(app=None):
             yield x
 
 def get_model(name, app=None):
-    name = name.lower()
     if isinstance(name, ModelBase):
         return name
+    name = name.lower()
     if app is not None: return apps.all_models[app][name]
     for _, models in apps.all_models.items():
         if name in models:

src/djangotools/common/path.py

@@ -22,7 +22,7 @@ class UrlPath:
 
     def iter_models(self):
         for x in self.liste:
-            if isinstance(x, (ModelPath, AttributePath)):
+            if isinstance(x, (ModelPath, AttributePath, VariablePath)):
                 yield x
         return
 
@@ -57,14 +57,18 @@ class UrlPath:
     def part(self):
         raise NotImplementedError()
 
-
+    def as_string(self):
+        return "/".join(str(x) for x in self.liste)
 
 class ConstPath(UrlPath):
-
+    """
+    Une partie d'un patch contenant juste une string
+    """
     def __init__(self, string):
         super().__init__()
         self.string = string
 
+
     @property
     def part(self):
         return self.string
@@ -73,7 +77,9 @@ class ConstPath(UrlPath):
         return self.string
 
 class AttributePath(UrlPath):
-
+    """
+        Permet d'avancer dans le path, c'set bien l'objet self qui sera appelé et non ajouté en parametre
+    """
     def __init__(self, model, attr):
         super().__init__()
         self.model = model
@@ -86,8 +92,15 @@ class AttributePath(UrlPath):
     def part(self):
         return f"<str:{self.key}>"
 
+    def __repr__(self):
+        return f"{self.model_name}[{self.attr}]"
+
 
 class ModelPath(UrlPath):
+    """
+        Permet d'avancer dans le path, c'set bien l'objet self qui sera appelé et non ajouté en parametre
+        A utiliser ModelPath(Classe)[id]
+    """
 
     def __init__(self, model):
         super().__init__()
@@ -100,7 +113,13 @@ class ModelPath(UrlPath):
     def part(self):
         return None
 
+    def __repr__(self):
+        return  "{"+self.model.__name__+"}"
+
 class DeferredModelPath(UrlPath):
+    """
+        Permet de faire comme un ModelPath avec un model qui n'est pas encore déclaré
+    """
     def __init__(self, model):
         super().__init__()
         self.model = model
@@ -120,11 +139,41 @@ class DeferredModelPath(UrlPath):
         self.attr = item
         return self
 
+    def __repr__(self):
+        return  f"() => {self.model}[{self.attr}]"
 
 
 class PointPath(UrlPath):
+    """
+        Un part qui ne change rien /a/. == /a/
+    """
     @property
     def part(self):
         return None
 
+    def __repr__(self):
+        return "."
 
+
+class VariablePath(UrlPath):
+    """
+    Permmet d'ajouter la variable en paramètre et non en self
+    """
+
+    def __init__(self, model, key, attr=None, resolve_var=None):
+        super().__init__()
+        self.model = models.get_model(model)
+        self.attr = attr or self.model._key_
+        self.key = key
+        self._resolve_var = resolve_var
+
+    def resolve_var(self, obj, kwargs):
+        if self._resolve_var: return self._resolve_var(obj, kwargs)
+        return self.default_resolve_var(obj, kwargs)
+
+    def default_resolve_var(self, obj, kwargs):
+        return self.model.objects.get(**{self.attr: kwargs[self.key]})
+
+    @property
+    def part(self):
+        return f"<str:{self.key}>"

src/djangotools/common/route.py

@@ -7,7 +7,7 @@ from django.db.models.base import ModelBase
 
 from djangotools.common import response, BaseSerializationModel, redirect
 from djangotools.common.errors import CustomException
-from djangotools.common.path import PointPath, ModelPath, AttributePath, ConstPath
+from djangotools.common.path import PointPath, ModelPath, AttributePath, ConstPath, VariablePath
 from djangotools.common.loggin import debug_login
 
 
@@ -26,6 +26,9 @@ class Route:
             route = ConstPath(route)
         self.path = route or PointPath()
 
+    def __repr__(self):
+        return f"<Route {self.method} {self.path.as_string()} >"
+
     def __call__(self, *args, **kwargs):
         return RegisteredRoute(self, args[0])
 
@@ -72,6 +75,10 @@ class RegisteredRoute:
         if not "no_wrap" in self.options: callback = request_wrapper(callback)
         self.callback = callback
 
+
+    def __repr__(self):
+        return f"<RegisteredRoute {self.route} >"
+
     def _call(self, req, *args, **kwargs):
         obj = None
         debug_login(req, self._default_user_id_)
@@ -101,6 +108,8 @@ class RegisteredRoute:
                     obj = obj.first()
                     if part.forward:
                         obj = getattr(obj, part.forward)
+            elif isinstance(part, VariablePath):
+                kwargs[part.key] = part.resolve_var(obj, kwargs)
             else:
                 raise Exception()
 
@@ -133,7 +142,6 @@ class RegisteredRoute:
         return request_wrapper(self._call)(req, *args, **kwargs)
 
 
-
     def copy(self):
         return RegisteredRoute(self.route, self.callback, is_manager=self.is_manager,
                                is_method=self.is_method)

src/djangotools/models/serializedmodel.py

@@ -188,6 +188,6 @@ class SerializableModel(BaseSerializationModel):
                         if old_value != new_value:
                             setattr(self, attrname, new_value)
                             serial.notify_update(self, attrname)
-
+        return self