feat(course): add purchase course endpoint

Author: Defelo

Cargo.lock

@@ -43,10 +43,10 @@ use academy_extern_impl::{
     render::RenderApiServiceImpl, vat::VatApiServiceImpl,
 };
 use academy_persistence_postgres::{
-    PostgresDatabase, coin::PostgresCoinRepository, heart::PostgresHeartRepository,
-    mfa::PostgresMfaRepository, oauth2::PostgresOAuth2Repository, paypal::PostgresPaypalRepository,
-    premium::PostgresPremiumRepository, session::PostgresSessionRepository,
-    user::PostgresUserRepository,
+    PostgresDatabase, coin::PostgresCoinRepository, course::PostgresCourseRepository,
+    heart::PostgresHeartRepository, mfa::PostgresMfaRepository, oauth2::PostgresOAuth2Repository,
+    paypal::PostgresPaypalRepository, premium::PostgresPremiumRepository,
+    session::PostgresSessionRepository, user::PostgresUserRepository,
 };
 use academy_shared_impl::{
     captcha::CaptchaServiceImpl, fs::FsServiceImpl, hash::HashServiceImpl, id::IdServiceImpl,
@@ -113,6 +113,7 @@ pub type CoinRepo = PostgresCoinRepository;
 pub type PaypalRepo = PostgresPaypalRepository;
 pub type HeartRepo = PostgresHeartRepository;
 pub type PremiumRepo = PostgresPremiumRepository;
+pub type CourseRepo = PostgresCourseRepository;
 
 // Auth
 pub type Auth =
@@ -233,6 +234,6 @@ pub type PremiumPlan = PremiumPlanServiceImpl;
 pub type Premium = PremiumServiceImpl<Time, PremiumPurchase, PremiumRepo>;
 pub type PremiumPurchase = PremiumPurchaseServiceImpl<Id, Time, Coin, PremiumPlan, PremiumRepo>;
 
-pub type CourseFeature = CourseFeatureServiceImpl;
+pub type CourseFeature = CourseFeatureServiceImpl<Database, Auth, Coin, CourseRepo>;
 
 pub type Internal = InternalServiceImpl<Database, AuthInternal, UserRepo, Coin, Heart, Premium>;

Cargo.nix

@@ -1,28 +1,41 @@
 use std::sync::Arc;
 
-use academy_core_course_contracts::CourseFeatureService;
+use academy_core_course_contracts::{CourseFeatureService, CoursePurchaseError};
+use academy_models::course::CourseId;
 use aide::{
     axum::{ApiRouter, routing},
     transform::TransformOperation,
 };
 use axum::{
     Json,
-    extract::{Query, State},
+    extract::{Path, Query, State},
     http::StatusCode,
     response::{IntoResponse, Response},
 };
+use schemars::JsonSchema;
+use serde::Deserialize;
 
 use crate::{
     docs::TransformOperationExt,
-    errors::{internal_server_error, internal_server_error_docs},
-    models::course::{ApiCourseFilter, ApiCourseUserSummary},
+    error_code,
+    errors::{auth_error, auth_error_docs, internal_server_error, internal_server_error_docs},
+    extractors::auth::ApiToken,
+    models::{
+        OkResponse,
+        course::{ApiCourseFilter, ApiCourseUserSummary},
+    },
+    routes::coin::NotEnoughCoinsError,
 };
 
 pub const TAG: &str = "Courses";
 
 pub fn router(service: Arc<impl CourseFeatureService>) -> ApiRouter<()> {
     ApiRouter::new()
         .api_route("/skills/courses", routing::get_with(list, list_docs))
+        .api_route(
+            "/skills/course_access/{course_id}",
+            routing::post_with(purchase, purchase_docs),
+        )
         .with_state(service)
         .with_path_items(|op| op.tag(TAG))
 }
@@ -48,3 +61,44 @@ fn list_docs(op: TransformOperation) -> TransformOperation {
         .add_response::<Vec<ApiCourseUserSummary>>(StatusCode::OK, None)
         .with(internal_server_error_docs)
 }
+
+#[derive(Deserialize, JsonSchema)]
+struct PurchasePath {
+    course_id: CourseId,
+}
+
+async fn purchase(
+    service: State<Arc<impl CourseFeatureService>>,
+    token: ApiToken,
+    Path(PurchasePath { course_id }): Path<PurchasePath>,
+) -> Response {
+    match service.purchase(&token.0, course_id).await {
+        Ok(()) => Json(OkResponse).into_response(),
+        Err(CoursePurchaseError::CourseNotFound) => CourseNotFoundError.into_response(),
+        Err(CoursePurchaseError::CourseIsFree) => CourseIsFreeError.into_response(),
+        Err(CoursePurchaseError::AlreadyPurchased) => AlreadyPurchasedError.into_response(),
+        Err(CoursePurchaseError::NotEnoughCoins) => NotEnoughCoinsError.into_response(),
+        Err(CoursePurchaseError::Auth(err)) => auth_error(err),
+        Err(CoursePurchaseError::Other(err)) => internal_server_error(err),
+    }
+}
+
+fn purchase_docs(op: TransformOperation) -> TransformOperation {
+    op.summary("Purchase a course for the authenticated user")
+        .add_response::<OkResponse>(StatusCode::OK, "The course has been purchased.")
+        .add_error::<CourseNotFoundError>()
+        .add_error::<CourseIsFreeError>()
+        .add_error::<AlreadyPurchasedError>()
+        .add_error::<NotEnoughCoinsError>()
+        .with(auth_error_docs)
+        .with(internal_server_error_docs)
+}
+
+error_code! {
+    /// The course does not exist.
+    CourseNotFoundError(NOT_FOUND, "Course not found");
+    /// The course is free.
+    CourseIsFreeError(FORBIDDEN, "Course is free");
+    /// The user has already purchased this course.
+    AlreadyPurchasedError(FORBIDDEN, "Already purchased course");
+}

academy/src/environment/types.rs

@@ -12,3 +12,4 @@ workspace = true
 [dependencies]
 academy_models.workspace = true
 anyhow.workspace = true
+thiserror.workspace = true

academy_api/rest/src/routes/course.rs

@@ -1,9 +1,38 @@
-use academy_models::course::{CourseFilter, CourseUserSummary};
+use academy_models::{
+    auth::{AccessToken, AuthError},
+    course::{CourseFilter, CourseId, CourseUserSummary},
+};
+use thiserror::Error;
 
 pub trait CourseFeatureService: Send + Sync + 'static {
     /// Return summaries of all courses.
     fn list(
         &self,
         filter: CourseFilter,
     ) -> impl Future<Output = anyhow::Result<Vec<CourseUserSummary>>> + Send;
+
+    /// Purchase a course for the authenticated user.
+    ///
+    /// Requires a verified email address.
+    fn purchase(
+        &self,
+        token: &AccessToken,
+        course_id: CourseId,
+    ) -> impl Future<Output = Result<(), CoursePurchaseError>> + Send;
+}
+
+#[derive(Debug, Error)]
+pub enum CoursePurchaseError {
+    #[error("The course does not exist.")]
+    CourseNotFound,
+    #[error("The user has already purchased this course.")]
+    AlreadyPurchased,
+    #[error("The course is free.")]
+    CourseIsFree,
+    #[error("The user does not have enough coins.")]
+    NotEnoughCoins,
+    #[error(transparent)]
+    Auth(#[from] AuthError),
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
 }

academy_core/course/contracts/Cargo.toml

@@ -10,14 +10,20 @@ repository.workspace = true
 workspace = true
 
 [dependencies]
+academy_auth_contracts.workspace = true
+academy_core_coin_contracts.workspace = true
 academy_core_course_contracts.workspace = true
 academy_data.workspace = true
 academy_di.workspace = true
 academy_models.workspace = true
+academy_persistence_contracts.workspace = true
 academy_utils.workspace = true
 anyhow.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
+academy_auth_contracts = { workspace = true, features = ["mock"] }
+academy_core_coin_contracts = { workspace = true, features = ["mock"] }
 academy_demo.workspace = true
+academy_persistence_contracts = { workspace = true, features = ["mock"] }
 tokio.workspace = true

academy_core/course/contracts/src/lib.rs

@@ -1,18 +1,35 @@
-use academy_core_course_contracts::CourseFeatureService;
+use academy_auth_contracts::{AuthResultExt, AuthService};
+use academy_core_coin_contracts::coin::{CoinAddCoinsError, CoinService};
+use academy_core_course_contracts::{CourseFeatureService, CoursePurchaseError};
 use academy_data::course::CourseDataRepository;
 use academy_di::Build;
-use academy_models::course::{CourseFilter, CourseUserSummary};
-use academy_utils::trace_instrument;
+use academy_models::{
+    auth::AccessToken,
+    course::{CourseFilter, CourseId, CourseUserPatchRef, CourseUserSummary},
+};
+use academy_persistence_contracts::{Database, Transaction, course::CourseRepository};
+use academy_utils::{patch::PatchValue, trace_instrument};
 
 #[cfg(test)]
 mod tests;
 
 #[derive(Debug, Clone, Default, Build)]
-pub struct CourseFeatureServiceImpl {
+pub struct CourseFeatureServiceImpl<Db, Auth, Coin, CourseRepo> {
+    db: Db,
+    auth: Auth,
+    coin: Coin,
+    course_repo: CourseRepo,
     course_data_repo: CourseDataRepository,
 }
 
-impl CourseFeatureService for CourseFeatureServiceImpl {
+impl<Db, Auth, Coin, CourseRepo> CourseFeatureService
+    for CourseFeatureServiceImpl<Db, Auth, Coin, CourseRepo>
+where
+    Db: Database,
+    Auth: AuthService<Db::Transaction>,
+    Coin: CoinService<Db::Transaction>,
+    CourseRepo: CourseRepository<Db::Transaction>,
+{
     #[trace_instrument(no_ret, skip(self))]
     async fn list(&self, filter: CourseFilter) -> anyhow::Result<Vec<CourseUserSummary>> {
         let mut courses = self
@@ -47,4 +64,66 @@ impl CourseFeatureService for CourseFeatureServiceImpl {
 
         Ok(courses)
     }
+
+    #[trace_instrument(skip(self))]
+    async fn purchase(
+        &self,
+        token: &AccessToken,
+        course_id: CourseId,
+    ) -> Result<(), CoursePurchaseError> {
+        let auth = self.auth.authenticate(token).await.map_auth_err()?;
+        auth.ensure_email_verified().map_auth_err()?;
+
+        let course = self
+            .course_data_repo
+            .get(&course_id)
+            .ok_or(CoursePurchaseError::CourseNotFound)?;
+
+        if course.base.price == 0 {
+            return Err(CoursePurchaseError::CourseIsFree);
+        }
+
+        let mut txn = self.db.begin_transaction().await?;
+
+        let course_user = self
+            .course_repo
+            .get_course_user(&mut txn, &course_id, auth.user_id)
+            .await?;
+        if course_user.purchased {
+            return Err(CoursePurchaseError::AlreadyPurchased);
+        }
+
+        let transaction_description = format!("Course \"{}\"", *course.base.title)
+            .try_into()
+            .map_err(anyhow::Error::from)?;
+        self.coin
+            .add_coins(
+                &mut txn,
+                auth.user_id,
+                -(course.base.price as i64),
+                false,
+                Some(transaction_description),
+                false,
+            )
+            .await
+            .map_err(|err| match err {
+                CoinAddCoinsError::NotEnoughCoins => CoursePurchaseError::NotEnoughCoins,
+                CoinAddCoinsError::Other(err) => err.into(),
+            })?;
+
+        self.course_repo
+            .update_course_user(
+                &mut txn,
+                &course_id,
+                auth.user_id,
+                CourseUserPatchRef {
+                    purchased: PatchValue::Update(&true),
+                },
+            )
+            .await?;
+
+        txn.commit().await?;
+
+        Ok(())
+    }
 }