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,7 @@ 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, TemplateEmail, UserRepo, 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

@@ -0,0 +1,8 @@
+{% extends "base" %}
+{% block title %}Kaufbestätigung{% endblock title %}
+{% block content %}
+  <p>
+    Danke für den Kauf des Kurses "{{ title }}"!
+    Wir wünschen dir viel Spaß und Erfolg damit.
+  </p>
+{% endblock content %}

academy_api/rest/src/routes/course.rs

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

academy_assets/assets/templates/course_purchase_confirmation.html

@@ -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,23 @@ 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_email_contracts.workspace = true
 academy_models.workspace = true
+academy_persistence_contracts.workspace = true
+academy_templates_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_email_contracts = { workspace = true, features = ["mock"] }
+academy_persistence_contracts = { workspace = true, features = ["mock"] }
 tokio.workspace = true