Struct CourseState 

pub struct CourseState {
    pub settings: CourseSettingsSnapshot,
    pub modules: Vec<ModuleSnapshot>,
    pub chapters: Vec<ChapterSnapshot>,
    pub pages: Vec<PageRecord>,
    pub glossary: Vec<GlossaryTermSnapshot>,
    pub references: Vec<ReferenceSnapshot>,
    pub course_default_review_config: Option<CourseDefaultReviewConfigSnapshot>,
    pub exercises: Option<BTreeMap<Uuid, ExerciseRecord>>,
    pub exercise_deadlines: BTreeMap<Uuid, ExerciseDeadline>,
}

Every editable entity of one course.

Fields

settings: CourseSettingsSnapshot

modules: Vec<ModuleSnapshot>

chapters: Vec<ChapterSnapshot>

pages: Vec<PageRecord>

glossary: Vec<GlossaryTermSnapshot>

references: Vec<ReferenceSnapshot>

course_default_review_config: Option<CourseDefaultReviewConfigSnapshot>

None when the course has none, or when the state was loaded without it.

exercises: Option<BTreeMap<Uuid, ExerciseRecord>>

By exercise id; None until CourseView::load_exercises or CourseView::load_exercises_on_pages (only those pages’) loads them.

exercise_deadlines: BTreeMap<Uuid, ExerciseDeadline>

By exercise id; loaded with the pages. Entries of exercises no page holds any more stay.

Implementations

impl CourseState

pub fn publish_blockers(&self) -> Vec<PublishBlocker>

What publishing this state would break, in a fixed order; empty if nothing.

pub fn blockers_added_since(&self, before: &CourseState) -> Vec<PublishBlocker>

The publish blockers of this state that before doesn’t have. The entities’ labels don’t count, so a blocker that only renames them isn’t new.

impl CourseState

pub fn course_id(&self) -> Uuid

The course the state belongs to.

pub fn page(&self, page_id: Uuid) -> Option<&PageRecord>

The page page_id.

pub fn page_mut(&mut self, page_id: Uuid) -> Option<&mut PageRecord>

Self::page for editing.

pub fn pages_in_order(&self, chapter_id: Option<Uuid>) -> Vec<&PageRecord>

The pages of a chapter, or the top-level pages with None, in the order the course structure shows them: the chapter’s front page (the course front page /) first, then by order number and path.

pub fn chapters_in_order(&self, module_id: Uuid) -> Vec<&ChapterSnapshot>

The chapters of a module in the order the course structure shows them.

pub fn modules_in_order(&self) -> Vec<&ModuleSnapshot>

The modules in the order the course structure shows them: the default module first.

pub fn has_entity(&self, _: EntityKey) -> bool

Whether the state has the entity.

pub fn entity_snapshot(&self, _: EntityKey) -> Option<EntitySnapshot>

The full snapshot of an entity, which a state holds of every entity type but pages.

pub fn entity_label(&self, key: EntityKey) -> Option<String>

What people call the entity; see entity_snapshots::EntityRef::label.

pub fn set_entity(&mut self, _: EntityKey, snapshot: Option<&EntitySnapshot>)

Replaces, adds or (with None) removes one entity. Course settings can’t be removed.

pub fn copy_entity_from(&mut self, source: &CourseState, key: EntityKey)

Sets one entity to its state in source, removing it if source doesn’t have it.

pub fn set_page_exercises(&mut self, page_id: Uuid, page: Option<&PageSnapshot>)

Replaces the exercise records made from the page’s snapshot with those of page, or removes them with None. Does nothing to a state without exercise records.

pub fn set_page_exercise_deadlines(&mut self, page: &PageSnapshot)

Sets the deadlines of the page’s exercises from its snapshot.

pub fn set_exercise_deadline( &mut self, exercise_id: Uuid, deadline: Option<DateTime<Utc>>, )

Sets the exercise’s own deadline in its record, if loaded, and in its deadline entry.

pub fn fork_review_config(&mut self, exercise_id: Uuid, config_id: Uuid)

Gives the exercise its own review config config_id, starting from a copy of the course default’s review instructions. No-op when the exercise’s record isn’t loaded.

pub fn use_course_default_review_config(&mut self, exercise_id: Uuid)

Switches the exercise to the course default review config, dropping its own. No-op when the exercise’s record isn’t loaded.

pub fn exercise_mut(&mut self, exercise_id: Uuid) -> Option<&mut ExerciseRecord>

The exercise’s record, to change; None also when the state has no exercise records.

pub fn effective_exercise_deadline( &self, exercise_id: Uuid, ) -> Option<DateTime<Utc>>

The deadline that applies to the exercise: its own, else its chapter’s. None also when the state doesn’t know the exercise.

pub fn exercise(&self, exercise_id: Uuid) -> Option<&ExerciseRecord>

The exercise’s record; None also when the state has no exercise records.

pub fn exercise_page_id(&self, exercise_id: Uuid) -> Option<Uuid>

The page holding the exercise: the one whose blocks hold it, else the one its record was made from.

pub fn exercise_page_ids(&self) -> HashMap<Uuid, Uuid>

The page whose blocks hold each exercise, by exercise id.

pub fn overlay<'a>( &self, rows: impl IntoIterator<Item = &'a AgentChangesetEntity>, parts: CourseParts, ) -> CourseState

The state with the staged entities of a changeset laid over it. Rows of entity types left out of parts are skipped.

pub fn changes_since(&self, before: &CourseState) -> StateChanges

The entities that differ between before and this state; the inverse of CourseState::overlay.

pub fn exercises_changed_since(&self, before: &CourseState) -> Vec<Uuid>

The exercises whose records differ from those of before, when both have records. Exercises only one of the states has are left out: their pages’ blocks differ.

pub fn pages_changed_since<'a>( &'a self, before: &CourseState, ) -> impl Iterator<Item = &'a PageRecord>

The pages of this state that differ from their state in before, new pages included.

pub fn entity_ref(&self, key: EntityKey) -> EntityRef

The entity, labelled as this state has it; with an empty label if the state lacks it.

pub fn is_chapter_front_page(&self, page_id: Uuid) -> bool

Whether the page is its chapter’s front page in this state.

pub fn is_live(&self) -> bool

Students see this course: it is neither a draft nor in test mode.

impl CourseState

pub fn field_changes_since( &self, before: &CourseState, key: EntityKey, ) -> Vec<FieldChange>

What this state changes of one entity of before, field by field, with references labelled as this state calls them, or before does.

Trait Implementations

impl Clone for CourseState

fn clone(&self) -> CourseState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CourseState

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

Formats the value using the given formatter.

impl PartialEq for CourseState

fn eq(&self, other: &CourseState) -> 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 StructuralPartialEq for CourseState