egs_api/api/
fab.rs

1use crate::api::EpicAPI;
2use crate::api::error::EpicAPIError;
3use crate::api::types::download_manifest::DownloadManifest;
4use crate::api::types::fab_asset_manifest::DownloadInfo;
5use crate::api::types::fab_library::FabLibrary;
6use log::{debug, error, warn};
7use std::borrow::BorrowMut;
8use url::Url;
9
10impl EpicAPI {
11    /// Fetch Fab asset manifest with signed distribution points. Returns `FabTimeout` on 403.
12    pub async fn fab_asset_manifest(
13        &self,
14        artifact_id: &str,
15        namespace: &str,
16        asset_id: &str,
17        platform: Option<&str>,
18    ) -> Result<Vec<DownloadInfo>, EpicAPIError> {
19        let url = format!("https://www.fab.com/e/artifacts/{}/manifest", artifact_id);
20        let parsed_url = Url::parse(&url).map_err(|_| EpicAPIError::InvalidParams)?;
21        match self
22            .authorized_post_client(parsed_url)
23            .json(&serde_json::json!({
24                "item_id": asset_id,
25                "namespace": namespace,
26                "platform": platform.unwrap_or("Windows"),
27            }))
28            .send()
29            .await
30        {
31            Ok(response) => {
32                if response.status() == reqwest::StatusCode::OK {
33                    let text = response.text().await.unwrap_or_default();
34                    match serde_json::from_str::<
35                        crate::api::types::fab_asset_manifest::FabAssetManifest,
36                    >(&text)
37                    {
38                        Ok(manifest) => Ok(manifest.download_info),
39                        Err(e) => {
40                            error!("{:?}", e);
41                            debug!("{}", text);
42                            Err(EpicAPIError::DeserializationError(format!("{}", e)))
43                        }
44                    }
45                } else if response.status() == reqwest::StatusCode::FORBIDDEN {
46                    Err(EpicAPIError::FabTimeout)
47                } else {
48                    debug!("{:?}", response.headers());
49                    let status = response.status();
50                    let body = response.text().await.unwrap_or_default();
51                    warn!("{} result: {}", status, body);
52                    Err(EpicAPIError::HttpError { status, body })
53                }
54            }
55            Err(e) => {
56                error!("{:?}", e);
57                Err(EpicAPIError::NetworkError(e))
58            }
59        }
60    }
61
62    /// Download and parse a Fab manifest from a distribution point.
63    pub async fn fab_download_manifest(
64        &self,
65        download_info: DownloadInfo,
66        distribution_point_url: &str,
67    ) -> Result<DownloadManifest, EpicAPIError> {
68        match download_info.get_distribution_point_by_base_url(distribution_point_url) {
69            None => {
70                error!("Distribution point not found");
71                Err(EpicAPIError::InvalidParams)
72            }
73            Some(point) => {
74                if point.signature_expiration < time::OffsetDateTime::now_utc() {
75                    error!("Expired signature");
76                    Err(EpicAPIError::InvalidParams)
77                } else {
78                    let data = self.get_bytes(&point.manifest_url).await?;
79                    match DownloadManifest::parse(data) {
80                        None => {
81                            error!("Unable to parse the Download Manifest");
82                            Err(EpicAPIError::DeserializationError(
83                                "Unable to parse the Download Manifest".to_string(),
84                            ))
85                        }
86                        Some(mut man) => {
87                            man.set_custom_field("SourceURL", distribution_point_url);
88                            Ok(man)
89                        }
90                    }
91                }
92            }
93        }
94    }
95
96    /// Fetch all Fab library items, paginating internally.
97    pub async fn fab_library_items(
98        &mut self,
99        account_id: String,
100    ) -> Result<FabLibrary, EpicAPIError> {
101        let mut library = FabLibrary::default();
102
103        loop {
104            let url = match &library.cursors.next {
105                None => {
106                    format!(
107                        "https://www.fab.com/e/accounts/{}/ue/library?count=100",
108                        account_id
109                    )
110                }
111                Some(c) => {
112                    format!(
113                        "https://www.fab.com/e/accounts/{}/ue/library?cursor={}&count=100",
114                        account_id, c
115                    )
116                }
117            };
118
119            match self.authorized_get_json::<FabLibrary>(&url).await {
120                Ok(mut api_library) => {
121                    library.cursors.next = api_library.cursors.next;
122                    library.results.append(api_library.results.borrow_mut());
123                }
124                Err(e) => {
125                    error!("{:?}", e);
126                    library.cursors.next = None;
127                }
128            }
129            if library.cursors.next.is_none() {
130                break;
131            }
132        }
133
134        Ok(library)
135    }
136
137    /// Fetch download info for a specific file within a Fab listing.
138    pub async fn fab_file_download_info(
139        &self,
140        listing_id: &str,
141        format_id: &str,
142        file_id: &str,
143    ) -> Result<DownloadInfo, EpicAPIError> {
144        let url = format!(
145            "https://www.fab.com/p/egl/listings/{}/asset-formats/{}/files/{}/download-info",
146            listing_id, format_id, file_id
147        );
148        self.authorized_get_json(&url).await
149    }
150
151    /// Search Fab listings. Public endpoint — no auth required.
152    ///
153    /// Use `FabSearchParams` to specify filters, sorting, and pagination.
154    pub async fn fab_search(
155        &self,
156        params: &crate::api::types::fab_search::FabSearchParams,
157    ) -> Result<crate::api::types::fab_search::FabSearchResults, EpicAPIError> {
158        let mut url = "https://www.fab.com/i/listings/search?".to_string();
159        let mut query_parts = Vec::new();
160
161        if let Some(ref q) = params.q {
162            query_parts.push(format!("q={}", q));
163        }
164        if let Some(ref channels) = params.channels {
165            query_parts.push(format!("channels={}", channels));
166        }
167        if let Some(ref listing_types) = params.listing_types {
168            query_parts.push(format!("listing_types={}", listing_types));
169        }
170        if let Some(ref categories) = params.categories {
171            query_parts.push(format!("categories={}", categories));
172        }
173        if let Some(ref sort_by) = params.sort_by {
174            query_parts.push(format!("sort_by={}", sort_by));
175        }
176        if let Some(count) = params.count {
177            query_parts.push(format!("count={}", count));
178        }
179        if let Some(ref cursor) = params.cursor {
180            query_parts.push(format!("cursor={}", cursor));
181        }
182        if let Some(ref aggregate_on) = params.aggregate_on {
183            query_parts.push(format!("aggregate_on={}", aggregate_on));
184        }
185        if let Some(ref in_filter) = params.in_filter {
186            query_parts.push(format!("in={}", in_filter));
187        }
188        if let Some(is_discounted) = params.is_discounted
189            && is_discounted
190        {
191            query_parts.push("is_discounted=true".to_string());
192        }
193        if let Some(is_free) = params.is_free
194            && is_free
195        {
196            query_parts.push("is_free=1".to_string());
197        }
198        if let Some(pct) = params.min_discount_percentage {
199            query_parts.push(format!("min_discount_percentage={}", pct));
200        }
201        if let Some(ref seller) = params.seller {
202            query_parts.push(format!("seller={}", seller));
203        }
204
205        url.push_str(&query_parts.join("&"));
206        self.get_json(&url).await
207    }
208
209    /// Get full listing detail. Public endpoint — no auth required.
210    pub async fn fab_listing(
211        &self,
212        uid: &str,
213    ) -> Result<crate::api::types::fab_search::FabListingDetail, EpicAPIError> {
214        let url = format!("https://www.fab.com/i/listings/{}", uid);
215        self.get_json(&url).await
216    }
217
218    /// Get UE-specific format details for a listing. Public endpoint.
219    pub async fn fab_listing_ue_formats(
220        &self,
221        uid: &str,
222    ) -> Result<Vec<crate::api::types::fab_search::FabListingUeFormat>, EpicAPIError> {
223        let url = format!(
224            "https://www.fab.com/i/listings/{}/asset-formats/unreal-engine",
225            uid
226        );
227        self.get_json(&url).await
228    }
229
230    /// Get user's listing state (ownership, wishlist, review). Requires Fab session.
231    pub async fn fab_listing_state(
232        &self,
233        uid: &str,
234    ) -> Result<crate::api::types::fab_search::FabListingState, EpicAPIError> {
235        let url = format!("https://www.fab.com/i/users/me/listings-states/{}", uid);
236        self.authorized_get_json(&url).await
237    }
238
239    /// Bulk check listing states for multiple IDs. Requires Fab session.
240    pub async fn fab_listing_states_bulk(
241        &self,
242        listing_ids: &[&str],
243    ) -> Result<Vec<crate::api::types::fab_search::FabListingState>, EpicAPIError> {
244        let ids = listing_ids.join(",");
245        let url = format!(
246            "https://www.fab.com/i/users/me/listings-states?listing_ids={}",
247            ids
248        );
249        self.authorized_get_json(&url).await
250    }
251
252    /// Bulk fetch pricing for multiple offer IDs. Public endpoint.
253    pub async fn fab_bulk_prices(
254        &self,
255        offer_ids: &[&str],
256    ) -> Result<crate::api::types::fab_search::FabBulkPricesResponse, EpicAPIError> {
257        let ids = offer_ids
258            .iter()
259            .map(|id| format!("offer_ids={}", id))
260            .collect::<Vec<_>>()
261            .join("&");
262        let url = format!("https://www.fab.com/i/listings/prices-infos?{}", ids);
263        self.get_json(&url).await
264    }
265
266    /// Get listing ownership info. Requires Fab session.
267    pub async fn fab_listing_ownership(
268        &self,
269        uid: &str,
270    ) -> Result<crate::api::types::fab_search::FabOwnership, EpicAPIError> {
271        let url = format!("https://www.fab.com/i/listings/{}/ownership", uid);
272        self.authorized_get_json(&url).await
273    }
274
275    /// Get pricing for a specific listing. Public endpoint.
276    pub async fn fab_listing_prices(
277        &self,
278        uid: &str,
279    ) -> Result<Vec<crate::api::types::fab_search::FabPriceInfo>, EpicAPIError> {
280        let url = format!("https://www.fab.com/i/listings/{}/prices-infos", uid);
281        self.get_json(&url).await
282    }
283
284    /// Get reviews for a listing. Public endpoint.
285    pub async fn fab_listing_reviews(
286        &self,
287        uid: &str,
288        sort_by: Option<&str>,
289        cursor: Option<&str>,
290    ) -> Result<crate::api::types::fab_search::FabReviewsResponse, EpicAPIError> {
291        let mut query_parts = Vec::new();
292        if let Some(sort) = sort_by {
293            query_parts.push(format!("sort_by={}", sort));
294        }
295        if let Some(c) = cursor {
296            query_parts.push(format!("cursor={}", c));
297        }
298        let url = if query_parts.is_empty() {
299            format!("https://www.fab.com/i/store/listings/{}/reviews", uid)
300        } else {
301            format!(
302                "https://www.fab.com/i/store/listings/{}/reviews?{}",
303                uid,
304                query_parts.join("&")
305            )
306        };
307        self.get_json(&url).await
308    }
309
310    /// Fetch available license types. Public endpoint.
311    pub async fn fab_licenses(
312        &self,
313    ) -> Result<Vec<crate::api::types::fab_taxonomy::FabLicenseType>, EpicAPIError> {
314        self.get_json("https://www.fab.com/i/taxonomy/licenses")
315            .await
316    }
317
318    /// Fetch asset format groups. Public endpoint.
319    pub async fn fab_format_groups(
320        &self,
321    ) -> Result<Vec<crate::api::types::fab_taxonomy::FabFormatGroup>, EpicAPIError> {
322        self.get_json("https://www.fab.com/i/taxonomy/asset-format-groups")
323            .await
324    }
325
326    /// Fetch tag groups with nested tags. Public endpoint.
327    pub async fn fab_tag_groups(
328        &self,
329    ) -> Result<Vec<crate::api::types::fab_taxonomy::FabTagGroup>, EpicAPIError> {
330        let wrapper: crate::api::types::fab_taxonomy::FabResultsWrapper<
331            crate::api::types::fab_taxonomy::FabTagGroup,
332        > = self.get_json("https://www.fab.com/i/tags/groups").await?;
333        Ok(wrapper.results)
334    }
335
336    /// Fetch available UE versions. Public endpoint.
337    pub async fn fab_ue_versions(&self) -> Result<Vec<String>, EpicAPIError> {
338        self.get_json("https://www.fab.com/i/unreal-engine/versions")
339            .await
340    }
341
342    /// Fetch channel info by slug. Public endpoint.
343    pub async fn fab_channel(
344        &self,
345        slug: &str,
346    ) -> Result<crate::api::types::fab_taxonomy::FabChannel, EpicAPIError> {
347        let url = format!("https://www.fab.com/i/channels/{}", slug);
348        self.get_json(&url).await
349    }
350
351    /// Search library entitlements with filters and aggregations.
352    /// Uses the browser-path Fab API. Requires Fab session cookies for full results.
353    pub async fn fab_library_entitlements(
354        &self,
355        params: &crate::api::types::fab_entitlement::FabEntitlementSearchParams,
356    ) -> Result<crate::api::types::fab_entitlement::FabEntitlementResults, EpicAPIError> {
357        let mut query_parts = Vec::new();
358        if let Some(ref sort_by) = params.sort_by {
359            query_parts.push(format!("sort_by={}", sort_by));
360        }
361        if let Some(ref cursor) = params.cursor {
362            query_parts.push(format!("cursor={}", cursor));
363        }
364        if let Some(ref listing_types) = params.listing_types {
365            query_parts.push(format!("listing_types={}", listing_types));
366        }
367        if let Some(ref categories) = params.categories {
368            query_parts.push(format!("categories={}", categories));
369        }
370        if let Some(ref tags) = params.tags {
371            query_parts.push(format!("tags={}", tags));
372        }
373        if let Some(ref licenses) = params.licenses {
374            query_parts.push(format!("licenses={}", licenses));
375        }
376        if let Some(ref asset_formats) = params.asset_formats {
377            query_parts.push(format!("asset_formats={}", asset_formats));
378        }
379        if let Some(ref source) = params.source {
380            query_parts.push(format!("source={}", source));
381        }
382        if let Some(ref aggregate_on) = params.aggregate_on {
383            query_parts.push(format!("aggregate_on={}", aggregate_on));
384        }
385        if let Some(count) = params.count {
386            query_parts.push(format!("count={}", count));
387        }
388        if let Some(ref added_since) = params.added_since {
389            query_parts.push(format!("added_since={}", added_since));
390        }
391
392        let url = if query_parts.is_empty() {
393            "https://www.fab.com/i/library/entitlements/search".to_string()
394        } else {
395            format!(
396                "https://www.fab.com/i/library/entitlements/search?{}",
397                query_parts.join("&")
398            )
399        };
400        self.authorized_get_json(&url).await
401    }
402
403    /// Initialize Fab CSRF token. Sets `fab_csrftoken` cookie on the client.
404    pub async fn fab_csrf(&self) -> Result<(), EpicAPIError> {
405        let parsed_url = url::Url::parse("https://www.fab.com/i/csrf")
406            .map_err(|_| EpicAPIError::InvalidParams)?;
407        let response = Self::send(self.client.get(parsed_url)).await?;
408        if response.status().is_success() {
409            Ok(())
410        } else {
411            Err(Self::error_response(response).await)
412        }
413    }
414
415    /// Fetch Fab user context (country, currency, feature flags). Works with just CSRF token.
416    pub async fn fab_user_context(
417        &self,
418    ) -> Result<crate::api::types::fab_search::FabUserContext, EpicAPIError> {
419        self.get_json("https://www.fab.com/i/users/context").await
420    }
421
422    /// Add a free listing to the user's library. Returns `Ok(())` on success (HTTP 204).
423    pub async fn fab_add_to_library(&self, listing_uid: &str) -> Result<(), EpicAPIError> {
424        let url = format!(
425            "https://www.fab.com/i/listings/{}/add-to-library",
426            listing_uid
427        );
428        let parsed_url = Url::parse(&url).map_err(|_| EpicAPIError::InvalidParams)?;
429        let response = self
430            .authorized_post_client(parsed_url)
431            .send()
432            .await
433            .map_err(|e| {
434                error!("{:?}", e);
435                EpicAPIError::NetworkError(e)
436            })?;
437        if response.status() == reqwest::StatusCode::NO_CONTENT
438            || response.status() == reqwest::StatusCode::OK
439        {
440            Ok(())
441        } else {
442            let status = response.status();
443            let body = response.text().await.unwrap_or_default();
444            warn!("{} result: {}", status, body);
445            Err(EpicAPIError::HttpError { status, body })
446        }
447    }
448
449    /// Fetch all available asset formats for a listing (UE, Unity, FBX, Blender, etc.).
450    pub async fn fab_listing_formats(
451        &self,
452        listing_uid: &str,
453    ) -> Result<Vec<crate::api::types::fab_search::FabListingFormat>, EpicAPIError> {
454        let url = format!(
455            "https://www.fab.com/i/listings/{}/asset-formats",
456            listing_uid
457        );
458        self.authorized_get_json(&url).await
459    }
460}
egs_api/api/fab.rs

egs_api/api/
fab.rs
