Monthly reports

README.md

@@ -85,6 +85,11 @@ aws ssm put-parameter \
     --name "/banking-app/dev/SesSenderEmail" \
     --value "sender@yourdomain.co.uk" \
     --type "String"
+
+aws ssm put-parameter \
+    --name "/banking-app/dev/SesNoReplyEmail" \
+    --value "no-reply@yourdomain.co.uk" \
+    --type "String"
 
 aws ssm put-parameter \
     --name "/banking-app/dev/SesReplyEmail" \

dev-requirements.txt

@@ -5,8 +5,10 @@ black==25.1.0
 ruff==0.11.9
 
 # Running
-aws_lambda_powertools==3.12.0
+aws_lambda_powertools==3.17.0
 boto3==1.38.13
+xhtml2pdf==0.2.17
+Jinja2==3.1.6
 
 # Tests
 pytest==8.3.5

functions/accounts/get_account_transactions/get_account_transactions/app.py

@@ -0,0 +1,99 @@
+import os
+import json
+
+from aws_lambda_powertools import Logger
+from aws_lambda_powertools.event_handler import (
+    APIGatewayRestResolver,
+    CORSConfig,
+)
+from aws_lambda_powertools.event_handler.exceptions import (
+    InternalServerError,
+    BadRequestError,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+from dynamodb import get_dynamodb_resource
+from .exceptions import ValidationError
+from .transaction_helpers import query_transactions
+
+TRANSACTIONS_TABLE_NAME = os.environ.get("TRANSACTIONS_TABLE_NAME")
+ENVIRONMENT_NAME = os.environ.get("ENVIRONMENT_NAME", "dev")
+POWERTOOLS_LOG_LEVEL = os.environ.get("POWERTOOLS_LOG_LEVEL", "INFO").upper()
+DYNAMODB_ENDPOINT = os.environ.get("DYNAMODB_ENDPOINT")
+AWS_REGION = os.environ.get("AWS_REGION", "eu-west-2")
+
+logger = Logger(service="GetAccountTransactions", level=POWERTOOLS_LOG_LEVEL)
+
+app = APIGatewayRestResolver(
+    cors=CORSConfig(allow_headers=["Content-Type", "Authorization"])
+)
+
+dynamodb = get_dynamodb_resource(DYNAMODB_ENDPOINT, AWS_REGION, logger)
+if TRANSACTIONS_TABLE_NAME:
+    table = dynamodb.Table(TRANSACTIONS_TABLE_NAME)
+    logger.debug(f"Initialized DynamoDB table: {TRANSACTIONS_TABLE_NAME}")
+else:
+    logger.critical("FATAL: TRANSACTIONS_TABLE_NAME environment variable not set!")
+    table = None
+
+
+@app.get("/accounts/<account_id>/transactions")
+def get_account_transactions(account_id: str):
+    try:
+        period = app.current_event.get_query_string_value("period", default_value=None)
+        start = app.current_event.get_query_string_value("start", default_value=None)
+        end = app.current_event.get_query_string_value("end", default_value=None)
+
+        result = query_transactions(
+            table=table,
+            account_id=account_id,
+            logger=logger,
+            period=period,
+            start=start,
+            end=end,
+        )
+        return result
+
+    except ValidationError as ve:
+        logger.warning(f"Validation error: {ve}")
+        raise BadRequestError(str(ve))
+    except Exception as e:
+        logger.error(f"Error fetching transactions: {e}", exc_info=True)
+        raise InternalServerError("Internal server error")
+
+
+@logger.inject_lambda_context
+def lambda_handler(event, context: LambdaContext):
+    logger.append_keys(request_id=context.aws_request_id)
+    logger.info(f"Processing request in {ENVIRONMENT_NAME}")
+
+    if not table:
+        logger.error("DynamoDB table resource is not initialized")
+        raise InternalServerError("Server configuration error")
+
+    # Detect Step Functions or API Gateway
+    if "httpMethod" in event or "requestContext" in event:
+        return app.resolve(event, context)
+    else:
+        account_id = event.get("accountId")
+        if not account_id:
+            return {
+                "statusCode": 400,
+                "body": json.dumps({"error": "Missing accountId"}),
+            }
+
+        try:
+            result = query_transactions(
+                table=table, account_id=account_id, logger=logger
+            )
+
+            response = {
+                **event,
+                "transactions": result.get("transactions", result),
+            }
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error fetching transactions: {e}", exc_info=True)
+            return {"statusCode": 500, "body": json.dumps({"error": str(e)})}

functions/accounts/get_account_transactions/get_account_transactions/date_helpers.py

@@ -0,0 +1,68 @@
+from datetime import datetime, timedelta, timezone
+import calendar
+
+from .exceptions import ValidationError
+
+
+def get_date_range(period: str = None, start: str = None, end: str = None):
+    # --- Validation rules ---
+    if period and (start or end):
+        raise ValidationError("Cannot combine 'period' with 'start'/'end'")
+
+    if (start and not end) or (end and not start):
+        raise ValidationError("Both 'start' and 'end' must be provided together")
+
+    # --- Custom range ---
+    if start and end:
+        try:
+            start_dt = datetime.strptime(start, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+            end_dt = datetime.strptime(end, "%Y-%m-%d").replace(
+                hour=23, minute=59, second=59, tzinfo=timezone.utc
+            )
+        except ValueError:
+            raise ValidationError("Invalid date format, must be YYYY-MM-DD")
+
+        if end_dt < start_dt:
+            raise ValidationError("'end' date must be after 'start' date")
+
+        statement_period = (
+            f"{start_dt.strftime('%Y-%m-%d')}_to_{end_dt.strftime('%Y-%m-%d')}"
+        )
+
+    # --- Period (month) ---
+    elif period:
+        try:
+            year, month = map(int, period.split("-"))
+            start_dt = datetime(year, month, 1, tzinfo=timezone.utc)
+            last_day_num = calendar.monthrange(year, month)[1]
+            end_dt = datetime(
+                year, month, last_day_num, 23, 59, 59, tzinfo=timezone.utc
+            )
+        except Exception:
+            raise ValidationError("Invalid period format, must be YYYY-MM")
+
+        statement_period = start_dt.strftime("%Y-%m")
+
+    # --- Default: last month ---
+    else:
+        today = datetime.now(timezone.utc)
+        first_day_this_month = datetime(today.year, today.month, 1, tzinfo=timezone.utc)
+        last_day_last_month = first_day_this_month - timedelta(days=1)
+        start_dt = datetime(
+            last_day_last_month.year, last_day_last_month.month, 1, tzinfo=timezone.utc
+        )
+        end_dt = datetime(
+            last_day_last_month.year,
+            last_day_last_month.month,
+            last_day_last_month.day,
+            23,
+            59,
+            59,
+            tzinfo=timezone.utc,
+        )
+        statement_period = start_dt.strftime("%Y-%m")
+
+    start_iso = start_dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end_iso = end_dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    return statement_period, start_iso, end_iso

functions/accounts/get_account_transactions/get_account_transactions/exceptions.py

@@ -0,0 +1,2 @@
+class ValidationError(Exception):
+    pass

functions/accounts/get_account_transactions/get_account_transactions/transaction_helpers.py

@@ -0,0 +1,35 @@
+from aws_lambda_powertools import Logger
+from boto3.dynamodb.conditions import Key
+
+from . import date_helpers
+
+
+def query_transactions(
+    table,
+    account_id: str,
+    logger: Logger,
+    period: str = None,
+    start: str = None,
+    end: str = None,
+    descending=False,
+):
+    statement_period, start_iso, end_iso = date_helpers.get_date_range(
+        period, start, end
+    )
+
+    logger.info(
+        f"Querying transactions for account {account_id} "
+        f"from {start_iso} to {end_iso} (period {statement_period})"
+    )
+
+    response = table.query(
+        IndexName="AccountDateIndex",
+        KeyConditionExpression=Key("accountId").eq(account_id)
+        & Key("createdAt").between(start_iso, end_iso),
+        ScanIndexForward=not descending,
+    )
+
+    return {
+        "statementPeriod": statement_period,
+        "transactions": response.get("Items", []),
+    }

functions/accounts/get_account_transactions/requirements.txt

@@ -0,0 +1,2 @@
+aws_lambda_powertools==3.17.0
+boto3==1.38.13

functions/accounts/get_accounts/requirements.txt

@@ -1,2 +1,2 @@
-aws_lambda_powertools==3.12.0
+aws_lambda_powertools==3.17.0
 boto3==1.38.13

functions/auth/requirements.txt

@@ -1,2 +1,2 @@
-aws_lambda_powertools==3.12.0
+aws_lambda_powertools==3.17.0
 boto3==1.38.13

functions/cognito/post_sign_up/requirements.txt

@@ -1,2 +1,2 @@
-aws_lambda_powertools==3.12.0
+aws_lambda_powertools==3.17.0
 boto3==1.38.13

functions/monthly_reports/accounts/create_report/create_report/app.py

@@ -0,0 +1,78 @@
+import os
+
+from aws_lambda_powertools import Logger
+from aws_lambda_powertools.utilities.typing import LambdaContext
+from botocore.exceptions import ClientError
+
+from .exceptions import ReportGenerationError, ReportTemplateError, ReportUploadError
+from s3 import get_s3_client
+from .generate_pdf import generate_transactions_pdf
+
+REPORTS_BUCKET = os.environ.get("REPORTS_BUCKET")
+POWERTOOLS_LOG_LEVEL = os.environ.get("POWERTOOLS_LOG_LEVEL")
+AWS_REGION = os.environ.get("AWS_REGION")
+
+logger = Logger(service="CreateAccountsReport", level=POWERTOOLS_LOG_LEVEL)
+
+s3 = get_s3_client(AWS_REGION, logger)
+
+
+def lambda_handler(event, _context: LambdaContext):
+    logger.info(f"Received event: {event}")
+
+    try:
+        required = [
+            "accountId",
+            "userId",
+            "statementPeriod",
+            "transactions",
+            "accountBalance",
+        ]
+        missing = [k for k in required if k not in event]
+
+        if missing:
+            logger.error(f"Missing required fields: {missing}")
+            raise ReportGenerationError(f"Invalid event: missing {missing}")
+
+        # Generate PDF
+        pdf_bytes = generate_transactions_pdf(event=event, logger=logger)
+
+        logger.info("PDF generated successfully")
+
+        # Store in S3
+        s3_key = f"{event['accountId']}/{event['statementPeriod']}.pdf"
+        try:
+            s3.put_object(
+                Bucket=REPORTS_BUCKET,
+                Key=s3_key,
+                Body=pdf_bytes,
+                ContentType="application/pdf",
+            )
+        except ClientError as e:
+            logger.exception("Failed to upload report to S3")
+            raise ReportUploadError(f"S3 upload failed: {str(e)}") from e
+
+        logger.info("Generating PDF uploaded to S3")
+
+        try:
+            presigned_url = s3.generate_presigned_url(
+                "get_object",
+                Params={"Bucket": REPORTS_BUCKET, "Key": s3_key},
+                ExpiresIn=3600,
+            )
+        except ClientError as e:
+            logger.exception("Failed to generate presigned URL")
+            raise ReportUploadError(f"Presigned URL generation failed: {str(e)}") from e
+
+        logger.info("Presigned URL generated successfully")
+
+        return {
+            "reportUrl": presigned_url,
+            "accountId": event["accountId"],
+            "userId": event["userId"],
+            "statementPeriod": event["statementPeriod"],
+        }
+
+    except (ReportGenerationError, ReportTemplateError, ReportUploadError):
+        logger.exception("Report generation failed")
+        raise

functions/monthly_reports/accounts/create_report/create_report/exceptions.py

@@ -0,0 +1,10 @@
+class ReportGenerationError(Exception):
+    """Raised when PDF generation fails."""
+
+
+class ReportTemplateError(Exception):
+    """Raised when the Jinja2 template is missing or invalid."""
+
+
+class ReportUploadError(Exception):
+    """Raised when uploading to S3 fails."""

functions/monthly_reports/accounts/create_report/create_report/generate_pdf.py

@@ -0,0 +1,44 @@
+import io
+import os
+from datetime import datetime, timezone
+
+from aws_lambda_powertools import Logger
+from jinja2 import Environment, FileSystemLoader, TemplateNotFound, select_autoescape
+from xhtml2pdf import pisa
+
+from .exceptions import ReportGenerationError, ReportTemplateError
+
+
+def generate_transactions_pdf(event: dict, logger: Logger) -> bytes:
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    env = Environment(
+        loader=FileSystemLoader(current_dir),
+        autoescape=select_autoescape(["html", "xml"]),
+    )
+
+    try:
+        template = env.get_template("template.html")
+    except TemplateNotFound as e:
+        logger.error("Template 'template.html' not found")
+        raise ReportTemplateError("Missing template: template.html") from e
+
+    html_out = template.render(
+        accountId=event["accountId"],
+        statementPeriod=event["statementPeriod"],
+        transactions=event["transactions"],
+        accountBalance=event["accountBalance"],
+        generationDate=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC"),
+    )
+
+    pdf_buffer = io.BytesIO()
+    pisa_status = pisa.CreatePDF(io.StringIO(html_out), dest=pdf_buffer)
+
+    if pisa_status.err:
+        logger.error("xhtml2pdf failed to generate PDF")
+        raise ReportGenerationError("Error generating PDF")
+
+    pdf_buffer.seek(0)
+    pdf_bytes = pdf_buffer.getvalue()
+
+    logger.debug("PDF generated (%d bytes).", len(pdf_bytes))
+    return pdf_bytes