jkn_rust 0.1.1

Client Rust untuk bridging API BPJS/JKN
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

use std::sync::Arc;

use serde::Serialize;

use crate::JknClient;
use crate::client::{JknResponse, RequestOptions, normalize_path};
use crate::config::ServiceType;
use crate::error::Result;
use crate::models::antrean::{AntreanFktpRefDokterResponse, AntreanFktpRefPoliResponse};

#[derive(Clone)]
pub struct AntreanFktp {
    client: Arc<JknClient>,
}

impl AntreanFktp {
    pub fn new(client: Arc<JknClient>) -> Self {
        Self { client }
    }

    pub async fn ref_poli(&self, tanggal: &str) -> Result<JknResponse> {
        self.client
            .send(
                ServiceType::Pcare,
                RequestOptions::get(format!("/ref/poli/tanggal/{tanggal}")),
            )
            .await
    }

    pub async fn ref_poli_typed(&self, tanggal: &str) -> Result<AntreanFktpRefPoliResponse> {
        self.ref_poli(tanggal).await?.into_response()
    }

    pub async fn ref_dokter(&self, tanggal: &str, kode_poli: &str) -> Result<JknResponse> {
        let path = normalize_path(
            "/ref/dokter/kodepoli/:kodePoli/tanggal/:tanggal",
            &[
                ("kodePoli", Some(kode_poli.to_string())),
                ("tanggal", Some(tanggal.to_string())),
            ],
        )?;
        self.client
            .send(ServiceType::Pcare, RequestOptions::get(path))
            .await
    }

    pub async fn tambah<T: Serialize>(&self, data: T) -> Result<JknResponse> {
        self.client
            .send(
                ServiceType::Pcare,
                RequestOptions::post("/antrean/add").data(data)?,
            )
            .await
    }

    pub async fn update_status<T: Serialize>(&self, data: T) -> Result<JknResponse> {
        self.client
            .send(
                ServiceType::Pcare,
                RequestOptions::post("/antrean/panggil").data(data)?,
            )
            .await
    }

    pub async fn batal<T: Serialize>(&self, data: T) -> Result<JknResponse> {
        self.client
            .send(
                ServiceType::Pcare,
                RequestOptions::post("/antrean/batal").data(data)?,
            )
            .await
    }

    pub async fn ref_dokter_typed(
        &self,
        tanggal: &str,
        kode_poli: &str,
    ) -> Result<AntreanFktpRefDokterResponse> {
        self.ref_dokter(tanggal, kode_poli).await?.into_response()
    }
}