Add top countries endpoint

Author: bubelov

src/db/main/area/blocking_queries.rs

@@ -407,6 +407,69 @@ pub fn select_top_communities(conn: &Connection) -> Result<Vec<CommunityStats>>
     Ok(results)
 }
 
+pub fn select_top_areas_by_type(conn: &Connection, area_type: &str) -> Result<Vec<CommunityStats>> {
+    let year_ago = time::OffsetDateTime::now_utc()
+        .saturating_sub(time::Duration::days(365))
+        .date()
+        .to_string();
+
+    let sql = format!(
+        r#"
+            WITH community_areas AS (
+                SELECT id, alias, tags
+                FROM area
+                WHERE deleted_at IS NULL
+                AND json_extract(tags, '$.type') = '{area_type}'
+            ),
+            element_stats AS (
+                SELECT 
+                    ca.id as area_id,
+                    COUNT(e.id) as total_elements,
+                    SUM(CASE 
+                        WHEN (COALESCE(json_extract(e.overpass_data, '$.tags.survey:date'), '2000-01-01') > '{year_ago}'
+                            OR COALESCE(json_extract(e.overpass_data, '$.tags.check_date'), '2000-01-01') > '{year_ago}'
+                            OR COALESCE(json_extract(e.overpass_data, '$.tags.check_date:currency:XBT'), '2000-01-01') > '{year_ago}')
+                        THEN 1 ELSE 0 
+                    END) as verified_1y
+                FROM community_areas ca
+                INNER JOIN area_element ae ON ae.area_id = ca.id AND ae.deleted_at IS NULL
+                INNER JOIN element e ON e.id = ae.element_id AND e.deleted_at IS NULL
+                GROUP BY ca.id
+            )
+            SELECT 
+                ca.id,
+                ca.alias,
+                COALESCE(json_extract(ca.tags, '$.name'), '') as name,
+                json_extract(ca.tags, '$.icon:square') as icon_url,
+                COALESCE(es.total_elements, 0) as places_total,
+                COALESCE(es.verified_1y, 0) as places_verified_1y
+            FROM community_areas ca
+            LEFT JOIN element_stats es ON es.area_id = ca.id
+            ORDER BY 
+                (COALESCE(es.verified_1y, 0) - (COALESCE(es.total_elements, 0) - COALESCE(es.verified_1y, 0)) * 5) DESC,
+                COALESCE(es.total_elements, 0) DESC
+        "#
+    );
+
+    let mut stmt = conn.prepare(&sql)?;
+    let rows = stmt.query_map([], |row| {
+        Ok(CommunityStats {
+            id: row.get(0)?,
+            alias: row.get(1)?,
+            name: row.get(2)?,
+            icon_url: row.get(3)?,
+            places_total: row.get(4)?,
+            places_verified_1y: row.get(5)?,
+        })
+    })?;
+
+    let mut results = Vec::new();
+    for row in rows {
+        results.push(row?);
+    }
+    Ok(results)
+}
+
 #[cfg(test)]
 mod test {
     use super::schema::Area;

src/db/main/area/queries.rs

@@ -147,3 +147,11 @@ pub async fn select_top_communities(pool: &Pool) -> Result<Vec<CommunityStats>>
         .interact(|conn| blocking_queries::select_top_communities(conn))
         .await?
 }
+
+pub async fn select_top_areas_by_type(pool: &Pool, area_type: &str) -> Result<Vec<CommunityStats>> {
+    let area_type = area_type.to_string();
+    pool.get()
+        .await?
+        .interact(move |conn| blocking_queries::select_top_areas_by_type(conn, &area_type))
+        .await?
+}

src/main.rs

@@ -177,7 +177,8 @@ async fn main() -> Result<()> {
                     .service(scope("areas").service(rest::v4::areas::get))
                     .service(scope("dashboard").service(rest::v4::dashboard::get))
                     .service(scope("top-editors").service(rest::v4::top_editors::get))
-                    .service(scope("communities").service(rest::v4::communities::get_top)),
+                    .service(scope("communities").service(rest::v4::communities::get_top))
+                    .service(scope("countries").service(rest::v4::countries::get_top)),
             )
     })
     .client_request_timeout(Duration::from_millis(0))

src/rest/v4/countries.rs

@@ -0,0 +1,99 @@
+use crate::db::main::area::blocking_queries::CommunityStats;
+use crate::db::main::MainPool;
+use crate::rest::error::RestApiError;
+use crate::rest::error::RestResult as Res;
+use actix_web::get;
+use actix_web::web::Data;
+use actix_web::web::Json;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct Country {
+    pub id: i64,
+    pub alias: String,
+    pub name: String,
+    pub icon: Option<String>,
+    pub places_total: i64,
+    pub places_verified_1y: i64,
+    pub grade: i32,
+}
+
+fn calculate_grade(places_total: i64, places_verified_1y: i64) -> i32 {
+    if places_total == 0 {
+        return 1;
+    }
+    let percentage = (places_verified_1y as f64 / places_total as f64) * 100.0;
+    if percentage >= 95.0 {
+        5
+    } else if percentage >= 75.0 {
+        4
+    } else if percentage >= 50.0 {
+        3
+    } else if percentage >= 25.0 {
+        2
+    } else {
+        1
+    }
+}
+
+#[get("/top")]
+pub async fn get_top(pool: Data<MainPool>) -> Res<Vec<Country>> {
+    let countries = crate::db::main::area::queries::select_top_areas_by_type(&pool, "country")
+        .await
+        .map_err(|_| RestApiError::database())?;
+
+    let result: Vec<Country> = countries
+        .into_iter()
+        .map(|c: CommunityStats| Country {
+            id: c.id,
+            alias: c.alias,
+            name: c.name,
+            icon: c.icon_url,
+            places_total: c.places_total,
+            places_verified_1y: c.places_verified_1y,
+            grade: calculate_grade(c.places_total, c.places_verified_1y),
+        })
+        .collect();
+
+    Ok(Json(result))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_calculate_grade_zero_places() {
+        assert_eq!(calculate_grade(0, 0), 1);
+    }
+
+    #[test]
+    fn test_calculate_grade_0_to_25_percent() {
+        assert_eq!(calculate_grade(100, 0), 1);
+        assert_eq!(calculate_grade(100, 24), 1);
+    }
+
+    #[test]
+    fn test_calculate_grade_25_to_50_percent() {
+        assert_eq!(calculate_grade(100, 25), 2);
+        assert_eq!(calculate_grade(100, 49), 2);
+    }
+
+    #[test]
+    fn test_calculate_grade_50_to_75_percent() {
+        assert_eq!(calculate_grade(100, 50), 3);
+        assert_eq!(calculate_grade(100, 74), 3);
+    }
+
+    #[test]
+    fn test_calculate_grade_75_to_95_percent() {
+        assert_eq!(calculate_grade(100, 75), 4);
+        assert_eq!(calculate_grade(100, 94), 4);
+    }
+
+    #[test]
+    fn test_calculate_grade_95_plus_percent() {
+        assert_eq!(calculate_grade(100, 95), 5);
+        assert_eq!(calculate_grade(100, 100), 5);
+    }
+}

src/rest/v4/mod.rs

@@ -1,5 +1,6 @@
 pub mod areas;
 pub mod communities;
+pub mod countries;
 pub mod dashboard;
 pub mod element_issues;
 pub mod events;