post_archiver/importer/

post.rs

use std::{collections::HashSet, fmt::Debug};

use chrono::{DateTime, Utc};
use rusqlite::params;

use crate::{
    error::Result,
    manager::{
        PostArchiverConnection, PostArchiverManager, UpdateAuthor, UpdateCollection, UpdatePost,
    },
    AuthorId, CollectionId, Comment, Content, PlatformId, PostId, POSTS_PRE_CHUNK,
};

use super::{collection::UnsyncCollection, tag::UnsyncTag, UnsyncFileMeta};

impl<T> PostArchiverManager<T>
where
    T: PostArchiverConnection,
{
    /// Import a post into the archive.
    ///
    /// If the post already exists (by source), it updates its title, platform, published date,
    ///
    /// # Parameters
    ///
    /// - `update_relation`: update the relations of authors and collections after importing.
    ///
    /// # Errors
    ///
    /// Returns `Error` if there was an error accessing the database.
    pub fn import_post(
        &self,
        post: UnsyncPost,
        update_relation: bool,
    ) -> Result<(PostId, Vec<AuthorId>, Vec<CollectionId>)> {
        macro_rules! import_many {
            ($vec:expr => $method:ident) => {
                $vec.into_iter()
                    .map(|d| self.$method(d))
                    .collect::<std::result::Result<Vec<_>, _>>()?
            };
        }

        // find post by source
        let existing: Option<PostId> = self.find_post(&post.source)?;

        let id = match existing {
            Some(id) => {
                let b = self.bind(id);
                b.update(
                    UpdatePost::default()
                        .title(post.title)
                        .platform(Some(post.platform))
                        .published(post.published.unwrap_or_else(Utc::now))
                        .updated_by_latest(post.updated.unwrap_or_else(Utc::now)),
                )?;
                id
            }
            None => {
                // insert new post
                let mut stmt = self.conn().prepare_cached(
                    "INSERT INTO posts (title, source, platform, published, updated) VALUES (?, ?, ?, ?, ?) RETURNING id",
                )?;
                let published = post.published.unwrap_or_else(Utc::now);
                let updated = post.updated.unwrap_or_else(Utc::now);
                stmt.query_row(
                    params![post.title, post.source, post.platform, published, updated],
                    |row| row.get(0),
                )?
            }
        };

        let b = self.bind(id);

        let mut thumb = post
            .thumb
            .as_ref()
            .map(|thumb| self.import_file_meta(id, thumb))
            .transpose()?;

        let content = post
            .content
            .iter()
            .map(|content| {
                Ok(match content {
                    UnsyncContent::Text(text) => Content::Text(text.clone()),
                    UnsyncContent::File(file) => {
                        let need_thumb = thumb.is_none() && file.mime.starts_with("image/");
                        let file_meta = self.import_file_meta(id, file)?;
                        need_thumb.then(|| thumb = Some(file_meta));
                        Content::File(file_meta)
                    }
                })
            })
            .collect::<Result<Vec<_>>>()?;
        b.update(
            UpdatePost::default()
                .content(content)
                .thumb(thumb)
                .comments(post.comments),
        )?;

        let tags = import_many!(post.tags => import_tag);
        b.add_tags(&tags)?;

        let collections = import_many!(post.collections => import_collection);
        b.add_collections(&collections)?;

        b.add_authors(&post.authors)?;

        //
        let path = self
            .path
            .join((id.raw() / POSTS_PRE_CHUNK).to_string())
            .join((id.raw() % POSTS_PRE_CHUNK).to_string());

        for f in post
            .content
            .into_iter()
            .flat_map(|c| match c {
                UnsyncContent::Text(_) => None,
                UnsyncContent::File(file) => Some(file),
            })
            .chain(post.thumb)
        {
            let path = path.join(f.filename);
            if let Some(parent) = path.parent() {
                std::fs::create_dir_all(parent)?;
            };
            f.data.write(&path)?;
        }

        if update_relation {
            post.authors.iter().try_for_each(|&author| {
                self.bind(author).update(
                    UpdateAuthor::default()
                        .thumb_by_latest()
                        .updated_by_latest(),
                )
            })?;

            collections.iter().try_for_each(|&collection| {
                self.bind(collection)
                    .update(UpdateCollection::default().thumb_by_latest())
            })?;
        }

        Ok((
            id,
            post.authors.into_iter().collect(),
            collections.into_iter().collect(),
        ))
    }

    /// Import multiple posts into the archive.
    ///
    /// This function processes each post, importing its authors, collections, and files.
    ///
    /// # Parameters
    ///
    /// - `update_relation`: update the relations of authors and collections after importing.
    ///
    /// # Errors
    ///
    /// Returns `Error` if there was an error accessing the database.
    pub fn import_posts<U>(
        &self,
        posts: impl IntoIterator<Item = UnsyncPost>,
        update_relation: bool,
    ) -> Result<Vec<PostId>> {
        let mut total_author = HashSet::new();
        let mut total_collections = HashSet::new();
        let mut results = Vec::new();

        for post in posts {
            let (id, authors, collections) = self.import_post(post, false)?;

            results.push(id);
            total_author.extend(authors);
            total_collections.extend(collections);
        }

        if update_relation {
            total_author.into_iter().try_for_each(|author| {
                self.bind(author).update(
                    UpdateAuthor::default()
                        .thumb_by_latest()
                        .updated_by_latest(),
                )
            })?;

            total_collections.into_iter().try_for_each(|collection| {
                self.bind(collection)
                    .update(UpdateCollection::default().thumb_by_latest())
            })?;
        }

        Ok(results)
    }
}

#[derive(Debug, Clone)]
/// Represents a post that is not yet synchronized with the archive.
pub struct UnsyncPost {
    /// The original URL of this post (e.g., "https://example.com/blog/1")
    pub source: String,
    /// The title of the post
    pub title: String,
    /// The post's content items (text and file references)
    pub content: Vec<UnsyncContent>,
    /// Optional thumbnail image for the post
    pub thumb: Option<UnsyncFileMeta>,
    /// Comments on the post
    pub comments: Vec<Comment>,
    /// When the post was updated
    pub updated: Option<DateTime<Utc>>,
    /// When the post was published
    pub published: Option<DateTime<Utc>>,
    /// Platform associated with the post
    pub platform: PlatformId,
    /// Tags associated with the post
    pub tags: Vec<UnsyncTag>,
    /// The IDs of the author who created this post
    pub authors: Vec<AuthorId>,
    /// The collections this post belongs to
    pub collections: Vec<UnsyncCollection>,
}

impl UnsyncPost {
    pub fn new(
        platform: PlatformId,
        source: String,
        title: String,
        content: Vec<UnsyncContent>,
    ) -> Self {
        Self {
            source,
            title,
            content,
            thumb: None,
            comments: Vec::new(),
            updated: None,
            published: None,
            platform,
            tags: Vec::new(),
            authors: Vec::new(),
            collections: Vec::new(),
        }
    }

    pub fn source(self, source: String) -> Self {
        Self { source, ..self }
    }

    pub fn title(self, title: String) -> Self {
        Self { title, ..self }
    }

    pub fn content(self, content: Vec<UnsyncContent>) -> Self {
        Self { content, ..self }
    }

    pub fn thumb(self, thumb: Option<UnsyncFileMeta>) -> Self {
        Self { thumb, ..self }
    }

    pub fn comments(self, comments: Vec<Comment>) -> Self {
        Self { comments, ..self }
    }

    pub fn updated(self, updated: DateTime<Utc>) -> Self {
        Self {
            updated: Some(updated),
            ..self
        }
    }

    pub fn published(self, published: DateTime<Utc>) -> Self {
        Self {
            published: Some(published),
            ..self
        }
    }

    pub fn platform(self, platform: PlatformId) -> Self {
        Self { platform, ..self }
    }

    pub fn tags(self, tags: Vec<UnsyncTag>) -> Self {
        Self { tags, ..self }
    }

    pub fn authors(self, authors: Vec<AuthorId>) -> Self {
        Self { authors, ..self }
    }

    pub fn collections(self, collections: Vec<UnsyncCollection>) -> Self {
        Self {
            collections,
            ..self
        }
    }
}

#[derive(Debug, Clone)]
pub enum UnsyncContent {
    Text(String),
    File(UnsyncFileMeta),
}