wip: affiliate payouts again

Author: aecsocket

apps/labrinth/migrations/20251024182919_subscription_affiliations.sql

@@ -0,0 +1,15 @@
+CREATE TABLE users_subscriptions_affiliations (
+	id				BIGSERIAL   NOT NULL PRIMARY KEY,
+	subscription_id BIGINT      NOT NULL REFERENCES users_subscriptions(id),
+	affiliate_code  BIGINT      NOT NULL REFERENCES affiliate_codes(id),
+	deactivated_at  TIMESTAMPTZ
+);
+
+CREATE TABLE users_subscriptions_affiliations_payouts(
+	id              BIGSERIAL          PRIMARY KEY,
+	charge_id       BIGINT    NOT NULL REFERENCES charges(id),
+	subscription_id BIGINT    NOT NULL REFERENCES users_subscriptions(id),
+	affiliate_code  BIGINT    NOT NULL REFERENCES affiliate_codes(id),
+	payout_value_id BIGSERIAL NOT NULL REFERENCES payouts_values(id),
+	UNIQUE (charge_id)
+);

apps/labrinth/src/database/models/mod.rs

@@ -35,6 +35,7 @@ pub mod user_subscription_item;
 pub mod users_compliance;
 pub mod users_notifications_preferences_item;
 pub mod users_redeemals;
+pub mod users_subscriptions_affiliations;
 pub mod users_subscriptions_credits;
 pub mod version_item;
 

apps/labrinth/src/database/models/users_subscriptions_affiliations.rs

@@ -0,0 +1,90 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::database::models::{
+    DBAffiliateCodeId, DBChargeId, DBUserSubscriptionId,
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DBUsersSubscriptionsAffiliations {
+    pub id: i64,
+    pub subscription_id: DBUserSubscriptionId,
+    pub affiliate_code: DBAffiliateCodeId,
+    pub deactivated_at: Option<DateTime<Utc>>,
+}
+
+impl DBUsersSubscriptionsAffiliations {
+    pub async fn insert<'a, E>(&mut self, exec: E) -> sqlx::Result<()>
+    where
+        E: sqlx::PgExecutor<'a>,
+    {
+        let id = sqlx::query_scalar!(
+            "
+            INSERT INTO users_subscriptions_affiliations
+                (subscription_id, affiliate_code, deactivated_at)
+            VALUES ($1, $2, $3)
+            RETURNING id
+            ",
+            self.subscription_id.0,
+            self.affiliate_code.0,
+            self.deactivated_at,
+        )
+        .fetch_one(exec)
+        .await?;
+
+        self.id = id;
+        Ok(())
+    }
+
+    pub async fn update<'a, E>(&mut self, exec: E) -> sqlx::Result<()>
+    where
+        E: sqlx::PgExecutor<'a>,
+    {
+        sqlx::query!(
+            "UPDATE users_subscriptions_affiliations
+            SET subscription_id = $1, affiliate_code = $2, deactivated_at = $3
+            WHERE id = $4",
+            self.subscription_id.0,
+            self.affiliate_code.0,
+            self.deactivated_at,
+            self.id
+        )
+        .execute(exec)
+        .await?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DBUsersSubscriptionsAffiliationsPayouts {
+    pub id: i64,
+    pub charge_id: DBChargeId,
+    pub subscription_id: DBUserSubscriptionId,
+    pub affiliate_code: DBAffiliateCodeId,
+    pub payout_value_id: i64,
+}
+
+impl DBUsersSubscriptionsAffiliationsPayouts {
+    pub async fn insert<'a, E>(&mut self, exec: E) -> sqlx::Result<()>
+    where
+        E: sqlx::PgExecutor<'a>,
+    {
+        let id = sqlx::query_scalar!(
+            "
+            INSERT INTO users_subscriptions_affiliations_payouts
+                (charge_id, subscription_id, affiliate_code, payout_value_id)
+            VALUES ($1, $2, $3, $4)
+            RETURNING id
+            ",
+            self.charge_id.0,
+            self.subscription_id.0,
+            self.affiliate_code.0,
+            self.payout_value_id,
+        )
+        .fetch_one(exec)
+        .await?;
+
+        self.id = id;
+        Ok(())
+    }
+}

apps/labrinth/src/routes/internal/billing.rs

@@ -4,16 +4,19 @@ use crate::database::models::charge_item::DBCharge;
 use crate::database::models::ids::DBUserSubscriptionId;
 use crate::database::models::notification_item::NotificationBuilder;
 use crate::database::models::products_tax_identifier_item::product_info_by_product_price_id;
+use crate::database::models::users_subscriptions_affiliations::DBUsersSubscriptionsAffiliations;
 use crate::database::models::users_subscriptions_credits::DBUserSubscriptionCredit;
 use crate::database::models::{
-    charge_item, generate_charge_id, product_item, user_subscription_item,
+    DBAffiliateCodeId, charge_item, generate_charge_id, product_item,
+    user_subscription_item,
 };
 use crate::database::redis::RedisPool;
 use crate::models::billing::{
     Charge, ChargeStatus, ChargeType, PaymentPlatform, Price, PriceDuration,
     Product, ProductMetadata, ProductPrice, SubscriptionMetadata,
     SubscriptionStatus, UserSubscription,
 };
+use crate::models::ids::AffiliateCodeId;
 use crate::models::notifications::NotificationBody;
 use crate::models::pats::Scopes;
 use crate::models::users::Badges;
@@ -1328,7 +1331,15 @@ pub enum ChargeRequestType {
 
 #[derive(Deserialize, Serialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
-pub enum PaymentRequestMetadata {
+pub struct PaymentRequestMetadata {
+    #[serde(flatten)]
+    pub kind: PaymentRequestMetadataKind,
+    pub affiliate_code: Option<AffiliateCodeId>,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum PaymentRequestMetadataKind {
     Pyro {
         server_name: Option<String>,
         server_region: Option<String>,
@@ -1866,12 +1877,12 @@ pub async fn stripe_webhook(
                                 } else {
                                     let (server_name, server_region, source) =
                                         if let Some(
-                                            PaymentRequestMetadata::Pyro {
-                                                ref server_name,
-                                                ref server_region,
-                                                ref source,
+                                            PaymentRequestMetadataKind::Pyro {
+                                                server_name,
+                                                server_region,
+                                                source,
                                             },
-                                        ) = metadata.payment_metadata
+                                        ) = metadata.payment_metadata.as_ref().map(|m| &m.kind)
                                         {
                                             (
                                                 server_name.clone(),
@@ -2055,6 +2066,25 @@ pub async fn stripe_webhook(
                             }
                             .upsert(&mut transaction)
                             .await?;
+
+                            if let Some(affiliate_code) = metadata
+                                .payment_metadata
+                                .as_ref()
+                                .and_then(|m| m.affiliate_code)
+                            {
+                                DBUsersSubscriptionsAffiliations {
+                                    id: 0,
+                                    subscription_id: subscription.id,
+                                    affiliate_code: DBAffiliateCodeId::from(
+                                        affiliate_code,
+                                    ),
+                                    deactivated_at: None,
+                                }
+                                .insert(&mut *transaction)
+                                .await?;
+                            }
+
+                            // TODO affiliate code
                         };
 
                         subscription.status = SubscriptionStatus::Provisioned;