312 lines
11 KiB
Rust
312 lines
11 KiB
Rust
use axum::{
|
|
Json, debug_handler,
|
|
extract::{Query, State},
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use sqlx::{PgPool, query, query_as, types::Uuid};
|
|
use tower_sessions::Session;
|
|
|
|
use crate::error::AppError;
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct Weapon {
|
|
id: Uuid,
|
|
name: String,
|
|
display: String,
|
|
def_index: i32,
|
|
category: String,
|
|
team: i32,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct SkinInfo {
|
|
id: Uuid,
|
|
weapon_id: Uuid,
|
|
name: String,
|
|
display: String,
|
|
paint_index: i32,
|
|
color: String,
|
|
float: f64,
|
|
min_float: f64,
|
|
max_float: f64,
|
|
pattern: i32,
|
|
}
|
|
|
|
#[axum::debug_handler]
|
|
pub async fn weapons(State(pool): State<PgPool>) -> Result<Json<Vec<Weapon>>, AppError> {
|
|
let weapons = query_as!(Weapon, "SELECT * FROM weapons")
|
|
.fetch_all(&pool)
|
|
.await?;
|
|
Ok(Json(weapons))
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
|
|
enum Teams {
|
|
CT,
|
|
T,
|
|
BOTH,
|
|
}
|
|
|
|
impl Teams {
|
|
fn as_i32(self) -> i32 {
|
|
match self {
|
|
Teams::CT => 0,
|
|
Teams::T => 1,
|
|
Teams::BOTH => 2,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
|
|
enum Categories {
|
|
Knives,
|
|
Gloves,
|
|
Rifles,
|
|
SMGs,
|
|
Pistols,
|
|
Heavy,
|
|
Equipment,
|
|
Weapons, // Special category to get all weapons except gloves and knives
|
|
}
|
|
|
|
impl Categories {
|
|
fn as_str(self) -> &'static str {
|
|
match self {
|
|
Categories::Knives => "Knives",
|
|
Categories::Gloves => "Gloves",
|
|
Categories::Rifles => "Rifles",
|
|
Categories::SMGs => "SMGs",
|
|
Categories::Pistols => "Pistols",
|
|
Categories::Heavy => "Heavy",
|
|
Categories::Equipment => "Equipment",
|
|
Categories::Weapons => "",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct SkinInfoQuery {
|
|
category: Option<Categories>,
|
|
team: Option<Teams>,
|
|
}
|
|
|
|
pub async fn skin_info(
|
|
State(pool): State<PgPool>,
|
|
session: Session,
|
|
Query(info_query): Query<SkinInfoQuery>,
|
|
) -> Result<Json<Vec<SkinInfo>>, AppError> {
|
|
if let Some(uuid) = session.get::<Uuid>("uuid").await? {
|
|
// Fetch all default skins
|
|
let mut default_skins = query!("SELECT w.id, w.name, w.display, w.team, w.category, w.display as wd, s.display as sd, r.color FROM skins s JOIN weapons w ON w.id = s.weapon JOIN rarity r ON r.id = s.rarity WHERE s.default = true").fetch_all(&pool).await?;
|
|
// Filter those skins by team if present in query
|
|
if let Some(team) = info_query.team {
|
|
default_skins = default_skins
|
|
.into_iter()
|
|
.filter(|x| team.as_i32() == x.team || Teams::BOTH.as_i32() == x.team)
|
|
.collect();
|
|
}
|
|
// Same with category
|
|
if let Some(category) = info_query.category {
|
|
default_skins = match category {
|
|
Categories::Weapons => default_skins
|
|
.into_iter()
|
|
.filter(|x| {
|
|
![Categories::Gloves.as_str(), Categories::Knives.as_str()]
|
|
.contains(&x.category.as_str())
|
|
})
|
|
.collect(),
|
|
_ => default_skins
|
|
.into_iter()
|
|
.filter(|x| category.as_str() == x.category)
|
|
.collect(),
|
|
}
|
|
}
|
|
// For each remaining default weapon, see if the user has set a skin
|
|
// Secific cases for Knives and Gloves
|
|
let mut skin_infos = vec![];
|
|
for default in default_skins {
|
|
struct Info {
|
|
id: Uuid,
|
|
weapon_id: Uuid,
|
|
float: f64,
|
|
min_float: f64,
|
|
max_float: f64,
|
|
pattern: i32,
|
|
team: i32,
|
|
name: String,
|
|
wd: String,
|
|
sd: String,
|
|
paint_index: i32,
|
|
color: String,
|
|
}
|
|
let user_skin = match default.category.as_str() {
|
|
"Gloves" | "Knives" => {
|
|
query_as!(Info, "SELECT us.id, w.id as weapon_id, us.float, us.pattern, us.team, w.name, w.display as wd, s.display as sd, s.paint_index, s.min_float, s.max_float, r.color FROM user_skins us JOIN skins s ON us.skin_id = s.id JOIN weapons w ON s.weapon = w.id JOIN rarity r ON r.id = s.rarity WHERE us.user_id = $1 AND w.category = $2", uuid, default.category).fetch_all(&pool).await?
|
|
},
|
|
_ => {
|
|
query_as!(Info, "SELECT us.id, w.id as weapon_id, us.float, us.pattern, us.team, w.name, w.display as wd, s.display as sd, s.paint_index, s.min_float, s.max_float, r.color FROM user_skins us JOIN skins s ON us.skin_id = s.id JOIN weapons w ON s.weapon = w.id JOIN rarity r ON r.id = s.rarity WHERE us.user_id = $1 AND w.id = $2", uuid, default.id).fetch_all(&pool).await?
|
|
}
|
|
};
|
|
let user_skin = if let Some(team) = info_query.team {
|
|
user_skin
|
|
.into_iter()
|
|
.filter(|x| x.team == team.as_i32() || x.team == Teams::BOTH.as_i32())
|
|
.min_by(|x, y| x.team.cmp(&y.team))
|
|
.unwrap_or(Info {
|
|
id: Uuid::nil(),
|
|
weapon_id: default.id,
|
|
float: 0.0,
|
|
min_float: 0.0,
|
|
max_float: 1.0,
|
|
pattern: 0,
|
|
team: 2,
|
|
name: default.name,
|
|
wd: default.wd,
|
|
sd: default.sd,
|
|
paint_index: 0,
|
|
color: default.color,
|
|
})
|
|
} else {
|
|
user_skin
|
|
.into_iter()
|
|
.max_by(|x, y| x.team.cmp(&y.team))
|
|
.unwrap_or(Info {
|
|
id: Uuid::nil(),
|
|
weapon_id: default.id,
|
|
float: 0.0,
|
|
min_float: 0.0,
|
|
max_float: 1.0,
|
|
pattern: 0,
|
|
team: 2,
|
|
name: default.name,
|
|
wd: default.wd,
|
|
sd: default.sd,
|
|
paint_index: 0,
|
|
color: default.color,
|
|
})
|
|
};
|
|
let display = if user_skin.sd.is_empty() {
|
|
user_skin.wd
|
|
} else {
|
|
format!("{} | {}", user_skin.wd, user_skin.sd)
|
|
};
|
|
let info = SkinInfo {
|
|
display,
|
|
id: user_skin.id,
|
|
weapon_id: user_skin.weapon_id,
|
|
name: user_skin.name,
|
|
paint_index: user_skin.paint_index,
|
|
color: user_skin.color,
|
|
float: user_skin.float,
|
|
min_float: user_skin.min_float,
|
|
max_float: user_skin.max_float,
|
|
pattern: user_skin.pattern,
|
|
};
|
|
skin_infos.push(info);
|
|
}
|
|
Ok(Json(skin_infos))
|
|
} else {
|
|
Err(AppError::Unauthorised)
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct AgentInfoQuery {
|
|
team: Teams,
|
|
}
|
|
|
|
#[debug_handler]
|
|
pub async fn agent_info(
|
|
State(pool): State<PgPool>,
|
|
session: Session,
|
|
Query(info_query): Query<AgentInfoQuery>,
|
|
) -> Result<Json<SkinInfo>, AppError> {
|
|
if let Some(uuid) = session.get::<Uuid>("uuid").await? {
|
|
let agent = query!("SELECT us.id, a.id as weapon_id, a.name, a.display, r.color FROM user_skins us JOIN agents a ON a.id = us.agent_id JOIN rarity r ON r.id = a.rarity WHERE us.user_id=$1 AND us.team=$2", uuid, info_query.team.as_i32()).fetch_optional(&pool).await?;
|
|
match agent {
|
|
Some(agent) => Ok(Json(SkinInfo {
|
|
id: agent.id,
|
|
weapon_id: agent.weapon_id,
|
|
name: agent.name,
|
|
display: agent.display,
|
|
paint_index: 0,
|
|
color: agent.color,
|
|
float: 0.0,
|
|
min_float: 0.0,
|
|
max_float: 0.0,
|
|
pattern: 0,
|
|
})),
|
|
None => {
|
|
let default = query!("SELECT a.name, a.id as weapon_id, a.display, r.color FROM agents a JOIN rarity r ON r.id = a.rarity WHERE a.team = $1 AND a.default = true", info_query.team.as_i32()).fetch_one(&pool).await?;
|
|
Ok(Json(SkinInfo {
|
|
id: Uuid::nil(),
|
|
weapon_id: default.weapon_id,
|
|
name: default.name,
|
|
display: default.display,
|
|
paint_index: 0,
|
|
color: default.color,
|
|
float: 0.0,
|
|
min_float: 0.0,
|
|
max_float: 0.0,
|
|
pattern: 0,
|
|
}))
|
|
}
|
|
}
|
|
} else {
|
|
Err(AppError::Unauthorised)
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Default, Debug)]
|
|
pub struct PaintIndexInfo {
|
|
name: String,
|
|
paint_index: i32,
|
|
display: String,
|
|
color: String,
|
|
min_float: f64,
|
|
max_float: f64,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct PaintQuery {
|
|
weapon: Uuid,
|
|
team: Teams,
|
|
agent: Option<bool>,
|
|
}
|
|
|
|
pub async fn list_paint_index(
|
|
State(pool): State<PgPool>,
|
|
Query(paint_query): Query<PaintQuery>,
|
|
) -> Result<Json<Vec<PaintIndexInfo>>, AppError> {
|
|
let agent = match paint_query.agent {
|
|
Some(agent) => agent,
|
|
None => false,
|
|
};
|
|
let paints = if agent {
|
|
let values = query!("SELECT a.name, a.def_index, a.display, r.color FROM agents a JOIN rarity r ON r.id = a.rarity WHERE a.team=$1", paint_query.team.as_i32()).fetch_all(&pool).await?;
|
|
values
|
|
.into_iter()
|
|
.map(|x| PaintIndexInfo {
|
|
name: x.name,
|
|
paint_index: x.def_index,
|
|
display: x.display,
|
|
color: x.color,
|
|
min_float: 0.0,
|
|
max_float: 0.0,
|
|
})
|
|
.collect()
|
|
} else {
|
|
let category = query!(
|
|
"SELECT w.category FROM weapons w WHERE w.id=$1",
|
|
paint_query.weapon
|
|
)
|
|
.fetch_one(&pool)
|
|
.await?;
|
|
match category.category.as_str() {
|
|
"Knives" | "Gloves" => query_as!(PaintIndexInfo, "SELECT w.name, s.paint_index, s.display, r.color, s.min_float, s.max_float FROM skins s JOIN rarity r ON r.id = s.rarity JOIN weapons w ON w.id = s.weapon WHERE w.category=$1", category.category).fetch_all(&pool).await?,
|
|
_ => query_as!(PaintIndexInfo, "SELECT w.name, s.paint_index, s.display, r.color, s.min_float, s.max_float FROM skins s JOIN rarity r ON r.id = s.rarity JOIN weapons w ON w.id = s.weapon WHERE w.id=$1", paint_query.weapon).fetch_all(&pool).await?
|
|
}
|
|
};
|
|
Ok(Json(paints))
|
|
}
|