'C'

app/db/database.py

@@ -1,118 +0,0 @@
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.pool import QueuePool
-from fastapi import HTTPException
-import asyncio
-import logging
-from app.db.models import Base
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Use SQLite with aiosqlite and connection pooling
-DATABASE_URL = "sqlite+aiosqlite:///./sql_app.db"
-
-# Configure the engine with connection pooling and timeouts
-engine = create_async_engine(
-    DATABASE_URL,
-    echo=True,
-    pool_size=20,  # Maximum number of connections in the pool
-    max_overflow=10,  # Maximum number of connections that can be created beyond pool_size
-    pool_timeout=30,  # Timeout for getting a connection from the pool
-    pool_recycle=1800,  # Recycle connections after 30 minutes
-    pool_pre_ping=True,  # Enable connection health checks
-    poolclass=QueuePool
-)
-
-# Configure session with retry logic
-AsyncSessionLocal = sessionmaker(
-    engine,
-    class_=AsyncSession,
-    expire_on_commit=False
-)
-
-# Semaphore to limit concurrent database operations
-MAX_CONCURRENT_DB_OPS = 10
-db_semaphore = asyncio.Semaphore(MAX_CONCURRENT_DB_OPS)
-
-async def get_db() -> AsyncSession:
-    async with db_semaphore:  # Limit concurrent database operations
-        session = AsyncSessionLocal()
-        try:
-            yield session
-        except SQLAlchemyError as e:
-            logger.error(f"Database error: {str(e)}")
-            await session.rollback()
-            raise HTTPException(
-                status_code=503,
-                detail="Database service temporarily unavailable. Please try again."
-            )
-        except Exception as e:
-            logger.error(f"Unexpected error: {str(e)}")
-            await session.rollback()
-            raise HTTPException(
-                status_code=500,
-                detail="An unexpected error occurred. Please try again."
-            )
-        finally:
-            await session.close()
-
-# Rate limiting configuration
-from fastapi import Request
-import time
-from collections import defaultdict
-
-class RateLimiter:
-    def __init__(self, requests_per_minute=60):
-        self.requests_per_minute = requests_per_minute
-        self.requests = defaultdict(list)
-    
-    def is_allowed(self, client_ip: str) -> bool:
-        now = time.time()
-        minute_ago = now - 60
-        
-        # Clean old requests
-        self.requests[client_ip] = [req_time for req_time in self.requests[client_ip] 
-                                  if req_time > minute_ago]
-        
-        # Check if allowed
-        if len(self.requests[client_ip]) >= self.requests_per_minute:
-            return False
-        
-        # Add new request
-        self.requests[client_ip].append(now)
-        return True
-
-rate_limiter = RateLimiter(requests_per_minute=60)
-
-# Add this to your database initialization
-async def init_db():
-    try:
-        async with engine.begin() as conn:
-            # Check if the database already has tables
-            if not await database_exists(conn):
-                logger.info("Initializing database: Creating tables...")
-                await conn.run_sync(Base.metadata.create_all)
-                logger.info("Database initialization completed successfully")
-            else:
-                logger.info("Database already exists. Skipping initialization.")
-    except Exception as e:
-        logger.error(f"Error initializing database: {str(e)}")
-        raise
-
-async def database_exists(conn) -> bool:
-    """Check if any tables exist in the database."""
-    try:
-        result = await conn.run_sync(
-            lambda sync_conn: sync_conn.dialect.has_table(sync_conn, "invoices")
-        )
-        return result
-    except Exception as e:
-        logger.error(f"Error checking database existence: {str(e)}")
-        return False
-            
-            
-
-###sdf

app/db/models.py

@@ -1,45 +0,0 @@
-from sqlalchemy.orm import DeclarativeBase, relationship
-from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey
-from sqlalchemy.ext.declarative import declarative_base
-from datetime import datetime
-from sqlalchemy.sql import func
-
-Base = declarative_base()
-
-class Invoice(Base):
-    __tablename__ = "invoices"
-
-    id = Column(Integer, primary_key=True, index=True)
-    invoice_number = Column(String)
-    date = Column(DateTime, default=datetime.now)
-    project = Column(String)
-    client_name = Column(String)
-    phone1 = Column(String)  # Changed from client_phone
-    phone2 = Column(String, nullable=True)  # Added second phone number
-    address = Column(String)
-    ville = Column(String)  # Add ville field
-    total_ht = Column(Float)
-    tax = Column(Float)
-    total_ttc = Column(Float)
-    frame_number = Column(String, nullable=True)
-    customer_name = Column(String)
-    amount = Column(Float)
-    status = Column(String, default="pending")
-    created_at = Column(DateTime, default=datetime.utcnow)
-    commercial = Column(String, default="divers")
-
-    items = relationship("InvoiceItem", back_populates="invoice", cascade="all, delete-orphan")
-
-class InvoiceItem(Base):
-    __tablename__ = "invoice_items"
-
-    id = Column(Integer, primary_key=True, index=True)
-    invoice_id = Column(Integer, ForeignKey("invoices.id"))
-    description = Column(String)
-    unit = Column(String)
-    quantity = Column(Integer)
-    length = Column(Float)
-    unit_price = Column(Float)
-    total_price = Column(Float)
-
-    invoice = relationship("Invoice", back_populates="items")

app/routes/__init__.py

@@ -1 +0,0 @@
-# Empty file to make the directory a Python package 

app/routes/invoices.py

@@ -1,295 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func, Sequence, delete
-from typing import List, Optional
-from sqlalchemy.orm import selectinload, joinedload, Session
-from fastapi.responses import StreamingResponse, Response
-import logging
-from datetime import datetime
-
-from app.db.database import get_db
-from app.schemas.invoice import InvoiceCreate, InvoiceResponse
-from app.db.models import Invoice, InvoiceItem
-from app.services.invoice_service import InvoiceService
-from app.services.excel_service import ExcelService
-#from app.services.invoice_page2_service import InvoiceServicePage2
-from app.services.invoice_service_page2 import InvoiceServicePage2
-# Merge PDFs using PyPDF2
-from pypdf import PdfWriter, PdfReader
-from io import BytesIO
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/invoices", tags=["invoices"])
-
-@router.post("/", response_model=InvoiceResponse)
-async def create_new_invoice(invoice: InvoiceCreate, db: AsyncSession = Depends(get_db)):
-    try:
-        # Create new invoice
-        new_invoice = Invoice(
-            invoice_number=invoice.invoice_number,
-            date=invoice.date or datetime.now(),
-            project=invoice.project,
-            client_name=invoice.client_name,
-            phone1=invoice.phone1,
-            phone2=invoice.phone2,
-            address=invoice.address,
-            frame_number=invoice.frame_number,
-            total_ht=invoice.total_ht,
-            tax=invoice.tax,
-            total_ttc=invoice.total_ttc,
-            commercial=invoice.commercial,
-            status=invoice.status
-        )
-        
-        db.add(new_invoice)
-        await db.commit()
-        await db.refresh(new_invoice)
-        
-        # Create invoice items with total_price calculation
-        for item in invoice.items:
-            total_price = item.quantity * item.length * item.unit_price  # Calculate total_price
-            invoice_item = InvoiceItem(
-                invoice_id=new_invoice.id,
-                description=item.description,
-                unit=item.unit,
-                quantity=item.quantity,
-                length=item.length,
-                unit_price=item.unit_price,
-                total_price=total_price  # Set the calculated total_price
-            )
-            db.add(invoice_item)
-        
-        await db.commit()
-        
-        # Fetch the complete invoice with items
-        result = await db.execute(
-            select(Invoice)
-            .options(selectinload(Invoice.items))
-            .filter(Invoice.id == new_invoice.id)
-        )
-        complete_invoice = result.scalar_one()
-        
-        return complete_invoice
-        
-    except Exception as e:
-        await db.rollback()
-        logger.error(f"Error creating invoice: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/{invoice_id}", response_model=InvoiceResponse)
-async def read_invoice(invoice_id: int, db: AsyncSession = Depends(get_db)):
-    result = await db.execute(
-        select(Invoice)
-        .options(selectinload(Invoice.items))
-        .filter(Invoice.id == invoice_id)
-    )
-    invoice = result.scalar_one_or_none()
-    if invoice is None:
-        raise HTTPException(status_code=404, detail="Invoice not found")
-    return invoice
-
-@router.get("/", response_model=List[InvoiceResponse])
-async def read_invoices(
-    skip: int = 0,
-    limit: int = 100,
-    db: AsyncSession = Depends(get_db)
-):
-    result = await db.execute(
-        select(Invoice)
-        .options(selectinload(Invoice.items))
-        .offset(skip)
-        .limit(limit)
-    )
-    return result.scalars().all()
-
-@router.post("/{invoice_id}/generate-pdf")
-async def generate_invoice_pdf(
-    invoice_id: int,
-    request: Request,
-    db: AsyncSession = Depends(get_db)
-):
-    try:
-        # Get invoice with items
-        result = await db.execute(
-            select(Invoice)
-            .options(selectinload(Invoice.items))
-            .filter(Invoice.id == invoice_id)
-        )
-        invoice = result.scalar_one_or_none()
-        
-        if not invoice:
-            raise HTTPException(status_code=404, detail="Invoice not found")
-            
-        logger.info(f"Generating PDF for invoice: {invoice_id}")
-        
-        # Generate both pages
-        pdf_bytes1 = InvoiceService.generate_pdf(invoice)
-        pdf_bytes2 = InvoiceServicePage2.generate_pdf(invoice)
-        
-        # Create a PDF writer object
-        writer = PdfWriter()
-        
-        # Add pages from both PDFs using PdfReader
-        writer.add_page(PdfReader(BytesIO(pdf_bytes1)).pages[0])
-        writer.add_page(PdfReader(BytesIO(pdf_bytes2)).pages[0])
-        
-        # Write the merged PDF to a BytesIO object
-        output = BytesIO()
-        writer.write(output)
-        
-        # Get the merged PDF bytes
-        output.seek(0)
-        final_pdf = output.getvalue()
-        
-        return StreamingResponse(
-            iter([final_pdf]),
-            media_type="application/pdf",
-            headers={"Content-Disposition": f"attachment; filename=devis_{invoice_id}.pdf"}
-        )
-    except Exception as e:
-        logger.error(f"Error generating PDF: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/last-number/{client_type}", response_model=dict)
-async def get_last_invoice_number(
-    client_type: str,
-    db: AsyncSession = Depends(get_db)
-):
-    try:
-        # Use async query syntax
-        query = select(func.max(Invoice.id))
-        result = await db.execute(query)
-        current_max_id = result.scalar() or 0
-        
-        # Next ID will be current max + 1
-        next_id = current_max_id + 1
-        
-        # Format the invoice number with the next ID
-        formatted_number = f"DCP/{client_type}/{next_id:04d}"
-        
-        return {
-            "next_number": next_id,
-            "formatted_number": formatted_number
-        }
-    except Exception as e:
-        print(f"Error in get_last_invoice_number: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.post("/reset-sequence")
-def reset_invoice_sequence(db: Session = Depends(get_db)):
-    try:
-        # Reset the sequence to 1
-        db.execute("ALTER SEQUENCE invoice_id_seq RESTART WITH 1")
-        db.commit()
-        return {"message": "Sequence reset successfully"}
-    except Exception as e:
-        db.rollback()
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.put("/{invoice_id}", response_model=InvoiceResponse)
-async def update_invoice(
-    invoice_id: int,
-    invoice_update: InvoiceCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    try:
-        # Get existing invoice
-        result = await db.execute(
-            select(Invoice)
-            .options(selectinload(Invoice.items))
-            .filter(Invoice.id == invoice_id)
-        )
-        invoice = result.scalar_one_or_none()
-        
-        if not invoice:
-            raise HTTPException(status_code=404, detail="Invoice not found")
-        
-        # Update invoice fields
-        for field, value in invoice_update.dict(exclude={'items'}).items():
-            setattr(invoice, field, value)
-        
-        # Delete existing items
-        await db.execute(delete(InvoiceItem).where(InvoiceItem.invoice_id == invoice_id))
-        
-        # Create new items with total_price calculation
-        for item_data in invoice_update.items:
-            total_price = item_data.quantity * item_data.length * item_data.unit_price
-            db_item = InvoiceItem(
-                invoice_id=invoice_id,
-                description=item_data.description,
-                unit=item_data.unit,
-                quantity=item_data.quantity,
-                length=item_data.length,
-                unit_price=item_data.unit_price,
-                total_price=total_price
-            )
-            db.add(db_item)
-        
-        await db.commit()
-        await db.refresh(invoice)
-        
-        return invoice
-    except Exception as e:
-        await db.rollback()
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.put("/{invoice_id}/status")
-async def update_invoice_status(
-    invoice_id: int,
-    status_update: dict,
-    db: AsyncSession = Depends(get_db)
-):
-    try:
-        # Get existing invoice
-        result = await db.execute(
-            select(Invoice)
-            .filter(Invoice.id == invoice_id)
-        )
-        invoice = result.scalar_one_or_none()
-        
-        if not invoice:
-            raise HTTPException(status_code=404, detail="Invoice not found")
-        
-        # Update status
-        invoice.status = status_update.get("status")
-        await db.commit()
-        
-        return {"message": "Status updated successfully"}
-    except Exception as e:
-        await db.rollback()
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.post("/{invoice_id}/generate-excel")
-async def generate_excel(
-    invoice_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    try:
-        # Get invoice with items
-        result = await db.execute(
-            select(Invoice)
-            .options(selectinload(Invoice.items))
-            .filter(Invoice.id == invoice_id)
-        )
-        invoice = result.scalar_one_or_none()
-        
-        if not invoice:
-            raise HTTPException(status_code=404, detail="Invoice not found")
-            
-        logger.info(f"Generating Excel for invoice: {invoice_id}")
-        
-        # Generate Excel
-        excel_bytes = ExcelService.generate_excel(invoice)
-        
-        return Response(
-            content=excel_bytes,
-            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            headers={
-                "Content-Disposition": f"attachment; filename=devis_{invoice_id}.xlsx"
-            }
-        )
-    except Exception as e:
-        logger.error(f"Error generating Excel: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e)) 

app/schemas/__init__.py

@@ -1 +0,0 @@
-# Empty file to make the directory a Python package 

app/schemas/invoice.py

@@ -1,53 +0,0 @@
-from pydantic import BaseModel, computed_field
-from typing import List, Optional
-from datetime import datetime
-
-class InvoiceItemCreate(BaseModel):
-    description: str
-    unit: str
-    quantity: int
-    length: float
-    unit_price: float
-    
-    @computed_field
-    def total_price(self) -> float:
-        return self.quantity * self.length * self.unit_price
-
-class InvoiceCreate(BaseModel):
-    invoice_number: str
-    date: Optional[datetime] = None
-    project: str
-    client_name: str
-    phone1: str
-    phone2: Optional[str] = None
-    address: str
-    ville: Optional[str] = None
-    total_ht: float
-    tax: float
-    total_ttc: float
-    frame_number: Optional[str] = None
-    items: List[InvoiceItemCreate]
-    commercial: Optional[str] = "divers"
-    status: Optional[str] = "pending"
-
-    @computed_field
-    def customer_name(self) -> str:
-        return self.client_name
-    
-    @computed_field
-    def amount(self) -> float:
-        return self.total_ttc
-
-class InvoiceItemResponse(InvoiceItemCreate):
-    id: int
-    invoice_id: int
-
-    class Config:
-        from_attributes = True
-
-class InvoiceResponse(InvoiceCreate):
-    id: int
-    items: List[InvoiceItemResponse]
-
-    class Config:
-        from_attributes = True

app/services/excel_service copy 2.py

@@ -1,205 +0,0 @@
-from openpyxl import Workbook
-from openpyxl.styles import Font, Alignment, Border, Side, PatternFill
-from openpyxl.utils import get_column_letter
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class ExcelService:
-    @staticmethod
-    def generate_excel(data: Invoice) -> bytes:
-        try:
-            wb = Workbook()
-            ws = wb.active
-            ws.title = "Devis"
-
-            # Constants - Match PDF colors and dimensions
-            HEADER_BLUE = "4A739B"  # Match PDF's HEADER_BLUE
-            WHITE = "FFFFFF"
-            BLACK = "000000"
-            STANDARD_FONT_SIZE = 11
-            
-            # Helper function for cell styling
-            def style_cell(cell, bold=False, color=BLACK, bg_color=None, size=STANDARD_FONT_SIZE, wrap_text=False, align='center'):
-                cell.font = Font(bold=bold, color=color, size=size)
-                cell.alignment = Alignment(horizontal=align, vertical='center', wrap_text=wrap_text)
-                if bg_color:
-                    cell.fill = PatternFill(start_color=bg_color, end_color=bg_color, fill_type="solid")
-
-            # Set fixed column widths to match PDF
-            column_widths = {
-                'A': 40,  # Description
-                'B': 15,  # Unité
-                'C': 15,  # NBRE
-                'D': 15,  # ML/Qté
-                'E': 15,  # P.U
-                'F': 20,  # Total HT
-            }
-            for col, width in column_widths.items():
-                ws.column_dimensions[col].width = width
-
-            # Add logo and company name
-            current_row = 1
-            logo_path = os.path.join(os.path.dirname(__file__), "..", "static", "logo.png")
-            if os.path.exists(logo_path):
-                from openpyxl.drawing.image import Image
-                img = Image(logo_path)
-                img.width = 100
-                img.height = 100
-                ws.add_image(img, 'A1')
-                current_row += 6
-
-            # Add DEVIS header
-            ws.merge_cells(f'E{current_row}:F{current_row}')
-            devis_cell = ws[f'E{current_row}']
-            devis_cell.value = "DEVIS"
-            style_cell(devis_cell, bold=True, size=36, align='right')
-            current_row += 2
-
-            # Client Information Box
-            client_info = [
-                ("Client:", data.client_name),
-                ("Projet:", data.project),
-                ("Adresse:", data.address),
-                ("Ville:", data.ville),
-                ("Tél:", data.client_phone)
-            ]
-            
-            # Style client info as a box
-            client_box_start = current_row
-            for label, value in client_info:
-                ws[f'E{current_row}'].value = label
-                ws[f'F{current_row}'].value = value
-                style_cell(ws[f'E{current_row}'], bold=True)
-                style_cell(ws[f'F{current_row}'])
-                current_row += 1
-
-            # Draw border around client info
-            for row in range(client_box_start, current_row):
-                for col in ['E', 'F']:
-                    ws[f'{col}{row}'].border = Border(
-                        left=Side(style='thin'),
-                        right=Side(style='thin'),
-                        top=Side(style='thin') if row == client_box_start else None,
-                        bottom=Side(style='thin') if row == current_row - 1 else None
-                    )
-
-            current_row += 2
-
-            # Invoice Details Box (Date, N° Devis, PLANCHER)
-            info_rows = [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]
-
-            for label, value in info_rows:
-                ws[f'A{current_row}'].value = label
-                ws[f'B{current_row}'].value = value
-                style_cell(ws[f'A{current_row}'], bold=True, color=WHITE, bg_color=HEADER_BLUE)
-                style_cell(ws[f'B{current_row}'])
-                current_row += 1
-
-            current_row += 1
-
-            # Table Headers
-            headers = ["Description", "Unité", "NBRE", "ML/Qté", "P.U", "Total HT"]
-            for col, header in enumerate(headers, 1):
-                cell = ws.cell(row=current_row, column=col, value=header)
-                style_cell(cell, bold=True, color=WHITE, bg_color=HEADER_BLUE)
-            current_row += 1
-
-            # Sections and Items
-            sections = [
-                ("POUTRELLES", "PCP"),
-                ("HOURDIS", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES", "PTS"),
-                ("AGGLOS", "AGGLOS")
-            ]
-
-            for section_name, keyword in sections:
-                items = [i for i in data.items if keyword in i.description]
-                if items:
-                    # Section Header
-                    ws.merge_cells(f'A{current_row}:F{current_row}')
-                    ws[f'A{current_row}'].value = section_name
-                    style_cell(ws[f'A{current_row}'], bold=True)
-                    current_row += 1
-
-                    # Items
-                    for item in items:
-                        ws.cell(row=current_row, column=1).value = item.description
-                        ws.cell(row=current_row, column=2).value = item.unit
-                        ws.cell(row=current_row, column=3).value = item.quantity
-                        ws.cell(row=current_row, column=4).value = item.length
-                        ws.cell(row=current_row, column=5).value = item.unit_price
-                        ws.cell(row=current_row, column=6).value = item.total_price
-                        
-                        # Style each cell in the row
-                        for col in range(1, 7):
-                            style_cell(ws.cell(row=current_row, column=col))
-                        
-                        current_row += 1
-
-            current_row += 1
-
-            # NB Section with wrapped text
-            ws.merge_cells(f'A{current_row}:F{current_row}')
-            nb_cell = ws[f'A{current_row}']
-            nb_cell.value = "NB: Toute modification apportée aux plans BA initialement fournis, entraine automatiquement la modification de ce devis."
-            style_cell(nb_cell, wrap_text=True, align='left')
-            current_row += 2
-
-            # Totals Section
-            totals = [
-                ("Total H.T", data.total_ht),
-                ("TVA 20%", data.tax),
-                ("Total TTC", data.total_ttc)
-            ]
-
-            for label, value in totals:
-                ws[f'E{current_row}'].value = label
-                ws[f'F{current_row}'].value = f"{value:,.2f} DH"
-                style_cell(ws[f'E{current_row}'], bold=True)
-                style_cell(ws[f'F{current_row}'], bold=True)
-                current_row += 1
-
-            # Footer
-            current_row += 1
-            footer_texts = [
-                "CARRIPREFA",
-                "Douar Ait Laarassi Tidili, Cercle El Kelâa, Route de Safi, Km 14-40000 Marrakech",
-                "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-            ]
-
-            for text in footer_texts:
-                ws.merge_cells(f'A{current_row}:F{current_row}')
-                footer_cell = ws[f'A{current_row}']
-                footer_cell.value = text
-                style_cell(footer_cell)
-                current_row += 1
-
-            # Commercial information if available
-            if data.commercial and data.commercial.lower() != 'divers':
-                ws.merge_cells(f'A{current_row}:C{current_row}')
-                ws[f'A{current_row}'].value = f"Commercial: {data.commercial.upper()}"
-                style_cell(ws[f'A{current_row}'], align='left')
-                
-                ws.merge_cells(f'D{current_row}:F{current_row}')
-                ws[f'D{current_row}'].value = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
-                style_cell(ws[f'D{current_row}'], align='right')
-
-            # Save to buffer
-            buffer = BytesIO()
-            wb.save(buffer)
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in Excel generation: {str(e)}", exc_info=True)
-            raise

app/services/excel_service copy.py

@@ -1,220 +0,0 @@
-
-from openpyxl import Workbook
-from openpyxl.styles import Font, Alignment, Border, Side, PatternFill
-from openpyxl.utils import get_column_letter
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class ExcelService:
-    @staticmethod
-    def generate_excel(data: Invoice) -> bytes:
-        try:
-            # Create a workbook and select the active worksheet
-            wb = Workbook()
-            ws = wb.active
-
-            # Constants
-            HEADER_BLUE = "00468B"  # RGB for header blue
-            WHITE = "FFFFFF"
-            BLACK = "000000"
-            MARGIN = 2  # Excel doesn't use pixels, so we simulate margins with empty rows/columns
-            LINE_HEIGHT = 15  # Row height
-            STANDARD_FONT_SIZE = 10
-            BOTTOM_MARGIN = 5  # Minimum margin at the bottom of the sheet
-
-            # Helper function to apply borders to a cell range
-            def apply_border(cell_range):
-                thin_border = Border(
-                    left=Side(style='thin'),
-                    right=Side(style='thin'),
-                    top=Side(style='thin'),
-                    bottom=Side(style='thin')
-                )
-                for row in ws[cell_range]:
-                    for cell in row:
-                        cell.border = thin_border
-
-            # Helper function to merge cells and center text
-            def merge_and_center(cell_range, text, font=None, fill=None):
-                ws.merge_cells(cell_range)
-                cell = ws[cell_range.split(":")[0]]
-                cell.value = text
-                cell.alignment = Alignment(horizontal="center", vertical="center")
-                if font:
-                    cell.font = font
-                if fill:
-                    cell.fill = PatternFill(start_color=fill, end_color=fill, fill_type="solid")
-
-            # Set column widths and row heights
-            ws.column_dimensions['A'].width = 30
-            ws.column_dimensions['B'].width = 10
-            ws.column_dimensions['C'].width = 10
-            ws.column_dimensions['D'].width = 12
-            ws.column_dimensions['E'].width = 12
-            ws.column_dimensions['F'].width = 15
-
-            # Top section layout
-            current_row = 1
-
-            # Add logo (if available)
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            logo_path = os.path.join(current_dir, "..", "static", "logo.png")
-            if os.path.exists(logo_path):
-                from openpyxl.drawing.image import Image
-                img = Image(logo_path)
-                img.width = 100
-                img.height = 100
-                ws.add_image(img, 'A1')
-                current_row += 6  # Adjust row position after logo
-
-            # Add "DEVIS" text
-            ws.merge_cells(f"F{current_row}:G{current_row}")
-            ws[f"F{current_row}"].value = "DEVIS"
-            ws[f"F{current_row}"].font = Font(bold=True, size=36)
-            ws[f"F{current_row}"].alignment = Alignment(horizontal="right")
-
-            # Client info box
-            current_row += 1
-            client_box_start = f"F{current_row}"
-            client_box_end = f"G{current_row + 4}"
-            apply_border(f"{client_box_start}:{client_box_end}")
-
-            client_info = [
-                data.client_name,
-                data.project,
-                data.address,
-                data.ville,
-                data.client_phone
-            ]
-            for i, info in enumerate(client_info):
-                ws[f"F{current_row + i}"].value = info
-                ws[f"F{current_row + i}"].alignment = Alignment(horizontal="center")
-
-            current_row += 6
-
-            # Info boxes (Date, N° Devis, PLANCHER)
-            for label, value in [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]:
-                ws[f"A{current_row}"].value = label
-                ws[f"A{current_row}"].font = Font(bold=True, color=WHITE)
-                ws[f"A{current_row}"].fill = PatternFill(start_color=HEADER_BLUE, end_color=HEADER_BLUE, fill_type="solid")
-                ws[f"B{current_row}"].value = value
-                apply_border(f"A{current_row}:B{current_row}")
-                current_row += 1
-
-            # Table headers
-            headers = [
-                ("Description", 30),
-                ("Unité", 10),
-                ("NBRE", 10),
-                ("ML/Qté", 12),
-                ("P.U", 12),
-                ("Total HT", 15)
-            ]
-            for col, (title, width) in enumerate(headers, start=1):
-                cell = ws.cell(row=current_row, column=col, value=title)
-                cell.font = Font(bold=True, color=WHITE)
-                cell.fill = PatternFill(start_color=HEADER_BLUE, end_color=HEADER_BLUE, fill_type="solid")
-                cell.alignment = Alignment(horizontal="center")
-            apply_border(f"A{current_row}:F{current_row}")
-            current_row += 1
-
-            # Draw sections and items
-            sections = [
-                ("POUTRELLES", "PCP"),
-                ("HOURDIS", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES", "PTS"),
-                ("AGGLOS", "AGGLOS")
-            ]
-
-            for section_title, keyword in sections:
-                items = [i for i in data.items if keyword in i.description]
-                if items:
-                    ws[f"A{current_row}"].value = section_title
-                    ws[f"A{current_row}"].font = Font(bold=True)
-                    current_row += 1
-
-                    for item in items:
-                        ws[f"A{current_row}"].value = item.description
-                        ws[f"B{current_row}"].value = item.unit
-                        ws[f"C{current_row}"].value = item.quantity
-                        ws[f"D{current_row}"].value = item.length
-                        ws[f"E{current_row}"].value = item.unit_price
-                        ws[f"F{current_row}"].value = item.total_price
-                        apply_border(f"A{current_row}:F{current_row}")
-                        current_row += 1
-
-            # NB box with text
-            ws[f"A{current_row}"].value = "NB:"
-            ws[f"A{current_row}"].font = Font(bold=True)
-            ws.merge_cells(f"B{current_row}:F{current_row}")
-            ws[f"B{current_row}"].value = "Toute modification apportée aux plans BA initialement fournis, entraine automatiquement la modification de ce devis."
-            ws[f"B{current_row}"].alignment = Alignment(wrap_text=True)
-            apply_border(f"A{current_row}:F{current_row}")
-            current_row += 2
-
-            # Totals section
-            totals = [
-                ("Total H.T", data.total_ht),
-                ("TVA 20%", data.tax),
-                ("Total TTC", data.total_ttc)
-            ]
-            for label, value in totals:
-                ws[f"E{current_row}"].value = label
-                ws[f"F{current_row}"].value = value
-                ws[f"F{current_row}"].font = Font(bold=True)
-                apply_border(f"E{current_row}:F{current_row}")
-                current_row += 1
-
-            # Footer
-            ws[f"A{current_row}"].value = "CARRIPREFA"
-            ws[f"A{current_row}"].font = Font(bold=True)
-            ws.merge_cells(f"A{current_row}:F{current_row}")
-            ws[f"A{current_row}"].alignment = Alignment(horizontal="center")
-            current_row += 1
-
-            ws[f"A{current_row}"].value = "Douar Ait Laarassi Tidili, Cercle El Kelâa, Route de Safi, Km 14-40000 Marrakech"
-            ws.merge_cells(f"A{current_row}:F{current_row}")
-            ws[f"A{current_row}"].alignment = Alignment(horizontal="center")
-            current_row += 1
-
-            # Commercial info
-            commercial_info = {
-                "salah": "06 62 29 99 78",
-                "khaled": "06 66 24 80 94",
-                "ismail": "06 66 24 50 15",
-                "jamal": "06 70 08 36 50"
-            }
-            if data.commercial and data.commercial.lower() != 'divers':
-                ws[f"A{current_row}"].value = f"Commercial: {data.commercial.upper()}"
-                ws[f"B{current_row}"].value = f"Tél: {commercial_info.get(data.commercial.lower(), '')}"
-                current_row += 1
-
-            ws[f"A{current_row}"].value = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-            ws.merge_cells(f"A{current_row}:F{current_row}")
-            ws[f"A{current_row}"].alignment = Alignment(horizontal="center")
-            current_row += 1
-
-            ws[f"A{current_row}"].value = f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}"
-            ws[f"F{current_row}"].value = f"Page 1/1"
-            apply_border(f"A{current_row}:F{current_row}")
-
-            # Save to BytesIO buffer
-            buffer = BytesIO()
-            wb.save(buffer)
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in Excel generation: {str(e)}", exc_info=True)
-            raise
-

app/services/excel_service.py

@@ -1,382 +0,0 @@
-from openpyxl import Workbook
-from openpyxl.styles import Font, Alignment, Border, Side, PatternFill
-from openpyxl.utils import get_column_letter
-from openpyxl.worksheet.pagebreak import Break  # Add this import
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-import io
-import xlsxwriter
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class ExcelService:
-    @staticmethod
-    def generate_excel(invoice: Invoice) -> bytes:
-        # Create an in-memory output file
-        output = io.BytesIO()
-        
-        # Create a new workbook and add a worksheet
-        workbook = xlsxwriter.Workbook(output)
-        worksheet = workbook.add_worksheet()
-
-        # Add formats
-        header_format = workbook.add_format({
-            'bold': True,
-            'align': 'center',
-            'valign': 'vcenter',
-            'border': 1
-        })
-        
-        cell_format = workbook.add_format({
-            'align': 'center',
-            'valign': 'vcenter',
-            'border': 1
-        })
-        
-        # Set column widths
-        worksheet.set_column('A:A', 30)  # Description
-        worksheet.set_column('B:B', 10)  # Unit
-        worksheet.set_column('C:C', 10)  # Quantity
-        worksheet.set_column('D:D', 10)  # Length
-        worksheet.set_column('E:E', 12)  # Unit Price
-        worksheet.set_column('F:F', 15)  # Total HT
-
-        # Write headers
-        headers = ['Description', 'Unité', 'Quantité', 'Longueur', 'P.U', 'Total HT']
-        for col, header in enumerate(headers):
-            worksheet.write(0, col, header, header_format)
-
-        # Write invoice information at the top
-        info_format = workbook.add_format({'bold': True})
-        worksheet.write('A1', f'Devis N°: {invoice.invoice_number}', info_format)
-        worksheet.write('A2', f'Date: {invoice.date.strftime("%d/%m/%Y")}', info_format)
-        worksheet.write('A3', f'Client: {invoice.client_name}', info_format)
-        worksheet.write('A4', f'Projet: {invoice.project}', info_format)
-
-        # Start writing items from row 6
-        current_row = 5
-
-        # Write items
-        for item in invoice.items:
-            worksheet.write(current_row, 0, item.description, cell_format)
-            worksheet.write(current_row, 1, item.unit, cell_format)
-            worksheet.write(current_row, 2, item.quantity, cell_format)
-            worksheet.write(current_row, 3, item.length, cell_format)
-            worksheet.write(current_row, 4, item.unit_price, cell_format)
-            worksheet.write(current_row, 5, item.total_price, cell_format)
-            current_row += 1
-
-        # Write totals
-        total_format = workbook.add_format({
-            'bold': True,
-            'align': 'right',
-            'border': 1
-        })
-        
-        current_row += 1
-        worksheet.write(current_row, 4, 'Total HT:', total_format)
-        worksheet.write(current_row, 5, invoice.total_ht, cell_format)
-        
-        current_row += 1
-        worksheet.write(current_row, 4, 'TVA (20%):', total_format)
-        worksheet.write(current_row, 5, invoice.tax, cell_format)
-        
-        current_row += 1
-        worksheet.write(current_row, 4, 'Total TTC:', total_format)
-        worksheet.write(current_row, 5, invoice.total_ttc, cell_format)
-
-        # Close the workbook
-        workbook.close()
-
-        # Seek to the beginning of the stream
-        output.seek(0)
-        
-        return output.getvalue()
-
-    @staticmethod
-    def generate_excel_openpyxl(data: Invoice) -> bytes:
-        try:
-            wb = Workbook()
-            ws = wb.active
-            ws.title = "Devis"
-
-            # Constants - Match PDF colors and dimensions
-            HEADER_BLUE = "4A739B"  # Match PDF's HEADER_BLUE
-            WHITE = "FFFFFF"
-            BLACK = "000000"
-            STANDARD_FONT_SIZE = 11
-            
-            # Helper function for cell styling
-            def style_cell(cell, bold=False, color=BLACK, bg_color=None, size=STANDARD_FONT_SIZE, wrap_text=False, align='center'):
-                cell.font = Font(bold=bold, color=color, size=size)
-                cell.alignment = Alignment(horizontal=align, vertical='center', wrap_text=wrap_text)
-                if bg_color:
-                    cell.fill = PatternFill(start_color=bg_color, end_color=bg_color, fill_type="solid")
-
-            # Set fixed column widths to match PDF
-            column_widths = {
-                'A': 40,  # Description
-                'B': 15,  # Unité
-                'C': 15,  # NBRE
-                'D': 15,  # ML/Qté
-                'E': 15,  # P.U
-                'F': 20,  # Total HT
-            }
-            for col, width in column_widths.items():
-                ws.column_dimensions[col].width = width
-
-            # Add logo and company name
-            current_row = 1
-            logo_path = os.path.join(os.path.dirname(__file__), "..", "static", "logo.png")
-            if os.path.exists(logo_path):
-                from openpyxl.drawing.image import Image
-                img = Image(logo_path)
-                img.width = 100
-                img.height = 100
-                ws.add_image(img, 'A1')
-                current_row += 6
-
-            # Add DEVIS header
-            ws.merge_cells(f'E{current_row}:F{current_row}')
-            devis_cell = ws[f'E{current_row}']
-            devis_cell.value = "DEVIS"
-            style_cell(devis_cell, bold=True, size=36, align='right')
-            current_row += 2
-
-            # Client Information Box
-            client_info = [
-                ("Client:", data.client_name),
-                ("Projet:", data.project),
-                ("Adresse:", data.address),
-                ("Ville:", data.ville),
-                ("Tél:", data.client_phone)
-            ]
-            
-            # Style client info as a box
-            client_box_start = current_row
-            for label, value in client_info:
-                ws[f'E{current_row}'].value = label
-                ws[f'F{current_row}'].value = value
-                style_cell(ws[f'E{current_row}'], bold=True)
-                style_cell(ws[f'F{current_row}'])
-                current_row += 1
-
-            # Draw border around client info
-            for row in range(client_box_start, current_row):
-                for col in ['E', 'F']:
-                    ws[f'{col}{row}'].border = Border(
-                        left=Side(style='thin'),
-                        right=Side(style='thin'),
-                        top=Side(style='thin') if row == client_box_start else None,
-                        bottom=Side(style='thin') if row == current_row - 1 else None
-                    )
-
-            current_row += 2
-
-            # Invoice Details Box (Date, N° Devis, PLANCHER)
-            info_rows = [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]
-
-            for label, value in info_rows:
-                ws[f'A{current_row}'].value = label
-                ws[f'B{current_row}'].value = value
-                style_cell(ws[f'A{current_row}'], bold=True, color=WHITE, bg_color=HEADER_BLUE)
-                style_cell(ws[f'B{current_row}'])
-                current_row += 1
-
-            current_row += 1
-
-            # Table Headers
-            headers = ["Description", "Unité", "NBRE", "ML/Qté", "P.U", "Total HT"]
-            for col, header in enumerate(headers, 1):
-                cell = ws.cell(row=current_row, column=col, value=header)
-                style_cell(cell, bold=True, color=WHITE, bg_color=HEADER_BLUE)
-            current_row += 1
-
-            # Helper function to extract number from description
-            def get_description_number(description: str) -> float:
-                try:
-                    # Extract numbers from strings like "PCP 114N", "HOURDIS TYPE 12", etc.
-                    import re
-                    numbers = re.findall(r'\d+\.?\d*', description)
-                    return float(numbers[0]) if numbers else 0
-                except:
-                    return 0
-
-            # Modified Sections and Items with sorting
-            sections = [
-                ("POUTRELLES", "PCP"),
-                ("HOURDIS", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES", "PTS"),
-                ("AGGLOS", "AGGLOS")
-            ]
-
-            # Modified sorting to be ascending instead of descending
-            for section_name, keyword in sections:
-                items = [i for i in data.items if keyword in i.description]
-                if items:
-                    # Sort items by description number (ascending) and then by length (ascending)
-                    sorted_items = sorted(
-                        items,
-                        key=lambda x: (get_description_number(x.description), x.length)
-                    )
-
-                    # Group items by unique description type and epaisseur
-                    unique_items = {}
-                    for item in sorted_items:
-                        key = (item.description, item.length)  # Tuple of description and length
-                        if key not in unique_items:
-                            unique_items[key] = item
-                        else:
-                            # If item exists, sum quantities and update total
-                            existing = unique_items[key]
-                            existing.quantity += item.quantity
-                            existing.total_price = existing.quantity * existing.length * existing.unit_price
-
-                    # Add section header
-                    ws.merge_cells(f'A{current_row}:F{current_row}')
-                    ws[f'A{current_row}'].value = section_name
-                    style_cell(ws[f'A{current_row}'], bold=True)
-                    current_row += 1
-
-                    # Add sorted and unique items
-                    for item in unique_items.values():
-                        ws.cell(row=current_row, column=1).value = item.description
-                        ws.cell(row=current_row, column=2).value = item.unit
-                        ws.cell(row=current_row, column=3).value = item.quantity
-                        ws.cell(row=current_row, column=4).value = item.length
-                        ws.cell(row=current_row, column=5).value = item.unit_price
-                        ws.cell(row=current_row, column=6).value = item.total_price
-                        
-                        for col in range(1, 7):
-                            style_cell(ws.cell(row=current_row, column=col))
-                        
-                        current_row += 1
-
-            current_row += 1
-
-            # NB Section with wrapped text
-            ws.merge_cells(f'A{current_row}:F{current_row}')
-            nb_cell = ws[f'A{current_row}']
-            nb_cell.value = "NB: Toute modification apportée aux plans BA initialement fournis, entraine automatiquement la modification de ce devis."
-            style_cell(nb_cell, wrap_text=True, align='left')
-            current_row += 2
-
-            # Totals Section
-            totals = [
-                ("Total H.T", data.total_ht),
-                ("TVA 20%", data.tax),
-                ("Total TTC", data.total_ttc)
-            ]
-
-            for label, value in totals:
-                ws[f'E{current_row}'].value = label
-                ws[f'F{current_row}'].value = f"{value:,.2f} DH"
-                style_cell(ws[f'E{current_row}'], bold=True)
-                style_cell(ws[f'F{current_row}'], bold=True)
-                current_row += 1
-
-            # Footer
-            current_row += 1
-            footer_texts = [
-                "CARRIPREFA",
-                "Douar Ait Laarassi Tidili, Cercle El Kelâa, Route de Safi, Km 14-40000 Marrakech",
-                "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-            ]
-
-            for text in footer_texts:
-                ws.merge_cells(f'A{current_row}:F{current_row}')
-                footer_cell = ws[f'A{current_row}']
-                footer_cell.value = text
-                style_cell(footer_cell)
-                current_row += 1
-
-            # Commercial information if available
-            if data.commercial and data.commercial.lower() != 'divers':
-                ws.merge_cells(f'A{current_row}:C{current_row}')
-                ws[f'A{current_row}'].value = f"Commercial: {data.commercial.upper()}"
-                style_cell(ws[f'A{current_row}'], align='left')
-                
-                ws.merge_cells(f'D{current_row}:F{current_row}')
-                ws[f'D{current_row}'].value = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
-                style_cell(ws[f'D{current_row}'], align='right')
-
-
-            # Set print area and page setup
-            ws.page_setup.paperSize = ws.PAPERSIZE_A4
-            ws.page_setup.orientation = ws.ORIENTATION_PORTRAIT
-            ws.page_setup.fitToPage = True
-            ws.page_setup.fitToHeight = 1
-            ws.page_setup.fitToWidth = 1
-            ws.page_margins.left = 0.5
-            ws.page_margins.right = 0.5
-            ws.page_margins.top = 0.5
-            ws.page_margins.bottom = 0.5
-            ws.page_margins.header = 0.3
-            ws.page_margins.footer = 0.3
-
-            # Set row heights for better spacing
-            ws.row_dimensions[1].height = 80  # Logo row
-            for row in range(2, ws.max_row + 1):
-                ws.row_dimensions[row].height = 20  # Standard row height
-
-            # Add page breaks for better printing
-            ws.page_breaks = []
-            
-            # Group rows for better organization
-            # Fix: change start_row/end_row to from_/to_
-            for row in range(client_box_start, current_row):
-                ws.row_dimensions[row].group = True
-                ws.row_dimensions[row].outline_level = 1
-
-            # Freeze panes to keep headers visible
-            ws.freeze_panes = 'A10'  # Freeze after headers
-
-            # Print settings
-            ws.print_options.gridLines = False
-            ws.print_options.horizontalCentered = True
-            ws.print_options.verticalCentered = False
-
-            # Add print titles (repeat rows)
-            ws.print_title_rows = '1:9'  # Repeat first 9 rows on each page
-
-            # Set the print area
-            ws.print_area = [f'A1:F{current_row}']
-
-            # Auto-fit all rows for content
-            for row in ws.rows:
-                max_height = 0
-                for cell in row:
-                    if cell.value:
-                        text_lines = str(cell.value).count('\n') + 1
-                        max_height = max(max_height, text_lines * 15)  # 15 points per line
-                if max_height > 0:
-                    ws.row_dimensions[cell.row].height = max_height
-
-            # Add page break before totals section
-            ws.row_breaks.append(Break(id=current_row - 4))
-
-            # Ensure footer stays together
-            # Fix: Replace the old footer grouping with this
-            # Group footer rows together
-            for row in range(current_row - 3, current_row + 1):
-                ws.row_dimensions[row].group = True
-                ws.row_dimensions[row].outline_level = 1
-                ws.row_dimensions[row].hidden = False
-
-            # Save to buffer
-            buffer = BytesIO()
-            wb.save(buffer)
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in Excel generation: {str(e)}", exc_info=True)
-            raise

app/services/invoice_service copy 2.py

@@ -1,396 +0,0 @@
-from reportlab.lib.pagesizes import A4
-from reportlab.pdfgen import canvas
-from reportlab.lib import colors
-from reportlab.lib.units import cm
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-import re
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class InvoiceService:
-    @staticmethod
-    def generate_pdf(data: Invoice) -> bytes:
-        try:
-            buffer = BytesIO()
-            pdf = canvas.Canvas(buffer, pagesize=A4)
-            page_width, page_height = A4
-
-            # Constants
-            HEADER_BLUE = (0.29, 0.45, 0.68)
-            BLUE_LIGHT = (1.5, 1.5, 1)
-            WHITE = (1, 1, 1)
-            BLACK = (0, 0, 0)
-            MARGIN = 30
-            LINE_HEIGHT = 20
-            BOX_PADDING = 10
-            STANDARD_FONT_SIZE = 10
-            BOTTOM_MARGIN = 50  # Minimum margin at the bottom of the page
-
-            # Helper function to draw centered text
-            def draw_centered_text(pdf, text, x, y, width, font="Helvetica", size=STANDARD_FONT_SIZE):
-                text_width = pdf.stringWidth(text, font, size)
-                pdf.drawString(x + (width - text_width) / 2, y, text)
-
-            # Helper function to draw a bordered box
-            def draw_box(pdf, x, y, width, height, fill_color=None, stroke_color=BLACK):
-                if fill_color:
-                    pdf.setFillColorRGB(*fill_color)
-                    pdf.rect(x, y, width, height, fill=1, stroke=0)
-                pdf.setFillColorRGB(*stroke_color)
-                pdf.rect(x, y, width, height, stroke=1)
-
-            # Add this helper function after the existing helper functions
-            def draw_wrapped_text(pdf, text, x, y, width, font="Helvetica", size=STANDARD_FONT_SIZE):
-                """Draw text wrapped to fit within a given width."""
-                pdf.setFont(font, size)
-                words = text.split()
-                lines = []
-                current_line = []
-                
-                for word in words:
-                    current_line.append(word)
-                    line_width = pdf.stringWidth(' '.join(current_line), font, size)
-                    if line_width > width:
-                        current_line.pop()  # Remove last word
-                        if current_line:  # Only add if there are words
-                            lines.append(' '.join(current_line))
-                        current_line = [word]  # Start new line with the word that didn't fit
-                
-                if current_line:  # Add the last line
-                    lines.append(' '.join(current_line))
-                
-                return lines
-
-            # Get the absolute path to the logo file
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            logo_path = os.path.join(current_dir, "..", "static", "logo.png")
-
-            # Top section layout
-            top_margin = page_height - 120
-
-            # Left side: Logo - moved far left and up
-            if os.path.exists(logo_path):
-                pdf.drawImage(logo_path, MARGIN, top_margin - 10, width=100, height=100)
-
-            # Right side: DEVIS and Client Box - moved far right and up
-            pdf.setFont("Helvetica-Bold", 36)
-            devis_text = "DEVIS"
-            devis_width = pdf.stringWidth(devis_text, "Helvetica-Bold", 36)
-            devis_x = page_width - devis_width - MARGIN - 10
-            devis_y = top_margin + 50
-            pdf.drawString(devis_x, devis_y, devis_text)
-
-            # Client info box - moved right under DEVIS
-            box_width = 200
-            box_height = 80
-            box_x = page_width - box_width - MARGIN + 10
-            box_y = devis_y - 120
-
-            # Draw client box
-            pdf.rect(box_x, box_y, box_width, box_height, stroke=1)
-
-            # Client Info
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-            client_info = [
-                data.client_name,
-                data.project,
-                data.address,
-                data.ville,  # Add ville here
-                data.client_phone
-            ]
-
-            available_height = box_height - BOX_PADDING * 2
-            y_position = box_y + box_height - BOX_PADDING
-
-            for text in client_info:
-                if text:
-                    # Calculate available width for text
-                    available_width = box_width - BOX_PADDING * 2
-                    # Get wrapped lines
-                    lines = draw_wrapped_text(pdf, str(text), box_x, y_position, available_width)
-                    
-                    # Draw each line
-                    for line in lines:
-                        text_width = pdf.stringWidth(line, "Helvetica", STANDARD_FONT_SIZE)
-                        x = box_x + (box_width - text_width) / 2
-                        pdf.drawString(x, y_position, line)
-                        y_position -= STANDARD_FONT_SIZE + 2  # Add some spacing between lines
-
-                    # Add extra spacing between different info pieces
-                    y_position -= 2
-
-            # Info boxes (Date, N° Devis, PLANCHER) - adjusted starting position
-            info_y = top_margin - 50
-            box_label_width = 100  # Reduced label width
-            box_value_width = 150  # Increased value width for longer text
-
-            for label, value in [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]:
-                draw_box(pdf, MARGIN, info_y, box_label_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-                pdf.setFillColorRGB(*WHITE)
-                pdf.drawString(MARGIN + BOX_PADDING, info_y + 6, label)
-
-                draw_box(pdf, MARGIN + box_label_width, info_y, box_value_width, LINE_HEIGHT, fill_color=WHITE)
-                pdf.setFillColorRGB(*BLACK)
-                # Draw value text with wrapping if needed
-                value_str = str(value)
-                if len(value_str) > 20:  # If text is too long
-                    pdf.setFont("Helvetica", 8)  # Reduce font size for long text
-                    lines = draw_wrapped_text(pdf, value_str, MARGIN + box_label_width, info_y + 6, box_value_width - 10)
-                    for i, line in enumerate(lines):
-                        draw_centered_text(pdf, line, MARGIN + box_label_width, info_y + 6 - (i * 8), box_value_width)
-                else:
-                    pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-                    draw_centered_text(pdf, value_str, MARGIN + box_label_width, info_y + 6, box_value_width)
-
-                info_y -= 25
-
-            # Table headers
-            table_y = info_y - 30
-            headers = [
-                ("Description", 150),
-                ("Unité", 50),
-                ("NBRE", 50),
-                ("ML/Qté", 60),
-                ("P.U", 60),
-                ("Total HT", 170)
-            ]
-
-            total_width = sum(width for _, width in headers)
-            table_x = (page_width - total_width) / 2  # Center table
-            draw_box(pdf, table_x, table_y, total_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-            pdf.setFillColorRGB(*WHITE)
-
-            current_x = table_x
-            for title, width in headers:
-                draw_box(pdf, current_x, table_y, width, LINE_HEIGHT)
-                pdf.setFillColorRGB(*WHITE)
-                draw_centered_text(pdf, title, current_x, table_y + 6, width)
-                current_x += width
-
-            # Draw sections and items
-            current_y = table_y - LINE_HEIGHT - 10
-
-            def draw_section_header2(title):
-                nonlocal current_y
-                draw_box(pdf, table_x, current_y, total_width, LINE_HEIGHT, fill_color=WHITE)
-                pdf.setFont("Helvetica-Bold", 9)
-                pdf.setFillColorRGB(*BLACK)
-                pdf.drawString(table_x + BOX_PADDING, current_y + 6, title)
-                current_y -= LINE_HEIGHT
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-
-            def format_currency(value):
-                return "{:,.2f}".format(value).replace(",", " ")
-
-            def draw_item_row(item, indent=False):
-                nonlocal current_y
-                pdf.setFillColorRGB(*BLACK)
-                current_x = table_x
-
-                draw_box(pdf, current_x, current_y, total_width, LINE_HEIGHT, fill_color=WHITE)
-
-                cells = [
-                    ("    " + item.description if indent else item.description, 150),
-                    (item.unit, 50),
-                    (str(item.quantity), 50),
-                    (f"{item.length:.2f}", 60),
-                    (f"{format_currency(item.unit_price)}", 60),
-                    (f"{format_currency(item.total_price)}", 170)
-                ]
-
-                for i, (value, width) in enumerate(cells):
-                    draw_box(pdf, current_x, current_y, width, LINE_HEIGHT)
-
-                    if i == len(cells) - 1:
-                        pdf.setFont("Helvetica-Bold", STANDARD_FONT_SIZE)
-                    else:
-                        pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-
-                    if isinstance(value, str) and value.startswith("    "):
-                        pdf.drawString(current_x + 20, current_y + 6, value.strip())
-                    else:
-                        draw_centered_text(pdf, str(value), current_x, current_y + 6, width)
-
-                    current_x += width
-
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-                current_y -= LINE_HEIGHT
-
-                # Check if we need a new page
-                if current_y < BOTTOM_MARGIN:
-                    pdf.showPage()
-                    current_y = page_height - MARGIN
-                    # Redraw headers on the new page
-                    draw_box(pdf, table_x, current_y, total_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-                    pdf.setFillColorRGB(*WHITE)
-                    current_x = table_x
-                    for title, width in headers:
-                        draw_box(pdf, current_x, current_y, width, LINE_HEIGHT)
-                        pdf.setFillColorRGB(*WHITE)
-                        draw_centered_text(pdf, title, current_x, current_y + 6, width)
-                        current_x += width
-                    current_y -= LINE_HEIGHT
-
-            # Draw sections
-            sections = [
-                ("POUTRELLES", "PCP"),
-                ("HOURDIS", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES", "PTS"),
-                ("AGGLOS", "AGGLOS")
-            ]
-
-            def get_description_number(description: str) -> float:
-                try:
-                    numbers = re.findall(r'\d+\.?\d*', description)
-                    return float(numbers[0]) if numbers else 0
-                except:
-                    return 0
-
-            # Modify the section items handling
-            for section_title, keyword in sections:
-                # Get items for this section
-                items = [i for i in data.items if keyword in i.description]
-                # Only draw section if it has items
-                if items:
-                    # Sort items by description number (ascending) and length (ascending)
-                    sorted_items = sorted(
-                        items,
-                        key=lambda x: (get_description_number(x.description), x.length)
-                    )
-                    
-                    # Group identical items
-                    grouped_items = {}
-                    for item in sorted_items:
-                        key = (item.description, item.length)
-                        if key not in grouped_items:
-                            grouped_items[key] = item
-                        else:
-                            existing = grouped_items[key]
-                            existing.quantity += item.quantity
-                            existing.total_price = existing.quantity * existing.length * existing.unit_price
-
-                    draw_section_header2(section_title)
-                    for item in grouped_items.values():
-                        draw_item_row(item, indent=(keyword != "lfflflflf"))
-
-            # NB box with text
-            nb_box_width = 200
-            nb_box_height = 80
-            pdf.setFillColorRGB(*BLACK)
-            pdf.rect(20, current_y - nb_box_height, nb_box_width, nb_box_height, stroke=1)
-            
-            # Split the text into "NB:" and the rest
-            pdf.setFont("Helvetica-Bold", STANDARD_FONT_SIZE)
-            pdf.drawString(30, current_y - nb_box_height + 60, "NB:")
-            
-            # Continue with regular font for the rest of the text
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-            nb_text = "Toute modification apportée aux plans BA initialement fournis, entraine automatiquement la modification de ce devis."
-            words = nb_text.split()
-            lines = []
-            current_line = []
-
-            for word in words:
-                current_line.append(word)
-                if pdf.stringWidth(' '.join(current_line), "Helvetica", STANDARD_FONT_SIZE) > nb_box_width - 40:  # Adjusted width to account for "NB:"
-                    current_line.pop()
-                    lines.append(' '.join(current_line))
-                    current_line = [word]
-
-            if current_line:
-                lines.append(' '.join(current_line))
-
-            # Draw the text lines after "NB:"
-            for i, line in enumerate(lines):
-                pdf.drawString(55, current_y - nb_box_height + 60 - (i * 10), line)  # Adjusted x position to account for "NB:"
-
-            # ADD text after the NB box
-            pdf.setFont("Helvetica-Bold", 9)
-            pdf.drawString(30, current_y - nb_box_height - 15, "Validité du devis : 1 mois")
-
-
-                
-            # Totals section
-            pdf.setFont("Helvetica-Bold", 12)
-            current_y -= 20
-            totals_table_width = 300
-            row_height = 20
-
-            # Define the widths for the left and right boxes
-            left_box_width = 130  # Width of the left box
-            right_box_width = totals_table_width - left_box_width  # Remaining width for the right box
-
-            for i, (label1, label2, value) in enumerate([
-                ("Total", "H.T", f"{format_currency(data.total_ht)} DH"),
-                ("TVA", "20%", f"{format_currency(data.tax)} DH"),
-                ("Total", "TTC", f"{format_currency(data.total_ttc)} DH")
-            ]):
-                y = current_y - (i * row_height)
-                totals_x = (page_width - totals_table_width) - 27
-
-                # Draw the left box
-                draw_box(pdf, totals_x, y, left_box_width, row_height)
-
-                # Draw the right box
-                draw_box(pdf, totals_x + left_box_width, y, right_box_width, row_height)
-
-                # Draw left-aligned labels in the left box
-                pdf.drawString(totals_x + 10, y + 6, f"{label1}    {label2}")
-
-                # Calculate the center x position for the right box
-                center_x = totals_x + left_box_width + (right_box_width / 2)
-
-                # Draw centered value in the right box
-                pdf.drawCentredString(center_x, y + 6, value)
-
-
-            # Footer
-            ## add the first line text
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE - 3)
-            
-            footer_text = "CARRIPREFA"
-            pdf.drawCentredString(page_width / 2, 40, footer_text)
-            
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE - 3)
-            footer_text = "Douar Ait Toumart Habil, Cercle El Bour, Route de Safi, Km 14 -40000 Marrakech"
-            pdf.drawCentredString(page_width / 2 + 20, 30, footer_text)
-
-            # Add commercial info to footer
-            commercial_info = dict(
-                salah="06 62 29 99 78",
-                khaled="06 66 24 80 94",
-                ismail="06 66 24 50 15",
-                jamal="06 70 08 36 50"
-            )
-
-            if data.commercial and data.commercial.lower() != 'divers':
-                commercial_text = f"Commercial: {data.commercial.upper()}"
-                commercial_phone = f"Tél: {commercial_info.get(data.commercial.lower(), '')}"
-                pdf.drawString(MARGIN + 10, 30, commercial_text)
-                pdf.drawString(MARGIN + 10, 20, commercial_phone)
-                footer_contact = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}")
-                pdf.drawString(page_width - 100, 20, f"Page {pdf.getPageNumber()}/{pdf.getPageNumber()}")
-            else:
-                footer_contact = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}")
-                pdf.drawString(page_width - 100, 20, f"Page {pdf.getPageNumber()}/{pdf.getPageNumber()}")
-
-            pdf.save()
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in PDF generation: {str(e)}", exc_info=True)
-            raise

app/services/invoice_service copy.py

@@ -1,308 +0,0 @@
-from reportlab.lib.pagesizes import A4
-from reportlab.pdfgen import canvas
-from reportlab.lib import colors
-from reportlab.lib.units import cm
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class InvoiceService:
-    @staticmethod
-    def generate_pdf(data: Invoice) -> bytes:
-        try:
-            buffer = BytesIO()
-            pdf = canvas.Canvas(buffer, pagesize=A4)
-            page_width, page_height = A4
-
-            # Constants
-            HEADER_BLUE = (0.29, 0.45, 0.68)
-            BLUE_LIGHT = (1.5, 1.5, 1)
-            WHITE = (1, 1, 1)
-            BLACK = (0, 0, 0)
-            MARGIN = 30
-            LINE_HEIGHT = 20
-            BOX_PADDING = 10
-            STANDARD_FONT_SIZE = 10  # Add standard font size constant
-
-            # Helper function to draw centered text
-            def draw_centered_text(pdf, text, x, y, width, font="Helvetica", size=STANDARD_FONT_SIZE):
-                text_width = pdf.stringWidth(text, font, size)
-                pdf.drawString(x + (width - text_width) / 2, y, text)
-
-            # Helper function to draw a bordered box
-            def draw_box(pdf, x, y, width, height, fill_color=None, stroke_color=BLACK):
-                if fill_color:
-                    pdf.setFillColorRGB(*fill_color)
-                    pdf.rect(x, y, width, height, fill=1, stroke=0)
-                pdf.setFillColorRGB(*stroke_color)
-                pdf.rect(x, y, width, height, stroke=1)
-
-            # Get the absolute path to the logo file
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            logo_path = os.path.join(current_dir, "..", "static", "logo.png")
-
-            # Top section layout
-            top_margin = page_height - 100
-
-            # Left side: Logo - moved far left and up
-            if os.path.exists(logo_path):
-                pdf.drawImage(logo_path, MARGIN, top_margin + 30, width=100, height=60)
-
-            # Right side: DEVIS and Client Box - moved far right and up
-            pdf.setFont("Helvetica-Bold", 36)  # Reduced from 48 to be more consistent
-            devis_text = "DEVIS"
-            devis_width = pdf.stringWidth(devis_text, "Helvetica-Bold", 36)
-            devis_x = page_width - devis_width - MARGIN - 10
-            devis_y = top_margin + 50
-            pdf.drawString(devis_x, devis_y, devis_text)
-
-            # Client info box - moved right under DEVIS
-            box_width = 200
-            box_height = 80
-            box_x = page_width - box_width - MARGIN + 10
-            box_y = devis_y - 120
-
-            # Draw client box
-            pdf.rect(box_x, box_y, box_width, box_height, stroke=1)
-
-            # Client Info
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-            client_info = [
-                data.client_name,
-                data.project,
-                data.address,
-                data.client_phone
-            ]
-
-            # Center and draw each line of client info
-            line_height = box_height / (len(client_info) + 1)
-            for i, text in enumerate(client_info):
-                text_width = pdf.stringWidth(str(text), "Helvetica", STANDARD_FONT_SIZE)
-                x = box_x + (box_width - text_width) / 2
-                y = box_y + box_height - ((i + 1) * line_height)
-                pdf.drawString(x, y, str(text))
-
-            # Info boxes (Date, N° Devis, PLANCHER) - adjusted starting position
-            info_y = top_margin - 30
-            box_label_width = 120
-            box_value_width = 80
-
-            for label, value in [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]:
-                draw_box(pdf, MARGIN, info_y, box_label_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-                pdf.setFillColorRGB(*WHITE)
-                pdf.drawString(MARGIN + BOX_PADDING, info_y + 6, label)
-
-                draw_box(pdf, MARGIN + box_label_width, info_y, box_value_width, LINE_HEIGHT, fill_color=WHITE)
-                pdf.setFillColorRGB(*BLACK)
-                draw_centered_text(pdf, str(value), MARGIN + box_label_width, info_y + 6, box_value_width)
-
-                info_y -= 25
-
-            # Table headers
-            table_y = info_y - 30
-            headers = [
-                ("Description", 150),
-                ("Unité", 50),
-                ("NBRE", 50),
-                ("LNG/Qté", 60),
-                ("P.U", 60),
-                ("Total HT", 170)
-            ]
-
-            total_width = sum(width for _, width in headers)
-            table_x = (page_width - total_width) / 2  # Center table
-            draw_box(pdf, table_x, table_y, total_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-            pdf.setFillColorRGB(*WHITE)
-            # add little bit of space 
-            
-            
-            current_x = table_x 
-            for title, width in headers:
-                draw_box(pdf, current_x, table_y, width, LINE_HEIGHT)
-                pdf.setFillColorRGB(*WHITE)
-                draw_centered_text(pdf, title, current_x, table_y + 6, width)
-                current_x += width
-
-
-            # Draw sections and items
-            current_y = table_y - LINE_HEIGHT - 10
-
-
-
-            def draw_section_header2(title):
-                nonlocal current_y
-                draw_box(pdf, table_x, current_y, total_width, LINE_HEIGHT, fill_color=WHITE)
-                
-                # Set the font to a bold variant
-                pdf.setFont("Helvetica-Bold", 9)  # Adjust the font name and size as needed
-                
-                # Set the fill color to black
-                pdf.setFillColorRGB(*BLACK)  # RGB values for black
-                
-                # Draw the string
-                pdf.drawString(table_x + BOX_PADDING, current_y + 6, title)
-                
-                current_y -= LINE_HEIGHT
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-
-            def format_currency(value):
-                # Format with 2 decimal places and thousands separator
-                return "{:,.2f}".format(value).replace(",", " ")
-
-
-            def draw_item_row(item, indent=False):
-                nonlocal current_y
-                pdf.setFillColorRGB(*BLACK)
-                current_x = table_x
-
-                draw_box(pdf, current_x, current_y, total_width, LINE_HEIGHT, fill_color=WHITE)
-
-                cells = [
-                    ("    " + item.description if indent else item.description, 150),
-                    (item.unit, 50),
-                    (str(item.quantity), 50),
-                    (f"{item.length:.2f}", 60),
-                    (f"{format_currency(item.unit_price)}", 60),
-                    (f"{format_currency(item.total_price)} DH", 170)  # Total column
-                ]
-
-                for i, (value, width) in enumerate(cells):
-                    draw_box(pdf, current_x, current_y, width, LINE_HEIGHT)
-
-                    if i == len(cells) - 1:  # If it's the last column (Total DH)
-                        pdf.setFont("Helvetica-Bold", STANDARD_FONT_SIZE)  # Make it bold
-                    else:
-                        pdf.setFont("Helvetica", STANDARD_FONT_SIZE)  # Normal font
-
-                    if isinstance(value, str) and value.startswith("    "):
-                        pdf.drawString(current_x + 20, current_y + 6, value.strip())
-                    else:
-                        draw_centered_text(pdf, str(value), current_x, current_y + 6, width)
-
-                    current_x += width
-
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)  # Reset font to normal for next rows
-                current_y -= LINE_HEIGHT
-
-
-            # Draw sections
-            sections = [
-                ("POUTRELLES :", "PCP"),
-                ("HOURDIS :", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES :", "PTS"),
-                ("AGGLOS :", "AGGLOS")
-            ]
-
-            for section_title, keyword in sections:
-                print("-------------")
-                print(f"section_title: {section_title}")
-                draw_section_header2(section_title)
-                items = [i for i in data.items if keyword in i.description]
-                for item in items:
-                    draw_item_row(item, indent=(keyword != "lfflflflf"))
-
-            # NB box with text
-            nb_box_width = 200
-            nb_box_height = 80
-            pdf.setFillColorRGB(*BLACK)
-            pdf.rect(20, current_y - nb_box_height, nb_box_width, nb_box_height, stroke=1)
-            pdf.setFont("Helvetica-Bold", STANDARD_FONT_SIZE)
-            pdf.drawString(30, current_y - nb_box_height + 60, "NB:")
-            
-            # Add the new text
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-            nb_text = "Toute modification apportée aux plans BA initialement fournis, entraine automatiquement la modification de ce devis."
-            # Split text to fit in box
-            words = nb_text.split()
-            lines = []
-            current_line = []
-            
-            for word in words:
-                current_line.append(word)
-                # Check if current line width exceeds box width
-                if pdf.stringWidth(' '.join(current_line), "Helvetica", STANDARD_FONT_SIZE) > nb_box_width - 20:
-                    current_line.pop()  # Remove last word
-                    lines.append(' '.join(current_line))
-                    current_line = [word]
-            
-            if current_line:
-                lines.append(' '.join(current_line))
-            
-            # Draw each line
-            for i, line in enumerate(lines):
-                pdf.drawString(30, current_y - nb_box_height + 45 - (i * 10), line)
-
-            # ADD text after the NB box
-            pdf.setFont("Helvetica-Bold", 9)
-            pdf.drawString(30 , current_y - nb_box_height - 15, "Validité du devis : 1 mois")
-            
-            
-            # Totals section
-            # set font to bold
-            pdf.setFont("Helvetica-Bold", 12)
-            current_y -= 20
-            totals_table_width = 300
-            row_height = 20
-
-            for i, (label1, label2, value) in enumerate([
-                ("Total", "H.T", f"{format_currency(data.total_ht)} DH"),
-                ("TVA", "20 %", f"{format_currency(data.tax)} DH"),
-                ("Total", "TTC", f"{format_currency(data.total_ttc)} DH")
-            ]):
-                y = current_y - (i * row_height)
-                totals_x = (page_width - totals_table_width) - 27
-                draw_box(pdf, totals_x, y, totals_table_width / 2, row_height)
-                draw_box(pdf, totals_x + totals_table_width / 2, y, totals_table_width / 2, row_height)
-                pdf.drawString(totals_x + 10, y + 6, f"{label1}    {label2}")
-                pdf.drawRightString(totals_x + totals_table_width - 10, y + 6, value)
-
-            # Footer
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE - 3)
-            footer_text = "Douar Ait Laarassi Tidili, Cercle El Kelâa, Route de Safi, Km 14-40000 Marrakech"
-            pdf.drawCentredString(page_width / 2 + 20, 30, footer_text)
-
-            # add the commercial phone number
-            # i have salah with 0666666666 and khaled with 077777777 and ismale with 08888888 and jamal with 099999999
-            commercial_info = dict(
-                salah = "06 62 29 99 78",
-                khaled= "06 66 24 80 94",
-                ismail= "06 66 24 50 15",
-                jamal = "06 70 08 36 50"
-            )
-            # Add commercial info to footer
-            print(f"Commercial value: {data.commercial}")  # Add this debug line
-            if data.commercial and data.commercial.lower() != 'divers':
-                commercial_text = f"Commercial: {data.commercial.upper()}"
-                commercial_phone = f"Tél: {commercial_info.get(data.commercial.lower(), '')}"
-                
-                pdf.drawString(MARGIN + 10, 30, commercial_text)
-                #draw under the commercial text : 
-                pdf.drawString(MARGIN + 10, 20, commercial_phone)
-                footer_contact = "Tél: 05 24 01 55 54 Fax : 05 24 01 55 29 E-mail : compra45@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                ## add the time and page number
-
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y')}")
-                pdf.drawString(page_width - 100, 20, f"Page {pdf.getPageNumber()}/{pdf.getPageNumber()}")
-            else:
-                footer_contact = "Tél: 05 24 01 55 54 Fax : 05 24 01 55 29 E-mail : compra45@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime().now.strftime('%d/%m/%Y')}")
-                pdf.drawString(page_width - 100, 20, f"Page {pdf.getPageNumber()}/{pdf.getPageNumber()}")
-
-            pdf.save()
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in PDF generation: {str(e)}", exc_info=True)
-            raise

app/services/invoice_service.py

@@ -1,452 +0,0 @@
-from reportlab.lib.pagesizes import A4
-from reportlab.pdfgen import canvas
-from reportlab.lib import colors
-from reportlab.lib.units import cm
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-import re
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class InvoiceService:
-    @staticmethod
-    def generate_pdf(data: Invoice) -> bytes:
-        try:
-            buffer = BytesIO()
-            pdf = canvas.Canvas(buffer, pagesize=A4)
-            page_width, page_height = A4
-
-            # Constants
-            HEADER_BLUE = (0.29, 0.45, 0.68)
-            BLUE_LIGHT = (1.5, 1.5, 1)
-            WHITE = (1, 1, 1)
-            BLACK = (0, 0, 0)
-            MARGIN = 50
-            LINE_HEIGHT = 20
-            BOX_PADDING = 10
-            STANDARD_FONT_SIZE = 9
-            HEADER_FONT_SIZE = 24
-            SECTION_FONT_SIZE = 10
-            FOOTER_FONT_SIZE = 8
-            LINE_SPACING = 15
-            VERTICAL_PADDING = 5
-            BOTTOM_MARGIN = 50
-
-            # Helper function to draw centered text
-            def draw_centered_text(pdf, text, x, y, width, font="Times-Roman", size=STANDARD_FONT_SIZE):
-                text_width = pdf.stringWidth(text, font, size)
-                pdf.drawString(x + (width - text_width) / 2, y, text)
-
-            # Helper function to draw a bordered box
-            def draw_box(pdf, x, y, width, height, fill_color=None, stroke_color=BLACK):
-                if fill_color:
-                    pdf.setFillColorRGB(*fill_color)
-                    pdf.rect(x, y, width, height, fill=1, stroke=0)
-                pdf.setFillColorRGB(*stroke_color)
-                pdf.rect(x, y, width, height, stroke=1)
-
-            # Add this helper function after the existing helper functions
-            def draw_wrapped_text(pdf, text, x, y, width, font="Helvetica", size=STANDARD_FONT_SIZE):
-                """Draw text wrapped to fit within a given width."""
-                pdf.setFont(font, size)
-                words = text.split()
-                lines = []
-                current_line = []
-                
-                for word in words:
-                    current_line.append(word)
-                    line_width = pdf.stringWidth(' '.join(current_line), font, size)
-                    if line_width > width:
-                        current_line.pop()  # Remove last word
-                        if current_line:  # Only add if there are words
-                            lines.append(' '.join(current_line))
-                        current_line = [word]  # Start new line with the word that didn't fit
-                
-                if current_line:  # Add the last line
-                    lines.append(' '.join(current_line))
-                
-                return lines
-
-            # Get the absolute path to the logo file
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            logo_path = os.path.join(current_dir, "..", "static", "logo.png")
-
-            # Top section layout
-            top_margin = page_height - 120
-
-            # Left side: Logo - moved far left and up, with reduced size
-            if os.path.exists(logo_path):
-                pdf.drawImage(logo_path, MARGIN, top_margin - 10, width=80, height=80)  # Reduced from 100x100 to 80x80
-
-            # Right side: DEVIS and Client Box - moved more to the left
-            pdf.setFont("Helvetica-Bold", HEADER_FONT_SIZE)
-            devis_text = "DEVIS"
-            devis_width = pdf.stringWidth(devis_text, "Helvetica-Bold", HEADER_FONT_SIZE)
-            devis_x = page_width - devis_width - MARGIN - 50  # Consistent right margin
-            devis_y = top_margin + 30
-            pdf.drawString(devis_x, devis_y, devis_text)
-
-            # Client info box - aligned with DEVIS text
-            box_width = 150
-            box_x = page_width - box_width - MARGIN - 10  # Align with right margin
-            box_y = devis_y - 80
-
-            # Client Info
-            pdf.setFont("Helvetica-Bold", 10)
-            client_info = [
-                data.client_name,
-                (f"{data.phone1}" + (f" / {data.phone2}" if data.phone2 else "")),
-                data.address
-            ]
-
-            # Calculate required height based on content
-            total_lines = 0
-            for text in client_info:
-                if text:
-                    lines = draw_wrapped_text(pdf, text, devis_x, 10, box_width - (BOX_PADDING * 2), font="Helvetica-Bold", size=10)
-                    total_lines += len(lines)
-
-            # Calculate box height based on content
-            box_height = (total_lines * LINE_SPACING) + (VERTICAL_PADDING)
-
-            # Draw client box
-            pdf.rect(box_x, box_y, box_width, box_height, stroke=1)
-
-            # Draw client info inside the box - start from top
-            y_position = box_y + box_height - 10  # Reduced top padding
-            for text in client_info:
-                if text:
-                    lines = draw_wrapped_text(pdf, text, box_x, y_position, box_width - (BOX_PADDING * 2) + 8, font="Helvetica-Bold", size=10)
-                    for line in lines:
-                        text_width = pdf.stringWidth(line, "Helvetica-Bold", 10)
-                        x_centered = box_x + (box_width - text_width) / 2
-                        pdf.drawString(x_centered, y_position, line)
-                        y_position -= LINE_SPACING
-
-            # Info boxes (Date, N° Devis, PLANCHER) - adjusted position and size
-            info_y = top_margin - 70
-            box_label_width = 77
-            box_value_width = 100
-            box_height = 15
-
-            for label, value in [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]:
-                # Set dashed line style with thicker lines
-                pdf.setLineWidth(1.5)  # Increased line thickness
-                pdf.setDash(3, 2)  # Longer dash (3 points) with smaller space (2 points)
-                
-                # Draw boxes with dashed borders
-                draw_box(pdf, MARGIN, info_y, box_label_width, box_height, fill_color=HEADER_BLUE)
-                draw_box(pdf, MARGIN + box_label_width, info_y, box_value_width, box_height, fill_color=WHITE)
-                
-                # Reset line style
-                pdf.setLineWidth(1)  # Reset line width
-                pdf.setDash(1, 0)  # Reset to solid line
-                
-                # Draw text
-                pdf.setFillColorRGB(*WHITE)
-                pdf.setFont("Helvetica-Bold", 9)
-                pdf.drawString(MARGIN + BOX_PADDING - 2, info_y + 4, label)
-
-                pdf.setFillColorRGB(*BLACK)
-                value_str = str(value)
-                if len(value_str) > 20:
-                    pdf.setFont("Helvetica-Bold", 9)
-                    lines = draw_wrapped_text(pdf, value_str, MARGIN + box_label_width, info_y + 4, box_value_width - 10)
-                    for i, line in enumerate(lines):
-                        draw_centered_text(pdf, line, MARGIN + box_label_width, info_y + 4 - (i * 8), box_value_width)
-                else:
-                    pdf.setFont("Helvetica-Bold", 9)
-                    draw_centered_text(pdf, value_str, MARGIN + box_label_width, info_y + 4, box_value_width)
-
-                info_y -= 20
-
-            # Table headers - adjust table width and position
-            table_y = info_y - 10
-            headers = [
-                ("Description", 180),
-                ("Unité", 40),
-                ("NBRE", 40),
-                ("ML/Qté", 50),
-                ("P.U", 50),
-                ("Total HT", 130)
-            ]
-
-            total_width = sum(width for _, width in headers)
-            table_x = (page_width - total_width) / 2  # Center table
-            
-            # Draw the filled background for the entire header
-            draw_box(pdf, table_x, table_y, total_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-            
-            # Draw outer border only
-            pdf.setFillColorRGB(*WHITE)
-            pdf.rect(table_x, table_y, total_width, LINE_HEIGHT, stroke=1)
-
-            # Draw header text
-            current_x = table_x
-            for title, width in headers:
-                draw_centered_text(pdf, title, current_x, table_y + 6, width, font="Helvetica-Bold", size=10)
-                current_x += width
-
-            # Start sections immediately after headers
-            current_y = table_y - LINE_HEIGHT + 12  # Reduced gap between headers and first section
-
-
-            def draw_section_header2(title):
-                nonlocal current_y
-                section_start_y = current_y
-                current_y -= 20  # Space before the title
-                pdf.setFont("Helvetica-Bold", SECTION_FONT_SIZE)
-                pdf.setFillColorRGB(*BLACK)
-                pdf.drawString(table_x + BOX_PADDING, current_y + 6, title)
-                current_y -= LINE_HEIGHT - 3  # Increased space between title and items (was LINE_HEIGHT - 12)
-                pdf.setFont("Times-Roman", STANDARD_FONT_SIZE)
-                return section_start_y
-
-
-            def format_currency(value):
-                return "{:,.2f}".format(value).replace(",", " ")
-
-            def format_number(value, section_type=None, is_length=False):
-                """Format numbers based on section type"""
-                # For poutrelles, keep decimals for length
-                if section_type == "POUTRELLES" and is_length:
-                    return f"{value:.2f}"
-                
-                # For other sections or non-length values
-                if isinstance(value, int) or (isinstance(value, float) and value.is_integer()):
-                    return str(int(value))
-                return str(int(value)) if value.is_integer() else f"{value:.0f}"
-
-            def draw_item_row(item, indent=False, is_last_item=False, section_type=None):
-                nonlocal current_y
-                row_values = [
-                    str(item.description),
-                    str(item.unit),
-                    format_number(item.quantity, section_type),
-                    format_number(item.length, section_type, is_length=True),
-                    f"{item.unit_price:.2f}",
-                    f"{item.total_price:.2f}"
-                ]
-                
-                # Calculate positions for perfect alignment
-                positions = [
-                    table_x + (20 if indent else 0),  # Description
-                    table_x + headers[0][1],  # Unité
-                    table_x + sum(width for _, width in headers[:2]),  # NBRE
-                    table_x + sum(width for _, width in headers[:3]),  # ML/Qté
-                    table_x + sum(width for _, width in headers[:4]),  # P.U
-                    table_x + sum(width for _, width in headers[:5])   # Total HT
-                ]
-                
-                pdf.setFont("Helvetica", 9)
-
-
-                for idx, value in enumerate(row_values):
-                    if idx == 0:
-                        indeent_amount = 30
-                        # Left align description
-                        pdf.drawString(positions[idx] + BOX_PADDING + indeent_amount, current_y + 6, value)
-                    else:
-                        # Center align other columns
-                        text_width = pdf.stringWidth(value, "Helvetica", 9)
-                        x_pos = positions[idx] + (headers[idx][1] - text_width) / 2
-                        pdf.drawString(x_pos, current_y + 6, value)
-                
-                if not is_last_item:
-                    current_y -= (LINE_HEIGHT - 8)
-                else:
-                    current_y -= (LINE_HEIGHT - 20)
-                
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-
-            # Draw sections
-            sections = [
-                ("POUTRELLES", "PCP"),
-                ("HOURDIS", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES", "PTS"),
-                ("AGGLOS", "AGGLOS")
-            ]
-            
-            def get_description_number(description: str) -> float:
-                try:
-                    numbers = re.findall(r'\d+\.?\d*', description)
-                    return float(numbers[0]) if numbers else 0
-                except:
-                    return 0
-
-            # Sort items based on section type and description number
-            def custom_sort_key(item):
-                description = item.description.upper()
-                # For poutrelles, prioritize items with 'N'
-                if 'POUTRELLE' in description or 'PCP' in description:
-                    has_n = 'N' in description
-                    # Get the number from the description
-                    numbers = re.findall(r'\d+', description)
-                    number = float(numbers[0]) if numbers else 0
-                    # Items with 'N' come first, then sort by number
-                    return (not has_n, number)
-                # For other items, use the existing logic
-                return (True, get_description_number(description))
-
-            # Modify the section items handling
-            for section_title, keyword in sections:
-                items = [i for i in data.items if keyword in i.description]
-                if items:
-                    # Sort the items using the custom sort key
-                    if section_title == 'POUTRELLES':
-                        items.sort(key=custom_sort_key)
-                    else:
-                        items.sort(key=lambda x: get_description_number(x.description))
-                    
-                    grouped_items = {}
-                    for item in items:
-                        key = (item.description, item.length)
-                        if key not in grouped_items:
-                            grouped_items[key] = item
-                        else:
-                            existing = grouped_items[key]
-                            existing.quantity += item.quantity
-                            existing.total_price = existing.quantity * existing.length * existing.unit_price
-
-                    # Draw section header and save starting position
-                    section_start_y = draw_section_header2(section_title)
-                    
-                    # Get list of items
-                    items_list = list(grouped_items.values())
-                    
-                    # Draw all items in the section
-                    for i, item in enumerate(items_list):
-                        is_last = i == len(items_list) - 1  # Check if this is the last item
-                        draw_item_row(item, indent=(keyword != "lfflflflf"), is_last_item=is_last, section_type=section_title)
-                    
-                    # Draw box around the entire section
-                    section_height = section_start_y - current_y
-                    pdf.setStrokeColorRGB(*BLACK)
-                    pdf.rect(table_x, current_y, total_width, section_height, stroke=1)
-
-            # Common y-position for both NB and totals
-            current_y -= 20
-
-            # NB box adjustments
-            nb_box_width = total_width * 0.35 + 40 # the width right of the box adjust by add
-            nb_box_height = 45
-            nb_box_x = table_x
-
-            # Set dashed line style with thicker lines
-            pdf.setLineWidth(1.5)  # Increased line thickness
-            pdf.setDash(3, 2)  # Longer dash (3 points) with smaller space (2 points)
-            
-            pdf.setFillColorRGB(*BLACK)
-            pdf.rect(nb_box_x, current_y - nb_box_height, nb_box_width, nb_box_height, stroke=1)
-            
-            # Reset line style
-            pdf.setLineWidth(1)  # Reset line width
-            pdf.setDash(1, 0)  # Reset to solid line
-            
-            y_offset = current_y - nb_box_height + 35
-            
-            # Draw "NB:" in bold with underline
-            nb_text = "NB:"
-            pdf.setFont("Helvetica-Bold", STANDARD_FONT_SIZE)
-            pdf.drawString(nb_box_x + 10, y_offset, nb_text)
-            
-            # Add underline
-            text_width = pdf.stringWidth(nb_text, "Helvetica-Bold", STANDARD_FONT_SIZE)
-            pdf.line(nb_box_x + 10, y_offset - 2, nb_box_x + 10 + text_width, y_offset - 2)
-            
-            # Draw the rest of the text in normal font
-            pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-            remaining_text = """Toute modification apportée aux plans BA
-initialement fournis, entraîne automatiquement
-la modification de ce devis."""
-            
-            # Draw each line after "NB:"
-            for i, line in enumerate(remaining_text.split('\n')):
-                if i == 0:
-                    pdf.drawString(nb_box_x + 30, y_offset, line)
-                else:
-                    pdf.drawString(nb_box_x + 10, y_offset - (i * 12), line)
-
-            # ADD text after the NB box with reduced spacing
-            pdf.setFont("Helvetica-Bold", 9)
-            pdf.drawString(nb_box_x + 10, current_y - nb_box_height - 12, "Validité du devis : 1 mois")
-
-            # Totals section adjustments
-            totals_table_width = total_width * 0.4
-            totals_x = table_x + total_width - totals_table_width
-            row_height = 12
-            left_box_width = totals_table_width * 0.4
-            right_box_width = totals_table_width * 0.6
-
-            for i, (label1, label2, value) in enumerate([
-                ("Total", "H.T", f"{format_currency(data.total_ht)} DH"),
-                ("TVA", "20%", f"{format_currency(data.tax)} DH"),
-                ("Total", "TTC", f"{format_currency(data.total_ttc)} DH")
-            ]):
-                y = current_y - (i * (row_height + 5)) - 12
-
-                # Draw the left box
-                draw_box(pdf, totals_x, y, left_box_width, row_height)
-                
-                # Draw the right box
-                draw_box(pdf, totals_x + left_box_width, y, right_box_width, row_height)
-
-                # Draw left-aligned labels in the left box with smaller font
-                pdf.setFont("Helvetica-Bold", 9)
-                # Center text vertically by adding half of (row_height - font_size)
-                vertical_center = y + (row_height - 9) / 2
-                pdf.drawString(totals_x + 8, vertical_center, f"{label1}    {label2}")
-
-                # Draw centered value in the right box with same bold font
-                value_width = pdf.stringWidth(value, "Helvetica-Bold", 9)
-                value_x = totals_x + left_box_width + (right_box_width - value_width) / 2
-                pdf.drawString(value_x, vertical_center, value)
-
-            # Footer
-            ## add the first line text
-            pdf.setFont("Helvetica", 8)  # Changed from Times-Roman to Helvetica
-            
-            footer_text = "CARRIPREFA"
-            pdf.drawCentredString(page_width / 2, 40, footer_text)
-            
-            footer_text = "Douar Ait Toumart Habil, Cercle El Bour, Route de Safi, Km 14 -40000 Marrakech"
-            pdf.drawCentredString(page_width / 2 + 20, 30, footer_text)
-
-            # Add commercial info to footer
-            commercial_info = dict(
-                salah="06 62 29 99 78",
-                khaled="06 66 24 80 94",
-                ismail="06 66 24 50 15",
-                jamal="06 70 08 36 50"
-            )
-
-            if data.commercial and data.commercial.lower() != 'divers':
-                commercial_text = f"Commercial: {data.commercial.upper()}"
-                commercial_phone = f"Tél: {commercial_info.get(data.commercial.lower(), '')}"
-                pdf.drawString(MARGIN + 10, 30, commercial_text)
-                pdf.drawString(MARGIN + 10, 20, commercial_phone)
-                footer_contact = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}")
-                pdf.drawString(page_width - 100, 20, f"Page 1/2")
-            else:
-                footer_contact = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}")
-                pdf.drawString(page_width - 100, 20, f"Page 1/2")
-
-            pdf.save()
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in PDF generation: {str(e)}", exc_info=True)
-            raise

app/services/invoice_service_page2.py

@@ -1,350 +0,0 @@
-from reportlab.lib.pagesizes import A4
-from reportlab.pdfgen import canvas
-from reportlab.lib import colors
-from reportlab.lib.units import cm
-from io import BytesIO
-from app.db.models import Invoice
-import logging
-import os
-import datetime
-import re
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-class InvoiceServicePage2:
-    @staticmethod
-    def generate_pdf(data: Invoice) -> bytes:
-        try:
-            buffer = BytesIO()
-            pdf = canvas.Canvas(buffer, pagesize=A4)
-            page_width, page_height = A4
-
-            # Constants
-            HEADER_BLUE = (0.29, 0.45, 0.68)
-            BLUE_LIGHT = (1.5, 1.5, 1)
-            WHITE = (1, 1, 1)
-            BLACK = (0, 0, 0)
-            MARGIN = 50
-            LINE_HEIGHT = 20
-            BOX_PADDING = 10
-            STANDARD_FONT_SIZE = 9
-            HEADER_FONT_SIZE = 24
-            SECTION_FONT_SIZE = 10
-            FOOTER_FONT_SIZE = 8
-            LINE_SPACING = 15
-            VERTICAL_PADDING = 5
-            BOTTOM_MARGIN = 50
-
-            # Helper functions (same as original)
-            def draw_centered_text(pdf, text, x, y, width, font="Helvetica", size=STANDARD_FONT_SIZE):
-                text_width = pdf.stringWidth(text, font, size)
-                pdf.drawString(x + (width - text_width) / 2, y, text)
-
-            def draw_box(pdf, x, y, width, height, fill_color=None, stroke_color=BLACK):
-                if fill_color:
-                    pdf.setFillColorRGB(*fill_color)
-                    pdf.rect(x, y, width, height, fill=1, stroke=0)
-                pdf.setFillColorRGB(*stroke_color)
-                pdf.rect(x, y, width, height, stroke=1)
-
-            def draw_wrapped_text(pdf, text, x, y, width, font="Helvetica", size=STANDARD_FONT_SIZE):
-                pdf.setFont(font, size)
-                words = text.split()
-                lines = []
-                current_line = []
-                
-                for word in words:
-                    current_line.append(word)
-                    line_width = pdf.stringWidth(' '.join(current_line), font, size)
-                    if line_width > width:
-                        current_line.pop()
-                        if current_line:
-                            lines.append(' '.join(current_line))
-                        current_line = [word]
-                
-                if current_line:
-                    lines.append(' '.join(current_line))
-                
-                return lines
-
-            # Get the absolute path to the logo file
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            logo_path = os.path.join(current_dir, "..", "static", "logo.png")
-
-            # Top section layout
-            top_margin = page_height - 120
-
-            # Left side: Logo - maintain left margin
-            if os.path.exists(logo_path):
-                pdf.drawImage(logo_path, MARGIN, top_margin - 10, width=80, height=80)
-
-            # Right side: DEVIS and Client Box - maintain right margin
-            pdf.setFont("Helvetica-Bold", HEADER_FONT_SIZE)
-            devis_text = """DEVIS LIVRAISON"""
-            devis_width = pdf.stringWidth(devis_text, "Helvetica-Bold", HEADER_FONT_SIZE)
-            devis_x = page_width - devis_width - MARGIN + 10  # Consistent right margin
-            devis_y = top_margin + 50
-            pdf.drawString(devis_x, devis_y, devis_text)
-
-            # Client info box - aligned with DEVIS text
-            box_width = 150
-            box_x = page_width - box_width - MARGIN - 10  # Align with right margin
-            box_y = devis_y - 80
-
-            # Client Info
-            pdf.setFont("Helvetica-Bold", 10)
-            client_info = [
-                data.client_name,
-                (f"{data.phone1}" + (f" / {data.phone2}" if data.phone2 else "")),
-                data.address
-            ]
-
-            # Calculate required height based on content
-            total_lines = 0
-            for text in client_info:
-                if text:
-                    lines = draw_wrapped_text(pdf, text, devis_x, 0, box_width - (BOX_PADDING * 2), font="Helvetica-Bold", size=10)
-                    total_lines += len(lines)
-
-            # Calculate box height based on content
-            box_height = (total_lines * LINE_SPACING) + (VERTICAL_PADDING * 2)
-
-            # Draw client box
-            pdf.rect(box_x, box_y, box_width, box_height, stroke=1)
-
-            # Draw client info inside the box - start from top
-            y_position = box_y + box_height - 10  # Reduced top padding
-            for text in client_info:
-                if text:
-                    lines = draw_wrapped_text(pdf, text, box_x, y_position, box_width - (BOX_PADDING * 2) + 8, font="Helvetica-Bold", size=10)
-                    for line in lines:
-                        text_width = pdf.stringWidth(line, "Helvetica-Bold", 10)
-                        x_centered = box_x + (box_width - text_width) / 2
-                        pdf.drawString(x_centered, y_position, line)
-                        y_position -= LINE_SPACING
-
-
-            # Info boxes (Date, N° Devis, PLANCHER) - maintain left margin
-            info_y = top_margin - 80
-            box_label_width = 70
-            box_value_width = 100
-            box_height = 15
-
-            for label, value in [
-                ("Date du devis :", data.date.strftime("%d/%m/%Y")),
-                ("N° Devis :", data.invoice_number),
-                ("PLANCHER :", data.frame_number or "PH RDC")
-            ]:
-                # Set dashed line style with thicker lines
-                pdf.setLineWidth(1.5)
-                pdf.setDash(3, 2)
-                
-                # Draw boxes with dashed borders
-                draw_box(pdf, MARGIN, info_y, box_label_width, box_height, fill_color=HEADER_BLUE)
-                draw_box(pdf, MARGIN + box_label_width, info_y, box_value_width, box_height, fill_color=WHITE)
-                
-                # Reset line style
-                pdf.setLineWidth(1)
-                pdf.setDash(1, 0)
-                
-                # Draw text
-                pdf.setFillColorRGB(*WHITE)
-                pdf.setFont("Helvetica-Bold", 9)
-                pdf.drawString(MARGIN + BOX_PADDING - 2, info_y + 4, label)
-
-                pdf.setFillColorRGB(*BLACK)
-                value_str = str(value)
-                if len(value_str) > 20:
-                    pdf.setFont("Helvetica-Bold", 9)
-                    lines = draw_wrapped_text(pdf, value_str, MARGIN + box_label_width, info_y + 4, box_value_width - 10)
-                    for i, line in enumerate(lines):
-                        draw_centered_text(pdf, line, MARGIN + box_label_width, info_y + 4 - (i * 8), box_value_width)
-                else:
-                    pdf.setFont("Helvetica-Bold", 9)
-                    draw_centered_text(pdf, value_str, MARGIN + box_label_width, info_y + 4, box_value_width)
-
-                info_y -= 20
-
-            # Table headers - align with info boxes and client box
-            headers = [
-                ("Description", 250),  # Increased width for better spacing
-                ("Unité", 80),        # Standardized width
-                ("NBRE", 80),         # Standardized width
-                ("ML/Qté", 80),       # Standardized width
-            ]
-
-            total_width = sum(width for _, width in headers)
-            table_x = MARGIN
-            table_y = info_y - 10
-
-            # Draw header background and border
-            draw_box(pdf, table_x, table_y, total_width, LINE_HEIGHT, fill_color=HEADER_BLUE)
-            pdf.setFillColorRGB(*WHITE)
-            pdf.rect(table_x, table_y, total_width, LINE_HEIGHT, stroke=1)
-
-            # Draw header text with consistent spacing
-            current_x = table_x
-            for title, width in headers:
-                draw_centered_text(pdf, title, current_x, table_y + 6, width, font="Helvetica-Bold", size=10)
-                # Draw vertical separator lines between headers
-                if current_x > table_x:
-                    pdf.line(current_x, table_y, current_x, table_y + LINE_HEIGHT)
-                current_x += width
-
-            # Start sections immediately after headers
-            current_y = table_y - LINE_HEIGHT + 12
-
-            def draw_section_header2(title):
-                nonlocal current_y
-                section_start_y = current_y
-                current_y -= 20  # Space before the title
-                pdf.setFont("Helvetica-Bold", SECTION_FONT_SIZE)
-                pdf.setFillColorRGB(*BLACK)
-                pdf.drawString(table_x + BOX_PADDING, current_y + 6, title)
-                current_y -= LINE_HEIGHT - 3  # Increased space between title and items (was LINE_HEIGHT - 12)
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-                return section_start_y
-
-            def format_number(value, section_type=None):
-                """Format numbers based on section type"""
-                if section_type in ["HOURDIS", "AGGLOS", "PANNEAU TREILLIS SOUDES"]:
-                    if isinstance(value, (int, float)) and value % 1 == 0:
-                        return str(int(value))
-                return f"{value:.2f}"
-
-            def draw_item_row(item, indent=False, is_last_item=False, section_type=None):
-                nonlocal current_y
-                row_values = [
-                    str(item.description),
-                    str(item.unit),
-                    format_number(item.quantity, section_type),
-                    f"{item.length:.2f}",
-                ]
-                
-                # Calculate positions for perfect alignment
-                positions = [
-                    table_x + (20 if indent else 0),
-                    table_x + headers[0][1],
-                    table_x + headers[0][1] + headers[1][1],
-                    table_x + headers[0][1] + headers[1][1] + headers[2][1]
-                ]
-                
-                pdf.setFont("Helvetica", 9)
-                
-                for idx, value in enumerate(row_values):
-                    if idx == 0:
-                        indeent_amount = 30
-                        # Left align description
-                        pdf.drawString(positions[idx] + BOX_PADDING + indeent_amount, current_y + 6, value)
-                    else:
-                        # Center align other columns
-                        text_width = pdf.stringWidth(value, "Helvetica", 9)
-                        x_pos = positions[idx] + (headers[idx][1] - text_width) / 2
-                        pdf.drawString(x_pos, current_y + 6, value)
-                
-                if not is_last_item:
-                    current_y -= (LINE_HEIGHT - 8)
-                else:
-                    current_y -= (LINE_HEIGHT - 20)
-                
-                pdf.setFont("Helvetica", STANDARD_FONT_SIZE)
-
-            # Draw sections
-            sections = [
-                ("POUTRELLES", "PCP"),
-                ("HOURDIS", "HOURDIS"),
-                ("PANNEAU TREILLIS SOUDES", "PTS"),
-                ("AGGLOS", "AGGLOS")
-            ]
-
-            def get_description_number(description: str) -> float:
-                try:
-                    numbers = re.findall(r'\d+\.?\d*', description)
-                    return float(numbers[0]) if numbers else 0
-                except:
-                    return 0
-
-            def custom_sort_key(item):
-                description = item.description.upper()
-                # For poutrelles, prioritize items with 'N'
-                if 'POUTRELLE' in description or 'PCP' in description:
-                    has_n = 'N' in description
-                    # Get the number from the description
-                    numbers = re.findall(r'\d+', description)
-                    number = float(numbers[0]) if numbers else 0
-                    # Items with 'N' come first, then sort by number
-                    return (not has_n, number)
-                # For other items, use the existing logic
-                return (True, get_description_number(description))
-
-            # Draw sections and items
-            for section_title, keyword in sections:
-                items = [i for i in data.items if keyword in i.description]
-                if items:
-                    # Sort the items using the custom sort key
-                    if section_title == 'POUTRELLES':
-                        items.sort(key=custom_sort_key)
-                    else:
-                        items.sort(key=lambda x: get_description_number(x.description))
-                    
-                    grouped_items = {}
-                    for item in items:
-                        key = (item.description, item.length)
-                        if key not in grouped_items:
-                            grouped_items[key] = item
-                        else:
-                            existing = grouped_items[key]
-                            existing.quantity += item.quantity
-
-                    section_start_y = draw_section_header2(section_title)
-                    items_list = list(grouped_items.values())
-                    
-                    for i, item in enumerate(items_list):
-                        is_last = i == len(items_list) - 1
-                        draw_item_row(item, indent=(keyword != "lfflflflf"), is_last_item=is_last, section_type=section_title)
-                    
-                    section_height = section_start_y - current_y
-                    pdf.setStrokeColorRGB(*BLACK)
-                    pdf.rect(table_x, current_y, total_width, section_height, stroke=1)
-
-            # Footer
-            pdf.setFont("Helvetica", FOOTER_FONT_SIZE)
-            
-            footer_text = "CARRIPREFA"
-            pdf.drawCentredString(page_width / 2, 40, footer_text)
-            
-            pdf.setFont("Helvetica", FOOTER_FONT_SIZE)
-            footer_text = "Douar Ait Toumart Habil, Cercle El Bour, Route de Safi, Km 14 -40000 Marrakech"
-            pdf.drawCentredString(page_width / 2 + 20, 30, footer_text)
-
-            # Add commercial info to footer
-            commercial_info = dict(
-                salah="06 62 29 99 78",
-                khaled="06 66 24 80 94",
-                ismail="06 66 24 50 15",
-                jamal="06 70 08 36 50"
-            )
-
-            if data.commercial and data.commercial.lower() != 'divers':
-                commercial_text = f"Commercial: {data.commercial.upper()}"
-                commercial_phone = f"Tél: {commercial_info.get(data.commercial.lower(), '')}"
-                pdf.drawString(MARGIN + 10, 30, commercial_text)
-                pdf.drawString(MARGIN + 10, 20, commercial_phone)
-                footer_contact = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}")
-                pdf.drawString(page_width - 100, 20, f"Page 1/2")
-            else:
-                footer_contact = "Tél: 05 24 01 33 34 Fax : 05 24 01 33 29 E-mail : carriprefa@gmail.com"
-                pdf.drawCentredString(page_width / 2 + 10, 20, footer_contact)
-                pdf.drawString(page_width - 100, 30, f"Date: {datetime.datetime.now().strftime('%d/%m/%Y %H:%M')}")
-                pdf.drawString(page_width - 100, 20, f"Page 1/2")
-
-            pdf.save()
-            buffer.seek(0)
-            return buffer.getvalue()
-
-        except Exception as e:
-            logger.error(f"Error in PDF generation: {str(e)}", exc_info=True)
-            raise

app/templates/history.html

@@ -1,192 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Historique des Devis</title>
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
-</head>
-<body class="bg-light">
-    <header class="bg-primary py-4 mb-4 shadow-sm">
-        <div class="container">
-            <div class="row align-items-center">
-                <div class="col-md-6">
-                    <h1 class="text-white mb-0">Historique des Devis</h1>
-                </div>
-                <div class="col-md-6 text-end">
-                    <a href="/" class="btn btn-light me-2">
-                        <i class="fas fa-plus"></i> Nouveau Devis
-                    </a>
-                </div>
-            </div>
-        </div>
-    </header>
-
-    <div class="container">
-        <div class="card shadow-sm">
-            <div class="card-header bg-white py-3">
-                <div class="row align-items-center">
-                    <div class="col-md-4">
-                        <input type="text" id="searchInput" class="form-control" placeholder="Rechercher par client, projet ou N° devis...">
-                    </div>
-                    <div class="col-md-3">
-                        <select id="statusFilter" class="form-select">
-                            <option value="">Tous les statuts</option>
-                            <option value="pending">En attente</option>
-                            <option value="completed">Complété</option>
-                        </select>
-                    </div>
-                </div>
-            </div>
-            <div class="card-body">
-                <div class="table-responsive">
-                    <table class="table table-hover">
-                        <thead class="table-primary">
-                            <tr>
-                                <th>N° Devis</th>
-                                <th>Date</th>
-                                <th>Client</th>
-                                <th>Projet</th>
-                                <th>Total TTC</th>
-                                <th>Status</th>
-                                <th>Actions</th>
-                            </tr>
-                        </thead>
-                        <tbody id="invoicesTableBody"></tbody>
-                    </table>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
-    <script>
-        document.addEventListener('DOMContentLoaded', async () => {
-            const tableBody = document.getElementById('invoicesTableBody');
-            const searchInput = document.getElementById('searchInput');
-            const statusFilter = document.getElementById('statusFilter');
-
-            async function loadInvoices() {
-                try {
-                    const response = await fetch('/api/invoices/');
-                    if (!response.ok) throw new Error('Failed to load invoices');
-                    return await response.json();
-                } catch (error) {
-                    console.error('Error:', error);
-                    return [];
-                }
-            }
-
-            function formatDate(dateString) {
-                return new Date(dateString).toLocaleDateString('fr-FR');
-            }
-
-            function formatCurrency(amount) {
-                return new Intl.NumberFormat('fr-FR', {
-                    style: 'currency',
-                    currency: 'MAD',
-                    minimumFractionDigits: 2
-                }).format(amount);
-            }
-
-            function renderInvoices(invoices) {
-                const searchTerm = searchInput.value.toLowerCase();
-                const statusValue = statusFilter.value;
-
-                const filteredInvoices = invoices.filter(invoice => {
-                    const matchesSearch = (
-                        invoice.invoice_number.toLowerCase().includes(searchTerm) ||
-                        invoice.client_name.toLowerCase().includes(searchTerm) ||
-                        invoice.project.toLowerCase().includes(searchTerm)
-                    );
-                    const matchesStatus = !statusValue || invoice.status === statusValue;
-                    return matchesSearch && matchesStatus;
-                });
-
-                tableBody.innerHTML = filteredInvoices.map(invoice => `
-                    <tr>
-                        <td class="fw-bold">${invoice.invoice_number}</td>
-                        <td>${formatDate(invoice.date)}</td>
-                        <td>${invoice.client_name}</td>
-                        <td>${invoice.project}</td>
-                        <td class="fw-bold">${formatCurrency(invoice.total_ttc)}</td>
-                        <td>
-                            <span class="badge ${invoice.status === 'pending' ? 'bg-warning' : 'bg-success'}">
-                                ${invoice.status === 'pending' ? 'En attente' : 'Complété'}
-                            </span>
-                        </td>
-                        <td>
-                            <div class="btn-group">
-                                <button onclick="editInvoice(${invoice.id})" class="btn btn-sm btn-warning" title="Modifier">
-                                    <i class="fas fa-edit"></i>
-                                </button>
-                                <button onclick="previewPDF(${invoice.id})" class="btn btn-sm btn-primary" title="Aperçu">
-                                    <i class="fas fa-eye"></i>
-                                </button>
-                                <button onclick="downloadPDF(${invoice.id})" class="btn btn-sm btn-success" title="Télécharger">
-                                    <i class="fas fa-download"></i>
-                                </button>
-                                <button onclick="duplicateInvoice(${invoice.id})" class="btn btn-sm btn-info" title="Dupliquer">
-                                    <i class="fas fa-copy"></i>
-                                </button>
-                            </div>
-                        </td>
-                    </tr>
-                `).join('');
-            }
-
-            // Load initial data
-            const invoices = await loadInvoices();
-            renderInvoices(invoices);
-
-            // Set up event listeners
-            searchInput.addEventListener('input', () => renderInvoices(invoices));
-            statusFilter.addEventListener('change', () => renderInvoices(invoices));
-
-            // Global functions for actions
-            window.editInvoice = (id) => {
-                window.location.href = `/?edit=${id}`;
-            };
-
-            window.previewPDF = async (id) => {
-                const response = await fetch(`/api/invoices/${id}/generate-pdf`, {
-                    method: 'POST'
-                });
-                const blob = await response.blob();
-                const url = URL.createObjectURL(blob);
-                window.open(url, '_blank');
-            };
-
-            window.downloadPDF = async (id) => {
-                const response = await fetch(`/api/invoices/${id}/generate-pdf`, {
-                    method: 'POST'
-                });
-                const blob = await response.blob();
-                const url = URL.createObjectURL(blob);
-                const a = document.createElement('a');
-                a.href = url;
-                a.download = `devis_${id}.pdf`;
-                document.body.appendChild(a);
-                a.click();
-                document.body.removeChild(a);
-                URL.revokeObjectURL(url);
-            };
-
-            window.duplicateInvoice = async (id) => {
-                try {
-                    const response = await fetch(`/api/invoices/${id}/duplicate`, {
-                        method: 'POST'
-                    });
-                    if (!response.ok) throw new Error('Failed to duplicate invoice');
-                    const newInvoice = await response.json();
-                    window.location.href = `/?edit=${newInvoice.id}`;
-                } catch (error) {
-                    console.error('Error:', error);
-                    alert('Failed to duplicate invoice');
-                }
-            };
-        });
-    </script>
-</body>
-</html>