Update app.py

app.py

@@ -5,6 +5,8 @@ from pydantic import BaseModel
 from weasyprint import HTML, CSS
 from io import BytesIO
 import base64
+from typing import Optional, List, Dict, Any
+from html import escape
 
 app = FastAPI()
 
@@ -22,6 +24,475 @@ class PDFRequest(BaseModel):
     css: str = ""
     orientation: str = "portrait"  # portrait or landscape
 
+# Modelos para a nova API baseada em JSON
+class Element(BaseModel):
+    id: str
+    type: str  # a4, column, row, container, text, image, line, spacer, table
+    children: Optional[List[str]] = None
+    parentId: Optional[str] = None
+    
+    # Propriedades comuns
+    padding: Optional[str] = None
+    width: Optional[str] = None
+    height: Optional[str] = None
+    backgroundColor: Optional[str] = None
+    backgroundImage: Optional[str] = None
+    backgroundImageBoxFit: Optional[str] = None
+    borderRadius: Optional[str] = None
+    alignment: Optional[str] = None
+    horizontalAlignment: Optional[str] = None
+    gap: Optional[str] = None
+    
+    # Propriedades específicas de cada tipo
+    content: Optional[str] = None  # text
+    color: Optional[str] = None  # text
+    fontFamily: Optional[str] = None  # text
+    fontSize: Optional[str] = None  # text
+    fontWeight: Optional[str] = None  # text
+    textAlign: Optional[str] = None  # text
+    lineHeight: Optional[str] = None  # text
+    wordSpacing: Optional[str] = None  # text
+    letterSpacing: Optional[str] = None  # text
+    fontStyle: Optional[str] = None  # text
+    textDecoration: Optional[str] = None  # text
+    textPadding: Optional[str] = None  # text
+    maxLines: Optional[int] = None  # text
+    
+    src: Optional[str] = None  # image
+    imageBoxFit: Optional[str] = None  # image
+    opacity: Optional[float] = None  # image
+    
+    direction: Optional[str] = None  # line (horizontal/vertical)
+    thickness: Optional[str] = None  # line
+    lineColor: Optional[str] = None  # line (renomeado para evitar conflito com color do text)
+    
+    borderWidth: Optional[str] = None  # container
+    borderStyle: Optional[str] = None  # container
+    borderColor: Optional[str] = None  # container
+    containerMargin: Optional[str] = None  # container
+    expansion: Optional[str] = None  # container
+    
+    mainAxisSize: Optional[str] = None  # column
+    
+    columns: Optional[List[Dict[str, Any]]] = None  # table
+    rows: Optional[List[Dict[str, Any]]] = None  # table
+    headerBackgroundColor: Optional[str] = None  # table
+    cellBackgroundColor: Optional[str] = None  # table
+
+class Project(BaseModel):
+    name: Optional[str] = "Documento A4"
+    orientation: Optional[str] = "portrait"
+
+class PDFFromJSONRequest(BaseModel):
+    elements: List[Element]
+    project: Optional[Project] = None
+
+# Funções auxiliares para gerar HTML a partir de JSON
+def get_background_size(box_fit: Optional[str]) -> str:
+    """Converte boxFit para CSS background-size"""
+    if not box_fit:
+        return "cover"
+    size_map = {
+        "fill": "100% 100%",
+        "contain": "contain",
+        "cover": "cover",
+        "fitWidth": "100% auto",
+        "fitHeight": "auto 100%",
+        "none": "auto",
+        "scaleDown": "contain"
+    }
+    return size_map.get(box_fit, "cover")
+
+def format_style_value(value: Any) -> str:
+    """Formata valores de estilo para CSS"""
+    if value is None:
+        return ""
+    if isinstance(value, (int, float)):
+        return f"{value}px"
+    if isinstance(value, str):
+        if any(unit in value for unit in ["px", "rem", "em", "%", "mm"]):
+            return value
+        try:
+            num = float(value)
+            return f"{num}px"
+        except ValueError:
+            return value
+    return str(value)
+
+def generate_element_html(element: Element, elements_dict: Dict[str, Element], level: int = 0) -> str:
+    """Gera HTML para um elemento e seus filhos recursivamente"""
+    indent = "  " * level
+    
+    # Busca filhos
+    children = []
+    if element.children:
+        for child_id in element.children:
+            if child_id in elements_dict:
+                children.append(elements_dict[child_id])
+    
+    element_type = element.type
+    
+    if element_type == "a4":
+        styles = []
+        if element.backgroundColor:
+            styles.append(f"background-color: {element.backgroundColor}")
+        if element.backgroundImage:
+            styles.append(f"background-image: url({element.backgroundImage})")
+            styles.append(f"background-size: {get_background_size(element.backgroundImageBoxFit)}")
+            styles.append("background-position: center")
+            styles.append("background-repeat: no-repeat")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        children_html = "\n".join([generate_element_html(child, elements_dict, level + 1) for child in children])
+        return f'{indent}<div class="a4-page"{style_attr}>\n{children_html}\n{indent}</div>'
+    
+    elif element_type == "column":
+        styles = []
+        if element.padding and element.padding != "0":
+            styles.append(f"padding: {format_style_value(element.padding)}")
+        if element.gap and element.gap != "0":
+            styles.append(f"gap: {format_style_value(element.gap)}")
+        if element.width and element.width != "100%":
+            styles.append(f"width: {element.width}")
+        
+        # Alignment
+        if element.alignment:
+            justify_map = {
+                "top-aligned": "flex-start",
+                "centered": "center",
+                "bottom-aligned": "flex-end",
+                "space-around": "space-around",
+                "space-between": "space-between"
+            }
+            justify = justify_map.get(element.alignment, "flex-start")
+            styles.append("align-items: stretch")
+            styles.append(f"justify-content: {justify}")
+        
+        # Flex e height
+        is_root = element.id == "root-column"
+        if element.mainAxisSize == "max" or is_root:
+            styles.append("flex: 1 1 auto")
+            styles.append("height: 100%")
+        else:
+            styles.append("flex: 0 1 auto")
+            styles.append("height: auto")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        children_html = "\n".join([generate_element_html(child, elements_dict, level + 1) for child in children])
+        return f'{indent}<div class="column"{style_attr}>\n{children_html}\n{indent}</div>'
+    
+    elif element_type == "row":
+        styles = []
+        if element.padding and element.padding != "0":
+            styles.append(f"padding: {format_style_value(element.padding)}")
+        if element.width and element.width != "100%":
+            styles.append(f"width: {element.width}")
+        if element.gap and element.gap != "0":
+            styles.append(f"gap: {format_style_value(element.gap)}")
+        if element.alignment:
+            styles.append(f"align-items: {element.alignment}")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        children_html = "\n".join([generate_element_html(child, elements_dict, level + 1) for child in children])
+        return f'{indent}<div class="row"{style_attr}>\n{children_html}\n{indent}</div>'
+    
+    elif element_type == "container":
+        styles = []
+        if element.backgroundColor and element.backgroundColor != "transparent":
+            styles.append(f"background-color: {element.backgroundColor}")
+        if element.backgroundImage:
+            styles.append(f"background-image: url({element.backgroundImage})")
+            styles.append(f"background-size: {get_background_size(element.backgroundImageBoxFit)}")
+            styles.append("background-position: center")
+            styles.append("background-repeat: no-repeat")
+        if element.width:
+            styles.append(f"width: {format_style_value(element.width)}")
+        if element.height:
+            styles.append(f"height: {format_style_value(element.height)}")
+        if element.padding and element.padding != "0":
+            styles.append(f"padding: {format_style_value(element.padding)}")
+        if element.borderRadius and element.borderRadius != "0":
+            styles.append(f"border-radius: {format_style_value(element.borderRadius)}")
+        
+        # Horizontal alignment
+        if element.horizontalAlignment:
+            align_map = {
+                "left-aligned": "0px auto 0px 0px",
+                "centered": "0px auto",
+                "right-aligned": "0px 0px 0px auto"
+            }
+            margin = align_map.get(element.horizontalAlignment, "0px auto")
+            styles.append(f"margin: {margin}")
+        elif element.containerMargin and element.containerMargin != "0":
+            styles.append(f"margin: {format_style_value(element.containerMargin)}")
+        
+        # Border
+        if element.borderWidth and element.borderWidth != "0":
+            styles.append(f"border-width: {format_style_value(element.borderWidth)}")
+            styles.append(f"border-style: {element.borderStyle or 'solid'}")
+            if element.borderColor:
+                styles.append(f"border-color: {element.borderColor}")
+        else:
+            styles.append("border-width: 0px")
+            styles.append("border-style: none")
+        
+        styles.append("box-sizing: border-box")
+        if element.expansion == "expanded":
+            styles.append("flex: 1 1 0%")
+        else:
+            styles.append("flex: 0 0 auto")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        children_html = "\n".join([generate_element_html(child, elements_dict, level + 1) for child in children])
+        return f'{indent}<div class="container"{style_attr}>\n{children_html}\n{indent}</div>'
+    
+    elif element_type == "text":
+        styles = []
+        if element.color:
+            styles.append(f"color: {element.color}")
+        if element.fontFamily:
+            styles.append(f"font-family: {element.fontFamily}")
+        if element.fontSize:
+            styles.append(f"font-size: {format_style_value(element.fontSize)}")
+        if element.fontWeight:
+            styles.append(f"font-weight: {element.fontWeight}")
+        if element.textAlign:
+            styles.append(f"text-align: {element.textAlign}")
+        if element.lineHeight:
+            styles.append(f"line-height: {element.lineHeight}")
+        if element.wordSpacing:
+            styles.append(f"word-spacing: {format_style_value(element.wordSpacing)}")
+        if element.letterSpacing:
+            styles.append(f"letter-spacing: {format_style_value(element.letterSpacing)}")
+        if element.fontStyle:
+            styles.append(f"font-style: {element.fontStyle}")
+        if element.textDecoration:
+            styles.append(f"text-decoration: {element.textDecoration}")
+        if element.textPadding and element.textPadding != "0":
+            styles.append(f"padding: {format_style_value(element.textPadding)}")
+        if element.maxLines:
+            styles.append(f"-webkit-line-clamp: {element.maxLines}")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        content = escape(element.content or "")
+        return f'{indent}<p class="text"{style_attr}>{content}</p>'
+    
+    elif element_type == "image":
+        styles = []
+        if element.width:
+            styles.append(f"width: {format_style_value(element.width)}")
+        if element.height:
+            styles.append(f"height: {format_style_value(element.height)}")
+        if element.padding and element.padding != "0":
+            styles.append(f"padding: {format_style_value(element.padding)}")
+        if element.borderRadius and element.borderRadius != "0":
+            styles.append(f"border-radius: {format_style_value(element.borderRadius)}")
+        if element.containerMargin and element.containerMargin != "0":
+            styles.append(f"margin: {format_style_value(element.containerMargin)}")
+        if element.imageBoxFit:
+            styles.append(f"object-fit: {element.imageBoxFit}")
+        if element.opacity is not None and element.opacity != 1:
+            styles.append(f"opacity: {element.opacity}")
+        if element.horizontalAlignment:
+            align_map = {
+                "left": "0",
+                "right": "auto",
+                "centered": "auto"
+            }
+            margin_left = align_map.get(element.horizontalAlignment, "auto")
+            margin_right = align_map.get(element.horizontalAlignment, "auto")
+            styles.append(f"display: block; margin-left: {margin_left}; margin-right: {margin_right}")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        src = element.src or ""
+        return f'{indent}<img class="image" src="{src}" alt=""{style_attr} />'
+    
+    elif element_type == "line":
+        styles = []
+        if element.lineColor:
+            styles.append(f"background-color: {element.lineColor}")
+        if element.thickness:
+            if element.direction == "vertical":
+                styles.append(f"width: {format_style_value(element.thickness)}")
+            else:
+                styles.append(f"height: {format_style_value(element.thickness)}")
+        if element.width and element.direction == "horizontal":
+            styles.append(f"width: {format_style_value(element.width)}")
+        if element.height and element.direction == "vertical":
+            styles.append(f"height: {format_style_value(element.height)}")
+        if element.borderRadius and element.borderRadius != "0":
+            styles.append(f"border-radius: {format_style_value(element.borderRadius)}")
+        if element.horizontalAlignment:
+            align_map = {
+                "left": "0",
+                "right": "auto",
+                "centered": "auto"
+            }
+            margin_left = align_map.get(element.horizontalAlignment, "auto")
+            margin_right = align_map.get(element.horizontalAlignment, "auto")
+            styles.append(f"margin-left: {margin_left}; margin-right: {margin_right}")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        return f'{indent}<div class="line"{style_attr}></div>'
+    
+    elif element_type == "spacer":
+        styles = []
+        if element.width:
+            styles.append(f"width: {format_style_value(element.width)}")
+        if element.height:
+            styles.append(f"height: {format_style_value(element.height)}")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        return f'{indent}<div class="spacer"{style_attr}></div>'
+    
+    elif element_type == "table":
+        styles = []
+        if element.width:
+            styles.append(f"width: {format_style_value(element.width)}")
+        if element.borderRadius and element.borderRadius != "0":
+            styles.append(f"border-radius: {format_style_value(element.borderRadius)}")
+        
+        style_attr = f' style="{"; ".join(styles)}"' if styles else ""
+        
+        columns = element.columns or [{"id": "col1", "title": "Coluna 1", "width": "100px"}]
+        rows = element.rows or [{"id": "row1"}]
+        
+        html_parts = [f'{indent}<table class="table"{style_attr}>']
+        
+        # Cabeçalho
+        html_parts.append(f'{indent}  <thead>')
+        html_parts.append(f'{indent}    <tr>')
+        for column in columns:
+            header_id = f'header-{column.get("id", "")}'
+            header_children = [e for e in elements_dict.values() if e.parentId == header_id]
+            header_style = f' style="background-color: {element.headerBackgroundColor};"' if element.headerBackgroundColor else ""
+            header_content = column.get("title", "")
+            if header_children:
+                header_content = "\n" + "\n".join([generate_element_html(child, elements_dict, level + 4) for child in header_children]) + f"\n{indent}      "
+            else:
+                header_content = escape(header_content)
+            html_parts.append(f'{indent}      <th{header_style}>{header_content}</th>')
+        html_parts.append(f'{indent}    </tr>')
+        html_parts.append(f'{indent}  </thead>')
+        
+        # Corpo
+        html_parts.append(f'{indent}  <tbody>')
+        for row in rows:
+            html_parts.append(f'{indent}    <tr>')
+            for column in columns:
+                cell_id = f'{row.get("id", "")}-{column.get("id", "")}'
+                cell_children = [e for e in elements_dict.values() if e.parentId == cell_id]
+                cell_style = f' style="background-color: {element.cellBackgroundColor};"' if element.cellBackgroundColor else ""
+                cell_content = ""
+                if cell_children:
+                    cell_content = "\n" + "\n".join([generate_element_html(child, elements_dict, level + 4) for child in cell_children]) + f"\n{indent}      "
+                html_parts.append(f'{indent}      <td{cell_style}>{cell_content}</td>')
+            html_parts.append(f'{indent}    </tr>')
+        html_parts.append(f'{indent}  </tbody>')
+        html_parts.append(f'{indent}</table>')
+        
+        return "\n".join(html_parts)
+    
+    return ""
+
+def generate_css(orientation: str = "portrait") -> str:
+    """Gera CSS básico para o PDF"""
+    is_portrait = orientation == "portrait"
+    page_width = "210mm" if is_portrait else "297mm"
+    page_height = "297mm" if is_portrait else "210mm"
+    
+    css = """* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html, body {
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  font-family: Arial, sans-serif;
+  background: #f5f5f5;
+}
+
+.a4-page {
+  width: """ + page_width + """;
+  height: """ + page_height + """;
+  margin: 0;
+  padding: 0;
+  background: white;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  box-sizing: border-box;
+}
+
+.paper-content {
+  width: 100%;
+  height: 100%;
+  padding: 0;
+  display: flex;
+  position: relative;
+  overflow: hidden;
+}
+
+.column-element,
+.column {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+}
+
+.row-element,
+.row {
+  display: flex;
+  flex-direction: row;
+  width: 100%;
+}
+
+.container-element,
+.container {
+  display: block;
+}
+
+.text-element,
+.text {
+  display: block;
+  word-wrap: break-word;
+}
+
+.image-element,
+.image {
+  display: block;
+  max-width: 100%;
+  height: auto;
+}
+
+.line-element,
+.line {
+  display: block;
+}
+
+.spacer-element,
+.spacer {
+  display: block;
+}
+
+.table-element,
+.table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.table th,
+.table td {
+  padding: 8px;
+  border: 1px solid #ddd;
+}
+"""
+    return css
+
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}
@@ -111,5 +582,149 @@ async def generate_pdf(request: PDFRequest):
             }
         )
     
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar PDF: {str(e)}")
+
+@app.post("/generate-pdf-from-json")
+async def generate_pdf_from_json(request: PDFFromJSONRequest):
+    """
+    Gera PDF a partir de uma estrutura JSON de elementos.
+    Esta rota é mais eficiente que /generate-pdf pois não requer envio de HTML completo.
+    
+    Exemplo de uso:
+    {
+        "elements": [
+            {
+                "id": "a4-page",
+                "type": "a4",
+                "children": ["root-column"],
+                "backgroundColor": "#FFFFFF"
+            },
+            {
+                "id": "root-column",
+                "type": "column",
+                "parentId": "a4-page",
+                "children": ["text-1"]
+            },
+            {
+                "id": "text-1",
+                "type": "text",
+                "parentId": "root-column",
+                "content": "Olá, mundo!",
+                "fontSize": "24px",
+                "color": "#000000"
+            }
+        ],
+        "project": {
+            "name": "Meu Documento",
+            "orientation": "portrait"
+        }
+    }
+    """
+    try:
+        # Cria dicionário de elementos para acesso rápido
+        elements_dict = {elem.id: elem for elem in request.elements}
+        
+        # Encontra o elemento raiz (a4-page)
+        a4_element = None
+        for elem in request.elements:
+            if elem.type == "a4":
+                a4_element = elem
+                break
+        
+        if not a4_element:
+            raise HTTPException(status_code=400, detail="Elemento 'a4' não encontrado nos elementos")
+        
+        # Gera HTML a partir dos elementos
+        body_content = generate_element_html(a4_element, elements_dict, 1)
+        
+        # Gera CSS
+        orientation = request.project.orientation if request.project else "portrait"
+        css_content = generate_css(orientation)
+        
+        # Monta HTML completo
+        project_name = request.project.name if request.project else "Documento A4"
+        html_content = f"""<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{escape(project_name)}</title>
+  <style>
+{css_content}
+  </style>
+</head>
+<body>
+{body_content}
+</body>
+</html>"""
+        
+        # Gera o PDF usando WeasyPrint
+        pdf_buffer = BytesIO()
+        
+        # Configura orientação e tamanho da página A4
+        if orientation == "landscape":
+            html_doc = HTML(string=html_content)
+            css_doc = CSS(string=f"""
+                @page {{
+                    size: 297mm 210mm;
+                    margin: 0;
+                    padding: 0;
+                }}
+                html, body {{
+                    margin: 0;
+                    padding: 0;
+                    width: 297mm;
+                    height: 210mm;
+                }}
+                .a4-page {{
+                    width: 297mm;
+                    height: 210mm;
+                    margin: 0;
+                    padding: 0;
+                }}
+                {css_content}
+            """)
+            html_doc.write_pdf(pdf_buffer, stylesheets=[css_doc])
+        else:
+            # Portrait (padrão)
+            html_doc = HTML(string=html_content)
+            css_doc = CSS(string=f"""
+                @page {{
+                    size: 210mm 297mm;
+                    margin: 0;
+                    padding: 0;
+                }}
+                html, body {{
+                    margin: 0;
+                    padding: 0;
+                    width: 210mm;
+                    height: 297mm;
+                }}
+                .a4-page {{
+                    width: 210mm;
+                    height: 297mm;
+                    margin: 0;
+                    padding: 0;
+                }}
+                {css_content}
+            """)
+            html_doc.write_pdf(pdf_buffer, stylesheets=[css_doc])
+        
+        pdf_buffer.seek(0)
+        pdf_bytes = pdf_buffer.read()
+        
+        # Retorna o PDF como resposta
+        filename = f"{project_name}.pdf" if request.project and request.project.name else "documento.pdf"
+        return Response(
+            content=pdf_bytes,
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f'attachment; filename="{filename}"'
+            }
+        )
+    
+    except HTTPException:
+        raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erro ao gerar PDF: {str(e)}")