redid tags to use through model, cleaned up note and notebook detail

views

7 files changed, 134 insertions, 65 deletions

diff --git a/apps/notes/forms.py b/apps/notes/forms.py
index c1df176..5ef9f84 100644
--- a/apps/notes/forms.py
+++ b/apps/notes/forms.py
@@ -20,7 +20,7 @@ class NoteForm(forms.ModelForm):
 class NotebookForm(NoteForm):
     class Meta:
         model = Notebook
-        fields = ['name']
+        fields = ['name', 'color_rgb']
         labels = {
             "name": _("Notebook Name"),
         }
diff --git a/apps/notes/models.py b/apps/notes/models.py
index c0b23ce..95c1c96 100644
--- a/apps/notes/models.py
+++ b/apps/notes/models.py
@@ -12,18 +12,36 @@ from django.conf import settings
 
 from utils.util import unique_slug_generator
 
+from django.utils.translation import ugettext_lazy as _
+
+from taggit.managers import TaggableManager
+from taggit.models import TagBase, GenericTaggedItemBase
+
+
+class LuxTag(TagBase):
+    color_rgb = models.CharField(max_length=20, null=True, blank=True)
+
+    class Meta:
+        verbose_name = _("Tag")
+        verbose_name_plural = _("Tags")
+
+
+class TaggedNotes(GenericTaggedItemBase):
+    tag = models.ForeignKey(LuxTag, related_name="%(app_label)s_%(class)s_items", on_delete=models.CASCADE)
+
 
 class Notebook(models.Model):
+    """ Notebook model for Notes """
     unique_id = models.UUIDField(default=uuid.uuid4, editable=False)
     owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
     name = models.CharField(max_length=250)
-    url = models.CharField(max_length=250, null=True, blank=True)
+    color_rgb = models.CharField(max_length=20, null=True, blank=True)
     slug = models.SlugField(blank=True)
     date_created = models.DateTimeField(blank=True, auto_now_add=True, editable=False)
     date_updated = models.DateTimeField(blank=True, auto_now=True, editable=False)
 
     class Meta:
-        unique_together = ("owner", "slug")
+        unique_together = ("owner", "name")
 
     def __str__(self):
         return self.name
@@ -35,7 +53,7 @@ class Notebook(models.Model):
 
     @cached_property
     def get_absolute_url(self):
-        return reverse("notes:notebook-detail", kwargs={"user": self.owner.username, "slug": self.slug})
+        return reverse("notebooks:detail", kwargs={"slug": self.slug})
 
 
 class Note(models.Model):
@@ -50,18 +68,19 @@ class Note(models.Model):
     url = models.CharField(max_length=250, null=True, blank=True)
     slug = models.SlugField(blank=True)
     notebook = models.ForeignKey(Notebook, null=True, blank=True, on_delete=models.SET_NULL)
-    tags = TaggableManager(blank=True, help_text='Tags')
+    tags = TaggableManager(through=TaggedNotes, blank=True, help_text='Tags')
     is_public = models.BooleanField(default=False)
 
     class Meta:
         unique_together = ("owner", "slug")
+        ordering = ("-date_created", "-date_updated")
 
     def __str__(self):
         return self.title
 
     @cached_property
     def get_absolute_url(self):
-        return reverse("notes:note-detail", kwargs={"user": self.owner.username, "slug": self.slug})
+        return reverse("notes:detail", kwargs={"slug": self.slug, 'pk': self.pk})
 
     def save(self, **kwargs):
         if not self.title:
diff --git a/apps/notes/serializers.py b/apps/notes/serializers.py
index daef52e..f811edd 100644
--- a/apps/notes/serializers.py
+++ b/apps/notes/serializers.py
@@ -1,11 +1,29 @@
 from rest_framework import serializers
 from taggit_serializer.serializers import TagListSerializerField, TaggitSerializer
 
-from .models import Note, Notebook
+from .models import Note, Notebook, LuxTag
+
+import six
+
+
+class NewTagListSerializerField(TagListSerializerField):
+    def to_internal_value(self, value):
+        if isinstance(value, six.string_types):
+            value = [v.strip() for v in value.split(',')]
+
+        if not isinstance(value, list):
+            self.fail('not_a_list', input_type=type(value).__name__)
+
+        for s in value:
+            if not isinstance(s, six.string_types):
+                self.fail('not_a_str')
+
+            self.child.run_validation(s)
+        return value
 
 
 class NoteSerializer(TaggitSerializer, serializers.ModelSerializer):
-    tags = TagListSerializerField()
+    tags = NewTagListSerializerField(required=False)
 
     class Meta:
         model = Note
@@ -14,7 +32,17 @@ class NoteSerializer(TaggitSerializer, serializers.ModelSerializer):
 
 class NotebookSerializer(serializers.HyperlinkedModelSerializer):
     json_absolute_url = serializers.URLField(source='get_absolute_url', read_only=True)
+    owner = serializers.HiddenField(
+        default=serializers.CurrentUserDefault()
+    )
 
     class Meta:
         model = Notebook
-        fields = ('name', 'json_absolute_url')
+        fields = ('name', 'color_rgb', 'json_absolute_url', 'owner')
+
+
+class NoteTagSerializer(serializers.HyperlinkedModelSerializer):
+
+    class Meta:
+        model = LuxTag
+        fields = ('name', 'color_hex')
diff --git a/apps/notes/tests/test_models.py b/apps/notes/tests/test_models.py
index cf21aca..05f2618 100644
--- a/apps/notes/tests/test_models.py
+++ b/apps/notes/tests/test_models.py
@@ -1,16 +1,26 @@
 from django.test import TestCase
+from django.urls import reverse
+from django.contrib import auth
 from mixer.backend.django import mixer
 
-from notes.models import Note, Notebook
-from accounts.models import User
+from notes.models import Note, Notebook 
+
+User = auth.get_user_model()
 
 
 class NotebookModelTest(TestCase):
+    def setUp(self):
+        self.user = mixer.blend(User, username='tpynchon')
+        self.notebook = Notebook(owner=self.user, name="San Miguel Notes")
+        self.notebook.save()
 
     def test_string_representation(self):
-        user = mixer.blend(User, username='tpynchon')
-        notebook = Notebook(owner=user, name="San Miguel Notes")
-        self.assertEqual(str(notebook), "San Miguel Notes")
+        """Notebook title should be the name of the object"""
+        self.assertEqual(str(self.notebook), "San Miguel Notes")
+
+    def test_get_absolute_url(self):
+        """Absolute URL should return /nb/slug """
+        self.assertEqual(str(self.notebook.get_absolute_url), reverse("notebooks:detail", kwargs={'slug': self.notebook.slug}))
 
 
 class NoteModelTest(TestCase):
@@ -41,4 +51,5 @@ class NoteModelTest(TestCase):
         self.assertEqual(str(self.note_no_title), str(self.note_no_title.body_text)[:50])
 
     def test_get_absolute_url(self):
-        self.assertEqual(str(self.note.get_absolute_url), "/notes/%s/%s" % (self.note.owner.username, self.note.slug))
+        """Absolute URL should return /n/slug/pk """
+        self.assertEqual(str(self.note.get_absolute_url), "/n/%s/%s" % (self.note.slug, self.note.pk))
diff --git a/apps/notes/tests/test_views.py b/apps/notes/tests/test_views.py
index 4f9a4ce..be48226 100644
--- a/apps/notes/tests/test_views.py
+++ b/apps/notes/tests/test_views.py
@@ -1,6 +1,6 @@
 import json
 from django.test import Client
-from django.test import RequestFactory, TestCase
+from django.test import RequestFactory, TestCase, TransactionTestCase
 from django.urls import reverse
 from django.template.defaultfilters import slugify
 
@@ -14,6 +14,37 @@ from notes.models import Note
 from notes.views import NoteListView, NoteViewSet
 
 
+class NoteCreateViewTests(TransactionTestCase):
+    """
+    Because I need pks to get URL of object I need
+    a clean database so I know the one and only object
+    has a pk of 1. There's probably a better way to do
+    this though.
+    Especially because this is a private API and subject
+    to change/deletion:
+    https://docs.djangoproject.com/en/2.1/topics/testing/advanced/#django.test.TransactionTestCase.reset_sequences
+    """
+    reset_sequences = True
+
+    def setUp(self):
+        self.client = Client()
+        self.user = User.objects.create(username='testuser', password='password')
+
+    def test_note_create_view(self):
+        data = {
+                'pk': 2,
+                'title': "test note post",
+                'body_text': "the body of the note",
+                'url': "https://luxagraf.net/",
+                'tags': [],
+            }
+        self.client.force_login(self.user)
+        url = reverse("notes:create")
+        response = self.client.post(url, data)
+        self.assertEqual(response.status_code, 302)
+        self.assertRedirects(response, '/n/%s/%s' % (slugify(data['title']), Note.objects.count()))
+
+
 class NotesViewsTest(TestCase):
     def setUp(self):
         # Every test needs access to the request factory.
@@ -35,25 +66,12 @@ class NotesViewsTest(TestCase):
         self.note.save()
 
     def test_list_view(self):
-        request = self.factory.get('/notes/')
+        request = self.factory.get('/n/')
         request.user = self.user
         response = NoteListView.as_view()(request)
         self.assertEqual(response.status_code, 200)
         # bad_user
 
-    def test_note_create_view(self):
-        data = {
-                'title': "test note post",
-                'body_text': "the body of the note",
-                'url': "https://luxagraf.net/",
-                'tags': [],
-            }
-        self.client.force_login(self.user)
-        url = reverse("notes:note-create")
-        response = self.client.post(url, data)
-        self.assertEqual(response.status_code, 302)
-        self.assertRedirects(response, '/notes/%s/%s' % (self.user.username, slugify(data['title'])))
-
     def test_api_list(self):
         # Make an authenticated request to the view...
         request = self.factory.get('/api/notes/')
diff --git a/apps/notes/urls.py b/apps/notes/urls.py
deleted file mode 100644
index a79c7cd..0000000
--- a/apps/notes/urls.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from django.urls import path
-
-from .views import (
-    NoteDetailView,
-    NoteCreateView,
-    NoteListView,
-    NoteListRedirectView,
-    NotebookListView,
-    NotebookDetailView,
-    NoteTagView,
-)
-
-app_name = "notes"
-
-urlpatterns = [
-    path(r'create/', NoteCreateView.as_view(), name='note-create',),
-    path(r'<str:user>/tagged/<slug>', NoteTagView.as_view(), name='note-tag',),
-    path(r'<str:user>/notebooks/<slug>', NotebookDetailView.as_view(), name='notebook-detail',),
-    path(r'<str:user>/notebooks/', NotebookListView.as_view(), name='notebook-list',),
-    path(r'<str:user>/<slug>', NoteDetailView.as_view(), name='note-detail',),
-    path(r'<str:user>/', NoteListView.as_view(), name='note-list',),
-    path(r'', NoteListRedirectView.as_view(), name='note-redirect',),
-]
diff --git a/apps/notes/views.py b/apps/notes/views.py
index d885ad9..5d55720 100644
--- a/apps/notes/views.py
+++ b/apps/notes/views.py
@@ -11,8 +11,8 @@ from rest_framework.response import Response
 from rest_framework.decorators import list_route
 from rest_framework import permissions
 
-from .serializers import NoteSerializer, NotebookSerializer
-from .models import Note, Notebook
+from .serializers import NoteSerializer, NotebookSerializer, NoteTagSerializer
+from .models import Note, Notebook, LuxTag
 from .forms import NoteForm, NotebookForm
 
 
@@ -43,7 +43,7 @@ class NoteListView(LoggedInViewWithUser, ListView):
 class NoteTagView(LoggedInViewWithUser, ListView):
     model = Note
     template_name = 'notes/notes_list.html'
-
+ 
     def get_queryset(self):
         '''
         This can generate a crazy amount of joins if there's a lot of tags
@@ -69,12 +69,6 @@ class NoteTagView(LoggedInViewWithUser, ListView):
         return context
 
 
-class NoteListRedirectView(RedirectView, LoggedInViewWithUser):
-
-    def get_redirect_url(self, *args, **kwargs):
-        return reverse_lazy("notes:note-list", kwargs={"user": self.request.user.username})
-
-
 class NoteDetailView(UpdateView, LoggedInViewWithUser):
     model = Note
     form_class = NoteForm
@@ -101,7 +95,12 @@ class NoteCreateView(CreateView, LoggedInViewWithUser):
         return super(NoteCreateView, self).form_valid(form)
 
     def get_success_url(self):
-        return reverse_lazy('notes:note-detail', kwargs={'user': self.request.user.username, 'slug': self.object.slug})
+        return reverse_lazy('notes:detail', kwargs={'slug': self.object.slug, 'pk': self.object.pk})
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context['notes_list'] = Note.objects.filter(owner=self.request.user).select_related()
+        return context
 
 
 class NotebookListView(CreateView, LoggedInViewWithUser):
@@ -124,11 +123,14 @@ class NotebookDetailView(DetailView, LoggedInViewWithUser):
     model = Notebook
 
     def get_object(self):
-        return get_object_or_404(self.get_queryset().select_related(), owner=self.request.user, slug=self.kwargs["slug"])
+        notebook = get_object_or_404(self.get_queryset().select_related(), owner=self.request.user, slug=self.kwargs["slug"])
+        self.form = NotebookForm(instance=notebook)
+        return notebook
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         context['notes_list'] = Note.objects.filter(owner=self.request.user).select_related()
+        context['form'] = self.form
         return context
 
 
@@ -153,7 +155,7 @@ class NoteViewSet(viewsets.ModelViewSet):
         return Note.objects.filter(owner=self.request.user).order_by('-date_created')
 
     def perform_create(self, serializer):
-        serializer.save(owner=self.request.user)
+        serializer.save(owner=self.request.user, tags__owner=self.request.user)
 
     def get_object(self):
         obj = get_object_or_404(self.get_queryset(), pk=self.kwargs["pk"])
@@ -178,3 +180,17 @@ class NotebookViewSet(viewsets.ModelViewSet):
 
     def get_menu_data(self, serializer):
         return Notebook.objects.filter(owner=self.request.user).order_by('-name')[:1]
+
+
+class TagViewSet(viewsets.ModelViewSet):
+    """
+    API endpoint that allows notes to be viewed or edited.
+    """
+    serializer_class = NoteTagSerializer
+    permission_classes = (permissions.IsAuthenticated,)
+
+    def get_queryset(self):
+        return LuxTag.objects.filter(owner=self.request.user)
+
+    def perform_create(self, serializer):
+        serializer.save(owner=self.request.user)