Work on product's functions

TODO : frontend

Author: littlewillow

api_server/src/entity/product.py

@@ -1,10 +1,11 @@
 # coding=utf-8
 from dataclasses import dataclass
+from typing import Optional
 
 
 @dataclass()
 class Product:
     name: str
-    buying_price: float
-    selling_price: float
-
+    buying_price: int
+    selling_price: int
+    product_id: Optional[int]

api_server/src/exceptions.py

@@ -153,6 +153,11 @@ def __init__(self, v=None):
         super().__init__('account_type', v)
 
 
+class ProductNotFoundError(NotFoundError):
+    def __init__(self, v=None):
+        super().__init__('product', v)
+
+
 # ALREADY EXIST ERRORS.
 class AlreadyExistsError(UserInputError):
     """

api_server/src/interface_adapter/http_api/product.py

@@ -1,52 +1,125 @@
 # coding=utf-8
+from dataclasses import asdict
+
+from connexion import NoContent
+
 from src.constants import DEFAULT_LIMIT, DEFAULT_OFFSET
+from src.entity.product import Product
+from src.exceptions import ProductNotFoundError, UserInputError
+from src.interface_adapter.http_api.decorator.with_context import with_context
+from src.interface_adapter.http_api.util.error import bad_request
 from src.interface_adapter.sql.decorator.auth import auth_regular_admin
 from src.interface_adapter.sql.decorator.sql_session import require_sql
-
-from src.entity.product import Product
-from src.use_case.product_manager import ProductManager
+from src.use_case.product_manager import PartialMutationRequest, ProductManager, FullMutationRequest
+from src.util.context import log_extra
+from src.util.log import LOG
 
 
 class ProductHandler:
     def __init__(self, product_manager: ProductManager):
         self.product_manager = product_manager
 
+    @with_context
     @require_sql
     @auth_regular_admin
-    def search(self, limit=DEFAULT_LIMIT, offset=DEFAULT_OFFSET, terms=None):
-        # TODO: LOG.debug
+    def search(self, ctx, limit=DEFAULT_LIMIT, offset=DEFAULT_OFFSET, terms=None):
+
+        LOG.debug("http_product_search_called", extra=log_extra(ctx,
+                                                                limit=limit,
+                                                                offset=offset,
+                                                                terms=terms))
         try:
-            result, count = self.product_manager.get_by_name(ctx, limit, offset, name, terms)
-        except Exception:
-            pass
-        # TODO: except NameInputError
+            result, count = self.product_manager.search(ctx, product_id=None, terms=terms)
+            headers = {
+                "X-Total-Count": count,
+                'access-control-expose-headers': 'X-Total-Count'
+            }
+            return list(map(_map_product_to_http_response, result)), 200, headers
 
-        headers = {
-            "X-Total-Count": count,
-            "access-control-expose-headers": "X-Total-Count"
-        }
-        return list(map(_map_product_to_http_response, result)), 200, headers
+        except UserInputError as e:
+            return bad_request(e), 400  # 400 Bad Request
 
+    @with_context
     @require_sql
     @auth_regular_admin
-    def post(self, body):
-        pass
+    def post(self, ctx, body):
+        """ Add a product record in the database """
+        LOG.debug("http_product_post_called", extra=log_extra(ctx, request=body))
 
+        try:
+            created = self.product_manager.update_or_create(ctx, req=FullMutationRequest(
+                                                            name=body.get('name'),
+                                                            buying_price=body.get('buying_price'),
+                                                            selling_price=body.get('selling_price')),
+                                                            product_id=body.get('product_id'))
+            if created:
+                return NoContent, 201  # 201 Created
+            else:
+                return NoContent, 204  # 204 No Content
+
+        except UserInputError as e:
+            return bad_request(e), 400  # 400 Bad Request
+
+    @with_context
     @require_sql
     @auth_regular_admin
-    def get(self, product_id):
-        pass
+    def get(self, ctx, product_id):
+        """ Get a specific account. """
+        LOG.debug("http_product_get_called", extra=log_extra(ctx, product_id=product_id))
+        try:
+            result = self.product_manager.get_by_id(ctx, product_id)
+            return _map_product_to_http_response(result), 200  # 200 OK
+        except ProductNotFoundError:
+            return NoContent, 404  # 404 Not Found
 
+    @with_context
     @require_sql
     @auth_regular_admin
-    def patch(self, product_id, body):
-        pass
+    def delete(self, ctx, name):
+        """ Delete the specified Product from the database """
+        LOG.debug("http_product_delete_called", extra=log_extra(ctx, name=name))
+        try:
+            self.product_manager.delete(ctx, name)
+            return NoContent, 204  # 204 No Content
 
+        except ProductNotFoundError:
+            return NoContent, 404  # 404 Not Found
 
-def _map_account_to_http_response(product: Product) -> dict:
+    @with_context
+    @require_sql
+    @auth_regular_admin
+    def patch(self, ctx, product_id, body):
+        """ Partially update a product from the database """
+        LOG.debug("http_product_patch_called", extra=log_extra(ctx, product_id=product_id, request=body))
+        try:
+            mutation_request = _map_http_request_to_full_mutation_request(body)
+            self.product_manager.update_or_create(ctx, mutation_request, product_id)
+            return NoContent, 204  # 204 No Content
+
+        except ProductNotFoundError:
+            return NoContent, 404  # 404 Not Found
+
+
+def _map_http_request_to_partial_mutation_request(body) -> PartialMutationRequest:
+    return PartialMutationRequest(
+        name=body.get('name'),
+        selling_price=body.get('selling_price'),
+        buying_price=body.get('buying_price'),
+    )
+
+
+def _map_product_to_http_response(product: Product) -> dict:
     fields = {
         'name': product.name,
         'buying_price': product.buying_price,
         'selling_price': product.selling_price,
+        'id': product.product_id,
     }
-    return {k: v for k, v in fields.items() if v is not None}
+    return {k: v for k, v in fields.items() if v is not None}
+
+
+def _map_http_request_to_full_mutation_request(body) -> FullMutationRequest:
+    partial = _map_http_request_to_partial_mutation_request(body)
+    return FullMutationRequest(**asdict(partial))
+
+

api_server/src/interface_adapter/sql/account_repository.py

@@ -44,8 +44,6 @@ def create_account(self, ctx, name=None, actif=None, type=None, creation_date=No
 
         return account
 
-    # TODO: update_account mais même problème qu'au dessus
-
     def search_account_by(self, ctx, limit=None, offset=None, account_id=None, terms=None) -> (List[Account], int):
         """
         Search for an account.

api_server/src/interface_adapter/sql/model/models.py

@@ -277,14 +277,25 @@ class PaymentMethod(Base):
     name = Column(String(255), nullable=False)
 
 
-class Product(Base):
+class Product(Base, RubyHashTrackable):
     __tablename__ = 'product'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, unique=True)
     buying_price = Column(DECIMAL(8, 2), nullable=False)
     selling_price = Column(DECIMAL(8, 2), nullable=False)
     name = Column(String(255), nullable=False)
 
+    def serialize_snapshot_diff(self, snap_before: dict, snap_after: dict) -> str:
+        """
+        Override this method to add the prefix.
+        """
+        modif = rubydiff(snap_before, snap_after)
+        modif = '--- !ruby/hash:ActiveSupport::HashWithIndifferentAccess\n' + modif
+        return modif
+
+    def get_related_member(self):
+        return self
+
 
 class Account(Base, RubyHashTrackable):
     __tablename__ = 'account'

api_server/src/interface_adapter/sql/product_repository.py

@@ -4,59 +4,100 @@
 """
 from typing import List
 
-from src.constants import CTX_SQL_SESSION, DEFAULT_LIMIT, DEFAULT_OFFSET
+from src.constants import CTX_SQL_SESSION
 from src.entity.product import Product
+from src.exceptions import ProductNotFoundError
+from src.interface_adapter.sql.model.models import Product as SQLProduct
+from src.interface_adapter.sql.track_modifications import track_modifications
 from src.use_case.interface.product_repository import ProductRepository
-
-# TODO: update_product mais même problème qu'au dessus
-# TODO: delete_product
+from src.util.context import log_extra
+from src.util.log import LOG
 
 
 class ProductSQLRepository(ProductRepository):
     """
     Represent the interface to the SQL database.
     """
 
-    def create_product(self, ctx, name=None, buying_price=None, selling_price=None) -> None:
+    def create_product(self, ctx, name=None, selling_price=None, buying_price=None):
+        """
+        Create a product .
+
+        :raise ProductTypeNotFound ?
         """
-        Create a product.
-        Possibly raise nothing ?
 
         s = ctx.get(CTX_SQL_SESSION)
+        LOG.debug("sql_product_repository_create_product_called", extra=log_extra(ctx, name=name))
 
-        TODO: LOG.debug
+        product = SQLProduct(
+            name=name,
+            buying_price=buying_price,
+            selling_price=selling_price,
+        )
 
-        product = Product(
-                name=name,
-                buying_price=buying_price,
-                selling_price=selling_price)
-        """
-        pass
+        with track_modifications(ctx, s, product):
+            s.add(product)
+
+        return product
 
-        # TODO: voir si track_modifications prendre en compte product et si s.add(product) fonctionne
+    # TODO: update_account mais même problème qu'au dessus
 
-    def search_product_by(self, ctx, limit=None, offset=None, name=None, terms=None) -> \
-            (List[Product], int):
+    def search_product_by(self, ctx, limit=None, offset=None, product_id=None, terms=None) -> (List[Product], int):
         """
         Search for a product.
         """
-        pass
+        LOG.debug("sql_product_repository_search_called", extra=log_extra(ctx, product_id=product_id, terms=terms))
+        s = ctx.get(CTX_SQL_SESSION)
 
-    def update_product(self, ctx, product_to_update, name=None, buying_price=None, selling_price=None):
+        q = s.query(SQLProduct)
+
+        if product_id:
+            q = q.filter(SQLProduct.id == product_id)
+        if terms:
+            q = q.filter(SQLProduct.name.contains(terms))
+
+        count = q.count()
+        #q = q.order_by(SQLProduct.creation_date.asc())
+        q = q.offset(offset)
+        q = q.limit(limit)
+        r = q.all()
+
+        return list(map(_map_product_sql_to_entity, r)), count
+
+    def update_product(self, ctx, name=None, selling_price=None, buying_price=None, product_id=None) -> None:
         """
         Update a product.
-
-        :raise ProductNotFound (one day)
+        Will raise (one day) ProductNotFound
         """
-        pass
+        s = ctx.get(CTX_SQL_SESSION)
+        LOG.debug("sql_product_repository_update_product_called", extra=log_extra(ctx, product_id=product_id))
+
+        product = _get_product_by_id(s, product_id)
+        if product is None:
+            raise ProductNotFoundError(product_id)
+
+        with track_modifications(ctx, s, product):
+            product.name = name or product.name
+            product.buying_price = buying_price or product.buying_price
+            product.selling_price = selling_price or product.selling_price
 
     def delete_product(self, ctx, name=None):
         """
         Delete a product.
 
         :raise ProductNotFound (one day)
         """
-        pass
+        s = ctx.get(CTX_SQL_SESSION)
+        LOG.debug("sql_product_repository_delete_product_called", extra=log_extra(ctx, name=name))
+
+        # Find the soon-to-be deleted user
+        product = _get_product_by_name(s, name)
+        if not product:
+            raise ProductNotFoundError(name)
+
+        with track_modifications(ctx, s, product):
+            # Actually delete it
+            s.delete(product)
 
 
 def _map_product_sql_to_entity(p) -> Product:
@@ -65,6 +106,15 @@ def _map_product_sql_to_entity(p) -> Product:
     """
     return Product(
         name=p.name,
+        buying_price=p.buying_price,
         selling_price=p.selling_price,
-        buying_price=p.buying_price
+        product_id=p.id
     )
+
+
+def _get_product_by_id(s, id) -> SQLProduct:
+    return s.query(SQLProduct).filter(SQLProduct.id == id).one_or_none()
+
+
+def _get_product_by_name(s, name) -> Product:
+    return s.query(Product).filter(Product.name == name).one_or_none()

api_server/src/use_case/account_manager.py

@@ -16,8 +16,6 @@
 from src.util.log import LOG
 
 
-# TODO: update_or_create
-
 @dataclass
 class PartialMutationRequest:
     """
@@ -83,8 +81,6 @@ def get_by_id(self, ctx, account_id=None) -> Account:
 
         return result[0]
 
-    # TODO: get_by_type and get_by_status (actif or not)
-
     def search(self, ctx, limit=DEFAULT_LIMIT, offset=DEFAULT_OFFSET, account_id=None, terms=None) -> (
             List[Account], int):
         """
@@ -139,7 +135,6 @@ def update_or_create(self, ctx, req: FullMutationRequest, account_id=None) -> bo
             ))
             # No account with that name, creating one...
             self.account_repository.create_account(ctx, **fields)
-            # TODO: LOG.info
             return True
 
         else:
@@ -150,5 +145,4 @@ def update_or_create(self, ctx, req: FullMutationRequest, account_id=None) -> bo
                 account_id=account_id,
             ))
             self.account_repository.update_account(ctx, account_id=account_id, **fields)
-            # TODO: LOG.info
             return False