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

use anyhow::{Ok, Result};
use mostro_core::dispute::{Dispute, Status as DisputeStatus};
use mostro_core::order::{Kind as OrderKind, SmallOrder, Status};
use nostr_sdk::prelude::*;
use std::str::FromStr;
use uuid::Uuid;

pub fn order_from_tags(tags: Vec<Tag>) -> Result<SmallOrder> {
    let mut order = SmallOrder::default();
    for tag in tags {
        let t = tag.as_vec();
        let v = t.get(1).unwrap().as_str();
        match t.first().unwrap().as_str() {
            "d" => {
                let id = t.get(1).unwrap().as_str().parse::<Uuid>();
                let id = match id {
                    core::result::Result::Ok(id) => Some(id),
                    Err(_) => None,
                };
                order.id = id;
            }
            "k" => {
                order.kind = Some(OrderKind::from_str(v).unwrap());
            }
            "f" => {
                order.fiat_code = v.to_string();
            }
            "s" => {
                order.status = Some(Status::from_str(v).unwrap_or(Status::Dispute));
            }
            "amt" => {
                order.amount = v.parse::<i64>().unwrap();
            }
            "fa" => {
                order.fiat_amount = v.parse::<i64>().unwrap();
            }
            "pm" => {
                order.payment_method = v.to_string();
            }
            "premium" => {
                order.premium = v.parse::<i64>().unwrap();
            }
            _ => {}
        }
    }

    Ok(order)
}

pub fn dispute_from_tags(tags: Vec<Tag>) -> Result<Dispute> {
    let mut dispute = Dispute::default();
    for tag in tags {
        let t = tag.as_vec();
        let v = t.get(1).unwrap().as_str();
        match t.first().unwrap().as_str() {
            "d" => {
                let id = t.get(1).unwrap().as_str().parse::<Uuid>();
                let id = match id {
                    core::result::Result::Ok(id) => id,
                    Err(_) => return Err(anyhow::anyhow!("Invalid dispute id")),
                };
                dispute.id = id;
            }

            "s" => {
                let status = match DisputeStatus::from_str(v) {
                    core::result::Result::Ok(status) => status,
                    Err(_) => return Err(anyhow::anyhow!("Invalid dispute status")),
                };

                dispute.status = status.to_string();
            }

            _ => {}
        }
    }

    Ok(dispute)
}