fix

http-api/app/routes/courses/__init__.py

@@ -0,0 +1,97 @@
+from http import HTTPStatus
+
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import NotFoundError
+from layercake.dynamodb import DynamoDBCollection, DynamoDBPersistenceLayer, KeyPair
+from meilisearch import Client as Meilisearch
+
+from api_gateway import JSONResponse
+from boto3clients import dynamodb_client
+from conf import (
+    COURSE_TABLE,
+    MEILISEARCH_API_KEY,
+    MEILISEARCH_HOST,
+    USER_TABLE,
+)
+from middlewares import AuditLogMiddleware, Tenant, TenantMiddleware
+from models import Course, Org
+from rules.course import create_course, update_course
+
+router = Router()
+
+meili_client = Meilisearch(MEILISEARCH_HOST, MEILISEARCH_API_KEY)
+course_layer = DynamoDBPersistenceLayer(COURSE_TABLE, dynamodb_client)
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer)
+course_collect = DynamoDBCollection(course_layer)
+
+
+@router.get(
+    '/',
+    compress=True,
+    tags=['Course'],
+    summary='Get courses',
+)
+def get_courses():
+    event = router.current_event
+    query = event.get_query_string_value('query', '')
+    sort = event.get_query_string_value('sort', 'create_date:desc')
+    page = int(event.get_query_string_value('page', '1'))
+    hits_per_page = int(event.get_query_string_value('hitsPerPage', '25'))
+
+    return meili_client.index(COURSE_TABLE).search(
+        query,
+        {
+            'sort': [sort],
+            'locales': ['pt'],
+            'page': page,
+            'hitsPerPage': hits_per_page,
+        },
+    )
+
+
+@router.post(
+    '/',
+    compress=True,
+    tags=['Course'],
+    middlewares=[
+        TenantMiddleware(user_collect),
+        AuditLogMiddleware('COURSE_ADD', user_collect, ('id', 'name')),
+    ],
+)
+def post_course(payload: Course):
+    tenant: Tenant = router.context['tenant']
+    create_course(
+        payload,
+        Org(id=tenant.id, name=tenant.name),
+        persistence_layer=course_layer,
+    )
+    return JSONResponse(
+        body=payload,
+        status_code=HTTPStatus.CREATED,
+    )
+
+
+@router.get('/<id>', compress=True, tags=['Course'])
+def get_course(id: str):
+    return course_collect.get_item(
+        KeyPair(id, '0'),
+        exception_cls=NotFoundError,
+    )
+
+
+@router.put(
+    '/<id>',
+    compress=True,
+    tags=['Course'],
+    middlewares=[
+        TenantMiddleware(user_collect),
+        AuditLogMiddleware('COURSE_UPDATE', user_collect, ('id', 'name')),
+    ],
+)
+def put_course(id: str, payload: Course):
+    update_course(id, payload, persistence_layer=course_layer)
+    return JSONResponse(
+        body=payload,
+        status_code=HTTPStatus.OK,
+    )

http-api/app/routes/enrollments/__init__.py

@@ -0,0 +1,99 @@
+import json
+
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from elasticsearch import Elasticsearch
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    KeyPair,
+    SortKey,
+    TransactKey,
+)
+from pydantic import UUID4, BaseModel
+
+from boto3clients import dynamodb_client
+from conf import ELASTIC_CONN, ENROLLMENT_TABLE, USER_TABLE
+import elastic
+from middlewares.audit_log_middleware import AuditLogMiddleware
+from middlewares.authentication_middleware import User
+from rules.enrollment import set_status_as_canceled
+
+from .vacancies import router as vacancies
+
+__all__ = ['vacancies']
+
+
+router = Router()
+elastic_client = Elasticsearch(**ELASTIC_CONN)
+enrollment_layer = DynamoDBPersistenceLayer(ENROLLMENT_TABLE, dynamodb_client)
+enrollment_collect = DynamoDBCollection(enrollment_layer)
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer)
+
+
+@router.get('/', compress=True, tags=['Enrollment'])
+def get_enrollments():
+    event = router.current_event
+    query = event.get_query_string_value('query', '{}')
+    page_size = event.get_query_string_value('page_size', '25')
+
+    return elastic.search(  # type: ignore
+        index=ENROLLMENT_TABLE,
+        page_size=int(page_size),
+        query=json.loads(query),
+        elastic_client=elastic_client,
+    )
+
+
+@router.get('/<id>', compress=True, tags=['Enrollment'])
+def get_enrollment(id: str):
+    return enrollment_collect.get_items(
+        TransactKey(id)
+        + SortKey('0')
+        + SortKey('started_date')
+        + SortKey('finished_date')
+        + SortKey('failed_date')
+        + SortKey('canceled_date')
+        + SortKey('archived_date')
+        + SortKey('cancel_policy')
+        + SortKey('parent_vacancy', path_spec='vacancy')
+        + SortKey('lock', path_spec='hash')
+        + SortKey('author')
+        + SortKey('tenant')
+        + SortKey('cert')
+    )
+
+
+class Cancel(BaseModel):
+    id: UUID4 | str
+    lock_hash: str
+    course: dict = {}
+    vacancy: dict = {}
+
+
+@router.patch(
+    '/<id>/cancel',
+    compress=True,
+    tags=['Enrollment'],
+    middlewares=[
+        AuditLogMiddleware('ENROLLMENT_CANCEL', user_collect, ('id', 'course'))
+    ],
+)
+def cancel(id: str, payload: Cancel):
+    user: User = router.context['user']
+
+    set_status_as_canceled(
+        id,
+        lock_hash=payload.lock_hash,
+        author=user.model_dump(),  # type: ignore
+        course=payload.course,  # type: ignore
+        vacancy_key=KeyPair.parse_obj(payload.vacancy),
+        persistence_layer=enrollment_layer,
+    )
+
+    return payload
+
+
+@router.post('/', compress=True, tags=['Enrollment'])
+def enroll():
+    return {}

http-api/app/routes/enrollments/vacancies.py

@@ -0,0 +1,37 @@
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from layercake.dynamodb import (
+    ComposeKey,
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    PartitionKey,
+)
+
+from boto3clients import dynamodb_client
+from conf import (
+    ENROLLMENT_TABLE,
+    USER_TABLE,
+)
+from middlewares import Tenant, TenantMiddleware
+
+router = Router()
+
+enrollment_layer = DynamoDBPersistenceLayer(ENROLLMENT_TABLE, dynamodb_client)
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer)
+enrollment_collect = DynamoDBCollection(enrollment_layer)
+
+
+@router.get(
+    '/vacancies',
+    compress=True,
+    tags=['Enrollment'],
+    middlewares=[
+        TenantMiddleware(user_collect),
+    ],
+)
+def get_vacancies():
+    tenant: Tenant = router.context['tenant']
+
+    return enrollment_collect.query(
+        PartitionKey(ComposeKey(str(tenant.id), prefix='vacancies'))
+    )

http-api/app/routes/lookup/__init__.py

@@ -0,0 +1,32 @@
+from http import HTTPStatus
+
+from aws_lambda_powertools.event_handler import Response, content_types
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from elasticsearch import Elasticsearch
+from elasticsearch_dsl import Search
+from layercake.funcs import pick
+
+from conf import ELASTIC_CONN, USER_TABLE
+
+router = Router()
+elastic_client = Elasticsearch(**ELASTIC_CONN)
+
+
+@router.get('/<username>', include_in_schema=False)
+def lookup(username: str):
+    s = Search(using=elastic_client, index=USER_TABLE).query(
+        'bool',
+        should=[
+            {'term': {'email.keyword': username}},
+            {'term': {'cpf.keyword': username}},
+        ],
+        minimum_should_match=1,
+    )
+
+    for hit in s.execute():
+        return pick(('id', 'name', 'email', 'cognito:sub'), hit.to_dict())
+
+    return Response(
+        content_type=content_types.APPLICATION_JSON,
+        status_code=HTTPStatus.NOT_FOUND,
+    )

http-api/app/routes/orders/__init__.py

@@ -0,0 +1,45 @@
+import json
+
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import (
+    BadRequestError,
+)
+from elasticsearch import Elasticsearch
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    KeyPair,
+)
+
+from boto3clients import dynamodb_client
+from conf import ELASTIC_CONN, ORDER_TABLE
+import elastic
+
+router = Router()
+order_layer = DynamoDBPersistenceLayer(ORDER_TABLE, dynamodb_client)
+order_collect = DynamoDBCollection(order_layer, exception_cls=BadRequestError)
+elastic_client = Elasticsearch(**ELASTIC_CONN)
+
+
+@router.get('/', compress=True, tags=['Order'])
+def get_orders():
+    event = router.current_event
+    query = event.get_query_string_value('query', '{}')
+    page_size = event.get_query_string_value('page_size', '25')
+
+    return elastic.search(  # type: ignore
+        index=ORDER_TABLE,
+        page_size=int(page_size),
+        query=json.loads(query),
+        elastic_client=elastic_client,
+    )
+
+
+@router.get(
+    '/<id>',
+    compress=True,
+    tags=['Order'],
+    summary='Get order',
+)
+def get_order(id: str):
+    return order_collect.get_item(KeyPair(id, '0'))

http-api/app/routes/orgs/__init__.py

@@ -0,0 +1,3 @@
+from .policies import router as policies
+
+__all__ = ['policies']

http-api/app/routes/orgs/policies.py

@@ -0,0 +1,69 @@
+from http import HTTPStatus
+from typing import Literal
+
+from aws_lambda_powertools.event_handler import Response, content_types
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import (
+    BadRequestError,
+)
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    SortKey,
+    TransactKey,
+)
+from pydantic.main import BaseModel
+
+from boto3clients import dynamodb_client
+from conf import USER_TABLE
+from rules.org import update_policies
+
+router = Router()
+org_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+org_collect = DynamoDBCollection(org_layer, exception_cls=BadRequestError)
+
+
+@router.get(
+    '/<id>/policies',
+    compress=True,
+    tags=['Organization'],
+    summary='Get organization policies',
+)
+def get_policies(id: str):
+    return org_collect.get_items(
+        TransactKey(id) + SortKey('billing_policy') + SortKey('payment_policy'),
+        flatten_top=False,
+    )
+
+
+class BillingPolicy(BaseModel):
+    billing_day: int
+    payment_method: Literal['PIX', 'BANK_SLIP', 'MANUAL']
+
+
+class PaymentPolicy(BaseModel):
+    due_days: int
+
+
+class Policies(BaseModel):
+    billing_policy: BillingPolicy | None = None
+    payment_policy: PaymentPolicy | None = None
+
+
+@router.put('/<id>/policies', compress=True, tags=['Organization'])
+def put_policies(id: str, payload: Policies):
+    payment_policy = payload.payment_policy
+    billing_policy = payload.billing_policy
+
+    update_policies(
+        id,
+        payment_policy=payment_policy.model_dump() if payment_policy else {},
+        billing_policy=billing_policy.model_dump() if billing_policy else {},
+        persistence_layer=org_layer,
+    )
+
+    return Response(
+        body=payload,
+        content_type=content_types.APPLICATION_JSON,
+        status_code=HTTPStatus.OK,
+    )

http-api/app/routes/settings/__init__.py

@@ -0,0 +1,46 @@
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    KeyPair,
+    PrefixKey,
+)
+
+from boto3clients import dynamodb_client
+from conf import USER_TABLE
+import konviva
+from middlewares import User
+
+router = Router()
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer)
+
+
+LIMIT = 25
+
+
+@router.get('/', include_in_schema=False)
+def settings():
+    user: User = router.context['user']
+    acls = user_collect.query(
+        KeyPair(user.id, PrefixKey('acls')),
+        limit=LIMIT,
+    )
+    tenants = user_collect.query(
+        KeyPair(user.id, PrefixKey('orgs')),
+        limit=LIMIT,
+    )
+
+    return {
+        'acls': acls['items'],
+        # Note: Ensure compatibility with search on React's tenant menu
+        'tenants': [x | {'id': x['sk'], 'sk': '0'} for x in tenants['items']],
+    }
+
+
+@router.get('/konviva', include_in_schema=False)
+def konviva_():
+    user: User = router.context['user']
+    token = konviva.token(user.email)
+
+    return {'redirect_uri': konviva.redirect_uri(token)}

http-api/app/routes/users/__init__.py

@@ -0,0 +1,147 @@
+from http import HTTPStatus
+import json
+from typing import Annotated
+
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import (
+    BadRequestError as PowertoolsBadRequestError,
+)
+from elasticsearch import Elasticsearch
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    MissingError,
+    SortKey,
+    TransactKey,
+)
+from layercake.extra_types import CpfStr, NameStr
+from pydantic import UUID4, BaseModel, StringConstraints
+
+from api_gateway import JSONResponse
+from boto3clients import dynamodb_client, idp_client
+import cognito
+from conf import ELASTIC_CONN, USER_POOOL_ID, USER_TABLE
+import elastic
+from middlewares import AuditLogMiddleware
+from models import User
+from rules.user import update_user
+
+from .emails import router as emails
+from .logs import router as logs
+from .orgs import router as orgs
+
+__all__ = ['logs', 'emails', 'orgs']
+
+
+class BadRequestError(MissingError, PowertoolsBadRequestError):
+    pass
+
+
+router = Router()
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer, exception_cls=BadRequestError)
+elastic_client = Elasticsearch(**ELASTIC_CONN)
+
+
+@router.get('/', compress=True, tags=['User'], summary='Get users')
+def get_users():
+    event = router.current_event
+    query = event.get_query_string_value('query', '{}')
+    page_size = event.get_query_string_value('page_size', '25')
+
+    return elastic.search(
+        index=USER_TABLE,
+        page_size=int(page_size),
+        query=json.loads(query),
+        elastic_client=elastic_client,
+    )
+
+
+@router.post(
+    '/',
+    compress=True,
+    tags=['User'],
+    summary='Create user',
+    middlewares=[AuditLogMiddleware('USER_ADD', user_collect)],
+)
+def post_user(payload: User):
+    return JSONResponse(status_code=HTTPStatus.CREATED)
+
+
+class UserData(BaseModel):
+    name: NameStr
+    cpf: CpfStr
+
+
+@router.put(
+    '/<id>',
+    compress=True,
+    tags=['User'],
+    summary='Update user',
+    middlewares=[
+        AuditLogMiddleware('USER_UPDATE', user_collect, ('id', 'name', 'new_cpf'))
+    ],
+)
+def put_user(id: str, payload: UserData):
+    update_user(
+        {
+            'id': id,
+            'name': payload.name,
+            'cpf': payload.cpf,
+        },
+        persistence_layer=user_layer,
+    )
+    return JSONResponse(
+        body={
+            'id': id,
+            'name': payload.name,
+            'new_cpf': payload.cpf,
+        },
+        status_code=HTTPStatus.OK,
+    )
+
+
+@router.get('/<id>', compress=True, tags=['User'], summary='Get user')
+def get_user(id: str):
+    return user_collect.get_items(
+        TransactKey(id) + SortKey('0') + SortKey('last_profile_edit')
+    )
+
+
+class Password(BaseModel):
+    cognito_sub: UUID4
+    new_password: Annotated[str, StringConstraints(min_length=6)]
+
+
+@router.post(
+    '/<id>/password',
+    compress=True,
+    tags=['User'],
+    include_in_schema=False,
+    middlewares=[
+        AuditLogMiddleware('PASSWORD_RESET', user_collect, ('id', 'cognito_sub'))
+    ],
+)
+def password(id: str, payload: Password):
+    cognito.admin_set_user_password(
+        username=str(payload.cognito_sub),
+        password=payload.new_password,
+        user_pool_id=USER_POOOL_ID,
+        idp_client=idp_client,
+    )
+    return JSONResponse(
+        body={
+            'id': id,
+            'cognito_sub': payload.cognito_sub,
+        },
+        status_code=HTTPStatus.OK,
+    )
+
+
+@router.get('/<sub>/idp', compress=True, include_in_schema=False)
+def get_idp(sub: str):
+    return cognito.admin_get_user(
+        sub=sub,
+        user_pool_id=USER_POOOL_ID,
+        idp_client=idp_client,
+    )

http-api/app/routes/users/emails.py

@@ -0,0 +1,105 @@
+from http import HTTPStatus
+
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import (
+    BadRequestError as PowertoolsBadRequestError,
+)
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    KeyPair,
+    MissingError,
+    PrefixKey,
+)
+from pydantic import BaseModel, EmailStr
+
+from api_gateway import JSONResponse
+from boto3clients import dynamodb_client
+from conf import USER_TABLE
+from middlewares import AuditLogMiddleware
+from rules.user import add_email, del_email, set_email_as_primary
+
+
+class BadRequestError(MissingError, PowertoolsBadRequestError): ...
+
+
+router = Router()
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer, exception_cls=BadRequestError)
+
+
+@router.get(
+    '/<id>/emails',
+    compress=True,
+    tags=['User'],
+    summary='Get user emails',
+)
+def get_emails(id: str):
+    return user_collect.query(
+        KeyPair(id, PrefixKey('emails')),
+        start_key=router.current_event.get_query_string_value('start_key', None),
+    )
+
+
+class Email(BaseModel):
+    email: EmailStr
+
+
+@router.post(
+    '/<id>/emails',
+    compress=True,
+    tags=['User'],
+    summary='Add user email',
+    middlewares=[AuditLogMiddleware('EMAIL_ADD', user_collect, ('email',))],
+)
+def post_email(id: str, payload: Email):
+    add_email(id, payload.email, persistence_layer=user_layer)
+    return JSONResponse(
+        body=payload,
+        status_code=HTTPStatus.CREATED,
+    )
+
+
+class EmailAsPrimary(BaseModel):
+    new_email: EmailStr
+    old_email: EmailStr
+    email_verified: bool = False
+
+
+@router.patch(
+    '/<id>/emails',
+    compress=True,
+    tags=['User'],
+    summary='Add user email as primary',
+    middlewares=[
+        AuditLogMiddleware(
+            'EMAIL_CHANGE',
+            user_collect,
+            (
+                'new_email',
+                'old_email',
+            ),
+        )
+    ],
+)
+def patch_email(id: str, payload: EmailAsPrimary):
+    set_email_as_primary(
+        id,
+        payload.new_email,
+        payload.old_email,
+        email_verified=payload.email_verified,
+        persistence_layer=user_layer,
+    )
+    return JSONResponse(body=payload, status_code=HTTPStatus.OK)
+
+
+@router.delete(
+    '/<id>/emails',
+    compress=True,
+    tags=['User'],
+    summary='Delete user email',
+    middlewares=[AuditLogMiddleware('EMAIL_DEL', user_collect, ('email',))],
+)
+def delete_email(id: str, payload: Email):
+    del_email(id, payload.email, persistence_layer=user_layer)
+    return payload

http-api/app/routes/users/logs.py

@@ -0,0 +1,41 @@
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import (
+    BadRequestError as PowertoolsBadRequestError,
+)
+from layercake.dynamodb import (
+    ComposeKey,
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    MissingError,
+    PartitionKey,
+)
+
+from boto3clients import dynamodb_client
+from conf import USER_TABLE
+
+from .orgs import router as orgs
+
+__all__ = ['orgs']
+
+
+class BadRequestError(MissingError, PowertoolsBadRequestError): ...
+
+
+router = Router()
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer, exception_cls=BadRequestError)
+
+
+@router.get(
+    '/<id>/logs',
+    compress=True,
+    tags=['User'],
+    summary='Get user logs',
+)
+def get_logs(id: str):
+    return user_collect.query(
+        # Post-migration: uncomment to enable PartitionKey with a composite key (id with `logs` prefix).
+        # PartitionKey(ComposeKey(id, 'logs')),
+        PartitionKey(ComposeKey(id, 'log', delimiter=':')),
+        start_key=router.current_event.get_query_string_value('start_key', None),
+    )

http-api/app/routes/users/orgs.py

@@ -0,0 +1,62 @@
+from http import HTTPStatus
+
+from aws_lambda_powertools.event_handler.api_gateway import Router
+from aws_lambda_powertools.event_handler.exceptions import (
+    BadRequestError as PowertoolsBadRequestError,
+)
+from layercake.dynamodb import (
+    DynamoDBCollection,
+    DynamoDBPersistenceLayer,
+    KeyPair,
+    MissingError,
+    PrefixKey,
+)
+from layercake.extra_types import CnpjStr
+from pydantic import BaseModel
+
+from api_gateway import JSONResponse
+from boto3clients import dynamodb_client
+from conf import USER_TABLE
+from middlewares.audit_log_middleware import AuditLogMiddleware
+from rules.user import del_org_member
+
+
+class BadRequestError(MissingError, PowertoolsBadRequestError): ...
+
+
+router = Router()
+user_layer = DynamoDBPersistenceLayer(USER_TABLE, dynamodb_client)
+user_collect = DynamoDBCollection(user_layer, exception_cls=BadRequestError)
+
+
+@router.get(
+    '/<id>/orgs',
+    compress=True,
+    tags=['User'],
+    summary='Get user orgs',
+)
+def get_orgs(id: str):
+    return user_collect.query(
+        KeyPair(id, PrefixKey('orgs')),
+        start_key=router.current_event.get_query_string_value('start_key', None),
+    )
+
+
+class Unassign(BaseModel):
+    id: str
+    name: str
+    cnpj: CnpjStr
+
+
+@router.delete(
+    '/<id>/orgs',
+    compress=True,
+    tags=['User'],
+    summary='Delete user org',
+    middlewares=[
+        AuditLogMiddleware('UNASSIGN_ORG', user_collect, ('id', 'name', 'cnpj'))
+    ],
+)
+def delete_org(id: str, payload: Unassign):
+    del_org_member(id, org_id=payload.id, persistence_layer=user_layer)
+    return JSONResponse(status_code=HTTPStatus.OK, body=payload)

http-api/app/routes/webhooks/__init__.py

@@ -0,0 +1,8 @@
+from aws_lambda_powertools.event_handler.api_gateway import Router
+
+router = Router()
+
+
+@router.get('/', include_in_schema=False)
+def get_webhooks():
+    return []