Back-End Developer Onboading Information

[atompie]

Project Structure

Tracardi has the following structure.

The whole application is in app folder. Inside app folder you will find api, domain, exceptions, event_server, service, process_engine.

Api folder

Inside API folder you will find all endpoints that are exposed to fastApi. These files should be very light. No big logic inside.

For example a simple CRUD endpoint should look like this.

from fastapi import APIRouter
from fastapi import HTTPException, Depends

from .auth.authentication import get_current_user
from ..domain.consent import Consent

router = APIRouter(
    dependencies=[Depends(get_current_user)]
)


@router.get("/consent")
async def get_consent(id: str):
    try:
        consent = Consent(id=id)
        return await consent.storage().load()
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/consent")
async def add_consent(consent: Consent):
    try:
        return await consent.storage().save()
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.put("/consent")
async def update_consent(consent: Consent):
    try:
        return await consent.storage().save()
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.delete("/consent")
async def delete_consent(id: str):
    try:
        consent = Consent(id=id)
        return await consent.storage().delete()
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

This is authenticated endpoint that starts with "/consent" and for every CRUD operation it has simple one line logic.

Authentication

This forces authentication requirement on an Endpoint

router = APIRouter(
    dependencies=[Depends(get_current_user)]
)

REST endpoints

Example of POST:

   # try:
        return await consent.storage().save()
   # except Exception as e:
   #     raise HTTPException(status_code=500, detail=str(e))

Logic inside endpoints must refer to handling how data is served not business logic. The logic for saving objects or other business actions is inside domain, or service folder.

The rest of the method is just HTTP error handling.

Domain folder

Domain folder consists of objects that represent the domain of Tracardi. That is: profile, session, etc.

These object define data and methods for processing this data. These are pydantic objects. See https://pydantic-docs.helpmanual.io/ for more information.

class Profile(Entity):
    metadata: Optional[Metadata]   # this defines profile metadata, etc.
    stats: ProfileStats = ProfileStats()
    properties: Optional[ProfileProperties] = ProfileProperties()
    segments: Optional[list] = []  # this defines profile segments, etc
    consents: Optional[dict] = {}

If object has some logic it should be inside domain object.