def _add(self, action):
model = None
if action.startswith(_('Add ')):
# not add_label was defined for the related model
tokens = action.replace(_('Add '), '').split(_(' in '))
verbose_name = tokens[0].strip()
if len(tokens) > 1:
relation_verbose_name = tokens[1].strip()
model = find_model_by_verbose_name(relation_verbose_name)
related_model = find_model_by_verbose_name(verbose_name)
else:
# an add_label was defined for the related model
tokens = action.split(_(' in '))
add_label = tokens[0].strip()
if len(tokens) > 1:
verbose_name = tokens[1].strip()
model = find_model_by_verbose_name(verbose_name)
related_model = find_model_by_add_label(add_label)
# check if there is a fieldset was defined with the relation
fieldsets = hasattr(
model, 'fieldsets') and model.fieldsets or get_fieldsets(model)
relation_name = None
inlines = []
if hasattr(model, 'fieldsets'):
for fieldset in fieldsets:
if 'relations' in fieldset[1]:
for item in fieldset[1]['relations']:
tmp = getattr(model, item.split(':')[0].split('__')[0])
if hasattr(tmp, 'field'
) and tmp.field.remote_field.model == model:
relation_name = item
if 'inlines' in fieldset[1]:
for item in fieldset[1]['inlines']:
inlines.append(item)
tmp = getattr(model, item)
if hasattr(tmp, 'field'
) and tmp.field.remote_field.model == model:
relation_name = item
# if the relation was defined in a fieldset
if relation_name:
add_inline = relation_name in inlines
add_label = get_metadata(related_model, 'add_label')
button_label = add_label or 'Adicionar'
button_label = get_metadata(related_model, 'add_label',
button_label)
username_attr = ''
if CACHE['LAST_AUTHENTICATED_USERNAME']:
username_attr = ", '{}'".format(
CACHE['LAST_AUTHENTICATED_USERNAME'])
func_decorator = '@testcase(\'{}\'{})'.format(
self.name, username_attr)
self._func_signature = '{}_{}_{}_{}'.format(
_('add'), related_model.__name__.lower(), _('in'),
model.__name__.lower())
self._test_function_code.append(' {}'.format(func_decorator))
self._test_function_code.append(' def {}(self):'.format(
self._func_signature))
self._view(related_model)
# the form is not in the visualization page and it must be opened
if not add_inline:
add_button_label = 'Adicionar {}'.format(
get_metadata(related_model, 'verbose_name'))
add_button_label = get_metadata(related_model, 'add_label',
add_button_label)
interaction = _('The user clicks the button')
self._interactions.append('{} "{}"'.format(
interaction, add_button_label))
self._interactions.append(
_('The system displays a popup window'))
self._test_function_code.append(
" self.click_button('{}')".format(add_button_label))
self._test_function_code.append(
" self.look_at_popup_window()")
form = factory.get_many_to_one_form(self._mocked_request(),
model(), relation_name,
related_model())
self._fill_out(form)
save_button_label = get_metadata(related_model, 'add_label',
_('Save'))
interaction = _('The user clicks the button')
self._interactions.append('{} "{}"'.format(interaction,
save_button_label))
self._test_function_code.append(
" self.click_button('{}')".format(save_button_label))
self._test_function_code.append(
" self.click_icon('{}')".format('Principal'))
else:
raise ValueError(
'Please add the {}\'s relation in the fieldsets of model {}'.
format(related_model.__name__, model.__name__))
def add(request, app, cls, pk=None, related_field_name=None, related_pk=None):
if not request.user.is_authenticated:
return httprr(request,
'/admin/login/?next={}'.format(request.get_full_path()))
try:
_model = apps.get_model(app, cls)
except LookupError as e:
return page_not_found(request, e, 'error404.html')
obj = pk and _model.objects.all(
request.user).filter(pk=pk).first() or _model()
obj.request = request
obj._user = request.user
title = pk and str(obj) or get_metadata(_model, 'verbose_name')
if related_field_name is None:
if obj.pk:
if not permissions.has_edit_permission(
request, _model) or not permissions.can_edit(request, obj):
return HttpResponseForbidden()
else:
if not permissions.has_add_permission(
request, _model) or not permissions.can_add(request, obj):
return HttpResponseForbidden()
form = factory.get_register_form(request, obj)
title = form.title
elif is_one_to_many(_model, related_field_name):
if not permissions.can_add(request, obj) and not permissions.can_edit(
request, obj):
return HttpResponseForbidden()
form = factory.get_one_to_many_form(request, obj, related_field_name)
elif is_many_to_many(_model, related_field_name):
if not permissions.can_add(request, obj) and not permissions.can_edit(
request, obj):
return HttpResponseForbidden()
form = factory.get_many_to_many_form(request, obj, related_field_name,
related_pk)
elif is_one_to_many_reverse(_model, related_field_name):
form = factory.get_many_to_many_reverse_form(request, obj,
related_field_name)
elif is_one_to_one(_model, related_field_name):
if not permissions.can_add(request, obj) and not permissions.can_edit(
request, obj):
return HttpResponseForbidden()
form = factory.get_one_to_one_form(request, obj, related_field_name,
related_pk)
else:
# many to one
for rel in list_related_objects(_model):
if hasattr(rel, 'get_accessor_name'):
if rel.get_accessor_name() in (
'{}_set'.format(related_field_name),
related_field_name):
related_queryset = rel.related_model.objects.all(
request.user)
related_obj = related_pk and related_queryset.get(
pk=related_pk) or rel.related_model()
related_obj.request = request
setattr(related_obj, rel.field.name, obj)
setattr(related_obj, '{}_id'.format(rel.field.name),
obj.pk)
if related_pk:
if not permissions.has_edit_permission(
request,
rel.related_model) or not permissions.can_edit(
request, related_obj):
return HttpResponseForbidden()
else:
if not permissions.has_add_permission(
request,
rel.related_model) or not permissions.can_add(
request, related_obj):
return HttpResponseForbidden()
form = factory.get_many_to_one_form(
request, obj, rel.get_accessor_name(), related_obj)
title = form.title
if form.is_valid():
is_editing = form.instance.pk is not None
try:
form.save()
obj = form.instance
if 'select' in request.GET:
return HttpResponse('{}|{}|{}'.format(obj.pk, obj,
request.GET['select']))
elif related_field_name:
message = 'Ação realizada com sucesso'
url = '..'
else:
message = get_metadata(form.instance.__class__, 'add_message')
if message and not is_editing:
if hasattr(obj, 'get_absolute_url'):
url = obj.get_absolute_url()
else:
url = '/view/{}/{}/{}/'.format(
get_metadata(obj.__class__, 'app_label'),
obj.__class__.__name__.lower(), obj.pk)
else:
url = '..'
if is_editing:
message = message or 'Atualização realizada com sucesso'
else:
message = message or 'Cadastro realizado com sucesso'
return httprr(request, url, message)
except ValidationError as e:
form.add_error(None, str(e.message))
return render(request, 'default.html', locals())
def _add(self, action):
model = None
if action.startswith(_(u'Add')):
# not add_label was defined for the related model
tokens = action.replace(_(u'Add'), '').split(_(u' in '))
verbose_name = tokens[0].strip()
if len(tokens) > 1:
relation_verbose_name = tokens[1].strip()
model = find_model_by_verbose_name(relation_verbose_name)
related_model = find_model_by_verbose_name(verbose_name)
else:
# an add_label was defined for the related model
tokens = action.split(_(u' in '))
add_label = tokens[0].strip()
if len(tokens) > 1:
verbose_name = tokens[1].strip()
model = find_model_by_verbose_name(verbose_name)
related_model = find_model_by_add_label(add_label)
# check if there is a fieldset was defined with the relation
relation_name = None
if hasattr(model, 'fieldsets'):
for fieldset in model.fieldsets:
if 'relations' in fieldset[1]:
for item in fieldset[1]['relations']:
tmp = getattr(model, item)
if tmp.rel.related_model == related_model:
relation_name = item
# if the relation was defined in a fieldset
if relation_name:
add_inline = get_metadata(related_model, 'add_inline')
add_label = get_metadata(related_model, 'add_label')
button_label = add_label or u'Adicionar'
button_label = get_metadata(related_model, 'add_label',
button_label)
function_signature = u'%s_%s_%s_%s' % \
(_(u'add'), related_model.__name__.lower(), _(u'in'), model.__name__.lower())
self._test_flow_code.append(u'\t\t\t# %s' % action)
self._test_flow_code.append(u'\t\t\tself.%s()' %
function_signature)
self._test_function_code.append(u'\tdef %s(self):' %
function_signature)
self._view(related_model)
# the form is not in the visualization page and it must be opened
if not add_inline:
add_button_label = u'Adicionar %s' % get_metadata(
related_model, 'verbose_name')
add_button_label = get_metadata(related_model, 'add_label',
add_button_label)
interaction = _(u'The user clicks the button')
self._interactions.append(u'%s "%s"' %
(interaction, add_button_label))
self._interactions.append(
_(u'The system displays a popup window'))
self._test_function_code.append(
u"\t\tself.click_button(u'%s')" % add_button_label)
self._test_function_code.append(
u"\t\tself.look_at_popup_window()")
form = factory.get_many_to_one_form(self._mocked_request(),
model(), relation_name,
related_model())
self._fill_out(form)
interaction = _(u'The user clicks the button')
self._interactions.append(u'%s "%s"' % (interaction, button_label))
self._test_function_code.append(u"\t\tself.click_button(u'%s')" %
button_label)
self._test_function_code.append(u"\t\tself.click_icon(u'%s')" %
u'Principal')
else:
raise ValueError(
u'Please add the %s\'s relation in the fieldsets of model %s' %
(related_model.__name__, model.__name__))