fix: making clippy happy :)

Author: Glubus

src/models/beatmap/impl.rs

@@ -1,54 +1,10 @@
 use super::query::{exists_by_checksum, find_by_id, get_beatmapset_id, insert::insert};
 use super::types::BeatmapRow;
-use bigdecimal::BigDecimal;
 use sqlx::PgPool;
 
 impl BeatmapRow {
-    pub async fn insert_into_db(
-        pool: &PgPool,
-        osu_id: Option<i32>,
-        beatmapset_id: Option<i32>,
-        difficulty: String,
-        difficulty_rating: BigDecimal,
-        count_circles: i32,
-        count_sliders: i32,
-        count_spinners: i32,
-        max_combo: i32,
-        drain_time: i32,
-        total_time: i32,
-        bpm: BigDecimal,
-        cs: BigDecimal,
-        ar: BigDecimal,
-        od: BigDecimal,
-        hp: BigDecimal,
-        mode: i32,
-        status: String,
-        file_md5: String,
-        file_path: String,
-    ) -> Result<i32, sqlx::Error> {
-        insert(
-            pool,
-            osu_id,
-            beatmapset_id,
-            difficulty,
-            difficulty_rating,
-            count_circles,
-            count_sliders,
-            count_spinners,
-            max_combo,
-            drain_time,
-            total_time,
-            bpm,
-            cs,
-            ar,
-            od,
-            hp,
-            mode,
-            status,
-            file_md5,
-            file_path,
-        )
-        .await
+    pub async fn insert_into_db(self, pool: &PgPool) -> Result<i32, sqlx::Error> {
+        insert(pool, self).await
     }
 
     pub async fn find_by_id(pool: &PgPool, id: i32) -> Result<Option<Self>, sqlx::Error> {

src/models/beatmap/query/insert.rs

@@ -1,28 +1,7 @@
-use bigdecimal::BigDecimal;
+use crate::models::beatmap::types::BeatmapRow;
 use sqlx::{Error as SqlxError, PgPool};
 
-pub async fn insert(
-    pool: &PgPool,
-    osu_id: Option<i32>,
-    beatmapset_id: Option<i32>,
-    difficulty: String,
-    difficulty_rating: BigDecimal,
-    count_circles: i32,
-    count_sliders: i32,
-    count_spinners: i32,
-    max_combo: i32,
-    drain_time: i32,
-    total_time: i32,
-    bpm: BigDecimal,
-    cs: BigDecimal,
-    ar: BigDecimal,
-    od: BigDecimal,
-    hp: BigDecimal,
-    mode: i32,
-    status: String,
-    file_md5: String,
-    file_path: String,
-) -> Result<i32, SqlxError> {
+pub async fn insert(pool: &PgPool, beatmap: BeatmapRow) -> Result<i32, SqlxError> {
     Ok(sqlx::query!(
         r#"
         INSERT INTO beatmap (
@@ -33,25 +12,25 @@ pub async fn insert(
         ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19)
         RETURNING id
         "#,
-        osu_id,
-        beatmapset_id,
-        difficulty,
-        difficulty_rating,
-        count_circles,
-        count_sliders,
-        count_spinners,
-        max_combo,
-        drain_time,
-        total_time,
-        bpm,
-        cs,
-        ar,
-        od,
-        hp,
-        mode,
-        status,
-        file_md5,
-        file_path
+        beatmap.osu_id,
+        beatmap.beatmapset_id,
+        beatmap.difficulty,
+        beatmap.difficulty_rating,
+        beatmap.count_circles,
+        beatmap.count_sliders,
+        beatmap.count_spinners,
+        beatmap.max_combo,
+        beatmap.drain_time,
+        beatmap.total_time,
+        beatmap.bpm,
+        beatmap.cs,
+        beatmap.ar,
+        beatmap.od,
+        beatmap.hp,
+        beatmap.mode,
+        beatmap.status,
+        beatmap.file_md5,
+        beatmap.file_path
     )
     .fetch_one(pool)
     .await?

src/models/beatmapset/impl.rs

@@ -3,43 +3,8 @@ use super::types::BeatmapsetRow;
 use sqlx::PgPool;
 
 impl BeatmapsetRow {
-    pub async fn insert(
-        pool: &PgPool,
-        osu_id: Option<i32>,
-        artist: String,
-        artist_unicode: Option<String>,
-        title: String,
-        title_unicode: Option<String>,
-        creator: String,
-        source: Option<String>,
-        tags: Option<Vec<String>>,
-        has_video: bool,
-        has_storyboard: bool,
-        is_explicit: bool,
-        is_featured: bool,
-        cover_url: Option<String>,
-        preview_url: Option<String>,
-        osu_file_url: Option<String>,
-    ) -> Result<i32, sqlx::Error> {
-        insert(
-            pool,
-            osu_id,
-            artist,
-            artist_unicode,
-            title,
-            title_unicode,
-            creator,
-            source,
-            tags,
-            has_video,
-            has_storyboard,
-            is_explicit,
-            is_featured,
-            cover_url,
-            preview_url,
-            osu_file_url,
-        )
-        .await
+    pub async fn insert(self, pool: &PgPool) -> Result<i32, sqlx::Error> {
+        insert(pool, self).await
     }
 
     pub async fn find_by_id(pool: &PgPool, id: i32) -> Result<Option<Self>, sqlx::Error> {

src/models/beatmapset/query/insert.rs

@@ -1,23 +1,7 @@
+use crate::models::beatmapset::types::BeatmapsetRow;
 use sqlx::{Error as SqlxError, PgPool};
 
-pub async fn insert(
-    pool: &PgPool,
-    osu_id: Option<i32>,
-    artist: String,
-    artist_unicode: Option<String>,
-    title: String,
-    title_unicode: Option<String>,
-    creator: String,
-    source: Option<String>,
-    tags: Option<Vec<String>>,
-    has_video: bool,
-    has_storyboard: bool,
-    is_explicit: bool,
-    is_featured: bool,
-    cover_url: Option<String>,
-    preview_url: Option<String>,
-    osu_file_url: Option<String>,
-) -> Result<i32, SqlxError> {
+pub async fn insert(pool: &PgPool, beatmapset: BeatmapsetRow) -> Result<i32, SqlxError> {
     Ok(sqlx::query!(
         r#"
             INSERT INTO beatmapset (
@@ -43,21 +27,21 @@ pub async fn insert(
                 updated_at = now()
             RETURNING id
             "#,
-        osu_id,
-        artist,
-        artist_unicode.as_deref(),
-        title,
-        title_unicode.as_deref(),
-        creator,
-        source.as_deref(),
-        tags.as_deref(),
-        has_video,
-        has_storyboard,
-        is_explicit,
-        is_featured,
-        cover_url.as_deref(),
-        preview_url.as_deref(),
-        osu_file_url.as_deref()
+        beatmapset.osu_id,
+        beatmapset.artist,
+        beatmapset.artist_unicode.as_deref(),
+        beatmapset.title,
+        beatmapset.title_unicode.as_deref(),
+        beatmapset.creator,
+        beatmapset.source.as_deref(),
+        beatmapset.tags.as_deref(),
+        beatmapset.has_video,
+        beatmapset.has_storyboard,
+        beatmapset.is_explicit,
+        beatmapset.is_featured,
+        beatmapset.cover_url.as_deref(),
+        beatmapset.preview_url.as_deref(),
+        beatmapset.osu_file_url.as_deref()
     )
     .fetch_one(pool)
     .await?

src/models/msd/impl.rs

@@ -2,39 +2,11 @@ use super::query::{
     find_all_by_beatmap_id, find_by_beatmap_id, find_by_beatmap_id_and_rate, find_by_id, insert,
 };
 use super::types::MSDRow;
-use bigdecimal::BigDecimal;
 use sqlx::PgPool;
 
 impl MSDRow {
-    pub async fn insert_into_db(
-        pool: &PgPool,
-        beatmap_id: i32,
-        overall: BigDecimal,
-        stream: BigDecimal,
-        jumpstream: BigDecimal,
-        handstream: BigDecimal,
-        stamina: BigDecimal,
-        jackspeed: BigDecimal,
-        chordjack: BigDecimal,
-        technical: BigDecimal,
-        rate: BigDecimal,
-        main_pattern: Option<String>,
-    ) -> Result<i32, sqlx::Error> {
-        insert(
-            pool,
-            beatmap_id,
-            overall,
-            stream,
-            jumpstream,
-            handstream,
-            stamina,
-            jackspeed,
-            chordjack,
-            technical,
-            rate,
-            main_pattern,
-        )
-        .await
+    pub async fn insert_into_db(self, pool: &PgPool) -> Result<i32, sqlx::Error> {
+        insert(pool, self).await
     }
 
     pub async fn find_by_id(pool: &PgPool, id: i32) -> Result<Option<Self>, sqlx::Error> {

src/models/msd/query/insert.rs

@@ -1,21 +1,8 @@
-use bigdecimal::BigDecimal;
+use crate::models::msd::types::MSDRow;
 
 use sqlx::{Error as SqlxError, PgPool};
 
-pub async fn insert(
-    pool: &PgPool,
-    beatmap_id: i32,
-    overall: BigDecimal,
-    stream: BigDecimal,
-    jumpstream: BigDecimal,
-    handstream: BigDecimal,
-    stamina: BigDecimal,
-    jackspeed: BigDecimal,
-    chordjack: BigDecimal,
-    technical: BigDecimal,
-    rate: BigDecimal,
-    main_pattern: Option<String>,
-) -> Result<i32, SqlxError> {
+pub async fn insert(pool: &PgPool, msd: MSDRow) -> Result<i32, SqlxError> {
     let row = sqlx::query!(
         r#"
             INSERT INTO msd (
@@ -24,17 +11,17 @@ pub async fn insert(
             ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
             RETURNING id
             "#,
-        beatmap_id,
-        overall,
-        stream,
-        jumpstream,
-        handstream,
-        stamina,
-        jackspeed,
-        chordjack,
-        technical,
-        rate,
-        main_pattern
+        msd.beatmap_id,
+        msd.overall,
+        msd.stream,
+        msd.jumpstream,
+        msd.handstream,
+        msd.stamina,
+        msd.jackspeed,
+        msd.chordjack,
+        msd.technical,
+        msd.rate,
+        msd.main_pattern
     )
     .fetch_one(pool)
     .await?;

src/models/pending_beatmap/query/count.rs

@@ -1,9 +1,7 @@
 use sqlx::{Error as SqlxError, PgPool};
 
 pub async fn count(pool: &PgPool) -> Result<i64, SqlxError> {
-    Ok(
-        sqlx::query_scalar::<_, i64>(r#"SELECT COUNT(*) FROM pending_beatmap"#)
-            .fetch_one(pool)
-            .await?,
-    )
+    sqlx::query_scalar::<_, i64>(r#"SELECT COUNT(*) FROM pending_beatmap"#)
+        .fetch_one(pool)
+        .await
 }

src/models/score/impl.rs

@@ -8,37 +8,11 @@ use super::query::{
     update_status::{update_status, update_status_by_hash},
 };
 use super::types::ScoreRow;
-use bigdecimal::BigDecimal;
 use sqlx::PgPool;
 
 impl ScoreRow {
-    pub async fn insert(
-        pool: &PgPool,
-        user_id: i64,
-        beatmap_id: i32,
-        score_metadata_id: i32,
-        replay_id: Option<i32>,
-        rate: BigDecimal,
-        hwid: Option<&str>,
-        mods: i64,
-        hash: &str,
-        rank: &str,
-        status: &str,
-    ) -> Result<Self, sqlx::Error> {
-        insert(
-            pool,
-            user_id,
-            beatmap_id,
-            score_metadata_id,
-            replay_id,
-            rate,
-            hwid,
-            mods,
-            hash,
-            rank,
-            status,
-        )
-        .await
+    pub async fn insert(self, pool: &PgPool) -> Result<Self, sqlx::Error> {
+        insert(pool, self).await
     }
 
     pub async fn exists_by_hash(pool: &PgPool, hash: &str) -> Result<bool, sqlx::Error> {