class Meta:
model = rel.related_model
fields = get_metadata(rel.related_model, 'form_fields',
'__all__')
exclude = get_metadata(rel.related_model, 'exclude_fields', ())
submit_label = related_obj.pk and u'Atualizar' or button_label
title = form_title
def add(self,
queryset,
start_field,
end_field=None,
color='#ccc',
action_names=[],
as_initial_date=False):
item = dict(queryset=dumps_qs_query(queryset),
start_field=start_field,
end_field=end_field,
color=color,
action_names=','.join(action_names))
self.items.append(item)
if as_initial_date:
qs_initial_date = queryset.order_by(start_field).values_list(
start_field, flat=True)
if qs_initial_date.exists():
self.set_initial_date(qs_initial_date[0])
if queryset.model not in self.models and has_add_permission(
self.request, queryset.model):
label = get_metadata(queryset.model, 'verbose_name')
app_label = get_metadata(queryset.model, 'app_label')
model_name = queryset.model.__name__.lower()
url = '/add/{}/{}/?{}='.format(app_label, model_name, start_field)
link = dict(label=label, url=url)
self.links.append(link)
self.models.append(queryset.model)
def delete(self, *args, **kwargs):
log_data = get_metadata(self.__class__, 'log', False)
log_index = get_metadata(self.__class__, 'logging', ())
if (log_data or log_index) and self._user:
from djangoplus.admin.models import Log
collector = Collector(using='default')
collector.collect([self], keep_parents=False)
for cls, objs in collector.data.items():
content_type = ContentType.objects.get_for_model(cls)
for obj in objs:
log = Log()
log.operation = Log.DELETE
log.user = self._user
log.content_type = content_type
log.object_id = obj.pk
log.object_description = unicode(obj)
diff = []
for field in get_metadata(obj.__class__, 'fields'):
if not isinstance(field, models.FileField):
o1 = getattr(obj, field.name)
v1 = unicode(o1)
diff.append((field.verbose_name, v1))
log.content = json.dumps(diff)
log.save()
log.create_indexes(obj)
super(Model, self).delete(*args, **kwargs)
self.check_role(False)
def all(self, user=None, obj=None):
app_label = get_metadata(self.model, 'app_label')
if user:
role_username = get_metadata(user, 'role_username')
if role_username:
user = get_user_model().objects.get(
username=getattr(user, role_username))
queryset = self._clone()
queryset.user = user
if user:
has_perm = obj and True or user.has_perm(
'%s.list_%s' % (app_label, self.model.__name__.lower()))
else:
has_perm = True
if has_perm:
if user and (user.organization_id or user.unit_id
or not user.is_superuser):
permission_mapping = user.get_permission_mapping(
self.model, obj)
if 'list_lookups' in permission_mapping and permission_mapping[
'list_lookups']:
l = []
for lookup, value in permission_mapping['list_lookups']:
l.append(Q(**{'%s__in' % lookup: value}))
return queryset.filter(reduce(OR, l))
return queryset
return self.none()
def all(self, user=None, obj=None):
app_label = get_metadata(self.model, 'app_label')
if user:
role_username = get_metadata(user, 'role_username')
if role_username:
user = get_user_model().objects.get(
username=getattr(user, role_username))
queryset = self._clone()
queryset._user = user
if user:
self_permission = '{}.view_{}'.format(app_label,
self.model.__name__.lower())
obj_permission = obj and '{}.view_{}'.format(
get_metadata(type(obj), 'app_label'),
type(obj).__name__.lower())
has_perm = obj_permission and user.has_perm(
obj_permission) or user.has_perm(self_permission)
else:
has_perm = True
if has_perm:
if user and not user.is_superuser:
permission_mapping = user.get_permission_mapping(
self.model, obj)
if 'list_lookups' in permission_mapping and permission_mapping[
'list_lookups']:
l = []
for lookup, value in permission_mapping['list_lookups']:
l.append(Q(**{'{}__in'.format(lookup): value}))
return queryset.filter(reduce(OR, l))
return queryset
return self.none()
def reload_options(request, app_name, class_name, current_value, lookup, selected_value, lazy):
l = []
pks = []
if not current_value == '0':
for pk in current_value.split('_'):
pks.append(int(pk))
selected_value = int(selected_value)
lazy = int(lazy)
cls = apps.get_model(app_name, class_name)
select_template = get_metadata(cls, 'select_template')
select_display = get_metadata(cls, 'select_display')
queryset = cls.objects.filter(**{lookup: selected_value})
data = dict(selected_value=selected_value, results=[], qs=lazy and dumps_qs_query(queryset) or None)
if lazy:
if pks:
for obj in cls.objects.filter(pk__in=pks):
html = (select_template or select_display) and render_to_string(select_template or 'select_template.html', dict(obj=obj, select_display=select_display)) or str(obj)
data['results'].append(dict(id=obj.id, text=str(obj), html=html))
else:
for obj in queryset:
html = (select_template or select_display) and render_to_string(select_template or 'select_template.html', dict(obj=obj, select_display=select_display)) or str(obj)
data['results'].append(dict(id=obj.id, text=str(obj), html=html))
s = json.dumps(data)
return HttpResponse(s)
def contextualize(self, user, obj=None):
app_label = get_metadata(self.model, 'app_label')
if user and user.is_authenticated:
role_username = get_metadata(user, 'role_username')
if role_username:
user = get_user_model().objects.get(
username=getattr(user, role_username))
queryset = self._clone()
queryset._user = user
if user:
self_permission = '{}.view_{}'.format(app_label,
self.model.__name__.lower())
obj_permission = obj and '{}.view_{}'.format(
get_metadata(type(obj), 'app_label'),
type(obj).__name__.lower())
has_perm = obj_permission and user.has_perm(
obj_permission) or user.has_perm(self_permission)
else:
has_perm = True
if has_perm:
if user and not user.is_superuser:
queryset = user.apply_current_scope(queryset)
permission_mapping = user.get_permission_mapping(
self.model, obj)
if 'list_lookups' in permission_mapping and permission_mapping[
'list_lookups']:
lookups = []
for lookup, value in permission_mapping['list_lookups']:
lookups.append(Q(**{'{}__in'.format(lookup): value}))
return queryset.filter(reduce(operator.__or__,
lookups)).distinct()
return queryset
return self.none()
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
class Meta:
model = loader.signup_model
fields = get_metadata(loader.signup_model, 'form_fields', '__all__')
exclude = get_metadata(loader.signup_model, 'exclude_fields', ())
submit_label = 'Cadastrar'
title = 'Cadastro de %s' % get_metadata(loader.signup_model, 'verbose_name')
icon = get_metadata(loader.signup_model, 'icon', None)
def __init__(self, request, qs, title=None, list_display=None, list_filter=None, search_fields=None,
list_per_page=25, list_subsets=None, exclude=None, relation=None, readonly=False, is_list_view=False,
help_text=None, url=None, template='datagrid.html', uid=None):
super(Paginator, self).__init__(is_list_view and '_' or abs(hash(title)), request)
if relation:
qs = qs.model.objects.filter(pk__in=qs.values_list('pk', flat=True))
else:
qs = qs.all()
self.qs = qs
self.title = title
self.list_display = list_display
self.list_filter = list_filter
self.search_fields = search_fields
self.list_per_page = list_per_page
self.subsets = None
self.exclude = exclude
self.relation = relation
self.readonly = readonly
self.is_list_view = is_list_view
self.icon = get_metadata(qs.model, 'icon', None)
self.list_total = get_metadata(qs.model, 'list_total', None)
self.ordering = get_metadata(qs.model, 'ordering', None)
self.template = get_metadata(self.qs.model, 'list_template', template)
self.help_text = help_text
self.url = url
self.display_checkboxes = False
self.action_names = None
self.filters = []
self.pagination = ''
self.original_qs = qs
self.count = None
# tabs
self.tabs = []
self.current_tab = self._get_from_request('tab', None)
if list_subsets is not None:
self.subsets = OrderedDict()
for subset_name in list_subsets:
self.subsets[subset_name] = {}
self._load_tabs()
# list display
self._configure_list_display()
# column names
self.column_names = []
self._configure_column_names()
# drop down
self.class_dropdown = GroupDropDown(request, style='class-action')
self.queryset_dropdown = GroupDropDown(request, style='queryset-action disabled')
self.drop_down = ModelDropDown(request, qs.model)
self.mobile = mobile(self.request)
if hasattr(self.qs, 'permission_map'):
self.permission_map = self.qs.permission_map
self.qs = self._filter_queryset(self.qs)
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 autocomplete(request, app_name, class_name):
results = []
q = request.POST['q']
qs = loads_qs_query(request.POST['qs[qs]'])
search_fields = get_metadata(qs.model, 'search_fields', [])
select_template = get_metadata(qs.model, 'select_template')
select_display = get_metadata(qs.model, 'select_display')
queryset = None
if q:
for i, search_field in enumerate(search_fields):
if i == 0:
queryset = qs.filter(**{'%s__icontains' % search_field: q})
else:
queryset = queryset | qs.filter(
**{'%s__icontains' % search_field: q})
if queryset is None:
raise ValueError('The class %s does not have any search field.' %
class_name)
else:
queryset = qs
queryset = queryset.all(request.user)
for obj in queryset[0:25]:
html = (select_template or select_display) and render_to_string(
select_template or 'select_template.html',
dict(obj=obj, select_display=select_display)) or unicode(obj)
results.append(dict(id=obj.id, text=unicode(obj), html=html))
s = json.dumps(dict(q=q, results=results))
return HttpResponse(s)
def __init__(self, request, title, qs, list_display=(), list_filter=()):
super(ModelReport, self).__init__(request)
self.title = title
self.qs = qs
self.components = []
if list_filter:
form = forms.Form(request)
form.icon = 'fa-file-text-o'
form.title = u''
form.submit_label = u'Gerar Relatório'
for field_name in list_filter:
field = get_field(qs.model, field_name)
form.fields[field_name] = forms.ModelChoiceField(
field.rel.to.objects.all(),
label=field.verbose_name,
required=False)
if form.is_valid():
for field_name in list_filter:
value = form.cleaned_data[field_name]
if value:
qs = qs.filter(**{field_name: value})
self.form = form
order_by = get_metadata(qs.model, 'order_by', iterable=True)
if order_by:
qs = qs.order_by(*order_by)
table_description = get_metadata(qs.model, 'verbose_name_plural')
self.table = ModelTable(request, table_description, qs, list_display)
def add_widget(self, obj, item):
model = item['model']
title = item['verbose_name']
func_name = item['function']
dashboard = item['dashboard']
list_display = item.get('list_display')
link = item['link']
l = []
if dashboard:
if type(dashboard) == dict:
for position, group_names in list(dashboard.items()):
group_names = type(
group_names) == tuple and group_names or (
group_names, )
l.append((position, group_names))
else:
l.append((dashboard, item['can_view']))
for position, group_names in l:
if permissions.check_group_or_permission(
self.request, group_names, ignore_superuser=True):
func = getattr(obj, func_name)
f_return = execute_and_format(self.request, func)
if type(f_return) in (int, Decimal):
verbose_name = get_metadata(model,
'verbose_name_plural')
icon = get_metadata(model, 'icon')
panel = NumberPanel(self.request, verbose_name,
f_return, title, icon)
html = str(panel)
elif hasattr(f_return, 'model'):
compact = position in ('left', 'right')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
verbose_name_plural = get_metadata(
model, 'verbose_name_plural')
if link:
title = '{} {}'.format(verbose_name_plural, title)
url = '/list/{}/{}/{}/'.format(app_label, model_name,
func_name)
paginator = Paginator(self.request,
f_return,
title,
readonly=compact,
list_display=list_display,
list_filter=(),
search_fields=(),
list_subsets=[func_name],
url=link and url or None)
if compact and not paginator.template:
paginator.column_names = paginator.column_names[
0:1]
html = str(paginator)
else:
html = str(f_return)
self.add(html, position)
def get_register_form(request, obj):
_model = type(obj)
initial = hasattr(obj, 'initial') and obj.initial() or {}
choices = hasattr(obj, 'choices') and obj.choices() or {}
form_name = get_metadata(_model, 'add_form')
app_label = get_metadata(_model, 'app_label')
verbose_name = get_metadata(_model, 'verbose_name')
role_username = get_metadata(_model, 'role_username', None)
if form_name:
full_app_name = settings.APP_MAPPING.get(app_label, app_label)
forms_module = __import__('{}.forms'.format(full_app_name),
fromlist=list(map(str, [app_label])))
Form = getattr(forms_module, form_name)
else:
if obj.pk:
form_title = '{} {}'.format(_('Edit'), str(verbose_name))
button_label = _('Save')
else:
add_label = get_metadata(_model, 'add_label', None)
form_title = add_label or '{} {}'.format(_('Register'),
str(verbose_name))
button_label = add_label or _('Save')
class Form(forms.ModelForm):
class Meta:
model = _model
fields = get_metadata(_model, 'form_fields', '__all__')
exclude = get_metadata(_model, 'exclude_fields', ())
submit_label = button_label
title = form_title
icon = get_metadata(_model, 'icon', None)
perm_or_group = '{}.add_{}'.format(app_label,
_model.__name__.lower())
class Media:
js = get_js(_model)
form = Form(request, instance=obj, initial=initial)
form.name = '{}Form'.format(_model.__name__)
for field_name in choices:
form.fields[field_name].queryset = choices[field_name]
form.fields[field_name].widget.queryset = choices[field_name]
if hasattr(obj, 'get_parent_field'):
parent_field = obj.get_parent_field()
if parent_field:
if not obj.pk and parent_field.name in form.fields:
form.fields[
parent_field.name].widget = forms.widgets.HiddenInput()
if role_username and obj.pk:
if role_username in form.fields:
form.fields[role_username].widget = forms.widgets.ReadOnlyInput()
return form
class Meta:
model = CACHE['SIGNUP_MODEL']
fields = get_metadata(CACHE['SIGNUP_MODEL'], 'form_fields', '__all__')
exclude = get_metadata(CACHE['SIGNUP_MODEL'], 'exclude_fields', ())
submit_label = _('Register')
title = '{} {}'.format(_('Register'), get_metadata(CACHE['SIGNUP_MODEL'], 'verbose_name'))
icon = get_metadata(CACHE['SIGNUP_MODEL'], 'icon', None)
captcha = settings.CAPTCHA_KEY and settings.CAPTCHA_SECRET and 'test' not in sys.argv or False
class Meta:
model = rel.to
fields = get_metadata(rel.to, 'form_fields', '__all__')
exclude = get_metadata(rel.to, 'exclude_fields', ())
submit_label = u'Adicionar %s' % get_metadata(
rel.to, 'verbose_name')
title = u'Adicionar %s' % get_metadata(rel.to, 'verbose_name')
icon = get_metadata(rel.to, 'icon', None)
class Meta:
model = related_field.rel.to
fields = get_metadata(related_field.rel.to, 'form_fields',
'__all__')
exclude = get_metadata(related_field.rel.to, 'exclude_fields', ())
submit_label = 'Atualizar %s' % related_field.verbose_name
title = u'Atualizar %s' % related_field.verbose_name
icon = get_metadata(related_field.rel.to, 'icon', None)
def load_widgets(self):
from djangoplus.cache import CACHE
for model in CACHE['SUBSETS']:
notification_panels = {}
icon = get_metadata(model, 'icon', 'fa-bell-o')
title = get_metadata(model, 'verbose_name_plural')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
for item in CACHE['SUBSETS'][model]:
description = item['verbose_name']
notify = item['notify']
if notify is True or notify and permissions.check_group_or_permission(
self.request, notify):
attr_name = item['function'].__func__.__name__
qs = model.objects.all(self.request.user)
qs = getattr(qs, attr_name)()
count = qs.count()
if count:
url = '/list/{}/{}/{}/'.format(app_label, model_name,
attr_name)
if model_name in notification_panels:
notification_panel = notification_panels[
model_name]
else:
notification_panel = NotificationPanel(
self.request, title, icon)
self.right.append(notification_panel)
notification_panels[
model_name] = notification_panel
notification_panel.add(count, url, description)
for model in CACHE['LIST_DASHBOARD']:
title = get_metadata(model, 'verbose_name_plural')
position = get_metadata(model, 'dashboard')
paginator = Paginator(self.request,
model.objects.all(self.request.user), title)
self.add(paginator, position)
icon_panel = ShortcutPanel(self.request)
card_panel = CardPanel(self.request)
self.top.append(icon_panel)
self.center.append(card_panel)
for item in CACHE['SUBSET_WIDGETS']:
self.add_widget(item['model'].objects.all(self.request.user), item)
for item in CACHE['WIDGETS']:
if permissions.check_group_or_permission(self.request,
item['can_view'],
ignore_superuser=True):
func = item['function']
position = item['position']
f_return = func(self.request)
html = render_to_string(
['{}.html'.format(func.__name__), 'dashboard.html'],
f_return, self.request)
self.add(html, position)
def __init__(self,
request,
qs,
title=None,
list_display=None,
list_filter=None,
search_fields=None,
list_per_page=25,
list_subsets=None,
exclude=None,
to=None,
readonly=False,
is_list_view=False):
super(Paginator, self).__init__(request)
self.id = abs(hash(title))
self.qs = qs.all()
self.title = title
self.list_display = list_display
self.list_filter = list_filter
self.search_fields = search_fields
self.list_per_page = list_per_page
self.list_subsets = list_subsets
self.exclude = exclude
self.to = to
self.readonly = readonly
self.is_list_view = is_list_view
self.icon = get_metadata(qs.model, 'icon', None)
self.list_total = get_metadata(qs.model, 'list_total', None)
self.subset_actions = []
self.filters = []
self.pagination = ''
self.original_qs = qs
# list display
self._configure_list_display()
# column names
self.column_names = []
self._configure_column_names()
# tabs
self.tabs = []
self.current_tab = self._get_from_request('tab', None)
self._load_tabs()
# drop down
self.paginator_dropdown = GroupDropDown(request)
self.subset_dropdown = GroupDropDown(request)
self.drop_down = ModelDropDown(request, qs.model)
self.mobile = mobile(self.request)
if hasattr(self.qs, 'permission_map'):
self.permission_map = self.qs.permission_map
self.qs = self._filter_queryset(self.qs)
class Meta:
model = _model
fields = get_metadata(_model, 'form_fields', '__all__')
exclude = get_metadata(_model, 'exclude_fields', ())
submit_label = button_label
title = form_title
icon = get_metadata(_model, 'icon', None)
perm_or_group = '{}.add_{}'.format(app_label,
_model.__name__.lower())
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)
def add_models(self, *models):
for model in models:
icon = get_metadata(model, 'icon')
title = get_metadata(model, 'verbose_name_plural')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
url = '/list/{}/{}/'.format(app_label, model_name)
permission = '{}.list_{}'.format(app_label, model_name)
self.add(icon, title, None, url, '', permission)
def add_models(self, *models):
for model in models:
icon = get_metadata(model, 'icon')
title = get_metadata(model, 'verbose_name_plural')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
url = '/list/%s/%s/' % (app_label, model_name)
permission = '%s.list_%s' % (app_label, model_name)
self.add(icon, title, None, url, u'bg-info', permission)
def get_many_to_one_form(request, obj, related_field_name, related_obj):
_model = type(obj)
rel = getattr(_model, related_field_name.split(':')[0].split('__')[0]).rel
add_label = get_metadata(rel.related_model, 'add_label')
if add_label:
form_title = add_label
button_label = add_label
else:
title = _('Add ')
action = _('Save')
form_title = '{} {}'.format(
title, get_metadata(rel.related_model, 'verbose_name'))
button_label = action
related_field_name = rel.field.name
setattr(related_obj, related_field_name, obj)
initial = hasattr(related_obj, 'initial') and related_obj.initial() or {}
choices = hasattr(related_obj, 'choices') and related_obj.choices() or {}
app_label = get_metadata(_model, 'app_label')
form_name = get_metadata(rel.related_model, 'add_form')
if form_name:
full_app_name = settings.APP_MAPPING.get(app_label, app_label)
forms_module = __import__('{}.forms'.format(full_app_name),
fromlist=list(map(str, [app_label])))
Form = getattr(forms_module, form_name)
else:
class Form(forms.ModelForm):
class Meta:
model = rel.related_model
fields = get_metadata(rel.related_model, 'form_fields',
'__all__')
exclude = get_metadata(rel.related_model, 'exclude_fields', ())
submit_label = related_obj.pk and 'Atualizar' or button_label
title = form_title
is_inner = True
class Media:
js = get_js(rel.related_model)
initial[related_field_name] = obj.pk
for key in list(initial.keys()):
if hasattr(obj, key) and obj.pk and getattr(obj, key):
del (initial[key])
form = Form(request, initial=initial, instance=related_obj)
form.form_name = '{}Form'.format(rel.related_model.__name__)
for field_name in choices:
if field_name in form.fields:
form.fields[field_name].queryset = choices[field_name]
if related_field_name in form.fields:
del (form.fields[related_field_name])
return form
class Meta:
model = related_field.remote_field.model
fields = get_metadata(related_field.remote_field.model,
'form_fields', '__all__')
exclude = get_metadata(related_field.remote_field.model,
'exclude_fields', ())
submit_label = 'Atualizar {}'.format(related_field.verbose_name)
title = 'Atualizar {}'.format(related_field.verbose_name)
icon = get_metadata(related_field.remote_field.model, 'icon', None)
is_inner = True
def get_register_form(request, obj):
_model = type(obj)
initial = hasattr(obj, 'initial') and obj.initial() or {}
choices = hasattr(obj, 'choices') and obj.choices() or {}
form_name = get_metadata(_model, 'add_form')
app_label = get_metadata(_model, 'app_label')
verbose_name = get_metadata(_model, 'verbose_name')
role_username = get_metadata(_model, 'role_username', None)
if form_name:
full_app_name = settings.APP_MAPPING.get(app_label, app_label)
forms_module = __import__('%s.forms' % full_app_name,
fromlist=app_label)
Form = getattr(forms_module, form_name)
else:
if obj.pk:
form_title = u'Atualização de %s' % unicode(verbose_name)
button_label = u'Atualizar'
else:
add_label = get_metadata(_model, 'add_label', None)
form_title = add_label or u'Cadastro de %s' % unicode(verbose_name)
button_label = add_label or u'Cadastrar'
class Form(forms.ModelForm):
class Meta:
model = _model
fields = get_metadata(_model, 'form_fields', '__all__')
exclude = get_metadata(_model, 'exclude_fields', ())
submit_label = button_label
title = form_title
icon = get_metadata(_model, 'icon', None)
perm_or_group = '%s.add_%s' % (app_label,
_model.__name__.lower())
form = Form(request, instance=obj, initial=initial)
form.name = u'%sForm' % _model.__name__
for field_name in choices:
form.fields[field_name].queryset = choices[field_name]
form.fields[field_name].widget.queryset = choices[field_name]
if hasattr(obj, 'get_parent_field'):
parent_field = obj.get_parent_field()
if parent_field:
if not obj.pk and parent_field.name in form.fields:
form.fields[
parent_field.name].widget = forms.widgets.HiddenInput()
if role_username and obj.pk:
if role_username in form.fields:
form.fields[role_username].widget = forms.widgets.ReadOnlyInput()
return form
def _find(self, model, registering=False):
click_str = []
click_str_unicode = []
verbose_name_plural = get_metadata(model, 'verbose_name_plural')
list_shortcut = get_metadata(model, 'list_shortcut', [], iterable=True)
list_menu = get_metadata(model, 'list_menu', [], iterable=True)
dashboard = get_metadata(model, 'dashboard')
menu = get_metadata(model, 'menu')
# list_required_role = [role_name for role_name in (list_shortcut + list_menu) if role_name is not True]
# if list_required_role and CACHE['LAST_AUTHENTICATED_ROLE'] and CACHE['LAST_AUTHENTICATED_ROLE'] not in list_required_role:
# self._login('{} {} {}'.format(_('Access'), _('as'), list_required_role[0]))
if dashboard and not registering:
panel_title = verbose_name_plural
interaction = _('The user looks at the painel')
self._interactions.append('{} "{}"'.format(interaction,
panel_title))
self._test_function_code.append(
" self.look_at_panel('{}')".format(panel_title))
return True
elif not CACHE[
'LAST_AUTHENTICATED_ROLE'] or True in list_shortcut or CACHE[
'LAST_AUTHENTICATED_ROLE'] in list_shortcut:
left = _('The user clicks on the shortcut card')
right = _('in the dashboard at main page')
interaction = '{} "{}" {}'.format(left, verbose_name_plural, right)
self._interactions.append(interaction)
self._interactions.append(
_('The system displays the listing page'))
self._test_function_code.append(
' self.click_link(u\'{}\')'.format(verbose_name_plural))
return True
elif menu:
if type(menu) == tuple:
menu = menu[0]
for menu_item in menu.split('::'):
click_str.append('"{}"'.format(menu_item))
click_str_unicode.append("'{}'".format(menu_item))
interaction = _('The user access the menu')
self._interactions.append('{} {}'.format(interaction,
', '.join(click_str)))
self._test_function_code.append(
' self.click_menu({})'.format(
', '.join(click_str_unicode)))
return True
return False
def _view(self, model, recursive=False):
list_shortcut = get_metadata(model, 'list_shortcut', [])
list_menu = get_metadata(model, 'list_menu')
# if the model can be accessed by the menu or shortcut
if list_shortcut or list_menu:
self._find(model)
self._interactions.append(
_(u'The user locates the record and clicks the visualization icon'
))
self._interactions.append(
_(u'The system displays the visualization page'))
self._test_function_code.append(u"\t\tself.click_icon(u'%s')" %
u'Visualizar') # _(u'Visualize')
else:
# the model can be accesses only by a parent model
for parent_model in loader.composition_relations:
if model in loader.composition_relations[parent_model]:
self._view(parent_model, True)
panel_title = None
if hasattr(parent_model, 'fieldsets'):
for fieldset in parent_model.fieldsets:
if 'relations' in fieldset[1]:
for item in fieldset[1]['relations']:
relation = getattr(parent_model, item)
if relation.rel.related_model == model:
panel_title = fieldset[0]
break
if panel_title:
if '::' in panel_title:
tab_name, panel_title = panel_title.split('::')
self._test_function_code.append(
u"\t\tself.click_tab(u'%s')" % tab_name)
interaction = _(u'The user clicks the tab')
self._interactions.append(u'%s "%s"' %
(interaction, tab_name))
if panel_title:
interaction = _(u'The user looks at the painel')
self._interactions.append(
u'%s "%s"' % (interaction, panel_title))
self._test_function_code.append(
u"\t\tself.look_at_panel(u'%s')" % panel_title)
if recursive:
self._interactions.append(
_(u'The user locates the record and clicks the visualization icon'
))
self._interactions.append(
_(u'The system displays the visualization page'))
self._test_function_code.append(
u"\t\tself.click_icon(u'%s')" %
u'Visualizar') # _(u'Visualize')
def get_many_to_one_form(request, obj, related_field_name, related_obj):
_model = type(obj)
rel = getattr(_model, related_field_name).field.rel
add_label = get_metadata(rel.related_model, 'add_label')
if add_label:
form_title = add_label
button_label = add_label
else:
action = related_obj.pk and u'Atualizar' or u'Adicionar'
form_title = u'%s %s' % (
action, get_metadata(rel.related_model, 'verbose_name'))
button_label = action
related_field_name = rel.field.name
setattr(related_obj, related_field_name, obj)
initial = hasattr(related_obj, 'initial') and related_obj.initial() or {}
choices = hasattr(related_obj, 'choices') and related_obj.choices() or {}
app_label = get_metadata(_model, 'app_label')
form_name = get_metadata(rel.related_model, 'add_form')
if form_name:
full_app_name = settings.APP_MAPPING.get(app_label, app_label)
forms_module = __import__('%s.forms' % full_app_name,
fromlist=app_label)
Form = getattr(forms_module, form_name)
else:
class Form(forms.ModelForm):
class Meta:
model = rel.related_model
fields = get_metadata(rel.related_model, 'form_fields',
'__all__')
exclude = get_metadata(rel.related_model, 'exclude_fields', ())
submit_label = related_obj.pk and u'Atualizar' or button_label
title = form_title
initial[related_field_name] = obj.pk
for key in initial.keys():
if hasattr(obj, key) and obj.pk and getattr(obj, key):
del (initial[key])
form = Form(request, initial=initial, instance=related_obj)
form.form_name = u'%sForm' % rel.related_model.__name__
for field_name in choices:
if field_name in form.fields:
form.fields[field_name].queryset = choices[field_name]
if related_field_name in form.fields:
del (form.fields[related_field_name])
return form
