def save(self, *args, **kwargs):
instance = self.instance
desc = self.descriptor
model = desc.model
cell_registry = desc.build_cell_registry()
group_id = self.cleaned_data['group']
extra_group_class = next(
group_class
for group_class in desc.extra_group_classes
if group_class.extra_group_id == group_id
)
instance.store_groups(FieldGroupList(
model=model,
cell_registry=cell_registry,
groups=[
*FieldGroupList.from_dicts(
model=model,
data=instance.groups_as_dicts(),
cell_registry=cell_registry,
),
extra_group_class(model=model),
],
))
return super().save(*args, **kwargs)
def post(self, request, *args, **kwargs):
target = get_from_POST_or_404(request.POST,
self.target_order_arg,
cast=int)
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
group_id = self.get_group_id()
groups = [*self.get_groups()]
if target > len(groups):
raise ConflictError(f'The target "{target}" is too big.')
moved_group = groups.pop(group_id)
groups.insert(target, moved_group)
cfci.store_groups(
FieldGroupList(
model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry(),
))
cfci.save() # TODO: only if changed ?
return HttpResponse()
def perform_deletion(self, request):
cell_key = get_from_POST_or_404(request.POST, self.cell_key_arg)
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
groups = []
found = False
for group in self.get_groups():
cells = []
# TODO: better API for group.cells ?
for cell in getattr(group, 'cells', ()):
if cell.key != cell_key:
cells.append(cell)
else:
found = True
groups.append(
FieldGroup(name=group.name, cells=cells, layout=group.layout
) if found else group)
if not found:
raise Http404(
f'The cell with key="{cell_key}" has not been found.')
cfci.store_groups(
FieldGroupList(model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry()))
cfci.save()
def post(self, request, *args, **kwargs):
layout = get_from_POST_or_404(request.POST, self.layout_arg)
if layout not in LAYOUTS:
raise ConflictError(f'The layout "{layout}" is invalid.')
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
group_id = self.get_group_id()
# groups = [
# FieldGroup(name=group.name, cells=group.cells, layout=layout)
# if i == group_id else
# group
# for i, group in enumerate(self.get_groups())
# ]
groups = [*self.get_groups()]
groups[group_id]._layout = layout
cfci.store_groups(
FieldGroupList(
model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry(),
))
cfci.save() # TODO: only if changed ?
return HttpResponse()
def save(self, *args, **kwargs):
cdata = self.cleaned_data
instance = self.instance
desc = self.descriptor
model = desc.model
cell_registry = desc.build_cell_registry()
instance.store_groups(FieldGroupList(
model=model,
cell_registry=cell_registry,
groups=[
*FieldGroupList.from_dicts(
model=model,
data=instance.groups_as_dicts(),
cell_registry=cell_registry,
),
FieldGroup(name=cdata['name'], cells=cdata['cells']),
],
))
return super().save(*args, **kwargs)
def save(self, *args, **kwargs):
cdata = self.cleaned_data
groups = [*self.groups]
layout = groups[self.group_id].layout
groups[self.group_id] = FieldGroup(
name=cdata['name'], cells=cdata['cells'], layout=layout,
)
self.instance.store_groups(FieldGroupList(
model=self.descriptor.model, groups=groups,
cell_registry=self.descriptor.build_cell_registry(),
))
return super().save(*args, **kwargs)
def perform_deletion(self, request):
group_id = get_from_POST_or_404(request.POST,
self.group_id_arg,
cast=int)
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
groups = [*self.get_groups()]
try:
del groups[group_id]
except IndexError:
raise ConflictError(f'The group ID "{group_id}" is invalid.')
cfci.store_groups(
FieldGroupList(
model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry(),
))
cfci.save()
def _add_approach_extra_cell(self):
cfci = CustomFormConfigItem.objects.get(
cform_id=ACTIVITY_CREATION_CFORM.id)
old_groups = ACTIVITY_CREATION_CFORM.groups(item=cfci)
new_groups = FieldGroupList(
model=old_groups.model,
cell_registry=old_groups.cell_registry,
groups=[
*old_groups,
FieldGroup(
name='Commercial approach',
cells=[
IsCommercialApproachSubCell(
model=Activity).into_cell(),
],
layout=LAYOUT_REGULAR,
)
])
cfci.store_groups(new_groups)
cfci.save()
def test_entity_creation_customform02(self):
user = self.login()
cfci = self.get_object_or_fail(
CustomFormConfigItem,
cform_id=FAKEACTIVITY_CREATION_CFORM.id,
)
build_cell = partial(EntityCellRegularField.build, model=FakeActivity)
cfci.store_groups(
FieldGroupList(
model=FakeActivity,
cell_registry=FAKEACTIVITY_CREATION_CFORM.build_cell_registry(
),
groups=[
FieldGroup(
name='My fields',
cells=[
*(build_cell(name=name)
for name in ('user', 'title', 'place', 'type')),
fake_forms.FakeActivityStartSubCell().into_cell(),
# fake_forms.FakeActivityEndSubCell().into_cell(),
],
),
],
))
cfci.save()
url = reverse('creme_core__create_fake_activity')
self.assertGET200(url)
# TODO: test HTML (or in model tests ?)
title = 'My meeting'
place = 'Mars capital'
atype = FakeActivityType.objects.get(name='Meeting')
self.assertNoFormError(
self.client.post(
url,
follow=True,
data={
'user': user.id,
'title': title,
'place': place,
'type': atype.id,
'cform_extra-fakeactivity_start': '28-09-2020',
# Should not be used
'cform_extra-fakeactivity_end': '30-09-2020',
'minutes': 'Should not be used',
},
))
activity = self.get_object_or_fail(FakeActivity, title=title)
self.assertEqual(title, activity.title)
self.assertEqual(place, activity.place)
self.assertEqual(atype, activity.type)
self.assertEqual(
self.create_datetime(year=2020, month=9, day=28),
activity.start,
)
self.assertIsNone(activity.end)
self.assertFalse(activity.minutes)
def test_json(self):
cfci = CustomFormConfigItem()
group_name1 = 'Main'
group_name2 = 'Details'
build_cell = partial(EntityCellRegularField.build, model=FakeContact)
cfci.store_groups(
FieldGroupList(model=FakeContact,
cell_registry=base_cell_registry,
groups=[
FieldGroup(
name=group_name1,
cells=(
build_cell(name='user'),
build_cell(name='description'),
),
),
FieldGroup(
name=group_name2,
layout=LAYOUT_DUAL_FIRST,
cells=(
build_cell(name='first_name'),
build_cell(name='last_name'),
),
),
]))
cfci.save()
self.assertListEqual(
[
{
'name':
group_name1,
'layout':
LAYOUT_REGULAR,
'cells': [
{
'type': 'regular_field',
'value': 'user'
},
{
'type': 'regular_field',
'value': 'description'
},
],
},
{
'name':
group_name2,
'layout':
LAYOUT_DUAL_FIRST,
'cells': [
{
'type': 'regular_field',
'value': 'first_name'
},
{
'type': 'regular_field',
'value': 'last_name'
},
],
},
],
self.refresh(cfci).groups_as_dicts(),
)