libertas/libertas_core/src/services.rs

use async_trait::async_trait;
use uuid::Uuid;

use crate::{
    authz::Permission,
    error::CoreResult,
    models::{
        Album, AlbumPermission, FaceRegion, Media, MediaBundle, Person, PersonPermission,
        PublicAlbumBundle, Tag, User,
    },
    schema::{
        AddMediaToAlbumData, CreateAlbumData, CreateUserData, ListMediaOptions, LoginUserData,
        PaginatedResponse, ShareAlbumData, UpdateAlbumData, UploadMediaData,
    },
};

#[async_trait]
pub trait MediaService: Send + Sync {
    async fn upload_media(&self, data: UploadMediaData<'_>) -> CoreResult<Media>;
    async fn get_media_details(&self, id: Uuid, user_id: Option<Uuid>) -> CoreResult<MediaBundle>;
    async fn list_user_media(
        &self,
        user_id: Uuid,
        options: ListMediaOptions,
    ) -> CoreResult<PaginatedResponse<Media>>;
    async fn get_media_filepath(&self, id: Uuid, user_id: Option<Uuid>) -> CoreResult<String>;
    async fn get_media_thumbnail_path(&self, id: Uuid, user_id: Option<Uuid>)
    -> CoreResult<String>;
    async fn get_media_for_serving(&self, id: Uuid, user_id: Option<Uuid>) -> CoreResult<Media>;
    async fn delete_media(&self, id: Uuid, user_id: Uuid) -> CoreResult<()>;
}

#[async_trait]
pub trait UserService: Send + Sync {
    async fn register(&self, data: CreateUserData<'_>) -> CoreResult<User>;
    async fn login(&self, data: LoginUserData<'_>) -> CoreResult<String>;
    async fn get_user_details(&self, user_id: uuid::Uuid) -> CoreResult<User>;
    async fn search_users(&self, query: &str) -> CoreResult<Vec<User>>;
}

#[async_trait]
pub trait AlbumService: Send + Sync {
    async fn create_album(&self, data: CreateAlbumData<'_>) -> CoreResult<Album>;
    async fn get_album_details(&self, album_id: Uuid, user_id: Uuid) -> CoreResult<Album>;
    async fn add_media_to_album(&self, data: AddMediaToAlbumData, user_id: Uuid) -> CoreResult<()>;
    async fn list_user_albums(&self, user_id: Uuid) -> CoreResult<Vec<Album>>;
    async fn share_album(&self, data: ShareAlbumData, owner_id: Uuid) -> CoreResult<()>;
    async fn update_album(
        &self,
        album_id: Uuid,
        user_id: Uuid,
        data: UpdateAlbumData<'_>,
    ) -> CoreResult<Album>;
    async fn delete_album(&self, album_id: Uuid, user_id: Uuid) -> CoreResult<()>;
    async fn get_public_album_bundle(&self, album_id: Uuid) -> CoreResult<PublicAlbumBundle>;
    async fn set_album_thumbnail(
        &self,
        album_id: Uuid,
        media_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<()>;
    async fn get_album_media(&self, album_id: Uuid, user_id: Uuid) -> CoreResult<Vec<Media>>;
    async fn remove_media_from_album(
        &self,
        album_id: Uuid,
        media_ids: &[Uuid],
        user_id: Uuid,
    ) -> CoreResult<()>;
    async fn get_album_shares(
        &self,
        album_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<Vec<(User, AlbumPermission)>>;

    async fn unshare_album(
        &self,
        album_id: Uuid,
        target_user_id: Uuid,
        owner_id: Uuid,
    ) -> CoreResult<()>;
}

#[async_trait]
pub trait TagService: Send + Sync {
    async fn add_tags_to_media(
        &self,
        media_id: Uuid,
        tag_names: &[String],
        user_id: Uuid,
    ) -> CoreResult<Vec<Tag>>;
    async fn remove_tags_from_media(
        &self,
        media_id: Uuid,
        tag_names: &[String],
        user_id: Uuid,
    ) -> CoreResult<()>;
    async fn list_tags_for_media(&self, media_id: Uuid, user_id: Uuid) -> CoreResult<Vec<Tag>>;
}

#[async_trait]
pub trait PersonService: Send + Sync {
    async fn create_person(&self, name: &str, owner_id: Uuid) -> CoreResult<Person>;
    async fn get_person(&self, person_id: Uuid, user_id: Uuid) -> CoreResult<Person>;
    async fn list_people(&self, user_id: Uuid) -> CoreResult<Vec<Person>>;
    async fn update_person(&self, person_id: Uuid, name: &str, user_id: Uuid)
    -> CoreResult<Person>;
    async fn delete_person(&self, person_id: Uuid, user_id: Uuid) -> CoreResult<()>;

    async fn assign_face_to_person(
        &self,
        face_region_id: Uuid,
        person_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<FaceRegion>;

    async fn list_faces_for_media(
        &self,
        media_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<Vec<FaceRegion>>;

    async fn share_person(
        &self,
        person_id: Uuid,
        target_user_id: Uuid,
        permission: PersonPermission,
        owner_id: Uuid,
    ) -> CoreResult<()>;

    async fn unshare_person(
        &self,
        person_id: Uuid,
        target_user_id: Uuid,
        owner_id: Uuid,
    ) -> CoreResult<()>;

    async fn merge_people(
        &self,
        target_person_id: Uuid,
        source_person_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<()>;

    async fn set_person_thumbnail(
        &self,
        person_id: Uuid,
        face_region_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<()>;

    async fn cluster_unassigned_faces(&self, user_id: Uuid) -> CoreResult<()>;

    async fn list_media_for_person(
        &self,
        person_id: Uuid,
        user_id: Uuid,
        options: ListMediaOptions,
    ) -> CoreResult<PaginatedResponse<Media>>;

    async fn get_person_shares(
        &self,
        person_id: Uuid,
        user_id: Uuid,
    ) -> CoreResult<Vec<(User, PersonPermission)>>;
}

#[async_trait]
pub trait AuthorizationService: Send + Sync {
    async fn check_permission(
        &self,
        user_id: Option<Uuid>,
        permission: Permission,
    ) -> CoreResult<()>;
}