use serde::{Deserialize, Serialize};
use crate::client::RazorpayClient;
use crate::error::RazorpayError;
use crate::resources::common::Notes;
use crate::util::pagination::{Collection, ListOptions};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceStatus {
Draft,
Issued,
Paid,
PartiallyPaid,
Expired,
Cancelled,
Deleted,
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LineItem {
#[serde(default)]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
pub description: Option<String>,
#[serde(default)]
pub amount: i64,
#[serde(skip_serializing_if = "Option::is_none", default)]
pub currency: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
pub quantity: Option<u32>,
}
impl LineItem {
pub fn new(name: impl Into<String>, amount: i64) -> Self {
Self {
name: Some(name.into()),
description: None,
amount,
currency: None,
quantity: None,
}
}
pub fn quantity(mut self, quantity: u32) -> Self {
self.quantity = Some(quantity);
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct Invoice {
pub id: String,
#[serde(default)]
pub entity: String,
pub status: InvoiceStatus,
#[serde(default)]
pub amount: i64,
#[serde(default)]
pub amount_paid: i64,
#[serde(default)]
pub amount_due: i64,
#[serde(default)]
pub currency: Option<String>,
#[serde(default)]
pub invoice_number: Option<String>,
#[serde(default)]
pub customer_id: Option<String>,
#[serde(default)]
pub order_id: Option<String>,
#[serde(default)]
pub payment_id: Option<String>,
#[serde(default)]
pub subscription_id: Option<String>,
#[serde(default)]
pub short_url: Option<String>,
#[serde(default)]
pub line_items: Vec<LineItem>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub expire_by: Option<i64>,
#[serde(default)]
pub issued_at: Option<i64>,
#[serde(default)]
pub paid_at: Option<i64>,
#[serde(default)]
pub cancelled_at: Option<i64>,
#[serde(default)]
pub notes: Notes,
#[serde(default)]
pub created_at: i64,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct CreateInvoiceParams {
#[serde(rename = "type")]
pub invoice_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub line_items: Vec<LineItem>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expire_by: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_notify: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email_notify: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub receipt: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub notes: Option<Notes>,
}
impl CreateInvoiceParams {
pub fn new(customer_id: impl Into<String>, line_items: Vec<LineItem>) -> Self {
Self {
invoice_type: "invoice".to_string(),
customer_id: Some(customer_id.into()),
line_items,
..Self::default()
}
}
pub fn expire_by(mut self, expire_by: i64) -> Self {
self.expire_by = Some(expire_by);
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
pub fn notify(mut self, sms: bool, email: bool) -> Self {
self.sms_notify = Some(u8::from(sms));
self.email_notify = Some(u8::from(email));
self
}
pub fn notes(mut self, notes: Notes) -> Self {
self.notes = Some(notes);
self
}
}
pub struct InvoicesClient<'a> {
pub(crate) client: &'a RazorpayClient,
}
impl<'a> InvoicesClient<'a> {
pub async fn create(&self, params: CreateInvoiceParams) -> Result<Invoice, RazorpayError> {
self.client.post("invoices", Some(¶ms)).await
}
pub async fn fetch(&self, id: &str) -> Result<Invoice, RazorpayError> {
self.client.get::<(), _>(&format!("invoices/{id}"), None).await
}
pub async fn all(&self, options: ListOptions) -> Result<Collection<Invoice>, RazorpayError> {
self.client.get("invoices", Some(&options)).await
}
pub async fn issue(&self, id: &str) -> Result<Invoice, RazorpayError> {
self.client
.post::<(), _>(&format!("invoices/{id}/issue"), None)
.await
}
pub async fn cancel(&self, id: &str) -> Result<Invoice, RazorpayError> {
self.client
.post::<(), _>(&format!("invoices/{id}/cancel"), None)
.await
}
pub async fn edit(
&self,
id: &str,
params: CreateInvoiceParams,
) -> Result<Invoice, RazorpayError> {
self.client.patch(&format!("invoices/{id}"), Some(¶ms)).await
}
pub async fn delete(&self, id: &str) -> Result<(), RazorpayError> {
self.client
.delete::<serde::de::IgnoredAny>(&format!("invoices/{id}"))
.await
.map(|_| ())
}
pub async fn notify_by(&self, id: &str, medium: &str) -> Result<(), RazorpayError> {
self.client
.post::<(), serde::de::IgnoredAny>(&format!("invoices/{id}/notify_by/{medium}"), None)
.await
.map(|_| ())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn create_sets_type_and_line_items() {
let params = CreateInvoiceParams::new("cust_1", vec![LineItem::new("Book", 10_000)]);
let json = serde_json::to_string(¶ms).unwrap();
assert!(json.contains(r#""type":"invoice""#));
assert!(json.contains(r#""name":"Book""#));
assert!(json.contains(r#""amount":10000"#));
}
#[test]
fn empty_line_items_are_omitted() {
let params = CreateInvoiceParams::new("cust_1", vec![]);
assert!(!serde_json::to_string(¶ms).unwrap().contains("line_items"));
}
#[test]
fn partially_paid_status_decodes() {
let inv: Invoice =
serde_json::from_str(r#"{"id":"inv_1","status":"partially_paid"}"#).unwrap();
assert_eq!(inv.status, InvoiceStatus::PartiallyPaid);
}
}