def get_component(self, request, as_pdf=False):
verbose_name = getattr(self.relation_model, '_meta').verbose_name
if self.is_one_to_one or self.is_many_to_one:
panel_fieldsets = getattr(self.relation_model, 'fieldsets', None)
if panel_fieldsets:
panel_fieldsets = ((self.relation_verbose_name, panel_fieldsets[0][1]),)
else:
panel_fieldsets = get_fieldsets(self.relation_model, self.relation_verbose_name)
component = ModelPanel(
request, self.relation_value or self.relation_model(),
fieldsets=panel_fieldsets, complete=False
)
if self.view_url and permissions.has_view_permission(request, self.relation_model):
label = 'Detalhar {}'.format(verbose_name)
component.drop_down.add_action(label, self.view_url, 'ajax', 'fa-eye', category=label)
if self.add_url and permissions.has_edit_permission(request, self.model):
label = 'Atualizar {}'.format(verbose_name)
component.drop_down.add_action(label, self.add_url, 'popup', 'fa-edit', category=label)
if self.delete_url and permissions.has_edit_permission(request, self.model):
label = 'Excluir {}'.format(verbose_name)
component.drop_down.add_action(label, self.delete_url, 'popup', 'fa-close', category=label)
else:
inlines = []
fieldsets = getattr(self.model, 'fieldsets', ())
title = self.relation_verbose_name
for fieldset in fieldsets:
fieldset_relations = fieldset[1].get('relations', ())
fieldset_inlines = fieldset[1].get('inlines', ())
fieldset_fields = fieldset[1].get('fields', ())
for inline in fieldset_inlines:
inlines.append(inline)
is_relation = self.relation_name in fieldset_relations
is_inline = self.relation_name in fieldset_inlines
is_field = self.relation_name in fieldset_fields
if is_relation or is_inline or is_field:
if len(fieldset_relations) + len(fieldset_inlines) + len(fieldset_fields) == 1:
title = fieldset[0].split('::')[-1]
if self.is_one_to_many or self.is_many_to_many:
if self.can_add:
has_add_permission = permissions.check_group_or_permission(request, self.can_add)
else:
has_add_permission = permissions.has_add_permission(request, self.model)
else:
has_add_permission = permissions.has_add_permission(request, self.relation_model)
list_subsets = list(self.subsets.keys())
component = Paginator(
request, self.relation_value.all(request.user), title, relation=self,
list_subsets=list_subsets, readonly=not has_add_permission, uid=slugify(self.relation_name)
)
action_names = self.subsets.get(component.current_tab or 'all', [])
component.load_actions(action_names)
instance = self.relation_model()
if self.hidden_field_name:
setattr(instance, self.hidden_field_name, self.instance)
can_add = not hasattr(instance, 'can_add') or instance.can_add()
if self.add_url and has_add_permission and can_add:
if self.relation_name in inlines:
form_name = get_metadata(self.relation_model, 'add_form')
relation_verbose_name = get_metadata(self.relation_model, 'verbose_name')
if form_name:
fromlist = list(map(str, [get_metadata(self.relation_model, 'app_label')]))
module = __import__('{}.forms'.format(fromlist), fromlist=fromlist)
form_cls = getattr(module, form_name)
else:
class Form(ModelForm):
class Meta:
model = self.relation_model
fields = get_metadata(self.relation_model, 'form_fields', '__all__')
exclude = get_metadata(self.relation_model, 'exclude_fields', ())
submit_label = 'Adicionar'
title = 'Adicionar {}'.format(relation_verbose_name)
form_cls = Form
form = form_cls(request, instance=instance, inline=True)
if self.hidden_field_name in form.fields:
del (form.fields[self.hidden_field_name])
if not hasattr(form.instance, 'can_add') or form.instance.can_add():
component.form = form
if form.is_valid():
try:
form.save()
component.message = 'Ação realizada com sucesso'
except ValidationError as e:
form.add_error(None, str(e.message))
else:
add_label = self.add_label or get_metadata(self.relation_model, 'add_label')
label = add_label or 'Adicionar {}'.format(verbose_name)
component.add_action(label, self.add_url, 'popup', 'fa-plus')
component.as_pdf = as_pdf
return component
def __init__(self,
request,
obj,
current_tab=None,
parent=None,
fieldsets=None,
complete=True,
readonly=False,
printable=True):
super(ModelPanel, self).__init__(obj.pk, request)
self.obj = obj
self.title = obj.pk and str(obj) or get_metadata(
type(obj), 'verbose_name')
self.id = self.title
self.tabs = []
self.current_tab = current_tab
self.message = None
self.complete = complete
self.readonly = readonly
self.printable = printable
self.drop_down = None
fieldsets = fieldsets or get_metadata(type(obj), 'view_fieldsets', [])
if not fieldsets:
fieldsets = get_fieldsets(type(obj))
if self.complete:
self.drop_down = ModelDropDown(self.request, type(self.obj))
self.drop_down.add_actions(self.obj, fieldset='')
if self.printable:
print_url = '?pdf={}&pk='.format(self.id)
self.drop_down.add_action('Imprimir',
url=print_url,
css='ajax',
icon='fa-print',
category='Imprimir')
else:
self.drop_down = GroupDropDown(self.request)
self.fieldsets_with_tab_name = []
self.fieldsets_without_tab_name = []
model = type(self.obj)
obj.as_pdf = self.as_pdf
for fieldset in fieldsets:
title, info = fieldset
tab_name = None
drop_down = ModelDropDown(self.request, model)
fieldset_actions = info.get('actions', [])
fieldset_image = info.get('image')
if fieldset_actions:
drop_down.add_actions(self.obj, fieldset=title)
if 'condition' in fieldset[1]:
condition = fieldset[1]['condition']
self.obj.request = self.request
if not check_condition(self.request.user, condition, self.obj):
continue
if '::' in title:
tab_name, title = title.split('::')
url = '/view/{}/{}/{}/{}/'.format(
get_metadata(model, 'app_label'), model.__name__.lower(),
self.obj.pk, slugify(tab_name))
tab = (tab_name, url)
if not self.tabs and not self.current_tab:
self.current_tab = slugify(tab_name)
if tab not in self.tabs:
self.tabs.append(tab)
if not tab_name or slugify(
tab_name) == self.current_tab or self.as_pdf:
fieldset_dict = dict(title=title or 'Dados Gerais',
tab_name=tab_name,
fields=[],
paginators=[],
drop_down=drop_down,
image=None)
relations = list(fieldset[1].get('relations', []))
inlines = list(fieldset[1].get('inlines', []))
if tab_name or self.as_pdf:
self.fieldsets_with_tab_name.append(fieldset_dict)
else:
self.fieldsets_without_tab_name.append(fieldset_dict)
if 'can_view' in fieldset[1]:
can_view = fieldset[1]['can_view']
if not permissions.check_group_or_permission(
self.request, can_view):
continue
if 'image' in fieldset[1]:
fieldset_dict['image'] = fieldset[1]['image']
if 'fields' in fieldset[1]:
for name_or_tuple in fieldset[1]['fields']:
if not type(name_or_tuple) == tuple:
name_or_tuple = (name_or_tuple, )
attr_names = []
for attr_name in name_or_tuple:
if attr_name != parent and attr_name != fieldset_image:
attr = getattr(model, attr_name)
field = None
if hasattr(attr, 'field_name'):
field = getattr(model, '_meta').get_field(
attr.field_name)
elif hasattr(attr, 'field'):
field = attr.field
if not field or not hasattr(
field, 'display') or field.display:
verbose_name, lookup, sortable, to = get_fiendly_name(
model, attr_name, as_tuple=True)
if to and not should_filter_or_display(
self.request, model, to):
continue
attr_names.append(
dict(verbose_name=verbose_name,
name=attr_name))
if attr_names:
fieldset_dict['fields'].append(attr_names)
if self.complete:
from djangoplus.utils.relations import Relation
for relation_name in relations + inlines:
component = Relation(self.obj,
relation_name).get_component(
self.request, self.as_pdf)
fieldset_dict['paginators'].append(component)
else:
for relation_name in relations + inlines:
if relation_name in [
field.name
for field in get_metadata(model, 'get_fields')
]:
relation_field = find_field_by_name(
model, relation_name)
if is_one_to_one(model,
relation_name) or is_many_to_one(
model, relation_name):
fieldset_dict['fields'].append([
dict(verbose_name=relation_field.
verbose_name,
name=relation_name)
])
if 'extra' in fieldset[1]:
fieldset_dict['extra'] = []
for info in fieldset[1]['extra']:
fieldset_dict['extra'].append(info)