backend/service/

map.rs

//! Service layer for maps.

use actix_http::StatusCode;
use postgis_diesel::types::{Point, Polygon};
use uuid::Uuid;

use crate::{
    config::{auth::user_info::UserInfo, data::SharedPool},
    error::ServiceError,
    model::{
        dto::{
            base_layer_images::BaseLayerImageDto, layers::LayerDto, MapDto, MapSearchParameters,
            NewMapDto, Page, PageParameters, UpdateMapDto, UpdateMapGeometryDto,
        },
        entity::{base_layer_images::BaseLayerImages, layers::Layer, Map, MapCollaborator},
        r#enum::layer_type::LayerType,
    },
};

/// Defines which layers should be created when a new map is created.
const LAYER_TYPES: [LayerType; 6] = [
    LayerType::Base,
    LayerType::Drawing,
    LayerType::Soiltexture,
    LayerType::Hydrology,
    LayerType::Shade,
    LayerType::Plants,
];

/// Search maps from the database.
///
/// # Errors
/// If the connection to the database could not be established.
pub async fn find(
    search_parameters: MapSearchParameters,
    page_parameters: PageParameters,
    pool: &SharedPool,
    user_info: UserInfo,
) -> Result<Page<MapDto>, ServiceError> {
    let mut conn = pool.get().await?;
    let collaborating_in = MapCollaborator::find_by_user_id(user_info.id, &mut conn).await?;
    let result = Map::find(
        search_parameters,
        page_parameters,
        &mut conn,
        user_info,
        collaborating_in,
    )
    .await?;
    Ok(result)
}

/// Find a map by id in the database.
///
/// # Errors
/// If the connection to the database could not be established.
pub async fn find_by_id(id: i64, pool: &SharedPool) -> Result<MapDto, ServiceError> {
    let mut conn = pool.get().await?;
    let result = Map::find_by_id(id, &mut conn).await?;
    Ok(result)
}

/// Create a new map in the database.
///
/// # Errors
/// If the connection to the database could not be established.
pub async fn create(
    new_map: NewMapDto,
    user_id: Uuid,
    pool: &SharedPool,
) -> Result<MapDto, ServiceError> {
    let mut conn = pool.get().await?;

    if Map::is_name_taken(&new_map.name, &mut conn).await? {
        return Err(ServiceError::new(
            StatusCode::CONFLICT,
            "Map name already taken",
        ));
    }

    let geometry_validation_result = is_valid_map_geometry(&new_map.geometry);
    if let Some(error) = geometry_validation_result {
        return Err(error);
    }

    let result = Map::create(new_map, user_id, &mut conn).await?;
    for (layer_type, order_index) in LAYER_TYPES.iter().zip(0..) {
        let new_layer = LayerDto {
            id: Uuid::now_v7(),
            type_: *layer_type,
            name: format!("{layer_type} Layer"),
            map_id: result.id,
            order_index,
            marked_deleted: false,
        };
        let layer = Layer::create(result.id.into(), new_layer, &mut conn).await?;

        // Immediately initialize a base layer image,
        // because the frontend would always have to create one
        // anyway.
        if layer.type_ == LayerType::Base {
            BaseLayerImages::create(
                BaseLayerImageDto {
                    id: Uuid::now_v7(),
                    layer_id: layer.id,
                    path: String::new(),
                    rotation: 0,
                    scale: 100,
                    x: 0,
                    y: 0,
                },
                &mut conn,
            )
            .await?;
        }
    }

    Ok(result)
}

/// Update a map in the database.
/// Checks if the map is owned by the requesting user.
///
/// # Errors
/// If the connection to the database could not be established.
/// If the requesting user is not the owner of the map.
pub async fn update(
    map_update: UpdateMapDto,
    id: i64,
    pool: &SharedPool,
) -> Result<MapDto, ServiceError> {
    let mut conn = pool.get().await?;

    let result = Map::update(map_update, id, &mut conn).await?;
    Ok(result)
}

/// Update a maps geometry in the database.
/// Checks if the map is owned by the requesting user.
///
/// # Errors
/// * If the connection to the database could not be established.
/// * If the requesting user is not the owner of the map.
pub async fn update_geometry(
    map_update_geometry: UpdateMapGeometryDto,
    id: i64,
    pool: &SharedPool,
) -> Result<MapDto, ServiceError> {
    let mut conn = pool.get().await?;

    let geometry_validation_result = is_valid_map_geometry(&map_update_geometry.geometry);
    if let Some(error) = geometry_validation_result {
        return Err(error);
    }

    let result = Map::update_geometry(map_update_geometry, id, &mut conn).await?;
    Ok(result)
}

/// Soft-deletes a map from the database.
/// Checks if the map is owned by the requesting user.
///
/// # Errors
/// * If the connection to the database could not be established.
/// * If the requesting user is not the owner of the map.
pub async fn delete_by_id(id: i64, pool: &SharedPool) -> Result<MapDto, ServiceError> {
    let mut conn = pool.get().await?;

    let result = Map::mark_for_deletion(id, &mut conn).await?;

    Ok(result)
}

/// Checks if a Polygon can be used as a maps geometry attribute.
fn is_valid_map_geometry(geometry: &Polygon<Point>) -> Option<ServiceError> {
    if geometry.rings.len() != 1 {
        return Some(ServiceError {
            status_code: StatusCode::BAD_REQUEST,
            reason: "Map geometry must have exactly one ring".to_owned(),
        });
    }

    let geometry_points_length = geometry.rings.get(0).unwrap_or(&Vec::new()).len();

    if geometry_points_length < 3 + 1 {
        return Some(ServiceError {
            status_code: StatusCode::BAD_REQUEST,
            reason: "Map geometry must be a polygon of at least three points.".to_owned(),
        });
    }

    None
}