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

use super::models;
use crate::api::core::models::Error;
use crate::core;
use std::{collections::HashMap, time::Duration};

///
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 list_games(
    &self,
    data: models::ListGamesRequest,
  ) -> Result<models::ListGamesResponse, Error> {
    let mut params = HashMap::new();

    params.insert("vendorKey", data.vendor_key);

    let res = match self
      .client
      .post(format!("{}/games", 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(e) => {
        return Err(Error {
          code: -1,
          msg: Some(e.to_string()),
        });
      }
    };

    match res.status() {
      reqwest::StatusCode::OK => match res.json::<models::_ListGamesResponse>().await {
        Ok(r) => {
          if r.code != 0 {
            return Err(Error {
              code: r.code,
              msg: r.msg,
            });
          }

          let games = match r.games {
            Some(v) => v,
            None => vec![],
          };

          Ok(models::ListGamesResponse { games })
        }
        Err(e) => Err(Error {
          code: -1,
          msg: Some(e.to_string()),
        }),
      },
      _ => Err(Error {
        code: -1,
        msg: None,
      }),
    }
  }

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

    params.insert("vendorKey", data.vendor_key);
    params.insert("gameKey", data.game_key);
    params.insert("username", data.username);
    params.insert("nickname", data.nickname);
    params.insert("siteUsername", data.site_username);

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

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

    if let Some(request_key) = data.request_key {
      params.insert("requestKey", request_key);
    }

    let res = match self
      .client
      .post(format!("{}/play", 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)
      .timeout(Duration::from_secs(10))
      .send()
      .await
    {
      Ok(res) => res,
      Err(e) => {
        return Err(Error {
          code: -1,
          msg: Some(e.to_string()),
        });
      }
    };

    match res.status() {
      reqwest::StatusCode::OK => match res.json::<models::_PlayResponse>().await {
        Ok(r) => {
          if r.code != 0 {
            return Err(Error {
              code: r.code,
              msg: r.msg,
            });
          }

          let user_id = match r.user_id {
            Some(v) => v,
            None => "".to_string(),
          };
          let url = match r.url {
            Some(v) => v,
            None => "".to_string(),
          };
          let balance = match r.balance {
            Some(v) => v,
            None => 0,
          };

          Ok(models::PlayResponse {
            user_id,
            url,
            balance,
          })
        }
        Err(e) => Err(Error {
          code: -1,
          msg: Some(e.to_string()),
        }),
      },
      _ => Err(Error {
        code: -1,
        msg: None,
      }),
    }
  }
}