Backend heatmap

backend/migrations/2023-07-03-165000_heatmap/down.sql

@@ -0,0 +1,3 @@
+-- This file should undo anything in `up.sql`
+DROP FUNCTION calculate_score;
+ALTER TABLE maps DROP COLUMN map_geom;

backend/migrations/2023-07-03-165000_heatmap/up.sql

@@ -0,0 +1,30 @@
+-- Your SQL goes here
+ALTER TABLE maps ADD COLUMN map_geom GEOMETRY(POLYGON, 4326) NOT NULL;
+
+CREATE OR REPLACE FUNCTION calculate_score(map_id INTEGER, plant_id INTEGER, num_rows INTEGER, num_cols INTEGER)
+RETURNS TABLE(score FLOAT, x INTEGER, y INTEGER) AS $$
+DECLARE
+    map_geometry GEOMETRY(POLYGON, 4326);
+    cell GEOMETRY;
+BEGIN
+    SELECT map_geom FROM maps WHERE id = map_id INTO map_geometry;
+
+    -- TODO: include plant in calculation (e.g. for shade)
+    FOR i IN 0..num_rows-1 LOOP
+        FOR j IN 0..num_cols-1 LOOP
+            cell := ST_Translate(ST_GeomFromEWKT('SRID=4326;POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))'), i, j);
+
+            IF ST_Intersects(cell, map_geometry) THEN
+                -- TODO: calculate score
+                score := 0.5;
+            ELSE
+                score := 0.0;
+            END IF;
+            x := i;
+            y := j;
+
+            RETURN NEXT;
+        END LOOP;
+    END LOOP;
+END;
+$$ LANGUAGE plpgsql;

backend/src/config/api_doc.rs

@@ -2,7 +2,7 @@
 
 use actix_web::web;
 use utoipa::{
-    openapi::security::{AuthorizationCode, Flow, OAuth2, Password, Scopes, SecurityScheme},
+    openapi::security::{AuthorizationCode, Flow, OAuth2, Scopes, SecurityScheme},
     Modify, OpenApi,
 };
 use utoipa_swagger_ui::SwaggerUi;
@@ -72,6 +72,7 @@ struct PlantsApiDoc;
 #[derive(OpenApi)]
 #[openapi(
     paths(
+        map::heatmap,
         map::find,
         map::find_by_id,
         map::create
@@ -186,14 +187,11 @@ impl Modify for SecurityAddon {
         let components = openapi.components.as_mut().unwrap();
 
         let config = &Config::get().openid_configuration;
-        let oauth2 = OAuth2::new([
-            Flow::AuthorizationCode(AuthorizationCode::new(
-                config.authorization_endpoint.clone(),
-                config.token_endpoint.clone(),
-                Scopes::new(),
-            )),
-            Flow::Password(Password::new(config.token_endpoint.clone(), Scopes::new())),
-        ]);
+        let oauth2 = OAuth2::new([Flow::AuthorizationCode(AuthorizationCode::new(
+            config.authorization_endpoint.clone(),
+            config.token_endpoint.clone(),
+            Scopes::new(),
+        ))]);
         components.add_security_scheme("oauth2", SecurityScheme::OAuth2(oauth2));
     }
 }

backend/src/config/routes.rs

@@ -29,6 +29,7 @@ pub fn config(cfg: &mut web::ServiceConfig) {
         )
         .service(
             web::scope("/maps")
+                .service(map::heatmap)
                 .service(map::find)
                 .service(map::find_by_id)
                 .service(map::create)

backend/src/controller/map.rs

@@ -9,9 +9,31 @@ use actix_web::{
 
 use crate::config::auth::user_info::UserInfo;
 use crate::config::data::AppDataInner;
-use crate::model::dto::{MapSearchParameters, PageParameters};
+use crate::model::dto::{HeatMapQueryParams, MapSearchParameters, PageParameters};
 use crate::{model::dto::NewMapDto, service};
 
+#[utoipa::path(
+    context_path = "/api/maps",
+    params(
+        HeatMapQueryParams
+    ),
+    responses(
+        (status = 200, description = "Generate a heatmap to find ideal locations to plant the plant", body = Vec<Vec<f64>>)
+    ),
+    security(
+        ("oauth2" = [])
+    )
+)]
+#[get("/heatmap")]
+pub async fn heatmap(
+    query_params: Query<HeatMapQueryParams>,
+    app_data: Data<AppDataInner>,
+) -> Result<HttpResponse> {
+    // TODO: figure out where to put endpoint
+    let response = service::map::heatmap(query_params.into_inner(), &app_data).await?;
+    Ok(HttpResponse::Ok().json(response))
+}
+
 /// Endpoint for fetching or searching all [`Map`](crate::model::entity::Map).
 /// Search parameters are taken from the URLs query string (e.g. .../api/maps?is_inactive=false&per_page=5).
 /// If no page parameters are provided, the first page is returned.

backend/src/model/dto.rs

@@ -344,3 +344,10 @@ pub enum SuggestionType {
     /// Suggests plants based on diversity criteria.
     Diversity,
 }
+
+#[typeshare]
+#[derive(Debug, Deserialize, IntoParams)]
+pub struct HeatMapQueryParams {
+    pub map_id: i32,
+    pub plant_id: i32,
+}

backend/src/model/dto/new_map_impl.rs

@@ -1,5 +1,6 @@
 //! Contains the implementation of [`NewMapDto`].
 
+use postgis_diesel::types::{Point, Polygon};
 use uuid::Uuid;
 
 use crate::model::entity::NewMap;
@@ -8,8 +9,38 @@ use super::NewMapDto;
 
 impl From<(NewMapDto, Uuid)> for NewMap {
     fn from((new_map, owner_id): (NewMapDto, Uuid)) -> Self {
+        let mut map_geom = Polygon::new(Some(4326));
+        map_geom.add_points(vec![
+            Point {
+                x: 0.0,
+                y: 0.0,
+                srid: None,
+            },
+            Point {
+                x: 5.0,
+                y: 0.0,
+                srid: None,
+            },
+            Point {
+                x: 5.0,
+                y: 5.0,
+                srid: None,
+            },
+            Point {
+                x: 0.0,
+                y: 5.0,
+                srid: None,
+            },
+            Point {
+                x: 0.0,
+                y: 0.0,
+                srid: None,
+            },
+        ]);
+
         Self {
             name: new_map.name,
+            map_geom,
             creation_date: new_map.creation_date,
             deletion_date: new_map.deletion_date,
             last_visit: new_map.last_visit,

backend/src/model/entity.rs

@@ -14,6 +14,7 @@ use chrono::NaiveDateTime;
 use diesel::QueryableByName;
 use diesel::{Identifiable, Insertable, Queryable};
 use postgis_diesel::types::Point;
+use postgis_diesel::types::Polygon;
 use uuid::Uuid;
 
 use crate::schema::{layers, maps, plants, seeds};
@@ -742,6 +743,8 @@ pub struct Map {
     pub location: Option<Point>,
     /// The id of the owner of the map.
     pub owner_id: Uuid,
+    /// The geometry of the map.
+    pub map_geom: Polygon<Point>,
 }
 
 /// The `NewMap` entity.
@@ -774,6 +777,8 @@ pub struct NewMap {
     pub location: Option<Point>,
     /// The id of the owner of the map.
     pub owner_id: Uuid,
+    /// The geometry of the map.
+    pub map_geom: Polygon<Point>,
 }
 
 /// The `Layer` entity.

backend/src/model/entity/map_impl.rs

@@ -2,10 +2,10 @@
 
 use diesel::dsl::sql;
 use diesel::pg::Pg;
-use diesel::sql_types::Float;
+use diesel::sql_types::{Double, Float, Integer};
 use diesel::{
     debug_query, BoolExpressionMethods, ExpressionMethods, PgTextExpressionMethods, QueryDsl,
-    QueryResult,
+    QueryResult, QueryableByName,
 };
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use log::debug;
@@ -22,7 +22,42 @@ use crate::{
 
 use super::{Map, NewMap};
 
+#[derive(Debug, Clone, QueryableByName)]
+pub struct HeatMapElement {
+    #[diesel(sql_type = Double)]
+    pub score: f64,
+    #[diesel(sql_type = Integer)]
+    pub x: i32,
+    #[diesel(sql_type = Integer)]
+    pub y: i32,
+}
+
 impl Map {
+    pub async fn heatmap(
+        map_id: i32,
+        plant_id: i32,
+        conn: &mut AsyncPgConnection,
+    ) -> QueryResult<Vec<Vec<f64>>> {
+        // TODO: Compute from the maps geometry
+        let num_rows = 10; // TODO: Calculate number of rows
+        let num_cols = 10; // TODO: Calculate number of columns
+
+        let query = diesel::sql_query("SELECT * FROM calculate_score($1, $2, $3, $4)")
+            .bind::<Integer, _>(map_id)
+            .bind::<Integer, _>(plant_id)
+            .bind::<Integer, _>(num_rows)
+            .bind::<Integer, _>(num_cols);
+
+        let result = query.load::<HeatMapElement>(conn).await?;
+
+        // TODO: figure out how to handle actual values (return matrix to frontend, create image, return matrix as binary?)
+        let mut heatmap = vec![vec![0.0; num_cols as usize]; num_rows as usize];
+        for HeatMapElement { score, x, y } in result {
+            heatmap[x as usize][y as usize] = score;
+        }
+        Ok(heatmap)
+    }
+
     /// Get the top maps matching the search query.
     ///
     /// Can be filtered by `is_inactive` and `owner_id` if provided in `search_parameters`.

backend/src/schema.patch

@@ -1,33 +1,38 @@
-diff --git a/backend/src/schema.rs b/backend/src/schema.rs
-index 16c1826d..d33481b0 100644
---- a/backend/src/schema.rs
-+++ b/backend/src/schema.rs
-@@ -14,16 +14,12 @@ pub mod sql_types {
-     pub struct Fertility;
+--- src/schema.rs	2023-07-03 18:30:12.781088814 +0200
++++ "src/schema copy.rs"	2023-07-03 18:31:06.642898879 +0200
+@@ -15,20 +15,12 @@
 
      #[derive(diesel::sql_types::SqlType)]
      #[diesel(postgres_type(name = "flower_type"))]
      pub struct FlowerType;
 
--    #[derive(diesel::sql_types::SqlType)]
+     #[derive(diesel::sql_types::SqlType)]
 -    #[diesel(postgres_type(name = "geography"))]
 -    pub struct Geography;
 -
-     #[derive(diesel::sql_types::SqlType)]
+-    #[derive(diesel::sql_types::SqlType)]
+-    #[diesel(postgres_type(name = "geometry"))]
+-    pub struct Geometry;
+-
+-    #[derive(diesel::sql_types::SqlType)]
      #[diesel(postgres_type(name = "growth_rate"))]
      pub struct GrowthRate;
 
      #[derive(diesel::sql_types::SqlType)]
      #[diesel(postgres_type(name = "herbaceous_or_woody"))]
-@@ -86,14 +82,13 @@ diesel::table! {
+     pub struct HerbaceousOrWoody;
+@@ -104,16 +96,15 @@
+         is_alternative -> Bool,
      }
  }
 
  diesel::table! {
      use postgis_diesel::sql_types::Geography;
++    use postgis_diesel::sql_types::Geometry;
      use diesel::sql_types::*;
      use super::sql_types::PrivacyOptions;
 -    use super::sql_types::Geography;
+-    use super::sql_types::Geometry;
 
      maps (id) {
          id -> Int4,

backend/src/service/map.rs

@@ -4,7 +4,7 @@ use actix_web::web::Data;
 use uuid::Uuid;
 
 use crate::config::data::AppDataInner;
-use crate::model::dto::{MapSearchParameters, Page};
+use crate::model::dto::{HeatMapQueryParams, MapSearchParameters, Page};
 use crate::model::dto::{NewLayerDto, PageParameters};
 use crate::model::entity::Layer;
 use crate::model::r#enum::layer_type::LayerType;
@@ -19,6 +19,15 @@ use crate::{
 /// Defines which layers should be created when a new map is created.
 const LAYER_TYPES: [LayerType; 2] = [LayerType::Base, LayerType::Plants];
 
+pub async fn heatmap(
+    query_params: HeatMapQueryParams,
+    app_data: &Data<AppDataInner>,
+) -> Result<Vec<Vec<f64>>, ServiceError> {
+    let mut conn = app_data.pool.get().await?;
+    let result = Map::heatmap(query_params.map_id, query_params.plant_id, &mut conn).await?;
+    Ok(result)
+}
+
 /// Search maps from the database.
 ///
 /// # Errors