carbon-zeta-decoder 2.0.0

//! This code was AUTOGENERATED using the Codama library.
pub mod cross_margin_account_manager_row;
pub mod cross_margin_account_row;
pub mod cross_open_orders_map_row;
pub mod greeks_row;
pub mod insurance_deposit_account_row;
pub mod margin_account_row;
pub mod market_indexes_row;
pub mod market_node_row;
pub mod open_orders_map_row;
pub mod perp_sync_queue_row;
pub mod pricing_row;
pub mod referral_account_row;
pub mod referrer_account_row;
pub mod referrer_alias_row;
pub mod settlement_account_row;
pub mod socialized_loss_account_row;
pub mod spread_account_row;
pub mod state_row;
pub mod underlying_row;
pub mod whitelist_deposit_account_row;
pub mod whitelist_insurance_account_row;
pub mod whitelist_trading_fees_account_row;
pub mod zeta_group_row;

pub use self::{
    cross_margin_account_manager_row::*, cross_margin_account_row::*, cross_open_orders_map_row::*,
    greeks_row::*, insurance_deposit_account_row::*, margin_account_row::*, market_indexes_row::*,
    market_node_row::*, open_orders_map_row::*, perp_sync_queue_row::*, pricing_row::*,
    referral_account_row::*, referrer_account_row::*, referrer_alias_row::*,
    settlement_account_row::*, socialized_loss_account_row::*, spread_account_row::*, state_row::*,
    underlying_row::*, whitelist_deposit_account_row::*, whitelist_insurance_account_row::*,
    whitelist_trading_fees_account_row::*, zeta_group_row::*,
};
use super::ZetaAccount;

pub struct ZetaAccountsMigration;

impl sqlx_migrator::Migration<sqlx::Postgres> for ZetaAccountsMigration {
    fn app(&self) -> &str {
        "zeta"
    }

    fn name(&self) -> &str {
        "zeta_accounts"
    }

    fn operations(&self) -> Vec<Box<dyn sqlx_migrator::Operation<sqlx::Postgres>>> {
        vec![
            Box::new(CrossMarginAccountMigrationOperation),
            Box::new(CrossMarginAccountManagerMigrationOperation),
            Box::new(CrossOpenOrdersMapMigrationOperation),
            Box::new(GreeksMigrationOperation),
            Box::new(InsuranceDepositAccountMigrationOperation),
            Box::new(MarginAccountMigrationOperation),
            Box::new(MarketIndexesMigrationOperation),
            Box::new(MarketNodeMigrationOperation),
            Box::new(OpenOrdersMapMigrationOperation),
            Box::new(PerpSyncQueueMigrationOperation),
            Box::new(PricingMigrationOperation),
            Box::new(ReferralAccountMigrationOperation),
            Box::new(ReferrerAccountMigrationOperation),
            Box::new(ReferrerAliasMigrationOperation),
            Box::new(SettlementAccountMigrationOperation),
            Box::new(SocializedLossAccountMigrationOperation),
            Box::new(SpreadAccountMigrationOperation),
            Box::new(StateMigrationOperation),
            Box::new(UnderlyingMigrationOperation),
            Box::new(WhitelistDepositAccountMigrationOperation),
            Box::new(WhitelistInsuranceAccountMigrationOperation),
            Box::new(WhitelistTradingFeesAccountMigrationOperation),
            Box::new(ZetaGroupMigrationOperation),
        ]
    }

    fn parents(&self) -> Vec<Box<dyn sqlx_migrator::Migration<sqlx::Postgres>>> {
        vec![]
    }
}

pub struct ZetaAccountWithMetadata(pub ZetaAccount, pub carbon_core::account::AccountMetadata);

impl From<(ZetaAccount, carbon_core::account::AccountMetadata)> for ZetaAccountWithMetadata {
    fn from(value: (ZetaAccount, carbon_core::account::AccountMetadata)) -> Self {
        ZetaAccountWithMetadata(value.0, value.1)
    }
}

#[async_trait::async_trait]
impl carbon_core::postgres::operations::Insert for ZetaAccountWithMetadata {
    async fn insert(&self, pool: &sqlx::PgPool) -> carbon_core::error::CarbonResult<()> {
        let ZetaAccountWithMetadata(account, metadata) = self;

        match account {
            ZetaAccount::Pricing(account) => {
                let row = pricing_row::PricingRow::from_parts(*account.clone(), metadata.clone());
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::Greeks(account) => {
                let row = greeks_row::GreeksRow::from_parts(*account.clone(), metadata.clone());
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::MarketIndexes(account) => {
                let row = market_indexes_row::MarketIndexesRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::OpenOrdersMap(account) => {
                let row = open_orders_map_row::OpenOrdersMapRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::CrossOpenOrdersMap(account) => {
                let row = cross_open_orders_map_row::CrossOpenOrdersMapRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::State(account) => {
                let row = state_row::StateRow::from_parts(*account.clone(), metadata.clone());
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::Underlying(account) => {
                let row =
                    underlying_row::UnderlyingRow::from_parts(*account.clone(), metadata.clone());
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::SettlementAccount(account) => {
                let row = settlement_account_row::SettlementAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::PerpSyncQueue(account) => {
                let row = perp_sync_queue_row::PerpSyncQueueRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::ZetaGroup(account) => {
                let row =
                    zeta_group_row::ZetaGroupRow::from_parts(*account.clone(), metadata.clone());
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::MarketNode(account) => {
                let row =
                    market_node_row::MarketNodeRow::from_parts(*account.clone(), metadata.clone());
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::SpreadAccount(account) => {
                let row = spread_account_row::SpreadAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::CrossMarginAccountManager(account) => {
                let row =
                    cross_margin_account_manager_row::CrossMarginAccountManagerRow::from_parts(
                        *account.clone(),
                        metadata.clone(),
                    );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::CrossMarginAccount(account) => {
                let row = cross_margin_account_row::CrossMarginAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::MarginAccount(account) => {
                let row = margin_account_row::MarginAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::SocializedLossAccount(account) => {
                let row = socialized_loss_account_row::SocializedLossAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::WhitelistDepositAccount(account) => {
                let row = whitelist_deposit_account_row::WhitelistDepositAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::WhitelistInsuranceAccount(account) => {
                let row = whitelist_insurance_account_row::WhitelistInsuranceAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::InsuranceDepositAccount(account) => {
                let row = insurance_deposit_account_row::InsuranceDepositAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::WhitelistTradingFeesAccount(account) => {
                let row =
                    whitelist_trading_fees_account_row::WhitelistTradingFeesAccountRow::from_parts(
                        *account.clone(),
                        metadata.clone(),
                    );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::ReferrerAccount(account) => {
                let row = referrer_account_row::ReferrerAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::ReferralAccount(account) => {
                let row = referral_account_row::ReferralAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
            ZetaAccount::ReferrerAlias(account) => {
                let row = referrer_alias_row::ReferrerAliasRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.insert(pool).await?;
                Ok(())
            }
        }
    }
}

#[async_trait::async_trait]
impl carbon_core::postgres::operations::Upsert for ZetaAccountWithMetadata {
    async fn upsert(&self, pool: &sqlx::PgPool) -> carbon_core::error::CarbonResult<()> {
        let ZetaAccountWithMetadata(account, metadata) = self;
        match account {
            ZetaAccount::Pricing(account) => {
                let row = pricing_row::PricingRow::from_parts(*account.clone(), metadata.clone());
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::Greeks(account) => {
                let row = greeks_row::GreeksRow::from_parts(*account.clone(), metadata.clone());
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::MarketIndexes(account) => {
                let row = market_indexes_row::MarketIndexesRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::OpenOrdersMap(account) => {
                let row = open_orders_map_row::OpenOrdersMapRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::CrossOpenOrdersMap(account) => {
                let row = cross_open_orders_map_row::CrossOpenOrdersMapRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::State(account) => {
                let row = state_row::StateRow::from_parts(*account.clone(), metadata.clone());
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::Underlying(account) => {
                let row =
                    underlying_row::UnderlyingRow::from_parts(*account.clone(), metadata.clone());
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::SettlementAccount(account) => {
                let row = settlement_account_row::SettlementAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::PerpSyncQueue(account) => {
                let row = perp_sync_queue_row::PerpSyncQueueRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::ZetaGroup(account) => {
                let row =
                    zeta_group_row::ZetaGroupRow::from_parts(*account.clone(), metadata.clone());
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::MarketNode(account) => {
                let row =
                    market_node_row::MarketNodeRow::from_parts(*account.clone(), metadata.clone());
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::SpreadAccount(account) => {
                let row = spread_account_row::SpreadAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::CrossMarginAccountManager(account) => {
                let row =
                    cross_margin_account_manager_row::CrossMarginAccountManagerRow::from_parts(
                        *account.clone(),
                        metadata.clone(),
                    );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::CrossMarginAccount(account) => {
                let row = cross_margin_account_row::CrossMarginAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::MarginAccount(account) => {
                let row = margin_account_row::MarginAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::SocializedLossAccount(account) => {
                let row = socialized_loss_account_row::SocializedLossAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::WhitelistDepositAccount(account) => {
                let row = whitelist_deposit_account_row::WhitelistDepositAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::WhitelistInsuranceAccount(account) => {
                let row = whitelist_insurance_account_row::WhitelistInsuranceAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::InsuranceDepositAccount(account) => {
                let row = insurance_deposit_account_row::InsuranceDepositAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::WhitelistTradingFeesAccount(account) => {
                let row =
                    whitelist_trading_fees_account_row::WhitelistTradingFeesAccountRow::from_parts(
                        *account.clone(),
                        metadata.clone(),
                    );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::ReferrerAccount(account) => {
                let row = referrer_account_row::ReferrerAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::ReferralAccount(account) => {
                let row = referral_account_row::ReferralAccountRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
            ZetaAccount::ReferrerAlias(account) => {
                let row = referrer_alias_row::ReferrerAliasRow::from_parts(
                    *account.clone(),
                    metadata.clone(),
                );
                row.upsert(pool).await?;
                Ok(())
            }
        }
    }
}