anypay 0.1.0

AnyPay is a payment processing platform that allows you to accept payments from multiple cryptocurrencies and fiat currencies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use axum::{
    routing::{get, post, delete},
    Router,
    extract::{Path, Json},
    http::StatusCode,
};
use serde::{Deserialize, Serialize};
use serde_json::json;
use uuid::Uuid;
use std::sync::Arc;

use crate::{supabase::SupabaseClient, types::PaymentOption};
use crate::types::{Invoice, Price, PaymentRequest};

// Request/Response types matching swagger spec
#[derive(Deserialize)]
pub struct CreateInvoiceRequest {
    amount: i64,
    currency: String,
    account_id: i64,
    redirect_url: Option<String>,
    webhook_url: Option<String>,
    wordpress_site_url: Option<String>,
    memo: Option<String>,
    email: Option<String>,
    external_id: Option<String>,
    business_id: Option<String>,
    location_id: Option<String>,
    register_id: Option<String>,
    required_fee_rate: Option<String>,
}

#[derive(Serialize)]
pub struct InvoiceResponse {
    pub invoice: Invoice,
    pub payment_options: Vec<PaymentOption>,
}

#[derive(Serialize)]
pub struct PricesResponse {
    prices: Vec<Price>,
}

pub struct HttpServer {
    supabase: Arc<SupabaseClient>,
}

impl HttpServer {
    pub fn new(supabase: Arc<SupabaseClient>) -> Self {
        Self { supabase }
    }

    pub fn router(&self) -> Router {
        let supabase = self.supabase.clone();

        Router::new()
            // Prices endpoint
            .route("/api/v1/prices", get({
                let supabase = supabase.clone();
                move |_: ()| async move {
                    match supabase.list_prices().await {
                        Ok(prices) => Ok(Json(PricesResponse { prices })),
                        Err(e) => {
                            tracing::error!("Error listing prices: {}", e);
                            Err(StatusCode::INTERNAL_SERVER_ERROR)
                        }
                    }
                }
            }))

            // Invoice endpoints
            .route("/api/v1/invoices/:invoice_id", get({
                let supabase = supabase.clone();
                move |Path(invoice_id): Path<String>| async move {
                    tracing::info!("Fetching invoice with id: {}", invoice_id);
                    match supabase.get_invoice(&invoice_id, true).await {
                        Ok(Some(result)) => {
                            tracing::info!("Invoice fetched successfully: {:?}", result);
                            Ok(Json(InvoiceResponse { invoice: result.0, payment_options: result.1 }))
                        }
                        Ok(None) => Err(StatusCode::NOT_FOUND),
                        Err(e) => {
                            tracing::error!("Error fetching invoice: {}", e);
                            Err(StatusCode::INTERNAL_SERVER_ERROR)
                        }
                    }
                }
            }))
            .route("/api/v1/invoices", post(move |Json(payload): Json<CreateInvoiceRequest>| async move {
                match supabase.create_invoice(
                    payload.amount, 
                    &payload.currency, 
                    payload.account_id,  // TODO: Get real account_id
                    payload.webhook_url,
                    payload.redirect_url,
                    payload.memo
                ).await {
                    Ok(response) => {
                        let data = response.as_object().unwrap();
                        Ok(Json(InvoiceResponse { 
                            invoice: serde_json::from_value(data["invoice"].clone()).unwrap(),
                            payment_options: serde_json::from_value(data["payment_options"].clone()).unwrap(),
                        }))
                    },
                    Err(e) => {
                        tracing::error!("Error creating invoice: {}", e);
                        Err(StatusCode::INTERNAL_SERVER_ERROR)
                    }
                }
            }))
            .route("/invoices/:uid", delete(move |Path(uid): Path<String>| async move {
                // TODO: Implement invoice cancellation
                StatusCode::NOT_IMPLEMENTED
            }))

            // Payment platform routes
            .route("/r", post(move |Json(payload): Json<PaymentRequest>| async move {
                // TODO: Implement payment request creation
                tracing::info!("Creating payment request: {:?}", payload);
                Ok::<Json<serde_json::Value>, StatusCode>(Json(json!({
                    "status": "success",
                    "uid": Uuid::new_v4().to_string()
                })))
            }))
            .route("/r/:uid", 
                post(move |
                    Path(uid): Path<String>,
                | async move {
                    // TODO: Process payment for existing request
                    tracing::info!("Processing payment for {}", uid);
                    Ok::<Json<serde_json::Value>, StatusCode>(Json(json!({
                        "status": "processing"
                    })))
                })
                .delete(move |Path(uid): Path<String>| async move {
                    // TODO: Cancel payment request
                    tracing::info!("Cancelling payment request {}", uid);
                    StatusCode::OK
                })
            )
    }
}