def test_kwargs_from_temba(self):
modified_date = timezone.now()
temba_contact = TembaContact.create(
uuid='C-007',
name="Jan",
urns=['tel:123'],
groups=['G-001', 'G-007'],
fields={
'gender': 'M',
},
language='eng',
modified_on=modified_date,
)
kwargs = models.Contact.kwargs_from_temba(self.unicef, temba_contact)
self.assertDictEqual(kwargs, {
'uuid': 'C-007',
'org': self.unicef,
'name': "Jan",
'urn': 'tel:123',
'region': self.region1,
'group': self.group3,
'language': 'eng',
'temba_modified_on': modified_date,
'_data_field_values': {
'gender': 'M',
},
})
# try creating contact from them
models.Contact.objects.create(**kwargs)
def test_temba_merge_contacts(self):
contact1 = TembaContact.create(uuid="000-001", name="Bob",
urns=['tel:123', 'email:[email protected]'],
fields=dict(chat_name="bob", age=23),
groups=['000-001', '000-002', '000-010'])
contact2 = TembaContact.create(uuid="000-001", name="Bobby",
urns=['tel:234', 'twitter:bob'],
fields=dict(chat_name="bobz", state='IN'),
groups=['000-003', '000-009', '000-011'])
merged = temba_merge_contacts(contact1, contact2, mutex_group_sets=(
('000-001', '000-002', '000-003'),
('000-008', '000-009'),
('000-098', '000-099'),
))
self.assertEqual(merged.uuid, '000-001')
self.assertEqual(merged.name, "Bob")
self.assertEqual(sorted(merged.urns), ['email:[email protected]', 'tel:123', 'twitter:bob'])
self.assertEqual(merged.fields, dict(chat_name="bob", age=23, state='IN'))
self.assertEqual(sorted(merged.groups), ['000-001', '000-009', '000-010', '000-011'])
def test_get_or_fetch(self, mock_get_contact):
mock_get_contact.return_value = TembaContact.create(
uuid='C-007', name="Mo Polls",
urns=['tel:078123'], groups=['G-001', 'G-005'],
fields={},
language='eng', modified_on=timezone.now())
# get locally
contact = models.Contact.get_or_fetch(self.unicef, 'C-001')
self.assertEqual(contact.name, "Ann")
# fetch remotely
contact = models.Contact.get_or_fetch(self.unicef, 'C-009')
self.assertEqual(contact.name, "Mo Polls")
def test_temba_compare_contacts(self):
# no differences
first = TembaContact.create(
uuid='000-001', name="Ann", urns=['tel:1234'], groups=['000-001'],
fields=dict(chat_name="ann"), language='eng', modified_on=timezone.now())
second = TembaContact.create(
uuid='000-001', name="Ann", urns=['tel:1234'], groups=['000-001'],
fields=dict(chat_name="ann"), language='eng', modified_on=timezone.now())
self.assertIsNone(temba_compare_contacts(first, second))
self.assertIsNone(temba_compare_contacts(second, first))
# different name
second = TembaContact.create(
uuid='000-001', name="Annie", urns=['tel:1234'], groups=['000-001'],
fields=dict(chat_name="ann"), language='eng', modified_on=timezone.now())
self.assertEqual(temba_compare_contacts(first, second), 'name')
# different URNs
second = TembaContact.create(
uuid='000-001', name="Ann", urns=['tel:1234', 'twitter:ann'], groups=['000-001'],
fields=dict(chat_name="ann"), language='eng', modified_on=timezone.now())
self.assertEqual(temba_compare_contacts(first, second), 'urns')
# different group
second = TembaContact.create(
uuid='000-001', name="Ann", urns=['tel:1234'], groups=['000-002'],
fields=dict(chat_name="ann"), language='eng', modified_on=timezone.now())
self.assertEqual(temba_compare_contacts(first, second), 'groups')
self.assertEqual(temba_compare_contacts(first, second, groups=('000-001', '000-002')),
'groups')
self.assertIsNone(temba_compare_contacts(first, second, groups=()))
self.assertIsNone(temba_compare_contacts(first, second, groups=('000-003', '000-004')))
# different field
second = TembaContact.create(
uuid='000-001', name="Ann", urns=['tel:1234'], groups=['000-001'],
fields=dict(chat_name="annie"), language='eng', modified_on=timezone.now())
self.assertEqual(temba_compare_contacts(first, second), 'fields')
self.assertEqual(temba_compare_contacts(first, second, fields=('chat_name', 'gender')),
'fields')
self.assertIsNone(temba_compare_contacts(first, second, fields=()))
self.assertIsNone(temba_compare_contacts(first, second, fields=('age', 'gender')))
# additional field
second = TembaContact.create(
uuid='000-001', name="Ann", urns=['tel:1234'], groups=['000-001'],
fields=dict(chat_name="ann", age=18), language='eng', modified_on=timezone.now())
self.assertEqual(temba_compare_contacts(first, second), 'fields')
self.assertIsNone(temba_compare_contacts(first, second, fields=()))
self.assertIsNone(temba_compare_contacts(first, second, fields=('chat_name',)))
def as_temba(self):
"""Return a Temba object representing this Contact."""
groups = [self.region.uuid]
if self.group_id:
groups.append(self.group.uuid)
fields = {f.field.key: f.get_value() for f in self.contactfield_set.all()}
temba_contact = TembaContact()
temba_contact.name = self.name
temba_contact.urns = [self.urn]
temba_contact.fields = fields
temba_contact.groups = groups
temba_contact.language = self.language
temba_contact.uuid = self.uuid
return temba_contact
def temba_merge_contacts(first, second, mutex_group_sets):
"""
Merges two Temba contacts, with priority given to the first contact
"""
if first.uuid != second.uuid: # pragma: no cover
raise ValueError("Can't merge contacts with different UUIDs")
# URNs are merged by scheme
first_urns_by_scheme = {u[0]: u[1] for u in [urn.split(':', 1) for urn in first.urns]}
urns_by_scheme = {u[0]: u[1] for u in [urn.split(':', 1) for urn in second.urns]}
urns_by_scheme.update(first_urns_by_scheme)
merged_urns = ['%s:%s' % (scheme, path) for scheme, path in six.iteritems(urns_by_scheme)]
# fields are simple key based merge
merged_fields = second.fields.copy()
merged_fields.update(first.fields)
# first merge mutually exclusive group sets
first_groups = list(first.groups)
second_groups = list(second.groups)
merged_mutex_groups = []
for group_set in mutex_group_sets:
from_first = intersection(first_groups, group_set)
if from_first:
merged_mutex_groups.append(from_first[0])
else:
from_second = intersection(second_groups, group_set)
if from_second:
merged_mutex_groups.append(from_second[0])
for group in group_set:
if group in first_groups:
first_groups.remove(group)
if group in second_groups:
second_groups.remove(group)
# then merge the remaining groups
merged_groups = merged_mutex_groups + union(first_groups, second_groups)
return TembaContact.create(uuid=first.uuid, name=first.name,
urns=merged_urns, fields=merged_fields, groups=merged_groups)
def test_create(self, mock_create_contact):
mock_create_contact.return_value = TembaContact.create(
uuid='C-007',
name="Mo Polls",
urns=['tel:078123'],
groups=['G-001', 'G-005'],
fields={},
language='eng',
modified_on=timezone.now(),
)
contact = factories.Contact(
name="Mo Polls",
org=self.unicef,
created_by=self.user1,
modified_by=self.user1,
urn="tel:078123",
region=self.region1,
group=self.group1,
language="eng",
)
self.assertEqual(contact.name, "Mo Polls")
self.assertEqual(contact.urn, 'tel:078123')
self.assertEqual(contact.region, self.region1)
self.assertEqual(contact.language, 'eng')
self.assertEqual(contact.created_by, self.user1)
self.assertIsNotNone(contact.created_on)
self.assertEqual(contact.modified_by, self.user1)
self.assertIsNotNone(contact.modified_on)
contact.push(ChangeType.created)
# reload and check UUID was updated by push task
contact.refresh_from_db()
self.assertEqual(contact.uuid, 'C-007')
self.assertEqual(mock_create_contact.call_count, 1)
def test_create(self):
url = reverse('contacts.contact_create')
# log in as an org administrator
self.login(self.admin)
response = self.url_get('unicef', url)
self.assertEqual(response.status_code, 200)
# submit with no fields entered
response = self.url_post('unicef', url, dict())
self.assertEqual(response.status_code, 200)
form = response.context['form']
self.assertEqual(len(form.errors), 4, form.errors)
self.assertFormError(response, 'form', 'name', 'This field is required.')
self.assertFormError(response, 'form', 'urn', 'This field is required.')
self.assertFormError(response, 'form', 'region', 'This field is required.')
self.assertFormError(response, 'form', 'group', 'This field is required.')
# submit again with all fields
temba_contact = TembaContact()
temba_contact.uuid = "uuid"
self.mock_temba_client.create_contact.return_value = temba_contact
response = self.url_post('unicef', url, {
'name': "Mo Polls",
'urn_0': "tel",
'urn_1': "5678",
'region': self.region1.pk,
'group': self.group1.pk,
'language': 'eng',
})
self.assertEqual(response.status_code, 302)
self.assertEqual(self.mock_temba_client.create_contact.call_count, 1)
# check new contact and profile
contact = Contact.objects.get(urn='tel:5678')
self.assertEqual(contact.name, "Mo Polls")
self.assertEqual(contact.region, self.region1)
self.assertEqual(contact.group, self.group1)
self.assertEqual(contact.language, 'eng')
# log in as a user
self.login(self.user1)
# try to create contact in region we don't have access to
response = self.url_post('unicef', url, {
'name': "Mo Polls II",
'urn_0': "tel",
'urn_1': "5678",
'region': self.region3.pk,
'group': self.group1.pk,
})
self.assertFormError(response, 'form', 'region',
"Select a valid choice. That choice is not one "
"of the available choices.")
# try again but this time in a region we do have access to
response = self.url_post('unicef', url, {
'name': "Mo Polls II",
'urn_0': "tel",
'urn_1': "5678",
'region': self.region1.pk,
'group': self.group1.pk,
})
self.assertEqual(response.status_code, 302)
# test ajax querying for languages
response = self.url_get('unicef', '%s?initial=' % url)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), dict(results=[]))
response = self.url_get('unicef', '%s?initial=eng' % url)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content),
dict(results=[dict(id='eng', text='English')]))
response = self.url_get('unicef', '%s?search=' % url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(json.loads(response.content)['results']), 10)
response = self.url_get('unicef', '%s?search=Kin' % url)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content),
dict(results=[dict(id='kin', text='Kinyarwanda')]))
