def test_functionfield_registry01(self): "Default data" registry = lv_search.FunctionFieldSearchRegistry() funfield1 = self.PhoneFunctionField() cell1 = EntityCellFunctionField(model=FakeContact, func_field=funfield1) field = registry.get_field(cell=cell1, user=self.user) self.assertIsInstance(field, lv_form.ListViewSearchField) # self.assertFalse(field.widget.type) self.assertIsNone(registry.builder(funfield1)) # --- class MyField(lv_form.ListViewSearchField): pass funfield2 = self.IsAdultFunctionField() cell2 = EntityCellFunctionField(model=FakeContact, func_field=funfield2) registry.register(ffield=funfield2, sfield_builder=MyField) self.assertIsInstance(registry.get_field(cell=cell2, user=self.user), MyField) field1 = registry.get_field(cell=cell1, user=self.user) self.assertIsInstance(field1, lv_form.ListViewSearchField) self.assertNotIsInstance(field1, MyField) self.assertIsNone(registry.builder(funfield1)) self.assertEqual(MyField, registry.builder(funfield2))
def test_functionfield02(self): "Register a function field." class PhoneFunctionField(FunctionField): name = 'phone_or_mobile' verbose_name = 'Phone or mobile' # def __call__(self, entity, user): # return self.result_type(entity.phone or entity.mobile) function_field1 = PropertiesField() function_field2 = PhoneFunctionField() class PropertySorter(AbstractCellSorter): def get_field_name(this, cell): return 'created' # NB: it has no sense, it's just for testing purposes... sorter = QuerySorter() ffield_registry = sorter.registry[EntityCellFunctionField.type_id] self.assertIsNone(ffield_registry.sorter(function_field1)) ffield_registry.register( ffield=function_field1, sorter_cls=PropertySorter, ) self.assertIsInstance(ffield_registry.sorter(function_field1), PropertySorter) cells = [ EntityCellRegularField.build(model=FakeOrganisation, name='name'), EntityCellFunctionField(model=FakeOrganisation, func_field=function_field1), EntityCellFunctionField(model=FakeOrganisation, func_field=function_field2), ] prop_key = cells[1].key sortinfo1 = sorter.get(model=FakeOrganisation, cells=cells, cell_key=prop_key) self.assertEqual(('created', 'name', 'cremeentity_ptr_id'), sortinfo1.field_names) self.assertEqual(prop_key, sortinfo1.main_cell_key) self.assertTrue(sortinfo1.main_order.asc) # --- sortinfo2 = sorter.get(model=FakeOrganisation, cells=cells, cell_key=cells[2].key) self.assertEqual(('name', 'cremeentity_ptr_id'), sortinfo2.field_names)
def test_functionfield03(self): "<sorter_class> attribute." class PhoneSorter(AbstractCellSorter): def get_field_name(this, cell): return 'modified' # NB: it has no sense, it's just for testing purposes... class PhoneFunctionField(FunctionField): name = 'phone_or_mobile' verbose_name = 'Phone or mobile' sorter_class = PhoneSorter # def __call__(self, entity, user): # return self.result_type(entity.phone or entity.mobile) function_field = PhoneFunctionField() sorter = QuerySorter() cells = [ EntityCellRegularField.build(model=FakeOrganisation, name='name'), EntityCellFunctionField(model=FakeOrganisation, func_field=function_field), ] key = cells[1].key sortinfo = sorter.get(model=FakeOrganisation, cells=cells, cell_key=key) self.assertEqual(('modified', 'name', 'cremeentity_ptr_id'), sortinfo.field_names) self.assertEqual(key, sortinfo.main_cell_key) self.assertTrue(sortinfo.main_order.asc)
def test_functionfield01(self): self.assertEqual(_('Computed fields'), EntityCellFunctionField.verbose_name) name = 'get_pretty_properties' funfield = function_field_registry.get(FakeContact, name) self.assertIsNotNone(funfield) cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) self.assertIsInstance(cell, EntityCellFunctionField) self.assertEqual(name, cell.value) self.assertEqual(str(funfield.verbose_name), cell.title) self.assertEqual(f'function_field-{funfield.name}', cell.key) self.assertIs(cell.is_hidden, False) self.assertIs(cell.is_multiline, True) self.assertEqual(settings.CSS_DEFAULT_LISTVIEW, cell.listview_css_class) self.assertEqual(settings.CSS_DEFAULT_HEADER_LISTVIEW, cell.header_listview_css_class) cell = EntityCellFunctionField.build(FakeContact, func_field_name=name) self.assertIsInstance(cell, EntityCellFunctionField) self.assertEqual(name, cell.value) self.assertIsNone( EntityCellFunctionField.build(FakeContact, func_field_name='invalid'))
def test_functionfield_registry05(self): "Sub-registry defined in FunctionField attribute." user1 = self.user user2 = CremeUser( username='******', email='*****@*****.**', first_name='Chie', last_name='Uru', ) class MyFunField1(lv_form.ListViewSearchField): pass class MyFunField2(lv_form.ListViewSearchField): pass class MyFunRegistry(lv_search.AbstractListViewSearchFieldRegistry): def get_field(self, *, cell, user, **kwarg): cls = MyFunField1 if user.username == user1.username else MyFunField2 return cls(cell=cell, user=user) class SearchablePhoneFunctionField(self.PhoneFunctionField): search_field_builder = MyFunRegistry funfield = SearchablePhoneFunctionField() cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) registry = lv_search.FunctionFieldSearchRegistry() get_field = registry.get_field self.assertIsInstance(get_field(cell=cell, user=user1), MyFunField1) self.assertIsInstance(get_field(cell=cell, user=user2), MyFunField2)
def _get_cells(self, entity, context): cells = super()._get_cells(entity=entity, context=context) cells.append( EntityCellFunctionField(model=get_ticket_model(), func_field=ResolvingDurationField())) return cells
def test_build_4_functionfield01(self): name = 'get_pretty_properties' funfield = function_field_registry.get(FakeContact, name) self.assertIsNotNone(funfield) cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) self.assertIsInstance(cell, EntityCellFunctionField) self.assertEqual(name, cell.value) self.assertEqual(str(funfield.verbose_name), cell.title) self.assertEqual('function_field-{}'.format(funfield.name), cell.key) # self.assertIs(cell.has_a_filter, True) # self.assertIs(cell.editable, False) # self.assertIs(cell.sortable, False) self.assertIs(cell.is_hidden, False) self.assertIs(cell.is_multiline, True) # self.assertEqual('', cell.filter_string) self.assertEqual(settings.CSS_DEFAULT_LISTVIEW, cell.listview_css_class) self.assertEqual(settings.CSS_DEFAULT_HEADER_LISTVIEW, cell.header_listview_css_class) cell = EntityCellFunctionField.build(FakeContact, func_field_name=name) self.assertIsInstance(cell, EntityCellFunctionField) self.assertEqual(name, cell.value) self.assertIsNone( EntityCellFunctionField.build(FakeContact, func_field_name='invalid'))
def test_cell_registry_functionfield02(self): "Default data." funfield = self.PhoneFunctionField() cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) registry = lv_search.ListViewSearchFieldRegistry() field = registry.get_field(cell=cell, user=self.user) self.assertEqual(lv_form.ListViewSearchField, type(field))
def test_cell_registry_functionfield01(self): funfield = self.PhoneFunctionField() cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) registry = lv_search.ListViewSearchFieldRegistry(to_register=()) field = registry.get_field(cell=cell, user=self.user) self.assertIsInstance(field, lv_form.ListViewSearchField) with self.assertRaises(KeyError): registry[EntityCellFunctionField.type_id] # NOQA
def test_functionfield02(self): class PhoneFunctionField(FunctionField): name = 'phone_or_mobile' verbose_name = 'Phone or mobile' def __call__(self, entity, user): return FunctionFieldResult(entity.phone or entity.mobile) funfield = PhoneFunctionField() cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) self.assertEqual(funfield.name, cell.value) self.assertEqual(funfield.verbose_name, cell.title) self.assertFalse(cell.is_multiline)
def test_functionfield_registry02(self): "Register in constructor." class MyField(lv_form.ListViewSearchField): pass registry = lv_search.FunctionFieldSearchRegistry(to_register=[ (self.PhoneFunctionField, MyField) ], ) cell = EntityCellFunctionField(model=FakeContact, func_field=self.PhoneFunctionField()) self.assertIsInstance(registry.get_field(cell=cell, user=self.user), MyField)
def test_cell_registry_get_item(self): class MyField(lv_form.ListViewSearchField): pass funfield = self.PhoneFunctionField() cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) registry = lv_search.ListViewSearchFieldRegistry() registry[EntityCellFunctionField.type_id].register( ffield=funfield, sfield_builder=MyField) self.assertIsInstance(registry.get_field(cell=cell, user=self.user), MyField) with self.assertNoException(): registry[EntityCellRegularField. type_id].builder_4_model_field_type(ForeignKey)
def test_functionfield_registry03(self): "Function field with default search-field." registry = lv_search.FunctionFieldSearchRegistry() class MySearchField1(lv_form.ListViewSearchField): pass class SearchablePhoneFunctionField(self.PhoneFunctionField): search_field_builder = MySearchField1 funfield = SearchablePhoneFunctionField() cell = EntityCellFunctionField(model=FakeContact, func_field=funfield) self.assertIsInstance(registry.get_field(cell=cell, user=self.user), MySearchField1) # --- class MySearchField2(lv_form.ListViewSearchField): pass registry.register(ffield=funfield, sfield_builder=MySearchField2) self.assertIsInstance(registry.get_field(cell=cell, user=self.user), MySearchField2)
def test_function_field01(self): funf = function_field_registry.get(CremeEntity, 'assistants-get_todos') self.assertIsInstance(funf, TodosField) self.assertEqual('<ul></ul>', funf(self.entity, self.user).for_html()) # --- field_class = funf.search_field_builder self.assertIsNotNone(field_class) field = field_class( cell=EntityCellFunctionField(model=FakeContact, func_field=funf), user=self.user, ) self.assertIsInstance(field.widget, TextLVSWidget) to_python = field.to_python self.assertEqual(Q(), to_python(value=None)) self.assertEqual(Q(), to_python(value='')) value = 'foobar' self.assertEqual(Q(assistants_todos__title__icontains=value), to_python(value=value))
def test_get_total_pending01(self): user = self.login() create_orga = partial(Organisation.objects.create, user=user) target = create_orga(name='Target') self.assertEqual(0, get_total_pending(target, user)) source01 = create_orga(name='Source#1') self._set_managed(source01) def set_status(invoice): invoice.status = self.pending_payment_status invoice.save() invoice01 = self.create_invoice('Invoice #1', source01, target, user=user) set_status(invoice01) source02 = create_orga(name='Source#2') self._set_managed(source02) invoice02 = self.create_invoice('Invoice #2', source02, target, user=user) set_status(invoice02) # No pending status => not used invoice03 = self.create_invoice('Invoice #3', source02, target, user=user) self.create_line(invoice03, 1000, 1) # Not managed source => not used source03 = create_orga(name='Source#3 (not managed)') invoice04 = self.create_invoice('Invoice #4', source03, target, user=user) set_status(invoice04) self.create_line(invoice04, 500, 1) # Other target => not used target02 = create_orga(name='Target#2') invoice05 = self.create_invoice('Invoice #5', source01, target02, user=user) set_status(invoice05) self.create_line(invoice05, 750, 1) bool(Organisation.objects.filter_managed_by_creme()) # Fill cache # 2 Queries: # - managed organisations # - only billing issued by managed organisations with self.assertNumQueries(2): total = get_total_pending(target, user) self.assertEqual(0, total) self.create_line(invoice01, 5000, 1) self.assertEqual(5000, get_total_pending(target, user)) self.create_line(invoice02, 2000, 1) self.assertEqual(7000, get_total_pending(target, user)) funf = function_field_registry.get(Organisation, 'total_pending_payment') self.assertIsNotNone(funf) val = number_format('7000.00', use_l10n=True) self.assertEqual(val, funf(target, user).for_html()) self.assertEqual(val, funf(target, user).for_csv()) # Test for EntityCellFunctionField + CSS cell = EntityCellFunctionField(model=Invoice, func_field=funf) self.assertEqual(settings.CSS_NUMBER_LISTVIEW, cell.listview_css_class) self.assertEqual(settings.CSS_DEFAULT_HEADER_LISTVIEW, cell.header_listview_css_class)
def test_create02(self): user = self.login() lv_url = FakeContact.get_lv_absolute_url() # Create a view to post the entity filter HeaderFilter.objects.create_if_needed( pk='creme_core-tests_views_header_filter_test_create02', name='A FakeContact view', # Starts with "A" => first model=FakeContact, cells_desc=[ (EntityCellRegularField, { 'name': 'last_name' }), (EntityCellRegularField, { 'name': 'first_name' }), (EntityCellRegularField, { 'name': 'email' }), ], ) # Set a filter in the session (should be kept) efilter = EntityFilter.objects.smart_update_or_create( 'creme_core-tests_views_header_filter_test_create02', name='Misato', model=FakeContact, is_custom=True, conditions=[ RegularFieldConditionHandler.build_condition( model=FakeContact, field_name='first_name', operator=EQUALS, values=['Misato'], ), ], ) response = self.assertPOST200(lv_url, data={'filter': efilter.id}) self.assertEqual(efilter.id, response.context['list_view_state'].entity_filter_id) # -- ct = self.contact_ct 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=ct, ) funcfield = function_field_registry.get(FakeContact, 'get_pretty_properties') url = self._build_add_url(ct) response = self.assertGET200(url) with self.assertNoException(): cells_f = response.context['form'].fields['cells'] build_4_field = partial(EntityCellRegularField.build, model=FakeContact) self.assertListEqual([ build_4_field(name='first_name'), build_4_field(name='last_name'), EntityCellRelation( model=FakeContact, rtype=RelationType.objects.get(pk=FAKE_REL_SUB_EMPLOYED_BY), ), ], cells_f.initial) field_name = 'first_name' name = 'DefaultHeaderFilter' response = self.client.post( url, follow=True, data={ 'name': name, 'user': user.id, 'is_private': 'on', 'cells': f'relation-{loves.id},' f'regular_field-{field_name},' f'function_field-{funcfield.name},' f'custom_field-{customfield.id}', }, ) self.assertNoFormError(response) hfilter = self.get_object_or_fail(HeaderFilter, name=name) self.assertEqual(user, hfilter.user) self.assertTrue(hfilter.is_private) self.assertListEqual([ EntityCellRelation(model=FakeContact, rtype=loves), EntityCellRegularField.build(FakeContact, field_name), EntityCellFunctionField(model=FakeContact, func_field=funcfield), EntityCellCustomField(customfield), ], hfilter.cells) self.assertRedirects(response, lv_url) # -- context = self.assertGET200(lv_url).context selected_hfilter = context['header_filters'].selected self.assertIsInstance(selected_hfilter, HeaderFilter) self.assertEqual(hfilter.id, selected_hfilter.id) lvs = context['list_view_state'] self.assertEqual(hfilter.id, lvs.header_filter_id) self.assertEqual(efilter.id, lvs.entity_filter_id)