Fix shortcut menu for baskets - add tests for shortcut menu

3 files changed, 295 insertions, 20 deletions

diff --git a/archaeological_operations/models.py b/archaeological_operations/models.py
index 30cd61010..7c9efaef7 100644
--- a/archaeological_operations/models.py
+++ b/archaeological_operations/models.py
@@ -551,9 +551,9 @@ class Operation(ClosedItem, BaseHistorizedItem, ImageModel, OwnPerms,
 
     @classmethod
     def get_query_owns(cls, user):
-        return Q(in_charge=user.ishtaruser.person) |\
+        return (Q(in_charge=user.ishtaruser.person) |\
             Q(scientist=user.ishtaruser.person) |\
-            Q(history_creator=user) & Q(end_date__isnull=True)
+            Q(history_creator=user)) & Q(end_date__isnull=True)
 
     def is_active(self):
         return not bool(self.end_date)
diff --git a/ishtar_common/models.py b/ishtar_common/models.py
index f87c1b8de..572bd85e7 100644
--- a/ishtar_common/models.py
+++ b/ishtar_common/models.py
@@ -242,13 +242,27 @@ class OwnPerms:
     @classmethod
     def _return_get_owns(cls, owns, values, get_short_menu_class,
                          label_key='cached_label'):
+        sorted_values = []
+        if hasattr(cls, 'BASKET_MODEL'):
+            owns_len = len(owns)
+            for idx, item in enumerate(reversed(owns)):
+                if get_short_menu_class:
+                    item = item[0]
+                if type(item) == cls.BASKET_MODEL:
+                    basket = owns.pop(owns_len - idx - 1)
+                    sorted_values.append(basket)
+            sorted_values = list(reversed(sorted_values))
         if not values:
             if not get_short_menu_class:
-                return sorted(owns, key=lambda x: getattr(x, label_key))
-            return sorted(owns, key=lambda x: getattr(x[0], label_key))
+                return sorted_values + list(
+                    sorted(owns, key=lambda x: getattr(x, label_key)))
+            return sorted_values + list(
+                sorted(owns, key=lambda x: getattr(x[0], label_key)))
         if not get_short_menu_class:
-            return sorted(owns, key=lambda x: x[label_key])
-        return sorted(owns, key=lambda x: x[0][label_key])
+            return sorted_values + list(
+                sorted(owns, key=lambda x: x[label_key]))
+        return sorted_values + list(
+            sorted(owns, key=lambda x: x[0][label_key]))
 
     @classmethod
     def get_owns(cls, user, replace_query={}, limit=None, values=None,
@@ -288,7 +302,16 @@ class OwnPerms:
                     raise NotImplementedError(
                         "Call of get_owns with get_short_menu_class option and"
                         " no 'id' in values is not implemented")
-                items = [(i, cls.get_short_menu_class(i['id'])) for i in items]
+                my_items = []
+                for i in items:
+                    if hasattr(cls, 'BASKET_MODEL') and \
+                            type(i) == cls.BASKET_MODEL:
+                        dct = dict([(k, getattr(i, k)) for k in values])
+                        my_items.append(
+                            (dct, cls.BASKET_MODEL.get_short_menu_class(i.pk)))
+                    else:
+                        my_items.append((i, cls.get_short_menu_class(i['id'])))
+                items = my_items
             else:
                 items = [(i, cls.get_short_menu_class(i.pk)) for i in items]
         return items
@@ -672,6 +695,10 @@ class Basket(models.Model):
     def __unicode__(self):
         return self.label
 
+    @property
+    def cached_label(self):
+        return unicode(self)
+
     @classmethod
     def get_short_menu_class(cls, pk):
         return 'basket'
diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 335b20ff6..d3c6eed4b 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -17,8 +17,9 @@
 
 # See the file COPYING for details.
 
-from StringIO import StringIO
 from bs4 import BeautifulSoup as Soup
+import datetime
+from StringIO import StringIO
 
 from django.conf import settings
 from django.contrib.auth.models import User
@@ -337,14 +338,26 @@ class MergeTest(TestCase):
 
 class ShortMenuTest(TestCase):
     def setUp(self):
-        from archaeological_operations.models import OperationType
         self.username = 'username666'
         self.password = 'dcbqj7xnjkxnjsknx!@%'
         self.user = User.objects.create_superuser(
             self.username, "nomail@nomail.com", self.password)
         self.other_user = User.objects.create_superuser(
             'John', "nomail@nomail.com", self.password)
-        self.ope_type = OperationType.objects.create()
+        profile = models.get_current_profile()
+        profile.files = True
+        profile.save()
+
+    def _create_ope(self, user=None):
+        if not user:
+            user = self.other_user
+        from archaeological_operations.models import Operation, OperationType
+        ope_type = OperationType.objects.create()
+        return Operation.objects.create(
+            operation_type=ope_type,
+            history_modifier=user,
+            year=2042, operation_code=54
+        )
 
     def testNotConnected(self):
         c = Client()
@@ -356,31 +369,25 @@ class ShortMenuTest(TestCase):
         # no content because the user owns no object
         response = c.get(reverse('shortcut-menu'))
         self.assertFalse("shortcut-menu" in response.content)
-        from archaeological_operations.models import Operation
-        Operation.objects.create(
-            operation_type=self.ope_type,
-            history_modifier=self.user)
+        self._create_ope(user=self.user)
         # content is here
         response = c.get(reverse('shortcut-menu'))
         self.assertTrue("shortcut-menu" in response.content)
 
     def testOperation(self):
-        from archaeological_operations.models import Operation
         c = Client()
         c.login(username=self.username, password=self.password)
-        ope = Operation.objects.create(
-            operation_type=self.ope_type,
-            history_modifier=self.other_user,
-            year=2042, operation_code=54
-        )
+        ope = self._create_ope()
         # not available at first
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertFalse(str(ope.cached_label) in response.content)
 
         # available because is the creator
         ope.history_creator = self.user
         ope.save()
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content)
 
         # available because is in charge
@@ -388,6 +395,7 @@ class ShortMenuTest(TestCase):
         ope.in_charge = self.user.ishtaruser.person
         ope.save()
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content)
 
         # available because is the scientist
@@ -396,8 +404,248 @@ class ShortMenuTest(TestCase):
         ope.scientist = self.user.ishtaruser.person
         ope.save()
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content)
 
+        # end date is reached - no more available
+        ope.end_date = datetime.date(1900, 1, 1)
+        ope.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(ope.cached_label) in response.content)
+
+    def testFile(self):
+        from archaeological_files.models import File, FileType
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        file_type = FileType.objects.create()
+        fle = File.objects.create(
+            file_type=file_type,
+            history_modifier=self.other_user,
+            year=2043,
+        )
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(fle.cached_label) in response.content)
+
+        # available because is the creator
+        fle.history_creator = self.user
+        fle.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(fle.cached_label) in response.content)
+
+        # available because is in charge
+        fle.history_creator = self.other_user
+        fle.in_charge = self.user.ishtaruser.person
+        fle.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(fle.cached_label) in response.content)
+
+        # end date is reached - no more available
+        fle.end_date = datetime.date(1900, 1, 1)
+        fle.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(fle.cached_label) in response.content)
+
+    def _create_cr(self):
+        from archaeological_context_records.models import ContextRecord
+        from archaeological_operations.models import Parcel
+        ope = self._create_ope()
+        town = models.Town.objects.create()
+        parcel = Parcel.objects.create(
+            operation=ope,
+            town=town,
+            section="AA",
+            parcel_number=42
+        )
+        return ContextRecord.objects.create(
+            parcel=parcel,
+            operation=ope,
+            history_modifier=self.other_user,
+        )
+
+    def testContextRecord(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        cr = self._create_cr()
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(cr.cached_label) in response.content)
+
+        # available because is the creator
+        cr.history_creator = self.user
+        cr.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(cr.cached_label) in response.content)
+
+        # available because is in charge
+        cr.history_creator = self.other_user
+        cr.save()
+        cr.operation.in_charge = self.user.ishtaruser.person
+        cr.operation.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(cr.cached_label) in response.content)
+
+        # available because is the scientist
+        cr.history_creator = self.other_user
+        cr.save()
+        cr.operation.in_charge = None
+        cr.operation.scientist = self.user.ishtaruser.person
+        cr.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(cr.cached_label) in response.content)
+
+    def _create_find(self):
+        from archaeological_finds.models import BaseFind, Find
+        cr = self._create_cr()
+        base_find = BaseFind.objects.create(
+            context_record=cr
+        )
+        find = Find.objects.create(
+            label="Where is my find?"
+        )
+        find.base_finds.add(base_find)
+        return base_find, find
+
+    def testFind(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        base_find, find = self._create_find()
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(find.cached_label) in response.content)
+
+        # available because is the creator
+        find.history_creator = self.user
+        find.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(find.cached_label) in response.content)
+
+        # available because is in charge
+        find.history_creator = self.other_user
+        find.save()
+        base_find.context_record.operation.in_charge = \
+            self.user.ishtaruser.person
+        base_find.context_record.operation.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(find.cached_label) in response.content)
+
+        # available because is the scientist
+        find.history_creator = self.other_user
+        find.save()
+        base_find.context_record.operation.in_charge = None
+        base_find.context_record.operation.scientist = \
+            self.user.ishtaruser.person
+        base_find.context_record.operation.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(find.cached_label) in response.content)
+
+    def testBasket(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        from archaeological_finds.models import FindBasket
+        basket = FindBasket.objects.create(
+            label="My basket",
+        )
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(basket.label) in response.content)
+
+        # available because is the owner
+        basket.user = self.user.ishtaruser
+        basket.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(basket.label) in response.content)
+
+    def testTreatmentFile(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        from archaeological_finds.models import TreatmentFile, TreatmentFileType
+        tf = TreatmentFile.objects.create(
+            type=TreatmentFileType.objects.create(),
+            year=2050
+        )
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(tf.cached_label) in response.content)
+
+        # available because is the creator
+        tf.history_creator = self.user
+        tf.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(tf.cached_label) in response.content)
+
+        # available because is in charge
+        tf.history_creator = self.other_user
+        tf.in_charge = self.user.ishtaruser.person
+        tf.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(tf.cached_label) in response.content)
+
+        # end date is reached - no more available
+        tf.end_date = datetime.date(1900, 1, 1)
+        tf.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(tf.cached_label) in response.content)
+
+    def testTreatment(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        from archaeological_finds.models import Treatment
+        treat = Treatment.objects.create(
+            label="My treatment",
+            year=2052
+        )
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(treat.cached_label) in response.content)
+
+        # available because is the creator
+        treat.history_creator = self.user
+        treat.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(treat.cached_label) in response.content)
+
+        # available because is in charge
+        treat.history_creator = self.other_user
+        treat.person = self.user.ishtaruser.person
+        treat.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(treat.cached_label) in response.content)
+
+        # end date is reached - no more available
+        treat.end_date = datetime.date(1900, 1, 1)
+        treat.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(treat.cached_label) in response.content)
+
 
 class ImportTest(TestCase):
     def testDeleteRelated(self):