Struct PageSnapshot 

pub struct PageSnapshot {
    pub id: Uuid,
    pub course_id: Uuid,
    pub chapter_id: Option<Uuid>,
    pub url_path: String,
    pub title: String,
    pub hidden: bool,
    pub order_number: i32,
    pub content: Arc<Vec<GutenbergBlock>>,
    pub exercises: Vec<CmsPageExercise>,
    pub exercise_slides: Vec<CmsPageExerciseSlide>,
    pub exercise_tasks: Vec<CmsPageExerciseTask>,
    pub joins_page_language_group_id: Option<Uuid>,
}

A course page: its metadata, its stored blocks and its exercises, in the shape the CMS page save takes. Exercise blocks in content are stored stripped to their id, as the CMS stores them; the exercises themselves are in exercises, exercise_slides and exercise_tasks.

Fields

id: Uuid

course_id: Uuid

chapter_id: Option<Uuid>

None for top-level pages.

url_path: String

title: String

hidden: bool

order_number: i32

Position among the pages of the same chapter (or the top-level pages). 0 is reserved for a chapter’s front page.

content: Arc<Vec<GutenbergBlock>>

Shared with the page records made from the snapshot.

exercises: Vec<CmsPageExercise>

exercise_slides: Vec<CmsPageExerciseSlide>

exercise_tasks: Vec<CmsPageExerciseTask>

joins_page_language_group_id: Option<Uuid>

For a page publishing creates: the page language group of its versions in the course’s other languages that it joins. None for every other page, whatever group it is in.

Implementations

impl PageSnapshot

pub fn from_record_and_bundles( course_id: Uuid, record: &PageRecord, bundles: &HashMap<Uuid, ExerciseBundle>, ) -> Result<Self, Vec<Uuid>>

The page record describes, with exactly the exercises its exercise blocks name, taken from bundles. Errors with the exercise ids bundles doesn’t have.

impl PageSnapshot

pub fn to_cms_page_update(&self) -> CmsPageUpdate

The CMS page save payload that writes this snapshot.

pub fn normalize_for_storage(&mut self)

Trims and normalises the title and path the way the page save does, so that the snapshot equals the page publishing it produces.

pub fn exercise_bundles(&self) -> Vec<ExerciseBundle>

The page’s exercises in exercise order, each with its slides and tasks.

pub fn set_exercise_bundles<'a>( &mut self, bundles: impl IntoIterator<Item = &'a ExerciseBundle>, )

Replaces the page’s exercises, with their slides and tasks, with bundles.

pub fn sort(&mut self)

Sorts the exercise lists so that two snapshots of the same page compare equal regardless of the order the database returned the rows in.

Trait Implementations

impl Clone for PageSnapshot

fn clone(&self) -> PageSnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for PageSnapshot

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl ContentEntity for PageSnapshot

const ENTITY_TYPE: ContentEntityType = ContentEntityType::Page

fn id(&self) -> Uuid

The entity’s id; the course id for course settings.

fn course_id(&self) -> Uuid

fn label(&self) -> &str

See EntityRef::label.

fn parent(&self) -> Option<EntityKey>

The chapter or module the entity is placed in; None for entities of the course itself.

fn narrow(snapshot: &EntitySnapshot) -> Option<&Self>

The snapshot, if it is of this kind.

async fn load_live( conn: &mut PgConnection, ids: &[Uuid], ) -> ModelResult<HashMap<Uuid, Self>>

The live entities with the ids, as load_live_many has them, by id.

async fn lock_rows(conn: &mut PgConnection, ids: &[Uuid]) -> ModelResult<()>

Locks the entities’ rows until the transaction ends. Soft-deleted rows are locked too: a publish can restore them. ids must be sorted, so that concurrent lockers take the rows in the same order.

impl Debug for PageSnapshot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PageSnapshot

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&PageSnapshot> for PageRecord

fn from(page: &PageSnapshot) -> Self

Converts to this type from the input type.

impl From<PageSnapshot> for EntitySnapshot

fn from(snapshot: PageSnapshot) -> Self

Converts to this type from the input type.

impl From<PageSnapshot> for PreviewPage

fn from(page: PageSnapshot) -> Self

Converts to this type from the input type.

impl InCourseState for PageSnapshot

fn find_in(_state: &CourseState, _id: Uuid) -> Option<&Self>

The entity in state. Always None for pages, which states hold as PageRecords.

fn is_in(state: &CourseState, id: Uuid) -> bool

fn put_in(&self, state: &mut CourseState)

Adds the entity to state, or replaces it there.

fn remove_from(state: &mut CourseState, id: Uuid)

Removes the entity from state; course settings stay, since a course always has them.

impl PartialEq for PageSnapshot

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for PageSnapshot

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference [utoipa::openapi::schema::Schema]s for this type.

impl StructuralPartialEq for PageSnapshot