Koucha/koucha/src/db/feed_channel.rs

use crate::{
  Result,
  AdapterPool,
  db::{
    Channel,
    ChannelId,
    Feed,
    FeedId,
    Item,
  },
};

pub struct UnparsedFeedChannel {
  pub channel_id: i64,
  pub feed_id: i64,
}
impl UnparsedFeedChannel {
  pub fn parse(self) -> Result<FeedChannel> {
    Ok(FeedChannel {
      channel_id: ChannelId(self.channel_id),
      feed_id: FeedId(self.feed_id)
    })
  }
}

pub struct FeedChannel {
  channel_id: ChannelId,
  feed_id: FeedId,
}

impl FeedChannel {
  pub async fn get_channel(&self, pool: &AdapterPool) -> Result<Channel> {
    Channel::get(pool, self.channel_id).await
  }
  pub async fn get_feed(&self, pool: &AdapterPool) -> Result<Feed> {
    Feed::get(pool, self.feed_id).await
  }

  pub async fn add_item(
    &self, pool: &AdapterPool, item: &Item
  ) -> Result<()> {
    let int_item_id = i64::from(item.id());
    let int_feed_id = i64::from(self.feed_id);

    sqlx::query!(
      "INSERT OR IGNORE INTO feed_items (feed_id, item_id, score)
       VALUES (?, ?, 5)", // TODO: Add in scoring featuress
      int_feed_id, int_item_id
    ).execute(&pool.0).await?;
    Ok(())
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use reqwest::Url;
  use crate::{
    db::{
      Channel,
      FeedId,
      User
    },
    test_utils::{
      FEED1, setup_adapter,
    },
  };

  #[test]
  fn parse() {
    const CID: i64 = 1;
    const FID: i64 = 1;
    let ufc = UnparsedFeedChannel {
      channel_id: CID,
      feed_id: FID,
    };

    let fc = ufc.parse().unwrap();

    assert_eq!(fc.channel_id.0, CID);
    assert_eq!(fc.feed_id.0, FID);
  }

  // FeedChannel Tests
  #[tokio::test]
  async fn get_channel() {
    let adapter = setup_adapter().await;
    let pool = adapter.get_pool();

    let url = Url::parse(FEED1).unwrap();
    let channel = Channel::get_or_create(pool, url).await.unwrap();

    let fc = FeedChannel {
      channel_id: channel.id(),
      feed_id: FeedId(1), // Fake Feed
    };

    let channel_from_fc = fc.get_channel(pool).await.unwrap();
    assert_eq!(channel_from_fc.id(), channel.id());
  }
  
  #[tokio::test]
  async fn get_feed() {
    let adapter = setup_adapter().await;
    let pool = adapter.get_pool();

    let user = User::create(pool, "Alice").await.unwrap();
    let feed = Feed::create(pool, user.id(), "My Feed").await.unwrap();

    let fc = FeedChannel {
      channel_id: ChannelId(1), // Fake Channel
      feed_id: feed.id(),
    };

    let feed_from_fc = fc.get_feed(pool).await.unwrap();
    assert_eq!(feed_from_fc.id(), feed.id());
  }
  
  #[tokio::test]
  pub async fn add_item() {
    let adapter = setup_adapter().await;
    let pool = adapter.get_pool();

    let user = User::create(pool, "Alice").await.unwrap();
    let feed = Feed::create(pool, user.id(), "My Feed").await.unwrap();
    let url = Url::parse(FEED1).unwrap();
    let channel = Channel::get_or_create(pool, url).await.unwrap();
    let fc = FeedChannel {
      channel_id: channel.id(),
      feed_id: feed.id(),
    };

    let item = Item::get_or_create(pool, channel.id(), "item-guid").await.unwrap();
    fc.add_item(pool, &item).await.unwrap();

    let items = feed.get_items(pool, 1, 0).await.unwrap();
    assert_eq!(items[0].id(), item.id());
  }
}