beteran-api-kgon-server-service/src/api/betting/api.rs

use super::models;
use crate::core;
use std::collections::HashMap;

///
pub struct Api {
  client: reqwest::Client,
  api_config: core::config::ApiConfig,
}

impl std::fmt::Debug for Api {
  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    f.debug_struct("Api of api.kgon.identity").finish()
  }
}

impl Api {
  ///
  pub fn new(api_config: core::config::ApiConfig) -> Api {
    Api {
      client: reqwest::Client::new(),
      api_config,
    }
  }

  ///
  pub async fn find_transactions(
    &self,
    data: models::FindTransactionsRequest,
  ) -> Result<models::FindTransactionsResponse, models::Error> {
    let mut params = HashMap::new();

    if let Some(vendor_key) = data.vendor_key {
      params.insert("vendorKey", vendor_key);
    }
    if let Some(sdate) = data.sdate {
      params.insert("sdate", sdate);
    }
    if let Some(edate) = data.edate {
      params.insert("edate", edate);
    }
    if let Some(group_key) = data.group_key {
      params.insert("groupKey", group_key);
    }
    if let Some(username) = data.username {
      params.insert("username", username);
    }

    params.insert("limit", data.limit.to_string());

    let res = match self
      .client
      .post(format!("{}/transaction", self.api_config.k_url))
      .header(reqwest::header::ACCEPT, "application/json")
      .header(
        reqwest::header::CONTENT_TYPE,
        "application/x-www-form-urlencoded",
      )
      .header("k-secret", self.api_config.k_secret.as_str())
      .header("k-username", self.api_config.k_username.as_str())
      .send()
      .await
    {
      Ok(res) => res,
      Err(err) => {
        return Err(models::Error { code: 0, msg: None });
      }
    };

    match res.status() {
      reqwest::StatusCode::OK => match res.json::<models::FindTransactionsResponse>().await {
        Ok(r) => Ok(r),
        Err(e) => Err(models::Error { code: 0, msg: None }),
      },
      _ => Err(models::Error { code: 0, msg: None }),
    }
  }

  ///
  pub async fn find_gragmatic_history(
    &self,
    data: models::FindPragmaticHistoryRequest,
  ) -> Result<models::FindPragmaticHistoryResponse, models::Error> {
    let mut params = HashMap::new();

    params.insert("id", data.id);

    let res = match self
      .client
      .post(format!("{}/pragmatic/history", self.api_config.k_url))
      .header(reqwest::header::ACCEPT, "application/json")
      .header(
        reqwest::header::CONTENT_TYPE,
        "application/x-www-form-urlencoded",
      )
      .header("k-secret", self.api_config.k_secret.as_str())
      .header("k-username", self.api_config.k_username.as_str())
      .form(&params)
      .send()
      .await
    {
      Ok(res) => res,
      Err(err) => {
        return Err(models::Error { code: 0, msg: None });
      }
    };

    match res.status() {
      reqwest::StatusCode::OK => match res.json::<models::FindPragmaticHistoryResponse>().await {
        Ok(r) => Ok(r),
        Err(e) => Err(models::Error { code: 0, msg: None }),
      },
      _ => Err(models::Error { code: 0, msg: None }),
    }
  }

  ///
  pub async fn find_evolution_transaction_detail(
    &self,
    data: models::FindEvolutionTransactionDetailRequest,
  ) -> Result<models::FindEvolutionTransactionDetailResponse, models::Error> {
    let mut params = HashMap::new();

    params.insert("ids", data.ids);

    let res = match self
      .client
      .post(format!(
        "{}/evolution/transaction/detail",
        self.api_config.k_url
      ))
      .header(reqwest::header::ACCEPT, "application/json")
      .header(
        reqwest::header::CONTENT_TYPE,
        "application/x-www-form-urlencoded",
      )
      .header("k-secret", self.api_config.k_secret.as_str())
      .header("k-username", self.api_config.k_username.as_str())
      .form(&params)
      .send()
      .await
    {
      Ok(res) => res,
      Err(err) => {
        return Err(models::Error { code: 0, msg: None });
      }
    };

    match res.status() {
      reqwest::StatusCode::OK => match res
        .json::<models::FindEvolutionTransactionDetailResponse>()
        .await
      {
        Ok(r) => Ok(r),
        Err(e) => Err(models::Error { code: 0, msg: None }),
      },
      _ => Err(models::Error { code: 0, msg: None }),
    }
  }

  ///
  pub async fn find_statistic(
    &self,
    data: models::FindStatisticRequest,
  ) -> Result<models::FindStatisticResponse, models::Error> {
    let mut params = HashMap::new();

    if let Some(vendor_key) = data.vendor_key {
      params.insert("vendorKey", vendor_key);
    }
    if let Some(group_key) = data.group_key {
      params.insert("groupKey", group_key);
    }
    if let Some(date) = data.date {
      params.insert("date", date);
    }

    let res = match self
      .client
      .post(format!("{}/statistic", self.api_config.k_url))
      .header(reqwest::header::ACCEPT, "application/json")
      .header(
        reqwest::header::CONTENT_TYPE,
        "application/x-www-form-urlencoded",
      )
      .header("k-secret", self.api_config.k_secret.as_str())
      .header("k-username", self.api_config.k_username.as_str())
      .form(&params)
      .send()
      .await
    {
      Ok(res) => res,
      Err(err) => {
        return Err(models::Error { code: 0, msg: None });
      }
    };

    match res.status() {
      reqwest::StatusCode::OK => match res.json::<models::FindStatisticResponse>().await {
        Ok(r) => Ok(r),
        Err(e) => Err(models::Error { code: 0, msg: None }),
      },
      _ => Err(models::Error { code: 0, msg: None }),
    }
  }
}