epok-toolkit 0.1.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

epok_toolkit/default_settings.py

@@ -1,3 +1,15 @@
-DEFAULT_EMAIL_SENDER = "no-reply@epok.ai"
-EMAIL_SUBJECT_PREFIX = "[Epok] "
-EPOK_WHATSAPP_DEFAULT = True
+# Configuración de correo electrónico
+EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+EMAIL_HOST = 'smtp.gmail.com'
+EMAIL_PORT = 465
+EMAIL_USE_SSL = True
+EMAIL_USE_TLS = False
+EMAIL_DEFAULT_FROM_EMAIL = "no-reply@epok.ai"
+EMAIL_HOST_USER = "no-reply@epok.ai"
+EMAIL_HOST_PASSWORD = "your-email-password"
+
+
+# Configuración de whatsApp
+API_KEY = "your-whatsapp-api-key"
+INSTANCE = "instance-id"
+SERVER_URL = "https://your-server-url.com/"

epok_toolkit/email/__init__.py

@@ -0,0 +1 @@
+from .email_async import send_email

epok_toolkit/messaging/__init__.py

@@ -0,0 +1 @@
+from .whatsapp_instanced import send_whatsapp_message

epok_toolkit/messaging/whatsapp.py

@@ -0,0 +1,367 @@
+import requests
+from typing import Optional
+from functools import wraps
+from dataclasses import dataclass
+
+
+def timeout_response(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except requests.Timeout:
+            print("La solicitud ha excedido el tiempo de espera.")
+            return HttpResponse(status_code=408, text="Timeout", json_data=None)
+        except requests.RequestException as e:
+            print(f"Error en la solicitud: {e}")
+            return HttpResponse(
+                status_code=500, text="Error", json_data={"error": str(e)}
+            )
+
+    return wrapper
+
+
+def require_connection(method):
+    """
+    Decorador para métodos de WhatsappClient que necesitan una conexión activa.
+    Llama a `self.ensure_connected()` y solo ejecuta el método original si la
+    conexión se confirma; de lo contrario devuelve False.
+    """
+    from functools import wraps
+
+    @wraps(method)
+    def _wrapper(self, *args, **kwargs):
+        if not self.ensure_connected():
+            print("❌ No fue posible establecer conexión.")
+            return False
+        return method(self, *args, **kwargs)
+
+    return _wrapper
+
+
+@dataclass
+class HttpResponse:
+    status_code: int
+    text: str
+    json_data: Optional[dict] = None
+
+
+class WhatsAppInstance:
+    def __init__(self, api_key: str, instance: str, server_url: str):
+        self.api_key = api_key
+        self.name_instance = instance
+        self.status = "disconnected"
+        self.server_url = server_url.rstrip("/")
+        self.headers = {"apikey": self.api_key, "Content-Type": "application/json"}
+
+    def create_instance(self) -> HttpResponse:
+        """Crea una nueva instancia de WhatsApp usando la API de Envole."""
+        url = f"{self.server_url}/instance/create"
+        payload = {
+            "instanceName": self.name_instance,
+            "integration": "WHATSAPP-BAILEYS",
+            "syncFullHistory": False,
+        }
+        response = requests.post(url, json=payload, headers=self.headers)
+        return HttpResponse(response.status_code, response.text, response.json())
+
+    def delete_instance(self) -> HttpResponse:
+        """Elimina una instancia de WhatsApp usando la API de Envole."""
+        url = f"{self.server_url}/instance/delete/{self.name_instance}"
+        response = requests.delete(url, headers=self.headers)
+        return HttpResponse(response.status_code, response.text)
+
+    def show_qr(self, qr_text: str) -> None:
+        """Genera un código QR a partir de `qr_text` y lo muestra con el visor por defecto."""
+        import qrcode
+
+        qr = qrcode.QRCode(border=2)
+        qr.add_data(qr_text)
+        qr.make(fit=True)
+        img = qr.make_image()
+        img.show()
+
+    def connect_instance_qr(self) -> None:
+        """Conecta una instancia de WhatsApp y muestra una imagen"""
+        url = f"{self.server_url}/instance/connect/{self.name_instance}"
+        response = requests.get(url, headers=self.headers)
+        codigo = response.json().get("code")
+        self.show_qr(codigo)
+
+    def mode_connecting(self):
+        """
+        Se intentará por 30 min el mantenter intentos de conexión a la instancia
+        generando un qr cada 10 segundos, si es exitoso se podra enviar un mensaje,
+        si después de eso no se conecta, se devolvera un error
+        """
+        pass
+
+
+class WhatsAppSender:
+    def __init__(self, instance: WhatsAppInstance):
+        self.instance = instance.name_instance
+        self.server_url = instance.server_url
+        self.headers = instance.headers
+        self._instance_obj = instance
+        self.connected = True  # estado de conexión conocido
+
+    def test_connection_status(self) -> bool:
+        cel_epok = "5214778966517"
+        print(f"Probando conexión enviando mensaje a {cel_epok}...")
+        ok = bool(self.send_text(cel_epok, "ping"))
+        self.connected = ok
+        return ok
+
+    @timeout_response
+    def get(self, endpoint: str, params: Optional[dict] = None) -> requests.Response:
+        url = f"{self.server_url}{endpoint}"
+        return requests.get(url, headers=self.headers, params=params)
+
+    def put(self, endpoint: str) -> requests.Response:
+        url = f"{self.server_url}{endpoint}"
+        return requests.put(url, headers=self.headers)
+
+    def post(self, endpoint: str, payload: dict):
+        url = f"{self.server_url}{endpoint}"
+        request = requests.post(url, json=payload, headers=self.headers, timeout=10)
+        # if timeout:
+        try:
+            return request
+        except requests.Timeout:
+            print("Request timed out")
+            return HttpResponse(status_code=408, text="Timeout", json_data=None)
+
+    def send_text(self, number: str, text: str, link_preview: bool = True, delay_ms: int = 0) -> str:
+        payload = {
+            "number": number,
+            "text": text,
+            "delay": delay_ms,
+            "linkPreview": link_preview,
+        }
+        print(f"Enviando mensaje a {number}: {text}")
+        resp = self.post(f"/message/sendText/{self.instance}", payload)
+
+        # Si la solicitud se convirtió en HttpResponse por timeout
+        status = resp.status_code if hasattr(resp, "status_code") else 0
+
+        if 200 <= status < 300:
+            self.connected = True
+            return resp.text
+
+        # Fallo: marcar desconexión y reportar
+        print(f"Error al enviar mensaje a {number}: {status} - {resp.text}")
+        self.connected = False
+        return False
+
+    def send_media(self, number: str, media_b64: str, filename: str, caption: str, mediatype: str = "document", mimetype: str = "application/pdf") -> str:
+        payload = {
+            "number": number,
+            "mediatype": mediatype,
+            "mimetype": mimetype,
+            "caption": caption,
+            "media": media_b64,
+            "fileName": filename,
+            "delay": 0,
+            "linkPreview": False,
+            "mentionsEveryOne": False,
+        }
+        resp = self.post(f"/message/sendMedia/{self.instance}", payload)
+        return resp.text
+
+    def send_sticker(self, number: str, sticker_b64: str, delay: int = 0, link_preview: bool = True, mentions_everyone: bool = True) -> str:
+        """Envía un sticker a un contacto específico."""
+        payload = {
+            "number": number,
+            "sticker": sticker_b64,
+            "delay": delay,
+            "linkPreview": link_preview,
+            "mentionsEveryOne": mentions_everyone,
+        }
+        resp = self.post(f"/message/sendSticker/{self.instance}", payload)
+        return resp.text
+
+    def send_location(self, number: str, name: str, address: str, latitude: float, longitude: float, delay: int = 0) -> str:
+        """Envía una ubicación a un contacto."""
+        payload = {
+            "number": number,
+            "name": name,
+            "address": address,
+            "latitude": latitude,
+            "longitude": longitude,
+            "delay": delay,
+        }
+        resp = self.post(f"/message/sendLocation/{self.instance}", payload)
+        return resp.text
+
+    def send_audio(self, number: str, audio_b64: str, delay: int = 0) -> str:
+        """Envía un audio en formato base64 a un contacto."""
+        payload = {
+            "audio": audio_b64,
+            "number": number,
+            "delay": delay,
+        }
+        resp = self.post(f"/message/sendWhatsAppAudio/{self.instance}", payload)
+        return resp.text
+
+    def connect(self, number: str) -> str:
+        querystring = {"number": number}
+        resp = self.get(f"/instance/connect/{self.instance}", params=querystring)
+        return resp.text
+
+    def set_webhook(self, webhook_url: str, enabled: bool = True, webhook_by_events: bool = True, webhook_base64: bool = True, events: Optional[list] = None) -> str:
+        """Configura el webhook para la instancia."""
+        if events is None:
+            events = ["SEND_MESSAGE"]
+        payload = {
+            "url": webhook_url,
+            "enabled": enabled,
+            "webhookByEvents": webhook_by_events,
+            "webhookBase64": webhook_base64,
+            "events": events,
+        }
+        resp = self.post(f"/webhook/set/{self.instance}", payload)
+        return resp.text
+
+    def fetch_groups(self, get_participants: bool = True) -> list:
+        """Obtiene todos los grupos y sus participantes."""
+        params = {"getParticipants": str(get_participants).lower()}
+        resp = self.get(f"/group/fetchAllGroups/{self.instance}", params=params)
+        if resp.status_code == 200:
+            return resp.json()
+        else:
+            raise Exception(
+                f"Error al obtener grupos: {resp.status_code} - {resp.text}"
+            )
+
+    @staticmethod
+    def fetch_instances(api_key: str, server_url: str) -> list:
+        """Obtiene todas las instancias disponibles en el servidor."""
+        url = f"{server_url}/instance/fetchInstances"
+        headers = {"apikey": api_key}
+        response = requests.get(url, headers=headers, verify=False)
+        # Puede ser una lista o dict, depende del backend
+        try:
+            return response.json()
+        except Exception:
+            return []
+
+    @staticmethod
+    def get_instance_info(api_key: str, instance_name: str, server_url: str):
+        """Busca la info de una instancia específica por nombre, robusto a diferentes formatos de respuesta."""
+        instances = WhatsAppSender.fetch_instances(api_key, server_url)
+
+        # Normalizar a lista para iterar
+        if isinstance(instances, dict):
+            instances = [instances]
+        # print(f"Buscando instancia: {instance_name} en {len(instances)} instancias disponibles.")
+        for item in instances:
+            data = (
+                item.get("instance")
+                if isinstance(item, dict) and "instance" in item
+                else item
+            )
+            # print(data)
+            if not isinstance(data, dict):
+                continue  # Formato inesperado para us
+
+            if data.get("name") == instance_name:
+                return data
+        return {}
+
+
+
+class WhatsappClient:
+    """
+    Cliente para interactuar con la API de WhatsApp.
+    """
+    def __init__(self, api_key: str, server_url: str, instance_name: str = "EPOK"):
+        self.instance = WhatsAppInstance(api_key, instance_name, server_url)
+        self.sender: Optional[WhatsAppSender] = None
+        self._auto_initialize_sender()
+
+    def _auto_initialize_sender(self):
+        """Solo asigna sender si la instancia está enlazada a WhatsApp."""
+        info = WhatsAppSender.get_instance_info(
+            self.instance.api_key, self.instance.name_instance, self.instance.server_url
+        )
+        if info.get("ownerJid"):  # <- si tiene owner, significa que ya está enlazada
+            self.sender = WhatsAppSender(self.instance)
+
+    def ensure_connected(self, retries: int = 3, delay: int = 30) -> bool:
+        """
+        Garantiza que la instancia esté conectada.
+        Si aún no existe `self.sender`, intentará crearlo.
+        Si la prueba de conexión falla, muestra un QR y reintenta.
+        """
+        import time
+
+        # Si ya tenemos sender y está marcado como conectado, salimos rápido
+        if self.sender and getattr(self.sender, "connected", False):
+            return True
+
+        def _init_sender():
+            if self.sender is None:
+                # Intentar inicializar si la instancia ya está enlazada
+                info = WhatsAppSender.get_instance_info(
+                    self.instance.api_key,
+                    self.instance.name_instance,
+                    self.instance.server_url,
+                )
+                if info.get("ownerJid"):
+                    self.sender = WhatsAppSender(self.instance)
+
+        # Primer intento de inicializar el sender
+        _init_sender()
+
+        for attempt in range(1, retries + 1):
+            if self.sender and self.sender.test_connection_status():
+                return True
+
+            print(
+                f"[{attempt}/{retries}] Conexión no disponible, mostrando nuevo QR (espera {delay}s)…"
+            )
+            self.instance.connect_instance_qr()  # muestra nuevo QR
+            time.sleep(delay)
+
+            # Reintentar inicializar sender después de mostrar QR
+            _init_sender()
+
+        print("❌ No fue posible establecer conexión después de varios intentos.")
+        return False
+
+    @require_connection
+    def send_text(self, number: str, text: str, link_preview: bool = True, delay_ms: int = 1000):
+        return self.sender.send_text(number, text, link_preview, delay_ms=delay_ms)
+
+    @require_connection
+    def send_media(self, number: str, media_b64: str, filename: str, caption: str, mediatype: str = "document", mimetype: str = "application/pdf"):
+        return self.sender.send_media(number, media_b64, filename, caption, mediatype, mimetype)
+
+    @require_connection
+    def send_sticker(self, number: str, sticker_b64: str, delay: int = 0, link_preview: bool = True, mentions_everyone: bool = True):
+        return self.sender.send_sticker(number, sticker_b64, delay, link_preview, mentions_everyone)
+
+    @require_connection
+    def send_location(self, number: str, name: str, address: str, latitude: float, longitude: float, delay: int = 0):
+        return self.sender.send_location(number, name, address, latitude, longitude, delay)
+
+    @require_connection
+    def send_audio(self, number: str, audio_b64: str, delay: int = 0):
+        return self.sender.send_audio(number, audio_b64, delay)
+
+    @require_connection
+    def connect_number(self, number: str):
+        return self.sender.connect(number)
+
+    @require_connection
+    def fetch_groups(self, get_participants: bool = True):
+        return self.sender.fetch_groups(get_participants)
+
+    def create_instance(self):
+        return self.instance.create_instance()
+
+    def delete_instance(self):
+        return self.instance.delete_instance()
+
+    def connect_instance_qr(self):
+        return self.instance.connect_instance_qr()

epok_toolkit/messaging/whatsapp_instanced.py

@@ -0,0 +1,22 @@
+from .whatsapp import WhatsappClient
+from django.conf import settings
+from celery import shared_task
+
+
+API_KEY = settings.API_KEY
+INSTANCE = settings.INSTANCE
+SERVER_URL = settings.SERVER_URL
+
+client = WhatsappClient(api_key=API_KEY, server_url=SERVER_URL, instance_name=INSTANCE)
+
+@shared_task(
+    bind=True,
+    autoretry_for=(ConnectionError, TimeoutError),
+    retry_backoff=True,       # 2, 4, 8, 16… s
+    retry_jitter=True,        # +- aleatorio
+    max_retries=3,
+    ignore_result=True,       # <-- ¡importante!
+)
+def send_whatsapp_message(number: str, message: str):
+    return client.send_text(number, message)
+

epok_toolkit/pdf/__init__.py

@@ -0,0 +1 @@
+from .ticket_pdf import TicketPDF

epok_toolkit/pdf/ticket_pdf.py

@@ -0,0 +1,246 @@
+from reportlab.lib.utils import ImageReader
+from reportlab.pdfbase import pdfmetrics
+from datetime import date, datetime
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.pdfgen import canvas
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+from PIL import Image
+import locale
+from uuid import uuid4, UUID
+import os
+import qrcode
+from io import BytesIO
+
+
+# pip install reportlab qrcode
+
+
+fuente_path = os.path.join(os.path.dirname(__file__), "fuentes", "Kollektif-Bold.ttf")
+pdfmetrics.registerFont(TTFont("kollektif", fuente_path))
+
+
+def hex_to_rgb(hex_color):
+    hex_color = hex_color.lstrip('#')
+    lv = len(hex_color)
+    return tuple(int(hex_color[i:i + lv // 3], 16) / 255.0 for i in range(0, lv, lv // 3))
+
+
+class Config:
+    base_path = os.path.dirname(__file__)
+    plantillas = base_path + "/plantillas/"
+    plantilla_path = os.path.join(plantillas, "Ticket_congrats.png")
+    output_path = os.path.join(base_path, "ticket_final.pdf")
+    fuente = "Helvetica"
+    fuente_bold = "kollektif"
+    #bg_color = "#0082FF"  
+    bg_color = "#FFFFFF"  
+    font_color = "#000000"  
+
+
+class Contenedor:
+    def __init__(self, x, y, w, h, bold: bool = False):
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.color = Config.bg_color
+        self.font_size = 28
+        self.font_color = Config.font_color
+        self.fuente = Config.fuente_bold if bold else Config.fuente
+
+    def dibujar(self, c):
+        c.setFillColorRGB(*hex_to_rgb(self.color))
+        c.rect(self.x, self.y, self.w, self.h, stroke=0, fill=1)
+
+
+    def dibujar_texto(self, c, texto):
+        c.setFillColorRGB(*hex_to_rgb(self.font_color))
+        c.setFont(self.fuente, self.font_size)
+        ascent = pdfmetrics.getAscent(self.fuente) * self.font_size / 1000
+        descent = abs(pdfmetrics.getDescent(self.fuente) * self.font_size / 1000)
+        text_h = ascent + descent
+        baseline_x = self.x + self.w / 2
+        baseline_y = self.y + (self.h - text_h) / 2 + descent
+        c.drawCentredString(baseline_x, baseline_y, texto)
+
+
+class ContenedorTexto(Contenedor):
+    def __init__(self, x, y, w, h, bold: bool = False, texto="Demo",
+                 font_size=28,
+                 font_color=None,
+                 color=None,
+                 fuente=None):
+        super().__init__(x, y, w, h, bold=bold)
+        self.texto = texto
+        if font_size:
+            self.font_size = font_size
+        if font_color:
+            self.font_color = font_color
+        if color:
+            self.color = color
+        if fuente:
+            self.fuente = fuente
+    
+    def dibujar(self, c):
+        super().dibujar(c)
+        self.dibujar_texto(c, self.texto)
+
+
+class ContenedorQR(Contenedor):
+    def __init__(self, x, y, w, h, texto="QR vacío", color=None):
+        super().__init__(x, y, w, h)
+        self.texto = texto
+        if color:
+            self.color = color
+
+    def dibujar(self, c):
+        super().dibujar(c)
+        qr = qrcode.QRCode(
+            version=3,
+            error_correction=qrcode.constants.ERROR_CORRECT_H, # type: ignore
+            box_size=10,
+            border=1,
+        )
+        qr.add_data(self.texto)
+        qr.make(fit=True)
+        qr_img = qr.make_image(fill_color="black", back_color="white").convert("RGB") # type: ignore
+        qr_img = qr_img.resize((self.w, self.h), Image.LANCZOS) # type: ignore
+        buffer = BytesIO()
+        qr_img.save(buffer, format="PNG")
+        buffer.seek(0)
+        c.drawImage(ImageReader(buffer), self.x, self.y, width=self.w, height=self.h)
+
+
+@dataclass
+class TicketPDF:
+    nombre_evento: str
+    fecha: Optional[date]
+    titulo_ticket: str
+    precio: float
+    edad_min: int
+    tipo_evento: str
+    direccion: str
+    ticket_actual: int
+    total_tickets: int
+    nombre_persona: str
+    uuid: Optional[UUID] = None
+    hora_evento: Optional[str] = None
+    qr : Optional[str] = None
+
+    def __post_init__(self):
+        if isinstance(self.fecha, str):
+            self.fecha = datetime.strptime(self.fecha, "%Y-%m-%d %H:%M")
+        elif isinstance(self.fecha, date) and not isinstance(self.fecha, datetime):
+            hora = self.hora_evento or "00:00"
+            self.fecha = datetime.combine(self.fecha, datetime.strptime(hora, "%H:%M").time())
+        if not self.uuid:
+            raise ValueError("UUID no puede ser None")
+        
+        self.hora_evento = self.fecha.strftime("%H:%M") # type: ignore
+        self.width = 0
+        self.height = 0
+        self.font_size = 28
+        self.font_color = Config.font_color
+        self.color = Config.bg_color
+        self.fuente = Config.fuente
+        self.img = Image.open(Config.plantilla_path)
+        self.width, self.height = self.img.size
+        self.buffer = BytesIO()
+        self.c = canvas.Canvas(self.buffer, pagesize=(self.width, self.height))
+
+
+    def generate_ticket(self):
+        def y(px): return self.height - px
+        self.c.drawImage(ImageReader(Config.plantilla_path), 0, 0, width=self.width, height=self.height, mask='auto')
+
+        # NOMBRE EVENTO
+        nombre_evento = ContenedorTexto(x=260, y=y(210), w=1400, h=90, texto=self.nombre_evento, font_size=78, bold=True)
+        nombre_evento.dibujar(self.c)
+        
+        # FECHA
+        SPANISH_DAYS = {
+            'Monday': 'Lunes', 'Tuesday': 'Martes', 'Wednesday': 'Miercoles',
+            'Thursday': 'Jueves', 'Friday': 'Viernes', 'Saturday': 'Sabado', 'Sunday': 'Domingo'
+        }
+        SPANISH_MONTHS = {
+            'January': 'Enero', 'February': 'Febrero', 'March': 'Marzo', 'April': 'Abril',
+            'May': 'Mayo', 'June': 'Junio', 'July': 'Julio', 'August': 'Agosto',
+            'September': 'Septiembre', 'October': 'Octubre', 'November': 'Noviembre', 'December': 'Diciembre'
+        }
+        fecha_obj = self.fecha  # type: ignore
+        day_name = SPANISH_DAYS[fecha_obj.strftime('%A')] # type: ignore
+        month_name = SPANISH_MONTHS[fecha_obj.strftime('%B')] # type: ignore
+        fecha = f"{day_name}, {fecha_obj.day} {month_name}".upper() #type: ignore
+        fecha = ContenedorTexto(x=570, y=y(320), w=900, h=90, texto=fecha, font_size=38, bold=True)
+        fecha.dibujar(self.c)
+
+        # TICKET TITULO
+        ticket_titulo = ContenedorTexto(x=260, y=y(525), w=950, h=90, texto=self.titulo_ticket, font_size=68, bold=True)
+        ticket_titulo.dibujar(self.c)
+        
+        # PRECIO
+        precio = f"{self.precio:,.2f} MXN"
+        precio = ContenedorTexto(x=450, y=y(650), w=600, h=90, texto=precio, font_size=58, bold=True)
+        precio.dibujar(self.c)
+        
+        # EDAD MINIMA
+        edad_min = str(self.edad_min)
+        edad_min = ContenedorTexto(x=345, y=y(760), w=80, h=30, texto=edad_min, font_size=18, bold=True)
+        edad_min.dibujar(self.c)
+        
+        # HORA DE ACCESO
+        hora_evento = ContenedorTexto(x=670, y=y(760), w=80, h=30, texto=self.hora_evento, font_size=18, bold=True) # type: ignore
+        hora_evento.dibujar(self.c)
+        
+        # TIPO DE EVENTO
+        tipo_evento = ContenedorTexto(x=995, y=y(760), w=150, h=30, texto=self.tipo_evento, font_size=18, bold=True)
+        tipo_evento.dibujar(self.c)
+
+        # DIRECCION
+        direccion = ContenedorTexto(x=200, y=y(950), w=1400, h=50, texto=self.direccion, font_size=38, bold=True)
+        direccion.dibujar(self.c)
+
+        # TICKET ACTUAL
+        texto = f"Ticket {self.ticket_actual} de {self.total_tickets}"
+        ticket_actual = ContenedorTexto(x=680, y=y(1035), w=340, h=50, texto=texto, font_size=28, bold=True)
+        ticket_actual.dibujar(self.c)
+        
+        # NOMBRE PERSONA
+        nombre_persona = ContenedorTexto(x=1080, y=y(1035), w=760, h=60, texto=self.nombre_persona, font_size=48, bold=True)
+        nombre_persona.dibujar(self.c)
+        
+        # UUID
+        uuid_string = self.uuid
+        # UUID
+        uuid_string = str(self.uuid)
+        uuid = ContenedorTexto(x=1390, y=y(770), w=400, h=30, texto=uuid_string, font_size=18, bold=True)
+        uuid.dibujar(self.c)
+        tam = 400
+        qr = ContenedorQR(x=1390, y=y(740), w=tam, h=tam, texto=uuid_string, color=Config.bg_color)
+        qr.dibujar(self.c)
+
+        self.c.showPage()
+        self.c.save()
+        self.buffer.seek(0)
+        return self.buffer.getvalue()
+
+
+
+        
+if __name__ == "__main__":
+    ticket = TicketPDF(
+        nombre_evento="14 aniversario Cerveza Libertad",
+        fecha=datetime(2025, 5, 31, 14, 30),
+        titulo_ticket="General",
+        precio=410,
+        edad_min=18,
+        tipo_evento="Aniversario",
+        direccion="Restaurante dentro de Hacienda del Conde",
+        ticket_actual=2,
+        total_tickets=5,
+        nombre_persona="Carolina Franco Medina",
+        uuid=uuid4(),
+    )
+    ticket.generate_ticket()

{epok_toolkit-0.1.0.dist-info → epok_toolkit-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epok-toolkit
-Version: 0.1.0
+Version: 1.0.0
 Summary: A toolkit for building Django applications with Celery support
 Author-email: Fernando Leon Franco <fernanlee2131@gmail.com>
 License: MIT

epok_toolkit-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+epok_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epok_toolkit/apps.py,sha256=O3q3CcucJOHjlYIS0VgbKsbtim2hpng_FxpKEG_MlWs,486
+epok_toolkit/default_settings.py,sha256=hxsRmsAcjk4ar-pRz_X6AI17mJ3192Ljbx-xBuP5rdY,452
+epok_toolkit/email/__init__.py,sha256=pyJwysyVoq6DuYAG72fulsKFoOuAfjw3aBH7FhmYGHc,35
+epok_toolkit/email/email_async.py,sha256=oC0WowWNUpTpXdxo6hJag5gWUaStxI6VBEArEKQxXko,1521
+epok_toolkit/email/engine.py,sha256=IIifqRI9z76pHdrO5oSSZ25aP5txOTAgrj1JuVVPlMY,2387
+epok_toolkit/email/templates.py,sha256=uO3gYn2iiGxcjxioaG066gGPts1m-3C1Gp7XatGgVOg,7578
+epok_toolkit/messaging/__init__.py,sha256=kO7-PTlYLqxeuouqjp_3hqV0aVMosOAMMLh6h7HSBjA,53
+epok_toolkit/messaging/whatsapp.py,sha256=TrMSiKzvnhWOotSDEGil1BGgOJ7jLK7h3MXKdW3zCJw,14114
+epok_toolkit/messaging/whatsapp_instanced.py,sha256=FsyJNPgAonmo_9EYBGmfh4Ykovn7lXhzDyclyCepKno,627
+epok_toolkit/pdf/__init__.py,sha256=Scb1iOYnVIUEiUVHLNaPmcigyD-jOSBs3ws5RmolMKE,33
+epok_toolkit/pdf/ticket_pdf.py,sha256=6-QhnL2LCtWZeRIGnuQDeTybjMs39DnzohYx1mPQoPQ,8821
+epok_toolkit-1.0.0.dist-info/licenses/LICENSE,sha256=iLDbGXdLSIOT5OsxzHCvtmxHtonE21GiFlS3LNkug4A,128
+epok_toolkit-1.0.0.dist-info/METADATA,sha256=j2fxHYN14mUnmjkIdjKL4FB5Hr7DAMqPiEifrLjRWww,739
+epok_toolkit-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+epok_toolkit-1.0.0.dist-info/top_level.txt,sha256=Wo72AqIFcfWwBGM5F5iGFw9PrO3WBnTSprFZIJk_pNg,13
+epok_toolkit-1.0.0.dist-info/RECORD,,

epok_toolkit-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-epok_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-epok_toolkit/apps.py,sha256=O3q3CcucJOHjlYIS0VgbKsbtim2hpng_FxpKEG_MlWs,486
-epok_toolkit/default_settings.py,sha256=SxRAoLm67uHhUHwz1-xeMaN6MRB8FiN0ZVlQZFDF27U,103
-epok_toolkit/email/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-epok_toolkit/email/async_task.py,sha256=oC0WowWNUpTpXdxo6hJag5gWUaStxI6VBEArEKQxXko,1521
-epok_toolkit/email/engine.py,sha256=IIifqRI9z76pHdrO5oSSZ25aP5txOTAgrj1JuVVPlMY,2387
-epok_toolkit/email/templates.py,sha256=uO3gYn2iiGxcjxioaG066gGPts1m-3C1Gp7XatGgVOg,7578
-epok_toolkit-0.1.0.dist-info/licenses/LICENSE,sha256=iLDbGXdLSIOT5OsxzHCvtmxHtonE21GiFlS3LNkug4A,128
-epok_toolkit-0.1.0.dist-info/METADATA,sha256=sDgLv2prb5w5aJTKKR6OmQnHhl-qV40z5rDrJinUeHU,739
-epok_toolkit-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-epok_toolkit-0.1.0.dist-info/top_level.txt,sha256=Wo72AqIFcfWwBGM5F5iGFw9PrO3WBnTSprFZIJk_pNg,13
-epok_toolkit-0.1.0.dist-info/RECORD,,