Fix material_types search for finds - add tests for hierarchical searches

5 files changed, 332 insertions, 39 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index fe4bb7674..c56964670 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -140,6 +140,30 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         models.RecordRelations.objects.create(
             left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type)
 
+    def testExternalID(self):
+        cr = self.context_records[0]
+        self.assertEqual(
+            cr.external_id,
+            u"{}-{}".format(cr.parcel.external_id, cr.label))
+
+
+class ContextRecordSearchTest(ContextRecordInit, TestCase):
+    fixtures = ImportContextRecordTest.fixtures
+
+    def setUp(self):
+        IshtarSiteProfile.objects.create()
+        self.username, self.password, self.user = create_superuser()
+        self.create_context_record(data={"label": u"CR 1"})
+        self.create_context_record(data={"label": u"CR 2"})
+
+        cr_1 = self.context_records[0]
+        cr_2 = self.context_records[1]
+        sym_rel_type = models.RelationType.objects.filter(
+            symmetrical=True).all()[0]
+        self.cr_rel_type = sym_rel_type
+        models.RecordRelations.objects.create(
+            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type)
+
     def testSearchExport(self):
         c = Client()
         response = c.get(reverse('get-contextrecord'))
@@ -187,11 +211,76 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         lines = [line for line in response.content.split('\n') if line]
         self.assertEqual(len(lines), 3)
 
-    def testZExternalID(self):
+    def testUnitHierarchicSearch(self):
         cr = self.context_records[0]
-        self.assertEqual(
-            cr.external_id,
-            u"{}-{}".format(cr.parcel.external_id, cr.label))
+        c = Client()
+
+        neg = models.Unit.objects.get(txt_idx='negative')
+        dig = models.Unit.objects.get(txt_idx='digging')
+        dest = models.Unit.objects.get(txt_idx='partial_destruction')
+        cr.unit = (dig)
+        cr.save()
+        search = {'unit': dig.pk}
+
+        # no result when no authentication
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(not json.loads(response.content))
+
+        # one result for exact search
+        c.login(username=self.username, password=self.password)
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
+        # no result for the brother
+        search = {'unit': dest.pk}
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 0)
+
+        # one result for the father
+        search = {'unit': neg.pk}
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
+    def testPeriodHierarchicSearch(self):
+        cr = self.context_records[0]
+        c = Client()
+
+        neo = models.Period.objects.get(txt_idx='neolithic')
+        final_neo = models.Period.objects.get(txt_idx='final_neolithic')
+        recent_neo = models.Period.objects.get(txt_idx='recent_neolithic')
+        dating = models.Dating.objects.create(
+            period=final_neo
+        )
+        cr.datings.add(dating)
+
+        search = {'datings__period': final_neo.pk}
+
+        # no result when no authentication
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(not json.loads(response.content))
+
+        # one result for exact search
+        c.login(username=self.username, password=self.password)
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
+        # no result for the brother
+        search = {'datings__period': recent_neo.pk}
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 0)
+
+        # one result for the father
+        search = {'datings__period': neo.pk}
+        response = c.get(reverse('get-contextrecord'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
 
 
 class RecordRelationsTest(ContextRecordInit, TestCase):
diff --git a/archaeological_finds/models_finds.py b/archaeological_finds/models_finds.py
index 588edb5cf..651559426 100644
--- a/archaeological_finds/models_finds.py
+++ b/archaeological_finds/models_finds.py
@@ -382,6 +382,7 @@ class Find(BaseHistorizedItem, ImageModel, OwnPerms, ShortMenuItem):
         'base_finds__context_record__operation__code_patriarche':
             'base_finds__context_record__operation__code_patriarche',
         'datings__period': 'datings__period__pk',
+        'material_types': 'material_types__pk',
         'base_finds__find__description':
             'base_finds__find__description__icontains',
         'base_finds__batch': 'base_finds__batch',
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 2d1367c58..34f95cf7d 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -17,7 +17,7 @@
 
 # See the file COPYING for details.
 
-import datetime
+import json
 
 from django.conf import settings
 from django.contrib.auth.models import User
@@ -29,7 +29,7 @@ from ishtar_common.models import ImporterType, IshtarUser, ImporterColumn,\
     FormaterType, ImportTarget
 
 from ishtar_common.models import Person
-from archaeological_context_records.models import Period
+from archaeological_context_records.models import Period, Dating
 from archaeological_finds import models, views
 from archaeological_warehouse.models import Warehouse, WarehouseType
 
@@ -325,6 +325,140 @@ class FindTest(FindInit, TestCase):
                       response.content)
 
 
+class FindSearchTest(FindInit, TestCase):
+    fixtures = [settings.ROOT_PATH +
+                '../fixtures/initial_data.json',
+                settings.ROOT_PATH +
+                '../ishtar_common/fixtures/initial_data.json',
+                settings.ROOT_PATH +
+                '../archaeological_files/fixtures/initial_data.json',
+                settings.ROOT_PATH +
+                '../archaeological_operations/fixtures/initial_data-fr.json',
+                settings.ROOT_PATH +
+                '../archaeological_finds/fixtures/initial_data-fr.json',
+                ]
+    model = models.Find
+
+    def setUp(self):
+        self.create_finds(force=True)
+        self.username = 'myuser'
+        self.password = 'mypassword'
+        User.objects.create_superuser(self.username, 'myemail@test.com',
+                                      self.password)
+        self.client = Client()
+
+    def testMaterialTypeHierarchicSearch(self):
+        find = self.finds[0]
+        c = Client()
+        metal = models.MaterialType.objects.get(txt_idx='metal')
+        iron_metal = models.MaterialType.objects.get(txt_idx='iron_metal')
+        not_iron_metal = models.MaterialType.objects.get(
+            txt_idx='not_iron_metal')
+        find.material_types.add(iron_metal)
+
+        search = {'material_types': iron_metal.pk}
+
+        # no result when no authentication
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(not json.loads(response.content))
+        c.login(username=self.username, password=self.password)
+
+        # one result for exact search
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(json.loads(response.content)['total'] == 1)
+
+        # no result for the brother
+        search = {'material_types': not_iron_metal.pk}
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(json.loads(response.content)['total'] == 0)
+
+        # one result for the father
+        search = {'material_types': metal.pk}
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(json.loads(response.content)['total'] == 1)
+
+    def testPeriodHierarchicSearch(self):
+        find = self.finds[0]
+        c = Client()
+
+        neo = Period.objects.get(txt_idx='neolithic')
+        final_neo = Period.objects.get(txt_idx='final_neolithic')
+        recent_neo = Period.objects.get(txt_idx='recent_neolithic')
+        dating = Dating.objects.create(
+            period=final_neo
+        )
+        find.datings.add(dating)
+
+        search = {'datings__period': final_neo.pk}
+
+        # no result when no authentication
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(not json.loads(response.content))
+
+        # one result for exact search
+        c.login(username=self.username, password=self.password)
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
+        # no result for the brother
+        search = {'datings__period': recent_neo.pk}
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 0)
+
+        # one result for the father
+        search = {'datings__period': neo.pk}
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
+    def testConservatoryStateHierarchicSearch(self):
+        find = self.finds[0]
+        c = Client()
+        cs1 = models.ConservatoryState.objects.all()[0]
+        cs1.parent = None
+        cs1.save()
+        cs2 = models.ConservatoryState.objects.all()[1]
+        cs2.parent = cs1
+        cs2.save()
+        cs3 = models.ConservatoryState.objects.all()[2]
+        cs3.parent = cs1
+        cs3.save()
+        find.conservatory_state = cs2
+        find.save()
+
+        search = {'conservatory_state': cs2.pk}
+
+        # no result when no authentication
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(not json.loads(response.content))
+        c.login(username=self.username, password=self.password)
+
+        # one result for exact search
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(json.loads(response.content)['total'] == 1)
+
+        # no result for the brother
+        search = {'conservatory_state': cs3.pk}
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(json.loads(response.content)['total'] == 0)
+
+        # one result for the father
+        search = {'conservatory_state': cs1.pk}
+        response = c.get(reverse('get-find'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(json.loads(response.content)['total'] == 1)
+
+
 class PackagingTest(FindInit, TestCase):
     fixtures = [settings.ROOT_PATH +
                 '../fixtures/initial_data.json',
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index 9a61d8bbb..ba7722d84 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -566,7 +566,73 @@ class OperationTest(TestCase, OperationInitTest):
         parcel.save()
         self.assertEqual(parcel.external_id, 'blabla')
 
-    def testSearch(self):
+    def create_relations(self):
+        rel1 = models.RelationType.objects.create(
+            symmetrical=True, label='Include', txt_idx='include')
+        rel2 = models.RelationType.objects.create(
+            symmetrical=False, label='Included', txt_idx='included',
+            inverse_relation=rel1)
+        models.RecordRelations.objects.create(
+            left_record=self.operations[0],
+            right_record=self.operations[1],
+            relation_type=rel1)
+        return rel1, rel2
+
+    def testPostDeleteRelations(self):
+        self.create_relations()
+        self.operations[0].delete()
+
+    def testPostDeleteParcels(self):
+        ope = self.operations[0]
+        town = Town.objects.create(name='plouf', numero_insee='20000')
+        parcel = models.Parcel.objects.create(town=town)
+        parcel_nb = models.Parcel.objects.count()
+        ope.parcels.add(parcel)
+        ope.delete()
+        # our parcel has no operation attached and should be deleted
+        self.assertEqual(parcel_nb - 1, models.Parcel.objects.count())
+        ope = self.operations[1]
+        parcel = models.Parcel.objects.create(town=town)
+        parcel_nb = models.Parcel.objects.count()
+        ope.parcels.add(parcel)
+        ope.parcels.clear()  # no signal raised... should resave
+        models.Parcel.objects.filter(pk=parcel.pk).all()[0].save()
+        # our parcel has no operation attached and should be deleted
+        self.assertEqual(parcel_nb - 1, models.Parcel.objects.count())
+
+    def testIndex(self):
+        ope = create_operation(self.user, values={'year': 2042})
+        self.assertEqual(ope.operation_code, 1)
+        ope2 = create_operation(self.user, values={'year': 2042})
+        self.assertEqual(ope2.operation_code, 2)
+        ope = create_operation(self.user, values={'year': 0})
+        self.assertEqual(ope.operation_code, 1)
+        ope2 = create_operation(self.user, values={'year': 0})
+        self.assertEqual(ope2.operation_code, 2)
+
+
+class OperationSearchTest(TestCase, OperationInitTest):
+    fixtures = [settings.ROOT_PATH +
+                '../fixtures/initial_data-auth-fr.json',
+                settings.ROOT_PATH +
+                '../ishtar_common/fixtures/initial_data-fr.json',
+                settings.ROOT_PATH +
+                '../archaeological_files/fixtures/initial_data.json',
+                settings.ROOT_PATH +
+                '../archaeological_operations/fixtures/initial_data-fr.json']
+
+    def setUp(self):
+        IshtarSiteProfile.objects.create()
+        self.username, self.password, self.user = create_superuser()
+        self.alt_username, self.alt_password, self.alt_user = create_user()
+        self.alt_user.user_permissions.add(Permission.objects.get(
+            codename='view_own_operation'))
+        self.orgas = self.create_orgas(self.user)
+        self.operations = self.create_operation(self.user, self.orgas[0])
+        self.operations += self.create_operation(self.alt_user, self.orgas[0])
+        self.item = self.operations[0]
+
+    def testBaseSearch(self):
         c = Client()
         response = c.get(reverse('get-operation'), {'year': '2010'})
         # no result when no authentification
@@ -603,27 +669,40 @@ class OperationTest(TestCase, OperationInitTest):
         response = c.get(reverse('get-operation'), search)
         self.assertTrue(json.loads(response.content)['total'] == 2)
 
-    def testPostDeleteRelations(self):
-        self.create_relations()
-        self.operations[0].delete()
-
-    def testPostDeleteParcels(self):
-        ope = self.operations[0]
-        town = Town.objects.create(name='plouf', numero_insee='20000')
-        parcel = models.Parcel.objects.create(town=town)
-        parcel_nb = models.Parcel.objects.count()
-        ope.parcels.add(parcel)
-        ope.delete()
-        # our parcel has no operation attached and should be deleted
-        self.assertEqual(parcel_nb - 1, models.Parcel.objects.count())
+    def testHierarchicSearch(self):
         ope = self.operations[1]
-        parcel = models.Parcel.objects.create(town=town)
-        parcel_nb = models.Parcel.objects.count()
-        ope.parcels.add(parcel)
-        ope.parcels.clear()  # no signal raised... should resave
-        models.Parcel.objects.filter(pk=parcel.pk).all()[0].save()
-        # our parcel has no operation attached and should be deleted
-        self.assertEqual(parcel_nb - 1, models.Parcel.objects.count())
+        c = Client()
+
+        neo = models.Period.objects.get(txt_idx='neolithic')
+        final_neo = models.Period.objects.get(txt_idx='final_neolithic')
+        recent_neo = models.Period.objects.get(txt_idx='recent_neolithic')
+        ope.periods.add(final_neo)
+
+        search = {'periods': final_neo.pk}
+
+        # no result when no authentication
+        response = c.get(reverse('get-operation'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(not json.loads(response.content))
+        c.login(username=self.username, password=self.password)
+
+        # one result for exact search
+        response = c.get(reverse('get-operation'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
+        # no result for the brother
+        search = {'periods': recent_neo.pk}
+        response = c.get(reverse('get-operation'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 0)
+
+        # one result for the father
+        search = {'periods': neo.pk}
+        response = c.get(reverse('get-operation'), search)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['total'], 1)
+
 
     def testOwnSearch(self):
         c = Client()
@@ -638,16 +717,6 @@ class OperationTest(TestCase, OperationInitTest):
                          {'operator': self.orgas[0].pk})
         self.assertTrue(json.loads(response.content)['total'] == 1)
 
-    def testIndex(self):
-        ope = create_operation(self.user, values={'year': 2042})
-        self.assertEqual(ope.operation_code, 1)
-        ope2 = create_operation(self.user, values={'year': 2042})
-        self.assertEqual(ope2.operation_code, 2)
-        ope = create_operation(self.user, values={'year': 0})
-        self.assertEqual(ope.operation_code, 1)
-        ope2 = create_operation(self.user, values={'year': 0})
-        self.assertEqual(ope2.operation_code, 2)
-
 
 def create_administrativact(user, operation):
     act_type, created = models.ActType.objects.get_or_create(
diff --git a/ishtar_common/views.py b/ishtar_common/views.py
index dbbc3d538..b7ef5ea47 100644
--- a/ishtar_common/views.py
+++ b/ishtar_common/views.py
@@ -759,7 +759,7 @@ def get_item(model, func_name, default_name, extra_request_keys=[],
                         if not idx:
                             q = Q(**{r: val})
                         else:
-                            q = q | Q(**{r: val})
+                            q |= Q(**{r: val})
                     and_reqs.append(q)
                     break
                 elif req.endswith(k_hr + '__pk'):
@@ -769,7 +769,7 @@ def get_item(model, func_name, default_name, extra_request_keys=[],
                     for idx in xrange(HIERARCHIC_LEVELS):
                         req = req[:-2] + 'parent__pk'
                         q = Q(**{req: val})
-                        reqs = reqs | q
+                        reqs |= q
                     and_reqs.append(reqs)
                     break
         query = Q(**dct)