def tolist(qs, add_header=True, list_display=()):
model = qs.model
data = []
fields = []
header = []
if type(list_display) == bool or not list_display:
list_display = get_metadata(model, 'list_display', fields)
if list_display:
for field_name in list_display:
header.append(get_fiendly_name(model, field_name))
fields.append(field_name)
else:
for field in get_metadata(model, 'fields'):
header.append(field.verbose_name)
fields.append(field.name)
if add_header:
data.append(header)
for obj in qs:
row = []
for field in fields:
val = getattr2(obj, field)
if callable(val):
val = val()
row.append(format_value(val, False))
data.append(row)
return data
def _configure_column_names(self):
for lookup in self.list_display:
hide_field = False
attr = getattr(self.qs.model, lookup.split('__')[0])
if hasattr(
attr, 'field'
) and attr.field.remote_field and attr.field.remote_field.model:
if hasattr(
attr.field.remote_field.model,
'unit_ptr_id') and self.request.user.role_set.filter(
scope__unit__isnull=False).values_list(
'scope__unit', flat=True).count() == 1:
continue
if hasattr(attr.field.remote_field.model, 'organization_ptr_id'
) and self.request.user.role_set.filter(
scope__organization__isnull=False).values_list(
'scope__organization',
flat=True).count() == 1:
continue
if not should_filter_or_display(self.request, self.qs.model,
attr.field.remote_field.model):
hide_field = True
if not hide_field:
self.column_names.append(
get_fiendly_name(self.qs.model, lookup, as_tuple=True))
def render(self, name, value, attrs=None, renderer=None, choices=()):
has_id = attrs and 'id' in attrs
final_attrs = self.build_attrs(attrs)
values = value and (type(value) == int and [value]
or [int(v) for v in value]) or []
widget_cls = self.allow_multiple_selected and CheckboxInput or RadioSelect
i = 0
grouped_objects = []
onclick = "var is=this.parentNode.parentNode.parentNode.parentNode.parentNode.getElementsByTagName('input');" \
"for(var i=0; i<is.length; i++) is[i].checked = {}".format(
self.allow_multiple_selected and 'this.checked' or 'false')
widget = widget_cls({
'onclick': onclick
}, check_test=lambda v: False).render(None, '')
extra_display = []
if self.choices:
qs = hasattr(
self.choices.queryset,
'all') and self.choices.queryset.all() or self.choices.queryset
select_display = get_metadata(qs.model, 'select_display')
if select_display:
for lookup in get_metadata(qs.model, 'select_display', []):
extra_display.append(
(get_fiendly_name(qs.model, lookup,
as_tuple=False), lookup))
else:
extra_display.append((None, '__str__'))
if self.grouper:
groupers = qs.values_list(self.grouper, flat=True).order_by(
self.grouper).distinct()
else:
groupers = [None]
for grouper in groupers:
objects = []
if grouper:
grouped_qs = qs.filter(**{self.grouper: grouper})
else:
grouped_qs = qs.all()
for obj in grouped_qs:
option_value = obj.pk
if has_id:
final_attrs = dict(final_attrs,
id='{}_{}'.format(attrs['id'], i))
final_attrs[
'class'] = self.allow_multiple_selected and 'custom-checkbox' or 'custom-radio'
obj.widget = widget_cls(
final_attrs,
check_test=lambda v: int(v) in values).render(
name, str(option_value))
i += 1
objects.append(obj)
grouped_objects.append((grouper, objects))
return mark_safe(
render_to_string(
self.template_name,
dict(grouped_objects=grouped_objects,
widget=widget,
extra_display=extra_display,
name=name.replace('-', '_'))))
def get_list_display(model):
l = []
lookups = get_metadata(model, 'list_display', [])
for i, lookup in enumerate(lookups):
if i > 0:
if i == len(lookups) - 1:
l.append(_(' and '))
else:
l.append(', ')
l.append('"%s"' % get_fiendly_name(model, lookup).lower())
return ''.join(l)
def get_list_filter(model):
l = []
lookups = get_metadata(model, 'list_filter', [])
if lookups:
for i, lookup in enumerate(lookups):
l.append('"%s"' % get_fiendly_name(model, lookup).lower())
if i > 0 and i == len(lookups) - 2:
l.append(_(' or '))
elif i < len(lookups) - 2:
l.append(', ')
return ''.join(l)
def get_list_display(model):
output = []
lookups = get_metadata(model, 'list_display', [])
for i, lookup in enumerate(lookups):
if i > 0:
if i == len(lookups) - 1:
output.append(_(' and '))
else:
output.append(', ')
output.append('"{}"'.format(get_fiendly_name(model, lookup).lower()))
return ''.join(output)
def get_list_filter(model):
output = []
lookups = get_metadata(model, 'list_filter', [])
if lookups:
for i, lookup in enumerate(lookups):
output.append('"{}"'.format(get_fiendly_name(model, lookup).lower()))
if i > 0 and i == len(lookups) - 2:
output.append(_(' or '))
elif i < len(lookups) - 2:
output.append(', ')
return ''.join(output)
def get_search_fields(model):
l = []
lookups = get_metadata(model, 'search_fields', [])
if lookups:
for i, lookup in enumerate(lookups):
l.append('"{}"'.format(get_fiendly_name(model, lookup).lower()))
if i > 0 and i == len(lookups) - 2:
l.append(_(' or '))
elif i < len(lookups) - 2:
l.append(',')
return ''.join(l)
def __init__(self, request, title, qs, list_display=()):
header = []
rows = []
if not list_display:
list_display = get_metadata(qs.model, 'list_display')
for lookup in list_display:
header.append(get_fiendly_name(qs.model, lookup, as_tuple=False))
for obj in qs:
row = []
for lookup in list_display:
row.append(getattr2(obj, lookup))
rows.append(row)
super(ModelTable, self).__init__(request, title, header, rows)
def _configure_column_names(self):
for lookup in self.list_display:
hide_field = False
attr = getattr(self.qs.model, lookup.split('__')[0])
if hasattr(attr, 'field') and hasattr(
attr.field,
'rel') and attr.field.rel and attr.field.rel.to:
if self.request.user.unit_id and hasattr(
attr.field.rel.to, 'unit_ptr_id'):
continue
if self.request.user.organization_id and hasattr(
attr.field.rel.to, 'organization_ptr_id'):
continue
if not should_filter_or_display(self.request, self.qs.model,
attr.field.rel.to):
hide_field = True
if not hide_field:
self.column_names.append(
get_fiendly_name(self.qs.model, lookup, as_tuple=True))
def get_action_form(request, obj, action):
action_function = action['function']
action_verbose_name = action['verbose_name']
initial = action['initial']
action_input = action['input']
action_choices = action['choices']
action_display = action['display']
app_label = get_metadata(type(obj), 'app_label')
func = getattr(obj, action_function.__name__, action_function)
if initial and hasattr(obj, initial):
initial = getattr(obj, initial)()
else:
initial = {}
if action_choices and hasattr(obj, action_choices):
action_choices = getattr(obj, action_choices)()
else:
action_choices = {}
if action_input:
# it is a form name
if type(action_input) in [str, str] and '.' not in action_input:
full_app_name = settings.APP_MAPPING.get(app_label, app_label)
fromlist = app_label
module = __import__('{}.forms'.format(full_app_name),
fromlist=list(map(str, [app_label])))
form_cls = getattr(module, action_input)
# it is a model or model name
else:
if type(action_input) in [str, str]:
app_name, class_name = action_input.split('.')
action_input = apps.get_model(app_name, class_name)
class Form(forms.ModelForm):
class Meta:
model = action_input
fields = get_parameters_names(func)
title = action_verbose_name
submit_label = action_verbose_name
form_cls = Form
else:
class Form(forms.ModelForm):
class Meta:
model = func.__self__.__class__
fields = get_parameters_names(func)
title = action_verbose_name
submit_label = action_verbose_name
form_cls = Form
if issubclass(form_cls, forms.ModelForm):
for key in list(initial.keys()):
if hasattr(obj, key) and obj.pk and getattr(obj, key):
del (initial[key])
form = form_cls(request, instance=obj, initial=initial)
else:
form = form_cls(request, initial=initial)
if action_display:
for lookup in action_display:
label = get_fiendly_name(func.__self__.__class__, lookup)
value = getattr2(obj, lookup)
form.fields[lookup] = forms.CharField(
label=label,
initial=value,
required=False,
widget=forms.widgets.DisplayInput(value))
if action_choices:
for field_name in action_choices:
form.fields[field_name].queryset = action_choices[field_name]
if not obj.pk:
verbose_name = get_metadata(obj.__class__, 'verbose_name')
form.fields['instance'] = forms.ModelChoiceField(
type(obj).objects.all(), label=verbose_name)
if form.fieldsets:
form.fieldsets = ((verbose_name, {
'fields': ('instance', )
}), ) + form.fieldsets
return form
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)
def __init__(self,
request,
obj,
current_tab=None,
parent=None,
fieldsets=None,
complete=True):
super(ModelPanel, self).__init__(request=request)
self.obj = obj
self.request = request
self.title = unicode(obj)
self.tabs = []
self.current_tab = current_tab
self.message = None
self.complete = complete
self.drop_down = None
fieldsets = fieldsets or get_metadata(type(obj), 'view_fieldsets', [])
if not fieldsets:
fields = []
for field in get_metadata(type(obj), 'fields')[1:]:
fields.append(field.name)
for field in get_metadata(type(obj), 'local_many_to_many'):
fields.append(field.name)
fieldsets = ((u'Dados Gerais', dict(fields=fields)), )
if self.complete:
self.drop_down = ModelDropDown(self.request, type(self.obj))
self.drop_down.add_actions(self.obj, fieldset_title='')
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', [])
if fieldset_actions:
drop_down.add_actions(self.obj, fieldset_title=title)
if '::' in title:
tab_name, title = title.split('::')
url = '/view/%s/%s/%s/%s/' % (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 u'Dados Gerais',
tab_name=tab_name,
fields=[],
paginators=[],
drop_down=drop_down,
image=None)
relations = fieldset[1].get('relations', [])
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 'condition' in fieldset[1]:
condition = fieldset[1]['condition']
self.obj.request = self.request
if not check_condition(condition, self.obj):
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:
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:
if is_one_to_one(
model, attr_name
) and attr.field.display == 'detail':
relations.append(attr_name)
elif is_one_to_many(
model, attr_name
) and field.display == 'detail':
relations.append(attr_name)
elif is_many_to_one(
model, attr_name
) and field.display == 'detail':
relations.append(attr_name)
elif is_many_to_many(
model, attr_name) and (
not hasattr(field, 'display')
or field.display == 'detail'):
relations.append(attr_name)
elif is_one_to_many_reverse(
model, attr_name):
relations.append(attr_name)
else:
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:
for relation_name in relations:
if relation_name in [
field.name
for field in get_metadata(model, 'get_fields')
]:
relation_field = find_field_by_name(
model, relation_name)
relation = getattr(self.obj, relation_name)
if not relation and hasattr(
relation_field,
'rel') and relation_field.rel.to:
relation = relation_field.rel.to()
if hasattr(relation.__class__, 'pk'):
if relation.pk:
fieldset_title = relation_field.verbose_name
panel_fieldsets = get_metadata(
type(relation), 'view_fieldsets', [])
panel_fieldsets = (
(fieldset_title,
panel_fieldsets[0][1]), )
panel = ModelPanel(
request,
relation,
fieldsets=panel_fieldsets,
complete=False)
if is_one_to_one(model, relation_name):
app_label = get_metadata(
model, 'app_label')
model_name = model.__name__.lower()
related_model_name = type(
relation).__name__.lower()
add_url = '/add/%s/%s/%s/%s' % (
app_label, model_name, self.obj.pk,
relation_name)
delete_url = None
if relation.pk:
add_url = '%s/%s/' % (add_url,
relation.pk)
app_label = get_metadata(
type(relation), 'app_label')
delete_url = '/delete/%s/%s/%s/' % (
app_label, related_model_name,
relation.pk)
if permissions.has_add_permission(
self.request, model
) or permissions.has_edit_permission(
self.request, model):
if delete_url:
panel.drop_down.add_action(
'Excluir %s' %
relation_field.
verbose_name, delete_url,
'popup', 'fa-close', None)
panel.drop_down.add_action(
'Atualizar %s' %
relation_field.verbose_name,
add_url, 'popup', 'fa-edit')
fieldset_dict['paginators'].append(panel)
else:
fieldset_title = len(
relations
) > 1 and title or relation_field.verbose_name
if is_one_to_many(
model,
relation_name) or is_many_to_many(
model, relation_name):
to = model.__name__.lower()
else:
to = relation_name
related_paginator = Paginator(
self.request,
relation.all(),
title=fieldset_title,
to=to,
list_subsets=[])
add_url = '/add/%s/%s/%s/%s/' % (get_metadata(
model, 'app_label'), model.__name__.lower(
), self.obj.pk, relation_name)
if permissions.has_add_permission(
self.request, model
) or permissions.has_relate_permission(
self.request, model):
related_paginator.add_action(
'Adicionar %s' % unicode(
get_metadata(
relation.model,
'verbose_name')), add_url,
'popup', 'fa-plus')
fieldset_dict['paginators'].append(
related_paginator)
else:
is_object_set = False
for related_object in list_related_objects(model):
if relation_name == related_object.get_accessor_name(
):
is_object_set = True
break
relation = getattr(self.obj, relation_name)
if hasattr(relation, 'all'):
qs = relation.all()
elif hasattr(relation, '__call__'):
qs = relation()
else:
qs = relation
to = is_object_set and related_object.field.name or None
fieldset_title = len(
relations) > 1 and get_metadata(
qs.model, 'verbose_name_plural') or title
if hasattr(relation, '_metadata'):
fieldset_title = relation._metadata[
'%s:verbose_name' % relation_name]
exclude = [
is_object_set and related_object.field.name
or ''
]
related_paginator = Paginator(
self.request,
qs,
fieldset_title,
exclude=exclude,
list_subsets=[],
to=to,
readonly=not is_object_set)
if is_object_set and (
permissions.has_add_permission(
self.request, qs.model)
or permissions.has_relate_permission(
self.request, qs.model)):
instance = qs.model()
setattr(instance, related_object.field.name,
self.obj)
if permissions.can_add(self.request, instance):
add_inline = get_metadata(
qs.model, 'add_inline')
if add_inline:
form_name = get_metadata(
qs.model, 'add_form')
if form_name:
fromlist = get_metadata(
qs.model, 'app_label')
forms_module = __import__(
'%s.forms' % fromlist,
fromlist=fromlist)
Form = getattr(
forms_module, form_name)
else:
class Form(ModelForm):
class Meta:
model = qs.model
fields = get_metadata(
qs.model,
'form_fields',
'__all__')
exclude = get_metadata(
qs.model,
'exclude_fields', ())
submit_label = 'Adicionar'
title = u'Adicionar %s' % get_metadata(
qs.model,
'verbose_name')
form = Form(self.request,
instance=instance,
inline=True)
if related_object.field.name in form.fields:
del (form.fields[
related_object.field.name])
related_paginator.form = form
if form.is_valid():
try:
form.save()
self.message = u'Ação realizada com sucesso'
except ValidationError, e:
form.add_error(
None, unicode(e.message))
else:
add_url = '/add/%s/%s/%s/%s/' % (
get_metadata(model, 'app_label'),
model.__name__.lower(),
self.obj.pk,
relation_name.replace('_set', ''))
add_label = u'Adicionar %s' % get_metadata(
qs.model, 'verbose_name')
add_label = get_metadata(
qs.model, 'add_label', add_label)
related_paginator.add_action(
add_label, add_url, 'popup',
'fa-plus')
fieldset_dict['paginators'].append(
related_paginator)
if 'extra' in fieldset[1]:
fieldset_dict['extra'] = []
for info in fieldset[1]['extra']:
fieldset_dict['extra'].append(info)
