moogli-erp 2024.0.0b3__tar.gz → 2024.0.0b5__tar.gz

moogli-erp-2024.0.0b5/CURRENT_PACKAGE_NAME

@@ -0,0 +1 @@
+moogli-erp

moogli-erp-2024.0.0b5/CURRENT_VERSION

@@ -0,0 +1 @@
+2024.0.0b5

moogli-erp-2024.0.0b5/MANIFEST.in

@@ -0,0 +1,10 @@
+graft endi
+prune endi/tests
+prune */__pycache__
+prune */.pyc
+prune */._DS_Store
+prune tools
+prune docs
+include CURRENT_VERSION CURRENT_PACKAGE_NAME moogli-erp_setup.json endi_setup.json requirements.txt MANIFEST.in README.rst dev_requirements.txt setup.cfg
+include COPYRIGHT.txt
+include pyproject.toml

{moogli-erp-2024.0.0b3 → moogli-erp-2024.0.0b5}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.1
 Name: moogli-erp
-Version: 2024.0.0b3
+Version: 2024.0.0b5
 Summary: Progiciel de gestion pour CAE
 Home-page: https://framagit.org/endi/endi
 Author: Majerti/Kilya
 Author-email: contact@moogli.eu
-License: UNKNOWN
 Keywords: pyramid,business,web
-Platform: UNKNOWN
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python
 Classifier: Framework :: Pyramid
@@ -390,5 +388,3 @@ https://doc.endi.coop
 
 
 :Ce projet est testé avec: `BrowserStack <https://www.browserstack.com/>`_
-
-

{moogli-erp-2024.0.0b3 → moogli-erp-2024.0.0b5}/endi/__init__.py

@@ -18,9 +18,6 @@ locale.setlocale(locale.LC_TIME, "fr_FR.UTF-8")
 
 from sqlalchemy import engine_from_config
 from pyramid.config import Configurator
-from pyramid.authentication import SessionAuthenticationPolicy
-from pyramid.authorization import ACLAuthorizationPolicy
-from pyramid.path import DottedNameResolver
 from pyramid_beaker import set_cache_regions_from_settings
 from endi.utils.session import get_session_factory
 from endi.utils.filedepot import (
@@ -294,7 +291,135 @@ ENDI_SERVICE_FACTORIES = (
         "endi.models.task.invoice.Invoice",
     ),
 )
-ENDI_SERVICES = ()
+# (key, callable, interface, context, params)
+# key : The setting key
+# callable : The callable returning the object (global to the wsgi context)
+# interface : The interface it implements
+# context : The context it should be used for
+# params : tuple of params passed to the callable as *params
+ENDI_SERVICES = (
+    # Statut de validation des Task
+    (
+        "services.validation_state_manager.invoice",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.task.invoice.Invoice",
+        ("invoice",),
+    ),
+    (
+        "services.validation_state_manager.cancelinvoice",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.task.invoice.CancelInvoice",
+        ("cancelinvoice",),
+    ),
+    (
+        "services.validation_state_manager.estimation",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.task.estimation.Estimation",
+        ("estimation",),
+    ),
+    (
+        "services.validation_state_manager.internalinvoice",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.task.internalinvoice.InternalInvoice",
+        ("internalinvoice",),
+    ),
+    (
+        "services.validation_state_manager.internalcancelinvoice",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.task.internalinvoice.InternalCancelInvoice",
+        ("internalcancelinvoice",),
+    ),
+    (
+        "services.validation_state_manager.internalestimation",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.task.internalestimation.InternalEstimation",
+        ("internalestimation",),
+    ),
+    # Status de validation des NDDs
+    (
+        "services.validation_state_manager.expense",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.expense.sheet.ExpenseSheet",
+        ("expense",),
+    ),
+    # Statut de validation des factures/avoirs fournisseurs
+    (
+        "services.validation_state_manager.supplier_order",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.supply.supplier_order.SupplierOrder",
+        ("supplier_order",),
+    ),
+    (
+        "services.validation_state_manager.supplier_invoice",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.supply.supplier_invoice.SupplierInvoice",
+        ("supplier_invoice",),
+    ),
+    (
+        "services.validation_state_manager.internalsupplier_order",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.supply.internalsupplier_order.InternalSupplierOrder",
+        ("internalsupplier_order",),
+    ),
+    (
+        "services.validation_state_manager.internalsupplier_invoice",
+        "endi.controllers.state_managers.validation.get_default_validation_state_manager",
+        "endi.interfaces.IValidationStateManager",
+        "endi.models.supply.internalsupplier_invoice.InternalSupplierInvoice",
+        ("internalsupplier_invoice",),
+    ),
+    # Statut des jusitificatifs de NDD
+    (
+        "services.justified_state_manager.expense",
+        "endi.controllers.state_managers.justified.get_default_justified_state_manager",
+        "endi.interfaces.IJustifiedStateManager",
+        [
+            "endi.models.expense.sheet.ExpenseSheet",
+            "endi.models.expense.sheet.ExpenseLine",
+        ],
+        ("expense",),
+    ),
+    # Statut de signature des Devis
+    (
+        "services.signed_state_manager.estimation",
+        "endi.controllers.state_managers.signed.get_default_signed_status_manager",
+        "endi.interfaces.ISignedStateManager",
+        "endi.models.task.Estimation",
+        ("estimation",),
+    ),
+    # Statut de paiement des factures/factures frns / NDDs
+    (
+        "services.payment_state_manager.invoice",
+        "endi.controllers.state_managers.payment.get_default_payment_state_manager",
+        "endi.interfaces.IPaymentStateManager",
+        "endi.models.task.invoice.Invoice",
+        ("invoice",),
+    ),
+    (
+        "services.payment_state_manager.expense",
+        "endi.controllers.state_managers.payment.get_default_payment_state_manager",
+        "endi.interfaces.IPaymentStateManager",
+        "endi.models.expense.sheet.ExpenseSheet",
+        ("expense",),
+    ),
+    (
+        "services.payment_state_manager.supplier_invoice",
+        "endi.controllers.state_managers.payment.get_default_payment_state_manager",
+        "endi.interfaces.IPaymentStateManager",
+        "endi.models.supply.SupplierInvoice",
+        ("supplier_invoice",),
+    ),
+)
 
 
 def get_groups(login, request):
@@ -334,8 +459,6 @@ def prepare_config(**settings):
     """
     session_factory = get_session_factory(settings)
     set_cache_regions_from_settings(settings)
-    # auth_policy = SessionAuthenticationPolicy(callback=get_groups)
-    # acl_policy = ACLAuthorizationPolicy()
 
     # Evite les imports circulaires avec endi_celery
     from endi.utils.security import SessionSecurityPolicy
@@ -450,10 +573,15 @@ def config_services(config):
     """
     logger.debug("  + Adding pyramid_services")
     settings = config.registry.settings
-    for service_name, default, interface in ENDI_SERVICES:
+    for service_name, default, interface, contexts, params in ENDI_SERVICES:
         module_path = settings.get("endi." + service_name, default)
         module = config.maybe_dotted(module_path)
-        config.register_service(module(), interface)
+
+        if not isinstance(contexts, (tuple, list)):
+            contexts = [contexts]
+
+        for ctx in contexts:
+            config.register_service(module(*params), interface, context=ctx)
 
     for service_name, default, interface, contexts in ENDI_SERVICE_FACTORIES:
         module = settings.get("endi." + service_name, default)

moogli-erp-2024.0.0b5/endi/controllers/payment.py

@@ -0,0 +1,21 @@
+import logging
+from typing import Union
+
+from endi.models.task import Invoice, BaseTaskPayment
+from endi.models.expense import ExpenseSheet, ExpensePayment
+from endi.models.supply import SupplierInvoice, BaseSupplierInvoicePayment
+
+logger = logging.getLogger(__name__)
+
+
+def record_payment(
+    request,
+    node: Union[Invoice, ExpenseSheet, SupplierInvoice],
+    payment: Union[BaseTaskPayment, ExpensePayment, BaseSupplierInvoicePayment],
+):
+    """
+    Record a payment for the given node
+    """
+    logger.debug(f"Recording a payment of {payment.amount} for {node.type_} {node.id}")
+    node.payments.append(payment)
+    return node

moogli-erp-2024.0.0b5/endi/controllers/state_managers/__init__.py

@@ -0,0 +1,20 @@
+from .validation import (
+    set_status as set_validation_status,
+    check_allowed as check_validation_allowed,
+    get_allowed_actions as get_validation_allowed_actions,
+)
+
+from .signed import (
+    set_status as set_signed_status,
+    check_allowed as check_signed_allowed,
+    get_allowed_actions as get_signed_allowed_actions,
+)
+from .justified import (
+    set_status as set_justified_status,
+    check_allowed as check_justified_allowed,
+    get_allowed_actions as get_justified_allowed_actions,
+)
+from .payment import (
+    set_status as set_payment_status,
+    check_node_resulted,
+)

moogli-erp-2024.0.0b5/endi/controllers/state_managers/justified.py

@@ -0,0 +1,70 @@
+from typing import Optional, List
+from zope.interface import implementer
+
+from endi.interfaces import IJustifiedStateManager
+
+from endi.models.action_manager import ActionManager, Action
+from endi.models.expense.sheet import ExpenseSheet
+
+
+def _build_justified_state_manager():
+    """
+    Return a state manager for setting the justified status attribute on
+    ExpenseSheet objects
+    """
+    manager = ActionManager()
+    for status, icon, label, title, css in (
+        (
+            False,
+            "clock",
+            "En attente",
+            "Les justificatifs n'ont pas ou pas tous été acceptés",
+            "btn",
+        ),
+        (
+            True,
+            "check",
+            "Acceptés",
+            "Les justificatifs ont été acceptés",
+            "btn",
+        ),
+    ):
+        action = Action(
+            status,
+            "set_justified.expensesheet",
+            status_attr="justified",
+            icon=icon,
+            label=label,
+            title=title,
+            css=css,
+        )
+        manager.add(action)
+    return manager
+
+
+@implementer(IJustifiedStateManager)
+def get_default_justified_state_manager(doctype: str) -> ActionManager:
+    return _build_justified_state_manager()
+
+
+def set_status(request, expense_sheet: ExpenseSheet, status: str, **kw) -> ExpenseSheet:
+    manager: ActionManager = request.find_service(
+        IJustifiedStateManager, context=expense_sheet
+    )
+    return manager.process(request, expense_sheet, status, **kw)
+
+
+def check_allowed(
+    request, expense_sheet: ExpenseSheet, status: str
+) -> Optional[Action]:
+    manager: ActionManager = request.find_service(
+        IJustifiedStateManager, context=expense_sheet
+    )
+    return manager.check_allowed(request, expense_sheet, status)
+
+
+def get_allowed_actions(request, expense_sheet: ExpenseSheet) -> List[Action]:
+    manager: ActionManager = request.find_service(
+        IJustifiedStateManager, context=expense_sheet
+    )
+    return manager.get_allowed_actions(request, expense_sheet)

moogli-erp-2024.0.0b5/endi/controllers/state_managers/payment.py

@@ -0,0 +1,101 @@
+import logging
+from typing import Union
+from zope.interface import implementer
+
+from endi.interfaces import IPaymentStateManager
+from endi.models.expense.sheet import ExpenseSheet
+from endi.models.task import Invoice
+from endi.models.supply.supplier_invoice import SupplierInvoice
+from endi.models.action_manager import ActionManager, Action
+from endi.utils.strings import PAID_STATUS
+from endi.utils.status_rendering import STATUS_ICON
+from endi.utils.meilisearch import invoice as meilisearch
+
+
+logger = logging.getLogger(__name__)
+
+
+def invoice_paid_status_callback(request, task: Invoice, **kw):
+    """
+    Update the current invoice acl
+    Args:
+        request (Request): The current pyramid request
+        task (Invoice): The current Invoice
+
+    Returns:
+        Invoice: The updated Invoice
+    """
+    meilisearch.push_invoice(request, task)
+    task.cache_acl()
+    return task
+
+
+def supplier_invoice_paid_status_callback(
+    request, supplier_invoice: SupplierInvoice, **kw
+):
+    logger.debug("In the supplier invoice paid status callback")
+    force_resulted = kw.get("force_resulted", False)
+    supplier_invoice.check_supplier_resulted(force_resulted=force_resulted)
+    supplier_invoice.check_worker_resulted(force_resulted=force_resulted)
+    request.dbsession.merge(supplier_invoice)
+    return supplier_invoice
+
+
+def get_paid_status_manager(doctype: str, callbacks: dict = {}) -> ActionManager:
+    # Build an ActionManager and add the statuses waiting/paid/resulted
+    manager = ActionManager()
+    global_callback = callbacks.get("__all__")
+    for status in (
+        "waiting",
+        "paid",
+        "resulted",
+    ):
+        label = title = PAID_STATUS.get(status, "En attente de paiement")
+        action = Action(
+            status,
+            [],
+            status_attr="paid_status",
+            icon=STATUS_ICON[status],
+            label=label,
+            title=title,
+            callback=callbacks.get(status, global_callback),
+        )
+        manager.add(action)
+    return manager
+
+
+PAID_STATUS_MANAGER = {
+    "invoice": get_paid_status_manager(
+        "invoice", callbacks={"__all__": invoice_paid_status_callback}
+    ),
+    "expense": get_paid_status_manager("expense"),
+    "supplier_invoice": get_paid_status_manager(
+        "supplier_invoice", callbacks={"__all__": supplier_invoice_paid_status_callback}
+    ),
+}
+
+
+@implementer(IPaymentStateManager)
+def get_default_payment_state_manager(doctype: str) -> ActionManager:
+    """
+    This function returns the default payment state manager for the given doctype.
+
+    Returns:
+        ActionManager: The default payment state manager for the given doctype.
+    """
+    return PAID_STATUS_MANAGER[doctype]
+
+
+def set_status(
+    request, node: Union[Invoice, ExpenseSheet, SupplierInvoice], status: str, **kw
+) -> Union[Invoice, ExpenseSheet, SupplierInvoice]:
+    manager: ActionManager = request.find_service(IPaymentStateManager, context=node)
+    return manager.process(request, node, status, **kw)
+
+
+def check_node_resulted(
+    request, node: Union[Invoice, ExpenseSheet, SupplierInvoice], **kw
+) -> Union[Invoice, ExpenseSheet, SupplierInvoice]:
+    """Set the paid_status of the given node"""
+    status = node.compute_paid_status(request, **kw)
+    return set_status(request, node, status, **kw)

moogli-erp-2024.0.0b5/endi/controllers/state_managers/signed.py

@@ -0,0 +1,96 @@
+from typing import List
+from zope.interface import implementer
+
+from endi.utils.status_rendering import SIGNED_STATUS_ICON
+from endi.interfaces import ISignedStateManager
+
+from endi.models.status import StatusLogEntry
+from endi.models.action_manager import (
+    Action,
+    ActionManager,
+)
+from endi.models.task import Estimation
+
+
+def signed_status_callback(request, task, **kw):
+    """
+    Cache an acl task in the database
+
+    :param obj request: The current pyramid request
+    :param obj task: The current context
+    """
+    task.cache_acl()
+    return task
+
+
+def get_signed_status_actions():
+    """
+    Return actions available for setting the signed_status attribute on
+    Estimation objects
+    """
+    manager = ActionManager()
+    for status, label, title, css in (
+        ("waiting", "En attente de réponse", "En attente de réponse du client", "btn"),
+        (
+            "sent",
+            "A été envoyé au client",
+            "A bien été envoyé au client",
+            "btn",
+        ),
+        (
+            "aborted",
+            "Sans suite",
+            "Marquer sans suite",
+            "btn negative",
+        ),
+        (
+            "signed",
+            "Signé par le client",
+            "Indiquer que le client a passé commande",
+            "btn btn-primary",
+        ),
+    ):
+        action = Action(
+            status,
+            "set_signed_status.estimation",
+            status_attr="signed_status",
+            icon=SIGNED_STATUS_ICON[status],
+            label=label,
+            title=title,
+            css=css,
+            callbacks=[signed_status_callback],
+        )
+        manager.add(action)
+    return manager
+
+
+SIGNED_ACTION_MANAGER = get_signed_status_actions()
+
+
+@implementer(ISignedStateManager)
+def get_default_signed_status_manager(doctype: str) -> ActionManager:
+    return SIGNED_ACTION_MANAGER
+
+
+def set_status(request, task: Estimation, status: str, **kw) -> Estimation:
+    if request.identity.id is not None:
+        status_record = StatusLogEntry(
+            status=status,
+            user=request.identity,
+            comment="",
+            state_manager_key="signed_status",
+        )
+        request.dbsession.add(status_record)
+        request.dbsession.flush()
+    manager = request.find_service(ISignedStateManager, context=task)
+    return manager.process(request, task, status, **kw)
+
+
+def check_allowed(request, task: Estimation, status: str) -> Action:
+    manager = request.find_service(ISignedStateManager, context=task)
+    return manager.check_allowed(request, task, status)
+
+
+def get_allowed_actions(request, task: Estimation) -> List[Action]:
+    manager = request.find_service(ISignedStateManager, context=task)
+    return manager.get_allowed_actions(request, task)