refactor: fix database

apps/recorder/src/models/auth.rs

@@ -1,6 +1,54 @@
 use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
 
-pub use super::entities::auth::*;
+#[derive(
+    Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, DeriveDisplay, Serialize, Deserialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "auth_type")]
+#[serde(rename_all = "snake_case")]
+pub enum AuthType {
+    #[sea_orm(string_value = "basic")]
+    Basic,
+    #[sea_orm(string_value = "oidc")]
+    Oidc,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, DeriveEntityModel)]
+#[sea_orm(table_name = "auth")]
+pub struct Model {
+    pub created_at: DateTime,
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub pid: String,
+    pub subscriber_id: i32,
+    pub auth_type: AuthType,
+    pub avatar_url: Option<String>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscribers::Entity",
+        from = "Column::SubscriberId",
+        to = "super::subscribers::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    SubscriberId,
+}
+
+impl Related<super::subscribers::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::SubscriberId.def()
+    }
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelatedEntity)]
+pub enum RelatedEntity {
+    #[sea_orm(entity = "super::subscribers::Entity")]
+    Subscriber,
+}
 
 #[async_trait::async_trait]
 impl ActiveModelBehavior for ActiveModel {}

apps/recorder/src/models/bangumi.rs

@@ -1,7 +1,87 @@
 use loco_rs::app::AppContext;
-use sea_orm::{entity::prelude::*, ActiveValue, TryIntoModel};
+use sea_orm::{entity::prelude::*, sea_query::OnConflict, ActiveValue, FromJsonQueryResult};
+use serde::{Deserialize, Serialize};
 
-pub use super::entities::bangumi::*;
+use super::subscription_bangumi;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct BangumiFilter {
+    pub name: Option<Vec<String>>,
+    pub group: Option<Vec<String>>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct BangumiExtra {
+    pub name_zh: Option<String>,
+    pub s_name_zh: Option<String>,
+    pub name_en: Option<String>,
+    pub s_name_en: Option<String>,
+    pub name_jp: Option<String>,
+    pub s_name_jp: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "bangumi")]
+pub struct Model {
+    pub created_at: DateTime,
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub mikan_bangumi_id: Option<String>,
+    pub subscriber_id: i32,
+    pub display_name: String,
+    pub raw_name: String,
+    pub season: i32,
+    pub season_raw: Option<String>,
+    pub fansub: Option<String>,
+    pub mikan_fansub_id: Option<String>,
+    pub filter: Option<BangumiFilter>,
+    pub rss_link: Option<String>,
+    pub poster_link: Option<String>,
+    pub save_path: Option<String>,
+    #[sea_orm(default = "false")]
+    pub deleted: bool,
+    pub homepage: Option<String>,
+    pub extra: Option<BangumiExtra>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::subscriptions::Entity")]
+    Subscription,
+    #[sea_orm(
+        belongs_to = "super::subscribers::Entity",
+        from = "Column::SubscriberId",
+        to = "super::subscribers::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscriber,
+    #[sea_orm(has_many = "super::episodes::Entity")]
+    Episode,
+}
+
+impl Related<super::episodes::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Episode.def()
+    }
+}
+
+impl Related<super::subscriptions::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::subscription_bangumi::Relation::Subscription.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(super::subscription_bangumi::Relation::Bangumi.def().rev())
+    }
+}
+
+impl Related<super::subscribers::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscriber.def()
+    }
+}
 
 impl Model {
     pub async fn get_or_insert_from_mikan<F>(
@@ -30,12 +110,37 @@ impl Model {
             let mut bgm = ActiveModel {
                 mikan_bangumi_id: ActiveValue::Set(Some(mikan_bangumi_id)),
                 mikan_fansub_id: ActiveValue::Set(Some(mikan_fansub_id)),
-                subscription_id: ActiveValue::Set(subscription_id),
                 subscriber_id: ActiveValue::Set(subscriber_id),
                 ..Default::default()
             };
             f(&mut bgm).await?;
-            let bgm: Model = bgm.save(db).await?.try_into_model()?;
+            let bgm = Entity::insert(bgm)
+                .on_conflict(
+                    OnConflict::columns([
+                        Column::MikanBangumiId,
+                        Column::MikanFansubId,
+                        Column::SubscriberId,
+                    ])
+                    .update_columns([
+                        Column::RawName,
+                        Column::Extra,
+                        Column::Fansub,
+                        Column::PosterLink,
+                        Column::Season,
+                        Column::SeasonRaw,
+                    ])
+                    .to_owned(),
+                )
+                .exec_with_returning(db)
+                .await?;
+            subscription_bangumi::Entity::insert(subscription_bangumi::ActiveModel {
+                subscription_id: ActiveValue::Set(subscription_id),
+                bangumi_id: ActiveValue::Set(bgm.id),
+                ..Default::default()
+            })
+            .on_conflict_do_nothing()
+            .exec(db)
+            .await?;
             Ok(bgm)
         }
     }

apps/recorder/src/models/downloaders.rs

@@ -1,7 +1,59 @@
-use sea_orm::prelude::*;
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
 use url::Url;
 
-pub use crate::models::entities::downloaders::*;
+#[derive(
+    Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, DeriveDisplay, Serialize, Deserialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "downloader_type")]
+#[serde(rename_all = "snake_case")]
+pub enum DownloaderCategory {
+    #[sea_orm(string_value = "qbittorrent")]
+    QBittorrent,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "downloaders")]
+pub struct Model {
+    #[sea_orm(column_type = "Timestamp")]
+    pub created_at: DateTime,
+    #[sea_orm(column_type = "Timestamp")]
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub category: DownloaderCategory,
+    pub endpoint: String,
+    pub password: String,
+    pub username: String,
+    pub subscriber_id: i32,
+    pub save_path: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscribers::Entity",
+        from = "Column::SubscriberId",
+        to = "super::subscribers::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscriber,
+    #[sea_orm(has_many = "super::downloads::Entity")]
+    Download,
+}
+
+impl Related<super::subscribers::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscriber.def()
+    }
+}
+
+impl Related<super::downloads::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Download.def()
+    }
+}
 
 #[async_trait::async_trait]
 impl ActiveModelBehavior for ActiveModel {}
@@ -10,6 +62,7 @@ impl Model {
     pub fn get_endpoint(&self) -> String {
         self.endpoint.clone()
     }
+
     pub fn endpoint_url(&self) -> Result<Url, url::ParseError> {
         let url = Url::parse(&self.endpoint)?;
         Ok(url)

apps/recorder/src/models/downloads.rs

@@ -1,27 +1,107 @@
-use sea_orm::{prelude::*, ActiveValue};
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
 
-use crate::extract::mikan::MikanRssItem;
-pub use crate::models::entities::downloads::*;
+#[derive(
+    Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, DeriveDisplay, Serialize, Deserialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "download_status")]
+#[serde(rename_all = "snake_case")]
+pub enum DownloadStatus {
+    #[sea_orm(string_value = "pending")]
+    Pending,
+    #[sea_orm(string_value = "downloading")]
+    Downloading,
+    #[sea_orm(string_value = "paused")]
+    Paused,
+    #[sea_orm(string_value = "completed")]
+    Completed,
+    #[sea_orm(string_value = "failed")]
+    Failed,
+    #[sea_orm(string_value = "deleted")]
+    Deleted,
+}
+
+#[derive(
+    Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, DeriveDisplay, Serialize, Deserialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "download_mime")]
+pub enum DownloadMime {
+    #[sea_orm(string_value = "application/octet-stream")]
+    #[serde(rename = "application/octet-stream")]
+    OctetStream,
+    #[sea_orm(string_value = "application/x-bittorrent")]
+    #[serde(rename = "application/x-bittorrent")]
+    BitTorrent,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "downloads")]
+pub struct Model {
+    pub created_at: DateTime,
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub raw_name: String,
+    pub display_name: String,
+    pub downloader_id: i32,
+    pub episode_id: i32,
+    pub subscriber_id: i32,
+    pub status: DownloadStatus,
+    pub mime: DownloadMime,
+    pub url: String,
+    pub all_size: Option<u64>,
+    pub curr_size: Option<u64>,
+    pub homepage: Option<String>,
+    pub save_path: Option<String>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscribers::Entity",
+        from = "Column::SubscriberId",
+        to = "super::subscribers::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscriber,
+    #[sea_orm(
+        belongs_to = "super::downloaders::Entity",
+        from = "Column::DownloaderId",
+        to = "super::downloaders::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Downloader,
+    #[sea_orm(
+        belongs_to = "super::episodes::Entity",
+        from = "Column::EpisodeId",
+        to = "super::episodes::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Episode,
+}
+
+impl Related<super::subscribers::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscriber.def()
+    }
+}
+
+impl Related<super::downloaders::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Downloader.def()
+    }
+}
+
+impl Related<super::episodes::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Episode.def()
+    }
+}
 
 #[async_trait::async_trait]
 impl ActiveModelBehavior for ActiveModel {}
 
-impl ActiveModel {
-    pub fn from_mikan_rss_item(m: MikanRssItem, subscription_id: i32) -> Self {
-        let _ = Self {
-            origin_name: ActiveValue::Set(m.title.clone()),
-            display_name: ActiveValue::Set(m.title),
-            subscription_id: ActiveValue::Set(subscription_id),
-            status: ActiveValue::Set(DownloadStatus::Pending),
-            mime: ActiveValue::Set(DownloadMime::BitTorrent),
-            url: ActiveValue::Set(m.url.to_string()),
-            curr_size: ActiveValue::Set(m.content_length.as_ref().map(|_| 0)),
-            all_size: ActiveValue::Set(m.content_length),
-            homepage: ActiveValue::Set(Some(m.homepage.to_string())),
-            ..Default::default()
-        };
-        todo!()
-    }
-}
-
-impl Model {}
+impl ActiveModel {}

apps/recorder/src/models/episodes.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use loco_rs::app::AppContext;
-use sea_orm::{entity::prelude::*, sea_query::OnConflict, ActiveValue};
+use sea_orm::{entity::prelude::*, sea_query::OnConflict, ActiveValue, FromJsonQueryResult};
+use serde::{Deserialize, Serialize};
 
-use super::bangumi;
-pub use super::entities::episodes::*;
+use super::{bangumi, query::InsertManyReturningExt, subscription_episode};
 use crate::{
     app::AppContextExt,
     extract::{
@@ -13,6 +13,92 @@ use crate::{
     },
 };
 
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult, Default)]
+pub struct EpisodeExtra {
+    pub name_zh: Option<String>,
+    pub s_name_zh: Option<String>,
+    pub name_en: Option<String>,
+    pub s_name_en: Option<String>,
+    pub name_jp: Option<String>,
+    pub s_name_jp: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "episodes")]
+pub struct Model {
+    pub created_at: DateTime,
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(indexed)]
+    pub mikan_episode_id: Option<String>,
+    pub raw_name: String,
+    pub display_name: String,
+    pub bangumi_id: i32,
+    pub subscriber_id: i32,
+    pub save_path: Option<String>,
+    pub resolution: Option<String>,
+    pub season: i32,
+    pub season_raw: Option<String>,
+    pub fansub: Option<String>,
+    pub poster_link: Option<String>,
+    pub episode_index: i32,
+    pub homepage: Option<String>,
+    pub subtitle: Option<Vec<String>>,
+    #[sea_orm(default = "false")]
+    pub deleted: bool,
+    pub source: Option<String>,
+    pub extra: EpisodeExtra,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscribers::Entity",
+        from = "Column::SubscriberId",
+        to = "super::subscribers::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscriber,
+    #[sea_orm(
+        belongs_to = "super::bangumi::Entity",
+        from = "Column::BangumiId",
+        to = "super::bangumi::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Bangumi,
+    #[sea_orm(has_many = "super::subscriptions::Entity")]
+    Subscriptions,
+    #[sea_orm(has_one = "super::downloads::Entity")]
+    Downloads,
+}
+
+impl Related<super::bangumi::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Bangumi.def()
+    }
+}
+
+impl Related<super::downloads::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Downloads.def()
+    }
+}
+
+impl Related<super::subscriptions::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscriptions.def()
+    }
+}
+
+impl Related<super::subscribers::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscriber.def()
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct MikanEpsiodeCreation {
     pub episode: MikanEpisodeMeta,
@@ -22,6 +108,7 @@ pub struct MikanEpsiodeCreation {
 impl Model {
     pub async fn add_episodes(
         ctx: &AppContext,
+        subscription_id: i32,
         creations: impl IntoIterator<Item = MikanEpsiodeCreation>,
     ) -> eyre::Result<()> {
         let db = &ctx.db;
@@ -35,13 +122,33 @@ impl Model {
             })
             .flatten();
 
-        Entity::insert_many(new_episode_active_modes)
+        let inserted_episodes = Entity::insert_many(new_episode_active_modes)
             .on_conflict(
                 OnConflict::columns([Column::BangumiId, Column::MikanEpisodeId])
                     .do_nothing()
                     .to_owned(),
             )
-            .on_empty_do_nothing()
+            .exec_with_returning_columns(db, [Column::Id])
+            .await?
+            .into_iter()
+            .flat_map(|r| r.try_get_many_by_index::<i32>());
+
+        let insert_subscription_episode_links = inserted_episodes.into_iter().map(|episode_id| {
+            subscription_episode::ActiveModel::from_subscription_and_episode(
+                subscription_id,
+                episode_id,
+            )
+        });
+
+        subscription_episode::Entity::insert_many(insert_subscription_episode_links)
+            .on_conflict(
+                OnConflict::columns([
+                    subscription_episode::Column::SubscriptionId,
+                    subscription_episode::Column::EpisodeId,
+                ])
+                .do_nothing()
+                .to_owned(),
+            )
             .exec(db)
             .await?;
 
@@ -72,7 +179,6 @@ impl ActiveModel {
             raw_name: ActiveValue::Set(item.episode_title.clone()),
             display_name: ActiveValue::Set(item.episode_title.clone()),
             bangumi_id: ActiveValue::Set(bgm.id),
-            subscription_id: ActiveValue::Set(bgm.subscription_id),
             subscriber_id: ActiveValue::Set(bgm.subscriber_id),
             resolution: ActiveValue::Set(raw_meta.resolution),
             season: ActiveValue::Set(if raw_meta.season > 0 {

apps/recorder/src/models/mod.rs

@@ -2,10 +2,10 @@ pub mod auth;
 pub mod bangumi;
 pub mod downloaders;
 pub mod downloads;
-pub mod entities;
 pub mod episodes;
-pub mod notifications;
 pub mod prelude;
 pub mod query;
 pub mod subscribers;
+pub mod subscription_bangumi;
+pub mod subscription_episode;
 pub mod subscriptions;

apps/recorder/src/models/query/mod.rs

@@ -1,7 +1,8 @@
 use sea_orm::{
     prelude::Expr,
     sea_query::{Alias, IntoColumnRef, IntoTableRef, Query, SelectStatement},
-    Value,
+    ActiveModelTrait, ColumnTrait, ConnectionTrait, DbErr, EntityTrait, Insert, IntoActiveModel,
+    Iterable, QueryResult, QueryTrait, SelectModel, SelectorRaw, Value,
 };
 
 pub fn filter_values_in<
@@ -24,3 +25,76 @@ pub fn filter_values_in<
         .and_where(Expr::col(col_ref).is_not_null())
         .to_owned()
 }
+
+#[async_trait::async_trait]
+pub trait InsertManyReturningExt<A>: Sized
+where
+    <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
+    A: ActiveModelTrait,
+{
+    fn exec_with_returning_models<C>(
+        self,
+        db: &C,
+    ) -> SelectorRaw<SelectModel<<A::Entity as EntityTrait>::Model>>
+    where
+        C: ConnectionTrait;
+
+    async fn exec_with_returning_columns<C, I>(
+        self,
+        db: &C,
+        columns: I,
+    ) -> Result<Vec<QueryResult>, DbErr>
+    where
+        C: ConnectionTrait,
+        I: IntoIterator<Item = <A::Entity as EntityTrait>::Column> + Send;
+}
+
+#[async_trait::async_trait]
+impl<A> InsertManyReturningExt<A> for Insert<A>
+where
+    <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
+    A: ActiveModelTrait + Send,
+{
+    fn exec_with_returning_models<C>(
+        self,
+        db: &C,
+    ) -> SelectorRaw<SelectModel<<A::Entity as EntityTrait>::Model>>
+    where
+        C: ConnectionTrait,
+    {
+        let mut insert_statement = self.into_query();
+        let db_backend = db.get_database_backend();
+        let returning = Query::returning().exprs(
+            <A::Entity as EntityTrait>::Column::iter()
+                .map(|c| c.select_as(c.into_returning_expr(db_backend))),
+        );
+        insert_statement.returning(returning);
+        let insert_statement = db_backend.build(&insert_statement);
+        SelectorRaw::<SelectModel<<A::Entity as EntityTrait>::Model>>::from_statement(
+            insert_statement,
+        )
+    }
+
+    async fn exec_with_returning_columns<C, I>(
+        self,
+        db: &C,
+        columns: I,
+    ) -> Result<Vec<QueryResult>, DbErr>
+    where
+        C: ConnectionTrait,
+        I: IntoIterator<Item = <A::Entity as EntityTrait>::Column> + Send,
+    {
+        let mut insert_statement = self.into_query();
+        let db_backend = db.get_database_backend();
+        let returning = Query::returning().exprs(
+            columns
+                .into_iter()
+                .map(|c| c.select_as(c.into_returning_expr(db_backend))),
+        );
+        insert_statement.returning(returning);
+
+        let statement = db_backend.build(&insert_statement);
+
+        db.query_all(statement).await
+    }
+}

apps/recorder/src/models/subscribers.rs

@@ -2,13 +2,73 @@ use loco_rs::{
     app::AppContext,
     model::{ModelError, ModelResult},
 };
-use sea_orm::{entity::prelude::*, ActiveValue, TransactionTrait};
+use sea_orm::{entity::prelude::*, ActiveValue, FromJsonQueryResult, TransactionTrait};
 use serde::{Deserialize, Serialize};
 
-pub use super::entities::subscribers::*;
-
 pub const SEED_SUBSCRIBER: &str = "konobangu";
 
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct SubscriberBangumiConfig {
+    pub leading_group_tag: Option<bool>,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "subscribers")]
+pub struct Model {
+    pub created_at: DateTime,
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(unique)]
+    pub pid: String,
+    pub display_name: String,
+    pub bangumi_conf: Option<SubscriberBangumiConfig>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::subscriptions::Entity")]
+    Subscription,
+    #[sea_orm(has_many = "super::downloaders::Entity")]
+    Downloader,
+    #[sea_orm(has_many = "super::bangumi::Entity")]
+    Bangumi,
+    #[sea_orm(has_many = "super::episodes::Entity")]
+    Episode,
+    #[sea_orm(has_many = "super::auth::Entity")]
+    Auth,
+}
+
+impl Related<super::subscriptions::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscription.def()
+    }
+}
+
+impl Related<super::downloaders::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Downloader.def()
+    }
+}
+
+impl Related<super::bangumi::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Bangumi.def()
+    }
+}
+
+impl Related<super::episodes::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Episode.def()
+    }
+}
+
+impl Related<super::auth::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Auth.def()
+    }
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct SubscriberIdParams {
     pub id: String,

apps/recorder/src/models/subscription_bangumi.rs

@@ -0,0 +1,56 @@
+use sea_orm::{entity::prelude::*, ActiveValue};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "subscription_bangumi")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub subscription_id: i32,
+    pub bangumi_id: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscriptions::Entity",
+        from = "Column::SubscriptionId",
+        to = "super::subscriptions::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscription,
+    #[sea_orm(
+        belongs_to = "super::bangumi::Entity",
+        from = "Column::BangumiId",
+        to = "super::bangumi::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Bangumi,
+}
+
+impl Related<super::subscriptions::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscription.def()
+    }
+}
+
+impl Related<super::bangumi::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Bangumi.def()
+    }
+}
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {}
+
+impl ActiveModel {
+    pub fn from_subscription_and_bangumi(subscription_id: i32, bangumi_id: i32) -> Self {
+        Self {
+            subscription_id: ActiveValue::Set(subscription_id),
+            bangumi_id: ActiveValue::Set(bangumi_id),
+            ..Default::default()
+        }
+    }
+}

apps/recorder/src/models/subscription_episode.rs

@@ -0,0 +1,56 @@
+use sea_orm::{entity::prelude::*, ActiveValue};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "subscription_episode")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub subscription_id: i32,
+    pub episode_id: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscriptions::Entity",
+        from = "Column::SubscriptionId",
+        to = "super::subscriptions::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscription,
+    #[sea_orm(
+        belongs_to = "super::episodes::Entity",
+        from = "Column::EpisodeId",
+        to = "super::episodes::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Episode,
+}
+
+impl Related<super::subscriptions::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscription.def()
+    }
+}
+
+impl Related<super::episodes::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Episode.def()
+    }
+}
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {}
+
+impl ActiveModel {
+    pub fn from_subscription_and_episode(subscription_id: i32, episode_id: i32) -> Self {
+        Self {
+            subscription_id: ActiveValue::Set(subscription_id),
+            episode_id: ActiveValue::Set(episode_id),
+            ..Default::default()
+        }
+    }
+}

apps/recorder/src/models/subscriptions.rs

@@ -5,7 +5,6 @@ use loco_rs::app::AppContext;
 use sea_orm::{entity::prelude::*, ActiveValue};
 use serde::{Deserialize, Serialize};
 
-pub use super::entities::subscriptions::{self, *};
 use super::{bangumi, episodes, query::filter_values_in};
 use crate::{
     app::AppContextExt,
@@ -24,6 +23,92 @@ use crate::{
     models::episodes::MikanEpsiodeCreation,
 };
 
+#[derive(
+    Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, Serialize, Deserialize, DeriveDisplay,
+)]
+#[sea_orm(
+    rs_type = "String",
+    db_type = "Enum",
+    enum_name = "subscription_category"
+)]
+#[serde(rename_all = "snake_case")]
+pub enum SubscriptionCategory {
+    #[sea_orm(string_value = "mikan")]
+    Mikan,
+    #[sea_orm(string_value = "manual")]
+    Manual,
+}
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "subscriptions")]
+pub struct Model {
+    #[sea_orm(column_type = "Timestamp")]
+    pub created_at: DateTime,
+    #[sea_orm(column_type = "Timestamp")]
+    pub updated_at: DateTime,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub display_name: String,
+    pub subscriber_id: i32,
+    pub category: SubscriptionCategory,
+    pub source_url: String,
+    pub enabled: bool,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::subscribers::Entity",
+        from = "Column::SubscriberId",
+        to = "super::subscribers::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Subscriber,
+    #[sea_orm(has_many = "super::bangumi::Entity")]
+    Bangumi,
+    #[sea_orm(has_many = "super::episodes::Entity")]
+    Episodes,
+    #[sea_orm(has_many = "super::subscription_episode::Entity")]
+    SubscriptionEpisode,
+    #[sea_orm(has_many = "super::subscription_bangumi::Entity")]
+    SubscriptionBangumi,
+}
+
+impl Related<super::subscribers::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Subscriber.def()
+    }
+}
+
+impl Related<super::bangumi::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::subscription_bangumi::Relation::Bangumi.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(
+            super::subscription_bangumi::Relation::Subscription
+                .def()
+                .rev(),
+        )
+    }
+}
+
+impl Related<super::episodes::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::subscription_episode::Relation::Episode.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(
+            super::subscription_episode::Relation::Subscription
+                .def()
+                .rev(),
+        )
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct SubscriptionCreateFromRssDto {
     pub rss_link: String,
@@ -77,7 +162,7 @@ impl Model {
         Ok(subscription.insert(db).await?)
     }
 
-    pub async fn toggle_iters(
+    pub async fn toggle_with_ids(
         ctx: &AppContext,
         ids: impl Iterator<Item = i32>,
         enabled: bool,
@@ -91,7 +176,7 @@ impl Model {
         Ok(())
     }
 
-    pub async fn delete_iters(
+    pub async fn delete_with_ids(
         ctx: &AppContext,
         ids: impl Iterator<Item = i32>,
     ) -> eyre::Result<()> {
@@ -213,6 +298,7 @@ impl Model {
                     );
                     episodes::Model::add_episodes(
                         ctx,
+                        self.id,
                         new_ep_metas.into_iter().map(|item| MikanEpsiodeCreation {
                             episode: item,
                             bangumi: bgm.clone(),