def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.project = ProjectFactory.create(slug='test-project')
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(project=self.project,
dict=individual_party_xform_group,
content_type=content_type,
errors=[])
create_attrs_schema(project=self.project,
dict=default_party_xform_group,
content_type=content_type,
errors=[])
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(project=self.project,
dict=tenure_relationship_xform_group,
content_type=content_type,
errors=[])
self.su = SpatialUnitFactory.create(project=self.project, type='CB')
self.party = PartyFactory.create(project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
})
self.tenure_rel = TenureRelationshipFactory.create(
spatial_unit=self.su,
party=self.party,
project=self.project,
attributes={'notes': 'PBS is the best.'})
self.resource = ResourceFactory.create(project=self.project)
self.results = get_fake_es_api_results(self.project, self.su,
self.party, self.tenure_rel,
self.resource)
self.proj_result = self.results['hits']['hits'][0]
self.su_result = self.results['hits']['hits'][1]
self.party_result = self.results['hits']['hits'][2]
self.tenure_rel_result = self.results['hits']['hits'][3]
self.resource_result = self.results['hits']['hits'][4]
self.query = 'searching'
self.query_body = {
'query': {
'simple_query_string': {
'default_operator': 'and',
'query': self.query,
}
}
}
self.es_endpoint = '{}/project-{}/_search'.format(
api_url, self.project.id)
self.es_body = json.dumps(self.query_body, sort_keys=True)
def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.project = ProjectFactory.create(slug='test-project')
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(
app_label='party', model='party')
create_attrs_schema(
project=self.project, dict=individual_party_xform_group,
content_type=content_type, errors=[])
create_attrs_schema(
project=self.project, dict=default_party_xform_group,
content_type=content_type, errors=[])
content_type = ContentType.objects.get(
app_label='party', model='tenurerelationship')
create_attrs_schema(
project=self.project, dict=tenure_relationship_xform_group,
content_type=content_type, errors=[])
self.su = SpatialUnitFactory.create(project=self.project, type='CB')
self.party = PartyFactory.create(
project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
})
self.tenure_rel = TenureRelationshipFactory.create(
spatial_unit=self.su, party=self.party, project=self.project,
attributes={'notes': 'PBS is the best.'})
self.resource = ResourceFactory.create(project=self.project)
self.results = get_fake_es_api_results(
self.project, self.su, self.party, self.tenure_rel, self.resource)
self.proj_result = self.results['hits']['hits'][0]
self.su_result = self.results['hits']['hits'][1]
self.party_result = self.results['hits']['hits'][2]
self.tenure_rel_result = self.results['hits']['hits'][3]
self.resource_result = self.results['hits']['hits'][4]
self.query = 'searching'
self.query_body = {
'query': {
'simple_query_string': {
'default_operator': 'and',
'query': self.query,
}
},
'from': 10,
'size': 20,
'sort': {'_score': {'order': 'desc'}},
}
self.es_endpoint = '{}/project-{}/_search/'.format(api_url,
self.project.id)
self.es_body = json.dumps(self.query_body, sort_keys=True)
def test_form_not_current_questionnaire(self):
# update the default form to a new version
QuestionnaireFactory.create(
project=self.prj,
xls_form=get_form('test_standard_questionnaire'),
filename='test_standard_questionnaire_updated',
id_string='test_standard_questionnaire',
version=20160727122111
)
data = self._submission(form='form')
response = self.request(method='POST', post_data=data,
user=self.user,
content_type='multipart/form-data')
msg = self._getResponseMessage(response)
assert msg == 'Form out of date'
def test_delete_questionnaire(self):
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(
project=project,
xls_form=self._get_form('xls-form'))
data = {
'name': 'New name',
'questionnaire': '',
'access': project.access,
'contacts-TOTAL_FORMS': 1,
'contacts-INITIAL_FORMS': 0,
'contacts-0-name': '',
'contacts-0-email': '',
'contacts-0-tel': ''
}
form = forms.ProjectEditDetails(
instance=project,
data=data,
initial={'questionnaire': questionnaire.xls_form.url})
form.save()
project.refresh_from_db()
assert project.name == data['name']
assert not project.current_questionnaire
def test_do_not_send_questionnaire_when_project_has_data(self):
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(
project=project,
xls_form=self._get_form('xls-form'))
SpatialUnitFactory.create(project=project)
data = {
'name': 'New name',
'access': project.access,
'contacts-TOTAL_FORMS': 1,
'contacts-INITIAL_FORMS': 0,
'contacts-0-name': '',
'contacts-0-email': '',
'contacts-0-tel': ''
}
form = forms.ProjectEditDetails(
instance=project,
data=data,
initial={'questionnaire': questionnaire.xls_form.url})
assert form.is_valid() is True
form.save()
project.refresh_from_db()
assert project.name == data['name']
assert project.current_questionnaire == questionnaire.id
def test_replace_questionnaire_when_project_has_data(self):
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(
project=project,
xls_form=self._get_form('xls-form'))
SpatialUnitFactory.create(project=project)
data = {
'name': 'New name',
'questionnaire': self._get_form('xls-form-copy'),
'access': project.access,
'contacts-TOTAL_FORMS': 1,
'contacts-INITIAL_FORMS': 0,
'contacts-0-name': '',
'contacts-0-email': '',
'contacts-0-tel': ''
}
form = forms.ProjectEditDetails(
instance=project,
data=data,
initial={'questionnaire': questionnaire.xls_form.url})
assert form.is_valid() is False
assert ("Data has already been contributed to this project. To "
"ensure data integrity, uploading a new questionnaire is "
"disabled for this project." in
form.errors.get('questionnaire'))
def test_save_new_party_with_attributes(self):
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(project=project)
spatial_unit = SpatialUnitFactory.create(project=project)
content_type = ContentType.objects.get(
app_label='party', model='tenurerelationship')
schema = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, ))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(
schema=schema,
name='r_name', long_name='Relationship field',
attr_type=attr_type, index=0,
required=False, omit=False
)
content_type = ContentType.objects.get(
app_label='party', model='party')
schema_gr = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, 'GR'))
Attribute.objects.create(
schema=schema_gr,
name='p_gr_name', long_name='Party GR field',
attr_type=attr_type, index=0,
required=True, omit=False
)
form = forms.TenureRelationshipForm(
project=project,
spatial_unit=spatial_unit,
data={'new_entity': 'on',
'id': '',
'name': 'The Beatles',
'party::gr::p_gr_name': 'Party Group Name',
'party_type': 'GR',
'tenure_type': 'CU',
'tenurerelationship::default::r_name': 'Rel Name'})
assert form.is_valid()
form.save()
assert Party.objects.count() == 1
party = Party.objects.first()
assert party.name == 'The Beatles'
assert party.type == 'GR'
assert party.attributes.get('p_gr_name') == 'Party Group Name'
assert TenureRelationship.objects.count() == 1
rel = TenureRelationship.objects.first()
assert rel.party == party
assert rel.spatial_unit == spatial_unit
assert rel.tenure_type_id == 'CU'
assert rel.attributes.get('r_name') == 'Rel Name'
def test_clean_with_existing_party(self):
project = ProjectFactory.create()
party = PartyFactory.create(project=project)
questionnaire = QuestionnaireFactory.create(project=project)
spatial_unit = SpatialUnitFactory.create(project=project)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
schema = Schema.objects.create(content_type=content_type,
selectors=(
project.organization.id,
project.id,
questionnaire.id,
))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(schema=schema,
name='r_name',
long_name='Relationship field',
attr_type=attr_type,
index=0,
required=False,
omit=False)
content_type = ContentType.objects.get(app_label='party',
model='party')
schema_in = Schema.objects.create(content_type=content_type,
selectors=(project.organization.id,
project.id,
questionnaire.id, 'IN'))
Attribute.objects.create(schema=schema_in,
name='p_in_name',
long_name='Party IN field',
attr_type=attr_type,
index=0,
required=True,
omit=False)
schema_gr = Schema.objects.create(content_type=content_type,
selectors=(project.organization.id,
project.id,
questionnaire.id, 'GR'))
Attribute.objects.create(schema=schema_gr,
name='p_gr_name',
long_name='Party GR field',
attr_type=attr_type,
index=0,
required=True,
omit=False)
form = forms.TenureRelationshipForm(project=project,
spatial_unit=spatial_unit,
data={
'new_entity': '',
'id': party.id,
'tenure_type': 'CU'
})
assert form.is_valid()
form.save()
def _get_questionnaire(self, id=None, version=None):
form = get_form('xls-form')
kwargs = {'project': self.prj, 'xls_form': form}
if id:
kwargs.update({'id_string': id})
if version:
kwargs.update({'version': version})
return QuestionnaireFactory.create(**kwargs)
def _get_questionnaire(self, id=None, version=None):
form = self.get_form('xls-form')
kwargs = {'project': self.prj, 'xls_form': form}
if id:
kwargs.update({'id_string': id})
if version:
kwargs.update({'version': version})
return QuestionnaireFactory.create(**kwargs)
def setUp(self):
super().setUp()
self.project = ProjectFactory.create()
QuestionnaireFactory.create(project=self.project)
ATTR_TYPE_IDS = get_attr_type_ids()
content_type = ContentType.objects.get(app_label='spatial',
model='spatialunit')
create_attrs_schema(
project=self.project,
question_group_dict=attr_schemas.location_xform_group,
content_type=content_type,
attr_type_ids=ATTR_TYPE_IDS,
)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(
project=self.project,
question_group_dict=attr_schemas.default_party_xform_group,
content_type=content_type,
attr_type_ids=ATTR_TYPE_IDS,
)
create_attrs_schema(
project=self.project,
question_group_dict=attr_schemas.individual_party_xform_group,
content_type=content_type,
attr_type_ids=ATTR_TYPE_IDS,
)
create_attrs_schema(
project=self.project,
question_group_dict=attr_schemas.group_party_attributes,
content_type=content_type,
attr_type_ids=ATTR_TYPE_IDS,
)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(
project=self.project,
question_group_dict=attr_schemas.tenure_relationship_xform_group,
content_type=content_type,
attr_type_ids=ATTR_TYPE_IDS,
)
def test_get_with_authorized_user_include_questionnaire(self):
questionnaire = QuestionnaireFactory.create(project=self.project)
user = UserFactory.create()
assign_policies(user)
response = self.request(user=user)
form = forms.ProjectEditDetails(
instance=self.project,
initial={'questionnaire': questionnaire.xls_form.url})
assert response.status_code == 200
assert response.content == self.render_content(form=form)
def test_clean(self):
data = {
'name': 'Cadasta',
'type': 'IN',
'party::in::fname': 'test',
'party::in::homeowner': True
}
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(project=project)
content_type = ContentType.objects.get(
app_label='party', model='party')
schema = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, ))
Attribute.objects.create(
schema=schema,
name='fname',
long_name='Test field',
attr_type=AttributeType.objects.get(name='text'),
index=0, required=False
)
schema_in = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, 'IN'))
Attribute.objects.create(
schema=schema_in,
name='homeowner',
long_name='Homeowner',
attr_type=AttributeType.objects.get(name='boolean'),
index=1, required=True
)
schema_gr = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, 'GR'))
Attribute.objects.create(
schema=schema_gr,
name='group_name',
long_name='Test field',
attr_type=AttributeType.objects.get(name='text'),
index=1, required=True
)
form = forms.PartyForm(project=project, data=data)
assert form.is_valid()
form.save()
assert Party.objects.filter(project=project).count() == 1
party = Party.objects.filter(project=project).first()
assert party.attributes.get('fname') == 'test'
assert party.attributes.get('homeowner')
def _create_questionnaire(self, questionnaire_name, version, schema=True):
questionnaire = QuestionnaireFactory.create(
project=self.prj,
xls_form=get_form(questionnaire_name),
filename=questionnaire_name,
id_string=questionnaire_name,
version=(20160727122110 + version))
if schema:
self._create_attrs_schema(self.prj)
return questionnaire
def setUp(self):
super().setUp()
PolicyFactory.load_policies()
create_attribute_types()
loadattrtypes.Command().handle(force=True)
load_tenure_relationship_types(force=True)
self.user = UserFactory.create()
self.project = ProjectFactory.create(current_questionnaire='a1')
self.questionnaire = QuestionnaireFactory.create(id_string='a1',
version=0,
project=self.project,
id='a1')
QuestionFactory.create(name='location_geometry',
label='Location of Parcel',
type='GS',
questionnaire=self.questionnaire)
content_type_party = ContentType.objects.get(app_label='party',
model='party')
content_type_spatial = ContentType.objects.get(app_label='spatial',
model='spatialunit')
content_type_tenure = ContentType.objects.get(
app_label='party', model='tenurerelationship')
for content_type in [
content_type_party, content_type_tenure, content_type_spatial
]:
schema = Schema.objects.create(
content_type=content_type,
selectors=(self.project.organization.id, self.project.id,
'a1'))
attr_type = AttributeType.objects.get(name='boolean')
Attribute.objects.create(schema=schema,
name='fname',
long_name='True or False',
attr_type=attr_type,
index=0,
required=False,
omit=False)
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(schema=schema,
name='fname_two',
long_name='Notes',
attr_type=attr_type,
index=1,
required=False,
omit=False)
OrganizationRole.objects.create(user=self.user,
organization=self.project.organization)
def _create_questionnaire(self, questionnaire_name, version,
schema=True):
questionnaire = QuestionnaireFactory.create(
project=self.prj,
xls_form=self.get_form(questionnaire_name),
filename=questionnaire_name,
id_string=questionnaire_name,
version=(20160727122110 + version))
if schema:
self._create_attrs_schema(self.prj)
return questionnaire
def test_clean_with_existing_party(self):
project = ProjectFactory.create()
party = PartyFactory.create(project=project)
questionnaire = QuestionnaireFactory.create(project=project)
spatial_unit = SpatialUnitFactory.create(project=project)
content_type = ContentType.objects.get(
app_label='party', model='tenurerelationship')
schema = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, ))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(
schema=schema,
name='r_name', long_name='Relationship field',
attr_type=attr_type, index=0,
required=False, omit=False
)
content_type = ContentType.objects.get(
app_label='party', model='party')
schema_in = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, 'IN'))
Attribute.objects.create(
schema=schema_in,
name='p_in_name', long_name='Party IN field',
attr_type=attr_type, index=0,
required=True, omit=False
)
schema_gr = Schema.objects.create(
content_type=content_type,
selectors=(
project.organization.id, project.id, questionnaire.id, 'GR'))
Attribute.objects.create(
schema=schema_gr,
name='p_gr_name', long_name='Party GR field',
attr_type=attr_type, index=0,
required=True, omit=False
)
form = forms.TenureRelationshipForm(project=project,
spatial_unit=spatial_unit,
data={'new_entity': '',
'id': party.id,
'tenure_type': 'CU'})
assert form.is_valid()
form.save()
def setup_models(self):
clause = {
'clause': [{
'effect': 'allow',
'object': ['project/*/*'],
'action': ['questionnaire.*']
}]
}
policy = Policy.objects.create(name='test-policy',
body=json.dumps(clause))
self.user = UserFactory.create()
self.user.assign_policies(policy)
self.questionnaire = QuestionnaireFactory.create()
def setUp(self):
super().setUp()
PolicyFactory.load_policies()
create_attribute_types()
loadattrtypes.Command().handle(force=True)
load_tenure_relationship_types(force=True)
self.user = UserFactory.create()
self.project = ProjectFactory.create(
current_questionnaire='a1')
self.questionnaire = QuestionnaireFactory.create(
id_string='a1', version=0, project=self.project, id='a1')
QuestionFactory.create(
name='location_geometry',
label='Location of Parcel',
type='GS',
questionnaire=self.questionnaire)
content_type_party = ContentType.objects.get(
app_label='party', model='party')
content_type_spatial = ContentType.objects.get(
app_label='spatial', model='spatialunit')
content_type_tenure = ContentType.objects.get(
app_label='party', model='tenurerelationship')
for content_type in [content_type_party, content_type_tenure,
content_type_spatial]:
schema = Schema.objects.create(
content_type=content_type,
selectors=(self.project.organization.id, self.project.id, 'a1')
)
attr_type = AttributeType.objects.get(name='boolean')
Attribute.objects.create(
schema=schema,
name='fname', long_name='True or False',
attr_type=attr_type, index=0,
required=False, omit=False
)
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(
schema=schema,
name='fname_two', long_name='Notes',
attr_type=attr_type, index=1,
required=False, omit=False
)
OrganizationRole.objects.create(
user=self.user, organization=self.project.organization)
def setup_models(self):
clause = {
'clause': [
{
'effect': 'allow',
'object': ['project/*/*'],
'action': ['questionnaire.*']
}
]
}
policy = Policy.objects.create(
name='test-policy',
body=json.dumps(clause))
self.user = UserFactory.create()
self.user.assign_policies(policy)
self.questionnaire = QuestionnaireFactory.create()
def setup_models(self):
self.project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='spatial',
model='spatialunit')
schema = Schema.objects.create(content_type=content_type,
selectors=(self.project.organization.id,
self.project.id,
questionnaire.id))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(schema=schema,
name='fname',
long_name='Test field',
attr_type=attr_type,
index=0,
required=False,
omit=False)
def setup_models(self):
self.project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(project=self.project)
self.spatial_unit = SpatialUnitFactory(project=self.project)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
schema = Schema.objects.create(content_type=content_type,
selectors=(self.project.organization.id,
self.project.id,
questionnaire.id))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(schema=schema,
name='r_name',
long_name='Relationship field',
attr_type=attr_type,
index=0,
required=False,
omit=False)
content_type = ContentType.objects.get(app_label='party',
model='party')
schema = Schema.objects.create(content_type=content_type,
selectors=(self.project.organization.id,
self.project.id,
questionnaire.id))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(schema=schema,
name='p_name',
long_name='Party field',
attr_type=attr_type,
index=0,
required=False,
omit=False)
schema = Schema.objects.create(content_type=content_type,
selectors=(self.project.organization.id,
self.project.id,
questionnaire.id, 'GR'))
Attribute.objects.create(schema=schema,
name='p_gr_name',
long_name='Party Group field',
attr_type=attr_type,
index=0,
required=False,
omit=False)
def test_repr(self):
user = UserFactory.build(username='******')
questionnaire = QuestionnaireFactory(title='questions')
json = {'key': 'value'}
instanceID = '19f004e7-d16f-49d0-abcc-a73762c6d102'
submission = XFormSubmission(id='abc123',
user=user,
questionnaire=questionnaire,
instanceID=instanceID,
json_submission=json)
assert repr(submission) == ('<XFormSubmission id=abc123 user=john'
' questionnaire=questions'
' json_submission={json}'
' instanceID={instance}'
' spatial_units=[]'
' parties=[]'
' tenure_relationships=[]>'
).format(json=dumps(json),
instance=instanceID)
def test_delete_questionnaire(self):
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(project=project, xls_form=self._get_form("xls-form"))
data = {
"name": "New name",
"questionnaire": "",
"access": project.access,
"contacts-TOTAL_FORMS": 1,
"contacts-INITIAL_FORMS": 0,
"contacts-0-name": "",
"contacts-0-email": "",
"contacts-0-tel": "",
}
form = forms.ProjectEditDetails(
instance=project, data=data, initial={"questionnaire": questionnaire.xls_form.url}
)
form.save()
project.refresh_from_db()
assert project.name == data["name"]
assert not project.current_questionnaire
def test_sanitize_string(self):
project = ProjectFactory.create()
questionnaire = QuestionnaireFactory.create(project=project)
spatial_unit = SpatialUnitFactory.create(project=project)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
schema = Schema.objects.create(content_type=content_type,
selectors=(
project.organization.id,
project.id,
questionnaire.id,
))
attr_type = AttributeType.objects.get(name='text')
Attribute.objects.create(schema=schema,
name='r_name',
long_name='Relationship field',
attr_type=attr_type,
index=0,
required=False,
omit=False)
form = forms.TenureRelationshipForm(
project=project,
spatial_unit=spatial_unit,
data={
'new_entity': 'on',
'id': '',
'name': '<The Beatles>',
'party_type': 'GR',
'tenure_type': 'CU',
'tenurerelationship::default::r_name': '<RName>'
})
assert form.is_valid() is False
assert form.errors['name'] is not None
assert form.errors['tenurerelationship::default::r_name'] is not None
def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.project = ProjectFactory.create(slug='test-project')
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(
project=self.project,
dict=attr_schemas.individual_party_xform_group,
content_type=content_type,
)
create_attrs_schema(
project=self.project,
dict=attr_schemas.default_party_xform_group,
content_type=content_type,
)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(
project=self.project,
dict=attr_schemas.tenure_relationship_xform_group,
content_type=content_type,
)
self.su = SpatialUnitFactory.create(project=self.project, type='CB')
self.party = PartyFactory.create(project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
})
self.tenure_rel = TenureRelationshipFactory.create(
spatial_unit=self.su,
party=self.party,
project=self.project,
attributes={'notes': 'PBS is the best.'})
self.resource = ResourceFactory.create(project=self.project)
self.results = get_fake_es_api_results(self.project, self.su,
self.party, self.tenure_rel,
self.resource)
self.proj_result = self.results['hits']['hits'][0]
self.su_result = self.results['hits']['hits'][1]
self.party_result = self.results['hits']['hits'][2]
self.tenure_rel_result = self.results['hits']['hits'][3]
self.resource_result = self.results['hits']['hits'][4]
self.query = 'searching'
self.query_body = {
'query': parse_query(self.query),
'from': 10,
'size': 20,
'sort': {
'_score': {
'order': 'desc'
}
},
}
url = '{}/project-{}/spatial,party,resource/_search/'
self.es_endpoint = url.format(api_url, self.project.id)
self.es_body = json.dumps(self.query_body, sort_keys=True)
def setup_data(self):
self.project = ProjectFactory.create()
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='spatial',
model='spatialunit')
create_attrs_schema(
project=self.project,
dict=attr_schemas.location_xform_group,
content_type=content_type,
)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(
project=self.project,
dict=attr_schemas.default_party_xform_group,
content_type=content_type,
)
create_attrs_schema(
project=self.project,
dict=attr_schemas.individual_party_xform_group,
content_type=content_type,
)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(
project=self.project,
dict=attr_schemas.tenure_relationship_xform_group,
content_type=content_type,
)
self.location = SpatialUnitFactory.create(
project=self.project,
geometry='SRID=4326;POINT(1 1)',
attributes={
'quality': 'point',
'infrastructure': 'food',
},
)
self.party = PartyFactory.create(
project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
},
)
self.tenure_rel = TenureRelationshipFactory.create(
project=self.project,
spatial_unit=self.location,
party=self.party,
attributes={'notes': 'The best relationship!'},
)
self.resource = ResourceFactory.create(project=self.project)
self.location_raw_result = {
'id': self.location.id,
'type': self.location.type,
'geometry': {
'type': 'geometry',
'value': '0101000020E6100000000000000000F03F000000000000F03F',
},
'attributes': {
'type': 'jsonb',
'value': '{"infrastructure": "food", "quality": "point"}',
},
'@timestamp': '2017-01-01T01:23:45.678Z',
}
self.party_raw_result = {
'id': self.party.id,
'name': self.party.name,
'type': 'IN',
'attributes': {
'type':
'jsonb',
'value': ('{"dob": "1951-05-05",'
' "gender": "m",'
' "homeowner": "yes"}'),
},
'tenure_id': None,
'tenure_attributes': None,
'tenure_partyid': None,
'spatial_unit_id': None,
'tenure_type_id': None,
'@timestamp': '2017-01-01T01:23:45.678Z',
}
self.tenure_rel_raw_result = {
'id': self.party.id,
'name': self.party.name,
'type': 'IN',
'attributes': {
'type':
'jsonb',
'value': ('{"dob": "1951-05-05",'
' "gender": "m",'
' "homeowner": "yes"}'),
},
'tenure_id': self.tenure_rel.id,
'tenure_attributes': {
'type': 'jsonb',
'value': '{"notes": "The best relationship!"}',
},
'tenure_partyid': self.party.id,
'spatial_unit_id': self.location.id,
'tenure_type_id': self.tenure_rel.tenure_type.id,
'@timestamp': '2017-01-01T01:23:45.678Z',
}
self.resource_raw_result = {
'id': self.resource.id,
'name': self.resource.name,
'description': self.resource.description,
'file': 'http://*****:*****@timestamp': '2017-01-01T01:23:45.678Z',
}
def setup_models(self):
self.user = UserFactory.create()
self.org = OrganizationFactory.create()
self.prj = ProjectFactory.create(organization=self.org)
self.prj_2 = ProjectFactory.create(organization=self.org)
self.prj_3 = ProjectFactory.create(organization=self.org)
OrganizationRole.objects.create(
organization=self.org, user=self.user, admin=True)
QuestionnaireFactory.create(
project=self.prj,
xls_form=get_form('test_standard_questionnaire'),
filename='test_standard_questionnaire',
id_string='test_standard_questionnaire',
version=20160727122110)
questionnaire = QuestionnaireFactory.create(
project=self.prj_2,
xls_form=get_form('test_standard_questionnaire_2'),
filename='test_standard_questionnaire_2',
id_string='test_standard_questionnaire_2',
version=20160727122111)
QuestionFactory.create(
name='location_geometry',
label='Location of Parcel',
type='GS',
questionnaire=questionnaire)
QuestionnaireFactory.create(
project=self.prj_3,
xls_form=get_form('test_standard_questionnaire_bad'),
filename='test_standard_questionnaire_bad',
id_string='test_standard_questionnaire_bad',
version=20160727122112)
# project 1
create_attrs_schema(
project=self.prj, dict=default_party_xform_group,
content_type=ContentType.objects.get(
app_label='party', model='party'), errors=[])
create_attrs_schema(
project=self.prj, dict=individual_party_xform_group,
content_type=ContentType.objects.get(
app_label='party', model='party'), errors=[])
create_attrs_schema(
project=self.prj, dict=location_xform_group,
content_type=ContentType.objects.get(
app_label='spatial', model='spatialunit'), errors=[])
create_attrs_schema(
project=self.prj, dict=tenure_relationship_xform_group,
content_type=ContentType.objects.get(
app_label='party', model='tenurerelationship'), errors=[])
# project 2
create_attrs_schema(
project=self.prj_2, dict=default_party_xform_group,
content_type=ContentType.objects.get(
app_label='party', model='party'), errors=[])
create_attrs_schema(
project=self.prj_2, dict=individual_party_xform_group,
content_type=ContentType.objects.get(
app_label='party', model='party'), errors=[])
create_attrs_schema(
project=self.prj_2, dict=location_xform_group,
content_type=ContentType.objects.get(
app_label='spatial', model='spatialunit'), errors=[])
create_attrs_schema(
project=self.prj_2, dict=tenure_relationship_xform_group,
content_type=ContentType.objects.get(
app_label='party', model='tenurerelationship'), errors=[])
