Exemplo n.º 1
0
class Journal(index.Indexed, ClusterableModel):
    name = models.CharField(max_length=255)
    url = models.URLField()
    issn = models.CharField(max_length=16,
                            blank=True,
                            help_text=_("Linking ISSN-L for this Journal"))
    description = MarkdownField()
    tags = TaggableManager(through=JournalTag, blank=True)

    panels = [
        FieldPanel('name'),
        FieldPanel('url'),
        FieldPanel('issn'),
        FieldPanel('description', widget=forms.Textarea),
        FieldPanel('tags'),
    ]

    search_fields = [
        index.SearchField('name', partial_match=True),
        index.SearchField('description', partial_match=True),
        index.SearchField('issn'),
        index.RelatedFields('tags', [
            index.SearchField('name', partial_match=True),
        ]),
    ]

    def __lt__(self, other):
        if isinstance(other, Journal):
            return self.name < other.name
        raise TypeError("Unorderable types: {0} < {1}".format(
            Journal, type(other)))

    def __str__(self):
        return "{0} {1} {2}".format(self.name, self.url, self.issn)
Exemplo n.º 2
0
class PeoplePage(Page, NavigationMixin):
    template = 'home/about/people.jinja'
    heading = models.CharField(max_length=64)
    description = MarkdownField(
        help_text=_("Text blurb on the people leading comses.net"))

    def sort_board(self):
        PeopleEntryPlacement.objects.board().update_sort_order_alpha()

    def add_users(self, category, usernames, offset):
        for idx, username in enumerate(usernames):
            # manually iterate and get MemberProfile to enforce original ordering
            profile = MemberProfile.objects.get(user__username=username)
            self.people_entry_placements.add(
                PeopleEntryPlacement(sort_order=offset + idx,
                                     member_profile=profile,
                                     category=category))

    def get_context(self, request, *args, **kwargs):
        context = super().get_context(request, *args, **kwargs)
        context['people_categories'] = PeopleEntryPlacement.CATEGORIES
        return context

    content_panels = Page.content_panels + [
        FieldPanel('heading'),
        FieldPanel('description'),
        InlinePanel('people_entry_placements', label='People Entries')
    ]
Exemplo n.º 3
0
class MarkdownPage(NavigationMixin, Page):
    heading = models.CharField(
        max_length=128,
        blank=True,
        help_text=
        _('Large heading text placed on the blue background introduction header'
          ))
    template = models.CharField(
        max_length=128,
        help_text=
        _('Relative filesystem path to the template file to be used for this page '
          '(advanced usage only - the template must exist on the filesystem). If you change '
          'this, help text suggestions on placement of elements may no longer apply.'
          ),
        default='home/markdown_page.jinja')
    post_date = models.DateField("Post date", default=timezone.now)
    description = MarkdownField(
        max_length=1024,
        blank=True,
        help_text=_(
            'Markdown-enabled summary text placed below the heading and title.'
        ))
    body = MarkdownField(
        blank=True,
        help_text=_('Markdown-enabled main content pane for this page.'))
    jumbotron = models.BooleanField(
        default=True,
        help_text=
        _("Mark as true if this page should display its title and description in a jumbotron"
          ))

    content_panels = Page.content_panels + [
        FieldPanel('post_date'),
        FieldPanel('jumbotron'),
        FieldPanel('heading'),
        FieldPanel('description'),
        FieldPanel('body'),
        FieldPanel('template'),
        InlinePanel('navigation_links', label=_('Subnavigation Links')),
    ]

    search_fields = Page.search_fields + [
        index.FilterField('post_date'),
        index.SearchField('description', partial_match=True),
        index.SearchField('body', partial_match=True),
        index.SearchField('heading', partial_match=True),
    ]
Exemplo n.º 4
0
class PlaceSerializer(serializers.ModelSerializer):
    """Serializer for Place."""

    description = MarkdownField()
    address = AddressSerializer()

    class Meta:  # noqa
        model = Place
        fields = ('id', 'name', 'address', 'description')
Exemplo n.º 5
0
class ConferencePage(Page):

    template = 'home/conference/index.jinja'
    introduction = MarkdownField(
        help_text=_("Lead introduction to the conference"))
    content = MarkdownField(
        help_text=_("Conference main body content markdown text"))
    start_date = models.DateField()
    end_date = models.DateField()
    external_url = models.URLField(help_text=_(
        "URL to the top-level Discourse category topic for this conference."))
    submission_deadline = models.DateField(null=True, blank=True)
    submission_information = MarkdownField(help_text=_(
        "Markdown formatted info on how to submit a presentation to the conference"
    ))

    @property
    def is_accepting_submissions(self):
        if self.submission_deadline:
            return date.today() < self.submission_deadline
        return False

    @property
    def is_open(self):
        return self.start_date <= date.today()

    @property
    def is_archived(self):
        return date.today() > self.end_date

    content_panels = Page.content_panels + [
        FieldPanel('start_date'),
        FieldPanel('end_date'),
        FieldPanel('introduction'),
        FieldPanel('content'),
        FieldPanel('external_url'),
        FieldPanel('submission_deadline'),
        FieldPanel('submission_information'),
        InlinePanel('themes', label='Themes'),
    ]
Exemplo n.º 6
0
class ProjectSerializer(serializers.HyperlinkedModelSerializer):
    """Serializer for Project objects."""

    description = MarkdownField()

    class Meta:  # noqa
        model = Project
        fields = ('id', 'url', 'name', 'description', 'logo')
        extra_kwargs = {
            'url': {
                'view_name': 'api:project-detail'
            },
        }
Exemplo n.º 7
0
class ConferenceTheme(models.Model):

    CATEGORIES = Choices('Panel', 'Session')

    title = models.CharField(max_length=512)
    category = models.CharField(choices=CATEGORIES,
                                default=CATEGORIES.Panel,
                                max_length=16)
    description = MarkdownField()
    external_url = models.URLField(help_text=_(
        "URL to this conference theme's (panel / session) Discourse topic"))
    page = ParentalKey('home.ConferencePage', related_name='themes')

    def add_presentations(self, presentations):
        """
        presentations must be a collection of dicts with the following keys:
        title, url, user_pk, contributors (optional)
        """
        for presentation in presentations:
            user_id = presentation['user_pk']
            submitter = MemberProfile.objects.get(user__pk=user_id)
            conference_presentation, created = self.presentations.get_or_create(
                title=presentation['title'],
                external_url=presentation['url'],
                submitter=submitter,
            )
            contributors = presentation.get('contributors')
            if contributors:
                conference_presentation.contributors.set(
                    Contributor.objects.filter(user__pk__in=contributors))
            else:
                conference_presentation.contributors.add(
                    Contributor.objects.get(user__pk=user_id))
            conference_presentation.save()

    def __str__(self):
        return "{0} {1}".format(self.category, self.title)

    panels = [
        FieldPanel('title'),
        FieldPanel('category'),
        FieldPanel('description'),
        FieldPanel('external_url'),
        # InlinePanel('presentations')
    ]
Exemplo n.º 8
0
class EditionListSerializer(serializers.HyperlinkedModelSerializer):
    """List serializer for Edition objects."""

    description = MarkdownField()
    project = serializers.StringRelatedField(read_only=True)
    organizers = serializers.SerializerMethodField()
    participations = serializers.SerializerMethodField()
    edition_form = EditionFormSerializer()
    participates = serializers.SerializerMethodField()

    def get_organizers(self, obj: Edition) -> int:
        """Return the number of organizers."""
        return obj.organizers.count()

    def get_participations(self, obj: Edition) -> int:
        """Return the number of participations."""
        return obj.participations.count()

    def get_participates(self, obj: Edition) -> bool:
        """Return whether the current user participates in the edition."""
        request = self.context['request']
        if not request.user:
            return False
        return request.user.pk in obj.participations.values_list('user__pk')

    class Meta:  # noqa
        model = Edition
        fields = (
            'id',
            'url',
            'name',
            'year',
            'project',
            'description',
            'organizers',
            'participations',
            'edition_form',
            'participates',
        )
        extra_kwargs = {
            'url': {
                'view_name': 'api:edition-detail'
            },
        }
Exemplo n.º 9
0
class ConferenceSubmission(models.Model):
    submitter = models.ForeignKey(MemberProfile, on_delete=models.DO_NOTHING)
    presenters = models.ManyToManyField(Contributor)
    conference = models.ForeignKey(ConferencePage,
                                   related_name='submissions',
                                   on_delete=models.PROTECT)
    date_created = models.DateTimeField(default=timezone.now)
    last_modified = models.DateTimeField(auto_now=True)

    title = models.CharField(max_length=150, help_text=_('Presentation title'))
    abstract = MarkdownField(max_length=3000,
                             help_text=_('Presentation abstract'),
                             blank=False)
    video_url = models.URLField(help_text=_('URL to your video presentation'))
    model_url = models.URLField(help_text=_(
        'Persistent URL to a model associated with your presentation (if applicable)'
    ),
                                blank=True)

    def __str__(self):
        return "submission {} by {}".format(self.title, self.submitter)