Made tag name field unique. Added index to "required" field for tag

boards/migrations/0010_auto_20150208_1451.py

@@ -0,0 +1,44 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    def clean_duplicate_tags(apps, schema_editor):
+        Tag = apps.get_model('boards', 'Tag')
+        for tag in Tag.objects.all():
+            tags_with_same_name = Tag.objects.filter(name=tag.name).all()
+            if len(tags_with_same_name) > 1:
+                for tag_duplicate in tags_with_same_name[1:]:
+                    threads = tag_duplicate.thread_set.all()
+                    for thread in threads:
+                        thread.tags.add(tag)
+                    tag_duplicate.delete()
+
+    dependencies = [
+        ('boards', '0009_post_thread'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='post',
+            name='thread',
+            field=models.ForeignKey(to='boards.Thread', related_name='pt+'),
+            preserve_default=True,
+        ),
+        migrations.RunPython(clean_duplicate_tags),
+        migrations.AlterField(
+            model_name='tag',
+            name='name',
+            field=models.CharField(db_index=True, unique=True, max_length=100),
+            preserve_default=True,
+        ),
+        migrations.AlterField(
+            model_name='tag',
+            name='required',
+            field=models.BooleanField(db_index=True, default=False),
+            preserve_default=True,
+        ),
+    ]

boards/models/tag.py

@@ -1,76 +1,76 b''
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count
 from django.core.urlresolvers import reverse
 
 from boards.models.base import Viewable
 from boards.utils import cached_result
 
 
 __author__ = 'neko259'
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         return self.filter(thread__archived=False)\
             .annotate(num_threads=Count('thread')).filter(num_threads__gt=0)\
             .order_by('-required', 'name')
 
 
 class Tag(models.Model, Viewable):
     """
     A tag is a text node assigned to the thread. The tag serves as a board
     section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
-    name = models.CharField(max_length=100, db_index=True)
-    required = models.BooleanField(default=False)
+    name = models.CharField(max_length=100, db_index=True, unique=True)
+    required = models.BooleanField(default=False, db_index=True)
 
     def __str__(self):
         return self.name
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
     def get_thread_count(self) -> int:
         return self.get_threads().count()
 
     def get_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
     def get_threads(self):
         return self.thread_set.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def get_view(self):
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_url(), self.name)
         if self.is_required():
             link = '<b>{}</b>'.format(link)
         return link
 
     def get_search_view(self, *args, **kwargs):
         return render_to_string('boards/tag.html', {
             'tag': self,
         })
 
     @cached_result
     def get_post_count(self):
         return self.get_threads().aggregate(num_posts=Count('post'))['num_posts']