Example #1
0
    def test_single_lookup(self):
        project = ProjectF.create()
        category = CategoryFactory.create(**{'project': project})
        lookup = LookupFieldFactory.create(
            **{'category': category, 'key': 'lookup'}
        )
        kermit = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Kermit'
        })
        gonzo = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Gonzo'
        })
        ObservationFactory.create_batch(3, **{
            'project': project,
            'category': category,
            'properties': {'lookup': kermit.id}
        })
        ObservationFactory.create_batch(3, **{
            'project': project,
            'category': category,
            'properties': {'lookup': gonzo.id}
        })

        result = project.observations.all().search('kermit')
        self.assertEqual(len(result), 3)

        for o in result:
            self.assertEqual(o.properties.get('lookup'), kermit.id)
Example #2
0
    def test_single_lookup(self):
        project = ProjectF.create()
        category = CategoryFactory.create(**{'project': project})
        lookup = LookupFieldFactory.create(
            **{'category': category, 'key': 'lookup'}
        )
        kermit = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Kermit'
        })
        gonzo = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Gonzo'
        })
        ObservationFactory.create_batch(3, **{
            'project': project,
            'category': category,
            'properties': {'lookup': kermit.id}
        })
        ObservationFactory.create_batch(3, **{
            'project': project,
            'category': category,
            'properties': {'lookup': gonzo.id}
        })

        result = project.observations.all().search('kermit')
        self.assertEqual(len(result), 3)

        for o in result:
            self.assertEqual(o.properties.get('lookup'), kermit.id)
Example #3
0
    def test_get_singlelookup_filter(self):
        field = LookupFieldFactory.create(**{'name': 'Field'})
        val_1 = LookupValueFactory.create(**{'field': field})
        val_2 = LookupValueFactory.create(**{'field': field})
        LookupValueFactory.create(**{'field': field})

        self.assertEqual(
            get_singlelookup_filter(field, [val_1.id, val_2.id]),
            '<li>Field is one of %s, %s</li>' % (val_1.name, val_2.name))
Example #4
0
    def test_get_data_lookup_filter(self):
        user = UserF.create()
        project = ProjectF.create()
        category_1 = CategoryFactory(**{'project': project})

        lookup_field = LookupFieldFactory(**{
            'key': 'lookup',
            'category': category_1
        })
        lookup_1 = LookupValueFactory(**{
            'name': 'Ms. Piggy',
            'field': lookup_field
        })
        lookup_2 = LookupValueFactory(**{
            'name': 'Kermit',
            'field': lookup_field
        })
        category_2 = CategoryFactory(**{'project': project})
        lookup_field_2 = LookupFieldFactory(**{
            'key': 'bla',
            'category': category_2
        })
        lookup_3 = LookupValueFactory(**{
            'name': 'Gonzo',
            'field': lookup_field_2
        })

        UserGroupF.create(
            add_users=[user],
            **{
                'project': project,
                'filters': {
                    category_1.id: {'lookup': [lookup_1.id, lookup_2.id]}
                }
            }
        )

        for x in range(0, 5):
            ObservationFactory.create(**{
                'project': project,
                'category': category_1,
                'properties': {'lookup': lookup_1.id}
            })

            ObservationFactory.create(**{
                'project': project,
                'category': category_1,
                'properties': {'lookup': lookup_2.id}
            })

            ObservationFactory.create(**{
                'project': project,
                'category': category_2,
                'properties': {'bla': lookup_3.id}
            })
        self.assertEqual(project.get_all_contributions(user).count(), 10)
Example #5
0
    def test_get_singlelookup_filter(self):
        field = LookupFieldFactory.create(**{'name': 'Field'})
        val_1 = LookupValueFactory.create(**{'field': field})
        val_2 = LookupValueFactory.create(**{'field': field})
        LookupValueFactory.create(**{'field': field})

        self.assertEqual(
            get_singlelookup_filter(field, [val_1.id, val_2.id]),
            '<li>Field is one of %s, %s</li>' % (val_1.name, val_2.name)
        )
Example #6
0
    def test_get_data_lookup_filter(self):
        user = UserF.create()
        project = ProjectF.create(add_admins=[user])
        category_1 = CategoryFactory(**{'project': project})
        lookup_field = LookupFieldFactory(**{
            'key': 'lookup',
            'category': category_1
        })
        lookup_1 = LookupValueFactory(**{
            'name': 'Ms. Piggy',
            'field': lookup_field
        })
        lookup_2 = LookupValueFactory(**{
            'name': 'Kermit',
            'field': lookup_field
        })
        category_2 = CategoryFactory(**{'project': project})
        lookup_field_2 = LookupFieldFactory(**{
            'key': 'bla',
            'category': category_2
        })
        lookup_3 = LookupValueFactory(**{
            'name': 'Gonzo',
            'field': lookup_field_2
        })

        for x in range(0, 5):
            ObservationFactory.create(**{
                'project': project,
                'category': category_1,
                'properties': {'lookup': lookup_1.id}
            })

            ObservationFactory.create(**{
                'project': project,
                'category': category_1,
                'properties': {'lookup': lookup_2.id}
            })

            ObservationFactory.create(**{
                'project': project,
                'category': category_2,
                'properties': {'bla': lookup_3.id}
            })

        view = GroupingFactory(**{'project': project})
        RuleFactory(**{
            'grouping': view,
            'category': category_1,
            'constraints': {'lookup': [lookup_1.id, lookup_2.id]}
        })

        self.assertEqual(view.data(user).count(), 10)
Example #7
0
    def test_pre_save(self):
        o_type = CategoryFactory.create()
        TextFieldFactory.create(**{
            'key': 'key',
            'category': o_type,
            'order': 0
        })

        lookup = LookupFieldFactory.create(**{
            'category': o_type,
            'key': 'lookup',
            'order': 1
        })
        kermit = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Kermit'
        })
        LookupValueFactory.create(**{'field': lookup, 'name': 'Gonzo'})

        m_lookup = MultipleLookupFieldFactory.create(**{
            'category': o_type,
            'key': 'm_lookup',
            'order': 2
        })
        m_kermit = MultipleLookupValueFactory.create(**{
            'field': m_lookup,
            'name': 'Kermit'
        })
        MultipleLookupValueFactory.create(**{
            'field': m_lookup,
            'name': 'Gonzo'
        })
        m_piggy = MultipleLookupValueFactory.create(**{
            'field': m_lookup,
            'name': 'Ms Piggy'
        })

        o = ObservationFactory.create(
            **{
                'properties': {
                    'key': 'blah',
                    'lookup': kermit.id,
                    'm_lookup': [m_kermit.id, m_piggy.id]
                },
                'category': o_type
            })

        pre_save_update(Observation, instance=o)
        self.assertIn('Ms Piggy', o.search_matches)
        self.assertIn('Kermit', o.search_matches)
        self.assertIn('blah', o.search_matches)
Example #8
0
    def test_filters(self):
        category = CategoryFactory.create()
        TextFieldFactory.create(**{'category': category, 'key': 'text'})
        NumericFieldFactory.create(**{'category': category, 'key': 'number'})
        DateFieldFactory.create(**{'category': category, 'key': 'date'})
        DateTimeFieldFactory.create(
            **{'category': category, 'key': 'datetime'})
        TimeFieldFactory.create(**{'category': category, 'key': 'time'})
        lookup = LookupFieldFactory.create(
            **{'category': category, 'key': 'lookup'})
        val_1 = LookupValueFactory.create(**{'field': lookup})
        multiple = MultipleLookupFieldFactory.create(
            **{'category': category, 'key': 'multiple'})
        mul_1 = MultipleLookupValueFactory.create(**{'field': multiple})

        rule = RuleFactory.create(**{
            'category': category,
            'min_date': datetime.datetime(2007, 12, 5, 12, 00),
            'max_date': datetime.datetime(2012, 12, 5, 15, 00),
            'constraints': {
                'text': 'blah',
                'number': {'minval': 0, 'maxval': 10},
                'date': {'minval': 0, 'maxval': 10},
                'datetime': {'minval': 0, 'maxval': 10},
                'time': {'minval': 0, 'maxval': 10},
                'lookup': [val_1.id],
                'multiple': [mul_1.id]
            }
        })

        result = filters(rule)
        self.assertEqual(result.count('<li>'), 8)
Example #9
0
    def test_pre_observation_save(self):
        o_type = CategoryFactory.create()
        TextFieldFactory.create(
            **{'key': 'key', 'category': o_type, 'order': 0}
        )

        lookup = LookupFieldFactory.create(
            **{'category': o_type, 'key': 'lookup', 'order': 1}
        )
        kermit = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Kermit'
        })
        LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Gonzo'
        })

        m_lookup = MultipleLookupFieldFactory.create(
            **{'category': o_type, 'key': 'm_lookup', 'order': 2}
        )
        m_kermit = MultipleLookupValueFactory.create(**{
            'field': m_lookup,
            'name': 'Kermit'
        })
        MultipleLookupValueFactory.create(**{
            'field': m_lookup,
            'name': 'Gonzo'
        })
        m_piggy = MultipleLookupValueFactory.create(**{
            'field': m_lookup,
            'name': 'Ms Piggy'
        })

        o = ObservationFactory.create(**{
            'properties': {
                'key': 'blah',
                'lookup': kermit.id,
                'm_lookup': [m_kermit.id, m_piggy.id]
            },
            'category': o_type
        })

        pre_save_observation_update(Observation, instance=o)
        self.assertIn('Ms Piggy', o.search_matches)
        self.assertIn('Kermit', o.search_matches)
        self.assertIn('blah', o.search_matches)
Example #10
0
    def test_create_search_index_lookup(self):
        category = CategoryFactory.create()
        TextFieldFactory.create(**{
            'key': 'text_1',
            'category': category,
            'order': 0
        })
        NumericFieldFactory(**{
            'key': 'number',
            'category': category,
            'order': 0
        })
        lookup = LookupFieldFactory.create(**{
            'category': category,
            'key': 'lookup',
            'order': 1
        })
        kermit = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Kermit'
        })
        LookupValueFactory.create(**{'field': lookup, 'name': 'Gonzo'})

        o = ObservationFactory.create(
            **{
                'properties': {
                    'text_1': 'blah, abc',
                    'number': 12,
                    'lookup': kermit.id
                },
                'category': category
            })
        o.create_search_index()
        o.save()

        reference = Observation.objects.get(pk=o.id)
        self.assertEqual(
            reference.search_index.split(',').sort(),
            'blah,abc,12,kermit'.split(',').sort())
Example #11
0
    def test_filters(self):
        category = CategoryFactory.create()
        TextFieldFactory.create(**{'category': category, 'key': 'text'})
        NumericFieldFactory.create(**{'category': category, 'key': 'number'})
        DateFieldFactory.create(**{'category': category, 'key': 'date'})
        DateTimeFieldFactory.create(**{
            'category': category,
            'key': 'datetime'
        })
        TimeFieldFactory.create(**{'category': category, 'key': 'time'})
        lookup = LookupFieldFactory.create(**{
            'category': category,
            'key': 'lookup'
        })
        val_1 = LookupValueFactory.create(**{'field': lookup})
        multiple = MultipleLookupFieldFactory.create(**{
            'category': category,
            'key': 'multiple'
        })
        mul_1 = MultipleLookupValueFactory.create(**{'field': multiple})

        rule = RuleFactory.create(
            **{
                'category': category,
                'min_date': datetime.datetime(2007, 12, 5, 12, 00),
                'max_date': datetime.datetime(2012, 12, 5, 15, 00),
                'constraints': {
                    'text': 'blah',
                    'number': {
                        'minval': 0,
                        'maxval': 10
                    },
                    'date': {
                        'minval': 0,
                        'maxval': 10
                    },
                    'datetime': {
                        'minval': 0,
                        'maxval': 10
                    },
                    'time': {
                        'minval': 0,
                        'maxval': 10
                    },
                    'lookup': [val_1.id],
                    'multiple': [mul_1.id]
                }
            })

        result = filters(rule)
        self.assertEqual(result.count('<li>'), 8)
Example #12
0
    def test_create_search_index_lookup(self):
        category = CategoryFactory.create()
        TextFieldFactory.create(
            **{'key': 'text_1', 'category': category, 'order': 0}
        )
        NumericFieldFactory(
            **{'key': 'number', 'category': category, 'order': 0}
        )
        lookup = LookupFieldFactory.create(
            **{'category': category, 'key': 'lookup', 'order': 1}
        )
        kermit = LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Kermit'
        })
        LookupValueFactory.create(**{
            'field': lookup,
            'name': 'Gonzo'
        })

        o = ObservationFactory.create(**{
            'properties': {
                'text_1': 'blah, abc',
                'number': 12,
                'lookup': kermit.id
            },
            'category': category
        })
        o.create_search_index()
        o.save()

        reference = Observation.objects.get(pk=o.id)
        self.assertEqual(
            reference.search_index.split(',').sort(),
            'blah,abc,12,kermit'.split(',').sort()
        )
Example #13
0
def create_horniman_sapelli_project(user):
    geokey_project = ProjectFactory.create(
        add_admins=[user], **{'name': 'Mapping Cultures (v1.1)'})
    geokey_cat = CategoryFactory.create(**{
        'name': 'Horniman Gardens',
        'project': geokey_project
    })
    select_field = LookupFieldFactory.create(**{
        'name': 'Garden_Feature',
        'key': 'garden_feature',
        'category': geokey_cat
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Red Flowers',
        'symbol': 'red flowers.png'
    })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Blue Flowers',
            'symbol': 'blue flowers.png'
        })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Yellow Flowers',
            'symbol': 'yellow flowers.png'
        })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Edible Plants',
        'symbol': 'BeenTold.png'
    })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Medicinal Plants',
            'symbol': 'Medicine.png'
        })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Two Legged Animal',
            'symbol': 'Chicken.png'
        })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Four Legged Animal',
        'symbol': 'Sheep.png'
    })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Old Bench With Memorial',
            'symbol': 'memorial.png'
        })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Old Bench with No Memorial',
            'symbol': 'no memorial'
        })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'New Bench With Memorial',
            'symbol': 'memorial.png'
        })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'New Bench with No Memorial',
            'symbol': 'no memorial.png'
        })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Covered Bin',
        'symbol': 'covered bin.png'
    })
    LookupValueFactory.create(
        **{
            'field': select_field,
            'name': 'Uncovered Bin',
            'symbol': 'uncovered bin.png'
        })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Dog Bin',
        'symbol': 'dog bin.png'
    })

    sapelli_project = SapelliProjectFactory.create(
        **{
            'geokey_project':
            geokey_project,
            'name':
            'Mapping Cultures',
            'variant':
            None,
            'version':
            '1.1',
            'sapelli_id':
            1111,
            'sapelli_fingerprint':
            -1001003931,
            'sapelli_model_id':
            55263534870692951,
            'dir_path':
            None,
            'sap_path':
            normpath(join(dirname(abspath(__file__)), 'files/Horniman.sap'))
        })
    form = SapelliFormFactory.create(
        **{
            'category': geokey_cat,
            'sapelli_project': sapelli_project,
            'sapelli_id': 'Horniman Gardens',
            'sapelli_model_schema_number': 1
        })
    SapelliLocationFactory.create(**{
        'sapelli_form': form,
        'sapelli_id': 'Position'
    })
    choice_root = SapelliFieldFactory.create(
        **{
            'sapelli_form': form,
            'field': select_field,
            'sapelli_id': 'Garden_Feature'
        })

    for idx, value in enumerate(select_field.lookupvalues.all()):
        SapelliChoiceFactory.create(**{
            'lookup_value': value,
            'number': idx,
            'sapelli_field': choice_root
        })

    return sapelli_project
Example #14
0
def create_horniman_sapelli_project(user):
    geokey_project = ProjectFactory.create(
        add_admins=[user],
        **{'name': 'Mapping Cultures (v1.1)'}
    )
    geokey_cat = CategoryFactory.create(**{
        'name': 'Horniman Gardens',
        'project': geokey_project
    })
    select_field = LookupFieldFactory.create(**{
        'name': 'Garden_Feature',
        'key': 'garden_feature',
        'category': geokey_cat
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Red Flowers',
        'symbol': 'red flowers.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Blue Flowers',
        'symbol': 'blue flowers.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Yellow Flowers',
        'symbol': 'yellow flowers.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Edible Plants',
        'symbol': 'BeenTold.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Medicinal Plants',
        'symbol': 'Medicine.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Two Legged Animal',
        'symbol': 'Chicken.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Four Legged Animal',
        'symbol': 'Sheep.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Old Bench With Memorial',
        'symbol': 'memorial.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Old Bench with No Memorial',
        'symbol': 'no memorial'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'New Bench With Memorial',
        'symbol': 'memorial.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'New Bench with No Memorial',
        'symbol': 'no memorial.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Covered Bin',
        'symbol': 'covered bin.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Uncovered Bin',
        'symbol': 'uncovered bin.png'
    })
    LookupValueFactory.create(**{
        'field': select_field,
        'name': 'Dog Bin',
        'symbol': 'dog bin.png'
    })

    sapelli_project = SapelliProjectFactory.create(**{
        'geokey_project': geokey_project,
        'name': 'Mapping Cultures',
        'variant': None,
        'version': '1.1',
        'sapelli_id': 1111,
        'sapelli_fingerprint': -1001003931,
        'sapelli_model_id': 55263534870692951,
        'dir_path': None,
        'sap_path': normpath(join(dirname(abspath(__file__)), 'files/Horniman.sap'))
    })
    form = SapelliFormFactory.create(**{
        'category': geokey_cat,
        'sapelli_project': sapelli_project,
        'sapelli_id': 'Horniman Gardens',
        'sapelli_model_schema_number': 1
    })
    SapelliLocationFactory.create(**{
        'sapelli_form': form,
        'sapelli_id': 'Position'
    })
    choice_root = SapelliFieldFactory.create(**{
        'sapelli_form': form,
        'field': select_field,
        'sapelli_id': 'Garden_Feature'
    })

    for idx, value in enumerate(select_field.lookupvalues.all()):
        SapelliChoiceFactory.create(**{
            'lookup_value': value,
            'number': idx,
            'sapelli_field': choice_root
        })

    return sapelli_project