Struct Model

pub struct Model {
    pub id: i64,
    pub module_id: i64,
    pub name: String,
    pub description: Option<String>,
    pub assignment_type: AssignmentType,
    pub status: Status,
    pub available_from: DateTime<Utc>,
    pub due_date: DateTime<Utc>,
    pub config: Option<JsonValue>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

Assignment model representing the assignments table in the database.

Fields

id: i64

module_id: i64

name: String

description: Option<String>

assignment_type: AssignmentType

status: Status

available_from: DateTime<Utc>

due_date: DateTime<Utc>

config: Option<JsonValue>

created_at: DateTime<Utc>

updated_at: DateTime<Utc>

Implementations

impl Model

pub async fn create( db: &DatabaseConnection, module_id: i64, name: &str, description: Option<&str>, assignment_type: AssignmentType, available_from: DateTime<Utc>, due_date: DateTime<Utc>, ) -> Result<Self, DbErr>

pub async fn edit( db: &DatabaseConnection, id: i64, module_id: i64, name: &str, description: Option<&str>, assignment_type: AssignmentType, available_from: DateTime<Utc>, due_date: DateTime<Utc>, ) -> Result<Self, DbErr>

pub async fn delete( db: &DatabaseConnection, id: i32, module_id: i32, ) -> Result<(), DbErr>

pub async fn filter( db: &DatabaseConnection, page: u64, per_page: u64, sort_by: Option<String>, query: Option<String>, ) -> Result<Vec<Self>, DbErr>

pub async fn compute_readiness_report( db: &DatabaseConnection, module_id: i64, assignment_id: i64, ) -> Result<ReadinessReport, DbErr>

Computes a detailed readiness report for an assignment by checking if all required components are present.

This function verifies the presence of all expected resources for an assignment:

• At least one task is defined in the database.
• A configuration file exists.
• A main file exists.
• A memo file exists.
• A makefile exists.
• A memo output file exists.
• A JSON mark allocator file exists.

The returned ReadinessReport (or [AssignmentReadiness]) contains boolean flags for each component and an is_ready field indicating whether the assignment is fully ready (i.e., suitable to transition from Setup to Ready state).

This function only checks readiness — it does not modify the assignment’s status in the database.

Arguments

• db - A reference to the database connection.
• module_id - The ID of the module to which the assignment belongs.
• assignment_id - The ID of the assignment to check.

Returns

• Ok(ReadinessReport) with per-component readiness details.
• Err(DbErr) if a database error occurs while checking tasks.

Notes

File presence is checked on the file system under the expected directories for each file type. Missing directories or I/O errors are treated as absence of the respective component.

pub async fn try_transition_to_ready( db: &DatabaseConnection, module_id: i64, assignment_id: i64, ) -> Result<bool, DbErr>

Attempts to transition an assignment to Ready state if all readiness conditions are met.

This function:

• Computes a full readiness report for the assignment.
• If all components are present (is_ready == true), it checks the current status.
• If the current status is Setup, it updates the status to Ready and updates updated_at.
• If already in Ready, Open, etc., it does not change the status.

Arguments

• db - A reference to the database connection.
• module_id - The ID of the module to which the assignment belongs.
• assignment_id - The ID of the assignment.

Returns

• Ok(true) if the assignment is fully ready (regardless of whether the status was updated).
• Ok(false) if the assignment is not ready.
• Err(DbErr) if a database error occurs.

Trait Implementations

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 From<Model> for ActiveModel

fn from(m: Model) -> Self

Converts to this type from the input type.

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 from_query_result_nullable( res: &QueryResult, pre: &str, ) -> Result<Self, TryGetError>

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 IntoActiveModel<ActiveModel> for Model

fn into_active_model(self) -> ActiveModel

Method to call to perform the conversion

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 a 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 TryFrom<ActiveModel> for Model

type Error = DbErr

The type returned in the event of a conversion error.

fn try_from(a: ActiveModel) -> Result<Self, DbErr>

Performs the conversion.

impl TryIntoModel<Model> for ActiveModel

fn try_into_model(self) -> Result<Model, DbErr>

Method to call to perform the conversion

impl StructuralPartialEq for Model