from patchwork.models import Bundle
from patchwork.models import Check
-from patchwork.models import Comment
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
+from patchwork.models import CoverComment
from patchwork.models import DelegationRule
from patchwork.models import Patch
+from patchwork.models import PatchComment
from patchwork.models import PatchRelation
from patchwork.models import Person
from patchwork.models import Project
admin.site.register(State, StateAdmin)
-class CoverLetterAdmin(admin.ModelAdmin):
+class CoverAdmin(admin.ModelAdmin):
list_display = ('name', 'submitter', 'project', 'date')
list_filter = ('project', )
search_fields = ('name', 'submitter__name', 'submitter__email')
date_hierarchy = 'date'
-admin.site.register(CoverLetter, CoverLetterAdmin)
+admin.site.register(Cover, CoverAdmin)
class PatchAdmin(admin.ModelAdmin):
admin.site.register(Patch, PatchAdmin)
-class CommentAdmin(admin.ModelAdmin):
- list_display = ('submission', 'submitter', 'date')
- search_fields = ('submission__name', 'submitter__name', 'submitter__email')
+class CoverCommentAdmin(admin.ModelAdmin):
+ list_display = ('cover', 'submitter', 'date')
+ search_fields = ('cover__name', 'submitter__name', 'submitter__email')
date_hierarchy = 'date'
-admin.site.register(Comment, CommentAdmin)
+admin.site.register(CoverComment, CoverCommentAdmin)
+
+
+class PatchCommentAdmin(admin.ModelAdmin):
+ list_display = ('patch', 'submitter', 'date')
+ search_fields = ('patch__name', 'submitter__name', 'submitter__email')
+ date_hierarchy = 'date'
+
+
+admin.site.register(PatchComment, PatchCommentAdmin)
class PatchInline(admin.StackedInline):
from patchwork.api.base import BaseHyperlinkedModelSerializer
from patchwork.api.base import PatchworkPermission
from patchwork.api.embedded import PersonSerializer
-from patchwork.models import Comment
+from patchwork.models import Cover
+from patchwork.models import CoverComment
from patchwork.models import Submission
+from patchwork.models import PatchComment
-class CommentListSerializer(BaseHyperlinkedModelSerializer):
+class BaseCommentListSerializer(BaseHyperlinkedModelSerializer):
web_url = SerializerMethodField()
subject = SerializerMethodField()
return headers
class Meta:
- model = Comment
fields = ('id', 'web_url', 'msgid', 'list_archive_url', 'date',
'subject', 'submitter', 'content', 'headers')
read_only_fields = fields
}
-class CommentList(ListAPIView):
+class CoverCommentListSerializer(BaseCommentListSerializer):
+
+ class Meta:
+ model = CoverComment
+ fields = BaseCommentListSerializer.Meta.fields
+ read_only_fields = fields
+ versioned_fields = BaseCommentListSerializer.Meta.versioned_fields
+
+
+class PatchCommentListSerializer(BaseCommentListSerializer):
+
+ class Meta:
+ model = PatchComment
+ fields = BaseCommentListSerializer.Meta.fields
+ read_only_fields = fields
+ versioned_fields = BaseCommentListSerializer.Meta.versioned_fields
+
+
+class CoverCommentList(ListAPIView):
+ """List cover comments"""
+
+ permission_classes = (PatchworkPermission,)
+ serializer_class = CoverCommentListSerializer
+ search_fields = ('subject',)
+ ordering_fields = ('id', 'subject', 'date', 'submitter')
+ ordering = 'id'
+ lookup_url_kwarg = 'pk'
+
+ def get_queryset(self):
+ if not Cover.objects.filter(pk=self.kwargs['pk']).exists():
+ raise Http404
+
+ return CoverComment.objects.filter(
+ cover=self.kwargs['pk']
+ ).select_related('submitter')
+
+
+class PatchCommentList(ListAPIView):
"""List comments"""
permission_classes = (PatchworkPermission,)
- serializer_class = CommentListSerializer
+ serializer_class = PatchCommentListSerializer
search_fields = ('subject',)
ordering_fields = ('id', 'subject', 'date', 'submitter')
ordering = 'id'
if not Submission.objects.filter(pk=self.kwargs['pk']).exists():
raise Http404
- return Comment.objects.filter(
- submission=self.kwargs['pk']
+ return PatchComment.objects.filter(
+ patch=self.kwargs['pk']
).select_related('submitter')
from patchwork.api.embedded import PersonSerializer
from patchwork.api.embedded import ProjectSerializer
from patchwork.api.embedded import SeriesSerializer
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
class CoverListSerializer(BaseHyperlinkedModelSerializer):
return data
class Meta:
- model = CoverLetter
+ model = Cover
fields = ('id', 'url', 'web_url', 'project', 'msgid',
'list_archive_url', 'date', 'name', 'submitter', 'mbox',
'series', 'comments')
return headers
class Meta:
- model = CoverLetter
+ model = Cover
fields = CoverListSerializer.Meta.fields + (
'headers', 'content')
read_only_fields = fields
ordering = 'id'
def get_queryset(self):
- return CoverLetter.objects.all()\
+ return Cover.objects.all()\
.prefetch_related('series__project')\
.select_related('project', 'submitter', 'series')\
.defer('content', 'headers')
serializer_class = CoverDetailSerializer
def get_queryset(self):
- return CoverLetter.objects.all()\
+ return Cover.objects.all()\
.select_related('project', 'submitter', 'series')
class _Serializer(MboxMixin, WebURLMixin, BaseHyperlinkedModelSerializer):
class Meta:
- model = models.CoverLetter
+ model = models.Cover
fields = ('id', 'url', 'web_url', 'msgid', 'list_archive_url',
'date', 'name', 'mbox')
read_only_fields = fields
from patchwork.api import utils
from patchwork.models import Bundle
from patchwork.models import Check
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
from patchwork.models import Event
from patchwork.models import Patch
from patchwork.models import Person
msgid = CharFilter(method=msgid_filter)
class Meta:
- model = CoverLetter
+ model = Cover
fields = ('project', 'series', 'submitter')
patch = BaseFilter(queryset=Patch.objects.all(),
widget=MultipleHiddenInput,
distinct=False)
- cover = BaseFilter(queryset=CoverLetter.objects.all(),
+ cover = BaseFilter(queryset=Cover.objects.all(),
widget=MultipleHiddenInput,
distinct=False)
def handle(self, *args, **options):
results = {
models.Patch: 0,
- models.CoverLetter: 0,
- models.Comment: 0,
+ models.Cover: 0,
+ models.PatchComment: 0,
+ models.CoverComment: 0,
}
duplicates = 0
dropped = 0
' %(errors)4d errors\n'
'Total: %(new)s new entries' % {
'total': count,
- 'covers': results[models.CoverLetter],
+ 'covers': results[models.Cover],
'patches': results[models.Patch],
- 'comments': results[models.Comment],
+ 'comments': (
+ results[models.CoverComment] + results[models.PatchComment]
+ ),
'duplicates': duplicates,
'dropped': dropped,
'errors': errors,
--- /dev/null
+import datetime
+
+from django.db import migrations, models
+import django.db.models.deletion
+import patchwork.models
+
+
+class Migration(migrations.Migration):
+
+ dependencies = [
+ ('patchwork', '0041_python3'),
+ ]
+
+ operations = [
+ # create a new, separate cover (letter) model
+
+ migrations.CreateModel(
+ name='Cover',
+ fields=[
+ (
+ 'id',
+ models.AutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name='ID',
+ ),
+ ),
+ ('msgid', models.CharField(max_length=255)),
+ (
+ 'date',
+ models.DateTimeField(default=datetime.datetime.utcnow),
+ ),
+ ('headers', models.TextField(blank=True)),
+ ('content', models.TextField(blank=True, null=True)),
+ ('name', models.CharField(max_length=255)),
+ (
+ 'project',
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ to='patchwork.Project',
+ ),
+ ),
+ (
+ 'submitter',
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ to='patchwork.Person',
+ ),
+ ),
+ ],
+ options={'ordering': ['date']},
+ bases=(patchwork.models.FilenameMixin, models.Model),
+ ),
+ migrations.AddIndex(
+ model_name='cover',
+ index=models.Index(
+ fields=['date', 'project', 'submitter', 'name'],
+ name='cover_covering_idx',
+ ),
+ ),
+ migrations.AlterUniqueTogether(
+ name='cover', unique_together=set([('msgid', 'project')]),
+ ),
+
+ # create a new, separate cover (letter) comment model
+
+ migrations.CreateModel(
+ name='CoverComment',
+ fields=[
+ (
+ 'id',
+ models.AutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name='ID',
+ ),
+ ),
+ ('msgid', models.CharField(max_length=255)),
+ (
+ 'date',
+ models.DateTimeField(default=datetime.datetime.utcnow),
+ ),
+ ('headers', models.TextField(blank=True)),
+ ('content', models.TextField(blank=True, null=True)),
+ (
+ 'cover',
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name='comments',
+ related_query_name='comment',
+ to='patchwork.Cover',
+ ),
+ ),
+ (
+ 'submitter',
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ to='patchwork.Person',
+ ),
+ ),
+ ],
+ options={'ordering': ['date']},
+ ),
+ migrations.AddIndex(
+ model_name='covercomment',
+ index=models.Index(
+ fields=['cover', 'date'], name='cover_date_idx'
+ ),
+ ),
+ migrations.AlterUniqueTogether(
+ name='covercomment', unique_together=set([('msgid', 'cover')]),
+ ),
+
+ # copy all entries from the 'CoverLetter' model to the new 'Cover'
+ # model; note that it's not possible to reverse this since we can't
+ # guarantee IDs will be unique after the split
+
+ migrations.RunSQL(
+ """
+ INSERT INTO patchwork_cover
+ (id, msgid, name, date, headers, project_id, submitter_id,
+ content)
+ SELECT s.id, s.msgid, s.name, s.date, s.headers, s.project_id,
+ s.submitter_id, s.content
+ FROM patchwork_coverletter c
+ INNER JOIN patchwork_submission s ON s.id = c.submission_ptr_id
+ """,
+ None,
+ ),
+
+ # copy all 'CoverLetter'-related comments to the new 'CoverComment'
+ # table; as above, this is non-reversible
+
+ migrations.RunSQL(
+ """
+ INSERT INTO patchwork_covercomment
+ (id, msgid, date, headers, content, cover_id, submitter_id)
+ SELECT c.id, c.msgid, c.date, c.headers, c.content,
+ c.submission_id, c.submitter_id
+ FROM patchwork_comment c
+ INNER JOIN patchwork_coverletter p
+ ON p.submission_ptr_id = c.submission_id
+ """,
+ None,
+ ),
+
+ # update all references to the 'CoverLetter' model to point to the new
+ # 'Cover' model instead
+
+ migrations.AlterField(
+ model_name='event',
+ name='cover',
+ field=models.ForeignKey(
+ blank=True,
+ help_text='The cover letter that this event was created for.',
+ null=True,
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name='+',
+ to='patchwork.Cover',
+ ),
+ ),
+ migrations.AlterField(
+ model_name='series',
+ name='cover_letter',
+ field=models.OneToOneField(
+ null=True,
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name='series',
+ to='patchwork.Cover'
+ ),
+ ),
+
+ # remove all the old 'CoverLetter'-related entries from the 'Comment'
+ # table
+
+ migrations.RunSQL(
+ """
+ DELETE patchwork_comment FROM
+ patchwork_comment
+ INNER JOIN patchwork_coverletter
+ ON patchwork_coverletter.submission_ptr_id = patchwork_comment.submission_id
+ """, # noqa
+ None
+ ),
+
+ # delete the old 'CoverLetter' model
+
+ migrations.DeleteModel(
+ name='CoverLetter',
+ ),
+
+ # rename the 'Comment.submission' field to 'Comment.patch'; note our
+ # use of 'AlterField' before and after to work around bug #31335
+ #
+ # https://code.djangoproject.com/ticket/31335
+
+ migrations.AlterField(
+ model_name='comment',
+ name='submission',
+ field=models.ForeignKey(
+ db_constraint=False,
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name='comments',
+ related_query_name='comment',
+ to='patchwork.Submission',
+ ),
+ ),
+ migrations.RemoveIndex(
+ model_name='comment',
+ name='submission_date_idx',
+ ),
+ migrations.RenameField(
+ model_name='comment',
+ old_name='submission',
+ new_name='patch',
+ ),
+ migrations.AlterUniqueTogether(
+ name='comment',
+ unique_together=set([('msgid', 'patch')]),
+ ),
+ migrations.AddIndex(
+ model_name='comment',
+ index=models.Index(
+ fields=['patch', 'date'],
+ name='patch_date_idx',
+ ),
+ ),
+ migrations.AlterField(
+ model_name='comment',
+ name='patch',
+ field=models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name='comments',
+ related_query_name='comment',
+ to='patchwork.Submission',
+ ),
+ ),
+
+ # rename the 'Comment' model to 'PatchComment'
+
+ migrations.RenameModel(
+ old_name='Comment',
+ new_name='PatchComment',
+ ),
+ ]
return fname
-class Submission(FilenameMixin, EmailMixin, models.Model):
+class SubmissionMixin(models.Model):
# parent
project = models.ForeignKey(Project, on_delete=models.CASCADE)
return self.name
class Meta:
- ordering = ['date']
- unique_together = [('msgid', 'project')]
- indexes = [
- # This is a covering index for the /list/ query
- # Like what we have for Patch, but used for displaying what we want
- # rather than for working out the count (of course, this all
- # depends on the SQL optimiser of your db engine)
- models.Index(fields=['date', 'project', 'submitter', 'name'],
- name='submission_covering_idx'),
- ]
+ abstract = True
-class CoverLetter(Submission):
+class Cover(FilenameMixin, EmailMixin, SubmissionMixin):
def get_absolute_url(self):
return reverse('cover-detail',
kwargs={'project_id': self.project.linkname,
'msgid': self.url_msgid})
+ class Meta:
+ ordering = ['date']
+ unique_together = [('msgid', 'project')]
+ indexes = [
+ # This is a covering index for the /list/ query
+ # Like what we have for Patch, but used for displaying what we want
+ # rather than for working out the count (of course, this all
+ # depends on the SQL optimiser of your DB engine)
+ models.Index(
+ fields=['date', 'project', 'submitter', 'name'],
+ name='cover_covering_idx',
+ ),
+ ]
+
+
+class Submission(SubmissionMixin, FilenameMixin, EmailMixin):
+
+ class Meta:
+ ordering = ['date']
+ unique_together = [('msgid', 'project')]
+ indexes = [
+ # This is a covering index for the /list/ query
+ # Like what we have for Patch, but used for displaying what we want
+ # rather than for working out the count (of course, this all
+ # depends on the SQL optimiser of your db engine)
+ models.Index(fields=['date', 'project', 'submitter', 'name'],
+ name='submission_covering_idx'),
+ ]
+
class Patch(Submission):
# patch metadata
]
-class Comment(EmailMixin, models.Model):
+class CoverComment(EmailMixin, models.Model):
+
+ cover = models.ForeignKey(
+ Cover,
+ related_name='comments',
+ related_query_name='comment',
+ on_delete=models.CASCADE,
+ )
+
+ @property
+ def list_archive_url(self):
+ if not self.cover.project.list_archive_url_format:
+ return None
+ if not self.msgid:
+ return None
+ return self.project.list_archive_url_format.format(self.url_msgid)
+
+ def get_absolute_url(self):
+ return reverse('comment-redirect', kwargs={'comment_id': self.id})
+
+ def is_editable(self, user):
+ return False
+
+ class Meta:
+ ordering = ['date']
+ unique_together = [('msgid', 'cover')]
+ indexes = [
+ models.Index(name='cover_date_idx', fields=['cover', 'date']),
+ ]
+
+
+class PatchComment(EmailMixin, models.Model):
# parent
- submission = models.ForeignKey(Submission, related_name='comments',
- related_query_name='comment',
- on_delete=models.CASCADE)
+ patch = models.ForeignKey(
+ Submission,
+ related_name='comments',
+ related_query_name='comment',
+ on_delete=models.CASCADE,
+ )
@property
def list_archive_url(self):
- if not self.submission.project.list_archive_url_format:
+ if not self.patch.project.list_archive_url_format:
return None
if not self.msgid:
return None
- return self.project.list_archive_url_format.format(
+ return self.patch.list_archive_url_format.format(
self.url_msgid)
def get_absolute_url(self):
return reverse('comment-redirect', kwargs={'comment_id': self.id})
def save(self, *args, **kwargs):
- super(Comment, self).save(*args, **kwargs)
- if hasattr(self.submission, 'patch'):
- self.submission.patch.refresh_tag_counts()
+ super(PatchComment, self).save(*args, **kwargs)
+ # TODO(stephenfin): Update this once patch is flattened
+ if hasattr(self.patch, 'patch'):
+ self.patch.patch.refresh_tag_counts()
def delete(self, *args, **kwargs):
- super(Comment, self).delete(*args, **kwargs)
- if hasattr(self.submission, 'patch'):
- self.submission.patch.refresh_tag_counts()
+ super(PatchComment, self).delete(*args, **kwargs)
+ # TODO(stephenfin): Update this once patch is flattened
+ if hasattr(self.patch, 'patch'):
+ self.patch.patch.refresh_tag_counts()
def is_editable(self, user):
return False
class Meta:
ordering = ['date']
- unique_together = [('msgid', 'submission')]
+ unique_together = [('msgid', 'patch')]
indexes = [
- models.Index(name='submission_date_idx',
- fields=['submission', 'date'])
+ models.Index(name='patch_date_idx', fields=['patch', 'date']),
]
blank=True, on_delete=models.CASCADE)
# content
- cover_letter = models.OneToOneField(CoverLetter, related_name='series',
- null=True,
- on_delete=models.CASCADE)
+ cover_letter = models.OneToOneField(
+ Cover,
+ related_name='series',
+ null=True,
+ on_delete=models.CASCADE
+ )
# metadata
name = models.CharField(max_length=255, blank=True, null=True,
on_delete=models.CASCADE,
help_text='The series that this event was created for.')
cover = models.ForeignKey(
- CoverLetter, related_name='+', null=True, blank=True,
+ Cover, related_name='+', null=True, blank=True,
on_delete=models.CASCADE,
help_text='The cover letter that this event was created for.')
from django.db.utils import IntegrityError
from django.db import transaction
-from patchwork.models import Comment
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
+from patchwork.models import CoverComment
from patchwork.models import DelegationRule
from patchwork.models import get_default_initial_patch_state
from patchwork.models import Patch
+from patchwork.models import PatchComment
from patchwork.models import Person
from patchwork.models import Project
from patchwork.models import Series
# see if we have comments that refer to a patch
try:
- comment = Comment.objects.get(submission__project=project,
- msgid=ref)
+ comment = PatchComment.objects.get(
+ patch__project=project,
+ msgid=ref,
+ )
return comment.submission
- except Comment.MultipleObjectsReturned:
+ except PatchComment.MultipleObjectsReturned:
# NOTE(stephenfin): This is a artifact of prior lack of support
# for cover letters in Patchwork. Previously all replies to
# patches were saved as comments. However, it's possible that
# apply the comment to the cover letter. Note that this only
# happens when running 'parsearchive' or similar, so it should not
# affect every day use in any way.
- comments = Comment.objects.filter(submission__project=project,
- msgid=ref)
+ comments = PatchComment.objects.filter(
+ patch__project=project,
+ msgid=ref,
+ )
# The latter item will be the cover letter
return comments.reverse()[0].submission
- except Comment.DoesNotExist:
+ except PatchComment.DoesNotExist:
+ pass
+
+ return None
+
+
+def find_cover_for_comment(project, refs):
+ for ref in refs:
+ ref = ref[:255]
+ # first, check for a direct reply
+ try:
+ cover = Cover.objects.get(project=project, msgid=ref)
+ return cover
+ except Cover.DoesNotExist:
+ pass
+
+ # see if we have comments that refer to a patch
+ try:
+ comment = CoverComment.objects.get(
+ cover__project=project,
+ msgid=ref,
+ )
+ return comment.cover
+ except CoverComment.DoesNotExist:
pass
return None
if not is_comment:
if not refs == []:
try:
- CoverLetter.objects.all().get(name=name)
- except CoverLetter.DoesNotExist:
+ Cover.objects.all().get(name=name)
+ except Cover.DoesNotExist:
# if no match, this is a new cover letter
is_cover_letter = True
- except CoverLetter.MultipleObjectsReturned:
+ except Cover.MultipleObjectsReturned:
# if multiple cover letters are found, just ignore
pass
else:
msgid=msgid, project=project, series=series)
with transaction.atomic():
- if CoverLetter.objects.filter(project=project, msgid=msgid):
+ if Cover.objects.filter(project=project, msgid=msgid):
raise DuplicateMailError(msgid=msgid)
- cover_letter = CoverLetter.objects.create(
+ cover_letter = Cover.objects.create(
msgid=msgid,
project=project,
name=name[:255],
# we only save comments if we have the parent email
submission = find_submission_for_comment(project, refs)
- if not submission:
+ if submission:
+ author = get_or_create_author(mail, project)
+
+ with transaction.atomic():
+ if PatchComment.objects.filter(patch=patch, msgid=msgid):
+ raise DuplicateMailError(msgid=msgid)
+ comment = PatchComment.objects.create(
+ patch=submission,
+ msgid=msgid,
+ date=date,
+ headers=headers,
+ submitter=author,
+ content=message)
+
+ logger.debug('Comment saved')
+
+ return comment
+
+ cover = find_cover_for_comment(project, refs)
+ if not cover:
return
author = get_or_create_author(mail, project)
with transaction.atomic():
- if Comment.objects.filter(submission=submission, msgid=msgid):
+ if CoverComment.objects.filter(cover=cover, msgid=msgid):
raise DuplicateMailError(msgid=msgid)
- comment = Comment.objects.create(
- submission=submission,
+ comment = CoverComment.objects.create(
+ cover=cover,
msgid=msgid,
date=date,
headers=headers,
from django.dispatch import receiver
from patchwork.models import Check
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
from patchwork.models import Event
from patchwork.models import Patch
from patchwork.models import PatchChangeNotification
notification.save()
-@receiver(post_save, sender=CoverLetter)
+@receiver(post_save, sender=Cover)
def create_cover_created_event(sender, instance, created, raw, **kwargs):
def create_event(cover):
from django.urls import reverse
from patchwork.tests.api import utils
-from patchwork.tests.utils import create_comment
from patchwork.tests.utils import create_cover
+from patchwork.tests.utils import create_cover_comment
from patchwork.tests.utils import create_patch
+from patchwork.tests.utils import create_patch_comment
from patchwork.tests.utils import SAMPLE_CONTENT
if settings.ENABLE_REST_API:
def test_list(self):
"""List cover letter comments."""
cover = create_cover()
- comment = create_comment(submission=cover)
+ comment = create_cover_comment(cover=cover)
resp = self.client.get(self.api_url(cover))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
def test_list_version_1_0(self):
"""List cover letter comments using API v1.0."""
cover = create_cover()
- create_comment(submission=cover)
+ create_cover_comment(cover=cover)
# check we can't access comments using the old version of the API
with self.assertRaises(NoReverseMatch):
def test_list(self):
"""List patch comments."""
patch = create_patch()
- comment = create_comment(submission=patch)
+ comment = create_patch_comment(patch=patch)
resp = self.client.get(self.api_url(patch))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
def test_list_version_1_0(self):
"""List patch comments using API v1.0."""
patch = create_patch()
- create_comment(submission=patch)
+ create_patch_comment(patch=patch)
# check we can't access comments using the old version of the API
with self.assertRaises(NoReverseMatch):
from django.test import TestCase
from django.urls import reverse
-from patchwork.tests.utils import create_comment
from patchwork.tests.utils import create_cover
+from patchwork.tests.utils import create_cover_comment
from patchwork.tests.utils import create_patch
+from patchwork.tests.utils import create_patch_comment
from patchwork.tests.utils import create_project
class CommentRedirectTest(TestCase):
- def _test_redirect(self, submission, submission_url):
- comment_id = create_comment(submission=submission).id
+ def test_patch_redirect(self):
+ patch = create_patch()
+ comment_id = create_patch_comment(patch=patch).id
requested_url = reverse('comment-redirect',
kwargs={'comment_id': comment_id})
redirect_url = '%s#%d' % (
- reverse(submission_url,
- kwargs={'project_id': submission.project.linkname,
- 'msgid': submission.url_msgid}),
+ reverse('patch-detail',
+ kwargs={'project_id': patch.project.linkname,
+ 'msgid': patch.url_msgid}),
comment_id)
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
- def test_patch_redirect(self):
- patch = create_patch()
- self._test_redirect(patch, 'patch-detail')
-
def test_cover_redirect(self):
cover = create_cover()
- self._test_redirect(cover, 'cover-detail')
+ comment_id = create_cover_comment(cover=cover).id
+
+ requested_url = reverse('comment-redirect',
+ kwargs={'comment_id': comment_id})
+ redirect_url = '%s#%d' % (
+ reverse('cover-detail',
+ kwargs={'project_id': cover.project.linkname,
+ 'msgid': cover.url_msgid}),
+ comment_id)
+
+ response = self.client.get(requested_url)
+ self.assertRedirects(response, redirect_url)
from django.test import TestCase
from django.urls import reverse
-from patchwork.tests.utils import create_comment
from patchwork.tests.utils import create_patch
+from patchwork.tests.utils import create_patch_comment
from patchwork.tests.utils import create_project
from patchwork.tests.utils import create_person
from patchwork.tests.utils import create_series
project=self.project,
submitter=self.person,
content='comment 1 text\nAcked-by: 1\n')
- create_comment(
- submission=patch,
+ create_patch_comment(
+ patch=patch,
submitter=self.person,
content='comment 2 text\nAcked-by: 2\n')
response = self.client.get(
project=self.project,
submitter=self.person,
content='patch text\n')
- create_comment(
- submission=patch,
+ create_patch_comment(
+ patch=patch,
submitter=self.person,
content=u'comment\nAcked-by:\u00A0 foo')
response = self.client.get(
submitter=self.person,
diff='',
content='comment 1 text\nAcked-by: 1\n---\nupdate\n')
- self.comment = create_comment(
- submission=self.patch,
+ self.comment = create_patch_comment(
+ patch=self.patch,
submitter=self.person,
content='comment 2 text\nAcked-by: 2\n')
from django.db.transaction import atomic
from django.db import connection
-from patchwork.models import Comment
+from patchwork.models import Cover
from patchwork.models import Patch
+from patchwork.models import PatchComment
from patchwork.models import Person
from patchwork.models import State
-from patchwork.models import CoverLetter
from patchwork.parser import clean_subject
from patchwork.parser import get_or_create_author
from patchwork.parser import find_patch_content as find_content
patch = Patch.objects.filter(project=project)[0]
# we should see the reply comment only
self.assertEqual(
- Comment.objects.filter(submission=patch).count(), 1)
+ PatchComment.objects.filter(patch=patch).count(), 1)
class ListIdHeaderTest(TestCase):
self._test_duplicate_mail(m2)
self.assertEqual(Patch.objects.count(), 1)
- self.assertEqual(Comment.objects.count(), 1)
+ self.assertEqual(PatchComment.objects.count(), 1)
def test_duplicate_coverletter(self):
m = create_email('test', listid=self.listid, msgid='1@example.com')
self._test_duplicate_mail(m)
- self.assertEqual(CoverLetter.objects.count(), 1)
+ self.assertEqual(Cover.objects.count(), 1)
mbox = mailbox.mbox(os.path.join(TEST_SERIES_DIR, name), create=False)
for msg in mbox:
obj = parser.parse_mail(msg, project.listid)
- if type(obj) == models.CoverLetter:
+ if type(obj) == models.Cover:
results[0].append(obj)
elif type(obj) == models.Patch:
results[1].append(obj)
from patchwork.models import Patch
from patchwork.models import PatchTag
from patchwork.models import Tag
-from patchwork.tests.utils import create_comment
from patchwork.tests.utils import create_patch
+from patchwork.tests.utils import create_patch_comment
class ExtractTagsTest(TestCase):
return '%s-by: Test Tagger <tagger@example.com>\n' % tags[tagtype]
def create_tag_comment(self, patch, tagtype=None):
- comment = create_comment(
- submission=patch,
+ comment = create_patch_comment(
+ patch=patch,
content=self.create_tag(tagtype))
return comment
from patchwork.models import Bundle
from patchwork.models import Check
-from patchwork.models import Comment
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
+from patchwork.models import CoverComment
from patchwork.models import Patch
+from patchwork.models import PatchComment
from patchwork.models import PatchRelation
from patchwork.models import Person
from patchwork.models import Project
def create_cover(**kwargs):
- """Create 'CoverLetter' object."""
- num = CoverLetter.objects.count()
+ """Create 'Cover' object."""
+ num = Cover.objects.count()
# NOTE(stephenfin): Despite first appearances, passing 'series' to the
# 'create' function doesn't actually cause the relationship to be created.
}
values.update(kwargs)
- cover = CoverLetter.objects.create(**values)
+ cover = Cover.objects.create(**values)
if series:
series.add_cover_letter(cover)
return cover
-def create_comment(**kwargs):
- """Create 'Comment' object."""
+def create_cover_comment(**kwargs):
+ """Create 'CoverComment' object."""
values = {
'submitter': create_person() if 'submitter' not in kwargs else None,
- 'submission': create_patch() if 'submission' not in kwargs else None,
+ 'cover': create_cover() if 'cover' not in kwargs else None,
'msgid': make_msgid(),
'content': SAMPLE_CONTENT,
}
values.update(kwargs)
- return Comment.objects.create(**values)
+ return CoverComment.objects.create(**values)
+
+
+def create_patch_comment(**kwargs):
+ """Create 'PatchComment' object."""
+ values = {
+ 'submitter': create_person() if 'submitter' not in kwargs else None,
+ 'patch': create_patch() if 'patch' not in kwargs else None,
+ 'msgid': make_msgid(),
+ 'content': SAMPLE_CONTENT,
+ }
+ values.update(kwargs)
+
+ return PatchComment.objects.create(**values)
def create_check(**kwargs):
api_1_1_patterns = [
url(r'^patches/(?P<pk>[^/]+)/comments/$',
- api_comment_views.CommentList.as_view(),
+ api_comment_views.PatchCommentList.as_view(),
name='api-patch-comment-list'),
url(r'^covers/(?P<pk>[^/]+)/comments/$',
- api_comment_views.CommentList.as_view(),
+ api_comment_views.CoverCommentList.as_view(),
name='api-cover-comment-list'),
]
# SPDX-License-Identifier: GPL-2.0-or-later
from django import http
-from django import shortcuts
from django.urls import reverse
from patchwork import models
def comment(request, comment_id):
- submission = shortcuts.get_object_or_404(models.Comment,
- id=comment_id).submission
- if models.Patch.objects.filter(id=submission.id).exists():
- url = 'patch-detail'
- else:
- url = 'cover-detail'
-
- return http.HttpResponseRedirect('%s#%s' % (
- reverse(url, kwargs={'project_id': submission.project.linkname,
- 'msgid': submission.url_msgid}), comment_id))
+ patch = None
+ cover = None
+
+ try:
+ patch = models.PatchComment.objects.get(id=comment_id).patch
+ except models.PatchComment.DoesNotExist:
+ try:
+ cover = models.CoverComment.objects.get(id=comment_id).cover
+ except models.CoverComment.DoesNotExist:
+ pass
+
+ if not patch and not cover:
+ raise http.Http404('No comment matches the given query.')
+
+ if patch:
+ url = reverse(
+ 'patch-detail',
+ kwargs={
+ 'project_id': patch.project.linkname,
+ 'msgid': patch.url_msgid,
+ },
+ )
+ else: # cover
+ url = reverse(
+ 'cover-detail',
+ kwargs={
+ 'project_id': cover.project.linkname,
+ 'msgid': cover.url_msgid,
+ },
+ )
+
+ return http.HttpResponseRedirect('%s#%s' % (url, comment_id))
from django.shortcuts import render
from django.urls import reverse
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
from patchwork.models import Patch
from patchwork.models import Project
from patchwork.views.utils import cover_to_mbox
# redirect to patches where necessary
try:
- cover = get_object_or_404(CoverLetter, project_id=project.id,
+ cover = get_object_or_404(Cover, project_id=project.id,
msgid=db_msgid)
except Http404 as exc:
patches = Patch.objects.filter(
comments = cover.comments.all()
comments = comments.select_related('submitter')
comments = comments.only('submitter', 'date', 'id', 'content',
- 'submission')
+ 'cover')
context['comments'] = comments
return render(request, 'patchwork/submission.html', context)
def cover_mbox(request, project_id, msgid):
db_msgid = ('<%s>' % msgid)
project = get_object_or_404(Project, linkname=project_id)
- cover = get_object_or_404(CoverLetter, project_id=project.id,
+ cover = get_object_or_404(Cover, project_id=project.id,
msgid=db_msgid)
response = HttpResponse(content_type='text/plain')
def cover_by_id(request, cover_id):
- cover = get_object_or_404(CoverLetter, id=cover_id)
+ cover = get_object_or_404(Cover, id=cover_id)
url = reverse('cover-detail', kwargs={'project_id': cover.project.linkname,
'msgid': cover.url_msgid})
def cover_mbox_by_id(request, cover_id):
- cover = get_object_or_404(CoverLetter, id=cover_id)
+ cover = get_object_or_404(Cover, id=cover_id)
url = reverse('cover-mbox', kwargs={'project_id': cover.project.linkname,
'msgid': cover.url_msgid})
from patchwork.forms import CreateBundleForm
from patchwork.forms import PatchForm
from patchwork.models import Bundle
-from patchwork.models import CoverLetter
+from patchwork.models import Cover
from patchwork.models import Patch
from patchwork.models import Project
from patchwork.views import generic_list
try:
patch = Patch.objects.get(project_id=project.id, msgid=db_msgid)
except Patch.DoesNotExist:
- covers = CoverLetter.objects.filter(
+ covers = Cover.objects.filter(
project_id=project.id,
msgid=db_msgid,
)
comments = patch.comments.all()
comments = comments.select_related('submitter')
- comments = comments.only('submitter', 'date', 'id', 'content',
- 'submission')
+ comments = comments.only('submitter', 'date', 'id', 'content', 'patch')
if patch.related:
related_same_project = patch.related.patches.only(
from django.conf import settings
from django.http import Http404
-from patchwork.models import Comment
+from patchwork.models import CoverComment
from patchwork.models import Patch
+from patchwork.models import PatchComment
from patchwork.parser import split_from_header
if settings.ENABLE_REST_API:
def _submission_to_mbox(submission):
- """Get an mbox representation of a single Submission.
+ """Get an mbox representation of a single submission.
- Handles both Patch and CoverLetter objects.
+ Handles both Patch and Cover objects.
Arguments:
- submission: The Patch object to convert.
+ submission: The Patch or Cover object to convert.
Returns:
A string for the mbox file.
postscript = ''
# TODO(stephenfin): Make this use the tags infrastructure
- for comment in Comment.objects.filter(submission=submission):
- body += comment.patch_responses
+ if is_patch:
+ for comment in PatchComment.objects.filter(patch=submission):
+ body += comment.patch_responses
+ else:
+ for comment in CoverComment.objects.filter(cover=submission):
+ body += comment.patch_responses
if postscript:
body += '---\n' + postscript + '\n'
projects / thirdparty / patchwork.git / commitdiff
