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 configure(self):
from djangoplus.ui.components.forms import factory
hidden_fields = []
one_to_one_fields = dict()
one_to_many_fields = dict()
for name in list(self.fields.keys()):
field = self.fields[name]
if type(field) == OneToOneField:
one_to_one_fields[name] = field
del (self.fields[name])
elif type(field) == OneToManyField:
one_to_many_fields[name] = field
del (self.fields[name])
if not self.fieldsets:
fields = list(self.fields.keys()) + list(
one_to_one_fields.keys()) + list(one_to_many_fields.keys())
if self.inline:
self.fieldsets = (('', {'fields': (fields, )}), )
else:
self.fieldsets = (('', {'fields': fields}), )
fieldset_field_names = []
extra_fieldset_field_names = []
for title, fieldset in self.fieldsets:
field_names = fieldset.get('fields', ())
relation_names = fieldset.get('relations', ())
for name_or_tuple in tuple(field_names) + tuple(relation_names):
for name in iterable(name_or_tuple):
fieldset_field_names.append(name)
for field_name in list(self.fields.keys()):
if field_name not in fieldset_field_names:
extra_fieldset_field_names.append(field_name)
if extra_fieldset_field_names:
self.fieldsets += ('Outros', {
'fields': extra_fieldset_field_names,
}),
for title, fieldset in self.fieldsets:
title = '::' in title and title.split('::')[1] or title.split(
'::')[0]
field_names = fieldset.get('fields', ())
relation_names = fieldset.get('relations', ())
configured_fieldset = dict(title=title,
tuples=[],
one_to_one=[],
one_to_many=[])
for name_or_tuple in tuple(field_names) + tuple(relation_names):
fields = []
for name in iterable(name_or_tuple):
if name in self.fields:
field = self.fields[name]
bf = BoundField(self, field, name)
if bf.is_hidden:
hidden_fields.append(bf)
else:
if bf.label:
label = conditional_escape(str(bf.label))
if self.label_suffix:
if label[-1] not in ':?.!':
label += self.label_suffix
label = label or ''
else:
label = ''
help_text = field.help_text or ''
label = str(label)[0:-1]
label = field.required and '{}<span class="text-danger">*</span>'.format(
label) or label
d = dict(name=name,
request=self.request,
label=label,
widget=bf,
help_text=help_text)
fields.append(d)
elif name in one_to_one_fields:
field = one_to_one_fields[name]
one_to_one_id = getattr(self.instance,
'{}_id'.format(name))
form = factory.get_one_to_one_form(self.request,
self.instance,
name,
one_to_one_id,
partial=True,
prefix=name)
required = field.required or form.data.get(
form.prefix, None)
save = form.data.get(form.prefix, None)
if not required:
for field_name in form.fields:
form.fields[field_name].required = False
configured_fieldset['one_to_one'].append(
(field, form, required, save))
self.inner_forms.append(form)
elif name in one_to_many_fields:
field = one_to_many_fields[name]
one_to_many_forms = []
if self.instance.pk:
qs = getattr(self.instance, name).all()
else:
qs = field.queryset.filter(pk=0)
count = qs.count()
for i in range(0, field.one_to_many_max):
instance = i < count and qs[i] or None
form = factory.get_one_to_many_form(
self.request,
self.instance,
name,
partial=True,
inline=True,
prefix='{}{}'.format(name, i),
instance=instance)
form.id = '{}-{}'.format(name, i)
form.hidden = i > count or field.one_to_many_count
required = form.data.get(form.prefix, None)
if not required:
for field_name in form.fields:
form.fields[field_name].required = False
one_to_many_forms.append(form)
self.inner_forms.append(form)
one_to_many_count = None
if field.one_to_many_count:
if type(field.one_to_many_count) is int:
one_to_many_count = field.one_to_many_count
else:
app_label = get_metadata(qs.model, 'app_label')
if '__' in field.one_to_many_count:
tokens = field.one_to_many_count.split(
'__')
model_name = self.fields[tokens[
0]].queryset.model.__name__.lower()
model_lookup = '__'.join(tokens[1:])
one_to_many_count = '{}:/view/{}/{}/PK/?one_to_many_count={}'.format(
tokens[0], app_label, model_name,
model_lookup)
else:
one_to_many_count = field.one_to_many_count
configured_fieldset['one_to_many'].append(
(name, field, one_to_many_forms,
one_to_many_count))
if len(fields) > 2 or mobile(self.request):
self.horizontal = False
configured_fieldset['tuples'].append(fields)
self.configured_fieldsets.append(configured_fieldset)
self.str_hidden = ''.join([str(x) for x in hidden_fields])