1531

pending completion

Build # 1531

Build Type

Pull #728

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/pythonindia/junction/commit/<a class=hub.com/pythonindia/junction/commit/<a class="double-link" href="https://git"><a class=hub.com/pythonindia/junction/commit/<a class="double-link" href="https://git"><a class=hub.com/pythonindia/junction/commit/<a class="double-link" href="https://git"><a class=hub.com/pythonindia/junction/commit/f38d55385a13b352cd62520ddf336fa0b30ac84e">f38d55385">&lt;a href=&quot;https://github.com/pythonindia/junction/commit/</a><a class="double-link" href="https://github.com/pythonindia/junction/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pythonindia/junction/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pythonindia/junction/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pythonindia/junction/commit/f38d55385a13b352cd62520ddf336fa0b30ac84e">f38d55385</a><a href="https://github.com/pythonindia/junction/commit/f38d55385a13b352cd62520ddf336fa0b30ac84e">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/pythonindia/junction/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/pythonindia/junction/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pythonindia/junction/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pythonindia/junction/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pythonindia/junction/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pythonindia/junction/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pythonindia/junction/commit/f38d55385a13b352cd62520ddf336fa0b30ac84e&quot;&gt;f38d55385&lt;/a&gt;&lt;a href=&quot;https://github.com/pythonindia/junction/commit/f38d55385a13b352cd62520ddf336fa0b30ac84e&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/pythonindia/junction/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&a... (continued)

Pull Request Pull Request #728: #727 add a command to add all pipx binary directories to PATH.

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

1371 of 2034 relevant lines covered (67.4%)

2.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.72

/junction/proposals/models.py

# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals

from datetime import datetime

from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.db import models
from django.template.defaultfilters import slugify
from django.utils.encoding import python_2_unicode_compatible
from django_extensions.db.fields import AutoSlugField
from hashids import Hashids
from rest_framework.reverse import reverse as rf_reverse
from simple_history.models import HistoricalRecords

from junction.base.constants import (
    ProposalCommentType,
    ProposalReviewStatus,
    ProposalReviewVote,
    ProposalStatus,
    ProposalTargetAudience,
    ProposalUserVoteRole,
    PSRVotePhase,
)
from junction.base.models import AuditModel, TimeAuditModel
from junction.conferences.models import Conference, ConferenceProposalReviewer


@python_2_unicode_compatible
class ProposalSection(AuditModel):

    """ List of Proposal Sections"""

    name = models.CharField(max_length=255, verbose_name="Proposal Section Name")
    description = models.TextField(default="", blank=True)
    active = models.BooleanField(default=True, verbose_name="Is Active?")
    conferences = models.ManyToManyField(
        to=Conference, related_name="proposal_sections"
    )

    def __str__(self):
        return self.name


@python_2_unicode_compatible
class ProposalSectionReviewer(AuditModel):

    """ List of Proposal Section Reviewers"""

    conference_reviewer = models.ForeignKey(
        "conferences.ConferenceProposalReviewer",
        verbose_name="Conference Proposal Reviewers",
        on_delete=models.CASCADE,
    )
    proposal_section = models.ForeignKey(
        ProposalSection, verbose_name="Proposal Section", on_delete=models.CASCADE
    )
    active = models.BooleanField(default=True, verbose_name="Is Active?")

    def __str__(self):
        return "{}:[{}]".format(self.conference_reviewer, self.proposal_section)


@python_2_unicode_compatible
class ProposalType(AuditModel):

    """ List of Proposal Types """

    name = models.CharField(max_length=255, verbose_name="Proposal Type Name")
    description = models.TextField(default="", blank=True)
    active = models.BooleanField(default=True, verbose_name="Is Active?")
    conferences = models.ManyToManyField(to=Conference, related_name="proposal_types")
    start_date = models.DateField(default=datetime.now, verbose_name="Start Date")
    end_date = models.DateField(default=datetime.now, verbose_name="End Date")

    def __str__(self):
        return self.name


@python_2_unicode_compatible
class Proposal(TimeAuditModel):

    """ The proposals master """

    conference = models.ForeignKey(Conference, on_delete=models.CASCADE)
    proposal_section = models.ForeignKey(
        ProposalSection, verbose_name="Proposal Section", on_delete=models.CASCADE
    )
    proposal_type = models.ForeignKey(
        ProposalType, verbose_name="Proposal Type", on_delete=models.CASCADE
    )
    author = models.ForeignKey(
        User, verbose_name="Primary Speaker", on_delete=models.CASCADE
    )
    title = models.CharField(max_length=255)
    slug = AutoSlugField(max_length=255, populate_from=("title",))
    description = models.TextField(default="")
    target_audience = models.PositiveSmallIntegerField(
        choices=ProposalTargetAudience.CHOICES,
        default=ProposalTargetAudience.BEGINNER,
        verbose_name="Target Audience",
    )
    video_url = models.URLField(
        blank=True,
        default="",
        help_text="Short 1-2 min video describing your talk",
    )
    prerequisites = models.TextField(blank=True, default="")
    content_urls = models.TextField(blank=True, default="")
    private_content_urls = models.BooleanField(
        default=False,
        help_text="Check it if you want to make your content URLs private",
    )
    speaker_info = models.TextField(blank=True, default="")
    speaker_links = models.TextField(blank=True, default="")
    is_first_time_speaker = models.BooleanField(blank=True, default=False)
    status = models.PositiveSmallIntegerField(
        choices=ProposalStatus.CHOICES, default=ProposalStatus.DRAFT
    )
    review_status = models.PositiveSmallIntegerField(
        choices=ProposalReviewStatus.CHOICES,
        default=ProposalReviewStatus.YET_TO_BE_REVIEWED,
        verbose_name="Review Status",
    )
    deleted = models.BooleanField(default=False, verbose_name="Is Deleted?")
    history = HistoricalRecords()

    def __str__(self):
        return "{}, {}".format(self.title, self.proposal_type)

    def is_public(self):
        # TODO: Fix with proper enum
        return self.status == 2

    def get_slug(self):
        return slugify(self.title)

    def get_hashid(self):
        hashids = Hashids(min_length=5)
        return hashids.encode(self.id)

    def get_absolute_url(self):
        return reverse(
            "proposal-detail",
            args=[self.conference.slug, self.get_slug(), self.get_hashid()],
        )

    def get_update_url(self):
        return reverse("proposal-update", args=[self.conference.slug, self.slug])

    def get_review_url(self):
        return reverse("proposal-review", args=[self.conference.slug, self.slug])

    def get_vote_url(self):
        return reverse("proposal-reviewer-vote", args=[self.conference.slug, self.slug])

    def get_secondary_vote_url(self):
        return reverse(
            "proposal-reviewer-secondary-vote", args=[self.conference.slug, self.slug]
        )

    def get_delete_url(self):
        return reverse("proposal-delete", args=[self.conference.slug, self.slug])

    def get_up_vote_url(self):
        return reverse("proposal-vote-up", args=[self.conference.slug, self.slug])

    def get_down_vote_url(self):
        return reverse("proposal-vote-down", args=[self.conference.slug, self.slug])

    def get_remove_vote_url(self):
        return reverse("proposal-vote-remove", args=[self.conference.slug, self.slug])

    def get_comments_count(self):
        """ Show only public comments count """
        return ProposalComment.objects.filter(
            proposal=self, deleted=False, private=False, vote=False, reviewer=False
        ).count()

    def get_reviews_comments_count(self):
        """ Show only private comments count """
        return ProposalComment.objects.filter(
            proposal=self, deleted=False, private=True, vote=False
        ).count()

    def get_reviewer_comments_count(self, reviewer):
        """ Number of private comments by a reviewer """
        return ProposalComment.objects.filter(
            proposal=self, deleted=False, private=True, commenter=reviewer, vote=False
        ).count()

    def get_votes_count(self):
        """ Show only the public comment count """
        votes = (
            ProposalVote.objects.filter(proposal=self)
            .values("up_vote")
            .annotate(counts=models.Count("up_vote"))
        )
        votes = {item["up_vote"]: item["counts"] for item in votes}
        up_vote_count = votes.get(True, 0)
        down_vote_count = votes.get(False, 0)
        return up_vote_count - down_vote_count

    def get_reviewer_votes_count(self):
        """ Show sum of reviewer vote value. """
        return ProposalSectionReviewerVote.objects.filter(proposal=self).count()

    def get_reviewer_votes_count_by_value(self, vote_value):
        """ Show sum of reviewer votes for given vote value. """
        return ProposalSectionReviewerVote.objects.filter(
            proposal=self, vote_value__vote_value=vote_value
        ).count()

    def get_reviewer_votes_sum(self):
        votes = ProposalSectionReviewerVote.objects.filter(
            proposal=self,
        )
        sum_of_votes = sum((v.vote_value.vote_value for v in votes))
        return sum_of_votes

    def get_reviewer_vote_value(self, reviewer):
        try:
            vote = ProposalSectionReviewerVote.objects.get(
                proposal=self,
                voter__conference_reviewer__reviewer=reviewer,
            )
            return vote.vote_value.vote_value
        except ProposalSectionReviewerVote.DoesNotExist:
            return 0

    def get_reviewers_count(self):
        """ Count of reviewers for given proposal section """
        return ProposalSectionReviewer.objects.filter(
            proposal_section=self.proposal_section
        ).count()

    def has_negative_votes(self):
        """ Show sum of reviewer votes for given vote value. """
        return (
            ProposalSectionReviewerVote.objects.filter(
                proposal=self,
                vote_value__vote_value=ProposalReviewVote.NOT_ALLOWED,
            ).count()
            > 0
        )

    def to_response(self, request):
        """method will return dict which can be passed to response"""
        author = "{} {}".format(self.author.first_name, self.author.last_name)
        data = {
            "id": self.id,
            "author": author,
            "title": self.title,
            "description": self.description,
            "target_audience": dict(ProposalTargetAudience.CHOICES)[
                self.target_audience
            ],
            "status": dict(ProposalStatus.CHOICES)[self.status],
            "review_status": dict(ProposalReviewStatus.CHOICES)[self.review_status],
            "proposal_type": self.proposal_type.name,
            "proposal_section": self.proposal_section.name,
            "votes_count": self.get_votes_count(),
            "speaker_info": self.speaker_info,
            "speaker_links": self.speaker_links,
            "content_urls": self.content_urls,
            "private_content_urls": self.private_content_urls,
            "conference": rf_reverse(
                "conference-detail", kwargs={"pk": self.conference_id}, request=request
            ),
        }
        return data

    class Meta:
        unique_together = ("conference", "slug")


@python_2_unicode_compatible
class ProposalVote(TimeAuditModel):

    """ User vote for a specific proposal """

    proposal = models.ForeignKey(Proposal, on_delete=models.CASCADE)
    voter = models.ForeignKey(User, on_delete=models.CASCADE)
    role = models.PositiveSmallIntegerField(
        choices=ProposalUserVoteRole.CHOICES, default=ProposalUserVoteRole.PUBLIC
    )
    up_vote = models.BooleanField(default=True)

    def __str__(self):
        return "[{}] {}".format("1" if self.up_vote else "-1", self.proposal)

    class Meta:
        unique_together = ("proposal", "voter")


class ProposalCommentQuerySet(models.QuerySet):
    def get_public_comments(self):
        return self.filter(private=False, reviewer=False, vote=False)

    def get_reviewers_comments(self):
        return self.filter(private=True, vote=False)

    def get_reviewers_only_comments(self):
        return self.filter(reviewer=True, vote=False)


@python_2_unicode_compatible
class ProposalSectionReviewerVoteValue(AuditModel):
    """ Proposal reviewer vote choices. """

    vote_value = models.SmallIntegerField()
    description = models.CharField(max_length=255)

    def __str__(self):
        return "{} ({})".format(self.description, self.vote_value)

    class Meta:
        ordering = ("-vote_value",)


@python_2_unicode_compatible
class ProposalSectionReviewerVote(TimeAuditModel):

    """ Reviewer vote for a specific proposal """

    proposal = models.ForeignKey(Proposal, on_delete=models.CASCADE)
    voter = models.ForeignKey(ProposalSectionReviewer, on_delete=models.CASCADE)
    role = models.PositiveSmallIntegerField(
        choices=ProposalUserVoteRole.CHOICES, default=ProposalUserVoteRole.REVIEWER
    )
    vote_value = models.ForeignKey(
        ProposalSectionReviewerVoteValue, on_delete=models.CASCADE
    )
    phase = models.PositiveSmallIntegerField(
        choices=PSRVotePhase.CHOICES, default=PSRVotePhase.PRIMARY
    )

    history = HistoricalRecords()

    def __str__(self):
        return "[{}] {}".format(self.vote_value, self.proposal)

    class Meta:
        verbose_name = "ProposalSectionReviewerVote"


# FIXME: Need to move private, reviewer, vote to type
@python_2_unicode_compatible
class ProposalComment(TimeAuditModel):

    """ User comments for a specific proposal """

    proposal = models.ForeignKey(Proposal, on_delete=models.CASCADE)
    commenter = models.ForeignKey(User, on_delete=models.CASCADE)
    private = models.BooleanField(default=False, verbose_name="Is Private?")
    reviewer = models.BooleanField(default=False, verbose_name="Is Reviewer?")
    vote = models.BooleanField(default=False, verbose_name="What is the reason?")
    comment = models.TextField()
    deleted = models.BooleanField(default=False, verbose_name="Is Deleted?")
    comment_type = models.PositiveSmallIntegerField(
        choices=ProposalCommentType.CHOICES, default=ProposalCommentType.GENERAL
    )
    objects = ProposalCommentQuerySet.as_manager()
    is_spam = models.BooleanField(default=False, blank=True)
    marked_as_spam_by = models.ForeignKey(
        User,
        related_name="marked_as_spam_by",
        default=None,
        null=True,
        blank=True,
        on_delete=models.SET_NULL,
    )

    class Meta:
        ordering = ("created_at",)
        index_together = [["is_spam", "marked_as_spam_by"], ["commenter", "is_spam"]]

    def __str__(self):
        return "[{} by {}] {}".format(
            self.comment, self.commenter.get_full_name(), self.proposal
        )

    def get_up_vote_url(self):
        return reverse(
            "proposal-comment-up-vote",
            args=[self.proposal.conference.slug, self.proposal.slug, self.id],
        )

    def get_down_vote_url(self):
        return reverse(
            "proposal-comment-down-vote",
            args=[self.proposal.conference.slug, self.proposal.slug, self.id],
        )

    def get_mark_spam_url(self):
        return reverse(
            "comment_mark_spam",
            args=[self.proposal.conference.slug, self.proposal.slug, self.id],
        )

    def get_unmark_spam_url(self):
        return reverse(
            "comment_unmark_spam",
            args=[self.proposal.conference.slug, self.proposal.slug, self.id],
        )

    def get_votes_count(self):
        up_vote_count = ProposalCommentVote.objects.filter(
            proposal_comment=self, up_vote=True
        ).count()
        down_vote_count = ProposalCommentVote.objects.filter(
            proposal_comment=self, up_vote=False
        ).count()
        return up_vote_count - down_vote_count

    def get_reviewer_nick(self):
        reviewer = ConferenceProposalReviewer.objects.get(
            conference_id=self.proposal.conference_id, reviewer_id=self.commenter_id
        )
        return reviewer.nick

    def get_comment_type(self):
        if self.deleted:
            return "Deleted"
        elif self.vote:
            return "Vote"
        elif self.reviewer:
            return "Reviewer Only"
        elif self.private:
            return "Review"
        else:
            return "Public"


@python_2_unicode_compatible
class ProposalCommentVote(TimeAuditModel):

    """ User vote for a specific proposal's comment """

    proposal_comment = models.ForeignKey(ProposalComment, on_delete=models.CASCADE)
    voter = models.ForeignKey(User, on_delete=models.CASCADE)
    up_vote = models.BooleanField(default=True)

    def __str__(self):
        return "[{}] {}".format("1" if self.up_vote else "-1", self.proposal_comment)

    class Meta:
        unique_together = ("proposal_comment", "voter")

1	# -- coding: utf-8 --
2	from __future__ import absolute_import, unicode_literals	4✔
3
4	from datetime import datetime	4✔
5
6	from django.contrib.auth.models import User	4✔
7	from django.core.urlresolvers import reverse	4✔
8	from django.db import models	4✔
9	from django.template.defaultfilters import slugify	4✔
10	from django.utils.encoding import python_2_unicode_compatible	4✔
11	from django_extensions.db.fields import AutoSlugField	4✔
12	from hashids import Hashids	4✔
13	from rest_framework.reverse import reverse as rf_reverse	4✔
14	from simple_history.models import HistoricalRecords	4✔
15
16	from junction.base.constants import (	4✔
17	ProposalCommentType,
18	ProposalReviewStatus,
19	ProposalReviewVote,
20	ProposalStatus,
21	ProposalTargetAudience,
22	ProposalUserVoteRole,
23	PSRVotePhase,
24	)
25	from junction.base.models import AuditModel, TimeAuditModel	4✔
26	from junction.conferences.models import Conference, ConferenceProposalReviewer	4✔
27
28
29	@python_2_unicode_compatible	4✔
30	class ProposalSection(AuditModel):	4✔
31
32	""" List of Proposal Sections"""
33
34	name = models.CharField(max_length=255, verbose_name="Proposal Section Name")	4✔
35	description = models.TextField(default="", blank=True)	4✔
36	active = models.BooleanField(default=True, verbose_name="Is Active?")	4✔
37	conferences = models.ManyToManyField(	4✔
38	to=Conference, related_name="proposal_sections"
39	)
40
41	def __str__(self):	4✔
42	return self.name	×
43
44
45	@python_2_unicode_compatible	4✔
46	class ProposalSectionReviewer(AuditModel):	4✔
47
48	""" List of Proposal Section Reviewers"""
49
50	conference_reviewer = models.ForeignKey(	4✔
51	"conferences.ConferenceProposalReviewer",
52	verbose_name="Conference Proposal Reviewers",
53	on_delete=models.CASCADE,
54	)
55	proposal_section = models.ForeignKey(	4✔
56	ProposalSection, verbose_name="Proposal Section", on_delete=models.CASCADE
57	)
58	active = models.BooleanField(default=True, verbose_name="Is Active?")	4✔
59
60	def __str__(self):	4✔
61	return "{}:[{}]".format(self.conference_reviewer, self.proposal_section)	×
62
63
64	@python_2_unicode_compatible	4✔
65	class ProposalType(AuditModel):	4✔
66
67	""" List of Proposal Types """
68
69	name = models.CharField(max_length=255, verbose_name="Proposal Type Name")	4✔
70	description = models.TextField(default="", blank=True)	4✔
71	active = models.BooleanField(default=True, verbose_name="Is Active?")	4✔
72	conferences = models.ManyToManyField(to=Conference, related_name="proposal_types")	4✔
73	start_date = models.DateField(default=datetime.now, verbose_name="Start Date")	4✔
74	end_date = models.DateField(default=datetime.now, verbose_name="End Date")	4✔
75
76	def __str__(self):	4✔
77	return self.name	4✔
78
79
80	@python_2_unicode_compatible	4✔
81	class Proposal(TimeAuditModel):	4✔
82
83	""" The proposals master """
84
85	conference = models.ForeignKey(Conference, on_delete=models.CASCADE)	4✔
86	proposal_section = models.ForeignKey(	4✔
87	ProposalSection, verbose_name="Proposal Section", on_delete=models.CASCADE
88	)
89	proposal_type = models.ForeignKey(	4✔
90	ProposalType, verbose_name="Proposal Type", on_delete=models.CASCADE
91	)
92	author = models.ForeignKey(	4✔
93	User, verbose_name="Primary Speaker", on_delete=models.CASCADE
94	)
95	title = models.CharField(max_length=255)	4✔
96	slug = AutoSlugField(max_length=255, populate_from=("title",))	4✔
97	description = models.TextField(default="")	4✔
98	target_audience = models.PositiveSmallIntegerField(	4✔
99	choices=ProposalTargetAudience.CHOICES,
100	default=ProposalTargetAudience.BEGINNER,
101	verbose_name="Target Audience",
102	)
103	video_url = models.URLField(	4✔
104	blank=True,
105	default="",
106	help_text="Short 1-2 min video describing your talk",
107	)
108	prerequisites = models.TextField(blank=True, default="")	4✔
109	content_urls = models.TextField(blank=True, default="")	4✔
110	private_content_urls = models.BooleanField(	4✔
111	default=False,
112	help_text="Check it if you want to make your content URLs private",
113	)
114	speaker_info = models.TextField(blank=True, default="")	4✔
115	speaker_links = models.TextField(blank=True, default="")	4✔
116	is_first_time_speaker = models.BooleanField(blank=True, default=False)	4✔
117	status = models.PositiveSmallIntegerField(	4✔
118	choices=ProposalStatus.CHOICES, default=ProposalStatus.DRAFT
119	)
120	review_status = models.PositiveSmallIntegerField(	4✔
121	choices=ProposalReviewStatus.CHOICES,
122	default=ProposalReviewStatus.YET_TO_BE_REVIEWED,
123	verbose_name="Review Status",
124	)
125	deleted = models.BooleanField(default=False, verbose_name="Is Deleted?")	4✔
126	history = HistoricalRecords()	4✔
127
128	def __str__(self):	4✔
129	return "{}, {}".format(self.title, self.proposal_type)	4✔
130
131	def is_public(self):	4✔
132	# TODO: Fix with proper enum
133	return self.status == 2	×
134
135	def get_slug(self):	4✔
136	return slugify(self.title)	4✔
137
138	def get_hashid(self):	4✔
139	hashids = Hashids(min_length=5)	4✔
140	return hashids.encode(self.id)	4✔
141
142	def get_absolute_url(self):	4✔
143	return reverse(	4✔
144	"proposal-detail",
145	args=[self.conference.slug, self.get_slug(), self.get_hashid()],
146	)
147
148	def get_update_url(self):	4✔
149	return reverse("proposal-update", args=[self.conference.slug, self.slug])	4✔
150
151	def get_review_url(self):	4✔
152	return reverse("proposal-review", args=[self.conference.slug, self.slug])	4✔
153
154	def get_vote_url(self):	4✔
155	return reverse("proposal-reviewer-vote", args=[self.conference.slug, self.slug])	4✔
156
157	def get_secondary_vote_url(self):	4✔
158	return reverse(	×
159	"proposal-reviewer-secondary-vote", args=[self.conference.slug, self.slug]
160	)
161
162	def get_delete_url(self):	4✔
163	return reverse("proposal-delete", args=[self.conference.slug, self.slug])	4✔
164
165	def get_up_vote_url(self):	4✔
166	return reverse("proposal-vote-up", args=[self.conference.slug, self.slug])	4✔
167
168	def get_down_vote_url(self):	4✔
169	return reverse("proposal-vote-down", args=[self.conference.slug, self.slug])	4✔
170
171	def get_remove_vote_url(self):	4✔
172	return reverse("proposal-vote-remove", args=[self.conference.slug, self.slug])	4✔
173
174	def get_comments_count(self):	4✔
175	""" Show only public comments count """
176	return ProposalComment.objects.filter(	×
177	proposal=self, deleted=False, private=False, vote=False, reviewer=False
178	).count()
179
180	def get_reviews_comments_count(self):	4✔
181	""" Show only private comments count """
182	return ProposalComment.objects.filter(	×
183	proposal=self, deleted=False, private=True, vote=False
184	).count()
185
186	def get_reviewer_comments_count(self, reviewer):	4✔
187	""" Number of private comments by a reviewer """
188	return ProposalComment.objects.filter(	×
189	proposal=self, deleted=False, private=True, commenter=reviewer, vote=False
190	).count()
191
192	def get_votes_count(self):	4✔
193	""" Show only the public comment count """
194	votes = (	×
195	ProposalVote.objects.filter(proposal=self)
196	.values("up_vote")
197	.annotate(counts=models.Count("up_vote"))
198	)
199	votes = {item["up_vote"]: item["counts"] for item in votes}	×
200	up_vote_count = votes.get(True, 0)	×
201	down_vote_count = votes.get(False, 0)	×
202	return up_vote_count - down_vote_count	×
203
204	def get_reviewer_votes_count(self):	4✔
205	""" Show sum of reviewer vote value. """
206	return ProposalSectionReviewerVote.objects.filter(proposal=self).count()	×
207
208	def get_reviewer_votes_count_by_value(self, vote_value):	4✔
209	""" Show sum of reviewer votes for given vote value. """
210	return ProposalSectionReviewerVote.objects.filter(	×
211	proposal=self, vote_value__vote_value=vote_value
212	).count()
213
214	def get_reviewer_votes_sum(self):	4✔
215	votes = ProposalSectionReviewerVote.objects.filter(	×
216	proposal=self,
217	)
218	sum_of_votes = sum((v.vote_value.vote_value for v in votes))	×
219	return sum_of_votes	×
220
221	def get_reviewer_vote_value(self, reviewer):	4✔
222	try:	×
223	vote = ProposalSectionReviewerVote.objects.get(	×
224	proposal=self,
225	voter__conference_reviewer__reviewer=reviewer,
226	)
227	return vote.vote_value.vote_value	×
228	except ProposalSectionReviewerVote.DoesNotExist:	×
229	return 0	×
230
231	def get_reviewers_count(self):	4✔
232	""" Count of reviewers for given proposal section """
233	return ProposalSectionReviewer.objects.filter(	×
234	proposal_section=self.proposal_section
235	).count()
236
237	def has_negative_votes(self):	4✔
238	""" Show sum of reviewer votes for given vote value. """
239	return (	×
240	ProposalSectionReviewerVote.objects.filter(
241	proposal=self,
242	vote_value__vote_value=ProposalReviewVote.NOT_ALLOWED,
243	).count()
244	> 0
245	)
246
247	def to_response(self, request):	4✔
248	"""method will return dict which can be passed to response"""
249	author = "{} {}".format(self.author.first_name, self.author.last_name)	×
250	data = {	×
251	"id": self.id,
252	"author": author,
253	"title": self.title,
254	"description": self.description,
255	"target_audience": dict(ProposalTargetAudience.CHOICES)[
256	self.target_audience
257	],
258	"status": dict(ProposalStatus.CHOICES)[self.status],
259	"review_status": dict(ProposalReviewStatus.CHOICES)[self.review_status],
260	"proposal_type": self.proposal_type.name,
261	"proposal_section": self.proposal_section.name,
262	"votes_count": self.get_votes_count(),
263	"speaker_info": self.speaker_info,
264	"speaker_links": self.speaker_links,
265	"content_urls": self.content_urls,
266	"private_content_urls": self.private_content_urls,
267	"conference": rf_reverse(
268	"conference-detail", kwargs={"pk": self.conference_id}, request=request
269	),
270	}
271	return data	×
272
273	class Meta:	4✔
274	unique_together = ("conference", "slug")	4✔
275
276
277	@python_2_unicode_compatible	4✔
278	class ProposalVote(TimeAuditModel):	4✔
279
280	""" User vote for a specific proposal """
281
282	proposal = models.ForeignKey(Proposal, on_delete=models.CASCADE)	4✔
283	voter = models.ForeignKey(User, on_delete=models.CASCADE)	4✔
284	role = models.PositiveSmallIntegerField(	4✔
285	choices=ProposalUserVoteRole.CHOICES, default=ProposalUserVoteRole.PUBLIC
286	)
287	up_vote = models.BooleanField(default=True)	4✔
288
289	def __str__(self):	4✔
290	return "[{}] {}".format("1" if self.up_vote else "-1", self.proposal)	×
291
292	class Meta:	4✔
293	unique_together = ("proposal", "voter")	4✔
294
295
296	class ProposalCommentQuerySet(models.QuerySet):	4✔
297	def get_public_comments(self):	4✔
298	return self.filter(private=False, reviewer=False, vote=False)	×
299
300	def get_reviewers_comments(self):	4✔
301	return self.filter(private=True, vote=False)	4✔
302
303	def get_reviewers_only_comments(self):	4✔
304	return self.filter(reviewer=True, vote=False)	4✔
305
306
307	@python_2_unicode_compatible	4✔
308	class ProposalSectionReviewerVoteValue(AuditModel):	4✔
309	""" Proposal reviewer vote choices. """
310
311	vote_value = models.SmallIntegerField()	4✔
312	description = models.CharField(max_length=255)	4✔
313
314	def __str__(self):	4✔
315	return "{} ({})".format(self.description, self.vote_value)	4✔
316
317	class Meta:	4✔
318	ordering = ("-vote_value",)	4✔
319
320
321	@python_2_unicode_compatible	4✔
322	class ProposalSectionReviewerVote(TimeAuditModel):	4✔
323
324	""" Reviewer vote for a specific proposal """
325
326	proposal = models.ForeignKey(Proposal, on_delete=models.CASCADE)	4✔
327	voter = models.ForeignKey(ProposalSectionReviewer, on_delete=models.CASCADE)	4✔
328	role = models.PositiveSmallIntegerField(	4✔
329	choices=ProposalUserVoteRole.CHOICES, default=ProposalUserVoteRole.REVIEWER
330	)
331	vote_value = models.ForeignKey(	4✔
332	ProposalSectionReviewerVoteValue, on_delete=models.CASCADE
333	)
334	phase = models.PositiveSmallIntegerField(	4✔
335	choices=PSRVotePhase.CHOICES, default=PSRVotePhase.PRIMARY
336	)
337
338	history = HistoricalRecords()	4✔
339
340	def __str__(self):	4✔
341	return "[{}] {}".format(self.vote_value, self.proposal)	×
342
343	class Meta:	4✔
344	verbose_name = "ProposalSectionReviewerVote"	4✔
345
346
347	# FIXME: Need to move private, reviewer, vote to type
348	@python_2_unicode_compatible	4✔
349	class ProposalComment(TimeAuditModel):	4✔
350
351	""" User comments for a specific proposal """
352
353	proposal = models.ForeignKey(Proposal, on_delete=models.CASCADE)	4✔
354	commenter = models.ForeignKey(User, on_delete=models.CASCADE)	4✔
355	private = models.BooleanField(default=False, verbose_name="Is Private?")	4✔
356	reviewer = models.BooleanField(default=False, verbose_name="Is Reviewer?")	4✔
357	vote = models.BooleanField(default=False, verbose_name="What is the reason?")	4✔
358	comment = models.TextField()	4✔
359	deleted = models.BooleanField(default=False, verbose_name="Is Deleted?")	4✔
360	comment_type = models.PositiveSmallIntegerField(	4✔
361	choices=ProposalCommentType.CHOICES, default=ProposalCommentType.GENERAL
362	)
363	objects = ProposalCommentQuerySet.as_manager()	4✔
364	is_spam = models.BooleanField(default=False, blank=True)	4✔
365	marked_as_spam_by = models.ForeignKey(	4✔
366	User,
367	related_name="marked_as_spam_by",
368	default=None,
369	null=True,
370	blank=True,
371	on_delete=models.SET_NULL,
372	)
373
374	class Meta:	4✔
375	ordering = ("created_at",)	4✔
376	index_together = [["is_spam", "marked_as_spam_by"], ["commenter", "is_spam"]]	4✔
377
378	def __str__(self):	4✔
379	return "[{} by {}] {}".format(	×
380	self.comment, self.commenter.get_full_name(), self.proposal
381	)
382
383	def get_up_vote_url(self):	4✔
384	return reverse(	×
385	"proposal-comment-up-vote",
386	args=[self.proposal.conference.slug, self.proposal.slug, self.id],
387	)
388
389	def get_down_vote_url(self):	4✔
390	return reverse(	×
391	"proposal-comment-down-vote",
392	args=[self.proposal.conference.slug, self.proposal.slug, self.id],
393	)
394
395	def get_mark_spam_url(self):	4✔
396	return reverse(	×
397	"comment_mark_spam",
398	args=[self.proposal.conference.slug, self.proposal.slug, self.id],
399	)
400
401	def get_unmark_spam_url(self):	4✔
402	return reverse(	×
403	"comment_unmark_spam",
404	args=[self.proposal.conference.slug, self.proposal.slug, self.id],
405	)
406
407	def get_votes_count(self):	4✔
408	up_vote_count = ProposalCommentVote.objects.filter(	×
409	proposal_comment=self, up_vote=True
410	).count()
411	down_vote_count = ProposalCommentVote.objects.filter(	×
412	proposal_comment=self, up_vote=False
413	).count()
414	return up_vote_count - down_vote_count	×
415
416	def get_reviewer_nick(self):	4✔
417	reviewer = ConferenceProposalReviewer.objects.get(	×
418	conference_id=self.proposal.conference_id, reviewer_id=self.commenter_id
419	)
420	return reviewer.nick	×
421
422	def get_comment_type(self):	4✔
423	if self.deleted:	4✔
424	return "Deleted"	×
425	elif self.vote:	4✔
426	return "Vote"	×
427	elif self.reviewer:	4✔
428	return "Reviewer Only"	4✔
429	elif self.private:	4✔
430	return "Review"	4✔
431	else:
432	return "Public"	4✔
433
434
435	@python_2_unicode_compatible	4✔
436	class ProposalCommentVote(TimeAuditModel):	4✔
437
438	""" User vote for a specific proposal's comment """
439
440	proposal_comment = models.ForeignKey(ProposalComment, on_delete=models.CASCADE)	4✔
441	voter = models.ForeignKey(User, on_delete=models.CASCADE)	4✔
442	up_vote = models.BooleanField(default=True)	4✔
443
444	def __str__(self):	4✔
445	return "[{}] {}".format("1" if self.up_vote else "-1", self.proposal_comment)	×
446
447	class Meta:	4✔
448	unique_together = ("proposal_comment", "voter")	4✔

pythonindia / junction / 1531

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous