shopify_client/admin/order/
remote.rs

1use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
2
3use crate::{
4    common::{http::http_client, types::APIError, utils::parse_response_from_text, ServiceContext},
5    types::order::{GetOrderResp, OrderQueryResp, PatchOrderRequest},
6};
7
8pub async fn patch_order(
9    ctx: &ServiceContext,
10    order_id: &String,
11    patch_request: &PatchOrderRequest,
12) -> Result<GetOrderResp, APIError> {
13    let endpoint = format!(
14        "{}/admin/api/{}/orders/{}.json",
15        ctx.shop_url.trim_end_matches('/'),
16        ctx.version,
17        order_id
18    );
19
20    let body_str = serde_json::to_string(&patch_request).unwrap_or_default();
21
22    let mut callback_headers = HeaderMap::new();
23    callback_headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
24
25    ctx.callbacks
26        .call_before(&endpoint, Some(&body_str), &callback_headers);
27
28    let response = http_client()
29        .put(&endpoint)
30        .header("X-Shopify-Access-Token", &*ctx.access_token)
31        .header("Content-Type", "application/json")
32        .json(&patch_request)
33        .send()
34        .await;
35
36    match response {
37        Ok(resp) => {
38            let response_headers = resp.headers().clone();
39            let response_text = match resp.text().await {
40                Ok(text) => text,
41                Err(e) => {
42                    let error_msg = format!("<failed to read response body: {}>", e);
43                    ctx.callbacks
44                        .call_after(&endpoint, &error_msg, &response_headers);
45                    return Err(APIError::FailedToParse);
46                }
47            };
48
49            ctx.callbacks
50                .call_after(&endpoint, &response_text, &response_headers);
51
52            parse_response_from_text::<GetOrderResp>(&response_text)
53        }
54        Err(e) => {
55            let error_msg = format!("<network error: {}>", e);
56            ctx.callbacks
57                .call_after(&endpoint, &error_msg, &HeaderMap::new());
58            Err(APIError::NetworkError)
59        }
60    }
61}
62
63pub async fn get_order_with_name(
64    ctx: &ServiceContext,
65    order_name: &String,
66) -> Result<OrderQueryResp, APIError> {
67    let endpoint = format!(
68        "{}/admin/api/{}/orders.json?query=name:%23{}&status=any",
69        ctx.shop_url.trim_end_matches('/'),
70        ctx.version,
71        order_name
72    );
73
74    let callback_headers = HeaderMap::new();
75
76    ctx.callbacks
77        .call_before(&endpoint, None, &callback_headers);
78
79    let response = http_client()
80        .get(&endpoint)
81        .header("X-Shopify-Access-Token", &*ctx.access_token)
82        .send()
83        .await;
84
85    match response {
86        Ok(resp) => {
87            let response_headers = resp.headers().clone();
88            let response_text = match resp.text().await {
89                Ok(text) => text,
90                Err(e) => {
91                    let error_msg = format!("<failed to read response body: {}>", e);
92                    ctx.callbacks
93                        .call_after(&endpoint, &error_msg, &response_headers);
94                    return Err(APIError::FailedToParse);
95                }
96            };
97
98            ctx.callbacks
99                .call_after(&endpoint, &response_text, &response_headers);
100
101            parse_response_from_text::<OrderQueryResp>(&response_text)
102        }
103        Err(e) => {
104            let error_msg = format!("<network error: {}>", e);
105            ctx.callbacks
106                .call_after(&endpoint, &error_msg, &HeaderMap::new());
107            Err(APIError::NetworkError)
108        }
109    }
110}
111
112pub async fn get_order_with_id(
113    ctx: &ServiceContext,
114    order_id: &String,
115) -> Result<GetOrderResp, APIError> {
116    let endpoint = format!(
117        "{}/admin/api/{}/orders/{}.json",
118        ctx.shop_url.trim_end_matches('/'),
119        ctx.version,
120        order_id
121    );
122
123    let callback_headers = HeaderMap::new();
124
125    ctx.callbacks
126        .call_before(&endpoint, None, &callback_headers);
127
128    let response = http_client()
129        .get(&endpoint)
130        .header("X-Shopify-Access-Token", &*ctx.access_token)
131        .send()
132        .await;
133
134    match response {
135        Ok(resp) => {
136            let response_headers = resp.headers().clone();
137            let response_text = match resp.text().await {
138                Ok(text) => text,
139                Err(e) => {
140                    let error_msg = format!("<failed to read response body: {}>", e);
141                    ctx.callbacks
142                        .call_after(&endpoint, &error_msg, &response_headers);
143                    return Err(APIError::FailedToParse);
144                }
145            };
146
147            ctx.callbacks
148                .call_after(&endpoint, &response_text, &response_headers);
149
150            parse_response_from_text::<GetOrderResp>(&response_text)
151        }
152        Err(e) => {
153            let error_msg = format!("<network error: {}>", e);
154            ctx.callbacks
155                .call_after(&endpoint, &error_msg, &HeaderMap::new());
156            Err(APIError::NetworkError)
157        }
158    }
159}
shopify_client/admin/order/remote.rs

shopify_client/admin/order/
remote.rs
