WIP default resources

TODO :

+ Tests
+ Marshaling documentation

Mirador_backend/models.py

@@ -2,10 +2,15 @@ from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm import mapped_column
 from sqlalchemy import Integer, JSON
 from sqlalchemy import select
+from sqlalchemy.exc import NoResultFound
 import json
 from Mirador_backend.utils.database import db
 
 
+class NotFound(NoResultFound):
+    pass
+
+
 class BaseModel(DeclarativeBase):
     """A generic model class
     """
@@ -19,11 +24,13 @@ class BaseModel(DeclarativeBase):
     id = mapped_column(Integer, primary_key=True)
     """Identifier of the object"""
 
+    data_fields = ['id']
+    """Actual data fields"""
+
     def create_tables():
         """Creates all tables for all models"""
         BaseModel.metadata.create_all(db.engine)
 
-
     @classmethod
     def query(cls, stmt):
         """Execute the given stmt on the db session
@@ -47,7 +54,10 @@ class BaseModel(DeclarativeBase):
         returns: cls or throw an Error
         """
         stmt = select(cls).where(cls.id == id)
+        try:
             obj = cls.query(stmt).scalar_one()
+        except NoResultFound:
+            raise NotFound(f'No such model {cls} id {id}')
         cls.session.add(obj)
         return obj
 
@@ -93,7 +103,7 @@ class BaseModel(DeclarativeBase):
         """
         self.session.delete(self)
         self.session.commit()
-        pass
+        return True
 
     def is_dirty(self):
         """Checks if the object needs to be saved"""
@@ -115,6 +125,12 @@ class BaseModel(DeclarativeBase):
             return self.save()
         return False
 
+    def clear(self):
+        """Clears all the fields of the object"""
+        for x in self.data_fields:
+            setattr(self, x, None)
+        return self
+
     def create(self, data):
         """Creates an object from the given data
 
@@ -141,6 +157,10 @@ class BaseModel(DeclarativeBase):
         self.session.commit()
         return self
 
+    @property
+    def serialized(self):
+        """Return object data in serializeable format"""
+        return {x: getattr(self, x) for x in self.data_fields}
 
 
 class MiradorResource(BaseModel):
@@ -153,7 +173,4 @@ class MiradorResource(BaseModel):
     """JSON content of the resource"""
 
     fillable = ['content']
-
-    def __repr__(self):
-        """Returns the string representation of the object"""
-        return f'<Manifest {self.id} content {json.dumps(self.content)}>'
+    data_fields = ['id', 'content']

Mirador_backend/resources/base.py

@@ -3,68 +3,82 @@ from flask_apispec.extension import FlaskApiSpec
 
 from marshmallow import Schema, fields
 from apispec import APISpec
-from flask_restful import Resource
+from flask import request
+from flask_restful import Resource, abort
 from flask_restful_swagger import swagger
 from flask_apispec.views import MethodResource
 from flask_apispec import marshal_with, doc, use_kwargs
 
-from Mirador_backend.models import BaseModel
-
-
-class SimpleResponse(Schema):
-    message = fields.Str(default='Success')
+from Mirador_backend.models import BaseModel, NotFound
 
 
 class ResourceGroup(MethodResource, Resource):
     Model = BaseModel
 
+    def parseData(self, request):
+        """Read the request and return only the useful data"""
+        return request.form
+
     def get_queryset(self):
+        """Get the queryset for the request"""
         return self.Model.all()
 
     def get(self):
-        return self.get_queryset()
+        """Handle a get request"""
+        return [x.serialized for x in self.get_queryset()]
 
     def post(self):
-        Model.
-        # TODO
-        return {'method': 'post', 'mode': 'group'}
+        """Handle a post request"""
+        return Model().create(self.parseData(request)).serialized
 
-    def genDoc(descr, tags):
+    def genDoc(descr, tags, klass):
         doc(description=f'Get all {descr}', tags=tags)(ResourceGroup.get)
         doc(description=f'Create a {descr}', tags=tags)(ResourceGroup.post)
-        # TODO response on JSON object given in param
-        marshal_with(SimpleResponse)(ResourceGroup.post)
-        # TODO marshal collection get response using given object
+        klass_fields = {x: fields.Raw() for x in klass.data_fields}
+        # TODO marshal
+        #marshal_with(klass_fields)(ResourceGroup.post)
+        #marshal_with(fields.List(klass_fields))(ResourceGroup.get)
 
 
 class ResourceItem(MethodResource, Resource):
     Model = BaseModel
 
     def get_queryset(self, id):
-        return self.Model.find(id)
+        """Get the queryset for the request"""
+        try:
+            return self.Model.find(id).serialized
+        except NotFound:
+            abort(404)
 
-    def get(self, id):
-        return self.get_queryset(id)
+    def parseData(self, request):
+        """Read the request and return only the useful data"""
+        return request.form
 
-    def post(self, id):
-        # TODO
-        return {'method': 'post', 'id': id, 'mode': 'item'}
+    def get(self, id):
+        """Handle a get request"""
+        return self.get_queryset(id).serialized
 
     def put(self, id):
-        # TODO
-        return {'method': 'put', 'id': id, 'mode': 'item'}
+        """Handle a put request"""
+        m = self.get_queryset(id)
+        m.clear()
+        m.fill(self.parseData(request))
+        return m.save().serialized
 
     def patch(self, id):
-        # TODO
-        return {'method': 'patch', 'id': id, 'mode': 'item'}
+        """Handle a patch request"""
+        m = self.get_queryset(id)
+        m.clear()
+        m.fill(self.parseData(request))
+        return m.save().serialized
 
     def delete(self, id):
-        return Model.find(id).delete()
+        """Handle a delete request"""
+        return self.get_queryset(id).delete()
 
-    def genDoc(descr, tags):
+    def genDoc(descr, tags, klass):
         doc(description=f'Get {descr} by id', tags=tags)(ResourceItem.get)
-        doc(description=f'Create or update a {descr} by id', tags=tags)(ResourceItem.post)
-        doc(description=f'Updates a {descr} by id', tags=tags)(ResourceItem.put)
+        doc(description=f'Create or Update a {descr} by id', tags=tags)(ResourceItem.put)
         doc(description=f'Updates partially a {descr} by id', tags=tags)(ResourceItem.patch)
         doc(description=f'deletes a {descr} by id', tags=tags)(ResourceItem.delete)
         # TODO marshal

Mirador_backend/resources/mirador_resource.py

@@ -8,9 +8,9 @@ tags = ['Mirador resource']
 
 class MiradorResourceGroup(ResourceGroup):
     Model = MiradorResource
-    ResourceGroup.genDoc(resourceDescription, tags)
+    ResourceGroup.genDoc(resourceDescription, tags, MiradorResource)
 
 
 class MiradorResourceItem(ResourceItem):
     Model = MiradorResource
-    ResourceItem.genDoc(resourceDescription, tags)
+    ResourceItem.genDoc(resourceDescription, tags, MiradorResource)