enrollment to PF

enrollments-events/app/events/enroll.py

@@ -0,0 +1,97 @@
+from uuid import uuid4
+
+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 glom import glom
+from layercake.dateutils import now
+from layercake.dynamodb import (
+    DynamoDBPersistenceLayer,
+    KeyChain,
+    KeyPair,
+    SortKey,
+    TransactKey,
+)
+
+from boto3clients import dynamodb_client
+from config import COURSE_TABLE, ENROLLMENT_TABLE, ORDER_TABLE
+from enrollment import DeduplicationWindow, LinkedEntity, enroll
+from schemas import Course, Enrollment, User
+
+logger = Logger(__name__)
+order_layer = DynamoDBPersistenceLayer(ORDER_TABLE, dynamodb_client)
+course_layer = DynamoDBPersistenceLayer(COURSE_TABLE, dynamodb_client)
+enrollment_layer = DynamoDBPersistenceLayer(ENROLLMENT_TABLE, dynamodb_client)
+
+
+@event_source(data_class=EventBridgeEvent)
+@logger.inject_lambda_context
+def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> list[str]:
+    new_image = event.detail['new_image']
+    now_ = now()
+    order_id = new_image['id']
+    order = order_layer.collection.get_items(
+        TransactKey(order_id) + SortKey('0') + SortKey('items', path_spec='items'),
+    )
+    items = {
+        item['id']: int(item['quantity'])
+        for item in order['items']
+        # Ignore items with non-positive unit price;
+        # negative values are treated as discounts
+        if item['unit_price'] > 0
+    }
+
+    result = order_layer.collection.query(KeyPair(order_id, 'assignees#'))
+    user_id = glom(result, 'items.0.sk').removeprefix('assignees#')
+
+    courses = _get_courses(set(items.keys()))
+    user = User(
+        id=user_id,
+        name=order['name'],
+        email=order['email'],
+        cpf=order['cpf'],
+    )
+
+    ids = []
+
+    for course in courses:
+        enrollment = Enrollment(
+            id=uuid4(),
+            user=user,
+            course=course,
+        )
+        enroll(
+            enrollment,
+            persistence_layer=enrollment_layer,
+            deduplication_window=DeduplicationWindow(offset_days=90),
+            linked_entities=frozenset({LinkedEntity(order_id, 'ORDER')}),
+        )
+        ids.append(enrollment.id)
+
+    order_layer.update_item(
+        key=KeyPair(new_image['id'], new_image['sk']),
+        update_expr='SET #status = :status, updated_at = :updated_at',
+        expr_attr_names={
+            '#status': 'status',
+        },
+        expr_attr_values={
+            ':status': 'SUCCESS',
+            ':updated_at': now_,
+        },
+        cond_expr='attribute_exists(sk)',
+    )
+
+    return ids
+
+
+def _get_courses(ids: set) -> tuple[Course, ...]:
+    pairs = tuple(KeyPair(idx, '0') for idx in ids)
+    result = course_layer.collection.get_items(
+        KeyChain(pairs),
+        flatten_top=False,
+    )
+    courses = tuple(Course(id=idx, **obj) for idx, obj in result.items())  # type: ignore
+    return courses

enrollments-events/app/events/stopgap/patch_enroll.py

@@ -29,30 +29,35 @@ enrollment_layer = DynamoDBPersistenceLayer(ENROLLMENT_TABLE, dynamodb_client)
 def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> bool:
     new_image = event.detail['new_image']
     now_ = now()
-    course = _get_course(new_image['course']['id'])
 
-    with enrollment_layer.transact_writer() as transact:
-        transact.put(
-            item={
-                'id': new_image['id'],
-                'sk': 'metadata#deduplication_window',
-                'offset_days': 90,
-                'created_at': now_,
-            }
-        )
-        transact.put(
-            item={
-                'id': new_image['id'],
-                'sk': 'metadata#course',
-                'created_at': now_,
-                'access_period': int(course['access_period']),
-                'cert': {
-                    'exp_interval': int(course['cert']['exp_interval']),
-                },
-            }
-        )
+    try:
+        course = _get_course(new_image['course']['id'])
 
-    return True
+        with enrollment_layer.transact_writer() as transact:
+            transact.put(
+                item={
+                    'id': new_image['id'],
+                    'sk': 'metadata#deduplication_window',
+                    'offset_days': 90,
+                    'created_at': now_,
+                }
+            )
+            transact.put(
+                item={
+                    'id': new_image['id'],
+                    'sk': 'metadata#course',
+                    'created_at': now_,
+                    'access_period': int(course['access_period']),
+                    'cert': {
+                        'exp_interval': int(course['cert']['exp_interval']),
+                    },
+                }
+            )
+    except Exception as exc:
+        logger.exception(exc)
+        return False
+    else:
+        return True
 
 
 class CourseNotFoundError(Exception):

enrollments-events/app/events/stopgap/patch_konviva.py

@@ -50,6 +50,8 @@ def lambda_handler(event: EventBridgeEvent, context: LambdaContext) -> bool:
         flatten_top=False,
     )
 
+    # If `class_id` is not found, try to retrieve it from the SQLite
+    # migration database.
     if 'class_id' not in data:
         data['class_id'] = _get_class_id(course_id)
 
@@ -72,6 +74,7 @@ class CourseNotFoundError(Exception):
         super().__init__('Course not found')
 
 
+# Post-migration: remove the following function
 def _get_class_id(course_id: str) -> int:
     with sqlite3.connect(
         database=SQLITE_DATABASE, detect_types=sqlite3.PARSE_DECLTYPES
@@ -84,4 +87,5 @@ def _get_class_id(course_id: str) -> int:
         for row in rows:
             return int(row['json']['metadata__konviva_id'])
 
+    logger.error('Course not found', course_id=course_id)
     raise CourseNotFoundError