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)