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)))