wip reporting

order-events/app/events/append_org_id.py

@@ -49,6 +49,8 @@ def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> bool:
         transact.update(
             key=KeyPair(new_image['id'], '0'),
             update_expr='SET tenant_id = :org_id, updated_at = :updated_at',
+            # Post-migration: uncomment the following line
+            # update_expr='SET org_id = :org_id, updated_at = :updated_at',
             expr_attr_values={
                 ':org_id': data['org_id'],
                 ':updated_at': now_,

order-events/app/events/reporting/add_item.py

@@ -0,0 +1,125 @@
+from datetime import datetime, time, timedelta
+
+from aws_lambda_powertools import Logger
+from aws_lambda_powertools.utilities.data_classes import (
+    EventBridgeEvent,
+    event_source,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+from layercake.dateutils import now, ttl
+from layercake.dynamodb import (
+    DynamoDBPersistenceLayer,
+    KeyPair,
+    SortKey,
+    TransactKey,
+)
+from layercake.funcs import pick
+
+from boto3clients import dynamodb_client
+from config import COURSE_TABLE, ENROLLMENT_TABLE, ORDER_TABLE
+from utils import get_billing_period
+
+logger = Logger(__name__)
+order_layer = DynamoDBPersistenceLayer(ORDER_TABLE, dynamodb_client)
+enrollment_layer = DynamoDBPersistenceLayer(ENROLLMENT_TABLE, dynamodb_client)
+course_layer = DynamoDBPersistenceLayer(COURSE_TABLE, dynamodb_client)
+
+
+@event_source(data_class=EventBridgeEvent)
+@logger.inject_lambda_context
+def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> bool:
+    new_image = event.detail['new_image']
+    now_ = now()
+    enrollment_id = new_image['id']
+    org_id = new_image['org_id']
+    data = enrollment_layer.collection.get_items(
+        TransactKey(enrollment_id) + SortKey('0') + SortKey('author')
+    )
+
+    if not data:
+        logger.debug('Enrollment not found')
+        return False
+
+    start_date, end_date = get_billing_period(new_image['billing_day'])
+    pk = 'BILLING#ORG#{org_id}'.format(org_id=org_id)
+    sk = 'START#{start}#END#{end}'.format(
+        start=start_date.isoformat(),
+        end=end_date.isoformat(),
+    )
+
+    try:
+        with order_layer.transact_writer() as transact:
+            transact.put(
+                item={
+                    'id': pk,
+                    'sk': sk,
+                    'status': 'PENDING',
+                    'created_at': now_,
+                },
+                cond_expr='attribute_not_exists(sk)',
+                exc_cls=ExistingBillingConflictError,
+            )
+            transact.put(
+                item={
+                    'id': pk,
+                    'sk': f'{sk}#SCHEDULE#AUTO_CLOSE',
+                    'ttl': ttl(
+                        start_dt=datetime.combine(end_date, time()) + timedelta(days=1)
+                    ),
+                    'created_at': now_,
+                }
+            )
+    except ExistingBillingConflictError:
+        pass
+
+    try:
+        with order_layer.transact_writer() as transact:
+            author = data['author']
+            course_id = data['course']['id']
+            course = course_layer.collection.get_items(
+                KeyPair(
+                    pk=course_id,
+                    sk=SortKey('0', path_spec='metadata__unit_price'),
+                    rename_key='unit_price',
+                )
+                + KeyPair(
+                    pk=f'CUSTOM_PRICING#ORG#{org_id}',
+                    sk=SortKey(f'COURSE#{course_id}', path_spec='unit_price'),
+                    rename_key='unit_price',
+                ),
+                flatten_top=False,
+            )
+
+            transact.condition(
+                key=KeyPair(pk, sk),
+                cond_expr='attribute_exists(sk)',
+                exc_cls=BillingNotFoundError,
+            )
+            transact.put(
+                item={
+                    'id': pk,
+                    'sk': f'{sk}#ENROLLMENT#{enrollment_id}',
+                    'user': pick(('id', 'name'), data['user']),
+                    'course': pick(('id', 'name'), data['course']),
+                    'unit_price': course['unit_price'],
+                    'author': {
+                        'id': author['user_id'],
+                        'name': author['name'],
+                    },
+                    # Post-migration: uncomment the following line
+                    # 'enrolled_at': data['created_at'],
+                    'enrolled_at': data['create_date'],
+                    'created_at': now_,
+                },
+                cond_expr='attribute_not_exists(sk)',
+            )
+    except Exception:
+        return False
+    else:
+        return True
+
+
+class ExistingBillingConflictError(Exception): ...
+
+
+class BillingNotFoundError(Exception): ...

order-events/app/events/set_as_expired.py

@@ -1,64 +0,0 @@
-from aws_lambda_powertools import Logger
-from aws_lambda_powertools.utilities.data_classes import (
-    EventBridgeEvent,
-    event_source,
-)
-from aws_lambda_powertools.utilities.typing import LambdaContext
-from layercake.dateutils import now
-from layercake.dynamodb import (
-    DynamoDBPersistenceLayer,
-    KeyPair,
-)
-
-from boto3clients import dynamodb_client
-from config import ORDER_TABLE
-
-logger = Logger(__name__)
-order_layer = DynamoDBPersistenceLayer(ORDER_TABLE, dynamodb_client)
-
-
-@event_source(data_class=EventBridgeEvent)
-@logger.inject_lambda_context
-def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> bool:
-    """Set the order status to `EXPIRED` 24 hours after it becomes overdue."""
-    new_image = event.detail['new_image']
-    now_ = now()
-    sk = new_image['sk']
-
-    try:
-        order_layer.update_item(
-            key=KeyPair(new_image['id'], '0'),
-            update_expr='SET #status = :expired, updated_at = :updated_at',
-            cond_expr='#status IN (:pending) and payment_method = :payment_method',
-            expr_attr_names={
-                '#status': 'status',
-            },
-            expr_attr_values={
-                ':expired': 'EXPIRED',
-                ':pending': 'PENDING',
-                ':payment_method': 'MANUAL',
-                ':updated_at': now_,
-            },
-        )
-    except Exception:
-        logger.info('Failed to update status to EXPIRED', order_id=new_image['id'])
-        order_layer.put_item(
-            item={
-                'id': new_image['id'],
-                'sk': f'{sk}#failed',
-                'created_at': now_,
-            }
-        )
-
-        return False
-    else:
-        logger.info('Status set to EXPIRED', order_id=new_image['id'])
-        order_layer.put_item(
-            item={
-                'id': new_image['id'],
-                'sk': f'{sk}#executed',
-                'created_at': now_,
-            }
-        )
-
-        return True

order-events/app/events/stopgap/schedule_expired.py

@@ -1,38 +0,0 @@
-from datetime import timedelta
-
-from aws_lambda_powertools import Logger
-from aws_lambda_powertools.utilities.data_classes import (
-    EventBridgeEvent,
-    event_source,
-)
-from aws_lambda_powertools.utilities.typing import LambdaContext
-from layercake.dateutils import fromisoformat, now, ttl
-from layercake.dynamodb import (
-    DynamoDBPersistenceLayer,
-)
-
-from boto3clients import dynamodb_client
-from config import ORDER_TABLE
-
-logger = Logger(__name__)
-order_layer = DynamoDBPersistenceLayer(ORDER_TABLE, dynamodb_client)
-
-
-@event_source(data_class=EventBridgeEvent)
-@logger.inject_lambda_context
-def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> bool:
-    new_image = event.detail['new_image']
-    due_date = fromisoformat(new_image['due_date'])
-    now_ = now()
-
-    if not due_date:
-        return False
-
-    return order_layer.put_item(
-        item={
-            'id': new_image['id'],
-            'sk': 'schedules#set_as_expired',
-            'ttl': ttl(start_dt=due_date + timedelta(hours=24)),
-            'created_at': now_,
-        }
-    )

order-events/app/utils.py

@@ -0,0 +1,35 @@
+import calendar
+from datetime import date
+
+from layercake.dateutils import now
+
+
+def get_billing_period(
+    billing_day: int,
+    year: int | None = None,
+    month: int | None = None,
+) -> tuple[date, date]:
+    today = now()
+    year_ = year or today.year
+    month_ = month or today.month
+
+    _, last_day = calendar.monthrange(year_, month_)
+    start_day = min(billing_day, last_day)
+    start_date = date(year_, month_, start_day)
+
+    if month_ == 12:
+        next_month = 1
+        next_year = year_ + 1
+    else:
+        next_month = month_ + 1
+        next_year = year_
+
+    _, last_day_next_month = calendar.monthrange(next_year, next_month)
+    end_day = min(billing_day, last_day_next_month) - 1
+
+    if end_day == 0:
+        end_date = date(year_, month_, last_day)
+    else:
+        end_date = date(next_year, next_month, end_day)
+
+    return start_date, end_date