Struct Model

pub struct Model {
    pub api_key_id: PrimaryId,
    pub id: String,
    pub uuid: Uuid,
    pub is_active: bool,
    pub updated_at: Option<DateTime>,
    pub created_at: DateTime,
    pub key: String,
}

Fields

api_key_id: PrimaryId

id: String

uuid: Uuid

is_active: bool

updated_at: Option<DateTime>

created_at: DateTime

key: String

Implementations

impl Model

pub fn new_model() -> ActiveModel

pub async fn get_by_uuid(db: &Db, uuid: &Uuid) -> Result<Option<Self>>

pub fn format(&self) -> Self

Trait Implementations

impl BasicModel for Model

type ActiveModel = ActiveModel

fn create<'life0, 'async_trait>( db: &'life0 Db, data: Self::ActiveModel, ) -> Pin<Box<dyn Future<Output = Result<<<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn create_many<'life0, 'async_trait>( db: &'life0 Db, data: Vec<Self::ActiveModel>, ) -> Pin<Box<dyn Future<Output = Result<<<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn get<'life0, 'async_trait>( db: &'life0 Db, primary_id: <<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType, ) -> Pin<Box<dyn Future<Output = Result<Option<<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::Model>, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn get_by_id<'life0, 'life1, 'async_trait>( db: &'life0 Db, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::Model>, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_all<'life0, 'async_trait>( db: &'life0 Db, ) -> Pin<Box<dyn Future<Output = Result<Vec<<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::Model>, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn get_all_where<'life0, 'async_trait>( db: &'life0 Db, conditions: Vec<SimpleExpr>, offset: Option<u64>, limit: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Vec<<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::Model>, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn update_by_id<'life0, 'life1, 'async_trait>( db: &'life0 Db, id: &'life1 str, data: Self::ActiveModel, ) -> Pin<Box<dyn Future<Output = Result<bool, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete<'life0, 'async_trait>( db: &'life0 Db, primary_id: <<<Self::ActiveModel as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType, ) -> Pin<Box<dyn Future<Output = Result<bool, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn delete_by_id<'life0, 'life1, 'async_trait>( db: &'life0 Db, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_by_ids<'life0, 'async_trait>( db: &'life0 Db, ids: Vec<String>, ) -> Pin<Box<dyn Future<Output = Result<u64, DbErr>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

impl Clone for Model

fn clone(&self) -> Model

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Model

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Model

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromQueryResult for Model

fn from_query_result(row: &QueryResult, pre: &str) -> Result<Self, DbErr>

Instantiate a Model from a QueryResult

fn from_query_result_optional( res: &QueryResult, pre: &str, ) -> Result<Option<Self>, DbErr>

Transform the error from instantiating a Model from a QueryResult and converting it to an Option

fn find_by_statement(stmt: Statement) -> SelectorRaw<SelectModel<Self>>

impl ModelTrait for Model

type Entity = Entity

fn get(&self, c: <Self::Entity as EntityTrait>::Column) -> Value

Get the Value of a column from an Entity

fn set(&mut self, c: <Self::Entity as EntityTrait>::Column, v: Value)

Set the Value of a column in an Entity

fn find_related<R>(&self, _: R) -> Select<R>

where R: EntityTrait, Self::Entity: Related<R>,

Find related Models

fn find_linked<L>(&self, l: L) -> Select<<L as Linked>::ToEntity>

where L: Linked<FromEntity = Self::Entity>,

Find linked Models

fn delete<'a, 'async_trait, A, C>( self, db: &'a C, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult, DbErr>> + Send + 'async_trait>>

where 'a: 'async_trait, Self: IntoActiveModel<A> + 'async_trait, C: ConnectionTrait + 'async_trait, A: ActiveModelTrait<Entity = Self::Entity> + ActiveModelBehavior + Send + 'a + 'async_trait,

Delete an model

impl PartialEq for Model

fn eq(&self, other: &Model) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Model

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Model

impl StructuralPartialEq for Model