Add optional area scope for opening hour humanizer

Author: bubelov

src/db/main/element/blocking_queries.rs

@@ -1,4 +1,5 @@
 use super::schema::{self, Columns, Element};
+use crate::db::main::area_element::schema::{self as area_element_schema};
 use crate::{service::overpass::OverpassElement, Result};
 use rusqlite::{named_params, params, Connection};
 use serde_json::{Map, Value};
@@ -177,6 +178,40 @@ pub fn select_with_opening_hours_without_humanization(
         .map_err(Into::into)
 }
 
+pub fn select_with_opening_hours_without_humanization_by_area(
+    area_id: i64,
+    limit: i64,
+    conn: &Connection,
+) -> Result<Vec<Element>> {
+    let table = schema::TABLE_NAME;
+    let sql = format!(
+        r#"
+            SELECT {table}.{id}, {table}.{overpass_data}, {table}.{tags}, {table}.{lat}, {table}.{lon}, {table}.{created_at}, {table}.{updated_at}, {table}.{deleted_at}
+            FROM {table}
+            INNER JOIN {area_element_table} ae ON ae.element_id = {table}.id AND ae.area_id = ?1 AND ae.deleted_at IS NULL
+            WHERE json_extract({table}.{overpass_data}, '$.tags.opening_hours') IS NOT NULL
+            AND json_extract({table}.{tags}, '$.opening_hours:en:human_readable') IS NULL
+            AND {table}.{deleted_at} IS NULL
+            ORDER BY RANDOM()
+            LIMIT ?2
+        "#,
+        table = table,
+        id = Columns::Id.as_str(),
+        overpass_data = Columns::OverpassData.as_str(),
+        tags = Columns::Tags.as_str(),
+        lat = Columns::Lat.as_str(),
+        lon = Columns::Lon.as_str(),
+        created_at = Columns::CreatedAt.as_str(),
+        updated_at = Columns::UpdatedAt.as_str(),
+        deleted_at = Columns::DeletedAt.as_str(),
+        area_element_table = area_element_schema::TABLE_NAME,
+    );
+    conn.prepare(&sql)?
+        .query_map(params![area_id, limit], Element::mapper())?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(Into::into)
+}
+
 pub fn select_by_id_or_osm_id(id: impl Into<String>, conn: &Connection) -> Result<Element> {
     let id: String = id.into();
     let id = id.as_str();

src/db/main/element/queries.rs

@@ -81,6 +81,21 @@ pub async fn select_with_opening_hours_without_humanization(
         .await?
 }
 
+pub async fn select_with_opening_hours_without_humanization_by_area(
+    area_id: i64,
+    limit: i64,
+    pool: &Pool,
+) -> Result<Vec<Element>> {
+    pool.get()
+        .await?
+        .interact(move |conn| {
+            blocking_queries::select_with_opening_hours_without_humanization_by_area(
+                area_id, limit, conn,
+            )
+        })
+        .await?
+}
+
 pub async fn select_by_osm_type_and_id(
     osm_type: String,
     osm_id: i64,

src/rpc/handler.rs

@@ -51,7 +51,7 @@ pub enum RpcMethod {
     SyncElements,
     GenerateElementIcons,
     GenerateElementCategories,
-    HumanizeWorkingHours,
+    HumanizeOpeningHours,
     GetElementIssues,
     GenerateElementCommentCounts,
     // area
@@ -409,9 +409,9 @@ pub async fn handle(
             req.id.clone(),
             super::generate_element_categories::run(params(req.params)?, &pool).await?,
         ),
-        RpcMethod::HumanizeWorkingHours => RpcResponse::from(
+        RpcMethod::HumanizeOpeningHours => RpcResponse::from(
             req.id.clone(),
-            super::humanize_working_hours::run(params(req.params)?, &pool).await?,
+            super::humanize_opening_hours::run(params(req.params)?, &pool).await?,
         ),
         RpcMethod::GetElementIssues => RpcResponse::from(
             req.id.clone(),

src/rpc/humanize_working_hours.rs src/rpc/humanize_opening_hours.rssrc/rpc/humanize_working_hours.rs renamed to src/rpc/humanize_opening_hours.rs

@@ -11,6 +11,7 @@ use tracing::info;
 #[derive(Deserialize)]
 pub struct Params {
     max_places: i64,
+    area: Option<i64>,
 }
 
 #[derive(Serialize)]
@@ -29,11 +30,20 @@ pub struct Res {
 }
 
 pub async fn run(params: Params, pool: &Pool) -> Result<Res> {
-    let elements = db::main::element::queries::select_with_opening_hours_without_humanization(
-        params.max_places,
-        pool,
-    )
-    .await?;
+    let elements = if let Some(area_id) = params.area {
+        db::main::element::queries::select_with_opening_hours_without_humanization_by_area(
+            area_id,
+            params.max_places,
+            pool,
+        )
+        .await?
+    } else {
+        db::main::element::queries::select_with_opening_hours_without_humanization(
+            params.max_places,
+            pool,
+        )
+        .await?
+    };
 
     let mut results = Vec::new();
 
@@ -49,7 +59,7 @@ pub async fn run(params: Params, pool: &Pool) -> Result<Res> {
 Source format (OSM opening_hours specification - formal and hard to read):
 {}
 
-Target format: Human readable, multi-line string where each day of the week is on a separate line, using full day names in English. Use 24-hour time format.
+Target format: Human readable, multi-line string where each day of the week is on a separate line, using full day names in English. Use 24-hour time format. Always list all days. For closed days just print "closed" instead of opening hours.
 
 Example:
 

src/rpc/mod.rs

@@ -19,7 +19,7 @@ pub mod get_trending_communities;
 pub mod get_trending_countries;
 pub mod get_user_activity;
 pub mod handler;
-pub mod humanize_working_hours;
+pub mod humanize_opening_hours;
 pub mod import;
 pub mod invoice;
 pub mod log;