def test_relations_brick01(self):
user = self.login()
create_contact = partial(FakeContact.objects.create, user=user)
atom = create_contact(first_name='Atom', last_name='Tenma')
tenma = create_contact(first_name='Dr', last_name='Tenma')
uran = create_contact(first_name='Uran', last_name='Ochanomizu')
rtype1 = RelationType.create(
('test-subject_son', 'is the son of'),
('test-object_father', 'is the father of'))[0]
Relation.objects.create(subject_entity=atom,
type=rtype1,
object_entity=tenma,
user=user)
rtype2 = RelationType.create(
('test-subject_brother', 'is the brother of'),
('test-object_sister', 'is the sister of'))[0]
Relation.objects.create(subject_entity=atom,
type=rtype2,
object_entity=uran,
user=user)
response = self.assertGET200(atom.get_absolute_url())
self.assertTemplateUsed(response, 'creme_core/bricks/relations.html')
document = self.get_html_tree(response.content)
brick_node = self.get_brick_node(document, RelationsBrick.id_)
self.assertInstanceLink(brick_node, tenma)
self.assertInstanceLink(brick_node, uran)
self.assertEqual('{}',
brick_node.attrib.get('data-brick-reloading-info'))
def test_converted_relations(self):
self.login()
from ..registry import relationtype_converter
self.assertEqual(0, Relation.objects.count())
quote, source, target = self.create_quote_n_orgas('My Quote')
rtype1, rtype2 = RelationType.create(
('test-CONVERT-subject_foobar', 'is loving', [Quote]),
('test-CONVERT-object_foobar', 'is loved by', [Organisation]),
)
rtype3, rtype4 = RelationType.create(
('test-CONVERT-subject_foobar_not_copiable', 'is loving',
[Invoice]),
('test-CONVERT-object_foobar_not_copiable', 'is loved by',
[Organisation]),
)
relationtype_converter.register(Quote, rtype1, Invoice, rtype3)
Relation.objects.create(user=self.user,
type=rtype1,
subject_entity=quote,
object_entity=source)
self.assertEqual(1, Relation.objects.filter(type=rtype1).count())
self.assertEqual(1, Relation.objects.filter(type=rtype2).count())
self.assertEqual(0, Relation.objects.filter(type=rtype3).count())
self.assertEqual(0, Relation.objects.filter(type=rtype4).count())
self._convert(200, quote, 'invoice')
self.assertEqual(1, Relation.objects.filter(type=rtype1).count())
self.assertEqual(1, Relation.objects.filter(type=rtype2).count())
self.assertEqual(1, Relation.objects.filter(type=rtype3).count())
self.assertEqual(1, Relation.objects.filter(type=rtype4).count())
def test_relationship(self):
constraint = GHCCRelation(model=FakeContact)
rtype1 = RelationType.create(
('test-subject_likes', 'likes'),
('test-object_likes', 'is liked by'),
)[0]
self.assertTrue(
constraint.check_cell(EntityCellRelation(FakeContact, rtype1)))
rtype2 = RelationType.create(
('test-subject_loves', 'is loving', [FakeContact]),
('test-object_loves', 'is loved by', [FakeContact]),
)[0]
self.assertTrue(
constraint.check_cell(EntityCellRelation(FakeContact, rtype2)))
rtype3 = RelationType.create(
('test-subject_branch', 'has branch', [FakeOrganisation]),
('test-object_branch', 'is a branch of', [FakeOrganisation]),
)[0]
self.assertFalse(
constraint.check_cell(EntityCellRelation(FakeContact, rtype3)))
# ---
cell1 = constraint.get_cell(cell_key=f'relation-{rtype2.id}')
self.assertIsInstance(cell1, EntityCellRelation)
self.assertEqual(rtype2, cell1.relation_type)
self.assertIsNone(
constraint.get_cell(cell_key=f'relation-{rtype3.id}'))
# ---
cells = [*constraint.cells()]
self.assertGreaterEqual(len(cells), 2)
self.assertIsInstance(cells[0], EntityCellRelation)
def find_cell(rtype):
for cell in cells:
if cell.relation_type == rtype:
return
self.fail(f'{rtype} not found in cells.')
find_cell(rtype1)
find_cell(rtype2)
for cell in cells:
if cell.relation_type == rtype3:
self.fail(f'{rtype3} should not be found in cells.')
def test_edit02(self):
"Edit a custom type"
rt = RelationType.create(('test-subfoo', 'subject_predicate'),
('test-objfoo', 'object_predicate'),
is_custom=True)[0]
url = self._build_edit_url(rt)
response = self.assertGET200(url)
# self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit_popup.html')
self.assertTemplateUsed(
response, 'creme_core/generics/blockform/edit-popup.html')
context = response.context
# self.assertEqual(_('Edit the type «{predicate}»').format(predicate=rt),
self.assertEqual(
pgettext('creme_config-relationship',
'Edit the type «{object}»').format(object=rt),
context.get('title'))
self.assertEqual(_('Save the modifications'),
context.get('submit_label'))
# ---
subject_pred = 'loves'
object_pred = 'is loved by'
response = self.client.post(url,
data={
'subject_predicate': subject_pred,
'object_predicate': object_pred,
})
self.assertNoFormError(response)
rel_type = RelationType.objects.get(pk=rt.id)
self.assertEqual(subject_pred, rel_type.predicate)
self.assertEqual(object_pred, rel_type.symmetric_type.predicate)
def test_manager_safe_multi_save02(self):
"De-duplicates arguments"
rtype = RelationType.create(
('test-subject_foobar', 'challenges'),
('test-object_foobar', 'is challenged by'))[0]
user = self.user
create_contact = partial(FakeContact.objects.create, user=user)
ryuko = create_contact(first_name='Ryuko', last_name='Matoi')
satsuki = create_contact(first_name='Satsuki', last_name='Kiryuin')
def build_rel():
return Relation(user=user,
subject_entity=ryuko,
type=rtype,
object_entity=satsuki)
with self.assertNoException():
count = Relation.objects.safe_multi_save(
[build_rel(), build_rel()])
rel = self.get_object_or_fail(Relation, type=rtype)
self.assertEqual(ryuko.id, rel.subject_entity_id)
self.assertEqual(satsuki.id, rel.object_entity_id)
self.assertEqual(user.id, rel.user_id)
self.assertEqual(1, count)
def test_relation01(self):
subject_pred = 'is loving'
object_pred = 'is loved by'
with self.assertNoException():
rtype1, rtype2 = RelationType.create(
('test-subject_foobar', subject_pred),
('test-object_foobar', object_pred))
self.assertEqual(rtype1.symmetric_type, rtype2)
self.assertEqual(rtype2.symmetric_type, rtype1)
self.assertEqual(rtype1.predicate, subject_pred)
self.assertEqual(rtype2.predicate, object_pred)
with self.assertNoException():
entity1 = CremeEntity.objects.create(user=self.user)
entity2 = CremeEntity.objects.create(user=self.user)
relation = Relation.objects.create(user=self.user,
type=rtype1,
subject_entity=entity1,
object_entity=entity2)
sym = relation.symmetric_relation
self.assertEqual(sym.type, rtype2)
self.assertEqual(sym.subject_entity, entity2)
self.assertEqual(sym.object_entity, entity1)
def test_manager_safe_get_or_create02(self):
"Give user ID (not user instance)"
rtype, srtype = RelationType.create(
('test-subject_challenge', 'challenges'),
('test-object_challenge', 'is challenged by'))
user = self.user
create_contact = partial(FakeContact.objects.create, user=user)
ryuko = create_contact(first_name='Ryuko', last_name='Matoi')
satsuki = create_contact(first_name='Satsuki', last_name='Kiryuin')
rel1 = Relation.objects.safe_get_or_create(
user_id=user.id,
subject_entity=ryuko,
type=rtype,
object_entity=satsuki,
)
self.assertIsInstance(rel1, Relation)
self.assertTrue(rel1.pk)
self.assertEqual(rtype.id, rel1.type_id)
self.assertEqual(ryuko.id, rel1.subject_entity_id)
self.assertEqual(satsuki.id, rel1.object_entity_id)
self.assertEqual(user.id, rel1.user_id)
self.assertEqual(srtype, rel1.symmetric_relation.type)
# ---
with self.assertNoException():
rel2 = Relation.objects.safe_get_or_create(
user_id=user.id,
subject_entity=ryuko,
type=rtype,
object_entity=satsuki,
)
self.assertEqual(rel1, rel2)
def test_manager_safe_create(self):
rtype, srtype = RelationType.create(
('test-subject_challenge', 'challenges'),
('test-object_challenge', 'is challenged by'))
user = self.user
create_contact = partial(FakeContact.objects.create, user=user)
ryuko = create_contact(first_name='Ryuko', last_name='Matoi')
satsuki = create_contact(first_name='Satsuki', last_name='Kiryuin')
res = Relation.objects.safe_create(
user=user,
subject_entity=ryuko,
type=rtype,
object_entity=satsuki,
)
self.assertIsNone(res)
rel = self.get_object_or_fail(Relation, type=rtype)
self.assertEqual(rtype.id, rel.type_id)
self.assertEqual(ryuko.id, rel.subject_entity_id)
self.assertEqual(satsuki.id, rel.object_entity_id)
self.assertEqual(user.id, rel.user_id)
self.assertEqual(srtype, rel.symmetric_relation.type)
# ---
with self.assertNoException():
Relation.objects.safe_create(
user=user,
subject_entity=ryuko,
type=rtype,
object_entity=satsuki,
)
def test_disable02(self):
"Relationship creation & deletion"
user = self.user
hayao = FakeContact.objects.create(user=user,
first_name='Hayao',
last_name='Miyazaki')
ghibli = FakeOrganisation.objects.create(user=user, name='Ghibli')
rtype = RelationType.create(('test-subject_employed', 'is employed'),
('test-object_employed', 'employs'))[0]
old_count = HistoryLine.objects.count()
rel = Relation(user=user,
subject_entity=hayao,
object_entity=ghibli,
type=rtype)
HistoryLine.disable(rel)
rel.save()
self.assertEqual(old_count, HistoryLine.objects.count())
# -----------------------
rel = self.refresh(rel)
HistoryLine.disable(rel)
rel.delete()
self.assertEqual(old_count, HistoryLine.objects.count())
def test_delete02(self):
"Can't be deleted"
user = self.user
invoice, source, target = self.create_invoice_n_orgas('Invoice001')
service_line = ServiceLine.objects.create(user=user, related_document=invoice,
on_the_fly_item='Flyyyyy',
)
rel1 = Relation.objects.get(subject_entity=invoice.id, object_entity=service_line.id)
# This relation prohibits the deletion of the invoice
ce = CremeEntity.objects.create(user=user)
rtype = RelationType.create(('test-subject_linked', 'is linked to'),
('test-object_linked', 'is linked to'),
is_internal=True,
)[0]
rel2 = Relation.objects.create(subject_entity=invoice, object_entity=ce, type=rtype, user=user)
self.assertRaises(ProtectedError, invoice.delete)
try:
Invoice.objects.get(pk=invoice.pk)
Organisation.objects.get(pk=source.pk)
Organisation.objects.get(pk=target.pk)
CremeEntity.objects.get(pk=ce.id)
Relation.objects.get(pk=rel2.id)
ServiceLine.objects.get(pk=service_line.pk)
Relation.objects.get(pk=rel1.id)
except Exception as e:
self.fail("Exception: ({}). Maybe the db doesn't support transaction ?".format(e))
def test_delete07(self):
"We replace with the segment with property_type=NULL"
user = self.login()
strategy = Strategy.objects.create(user=user, name='Producers')
desc = self._create_segment_desc(strategy, 'Producer')
segment1 = desc.segment
old_ptype = segment1.property_type
orga = Organisation.objects.create(user=user, name='NHK')
prop = CremeProperty.objects.create(creme_entity=orga, type=old_ptype)
rtype = RelationType.create(
('commercial-subject_test_segment_delete7', 'has produced',
[Organisation], [old_ptype]),
('commercial-object_test_segment_delete7', 'has been produced by',
[Organisation]),
)[0]
segment2 = self.get_object_or_fail(MarketSegment, property_type=None)
self.assertPOST200(self._build_delete_url(segment1),
data={'to_segment': segment2.id})
self.assertDoesNotExist(segment1)
self.assertDoesNotExist(old_ptype)
desc = self.assertStillExists(desc)
self.assertEqual(segment2, desc.segment)
self.assertDoesNotExist(prop)
self.assertFalse(rtype.subject_properties.all())
def test_delete02(self):
rt, srt = RelationType.create(('test-subfoo', 'subject_predicate'),
('test-subfoo', 'object_predicate'),
is_custom=True)
self.assertPOST200(self.DEL_URL, data={'id': rt.id})
self.assertDoesNotExist(rt)
self.assertDoesNotExist(srt)
def test_create08(self):
"Internal relationships are forbidden."
user = self.login()
orga = Organisation.objects.create(user=user,
name='Olympus',
is_managed=True)
rtype = RelationType.create(
('creme_config-subject_test_badrtype', 'Bad RType', [Contact]),
('creme_config-object_test_badrtype', 'Bad RType sym',
[Organisation]),
is_internal=True, # <==
)[0]
password = '******'
response = self.assertPOST200(
self.ADD_URL,
follow=True,
data={
'username': '******',
'password_1': password,
'password_2': password,
'first_name': 'Deunan',
'last_name': 'Knut',
'email': '*****@*****.**',
'organisation': orga.id,
'relation': rtype.id,
},
)
self.assertFormError(
response,
'form',
'relation',
_('Select a valid choice. That choice is not one of the available choices.'
),
)
def test_relation_block_errors(self):
rtype = RelationType.create(('test-subject_rented', 'is rented by'),
('test-object_rented', 'rents'),
)[0]
ct_contact = ContentType.objects.get_for_model(FakeContact)
rbi = RelationBrickItem.create(rtype.id)
build = partial(EntityCellRegularField.build, model=FakeContact)
rbi.set_cells(ct_contact,
[build(name='last_name'), build(name='description')]
)
rbi.save()
# Inject error by bypassing checkings
RelationBrickItem.objects.filter(id=rbi.id) \
.update(json_cells_map=rbi.json_cells_map.replace('description', 'invalid'))
rbi = self.refresh(rbi)
cells_contact = rbi.get_cells(ct_contact)
self.assertEqual(1, len(cells_contact))
self.assertEqual('last_name', cells_contact[0].value)
with self.assertNoException():
deserialized = jsonloads(rbi.json_cells_map)
self.assertEqual({str(ct_contact.id): [{'type': 'regular_field', 'value': 'last_name'}]},
deserialized
)
def test_ok02(self):
"All types of columns"
loves = RelationType.create(('test-subject_love', 'Is loving'),
('test-object_love', 'Is loved by'))[0]
customfield = CustomField.objects.create(
name='Size (cm)',
field_type=CustomField.INT,
content_type=self.ct_contact,
)
funcfield = function_field_registry.get(FakeContact,
'get_pretty_properties')
field = EntityCellsField(content_type=self.ct_contact)
cells = field.clean('relation-{},'
'regular_field-last_name,'
'function_field-{},'
'custom_field-{},'
'regular_field-first_name'.format(
loves.id,
funcfield.name,
customfield.id,
))
self.assertEqual(5, len(cells))
self.assertCellOK(cells[0], EntityCellRelation, loves.id)
self.assertCellOK(cells[1], EntityCellRegularField, 'last_name')
self.assertCellOK(cells[2], EntityCellFunctionField, funcfield.name)
self.assertCellOK(cells[3], EntityCellCustomField, str(customfield.id))
self.assertCellOK(cells[4], EntityCellRegularField, 'first_name')
def test_relation_brick02(self):
"All ctypes configured + Relation instance."
rtype = RelationType.create(
('test-subject_rented', 'is rented by'),
('test-object_rented', 'rents', [FakeContact, FakeOrganisation]),
)[0]
# rbi = RelationBrickItem.create(rtype.id)
rbi = RelationBrickItem.objects.create_if_needed(rtype)
self.assertIsInstance(rbi, RelationBrickItem)
self.assertIsNotNone(rbi.pk)
self.assertEqual(rtype.id, rbi.relation_type_id)
get_ct = ContentType.objects.get_for_model
rbi.set_cells(get_ct(FakeContact),
[EntityCellRegularField.build(FakeContact, 'last_name')])
rbi.save()
self.assertFalse(self.refresh(rbi).all_ctypes_configured)
rbi.set_cells(get_ct(FakeOrganisation),
[EntityCellRegularField.build(FakeOrganisation, 'name')])
rbi.save()
self.assertTrue(self.refresh(rbi).all_ctypes_configured)
# ---
self.assertEqual(rbi,
RelationBrickItem.objects.create_if_needed(rtype))
def test_create_linked_contact07(self):
"Avoid internal RelationType."
user = self.login()
orga = Organisation.objects.create(user=user, name='Acme')
rtype = RelationType.create(
('persons-subject_test_linked', 'is the employee of the month at', [Contact]),
('persons-object_test_linked', 'has the employee of the month', [Organisation]),
is_internal=True,
)[0]
response = self.assertPOST200(
self._build_addrelated_url(orga.id),
follow=True,
data={
'user': user.pk,
'first_name': 'Bugs',
'last_name': 'Bunny',
'rtype_for_organisation': rtype.id,
},
)
self.assertFormError(
response, 'form', 'rtype_for_organisation',
_('Select a valid choice. That choice is not one of the available choices.'),
)
def save(self,
pk_subject='creme_config-subject_userrelationtype',
pk_object='creme_config-object_userrelationtype',
generate_pk=True,
*args,
**kwargs):
get_data = self.cleaned_data.get
subject_ctypes = [
ct.model_class() for ct in get_data('subject_ctypes')
]
object_ctypes = [ct.model_class() for ct in get_data('object_ctypes')]
return RelationType.create(
(
pk_subject,
get_data('subject_predicate'),
subject_ctypes,
get_data('subject_properties'),
),
(
pk_object,
get_data('object_predicate'),
object_ctypes,
get_data('object_properties'),
),
is_custom=True,
generate_pk=generate_pk,
is_copiable=(get_data('subject_is_copiable'),
get_data('object_is_copiable')),
minimal_display=(get_data('subject_min_display'),
get_data('object_min_display')),
)
def test_relations_n_properties(self):
"The properties needed by the relation types are added."
user = self.login()
orga = FakeOrganisation.objects.create(user=user, name='Bebop')
create_ptype = CremePropertyType.create
ptype1 = create_ptype(str_pk='test-prop_captain', text='Is a captain')
ptype2 = create_ptype(str_pk='test-prop_strong', text='Is strong')
rtype = RelationType.create(
('test-subject_leads', 'leads', [FakeContact], [ptype1, ptype2]),
('test-object_leads', 'is lead', [FakeOrganisation]),
)[0]
form = FakeContactForm(
user=user,
data={
'user':
user.id,
'first_name':
'Spike',
'last_name':
'Spiegel',
'property_types': [ptype1.id, ptype2.id],
'relation_types':
self.formfield_value_multi_relation_entity((rtype.id, orga), ),
},
)
self.assertFalse(form.errors)
subject = form.save()
self.assertRelationCount(1, subject, rtype, orga)
def test_delete01(self):
rt = RelationType.create(
('test-subfoo', 'subject_predicate'),
('test-subfoo', 'object_predicate'),
is_custom=False,
)[0]
self.assertGET405(self.DEL_URL, data={'id': rt.id})
def test_relationtype_registry01(self):
"Default data + register() method."
registry = lv_search.RelationSearchRegistry()
cell1 = EntityCellRelation.build(model=FakeContact,
rtype_id=REL_SUB_HAS)
field = registry.get_field(cell=cell1, user=self.user)
self.assertIsInstance(field, lv_form.RelationField)
self.assertIsNone(registry.builder(REL_SUB_HAS))
self.assertEqual(lv_form.RelationField, registry.default_builder)
# ---
class MyRelationField(lv_form.ListViewSearchField):
pass
rtype2 = RelationType.create(
('test-subject_loves', 'loves'),
('test-object_loved', 'is loved by'),
)[0]
cell2 = EntityCellRelation(model=FakeContact, rtype=rtype2)
registry.register(rtype_id=rtype2.id, sfield_builder=MyRelationField)
self.assertIsInstance(registry.get_field(cell=cell2, user=self.user),
MyRelationField)
self.assertIsInstance(registry.get_field(cell=cell1, user=self.user),
lv_form.RelationField)
self.assertIsNone(registry.builder(REL_SUB_HAS))
self.assertEqual(MyRelationField, registry.builder(rtype2.id))
def test_add_relation02(self):
"Create the relation using the 'object' relation type"
user = self.user
nerv = FakeOrganisation.objects.create(user=user, name='Nerv')
rei = FakeContact.objects.create(user=user, first_name='Rei', last_name='Ayanami')
olds_ids = list(HistoryLine.objects.values_list('id', flat=True))
rtype, srtype = RelationType.create(('test-subject_works5', 'is employed'),
('test-object_works5', 'employs')
)
Relation.objects.create(user=user, subject_entity=nerv, object_entity=rei, type=srtype)
hlines = list(HistoryLine.objects.exclude(id__in=olds_ids).order_by('id'))
self.assertEqual(2, len(hlines))
hline = hlines[-2]
self.assertEqual(rei.id, hline.entity.id)
self.assertEqual(TYPE_RELATION, hline.type)
self.assertEqual([rtype.id], hline.modifications)
hline_sym = hlines[-1]
self.assertEqual(nerv.id, hline_sym.entity.id)
self.assertEqual(TYPE_SYM_RELATION, hline_sym.type)
self.assertEqual([srtype.id], hline_sym.modifications)
self.assertEqual(hline_sym.id, hline.related_line.id)
def test_related_edition01(self):
user = self.user
ghibli = self._build_organisation(user=user.id, name='Ghibli')
first_name = 'Hayao'
last_name = 'Miyazaki'
hayao = self._build_contact(user=user.id, first_name=first_name, last_name=last_name)
rtype, srtype = RelationType.create(('test-subject_employed', 'is employed'),
('test-object_employed', 'employs')
)
Relation.objects.create(user=user, subject_entity=hayao, object_entity=ghibli, type=rtype)
old_count = HistoryLine.objects.count()
description = 'A great animation movie maker'
response = self.client.post(hayao.get_edit_absolute_url(), follow=True,
data={'user': user.id,
'first_name': first_name,
'last_name': last_name,
'description': description,
}
)
self.assertNoFormError(response)
self.assertEqual(description, self.refresh(hayao).description)
hlines = self._get_hlines()
self.assertEqual(old_count + 1, len(hlines))
hline = hlines[-1]
self.assertEqual(TYPE_EDITION, hline.type)
self.assertIsNone(hline.related_line)
def test_delete_lines(self):
user = self.user
hayao = FakeContact.objects.create(user=user, first_name='Hayao', last_name='Miyazaki')
ghibli = FakeOrganisation.objects.create(user=user, name='Ghibli')
rtype = RelationType.create(('test-subject_delline_works', 'is employed'),
('test-object_delline_works', 'employs')
)[0]
Relation.objects.create(user=user, subject_entity=hayao, object_entity=ghibli, type=rtype)
HistoryConfigItem.objects.create(relation_type=rtype)
hayao = self.refresh(hayao)
hayao.description = 'Dream maker'
hayao.save()
hayao_line_qs = HistoryLine.objects.filter(entity=hayao)
ghibli_line_qs = HistoryLine.objects.filter(entity=ghibli)
self.assertEqual(3, hayao_line_qs.count())
self.assertEqual(3, ghibli_line_qs.count())
HistoryLine.delete_lines(hayao_line_qs)
self.assertFalse(hayao_line_qs.all())
ghibli_lines = list(ghibli_line_qs.all())
self.assertEqual(1, len(ghibli_lines))
self.assertEqual(TYPE_CREATION, ghibli_lines[0].type)
def test_not_copiable_relations(self):
self.login()
self.assertEqual(0, Relation.objects.count())
quote, source, target = self.create_quote_n_orgas('My Quote')
rtype1, rtype2 = RelationType.create(('test-subject_foobar', 'is loving', (Quote, Invoice)),
('test-object_foobar', 'is loved by', (Organisation,)))
self.assertTrue(rtype1.is_copiable)
self.assertTrue(rtype2.is_copiable)
Relation.objects.create(user=self.user, type=rtype1,
subject_entity=quote,
object_entity=source)
self.assertEqual(1, Relation.objects.filter(type=rtype1).count())
self.assertEqual(1, Relation.objects.filter(type=rtype2).count())
rtype3, rtype4 = RelationType.create(('test-subject_foobar_not_copiable', 'is loving', (Quote, Invoice)),
('test-object_foobar_not_copiable', 'is loved by', (Organisation,)),
is_copiable=False)
self.assertFalse(rtype3.is_copiable)
self.assertFalse(rtype4.is_copiable)
Relation.objects.create(user=self.user, type=rtype3,
subject_entity=quote,
object_entity=source)
self.assertEqual(1, Relation.objects.filter(type=rtype3).count())
self.assertEqual(1, Relation.objects.filter(type=rtype4).count())
rtype5, rtype6 = RelationType.create(('test-subject_foobar_wrong_ctype', 'is loving', (Quote,)),
('test-object_foobar_wrong_ctype', 'is loved by', (Organisation,)))
Relation.objects.create(user=self.user, type=rtype5,
subject_entity=quote,
object_entity=source)
self.assertEqual(1, Relation.objects.filter(type=rtype5).count())
self.assertEqual(1, Relation.objects.filter(type=rtype6).count())
# Contact2 < ---- > Orga
self._convert(200, quote, 'invoice')
self.assertEqual(2, Relation.objects.filter(type=rtype1).count())
self.assertEqual(2, Relation.objects.filter(type=rtype2).count())
self.assertEqual(1, Relation.objects.filter(type=rtype3).count())
self.assertEqual(1, Relation.objects.filter(type=rtype4).count())
self.assertEqual(1, Relation.objects.filter(type=rtype5).count())
self.assertEqual(1, Relation.objects.filter(type=rtype6).count())
def test_delete(self):
rtype = RelationType.create(('test-subject_foo', 'fooes'),
('test-object_foo', 'fooed'))[0]
hci = HistoryConfigItem.objects.create(relation_type=rtype)
self.assertPOST200(reverse('creme_config__remove_history_config'),
data={'id': hci.id})
self.assertDoesNotExist(hci)
def test_relations_credentials02(self):
"Label if cannot link the future entity."
user = self.login(is_superuser=False, creatable_models=[FakeContact])
create_creds = partial(SetCredentials.objects.create, role=self.role)
create_creds(value=EntityCredentials.VIEW |
EntityCredentials.CHANGE |
EntityCredentials.LINK,
set_type=SetCredentials.ESET_OWN,
)
create_creds(value=EntityCredentials.LINK,
set_type=SetCredentials.ESET_ALL,
ctype=FakeContact, forbidden=True,
)
orga = FakeOrganisation.objects.create(user=user, name='Oshino corp.')
rtype = RelationType.create(('test-subject_heals', 'heals'),
('test-object_heals', 'is healed by'),
)[1]
sfrt = SemiFixedRelationType.objects.create(predicate='Healed by Oshino',
relation_type=rtype,
object_entity=orga,
)
fields = FakeContactForm(user=user).fields
with self.assertNoException():
info_field = fields['rtypes_info']
self.assertNotIn('relation_types', fields)
self.assertNotIn('semifixed_rtypes', fields)
self.assertIsInstance(info_field.widget, Label)
self.assertEqual(
_('You are not allowed to link this kind of entity.'),
info_field.initial
)
# ---
form = FakeContactForm(
user=user,
data={
'user': user.id,
'first_name': 'Kanbaru',
'last_name': 'Suruga',
'relation_types': self.formfield_value_multi_relation_entity(
(rtype.id, orga), # Should not be used
),
'semifixed_rtypes': [sfrt.id], # Idem
},
)
self.assertFalse(form.errors)
subject = form.save()
self.assertFalse(subject.relations.count())
def test_add_relation01(self):
user = self.user
nerv = FakeOrganisation.objects.create(user=user, name='Nerv')
rei = FakeContact.objects.create(user=user,
first_name='Rei',
last_name='Ayanami')
old_count = HistoryLine.objects.count()
sleep(1) # Ensure than relation is younger than entities
rtype, srtype = RelationType.create(
('test-subject_works4', 'is employed'),
('test-object_works4', 'employs'))
relation = Relation.objects.create(user=user,
subject_entity=rei,
object_entity=nerv,
type=rtype)
relation = self.refresh(
relation) # Refresh to get the right modified value
hlines = self._get_hlines()
self.assertEqual(old_count + 2, len(hlines))
hline = hlines[-2]
self.assertEqual(rei.id, hline.entity.id)
self.assertEqual(str(rei), hline.entity_repr)
self.assertEqual(TYPE_RELATION, hline.type)
self.assertEqual([rtype.id], hline.modifications)
# self.assertEqual(relation.modified, hline.date)
self.assertEqual(relation.created, hline.date)
self.assertEqual(True, hline.line_type.is_about_relation)
hline_sym = hlines[-1]
self.assertEqual(nerv.id, hline_sym.entity.id)
self.assertEqual(str(nerv), hline_sym.entity_repr)
self.assertEqual(TYPE_SYM_RELATION, hline_sym.type)
self.assertEqual([srtype.id], hline_sym.modifications)
# self.assertEqual(relation.modified, hline_sym.date)
self.assertEqual(relation.created, hline_sym.date)
self.assertIs(True, hline.line_type.is_about_relation)
self.assertEqual(hline_sym.id, hline.related_line.id)
self.assertEqual(hline.id, hline_sym.related_line.id)
msg = _('Add a relationship “{}”').format
self.assertEqual([msg(rtype.predicate)],
hline.get_verbose_modifications(user))
self.assertEqual([msg(srtype.predicate)],
hline_sym.get_verbose_modifications(user))
rtype_id = rtype.id
relation.delete()
rtype.delete()
self.assertDoesNotExist(rtype)
self.assertEqual([msg(rtype_id)],
self.refresh(hline).get_verbose_modifications(user))
def setUp(self):
self.login()
self.loves = RelationType.create(
('test-subject_foobar', 'is loving'),
('test-object_foobar', 'is loved by'))[0]
self.iori = FakeContact.objects.create(user=self.user,
first_name='Iori',
last_name='Yoshizuki')
def test_relations_credentials06(self):
"Link credentials on the created entity + forced relationships."
user = self.login(is_superuser=False, creatable_models=[FakeContact])
create_creds = partial(SetCredentials.objects.create, role=self.role)
create_creds(
value=EntityCredentials.VIEW | EntityCredentials.LINK,
set_type=SetCredentials.ESET_OWN,
)
create_creds(value=EntityCredentials.VIEW,
set_type=SetCredentials.ESET_ALL)
orga = FakeOrganisation.objects.create(user=user, name='Oshino corp.')
rtype = RelationType.create(
('test-subject_heals', 'heals'),
('test-object_heals', 'is healed by'),
)[1]
data = {
'first_name': 'Kanbaru',
'last_name': 'Suruga',
}
forced_relations = [Relation(type=rtype, object_entity=orga)]
# KO ---
form1 = FakeContactForm(
user=user,
data={
**data, 'user': self.other_user.id
},
forced_relations=forced_relations,
)
self.assertFormInstanceErrors(
form1,
(
'user',
_('You are not allowed to link with the «{models}» of this user.'
).format(models='Test Contacts', ),
),
)
# OK ---
form2 = FakeContactForm(
user=user,
data={
**data, 'user': user.id
},
forced_relations=forced_relations,
)
self.assertFalse(form2.errors)
subject = form2.save()
self.assertRelationCount(1, subject, rtype, orga)