Comprehensive comparison for technology in applications

import json
import boto3
import os
from decimal import Decimal
from datetime import datetime
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ.get('PRODUCTS_TABLE', 'Products'))

class DecimalEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Decimal):
            return float(obj)
        return super(DecimalEncoder, self).default(obj)

def lambda_handler(event, context):
    """
    API Gateway Lambda handler for product management.
    Supports GET, POST, PUT, DELETE operations.
    """
    try:
        http_method = event.get('httpMethod')
        path_parameters = event.get('pathParameters') or {}
        product_id = path_parameters.get('id')
        
        logger.info(f"Processing {http_method} request for product: {product_id}")
        
        if http_method == 'GET':
            if product_id:
                return get_product(product_id)
            else:
                return list_products(event.get('queryStringParameters') or {})
        
        elif http_method == 'POST':
            body = json.loads(event.get('body', '{}'))
            return create_product(body)
        
        elif http_method == 'PUT':
            if not product_id:
                return error_response(400, 'Product ID is required')
            body = json.loads(event.get('body', '{}'))
            return update_product(product_id, body)
        
        elif http_method == 'DELETE':
            if not product_id:
                return error_response(400, 'Product ID is required')
            return delete_product(product_id)
        
        else:
            return error_response(405, 'Method not allowed')
    
    except json.JSONDecodeError:
        return error_response(400, 'Invalid JSON in request body')
    except Exception as e:
        logger.error(f"Error processing request: {str(e)}")
        return error_response(500, 'Internal server error')

def get_product(product_id):
    try:
        response = table.get_item(Key={'productId': product_id})
        if 'Item' not in response:
            return error_response(404, 'Product not found')
        return success_response(response['Item'])
    except Exception as e:
        logger.error(f"Error getting product: {str(e)}")
        return error_response(500, 'Failed to retrieve product')

def list_products(query_params):
    try:
        limit = int(query_params.get('limit', 50))
        response = table.scan(Limit=limit)
        return success_response({
            'products': response.get('Items', []),
            'count': len(response.get('Items', []))
        })
    except Exception as e:
        logger.error(f"Error listing products: {str(e)}")
        return error_response(500, 'Failed to list products')

def create_product(body):
    if not body.get('name') or not body.get('price'):
        return error_response(400, 'Name and price are required')
    
    try:
        product_id = f"prod_{datetime.now().timestamp()}"
        item = {
            'productId': product_id,
            'name': body['name'],
            'price': Decimal(str(body['price'])),
            'description': body.get('description', ''),
            'createdAt': datetime.now().isoformat(),
            'updatedAt': datetime.now().isoformat()
        }
        table.put_item(Item=item)
        return success_response(item, status_code=201)
    except Exception as e:
        logger.error(f"Error creating product: {str(e)}")
        return error_response(500, 'Failed to create product')

def update_product(product_id, body):
    try:
        update_expr = 'SET updatedAt = :updated'
        expr_values = {':updated': datetime.now().isoformat()}
        expr_names = {}
        
        if 'name' in body:
            update_expr += ', #n = :name'
            expr_values[':name'] = body['name']
            expr_names['#n'] = 'name'
        if 'price' in body:
            update_expr += ', price = :price'
            expr_values[':price'] = Decimal(str(body['price']))
        if 'description' in body:
            update_expr += ', description = :desc'
            expr_values[':desc'] = body['description']
        
        response = table.update_item(
            Key={'productId': product_id},
            UpdateExpression=update_expr,
            ExpressionAttributeValues=expr_values,
            ExpressionAttributeNames=expr_names if expr_names else None,
            ReturnValues='ALL_NEW'
        )
        return success_response(response['Attributes'])
    except Exception as e:
        logger.error(f"Error updating product: {str(e)}")
        return error_response(500, 'Failed to update product')

def delete_product(product_id):
    try:
        table.delete_item(Key={'productId': product_id})
        return success_response({'message': 'Product deleted successfully'})
    except Exception as e:
        logger.error(f"Error deleting product: {str(e)}")
        return error_response(500, 'Failed to delete product')

def success_response(data, status_code=200):
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS'
        },
        'body': json.dumps(data, cls=DecimalEncoder)
    }

def error_response(status_code, message):
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        'body': json.dumps({'error': message})
    }