def populate(self):
Report = get_report_model()
HeaderFilter.create(
pk=constants.DEFAULT_HFILTER_REPORT,
name=_('Report view'),
model=Report,
cells_desc=[
(EntityCellRegularField, {
'name': 'name'
}),
(EntityCellRegularField, {
'name': 'ct'
}),
],
)
# ---------------------------
SearchConfigItem.create_if_needed(Report, ['name'])
# ---------------------------
# NB: no straightforward way to test that this populate script has not been already run
if not BrickDetailviewLocation.objects.filter_for_model(
Report).exists():
create_bdl = partial(
BrickDetailviewLocation.objects.create_if_needed, model=Report)
LEFT = BrickDetailviewLocation.LEFT
RIGHT = BrickDetailviewLocation.RIGHT
BrickDetailviewLocation.objects.create_for_model_brick(
order=5, zone=LEFT, model=Report)
create_bdl(brick=core_bricks.CustomFieldsBrick,
order=40,
zone=LEFT)
create_bdl(brick=bricks.ReportFieldsBrick, order=50, zone=LEFT)
create_bdl(brick=bricks.ReportGraphsBrick, order=60, zone=LEFT)
create_bdl(brick=core_bricks.PropertiesBrick, order=450, zone=LEFT)
create_bdl(brick=core_bricks.RelationsBrick, order=500, zone=LEFT)
create_bdl(brick=core_bricks.HistoryBrick, order=20, zone=RIGHT)
if apps.is_installed('creme.assistants'):
logger.info(
'Assistants app is installed => we use the assistants blocks on detail view'
)
from creme.assistants import bricks as a_bricks
create_bdl(brick=a_bricks.TodosBrick, order=100, zone=RIGHT)
create_bdl(brick=a_bricks.MemosBrick, order=200, zone=RIGHT)
create_bdl(brick=a_bricks.AlertsBrick, order=300, zone=RIGHT)
create_bdl(brick=a_bricks.UserMessagesBrick,
order=400,
zone=RIGHT)
if apps.is_installed('creme.documents'):
# logger.info('Documents app is installed => we use the documents block on detail views')
from creme.documents.bricks import LinkedDocsBrick
create_bdl(brick=LinkedDocsBrick, order=600, zone=RIGHT)
def _setup_contacts(self, disabled=False, user=None):
SearchConfigItem.create_if_needed(
FakeContact,
['first_name', 'last_name', 'sector__title'],
disabled=disabled,
)
self._build_contacts(user)
def test_get_4_models03(self):
"One model, 1 config in DB"
user = self.login()
sc_item = SearchConfigItem.create_if_needed(
FakeContact, ['first_name', 'last_name'])
configs = list(SearchConfigItem.get_4_models([FakeContact], user))
self.assertEqual(1, len(configs))
self.assertEqual(sc_item, configs[0])
def test_search08(self):
"Use Role's config if it exists"
self.login(is_superuser=False, allowed_apps=['creme_core'])
SearchConfigItem.create_if_needed(FakeContact, ['description'], role=self.role)
self._setup_contacts()
response = self._search('bear', self.contact_ct_id)
self.assertEqual(200, response.status_code)
self.assertNotContains(response, self.linus.get_absolute_url())
self.assertNotContains(response, self.linus2.get_absolute_url())
self.assertContains(response, self.alan.get_absolute_url())
def test_add04(self):
"Unique configuration (super-user)"
ct = self.ct_contact
SearchConfigItem.create_if_needed(FakeContact, role='superuser',
fields=['first_name', 'last_name'],
)
response = self.assertGET200(self._build_add_url(ct))
with self.assertNoException():
role_f = response.context['form'].fields['role']
self.assertIsNone(role_f.empty_label)
def test_search09(self):
"Use Role's config if it exists (super-user)"
self.login()
SearchConfigItem.create_if_needed(FakeContact, ['description'], role='superuser')
self._setup_contacts()
response = self._search('bear', self.contact_ct_id)
self.assertEqual(200, response.status_code)
self.assertNotContains(response, self.linus.get_absolute_url())
self.assertNotContains(response, self.linus2.get_absolute_url())
self.assertContains(response, self.alan.get_absolute_url())
def test_search10(self):
"With FieldsConfig"
user = self.login()
hidden_fname1 = 'description'
hidden_fname2 = 'sector'
SearchConfigItem.create_if_needed(
FakeContact,
[
'first_name',
'last_name',
hidden_fname1,
hidden_fname2 + '__title',
],
)
sector = FakeSector.objects.create(title='Linux dev')
create_contact = partial(FakeContact.objects.create, user=user)
linus = create_contact(first_name='Linus',
last_name='Torvalds',
description="Alan's friend")
alan = create_contact(first_name='Alan',
last_name='Cox',
description="Linus' friend")
andrew = create_contact(first_name='Andrew',
last_name='Morton',
sector=sector)
FieldsConfig.create(FakeContact,
descriptions=[
(hidden_fname1, {
FieldsConfig.HIDDEN: True
}),
(hidden_fname2, {
FieldsConfig.HIDDEN: True
}),
])
response = self._search('Linu', self.contact_ct_id)
self.assertEqual(200, response.status_code)
self.assertContains(response, linus.get_absolute_url())
self.assertNotContains(response, alan.get_absolute_url())
self.assertNotContains(response, andrew.get_absolute_url())
self.assertContains(response, _('First name'))
self.assertContains(response, _('Last name'))
self.assertNotContains(response, _('Description'))
self.assertNotContains(response, _('Sector'))
def test_delete03(self):
"Cannot delete the default configuration"
sci = SearchConfigItem.create_if_needed(FakeContact,
['first_name', 'last_name'])
self.assertPOST409(reverse('creme_config__delete_search_config'),
data={'id': sci.id})
self.assertStillExists(sci)
def test_edit07(self):
"With FieldsConfig + selected hidden fields"
model = FakeContact
hidden_fname1 = 'description'
hidden_fname2 = 'position'
hidden_sub_fname2 = hidden_fname2 + '__title'
sci = SearchConfigItem.create_if_needed(model,
fields=[
'first_name',
hidden_fname1,
hidden_sub_fname2,
])
FieldsConfig.create(model,
descriptions=[
(hidden_fname1, {
FieldsConfig.HIDDEN: True
}),
(hidden_fname2, {
FieldsConfig.HIDDEN: True
}),
])
response = self.assertGET200(self._build_edit_url(sci))
with self.assertNoException():
fields_f = response.context['form'].fields['fields']
self.assertEqual(['first_name', hidden_fname1, hidden_sub_fname2],
fields_f.initial)
self._find_field_index(fields_f, 'first_name')
self._find_field_index(fields_f, hidden_fname1)
self._find_field_index(fields_f, hidden_sub_fname2)
def test_edit06(self):
"With FieldsConfig"
model = FakeContact
hidden_fname1 = 'description'
hidden_fname2 = 'position'
FieldsConfig.create(model,
descriptions=[
(hidden_fname1, {
FieldsConfig.HIDDEN: True
}),
(hidden_fname2, {
FieldsConfig.HIDDEN: True
}),
])
sci = SearchConfigItem.create_if_needed(model, fields=['first_name'])
response = self.assertGET200(self._build_edit_url(sci))
with self.assertNoException():
fields_f = response.context['form'].fields['fields']
self.assertEqual(['first_name'], fields_f.initial)
self._find_field_index(fields_f, 'first_name')
self._find_field_index(fields_f, 'civility__title')
self._assertNotInChoices(fields_f, hidden_fname1)
self._assertNotInChoices(fields_f, 'position__title')
def test_edit01(self):
sci = SearchConfigItem.create_if_needed(FakeContact,
fields=['last_name'])
self.assertIsNone(sci.role)
url = self._build_edit_url(sci)
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 «{object}»').format(object=sci), context.get('title'))
with self.assertNoException():
fields = context['form'].fields['fields']
self.assertEqual(['last_name'], fields.initial)
fname1 = 'last_name'
index1 = self._find_field_index(fields, fname1)
fname2 = 'first_name'
index2 = self._find_field_index(fields, fname2)
self._find_field_index(fields, 'civility__title')
self.assertNoChoice(fields, 'birthday')
sci = self._edit_config(url, sci, ((fname1, index1), (fname2, index2)))
self.assertFalse(sci.disabled)
def test_delete02(self):
"Super users"
sci = SearchConfigItem.create_if_needed(FakeContact, role='superuser',
fields=['first_name', 'last_name'],
)
self.assertPOST200(reverse('creme_config__delete_search_config'), data={'id': sci.id})
self.assertDoesNotExist(sci)
def test_create_if_needed06(self):
"Disabled"
self.login()
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation, [],
disabled=True)
self.assertTrue(sc_item.disabled)
self.assertFalse(sc_item.field_names)
def test_searchfields_setter03(self):
"Invalid fields"
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation,
['name', 'phone'])
sc_item.searchfields = ['invalid']
sc_item.save()
self.assertIsNone(self.refresh(sc_item).field_names)
def test_create_if_needed05(self):
"Invalid fields : no subfield"
sc_item = SearchConfigItem.create_if_needed(
FakeContact, ['last_name__invalid', 'first_name'])
sfields = sc_item.searchfields
self.assertEqual(1, len(sfields))
self.assertEqual('first_name', sfields[0].name)
def test_searchfields_setter04(self):
"Fields + disabled"
sc_item = SearchConfigItem.create_if_needed(
FakeOrganisation,
['name', 'phone'],
disabled=True,
)
self.assertEqual(['name', 'phone'],
[sf.name for sf in sc_item.searchfields])
def test_allfields01(self):
"True"
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation, [])
self.assertTrue(sc_item.all_fields)
sfields = {sf.name for sf in sc_item.searchfields}
self.assertIn('name', sfields)
self.assertIn('address__city', sfields)
self.assertNotIn('creation_date', sfields)
def test_get_4_models07(self):
"One model, 2 configs in DB (super-user) (other order)"
user = self.login()
create = SearchConfigItem.create_if_needed
sc_item = create(FakeContact, ['last_name'], role='superuser')
create(FakeContact, ['first_name', 'last_name'])
self.assertEqual(
sc_item, next(SearchConfigItem.get_4_models([FakeContact], user)))
def test_create_if_needed01(self):
# self.assertEqual(0, SearchConfigItem.objects.count())
count = SearchConfigItem.objects.count()
ct = ContentType.objects.get_for_model(FakeContact)
self.assertFalse(SearchConfigItem.objects.filter(content_type=ct))
SearchConfigItem.create_if_needed(FakeContact,
['first_name', 'last_name'])
# sc_items = SearchConfigItem.objects.all()
self.assertEqual(count + 1, SearchConfigItem.objects.count())
sc_items = SearchConfigItem.objects.filter(content_type=ct)
self.assertEqual(1, len(sc_items))
sc_item = sc_items[0]
self.assertEqual(FakeContact, sc_item.content_type.model_class())
self.assertIsNone(sc_item.role)
self.assertIs(sc_item.superuser, False)
self.assertEqual('first_name,last_name', sc_item.field_names)
self.assertIs(sc_item.all_fields, False)
self.assertIs(sc_item.disabled, False)
sfields = sc_item.searchfields
self.assertEqual(2, len(sfields))
fn_field = sfields[0]
self.assertEqual('first_name', fn_field.name)
self.assertEqual(_('First name'), fn_field.verbose_name)
self.assertEqual(_('First name'), str(fn_field))
ln_field = sfields[1]
self.assertEqual('last_name', ln_field.name)
self.assertEqual(_('Last name'), ln_field.verbose_name)
self.assertEqual(_('Last name'), str(ln_field))
self.assertEqual(
_('Default search configuration for «{model}»').format(
model='Test Contact'), str(sc_item))
SearchConfigItem.create_if_needed(FakeContact,
['first_name', 'last_name'])
self.assertEqual(count + 1, SearchConfigItem.objects.count())
def test_search15(self):
"Grouped words."
self.login()
SearchConfigItem.create_if_needed(FakeOrganisation, ['name'])
create_orga = partial(FakeOrganisation.objects.create, user=self.user)
orga1 = create_orga(name='Foobar Foundation')
orga2 = create_orga(name='Foobar Mega Foundation')
orga3 = create_orga(name='Mega Foobar Foundation')
response = self._search(
'"Foobar Foundation"',
ct_id=ContentType.objects.get_for_model(FakeOrganisation).id,
)
self.assertEqual(200, response.status_code)
self.assertContains(response, orga1.get_absolute_url())
self.assertContains(response, orga3.get_absolute_url())
self.assertNotContains(response, orga2.get_absolute_url())
def test_get_4_models08(self):
"2 models"
user = self.login()
configs = list(
SearchConfigItem.get_4_models([FakeContact, FakeOrganisation],
user))
self.assertEqual(2, len(configs))
self.assertEqual(FakeContact, configs[0].content_type.model_class())
self.assertEqual(FakeOrganisation,
configs[1].content_type.model_class())
def test_search11(self):
"With FieldsConfig: all fields are hidden"
self.login()
hidden_fname = 'description'
SearchConfigItem.create_if_needed(FakeContact, [hidden_fname])
FieldsConfig.create(FakeContact,
descriptions=[(hidden_fname, {FieldsConfig.HIDDEN: True})]
)
self._build_contacts()
response = self._search('Cool', self.contact_ct_id)
self.assertEqual(200, response.status_code)
self.assertNotContains(response, self.linus.get_absolute_url())
self.assertNotContains(response, self.alan.get_absolute_url())
self.assertNotContains(response, self.andrew.get_absolute_url())
self.assertContains(response,
_('It seems that all fields are hidden. Ask your administrator to fix the configuration.')
)
def test_searchfields_setter02(self):
"No fields"
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation,
['name', 'phone'])
sc_item.searchfields = []
sc_item.save()
self.assertIsNone(self.refresh(sc_item).field_names)
self.assertTrue(sc_item.all_fields)
sc_item.searchfields = ['name']
self.assertEqual(['name'], [sf.name for sf in sc_item.searchfields])
self.assertFalse(sc_item.all_fields)
def test_searchfields01(self):
"Invalid field are deleted automatically"
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation,
['name', 'phone'])
sc_item.field_names += ',invalid'
sc_item.save()
sc_item = self.refresh(sc_item) # No cache any more
self.assertEqual(['name', 'phone'],
[sf.name for sf in sc_item.searchfields])
self.assertEqual('name,phone', sc_item.field_names)
def test_get_4_models05(self):
"One model, 2 configs in DB (other order)"
self.login()
create = SearchConfigItem.create_if_needed
sc_item = create(FakeContact, ['last_name'], role=self.role)
create(FakeContact, ['first_name', 'last_name'])
create(FakeContact, ['description'], role='superuser')
self.assertEqual(
sc_item,
next(SearchConfigItem.get_4_models([FakeContact],
self.other_user)))
def populate(self):
RecurrentGenerator = get_rgenerator_model()
HeaderFilter.create(
pk=constants.DEFAULT_HFILTER_RGENERATOR,
model=RecurrentGenerator,
name=_('Generator view'),
cells_desc=[(EntityCellRegularField, {
'name': 'name'
})],
)
SearchConfigItem.create_if_needed(RecurrentGenerator,
['name', 'description'])
Job.objects.get_or_create(
type_id=recurrents_gendocs_type.id,
defaults={
'language': settings.LANGUAGE_CODE,
'status': Job.STATUS_OK,
},
)
def test_create_if_needed03(self):
"For super users"
self.login()
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation, ['name'],
role='superuser')
self.assertEqual(FakeOrganisation, sc_item.content_type.model_class())
self.assertIsNone(sc_item.role)
self.assertTrue(sc_item.superuser)
self.assertEqual(
_('Search configuration of super-users for «{model}»').format(
model='Test Organisation'), str(sc_item))
def test_get_4_models02(self):
"One model, no config in BD"
user = self.login()
configs = list(SearchConfigItem.get_4_models([FakeContact], user))
self.assertEqual(1, len(configs))
sc_item = configs[0]
self.assertIsInstance(sc_item, SearchConfigItem)
self.assertEqual(FakeContact, sc_item.content_type.model_class())
self.assertIsNone(sc_item.role)
self.assertFalse(sc_item.superuser)
self.assertTrue(sc_item.all_fields)
self.assertIsNone(sc_item.pk)
def test_searchfields02(self):
"Invalid field are deleted automatically => if no more valid field, all are used"
sc_item = SearchConfigItem.create_if_needed(FakeOrganisation,
['name', 'phone'])
sc_item.field_names = 'invalid01,invalid02'
sc_item.save()
sc_item = self.refresh(sc_item) # No cache anymore
sfields = {sf.name for sf in sc_item.searchfields}
self.assertIn('name', sfields)
self.assertIn('capital', sfields)
self.assertNotIn('created', sfields)
self.assertTrue(sc_item.all_fields)
self.assertIsNone(sc_item.field_names)
def test_get_4_models06(self):
"One model, 2 configs in DB (super-user)"
user = self.login()
create_role = UserRole.objects.create
role2 = create_role(name='CEO')
role3 = create_role(name='Office lady')
create = SearchConfigItem.create_if_needed
create(FakeContact, ['first_name', 'last_name'])
create(FakeContact, ['first_name'], role=role2)
sc_item = create(FakeContact, ['last_name'], role='superuser') # <==
create(FakeContact, ['first_name', 'description'], role=role3)
self.assertEqual(
sc_item, next(SearchConfigItem.get_4_models([FakeContact], user)))
