lambda_function.py

import logging
import json
from certified_builder.certified_builder import CertifiedBuilder
from models.participant import Participant
from models.certificate import Certificate
from models.event import Event
from datetime import datetime
import base64
import os
from aws.s3_service import S3Service
from aws.sqs_service import SQSService

# Configure logging for CloudWatch
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# Remove any existing handlers to avoid duplicate logs
for handler in logger.handlers:
 logger.removeHandler(handler)

# Add a StreamHandler for CloudWatch
handler = logging.StreamHandler()
handler.setFormatter(
 logging.Formatter(
 "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
 datefmt="%Y-%m-%d %H:%M:%S",
 )
)
logger.addHandler(handler)


class DateTimeEncoder(json.JSONEncoder):
 def default(self, obj):
 if isinstance(obj, datetime):
 return obj.strftime("%Y-%m-%d %H:%M:%S")
 if hasattr(obj, "model_dump"):
 return obj.model_dump()
 return super().default(obj)


def extract_data_body(event):
 try:
 logger.info("Event recebido : {}".format(event))
 record = event["Records"][0]
 if isinstance(record["body"], str):
 body = json.loads(record["body"])
 return body
 else:
 return record["body"]
 except Exception as e:
 logger.error(f"Erro ao extrair dados do body: {str(e)}", exc_info=True)
 raise


def create_participant_object(participant_data):
 # Create Certificate object
 certificate = Certificate(
 details=participant_data.get("certificate_details"),
 logo=participant_data.get("certificate_logo"),
 background=participant_data.get("certificate_background"),
 )

 # Create Event object
 event = Event(
 order_id=participant_data.get("order_id"),
 product_id=participant_data.get("product_id"),
 product_name=participant_data.get("product_name"),
 date=datetime.strptime(participant_data.get("order_date"), "%Y-%m-%d %H:%M:%S"),
 time_checkin=(
 datetime.strptime(participant_data.get("time_checkin"), "%Y-%m-%d %H:%M:%S")
 if participant_data.get("time_checkin")
 else None
 ),
 checkin_latitude=(
 float(participant_data.get("checkin_latitude"))
 if participant_data.get("checkin_latitude")
 else None
 ),
 checkin_longitude=(
 float(participant_data.get("checkin_longitude"))
 if participant_data.get("checkin_longitude")
 else None
 ),
 )

 # Create Participant object
 participant = Participant(
 first_name=participant_data.get("first_name"),
 last_name=participant_data.get("last_name"),
 email=participant_data.get("email"),
 phone=participant_data.get("phone"),
 cpf=participant_data.get("cpf", ""),
 certificate=certificate,
 event=event,
 )
 return participant


def lambda_handler(event, context):
 # Log the start of the Lambda execution
 try:

 logger.info("Starting Lambda execution")
 body = extract_data_body(event)
 participants_data = body

 if not participants_data:
 logger.warning("No participants found in message")
 return {
 "statusCode": 400,
 "body": json.dumps(
 {
 "error": "No participants found in message",
 "message": "Nenhum participante encontrado para processamento",
 }
 ),
 }
 s3_service = S3Service()
 sqs_service = SQSService()

 logger.info(f"Processing {len(participants_data)} participants")

 # Create list of participants
 participants = []
 results = []

 for participant_data in participants_data:
 try:
 participant = create_participant_object(participant_data)
 participants.append(participant)
 except Exception as e:
 logger.error(f"Error creating participant object: {str(e)}")
 results.append(
 {
 "participant_data": participant_data,
 "error": str(e),
 "success": False,
 }
 )

 # Generate certificates if we have valid participants
 if participants:
 builder = CertifiedBuilder()
 certificates_results = builder.build_certificates(participants)
 # Format results before adding to response
 certificates_results_messagens = []

 for result in certificates_results:

 if result.get("success"):
 s3_service.upload_file(
 result.get("certificate_path"), result.get("certificate_key")
 )

 certificates_results_messagens.append(
 {
 "order_id": result.get("participant", {})
 .get("event", {})
 .get("order_id", ""),
 "validation_code": result.get("participant", {}).get(
 "validation_code", ""
 ),
 "authenticity_verification_url": result.get(
 "participant", {}
 ).get("authenticity_verification_url", ""),
 "product_id": result.get("participant", {})
 .get("event", {})
 .get("product_id", ""),
 "product_name": result.get("participant", {})
 .get("event", {})
 .get("product_name", ""),
 "email": result.get("participant", {}).get("email", ""),
 "certificate_key": result.get("certificate_key", ""),
 "success": result.get("success", False),
 }
 )

 sqs_service.send_message(certificates_results_messagens)

 logger.info("Certificados gerados com sucesso")
 return {
 "statusCode": 200,
 "body": json.dumps(
 {"message": "Processamento concluído", "results": results},
 cls=DateTimeEncoder,
 ),
 }
 else:
 logger.warning("No valid participants to process")
 return {
 "statusCode": 400,
 "body": json.dumps(
 {
 "error": "No valid participants to process",
 "message": "Nenhum participante válido para processamento",
 "results": results,
 },
 cls=DateTimeEncoder,
 ),
 }

 except Exception as e:
 logger.error(f"Error in lambda handler: {str(e)}")
 return {
 "statusCode": 500,
 "body": json.dumps(
 {"error": str(e), "message": "Erro ao gerar certificados"}
 ),
 }