moogli-erp 2024.1.2__tar.gz → 2024.1.4__tar.gz

moogli-erp-2024.1.4/CURRENT_VERSION

@@ -0,0 +1 @@
+2024.1.4

{moogli-erp-2024.1.2 → moogli-erp-2024.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moogli-erp
-Version: 2024.1.2
+Version: 2024.1.4
 Summary: Progiciel de gestion pour CAE
 Home-page: https://framagit.org/caerp/caerp
 Author: Majerti/Kilya

moogli-erp-2024.1.4/caerp/controllers/base.py

@@ -0,0 +1,16 @@
+from pyramid.request import Request
+from pyramid.session import ISession
+from caerp_base.models.base import DBSESSION
+
+
+class BaseController:
+    def __init__(self, context, request=None):
+        if request is None:
+            # Needed for manually called views
+            self.request: Request = context
+            self.context = self.request.context
+        else:
+            self.request: Request = request
+            self.context = context
+        self.session: ISession = self.request.session
+        self.dbsession: DBSESSION = self.request.dbsession

moogli-erp-2024.1.4/caerp/controllers/business.py

@@ -0,0 +1,197 @@
+import logging
+from typing import Optional, Union
+
+from caerp.controllers.base import BaseController
+from caerp.controllers.task.invoice import InvoiceController
+from caerp.controllers.task.estimation import EstimationController
+from caerp.services.business import BusinessService
+from caerp.models.user import User
+from caerp.models.project import Business, BusinessPaymentDeadline
+from caerp.models.task import Task, Estimation, Invoice, CancelInvoice
+
+
+logger = logging.getLogger(__name__)
+
+
+class BusinessController(BaseController):
+    def _create_deposit_deadline(self, business, estimation):
+        """
+        Create a deadline for the deposit in the business
+
+        :param obj business: The Business instance
+        :param obj estimation: The Estimation instance
+        :returns: The Business instance
+        :rtype: obj
+        """
+        deposit = estimation.deposit
+        if not deposit:
+            return None
+
+        query = self.dbsession.query(BusinessPaymentDeadline)
+        query = query.filter_by(business_id=business.id)
+        query = query.filter_by(estimation_id=estimation.id)
+        query = query.filter_by(deposit=True)
+        if query.count() == 0:
+            deadline = BusinessPaymentDeadline(
+                business_id=business.id,
+                estimation_id=estimation.id,
+                deposit=True,
+                date=estimation.date,
+                amount=estimation.deposit_amount_ttc(),
+                order=0,
+                description="Acompte à la commande",
+            )
+
+            self.dbsession.add(deadline)
+            self.dbsession.flush()
+            return deadline
+        return None
+
+    def _create_business_deadline(self, business, payment_line, estimation, order):
+        """
+        Create a deadline for the payment in the business
+
+        :param obj business: The Business instance
+        :param obj payment_line: The PaymentLine instance
+        :param obj estimation: The Estimation instance
+        :returns: The Business instance
+        :rtype: obj
+        """
+        from caerp.models.project.business import BusinessPaymentDeadline
+
+        query = (
+            self.dbsession.query(BusinessPaymentDeadline)
+            .filter(BusinessPaymentDeadline.business_id == business.id)
+            .filter(BusinessPaymentDeadline.estimation_id == estimation.id)
+            .filter(BusinessPaymentDeadline.estimation_payment_id == payment_line.id)
+        )
+        deadline = None
+        if query.count() == 0:
+            deadline = BusinessPaymentDeadline(
+                payment_line=payment_line,
+                description=payment_line.description,
+                date=payment_line.date,
+                amount=payment_line.amount,
+                estimation=estimation,
+                order=order,
+            )
+            self.dbsession.add(deadline)
+            self.dbsession.flush()
+        return deadline
+
+    def populate_deadlines(self, business, estimation=None):
+        """
+        Populate the business deadlines with those described in the associated
+        estimation(s)
+
+        :param obj business: The Business instance
+        :param obj estimation: Optionnal Estimation instance
+        :returns: The Business instance
+        :rtype: obj
+        """
+        logger.debug("Populating deadlines for the business {}".format(business.id))
+        if estimation is not None:
+            estimations = [estimation]
+        else:
+            estimations = business.estimations
+
+        order = 0
+        deadlines = []
+        for estimation in estimations:
+            deadline = self._create_deposit_deadline(business, estimation)
+            if deadline is not None:
+                order += 1
+                deadlines.append(deadline)
+            for payment_line in estimation.payment_lines:
+                deadlines.append(
+                    self._create_business_deadline(
+                        business, payment_line, estimation, order
+                    )
+                )
+                order += 1
+
+        self.dbsession.merge(business)
+        return deadlines
+
+    def gen_business_from_task(self, task: Task) -> Business:
+        """
+        Generate a business from the given task
+        """
+        business = Business(
+            name=task.name,
+            business_type_id=task.business_type_id,
+            project=task.project,
+        )
+
+        if task.project.project_type.with_business:
+            business.visible = True
+
+        self.dbsession.add(business)
+        self.dbsession.flush()
+        task.business_id = business.id
+        self.dbsession.merge(task)
+        self.dbsession.flush()
+        return business
+
+    def gen_business_from_estimation(self, estimation: Estimation) -> Business:
+        """
+        Generate a business from the given estimation
+        """
+        business = self.gen_business_from_task(estimation)
+        if estimation.deposit or len(estimation.payment_lines) > 1:
+            business.visible = True
+            self.dbsession.merge(business)
+            self.dbsession.flush()
+        self.populate_deadlines(business, estimation)
+        business.populate_indicators()
+        return business
+
+    def gen_business_from_invoice(
+        request, invoice: Union[Invoice, CancelInvoice]
+    ) -> Business:
+        """
+        Generate a business from the given invoice
+        """
+        business = self.gen_business_from_task(invoice)
+        business.populate_indicators()
+        return business
+
+    def gen_invoice(
+        self,
+        user: User,
+        business: Business,
+        payment_deadline: Optional[BusinessPaymentDeadline] = None,
+    ) -> Invoice:
+        if payment_deadline is None:
+            payment_deadline = business.payment_deadlines[0]
+
+        estimation = payment_deadline.estimation
+        if payment_deadline.deposit:
+            invoice = estimation.gen_deposit_invoice(self.request, user)
+        else:
+            invoice = estimation.gen_invoice(
+                self.request, payment_deadline.payment_line, user
+            )
+        payment_deadline.invoice_id = invoice.id
+        self.dbsession.merge(payment_deadline)
+        self.dbsession.flush()
+        return invoice
+
+    def add_estimation_to_business(self, business, user):
+        service = BusinessService(self.request)
+        customer = service.get_customer(business)
+        data = dict(
+            user=user,
+            company=business.project.company,
+            project=business.project,
+            business_id=business.id,
+            business_type_id=business.business_type_id,
+        )
+        controller = EstimationController(self.request)
+        estimation = controller.create(customer, data)
+        if business.invoicing_mode == business.PROGRESS_MODE:
+            pass
+
+        self.dbsession.merge(estimation)
+        self.dbsession.flush()
+        return estimation

moogli-erp-2024.1.4/caerp/controllers/task/estimation.py

@@ -0,0 +1,24 @@
+from caerp.controllers.task.task import TaskController
+from caerp.models.task import Estimation, InternalEstimation
+from caerp.services.business import BusinessService
+
+
+class EstimationController(TaskController):
+    def create(self, customer, data: dict, no_price_study: bool = False):
+        estimation: Estimation = super().create(customer, data, no_price_study)
+        estimation.add_default_payment_line()
+        estimation.set_default_validity_duration()
+        return estimation
+
+    def cache_totals(self, task_obj):
+        result = super().cache_totals(task_obj)
+        task_obj.update_payment_lines(self.request)
+        return result
+
+    def get_customer_task_factory(self, customer):
+        if customer.is_internal():
+            factory = InternalEstimation
+        else:
+            factory = Estimation
+        return factory
+

moogli-erp-2024.1.4/caerp/controllers/task/invoice.py

@@ -0,0 +1,39 @@
+import datetime
+
+from caerp.controllers.task.task import TaskController
+from caerp.models.task import (
+    Invoice,
+    InternalInvoice,
+    CancelInvoice,
+    InternalCancelInvoice,
+)
+
+
+class InvoiceController(TaskController):
+    def create(self, customer, data: dict, no_price_study: bool = False):
+        invoice: Invoice = super().create(customer, data, no_price_study)
+        invoice.financial_year = datetime.date.today().year
+        return invoice
+
+    def _set_business_data(self, invoice):
+        # Une facture a forcément une affaire associée
+        if not invoice.business and not invoice.business_id:
+            invoice.gen_business()
+
+        return super()._set_business_data(invoice)
+
+    def get_customer_task_factory(self, customer):
+        if customer.is_internal():
+            factory = InternalInvoice
+        else:
+            factory = Invoice
+        return factory
+
+
+class CancelInvoiceController(TaskController):
+    def get_customer_task_factory(self, customer):
+        if customer.is_internal():
+            factory = InternalCancelInvoice
+        else:
+            factory = CancelInvoice
+        return factory

moogli-erp-2024.1.4/caerp/controllers/task/task.py

@@ -0,0 +1,170 @@
+import logging
+import datetime
+from typing import Type
+
+from sqlalchemy import desc
+
+from caerp.controllers.base import BaseController
+from caerp.models.config import Config
+from caerp.models.progress_invoicing import ProgressInvoicingPlan
+from caerp.models.price_study import PriceStudy, PriceStudyChapter
+from caerp.models.task import Task
+
+logger = logging.getLogger(__name__)
+
+
+class TaskController(BaseController):
+    def create(self, customer, data: dict, no_price_study: bool = False) -> Task:
+        instance = self._new_instance(customer, data)
+        if not no_price_study and instance.project.project_type.price_study_default():
+            logger.debug("   + Adding Price study to {}".format(instance))
+            self.set_price_study(instance)
+
+        self.set_display_ttc(instance)
+        self.set_display_units(instance)
+        return instance
+
+    def _new_instance(self, customer, data):
+        for key in ["company", "project", "business_type_id"]:
+            assert key in data
+        # On s'assure que l'info est bien dans les data
+        data["customer"] = customer
+
+        factory = self.get_customer_task_factory(customer)
+        logger.debug("  + Creating task of type {} for {}".format(factory, customer))
+        instance = factory(**data)
+        # On gère les données relatives à l'affaire
+        self._set_business_data(instance)
+        # On gère les données relatives au type d'affaire
+        # Initialise les indicateurs (fichiers requis, mentions)
+        instance.initialize_business_type_data()
+
+        self.dbsession.add(instance)
+        self.dbsession.flush()
+
+        if "decimal_to_display" not in data:
+            instance.decimal_to_display = instance.company.decimal_to_display
+        return instance
+
+    def _set_business_data(self, instance):
+        instance.update_indicators()
+
+    def get_customer_task_factory(self, customer) -> Type[Task]:
+        return Task
+
+    def set_display_units(self, task: Task):
+        """
+        Set last display_units value used by the company
+        :return: number
+        """
+        default = Config.get_value("task_display_units_default")
+        query = self.dbsession.query(Task.display_units)
+        query = query.filter(Task.company_id == task.company_id)
+        query = query.filter(Task.id != task.id)
+        query = query.order_by(desc(Task.id)).limit(1)
+        last_display_units = query.scalar()
+        if last_display_units in (0, 1):
+            default = last_display_units
+        task.display_units = default
+
+    def set_display_ttc(self, task: Task):
+        """
+        Set last display_ttc value used by the company
+        :return: number
+        """
+        default = Config.get_value("task_display_ttc_default")
+        query = self.dbsession.query(Task.display_ttc)
+        query = query.filter(Task.company_id == task.company_id)
+        query = query.filter(Task.id != task.id)
+        query = query.order_by(desc(Task.id)).limit(1)
+        last_display_ttc = query.scalar()
+        if last_display_ttc in (0, 1):
+            default = last_display_ttc
+        task.display_ttc = default
+
+    def set_price_study(self, task):
+        """
+        Initialize a price study using the task's current datas
+        """
+        if task.price_study is None:
+            self._clean_task(task)
+            price_study = PriceStudy(
+                general_overhead=task.company.general_overhead,
+                task=task,
+            )
+            chapter = PriceStudyChapter()
+            price_study.chapters.append(chapter)
+
+            self.dbsession.add(price_study)
+            self.dbsession.flush()
+            price_study.sync_with_task(self.request)
+
+        return task.price_study
+
+    def _clean_task(self, task):
+        """
+        Remove the price study and ensure the task has the appropriate line groups
+        """
+        logger.debug("Cleaning the task")
+        # On vide la task avant d'ajouter une étude de prix
+        for group in task.line_groups:
+            self.dbsession.delete(group)
+        task.line_groups = []
+
+        for discount in task.discounts:
+            self.dbsession.delete(discount)
+        task.discounts = []
+
+        task.expenses_ht = 0
+        self.dbsession.merge(task)
+        self.dbsession.flush()
+
+    def unset_price_study(self, task):
+        """
+        Remove the price study and ensure the task has the appropriate line groups
+        """
+        self.dbsession.delete(task.price_study)
+        if len(task.line_groups) == 0:
+            task.add_default_task_line_group()
+        self.cache_totals(task)
+        self.dbsession.merge(task)
+
+    def cache_totals(self, task_obj):
+        """Cache the totals of a task"""
+        logger.debug("TaskService.cache_totals()")
+
+        task_obj.ht = task_obj.total_ht()
+        logger.debug(
+            f" + Setting TTC {task_obj.tva} TVA : {task_obj.tva} HT : {task_obj.ht}"
+        )
+        task_obj.tva = task_obj.tva_amount()
+        task_obj.ttc = task_obj.total()
+        task_obj.updated_at = datetime.datetime.now()
+
+        self.dbsession.merge(task_obj)
+
+    def set_progress_invoicing_plan(self, task):
+        """
+        Initialize a price study using the task's current datas
+        """
+        task.invoicing_mode = task.PROGRESS_MODE
+        self.dbsession.merge(task)
+        if task.progress_invoicing_plan is None:
+            self._clean_task(task)
+            progress_invoicing_plan = ProgressInvoicingPlan(
+                business=task.business,
+                task=task,
+            )
+            self.dbsession.add(progress_invoicing_plan)
+            self.dbsession.flush()
+        return task.progress_invoicing_plan
+
+    def unset_progress_invoicing_plan(self, task):
+        """
+        Remove the price study and ensure the task has the appropriate line groups
+        """
+        self.dbsession.delete(task.progress_invoicing_plan)
+        if len(task.line_groups) == 0:
+            task.add_default_task_line_group()
+        self.cache_totals(task)
+        self.dbsession.merge(task)

{moogli-erp-2024.1.2 → moogli-erp-2024.1.4}/caerp/export/isacompta.py

@@ -29,7 +29,7 @@ class CsvWriter(CsvExporter):
     quotechar = '"'
     headers = ()
     amount_precision = 2
-    quoting = csv.QUOTE_NONE
+    quoting = csv.QUOTE_MINIMAL
 
     def __init__(self, context, request):
         super().__init__()

{moogli-erp-2024.1.2 → moogli-erp-2024.1.4}/caerp/models/task/services/payment.py

@@ -106,6 +106,11 @@ class InternalPaymentRecordService:
 class InternalPaymentService:
     @classmethod
     def sync_with_customer(cls, payment, request, action="add", **kw):
+        logger.info(
+            f" + Syncing internal invoice's payment with associated supplier_invoice. "
+            f"Action {action} payment id : "
+            f"{payment.id}"
+        )
         supplier_invoice = payment.invoice.supplier_invoice
         force_resulted = payment.invoice.paid_status == "resulted"
 

moogli-erp-2024.1.4/caerp/services/base.py

@@ -0,0 +1,16 @@
+from pyramid.request import Request
+from pyramid.session import ISession
+from caerp_base.models.base import DBSESSION
+
+
+class BaseService:
+    def __init__(self, context, request=None):
+        if request is None:
+            # Needed for manually called views
+            self.request: Request = context
+            self.context = self.request.context
+        else:
+            self.request: Request = request
+            self.context = context
+        self.session: ISession = self.request.session
+        self.dbsession: DBSESSION = self.request.dbsession

moogli-erp-2024.1.4/caerp/services/business.py

@@ -0,0 +1,18 @@
+from sqlalchemy import select
+
+from caerp.models.third_party import Customer
+from caerp.models.task import Task
+from .base import BaseService
+
+
+class BusinessService(BaseService):
+    def get_customer(self, business):
+        customer_id_query = select(Task.customer_id).where(
+            Task.business_id == business.id
+        ).limit(1)
+        query = select(Customer).where(
+            Customer.id.in_(customer_id_query)
+        )
+        return self.dbsession.execute(query).fetchone()
+    
+