251 lines
7.3 KiB
Python
251 lines
7.3 KiB
Python
# Create your models here.
|
|
|
|
from django.utils.text import slugify
|
|
from wagtail import blocks
|
|
from wagtail.blocks import StreamBlock
|
|
from wagtail.fields import StreamField
|
|
from wagtail.images.blocks import ImageChooserBlock
|
|
from wagtail.models import Page, Orderable
|
|
|
|
from vbv_lernwelt.learnpath.models_competences import *
|
|
from vbv_lernwelt.learnpath.models_learning_unit_content import WebBasedTrainingBlock, VideoBlock, PodcastBlock, \
|
|
CompetenceBlock, ExerciseBlock, DocumentBlock, KnowledgeBlock
|
|
from vbv_lernwelt.learnpath.serializer_helpers import get_it_serializer_class
|
|
|
|
|
|
class LearningPath(Page):
|
|
# PageChooserPanel('related_page', 'demo.PublisherPage'),
|
|
|
|
content_panels = Page.content_panels
|
|
subpage_types = ['learnpath.Circle', 'learnpath.Topic']
|
|
|
|
class Meta:
|
|
verbose_name = "Learning Path"
|
|
|
|
def __str__(self):
|
|
return f"{self.title}"
|
|
|
|
|
|
class Topic(Page):
|
|
# title = models.TextField(default='')
|
|
is_visible = models.BooleanField(default=True)
|
|
|
|
parent_page_types = ['learnpath.LearningPath']
|
|
|
|
panels = [FieldPanel('title'),
|
|
FieldPanel('is_visible'),
|
|
]
|
|
|
|
# content_panels = Page.content_panels + [
|
|
# FieldPanel('is_visible', classname="full"),
|
|
# PageChooserPanel('learning_path', 'learnpath.LearningPath'),
|
|
# ]
|
|
|
|
# parent_page_types = ['learnpath.LearningPath']
|
|
# subpage_types = ['learnpath.Circle']
|
|
|
|
def full_clean(self, *args, **kwargs):
|
|
self.slug = find_available_slug(Topic, slugify(self.title, allow_unicode=True))
|
|
print(self.slug)
|
|
super(Topic, self).full_clean(*args, **kwargs)
|
|
|
|
@classmethod
|
|
def get_serializer_class(cls):
|
|
return get_it_serializer_class(cls,
|
|
field_names=['id', 'title', 'slug', 'type', 'translation_key', 'is_visible', ])
|
|
|
|
class Meta:
|
|
verbose_name = "Topic"
|
|
|
|
def __str__(self):
|
|
return f"{self.title}"
|
|
|
|
|
|
class PersonBlock(blocks.StructBlock):
|
|
first_name = blocks.CharBlock()
|
|
last_name = blocks.CharBlock()
|
|
email = blocks.EmailBlock()
|
|
photo = ImageChooserBlock(required=False)
|
|
biography = blocks.RichTextBlock(required=False)
|
|
|
|
class Meta:
|
|
icon = 'user'
|
|
|
|
|
|
class Circle(Page):
|
|
description = models.TextField(default="", blank=True)
|
|
goals = StreamField([
|
|
('goal', blocks.TextBlock()),
|
|
], use_json_field=True)
|
|
job_situations = StreamField([
|
|
('job_situation', blocks.CharBlock()),
|
|
], use_json_field=True)
|
|
experts = StreamField([
|
|
('person', PersonBlock()),
|
|
], use_json_field=True)
|
|
|
|
parent_page_types = ['learnpath.LearningPath']
|
|
subpage_types = ['learnpath.LearningSequence', 'learnpath.LearningUnit', 'learnpath.LearningContent']
|
|
|
|
content_panels = Page.content_panels + [
|
|
FieldPanel('description'),
|
|
FieldPanel('goals'),
|
|
FieldPanel('job_situations'),
|
|
FieldPanel('experts'),
|
|
]
|
|
|
|
@property
|
|
def learning_sequences(self):
|
|
return self.get_children().filter(content_type__model='learningsequence').values('id', 'title')
|
|
|
|
@classmethod
|
|
def get_serializer_class(cls):
|
|
return get_it_serializer_class(cls, field_names=['id', 'title', 'slug', 'type', 'translation_key', 'learning_sequences'])
|
|
|
|
def full_clean(self, *args, **kwargs):
|
|
self.slug = find_available_slug(Circle, slugify(self.title, allow_unicode=True))
|
|
super(Circle, self).full_clean(*args, **kwargs)
|
|
|
|
class Meta:
|
|
verbose_name = "Circle"
|
|
|
|
def __str__(self):
|
|
return f"{self.title}"
|
|
|
|
|
|
class LearningSequence(Page):
|
|
parent_page_types = ['learnpath.Circle']
|
|
subpage_types = []
|
|
|
|
icon = models.CharField(max_length=255, default="it-icon-ls-start")
|
|
|
|
content_panels = Page.content_panels + [
|
|
FieldPanel('icon'),
|
|
]
|
|
|
|
class Meta:
|
|
verbose_name = "Learning Sequence"
|
|
|
|
def __str__(self):
|
|
return f"{self.title}"
|
|
|
|
@classmethod
|
|
def get_serializer_class(cls):
|
|
return get_it_serializer_class(cls, field_names=['id', 'title', 'slug', 'type', 'translation_key', 'icon'])
|
|
|
|
def get_admin_display_title(self):
|
|
return f'{self.icon} {self.draft_title}'
|
|
|
|
def full_clean(self, *args, **kwargs):
|
|
super(LearningSequence, self).full_clean(*args, **kwargs)
|
|
|
|
|
|
class LearningUnit(Page):
|
|
parent_page_types = ['learnpath.Circle']
|
|
subpage_types = []
|
|
|
|
questions = StreamField([
|
|
('question', blocks.CharBlock()),
|
|
], use_json_field=True)
|
|
|
|
content_panels = Page.content_panels + [
|
|
FieldPanel('questions'),
|
|
]
|
|
|
|
class Meta:
|
|
verbose_name = "Learning Unit"
|
|
|
|
def __str__(self):
|
|
return f"{self.title}"
|
|
|
|
@classmethod
|
|
def get_serializer_class(cls):
|
|
return get_it_serializer_class(cls, field_names=['id', 'title', 'slug', 'type', 'translation_key', 'questions'])
|
|
|
|
|
|
class LearningContent(Page):
|
|
parent_page_types = ['learnpath.Circle']
|
|
subpage_types = []
|
|
|
|
minutes = models.PositiveIntegerField(default=15)
|
|
|
|
content_blocks = [
|
|
('video', VideoBlock()),
|
|
('web_based_training', WebBasedTrainingBlock()),
|
|
('podcast', PodcastBlock()),
|
|
('competence', CompetenceBlock()),
|
|
('exercise', ExerciseBlock()),
|
|
('document', DocumentBlock()),
|
|
('knowledge', KnowledgeBlock()),
|
|
]
|
|
|
|
contents = StreamField(
|
|
StreamBlock(content_blocks), blank=False, min_num=1, max_num=1
|
|
)
|
|
|
|
content_panels = [
|
|
FieldPanel('title', classname="full title"),
|
|
FieldPanel('minutes'),
|
|
StreamFieldPanel('contents'),
|
|
]
|
|
|
|
def get_admin_display_title(self):
|
|
display_title = ''
|
|
|
|
if len(self.contents) > 0:
|
|
display_title += f'{self.contents[0].block_type.capitalize()}: '
|
|
|
|
display_title += self.draft_title
|
|
|
|
return display_title
|
|
|
|
class Meta:
|
|
verbose_name = "Learning Content"
|
|
|
|
def full_clean(self, *args, **kwargs):
|
|
self.slug = find_available_slug(LearningContent, slugify(self.title, allow_unicode=True))
|
|
super(LearningContent, self).full_clean(*args, **kwargs)
|
|
|
|
@classmethod
|
|
def get_serializer_class(cls):
|
|
return get_it_serializer_class(cls,
|
|
field_names=['id', 'title', 'slug', 'type',
|
|
'translation_key', 'minutes', 'contents'])
|
|
|
|
def __str__(self):
|
|
return f"{self.title}"
|
|
|
|
|
|
def find_available_slug(model, requested_slug, ignore_page_id=None):
|
|
"""
|
|
Finds an available slug within the specified parent.
|
|
|
|
If the requested slug is not available, this adds a number on the end, for example:
|
|
|
|
- 'requested-slug'
|
|
- 'requested-slug-1'
|
|
- 'requested-slug-2'
|
|
|
|
And so on, until an available slug is found.
|
|
|
|
The `ignore_page_id` keyword argument is useful for when you are updating a page,
|
|
you can pass the page being updated here so the page's current slug is not
|
|
treated as in use by another page.
|
|
"""
|
|
|
|
# TODO: In comparison ot wagtails own function, I look for the same model instead of the parent
|
|
pages = model.objects.filter(slug__startswith=requested_slug)
|
|
|
|
if ignore_page_id:
|
|
pages = pages.exclude(id=ignore_page_id)
|
|
|
|
existing_slugs = set(pages.values_list("slug", flat=True))
|
|
slug = requested_slug
|
|
number = 1
|
|
|
|
while slug in existing_slugs:
|
|
slug = requested_slug + "-" + str(number)
|
|
number += 1
|
|
|
|
return slug
|