def set_object_permissions(sender, instance=None, created=False, **kwargs):
# seems the super is not called, have to get xform from here
xform = XForm.objects.get(pk=instance.pk)
if created:
from onadata.libs.permissions import OwnerRole
OwnerRole.add(instance.user, xform)
if instance.created_by and instance.user != instance.created_by:
OwnerRole.add(instance.created_by, xform)
from onadata.libs.utils.project_utils import set_project_perms_to_xform
set_project_perms_to_xform(xform, instance.project)
if hasattr(instance, 'has_external_choices') \
and instance.has_external_choices:
instance.xls.seek(0)
f = sheet_to_csv(instance.xls.read(), 'external_choices')
f.seek(0, os.SEEK_END)
size = f.tell()
f.seek(0)
from onadata.apps.main.models.meta_data import MetaData
data_file = InMemoryUploadedFile(
file=f,
field_name='data_file',
name='itemsets.csv',
content_type='text/csv',
size=size,
charset=None
)
MetaData.media_upload(xform, data_file)
def save(self):
"""
Creates and updates RestService and MetaData objects with textit or
rapidpro service properties.
"""
service = RestService() if not self.pk else \
RestService.objects.get(pk=self.pk)
service.name = self.name
service.service_url = self.service_url
service.xform = self.xform
try:
service.save()
except IntegrityError as e:
if str(e).startswith("duplicate key value violates unique "
"constraint"):
msg = _(u"The service already created for this form.")
else:
msg = _(str(e))
raise serializers.ValidationError(msg)
self.pk = service.pk
self.date_created = service.date_created
self.date_modified = service.date_modified
data_value = '{}|{}|{}'.format(self.auth_token, self.flow_uuid,
self.contacts)
MetaData.textit(self.xform, data_value=data_value)
if self.xform.is_merged_dataset:
for xform in self.xform.mergedxform.xforms.all():
MetaData.textit(xform, data_value=data_value)
def get_enketo_url(self, obj):
if obj:
_enketo_url = cache.get('{}{}'.format(ENKETO_URL_CACHE, obj.pk))
if _enketo_url:
return _enketo_url
try:
metadata = MetaData.objects.get(xform=obj,
data_type="enketo_url")
except MetaData.DoesNotExist:
request = self.context.get('request')
form_url = _get_form_url(request, obj.user.username)
url = ""
try:
url = enketo_url(form_url, obj.id_string)
MetaData.enketo_url(obj, url)
except (EnketoError, ConnectionError):
pass
cache.set('{}{}'.format(ENKETO_URL_CACHE, obj.pk), url)
return url
_enketo_url = metadata.data_value
cache.set('{}{}'.format(ENKETO_URL_CACHE, obj.pk), _enketo_url)
return _enketo_url
return None
def set_object_permissions(sender, instance=None, created=False, **kwargs):
# seems the super is not called, have to get xform from here
xform = XForm.objects.get(pk=instance.pk)
if created:
from onadata.libs.permissions import OwnerRole
OwnerRole.add(instance.user, xform)
if instance.created_by and instance.user != instance.created_by:
OwnerRole.add(instance.created_by, xform)
from onadata.libs.utils.project_utils import set_project_perms_to_xform
set_project_perms_to_xform(xform, instance.project)
if hasattr(instance, 'has_external_choices') \
and instance.has_external_choices:
instance.xls.seek(0)
f = sheet_to_csv(instance.xls.read(), 'external_choices')
f.seek(0, os.SEEK_END)
size = f.tell()
f.seek(0)
from onadata.apps.main.models.meta_data import MetaData
data_file = InMemoryUploadedFile(file=f,
field_name='data_file',
name='itemsets.csv',
content_type='text/csv',
size=size,
charset=None)
MetaData.media_upload(xform, data_file)
def get_enketo_url(self, obj):
if obj:
_enketo_url = cache.get(
'{}{}'.format(ENKETO_URL_CACHE, obj.pk))
if _enketo_url:
return _enketo_url
try:
metadata = MetaData.objects.get(
xform=obj, data_type="enketo_url")
except MetaData.DoesNotExist:
request = self.context.get('request')
form_url = _get_form_url(request, obj.user.username)
url = ""
try:
url = enketo_url(form_url, obj.id_string)
MetaData.enketo_url(obj, url)
except (EnketoError, ConnectionError):
pass
cache.set('{}{}'.format(ENKETO_URL_CACHE, obj.pk), url)
return url
_enketo_url = metadata.data_value
cache.set('{}{}'.format(ENKETO_URL_CACHE, obj.pk), _enketo_url)
return _enketo_url
return None
def save(self, **kwargs):
rs = RestService() if not self.pk else \
RestService.objects.get(pk=self.pk)
rs.name = self.name
rs.service_url = self.service_url
rs.xform = self.xform
try:
rs.save()
except IntegrityError as e:
if str(e).startswith("duplicate key value violates unique "
"constraint"):
msg = _(u"The service already created for this form.")
else:
msg = _(str(e))
raise serializers.ValidationError(msg)
self.date_created = rs.date_created
self.date_modified = rs.date_modified
data_value = '{}|{}|{}'.format(self.auth_token, self.flow_uuid,
self.contacts)
MetaData.textit(self.xform, data_value=data_value)
self.pk = rs.pk
def handle(self, *args, **options):
request = HttpRequest()
server_name = options.get('server_name')
server_port = options.get('server_port')
protocol = options.get('protocol')
generate_consistent_urls = options.get('generate_consistent_urls')
if not server_name or not server_port or not protocol:
raise CommandError(
'please provide a server_name, a server_port and a protocol')
if server_name not in ['ona.io', 'stage.ona.io', 'localhost']:
raise CommandError('server name provided is not valid')
if protocol not in ['http', 'https']:
raise CommandError('protocol provided is not valid')
# required for generation of enketo url
request.META['HTTP_HOST'] = '%s:%s' % (server_name, server_port)\
if server_port != '80' else server_name
# required for generation of enketo preview url
request.META['SERVER_NAME'] = server_name
request.META['SERVER_PORT'] = server_port
resultset = MetaData.objects.filter(
Q(data_type='enketo_url') | Q(data_type='enketo_preview_url'))
for meta_data in resultset:
username = meta_data.content_object.user.username
id_string = meta_data.content_object.id_string
data_type = meta_data.data_type
data_value = meta_data.data_value
xform = meta_data.content_object
xform_pk = xform.pk
with open('/tmp/enketo_url', 'a') as f:
if data_type == 'enketo_url':
form_url = get_form_url(
request,
username=username,
id_string=id_string,
xform_pk=xform_pk,
generate_consistent_urls=generate_consistent_urls)
_enketo_url = enketo_url(form_url, id_string)
MetaData.enketo_url(xform, _enketo_url)
elif data_type == 'enketo_preview_url':
_enketo_preview_url = get_enketo_preview_url(
request,
id_string,
username=username,
xform_pk=xform_pk,
generate_consistent_urls=generate_consistent_urls)
MetaData.enketo_preview_url(xform, _enketo_preview_url)
f.write('%s : %s \n' % (id_string, data_value))
self.stdout.write('%s: %s' % (data_type, meta_data.data_value))
self.stdout.write("enketo urls update complete!!")
def get_enketo_preview_url(self, obj):
if obj:
_enketo_preview_url = cache.get('{}{}'.format(
ENKETO_PREVIEW_URL_CACHE, obj.pk))
if _enketo_preview_url:
return _enketo_preview_url
try:
metadata = MetaData.objects.get(xform=obj,
data_type="enketo_preview_url")
except MetaData.DoesNotExist:
request = self.context.get('request')
preview_url = ""
try:
preview_url = get_enketo_preview_url(
request, obj.user.username, obj.id_string)
MetaData.enketo_preview_url(obj, preview_url)
except EnketoError:
pass
cache.set('{}{}'.format(ENKETO_PREVIEW_URL_CACHE, obj.pk),
preview_url)
return preview_url
_enketo_preview_url = metadata.data_value
cache.set('{}{}'.format(ENKETO_URL_CACHE, obj.pk),
_enketo_preview_url)
return _enketo_preview_url
return None
def test_update_with_errors(self):
rest = self._create_textit_service()
data_value = "{}|{}".format("test", "test2")
MetaData.textit(self.xform, data_value)
request = self.factory.get('/', **self.extra)
response = self.view(request, pk=rest.get('id'))
self.assertEquals(response.status_code, 400)
self.assertEquals(response.data,
[u"Error occurred when loading textit service."
u"Resolve by updating auth_token, flow_uuid and "
u"contacts fields"])
post_data = {
"name": "textit",
"service_url": "https://textit.io",
"xform": self.xform.pk,
"auth_token": "sadsdfhsdf",
"flow_uuid": "sdfskhfskdjhfs",
"contacts": "ksadaskjdajsda"
}
request = self.factory.put('/', data=post_data, **self.extra)
response = self.view(request, pk=rest.get('id'))
self.assertEquals(response.status_code, 200)
def forms(self, request, **kwargs):
"""Add a form to a project or list forms for the project.
The request key `xls_file` holds the XLSForm file object.
"""
project = self.object = self.get_object()
if request.method.upper() == 'POST':
survey = utils.publish_project_xform(request, project)
if isinstance(survey, XForm):
if 'formid' in request.data:
serializer_cls = XFormSerializer
else:
serializer_cls = XFormCreateSerializer
serializer = serializer_cls(survey,
context={'request': request})
published_by_formbuilder = request.data.get(
'published_by_formbuilder'
)
if str_to_bool(published_by_formbuilder):
MetaData.published_by_formbuilder(survey, 'True')
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(survey, status=status.HTTP_400_BAD_REQUEST)
xforms = XForm.objects.filter(project=project)
serializer = XFormSerializer(xforms, context={'request': request},
many=True)
return Response(serializer.data)
def test_create_metadata(self):
count = len(MetaData.objects.filter(xform=self.xform,
data_type='enketo_url'))
enketo_url = "https://dmfrm.enketo.org/webform"
MetaData.enketo_url(self.xform, enketo_url)
self.assertEquals(count + 1, len(MetaData.objects.filter(
xform=self.xform, data_type='enketo_url')))
def forms(self, request, **kwargs):
"""Add a form to a project or list forms for the project.
The request key `xls_file` holds the XLSForm file object.
"""
project = self.object = self.get_object()
if request.method.upper() == 'POST':
survey = utils.publish_project_xform(request, project)
if isinstance(survey, XForm):
if 'formid' in request.data:
serializer_cls = XFormSerializer
else:
serializer_cls = XFormCreateSerializer
serializer = serializer_cls(survey,
context={'request': request})
published_by_formbuilder = request.data.get(
'published_by_formbuilder'
)
if str_to_bool(published_by_formbuilder):
MetaData.published_by_formbuilder(survey, 'True')
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(survey, status=status.HTTP_400_BAD_REQUEST)
xforms = XForm.objects.filter(project=project)
serializer = XFormSerializer(xforms, context={'request': request},
many=True)
return Response(serializer.data)
def test_create_metadata(self):
count = len(MetaData.objects.filter(object_id=self.xform.id,
data_type='enketo_url'))
enketo_url = "https://dmfrm.enketo.org/webform"
MetaData.enketo_url(self.xform, enketo_url)
self.assertEquals(count + 1, len(MetaData.objects.filter(
object_id=self.xform.id, data_type='enketo_url')))
def get_enketo_preview_url(self, obj):
if obj:
_enketo_preview_url = cache.get(
'{}{}'.format(ENKETO_PREVIEW_URL_CACHE, obj.pk))
if _enketo_preview_url:
return _enketo_preview_url
try:
metadata = MetaData.objects.get(
xform=obj, data_type="enketo_preview_url")
except MetaData.DoesNotExist:
request = self.context.get('request')
preview_url = ""
try:
preview_url = get_enketo_preview_url(request,
obj.user.username,
obj.id_string)
MetaData.enketo_preview_url(obj, preview_url)
except EnketoError:
pass
cache.set('{}{}'.format(ENKETO_PREVIEW_URL_CACHE, obj.pk),
preview_url)
return preview_url
_enketo_preview_url = metadata.data_value
cache.set(
'{}{}'.format(ENKETO_URL_CACHE, obj.pk), _enketo_preview_url)
return _enketo_preview_url
return None
def _get_server_from_metadata(xform, meta, token):
# Fetch metadata details from master directly
try:
report_templates = MetaData.external_export(xform)
except MetaData.DoesNotExist:
from multidb.pinning import use_master
with use_master:
report_templates = MetaData.external_export(xform)
if meta:
try:
int(meta)
except ValueError:
raise Exception(u"Invalid metadata pk {0}".format(meta))
# Get the external server from the metadata
result = report_templates.get(pk=meta)
server = result.external_export_url
name = result.external_export_name
elif token:
server = token
name = None
else:
# Take the latest value in the metadata
if not report_templates:
raise Exception(
u"Could not find the template token: Please upload template.")
server = report_templates[0].external_export_url
name = report_templates[0].external_export_name
return server, name
def test_saving_same_metadata_object_doesnt_trigger_integrity_error(self):
count = len(MetaData.objects.filter(object_id=self.xform.id,
data_type='enketo_url'))
enketo_url = "https://dmfrm.enketo.org/webform"
MetaData.enketo_url(self.xform, enketo_url)
count += 1
self.assertEquals(count, len(MetaData.objects.filter(
object_id=self.xform.id, data_type='enketo_url')))
MetaData.enketo_url(self.xform, enketo_url)
self.assertEquals(count, len(MetaData.objects.filter(
object_id=self.xform.id, data_type='enketo_url')))
def test_saving_same_metadata_object_doesnt_trigger_integrity_error(self):
count = len(MetaData.objects.filter(xform=self.xform,
data_type='enketo_url'))
enketo_url = "https://dmfrm.enketo.org/webform"
MetaData.enketo_url(self.xform, enketo_url)
count += 1
self.assertEquals(count, len(MetaData.objects.filter(
xform=self.xform, data_type='enketo_url')))
MetaData.enketo_url(self.xform, enketo_url)
self.assertEquals(count, len(MetaData.objects.filter(
xform=self.xform, data_type='enketo_url')))
def test_textit_flow_without_parsed_instances(self, mock_http):
rest = RestService(name="textit",
service_url="https://server.io",
xform=self.xform)
rest.save()
MetaData.textit(self.xform,
data_value='{}|{}|{}'.format("sadsdfhsdf",
"sdfskhfskdjhfs",
"ksadaskjdajsda"))
self.assertFalse(mock_http.called)
self._make_submissions()
def test_upload_to_with_project_and_xform_instance(self):
models = [Project, XForm]
for model in models:
model_instance = model(user=self.user, created_by=self.user)
metadata = MetaData(data_type="media")
metadata.content_object = model_instance
filename = "filename"
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.user.username,
'formid-media',
filename))
def handle(self, *args, **options):
request = HttpRequest()
server_name = options.get('server_name')
server_port = options.get('server_port')
protocol = options.get('protocol')
if not server_name or not server_port or not protocol:
raise CommandError(
'please provide a server_name, a server_port and a protocol')
if server_name not in ['ona.io', 'stage.ona.io', 'localhost']:
raise CommandError('server name provided is not valid')
if protocol not in ['http', 'https']:
raise CommandError('protocol provided is not valid')
# required for generation of enketo url
request.META['HTTP_HOST'] = '%s:%s' % (server_name, server_port)\
if server_port != '80' else server_name
# required for generation of enketo preview url
request.META['SERVER_NAME'] = server_name
request.META['SERVER_PORT'] = server_port
resultset = MetaData.objects.filter(
Q(data_type='enketo_url') | Q(data_type='enketo_preview_url'))
for meta_data in resultset:
username = meta_data.content_object.user.username
id_string = meta_data.content_object.id_string
data_type = meta_data.data_type
data_value = meta_data.data_value
xform = meta_data.content_object
with open('/tmp/enketo_url', 'a') as f:
if data_type == 'enketo_url':
form_url = get_form_url(
request, username, protocol=protocol,
xform_pk=xform.pk)
_enketo_url = enketo_url(form_url, id_string)
MetaData.enketo_url(xform, _enketo_url)
elif data_type == 'enketo_preview_url':
_enketo_preview_url = get_enketo_preview_url(
request, username, id_string, xform_pk=xform.pk)
MetaData.enketo_preview_url(xform, _enketo_preview_url)
f.write('%s : %s \n' % (id_string, data_value))
self.stdout.write('%s: %s' % (data_type, meta_data.data_value))
self.stdout.write("enketo urls update complete!!")
def save(self, **kwargs):
rs = RestService() if not self.pk else \
RestService.objects.get(pk=self.pk)
rs.name = self.name
rs.service_url = self.service_url
rs.xform = self.xform
rs.save()
data_value = '{}|{}|{}'.format(self.auth_token, self.flow_uuid,
self.contacts)
MetaData.textit(self.xform, data_value=data_value)
self.pk = rs.pk
def set_object_permissions(sender, instance=None, created=False, **kwargs):
"""
Apply the relevant object permissions for the form to all users who should
have access to it.
"""
if instance.project:
# clear cache
safe_delete('{}{}'.format(PROJ_FORMS_CACHE, instance.project.pk))
safe_delete('{}{}'.format(PROJ_BASE_FORMS_CACHE, instance.project.pk))
# seems the super is not called, have to get xform from here
xform = XForm.objects.get(pk=instance.pk)
if created:
from onadata.libs.permissions import OwnerRole
OwnerRole.add(instance.user, xform)
if instance.created_by and instance.user != instance.created_by:
OwnerRole.add(instance.created_by, xform)
from onadata.libs.utils.project_utils import set_project_perms_to_xform_async # noqa
try:
set_project_perms_to_xform_async.delay(xform.pk,
instance.project.pk)
except OperationalError:
from onadata.libs.utils.project_utils import set_project_perms_to_xform # noqa
set_project_perms_to_xform(xform, instance.project)
if hasattr(instance, 'has_external_choices') \
and instance.has_external_choices:
instance.xls.seek(0)
f = sheet_to_csv(instance.xls.read(), 'external_choices')
f.seek(0, os.SEEK_END)
size = f.tell()
f.seek(0)
from onadata.apps.main.models.meta_data import MetaData
data_file = InMemoryUploadedFile(
file=f,
field_name='data_file',
name='itemsets.csv',
content_type='text/csv',
size=size,
charset=None
)
MetaData.media_upload(xform, data_file)
def set_object_permissions(sender, instance=None, created=False, **kwargs):
"""
Apply the relevant object permissions for the form to all users who should
have access to it.
"""
if instance.project:
# clear cache
safe_delete('{}{}'.format(PROJ_FORMS_CACHE, instance.project.pk))
safe_delete('{}{}'.format(PROJ_BASE_FORMS_CACHE, instance.project.pk))
# seems the super is not called, have to get xform from here
xform = XForm.objects.get(pk=instance.pk)
if created:
from onadata.libs.permissions import OwnerRole
OwnerRole.add(instance.user, xform)
if instance.created_by and instance.user != instance.created_by:
OwnerRole.add(instance.created_by, xform)
from onadata.libs.utils.project_utils import set_project_perms_to_xform_async # noqa
try:
set_project_perms_to_xform_async.delay(xform.pk,
instance.project.pk)
except OperationalError:
from onadata.libs.utils.project_utils import set_project_perms_to_xform # noqa
set_project_perms_to_xform(xform, instance.project)
if hasattr(instance, 'has_external_choices') \
and instance.has_external_choices:
instance.xls.seek(0)
f = sheet_to_csv(instance.xls.read(), 'external_choices')
f.seek(0, os.SEEK_END)
size = f.tell()
f.seek(0)
from onadata.apps.main.models.meta_data import MetaData
data_file = InMemoryUploadedFile(
file=f,
field_name='data_file',
name='itemsets.csv',
content_type='text/csv',
size=size,
charset=None
)
MetaData.media_upload(xform, data_file)
def update_role_by_meta_xform_perms(xform):
"""
Updates users role in a xform based on meta permissions set on the form.
"""
# load meta xform perms
metadata = MetaData.xform_meta_permission(xform)
editor_role_list = [EditorRole, EditorMinorRole]
editor_role = {role.name: role for role in editor_role_list}
dataentry_role_list = [
DataEntryMinorRole, DataEntryOnlyRole, DataEntryRole
]
dataentry_role = {role.name: role for role in dataentry_role_list}
if metadata:
meta_perms = metadata.data_value.split('|')
# update roles
users = get_xform_users(xform)
for user in users:
role = users.get(user).get('role')
if role in editor_role:
role = ROLES.get(meta_perms[0])
role.add(user, xform)
if role in dataentry_role:
role = ROLES.get(meta_perms[1])
role.add(user, xform)
def test_xform_meta_permission(self):
view = MetaDataViewSet.as_view({'post': 'create'})
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minor|dataentry',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 201)
meta = MetaData.xform_meta_permission(self.xform)
self.assertEqual(meta.data_value, response.data.get('data_value'))
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minors|invalid_role',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 400)
error = u"Format 'role'|'role' or Invalid role"
self.assertEqual(response.data, {'non_field_errors': [error]})
def save(self, **kwargs):
rs = RestService() if not self.pk else \
RestService.objects.get(pk=self.pk)
rs.name = self.name
rs.service_url = self.service_url
rs.xform = self.xform
rs.save()
data_value = '{}|{}|{}'.format(self.auth_token,
self.flow_uuid,
self.contacts)
MetaData.textit(self.xform, data_value=data_value)
self.pk = rs.pk
def _get_server_from_metadata(xform, meta, token):
report_templates = MetaData.external_export(xform)
if meta:
try:
int(meta)
except ValueError:
raise Exception(u"Invalid metadata pk {0}".format(meta))
# Get the external server from the metadata
result = report_templates.get(pk=meta)
server = result.external_export_url
name = result.external_export_name
elif token:
server = token
name = None
else:
# Take the latest value in the metadata
if not report_templates:
raise Exception(
u"Could not find the template token: Please upload template.")
server = report_templates[0].external_export_url
name = report_templates[0].external_export_name
return server, name
def test_xform_meta_permission(self):
view = MetaDataViewSet.as_view({'post': 'create'})
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minor|dataentry',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 201)
meta = MetaData.xform_meta_permission(self.xform)
self.assertEqual(meta.data_value, response.data.get('data_value'))
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minors|invalid_role',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 400)
error = u"Format 'role'|'role' or Invalid role"
self.assertEqual(response.data, {'non_field_errors': [error]})
def test_textit_flow(self, mock_http):
rest = RestService(name="textit",
service_url="https://server.io",
xform=self.xform)
rest.save()
MetaData.textit(self.xform,
data_value='{}|{}|{}'.format("sadsdfhsdf",
"sdfskhfskdjhfs",
"ksadaskjdajsda"))
self.assertFalse(mock_http.called)
self._make_submissions()
self.assertTrue(mock_http.called)
self.assertEquals(mock_http.call_count, 4)
def _get_server_from_metadata(xform, meta, token):
report_templates = MetaData.external_export(xform)
if meta:
try:
int(meta)
except ValueError:
raise Exception(u"Invalid metadata pk {0}".format(meta))
# Get the external server from the metadata
result = report_templates.get(pk=meta)
server = result.external_export_url
name = result.external_export_name
elif token:
server = token
name = None
else:
# Take the latest value in the metadata
if not report_templates:
raise Exception(
u"Could not find the template token: Please upload template.")
server = report_templates[0].external_export_url
name = report_templates[0].external_export_name
return server, name
def update_role_by_meta_xform_perms(xform):
"""
Updates users role in a xform based on meta permissions set on the form.
"""
# load meta xform perms
metadata = MetaData.xform_meta_permission(xform)
editor_role_list = [EditorRole, EditorMinorRole]
editor_role = {role.name: role for role in editor_role_list}
dataentry_role_list = [
DataEntryMinorRole, DataEntryOnlyRole, DataEntryRole
]
dataentry_role = {role.name: role for role in dataentry_role_list}
if metadata:
meta_perms = metadata.data_value.split('|')
# update roles
users = get_xform_users(xform)
for user in users:
role = users.get(user).get('role')
if role in editor_role:
role = ROLES.get(meta_perms[0])
role.add(user, xform)
if role in dataentry_role:
role = ROLES.get(meta_perms[1])
role.add(user, xform)
def _create_enketo_url(request, xform):
"""
Generate enketo url for a form
:param request:
:param xform:
:return: enketo url
"""
form_url = get_form_url(request, xform.user.username,
settings.ENKETO_PROTOCOL)
url = ""
try:
url = enketo_url(form_url, xform.id_string)
MetaData.enketo_url(xform, url)
except ConnectionError, e:
logging.exception("Connection Error: %s" % e.message)
def test_upload_to_with_anonymous_user(self):
instance = Instance(user=self.user, xform=self.xform)
metadata = MetaData(data_type="media")
metadata.content_object = instance
filename = "filename"
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.user.username,
'formid-media',
filename))
# test instance with anonymous user
instance_without_user = Instance(xform=self.xform)
metadata.content_object = instance_without_user
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.xform.user.username,
'formid-media',
filename))
def test_upload_to_with_anonymous_user(self):
instance = Instance(user=self.user, xform=self.xform)
metadata = MetaData(data_type="media")
metadata.content_object = instance
filename = "filename"
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.user.username,
'formid-media',
filename))
# test instance with anonymous user
instance_without_user = Instance(xform=self.xform)
metadata.content_object = instance_without_user
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.xform.user.username,
'formid-media',
filename))
def test_create_google_sheet_metadata_object(self):
count = len(MetaData.objects.filter(object_id=self.xform.id,
data_type=GOOGLE_SHEET_DATA_TYPE))
google_sheets_actions = (
'{} ABC100| '
'{} True | '
'{} 123'
).format(GOOGLE_SHEET_ID, UPDATE_OR_DELETE_GOOGLE_SHEET_DATA, USER_ID)
MetaData.set_google_sheet_details(self.xform, google_sheets_actions)
# change
self.assertEquals(count + 1, MetaData.objects.filter(
object_id=self.xform.id, data_type=GOOGLE_SHEET_DATA_TYPE).count())
gsheet_details = MetaData.get_google_sheet_details(self.xform.pk)
self.assertEqual({
GOOGLE_SHEET_ID: 'ABC100',
UPDATE_OR_DELETE_GOOGLE_SHEET_DATA: 'True',
USER_ID: '123'}, gsheet_details)
def test_create_google_sheet_metadata_object(self):
count = len(MetaData.objects.filter(object_id=self.xform.id,
data_type=GOOGLE_SHEET_DATA_TYPE))
google_sheets_actions = (
'{} ABC100| '
'{} True | '
'{} 123'
).format(GOOGLE_SHEET_ID, UPDATE_OR_DELETE_GOOGLE_SHEET_DATA, USER_ID)
MetaData.set_google_sheet_details(self.xform, google_sheets_actions)
# change
self.assertEquals(count + 1, MetaData.objects.filter(
object_id=self.xform.id, data_type=GOOGLE_SHEET_DATA_TYPE).count())
gsheet_details = MetaData.get_google_sheet_details(self.xform.pk)
self.assertEqual({
GOOGLE_SHEET_ID: 'ABC100',
UPDATE_OR_DELETE_GOOGLE_SHEET_DATA: 'True',
USER_ID: '123'}, gsheet_details)
def retrieve(self):
meta = MetaData.textit(self.xform)
try:
self.auth_token, self.flow_uuid, self.contacts = \
meta.data_value.split(METADATA_SEPARATOR)
except ValueError:
raise serializers.ValidationError(
_("Error occurred when loading textit service."
"Resolve by updating auth_token, flow_uuid and contacts"
" fields"))
def get_enketo_preview_url(self, obj):
if obj:
_enketo_preview_url = cache.get(
'{}{}'.format(ENKETO_PREVIEW_URL_CACHE, obj.pk))
if _enketo_preview_url:
return _enketo_preview_url
url = self._get_metadata(obj, 'enketo_preview_url')
if url is None:
try:
url = get_enketo_preview_url(
self.context.get('request'), obj.user.username,
obj.id_string)
except:
return url
else:
MetaData.enketo_preview_url(obj, url)
return _set_cache(ENKETO_PREVIEW_URL_CACHE, url, obj)
return None
def test_upload_to_with_project_and_xform_instance(self):
model_instance = Project(created_by=self.user)
metadata = MetaData(data_type="media")
metadata.content_object = model_instance
filename = "filename"
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.user.username,
'formid-media',
filename))
model_instance = XForm(user=self.user, created_by=self.user)
metadata = MetaData(data_type="media")
metadata.content_object = model_instance
filename = "filename"
self.assertEquals(upload_to(metadata, filename),
"{}/{}/{}".format(self.user.username,
'formid-media',
filename))
def get_enketo_preview_url(self, obj):
if obj:
_enketo_preview_url = cache.get(
'{}{}'.format(ENKETO_PREVIEW_URL_CACHE, obj.pk))
if _enketo_preview_url:
return _enketo_preview_url
url = self._get_metadata(obj, 'enketo_preview_url')
if url is None:
try:
url = get_enketo_preview_url(
self.context.get('request'), obj.user.username,
obj.id_string, xform_pk=obj.pk)
except Exception:
return url
else:
MetaData.enketo_preview_url(obj, url)
return _set_cache(ENKETO_PREVIEW_URL_CACHE, url, obj)
return None
def _create_enketo_url(request, xform):
"""
Generate enketo url for a form
:param request:
:param xform:
:return: enketo url
"""
form_url = get_form_url(request, xform.user.username,
settings.ENKETO_PROTOCOL, xform_pk=xform.pk)
url = ""
try:
url = enketo_url(form_url, xform.id_string)
MetaData.enketo_url(xform, url)
except ConnectionError as e:
logging.exception("Connection Error: %s" % e)
except EnketoError as e:
logging.exception("Enketo Error: %s" % e.message)
return url
def _create_enketo_urls(request, xform):
"""
Generate enketo urls for a form
:param request:
:param xform:
:return: enketo urls
"""
form_url = get_form_url(request,
xform.user.username,
settings.ENKETO_PROTOCOL,
xform_pk=xform.pk,
generate_consistent_urls=True)
data = {}
try:
enketo_urls = get_enketo_urls(form_url, xform.id_string)
offline_url = enketo_urls.get("offline_url")
MetaData.enketo_url(xform, offline_url)
data['offline_url'] = offline_url
if 'preview_url' in enketo_urls:
preview_url = enketo_urls.get("preview_url")
MetaData.enketo_preview_url(xform, preview_url)
data['preview_url'] = preview_url
if 'single_url' in enketo_urls:
single_url = enketo_urls.get("single_url")
MetaData.enketo_single_submit_url(xform, single_url)
data['single_url'] = single_url
except ConnectionError as e:
logging.exception("Connection Error: %s" % e)
except EnketoError as e:
logging.exception("Enketo Error: %s" % e.message)
return data
def save(self):
"""
Creates and updates RestService and MetaData objects with textit or
rapidpro service properties.
"""
service = RestService() if not self.pk else \
RestService.objects.get(pk=self.pk)
service.name = self.name
service.service_url = self.service_url
service.xform = self.xform
try:
service.save()
except IntegrityError as e:
if str(e).startswith("duplicate key value violates unique "
"constraint"):
msg = _(u"The service already created for this form.")
else:
msg = _(str(e))
raise serializers.ValidationError(msg)
self.pk = service.pk
self.date_created = service.date_created
self.date_modified = service.date_modified
self.active = service.active
self.inactive_reason = service.inactive_reason
data_value = '{}|{}|{}'.format(self.auth_token,
self.flow_uuid,
self.contacts)
MetaData.textit(self.xform, data_value=data_value)
if self.xform.is_merged_dataset:
for xform in self.xform.mergedxform.xforms.all():
MetaData.textit(xform, data_value=data_value)
def restore_object(self, attrs, instance=None):
data_type = attrs.get('data_type')
data_file = attrs.get('data_file')
xform = attrs.get('xform')
data_value = data_file.name if data_file else attrs.get('data_value')
data_file_type = data_file.content_type if data_file else None
if instance:
return super(MetaDataSerializer,
self).restore_object(attrs, instance)
return MetaData(data_type=data_type,
xform=xform,
data_value=data_value,
data_file=data_file,
data_file_type=data_file_type)
def update(self, instance, validated_data):
data_value = MetaData.textit(instance.xform) or ''
values = data_value.split(settings.METADATA_SEPARATOR)
if len(values) < 3:
values = ['', '', '']
xform = validated_data.get('xform', instance.xform)
auth_token = validated_data.get('auth_token', values[0])
flow_uuid = validated_data.get('flow_uuid', values[1])
contacts = validated_data.get('contacts', values[2])
name = validated_data.get('name', instance.name)
service_url = validated_data.get('service_url', instance.service_url)
instance = TextItService(xform, service_url, name, auth_token,
flow_uuid, contacts, instance.pk)
instance.save()
return instance
def update(self, instance, validated_data):
data_value = MetaData.textit(instance.xform) or ''
values = data_value.split(settings.METADATA_SEPARATOR)
if len(values) < 3:
values = ['', '', '']
xform = validated_data.get('xform', instance.xform)
auth_token = validated_data.get('auth_token', values[0])
flow_uuid = validated_data.get('flow_uuid', values[1])
contacts = validated_data.get('contacts', values[2])
name = validated_data.get('name', instance.name)
service_url = validated_data.get('service_url', instance.service_url)
instance = TextItService(xform, service_url, name, auth_token,
flow_uuid, contacts, instance.pk)
instance.save()
return instance
def test_role_update_xform_meta_perms(self):
alice_data = {'username': '******', 'email': '*****@*****.**'}
alice_profile = self._create_user_profile(alice_data)
EditorRole.add(alice_profile.user, self.xform)
view = MetaDataViewSet.as_view({
'post': 'create',
'put': 'update'
})
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minor|dataentry',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertFalse(
EditorRole.user_has_role(alice_profile.user, self.xform))
self.assertTrue(
EditorMinorRole.user_has_role(alice_profile.user, self.xform))
meta = MetaData.xform_meta_permission(self.xform)
DataEntryRole.add(alice_profile.user, self.xform)
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor|dataentry-only',
'xform': self.xform.pk
}
request = self.factory.put('/', data, **self.extra)
response = view(request, pk=meta.pk)
self.assertEqual(response.status_code, 200)
self.assertFalse(
DataEntryRole.user_has_role(alice_profile.user, self.xform))
self.assertTrue(
DataEntryOnlyRole.user_has_role(alice_profile.user, self.xform))
def test_role_update_xform_meta_perms(self):
alice_data = {'username': '******', 'email': '*****@*****.**'}
alice_profile = self._create_user_profile(alice_data)
EditorRole.add(alice_profile.user, self.xform)
view = MetaDataViewSet.as_view({
'post': 'create',
'put': 'update'
})
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minor|dataentry',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertFalse(
EditorRole.user_has_role(alice_profile.user, self.xform))
self.assertTrue(
EditorMinorRole.user_has_role(alice_profile.user, self.xform))
meta = MetaData.xform_meta_permission(self.xform)
DataEntryRole.add(alice_profile.user, self.xform)
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor|dataentry-only',
'xform': self.xform.pk
}
request = self.factory.put('/', data, **self.extra)
response = view(request, pk=meta.pk)
self.assertEqual(response.status_code, 200)
self.assertFalse(
DataEntryRole.user_has_role(alice_profile.user, self.xform))
self.assertTrue(
DataEntryOnlyRole.user_has_role(alice_profile.user, self.xform))
def test_external_export_list(self):
kwargs = {'username': self.user.username,
'id_string': self.xform.id_string,
'export_type': Export.EXTERNAL_EXPORT}
server = 'http://localhost:8080/xls/23fa4c38c0054748a984ffd89021a295'
data_value = 'template 1 |{0}'.format(server)
meta = MetaData.external_export(self.xform, data_value)
custom_params = {
'meta': meta.id,
}
url = reverse(export_list, kwargs=kwargs)
count = len(Export.objects.all())
response = self.client.get(url, custom_params)
self.assertEqual(response.status_code, 200)
count1 = len(Export.objects.all())
self.assertEquals(count + 1, count1)
def test_external_export_list(self):
kwargs = {'username': self.user.username,
'id_string': self.xform.id_string,
'export_type': Export.EXTERNAL_EXPORT}
server = 'http://localhost:8080/xls/23fa4c38c0054748a984ffd89021a295'
data_value = 'template 1 |{0}'.format(server)
meta = MetaData.external_export(self.xform, data_value)
custom_params = {
'meta': meta.id,
}
url = reverse(export_list, kwargs=kwargs)
count = len(Export.objects.all())
response = self.client.get(url, custom_params)
self.assertEqual(response.status_code, 200)
count1 = len(Export.objects.all())
self.assertEquals(count + 1, count1)
def retrieve(self):
"""
Sets the textit or rapidpro properties from the MetaData object.
The properties are:
- auth_token
- flow_uuid
- contacts
"""
data_value = MetaData.textit(self.xform)
try:
self.auth_token, self.flow_uuid, self.contacts = \
data_value.split(METADATA_SEPARATOR)
except ValueError:
raise serializers.ValidationError(
_("Error occurred when loading textit service."
"Resolve by updating auth_token, flow_uuid and contacts"
" fields"))
def restore_object(self, attrs, instance=None):
if instance:
meta = MetaData.textit(instance.xform)
values = meta.data_value.split(settings.METADATA_SEPARATOR)
if len(values) < 3:
values = ['', '', '']
xform = attrs.get('xform', instance.xform)
auth_token = attrs.get('auth_token', values[0])
flow_uuid = attrs.get('flow_uuid', values[1])
contacts = attrs.get('contacts', values[2])
name = attrs.get('name', instance.name)
service_url = attrs.get('service_url', instance.service_url)
return TextItService(xform, service_url, name, auth_token,
flow_uuid, contacts, instance.pk)
return TextItService(**attrs)
def test_xform_meta_perms_duplicates(self):
view = MetaDataViewSet.as_view({
'post': 'create',
'put': 'update'
})
ct = ContentType.objects.get_for_model(self.xform)
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minor|dataentry',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 201)
count = MetaData.objects.filter(data_type=XFORM_META_PERMS,
object_id=self.xform.pk,
content_type=ct.pk).count()
self.assertEqual(1, count)
data = {
'data_type': XFORM_META_PERMS,
'data_value': 'editor-minor|dataentry-only',
'xform': self.xform.pk
}
request = self.factory.post('/', data, **self.extra)
response = view(request)
self.assertEqual(response.status_code, 201)
count = MetaData.objects.filter(data_type=XFORM_META_PERMS,
object_id=self.xform.pk,
content_type=ct.pk).count()
self.assertEqual(1, count)
metadata = MetaData.xform_meta_permission(self.xform)
self.assertEqual(metadata.data_value, "editor-minor|dataentry-only")
def test_create_external_export_url(self):
self._publish_transportation_form()
self._submit_transport_instance()
num_exports = Export.objects.count()
server = 'http://localhost:8080/xls/23fa4c38c0054748a984ffd89021a295'
data_value = 'template 1 |{0}'.format(server)
meta = MetaData.external_export(self.xform, data_value)
custom_params = {
'meta': meta.id,
}
# create export
create_export_url = reverse(create_export, kwargs={
'username': self.user.username,
'id_string': self.xform.id_string,
'export_type': Export.EXTERNAL_EXPORT
})
response = self.client.post(create_export_url, custom_params)
self.assertEqual(response.status_code, 302)
self.assertEqual(Export.objects.count(), num_exports + 1)
def retrieve(self):
meta = MetaData.textit(self.xform)
self.auth_token, self.flow_uuid, self.contacts = \
meta.data_value.split(METADATA_SEPARATOR)
def _add_external_export_metadata(self, content_object):
MetaData.external_export(content_object,
"https://test/external/export")
