def test_get_data_with_none_rule(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
category_2 = CategoryFactory(**{'project': project})
category_3 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{'project': project, 'filters': None}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_2}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_3}
)
self.assertEqual(project.get_all_contributions(user).count(), 15)
def test_get_data_min_max_number_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'number',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'number': {
'minval': '10',
'maxval': '22'
}}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 5}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 12}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 20}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 25}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'number': 12}}
)
self.assertEqual(project.get_all_contributions(user).count(), 10)
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)
def test_get_data_text_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {'text': 'yes'}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes %s' % x}}
)
self.assertEqual(project.get_all_contributions(user).count(), 5)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.moderator = UserF.create()
self.commenter = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator, self.commenter])
self.moderators = UserGroupF(add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator,
'status': 'review'
})
self.comment = CommentFactory.create(
**{
'commentto': self.observation,
'creator': self.commenter,
'review_status': 'open'
})
def test_get_data_subset_user_group_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_2.id: {}}
}
)
subset = SubsetFactory.create(**{
'project': project,
'filters': {category_1.id: {}}
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(
project.get_all_contributions(user, subset=subset.id).count(),
0
)
def test_get_data_min_max_date_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
DateFieldFactory(**{
'key': 'date',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
DateFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'date': {
'minval': '2014-01-01', 'maxval': '2014-06-09'}
}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'date': '2014-04-09'}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'date': '2013-04-09'}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': '2014-04-09'}
})
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_get_created_before_and_after(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {
'min_date': '2013-01-01 00:00:00',
'max_date': '2013-10-01 00:00:00'}
}
}
)
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2014, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2013, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2012, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_delete_with_category_filter(self):
project = ProjectF.create()
category = CategoryFactory.create(**{"project": project})
category_2 = CategoryFactory.create(**{"project": project})
group = UserGroupF.create(**{"project": project, "filters": {category.id: {}, category_2.id: {}}})
category.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category_2.id): {}})
def test_delete_with_field_filter(self):
project = ProjectF.create()
category = CategoryFactory.create(**{"project": project})
field = Field.create("name", "key", "description", False, category, "TextField")
group = UserGroupF.create(**{"project": project, "filters": {category.id: {field.key: "blah"}}})
field.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category.id): {}})
def add_contributors(self, create, extracted, **kwargs):
from geokey.users.tests.model_factories import UserGroupF
if not create:
return
if extracted:
UserGroupF(add_users=extracted,
**{
'project': self,
'can_contribute': True
})
def test_usergroups(self):
project = ProjectF.create()
grouping = GroupingFactory.create(**{'project': project})
group = UserGroupF(**{'project': project})
html = usergroups(grouping)
self.assertEqual(
html, '<ul class="list-unstyled overview-list"><li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right grant-single" data-toggle="button" ><span '
'class="text-success">Grant access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li></ul>' % (group.id, group.name, group.description))
def add_viewers(self, create, extracted, **kwargs):
if not create:
return
if extracted:
from geokey.users.tests.model_factories import (
UserGroupF, GroupingUserGroupFactory)
group = UserGroupF(add_users=extracted,
**{
'project': self.project,
'can_contribute': False
})
GroupingUserGroupFactory(**{'grouping': self, 'usergroup': group})
def test_moderator(self):
user = UserF.create()
view = GroupingFactory.create()
group = UserGroupF.create(
add_users=[user],
**{'project': view.project, 'can_moderate': True}
)
GroupingUserGroupFactory.create(
**{'grouping': view, 'usergroup': group,
'can_view': True, 'can_read': True}
)
self.assertTrue(view.can_view(user))
self.assertTrue(view.can_read(user))
self.assertTrue(view.can_moderate(user))
def test_delete_with_category_filter(self):
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
category_2 = CategoryFactory.create(**{'project': project})
group = UserGroupF.create(**{
'project': project,
'filters': {
category.id: {},
category_2.id: {}
}
})
category.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category_2.id): {}})
def setUp(self):
self.moderator_view = UserF.create()
self.moderator = UserF.create()
self.contributor_view = UserF.create()
self.contributor = UserF.create()
self.viewer_view = UserF.create()
self.viewer = UserF.create()
self.some_dude = UserF.create()
self.project = ProjectF.create(**{
'isprivate': False,
'everyone_contributes': 'false'
})
self.moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.project,
'can_moderate': True
})
self.contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.project,
'can_contribute': True
})
self.viewers_view = UserGroupF(
add_users=[self.viewer_view],
**{
'project': self.project,
'can_contribute': False,
'can_moderate': False
})
self.moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.project,
'can_contribute': True
})
self.viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.project,
'can_contribute': False,
'can_moderate': False
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.moderator = UserF.create()
self.viewer = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.creator],
add_viewer=[self.viewer])
self.moderators = UserGroupF(add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator,
'status': 'active'
})
def test_delete_with_field_filter(self):
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
field = Field.create('name', 'key', 'description', False, category,
'TextField')
group = UserGroupF.create(**{
'project': project,
'filters': {
category.id: {
field.key: 'blah'
}
}
})
field.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category.id): {}})
def test_get_user_group(self):
project = ProjectF.create()
grouping = GroupingFactory.create(**{'project': project})
group = UserGroupF(**{'project': project})
html = get_user_group(group, grouping)
self.assertEqual(
html, '<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right grant-single" data-toggle="button" ><span '
'class="text-success">Grant access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (group.id, group.name, group.description))
GroupingUserGroupFactory.create(**{
'usergroup': group,
'grouping': grouping
})
html = get_user_group(group, grouping)
self.assertEqual(
html, '<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right active grant-single" data-toggle="button" >'
'<span class="text-danger">Revoke access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (group.id, group.name, group.description))
project.isprivate = False
project.save()
grouping.isprivate = False
grouping.save()
html = get_user_group(group, grouping)
self.assertEqual(
html, '<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right active grant-single" data-toggle="button" '
'disabled="disabled">'
'<span class="text-danger">Revoke access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (group.id, group.name, group.description))
def test_delete_with_field_filter(self):
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
field = Field.create(
'name', 'key', 'description', False, category,
'TextField'
)
group = UserGroupF.create(
**{
'project': project,
'filters': {
category.id: {field.key: 'blah'}}
}
)
field.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category.id): {}})
def setUp(self):
self.admin = UserF.create()
self.moderator_view = UserF.create()
self.moderator = UserF.create()
self.contributor_view = UserF.create()
self.contributor = UserF.create()
self.viewer = UserF.create()
self.some_dude = UserF.create()
self.private_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Private',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.private_project,
'can_moderate': True
})
self.private_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.private_project,
'can_contribute': True
})
self.private_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.private_project,
'can_moderate': True
})
self.private_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.private_project,
'can_contribute': True
})
self.private_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.private_project,
'can_contribute': False,
'can_moderate': False
})
self.private_publicview_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Private with public view',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_publicview_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.private_publicview_project,
'can_moderate': True
})
self.private_publicview_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.private_publicview_project,
'can_contribute': True
})
self.private_publicview_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.private_publicview_project,
'can_moderate': True
})
self.private_publicview_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.private_publicview_project,
'can_contribute': True
})
self.private_publicview_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.private_publicview_project,
'can_contribute': False,
'can_moderate': False
})
self.private_publicviews_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Private with public views',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_publicviews_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.private_publicviews_project,
'can_moderate': True
})
self.private_publicviews_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.private_publicviews_project,
'can_contribute': True
})
self.private_publicviews_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.private_publicviews_project,
'can_moderate': True
})
self.private_publicviews_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.private_publicviews_project,
'can_contribute': True
})
self.private_publicviews_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.private_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
self.public_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Public',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.public_project,
'can_moderate': True
})
self.public_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.public_project,
'can_contribute': True
})
self.public_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.public_project,
'can_moderate': True
})
self.public_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.public_project,
'can_contribute': True
})
self.public_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.public_project,
'can_contribute': False,
'can_moderate': False
})
self.public_publicview_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Public with public view',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_publicview_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.public_publicview_project,
'can_moderate': True
})
self.public_publicview_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.public_publicview_project,
'can_contribute': True
})
self.public_publicview_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.public_publicview_project,
'can_moderate': True
})
self.public_publicview_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.public_publicview_project,
'can_contribute': True
})
self.public_publicview_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.public_publicview_project,
'can_contribute': False,
'can_moderate': False
})
self.public_publicviews_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'public with all public views',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_publicviews_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.public_publicviews_project,
'can_moderate': True
})
self.public_publicviews_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.public_publicviews_project,
'can_contribute': True
})
self.public_publicviews_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.public_publicviews_project,
'can_moderate': True
})
self.public_publicviews_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.public_publicviews_project,
'can_contribute': True
})
self.public_publicviews_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.public_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
