def _load(self):
if settings.DEBUG or 'side_menu' not in self.request.session:
from djangoplus.cache import loader
for item in loader.views:
if item['menu']:
can_view = permissions.check_group_or_permission(
self.request, item['can_view'])
if can_view and 'groups' in item:
can_view = permissions.check_group_or_permission(
self.request, item['groups'])
if can_view:
self._add(item['menu'], item['url'], item['icon'],
item.get('style', 'ajax'))
for cls, itens in list(loader.subsets.items()):
for item in itens:
if permissions.check_group_or_permission(
self.request, item['can_view']):
if False: # TODO False
self._add(item['menu'], item['url'], item['icon'],
'ajax')
self.request.session['side_menu'] = super(Menu, self).__str__()
self.request.session['side_menu_size'] = len(
list(self.subitems.keys()))
self.request.session.save()
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 receive_function_args(request, *args, **kwargs):
if can_execute and not permissions.check_group_or_permission(
request, '{}.{}'.format(model._meta.app_label,
function.__name__)):
return HttpResponseRedirect('/admin/login/')
f_return = function(request, *args, **kwargs)
if 'title' not in f_return:
f_return['title'] = title
if type(f_return) == dict:
if 'pdf' in style:
request.GET._mutable = True
request.GET['pdf'] = 1
request.GET._mutable = False
from datetime import datetime
from djangoplus.admin.models import Settings
app_settings = Settings.default()
f_return[
'logo'] = app_settings.logo_pdf and app_settings.logo_pdf or app_settings.logo
f_return['project_name'] = app_settings.initials
f_return['project_description'] = app_settings.name
f_return['today'] = datetime.now()
template_list = [
'{}.html'.format(function.__name__), 'report.html'
]
return PdfResponse(
render_to_string(template_list,
f_return,
request=request))
else:
template_list = [
'{}.html'.format(function.__name__), 'default.html'
]
return render(request, template or template_list, f_return)
else:
return f_return
def receive_function_args(request, *args, **kwargs):
if can_execute and not permissions.check_group_or_permission(
request, '{}.{}'.format(get_metadata(model, 'app_label'), func.__name__)):
return HttpResponseRedirect('/admin/login/')
f_return = func(request, *args, **kwargs)
template_name = '{}.html'.format(func.__name__)
return return_response(f_return, request, verbose_name, style, template_name)
def delete(request, app, cls, pk, related_field_name=None, related_pk=None):
try:
_model = apps.get_model(app, cls)
except LookupError:
return page_not_found(request)
obj = _model.objects.all(request.user).get(pk=pk)
obj.request = request
permission_name = '%s.delete_%s' % (app, cls)
if permissions.can_delete(request,
obj) and permissions.check_group_or_permission(
request, permission_name):
if related_field_name:
getattr(obj, related_field_name).remove(related_pk)
return httprr(request, '..', u'Removido com sucesso')
else:
title = u'Excluir %s' % unicode(obj)
form = factory.get_delete_form(request, obj)
if form.is_valid():
obj.delete()
return httprr(request, '..',
u'Exclusão realizada com sucesso.')
return render(request, 'delete.html', locals())
else:
return HttpResponseForbidden()
def receive_function_args(request, *args, **kwargs):
without_permission = can_view and not permissions.check_group_or_permission(
request, 'admin.%s' % function.func_name)
without_authentication = login_required and not request.user.is_authenticated(
)
if without_permission or without_authentication:
return HttpResponseRedirect('/admin/login/?next=%s' % url)
f_return = function(request, *args, **kwargs)
if type(f_return) == dict:
f_return['title'] = title % f_return
if 'pdf' in style:
template_list = [
'%s.html' % function.func_name, 'report.html'
]
return PdfResponse(
render_to_string(template_list,
f_return,
request=request))
else:
template_list = [
template or '%s.html' % function.func_name,
'default.html'
]
return render(request, template_list, f_return)
return f_return
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 receive_function_args(request, *args, **kwargs):
without_permission = can_view and not permissions.check_group_or_permission(request, can_view)
without_authentication = login_required and not request.user.is_authenticated
if without_permission or without_authentication:
return HttpResponseRedirect('/admin/login/?next={}'.format(url))
f_return = func(request, *args, **kwargs)
template_name = template or '{}.html'.format(func.__name__)
return return_response(f_return, request, verbose_name, style, template_name)
def load(self):
if settings.DEBUG or 'side_menu' not in self.request.session:
from djangoplus.cache import loader
for item in loader.views:
if item['menu']:
if permissions.check_group_or_permission(self.request, item['can_view']):
self.add(item['menu'], item['url'], item['icon'], item.get('style', 'ajax'))
for cls, itens in loader.subsets.items():
for item in itens:
if permissions.check_group_or_permission(self.request, item['can_view']):
if False: # TODO False
self.add(item['menu'], item['url'], item['icon'], 'ajax')
self.request.session['side_menu'] = self.render('menu.html')
self.request.session['side_menu_size'] = len(self.subitems.keys())
self.request.session.save()
def __init__(self, request):
super(CardPanel, self).__init__('cardpanel', request)
self.items = []
from djangoplus.cache import loader
for model, list_shortcut in loader.card_panel_models:
if type(list_shortcut) == bool:
add_model = list_shortcut
else:
if not type(list_shortcut) in (list, tuple):
list_shortcut = list_shortcut,
add_model = request.user.in_group(*list_shortcut)
if add_model or request.user.is_superuser:
if permissions.has_list_permission(request, model):
self.add_model(model)
if model in loader.subsets:
icon = get_metadata(model, 'icon')
title = get_metadata(model, 'verbose_name_plural')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
for item in loader.subsets[model]:
can_view = item['can_view']
# TODO False
if False and permissions.check_group_or_permission(
self.request, can_view):
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)
self.add(icon, title, count, url, 'bg-info',
None, item['title'])
for item in loader.views:
if False: # TODO False
if permissions.check_group_or_permission(
request, item['can_view']):
self.add(item['icon'], item['menu'], None, item['url'],
'bg-info', item['can_view'], item['style'])
def __init__(self, request):
super(CardPanel, self).__init__('cardpanel', request)
self.items = []
from djangoplus.cache import CACHE
for model, list_shortcut in CACHE['CARD_PANEL_MODELS']:
if type(list_shortcut) == bool:
add_model = list_shortcut
else:
if not type(list_shortcut) in (list, tuple):
list_shortcut = list_shortcut,
add_model = request.user.in_group(*list_shortcut)
if add_model or request.user.is_superuser:
if permissions.has_list_permission(request, model):
self.add_model(model)
if model in CACHE['SUBSETS']:
icon = get_metadata(model, 'icon')
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]:
can_view = item['can_view']
# TODO False
if False and permissions.check_group_or_permission(
self.request, can_view):
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)
self.add(icon, title, count, url, '', None,
item['verbose_name'])
for item in CACHE['SUBSET_WIDGETS']:
if item.get('shortcut'):
if permissions.check_group_or_permission(
request, item['can_view']):
icon = item.get('icon', get_metadata(model, 'icon'))
self.add(item['icon'], item['verbose_name'], None,
item['url'], item['can_view'], '')
def _load(self):
if settings.DEBUG or 'side_menu' not in self.request.session:
for item in CACHE['VIEWS']:
if item['menu']:
can_view = permissions.check_group_or_permission(
self.request, item['can_view']
)
if can_view and 'groups' in item:
can_view = permissions.check_group_or_permission(
self.request, item['groups']
)
if can_view:
self._add(
item['menu'], item['url'], item['icon'], item.get('style', 'ajax')
)
self.request.session['side_menu'] = super(Menu, self).__str__()
self.request.session['side_menu_size'] = len(list(self.subitems.keys()))
self.request.session.save()
def _load_tabs(self):
from djangoplus.cache import loader
subsets = []
if self.subsets is None:
subsets = loader.subsets[self.qs.model]
elif self.subsets:
for subset_name in self.subsets.keys():
for subset in loader.subsets[self.qs.model]:
if subset['name'] == subset_name:
subsets.append(subset)
tab_qs = None
active_queryset = None
create_default_tab = True
for subset in subsets:
tab_title = subset['verbose_name']
tab_function = subset['function']
tab_can_view = subset['can_view']
tab_name = subset['name']
tab_help_text = subset['help_text']
tab_order = subset['order']
tab_list_display = subset['list_display']
tab_list_filter = subset['list_filter']
tab_search_fields = subset['search_fields']
tab_active = False
if permissions.check_group_or_permission(self.request, tab_can_view):
tab_qs = getattr(self.qs, tab_function.__func__.__name__)()
tab_active = self.current_tab == tab_name
self.tabs.append([tab_name, tab_title, tab_qs, tab_active, tab_order, tab_help_text])
if (tab_active or len(subsets) == 1) and tab_help_text:
self.help_text = tab_help_text
if tab_name == 'all':
create_default_tab = False
if tab_active:
active_queryset = tab_qs
self.drop_down = ModelDropDown(self.request, self.qs.model)
self.list_display = tab_list_display
self.list_filter = tab_list_filter
self.search_fields = tab_search_fields
self.tabs = sorted(self.tabs, key=lambda k: k[4])
if (self.subsets is None or self.relation) and create_default_tab:
tab_title = get_metadata(self.qs.model, 'verbose_female') and 'Todas' or 'Todos'
tab_qs = self.original_qs.all()
tab_active = self.current_tab == 'all'
if tab_active:
active_queryset = tab_qs
tab_order = 0
self.tabs.insert(0, ['', tab_title, tab_qs, tab_active, tab_order, None])
if active_queryset is not None:
self.qs = active_queryset
elif self.tabs:
self.tabs[0][3] = True
self.qs = self.tabs[0][2]
def listt(request, app, cls, subset=None):
try:
_model = apps.get_model(app, cls)
except LookupError as e:
return page_not_found(request, e, 'error404.html')
title = get_metadata(_model, 'verbose_name_plural')
subsetp = None
list_display = None
list_filter = None
search_fields = None
if subset:
subset_func = getattr(_model.objects.get_queryset(), subset)
can_view = get_metadata(subset_func, 'can_view')
list_display = get_metadata(subset_func, 'list_display')
list_filter = get_metadata(subset_func, 'list_filter')
search_fields = get_metadata(subset_func, 'search_fields')
title = '{} - {}'.format(title,
get_metadata(subset_func, 'verbose_name'))
else:
tid = request.GET.get('tid')
subsetp = request.GET.get('tab{}'.format(tid))
if tid and subsetp:
subset_func = getattr(_model.objects.get_queryset(), subsetp)
subset_title = get_metadata(subset_func, 'verbose_name')
can_view = get_metadata(subset_func, 'can_view')
title = '{} - {}'.format(title,
get_metadata(subset_func, 'verbose_name'))
if not permissions.check_group_or_permission(request, can_view):
return httprr(
request,
'/admin/login/?next={}'.format(request.get_full_path()))
else:
permission = '{}.list_{}'.format(app, cls)
if not request.user.has_perm(permission):
return httprr(
request,
'/admin/login/?next={}'.format(request.get_full_path()))
qs = _model.objects.all(request.user)
list_subsets = subset and [subset] or None
paginator = Paginator(request,
qs,
title,
list_subsets=list_subsets,
is_list_view=True,
list_display=list_display,
list_filter=list_filter,
search_fields=search_fields)
paginator.process_request()
paginator.load_actions()
return render(request, 'default.html', locals())
def add(self,
icon,
description,
count=None,
url=None,
perm_or_group=None,
style='ajax'):
if permissions.check_group_or_permission(self.request, perm_or_group):
item = dict(icon=icon,
description=description,
count=count,
url=url or '#',
style=style)
self.items.append(item)
def add(self,
icon,
title,
count=None,
url=None,
css='',
perm_or_group=None,
description=''):
if permissions.check_group_or_permission(self.request, perm_or_group):
item = dict(icon=icon,
title=title,
count=count,
url=url,
css=css,
description=description)
self.items.append(item)
def context_processor(request):
executing_tests = 'test' in sys.argv
app_settings = Settings.default()
alerts = []
menu = None
if request.user.is_authenticated:
menu = Menu(request, app_settings)
for model in loader.subsets:
icon = get_metadata(model, 'icon', 'fa-warning')
title = get_metadata(model, 'verbose_name_plural')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
for item in loader.subsets[model]:
can_view = item['can_view']
alert = item['alert']
if alert and permissions.check_group_or_permission(
request, can_view):
attr_name = item['function'].__func__.__name__
qs = model.objects.all(request.user)
qs = getattr(qs, attr_name)()
count = qs.count()
if count:
url = '/list/{}/{}/{}/'.format(app_label, model_name,
attr_name)
description = item['verbose_name'].replace(title, '')
item = dict(title=title,
description=description,
count=count,
url=url,
icon=icon)
alerts.append(item)
return dict(debug=settings.DEBUG,
role_selector=RoleSelector(request),
username_mask=settings.USERNAME_MASK,
js_files=settings.EXTRA_JS,
css_files=settings.EXTRA_CSS,
settings=app_settings,
menu=menu,
alerts=alerts,
display_emails=settings.DEBUG and not executing_tests
and should_display(),
display_fake_mouse=test.CACHE['RECORD'],
executing_tests=executing_tests,
default_template='default.html')
def _load_tabs(self):
from djangoplus.cache import loader
if self.list_subsets is None:
list_subsets = loader.subsets[self.qs.model]
else:
list_subsets = []
for subset_name in self.list_subsets:
for subset in loader.subsets[self.qs.model]:
if subset['name'] == subset_name:
list_subsets.append(subset)
create_default_tab = True
for subset in list_subsets:
tab_title = subset['title']
tab_function = subset['function']
tab_can_view = subset['can_view']
tab_name = subset['name']
tab_order = subset['order']
tab_active = False
if permissions.check_group_or_permission(self.request,
tab_can_view):
tab_qs = tab_function()
tab_qs = tab_qs.all(self.request.user)
tab_active = self.current_tab == tab_name
self.tabs.append(
[tab_name, tab_title, tab_qs, tab_active, tab_order])
if tab_name == 'all':
create_default_tab = False
if tab_active:
self.qs = tab_qs
self.drop_down = ModelDropDown(self.request, self.qs.model)
self.tabs = sorted(self.tabs, key=lambda k: k[4])
if self.list_subsets is None and create_default_tab:
tab_title = get_metadata(self.qs.model,
'verbose_female') and 'Todas' or 'Todos'
tab_qs = self.original_qs
tab_active = self.current_tab == 'all'
tab_order = 0
self.tabs.insert(0, ['', tab_title, tab_qs, tab_active, tab_order])
if not self.current_tab and self.tabs:
self.tabs[0][3] = True
self.qs = self.tabs[0][2]
def receive_function_args(request, *args, **kwargs):
without_permission = can_view and not permissions.check_group_or_permission(
request, can_view)
without_authentication = login_required and not request.user.is_authenticated
if without_permission or without_authentication:
return HttpResponseRedirect(
'/admin/login/?next={}'.format(url))
f_return = function(request, *args, **kwargs)
if 'title' not in f_return:
f_return['title'] = title
if type(f_return) == dict:
for key in f_return:
if hasattr(f_return[key], 'process_request'):
f_return[key].process_request()
if 'pdf' in style:
request.GET._mutable = True
request.GET['pdf'] = 1
request.GET._mutable = False
from datetime import datetime
from djangoplus.admin.models import Settings
app_settings = Settings.default()
f_return[
'logo'] = app_settings.logo_pdf and app_settings.logo_pdf or app_settings.logo
f_return['project_name'] = app_settings.initials
f_return['project_description'] = app_settings.name
f_return['today'] = datetime.now()
template_list = [
'{}.html'.format(function.__name__), 'report.html'
]
return PdfResponse(
render_to_string(template_list,
f_return,
request=request))
else:
template_list = [
template or '{}.html'.format(function.__name__),
'default.html'
]
return render(request, template_list, f_return)
return f_return
def context_processor(request):
app_settings = Settings.default()
alerts = []
menu = None
if request.user.is_authenticated:
menu = Menu(request, app_settings)
menu.load()
for model in loader.subsets:
icon = get_metadata(model, 'icon', u'fa-warning')
title = get_metadata(model, 'verbose_name_plural')
app_label = get_metadata(model, 'app_label')
model_name = model.__name__.lower()
for item in loader.subsets[model]:
can_view = item['can_view']
alert = item['alert']
if alert and permissions.check_group_or_permission(
request, can_view):
attr_name = item['function'].im_func.func_name
qs = model.objects.all(request.user)
qs = getattr(qs, attr_name)()
count = qs.count()
if count:
url = '/list/%s/%s/%s/' % (app_label, model_name,
attr_name)
item = dict(title=title,
description=item['title'],
count=count,
url=url,
icon=icon)
alerts.append(item)
return dict(js_files=settings.EXTRA_JS,
css_files=settings.EXTRA_CSS,
settings=app_settings,
menu=menu,
alerts=alerts)
def __init__(self, request):
from djangoplus.cache import loader
super(ShortcutPanel, self).__init__('shortcutpanel', request)
self.items = []
for model, add_shortcut in loader.icon_panel_models:
if type(add_shortcut) == bool:
add_model = add_shortcut
else:
if not type(add_shortcut) in (list, tuple):
add_shortcut = add_shortcut,
add_model = request.user.in_group(*add_shortcut)
if add_model or request.user.is_superuser:
if permissions.has_add_permission(request, model):
self.add_model(model)
for item in loader.views:
if item['add_shortcut']:
if permissions.check_group_or_permission(
request, item['can_view']):
self.add(item['icon'], item['verbose_name'], None,
item['url'], item['can_view'], item['style'])
def receive_function_args(request, *args, **kwargs):
if can_execute and not permissions.check_group_or_permission(
request, '%s.%s' %
(model._meta.app_label, function.func_name)):
return HttpResponseRedirect('/admin/login/')
f_return = function(request, *args, **kwargs)
if type(f_return) == dict:
if 'pdf' in style:
template_list = [
'%s.html' % function.func_name, 'report.html'
]
return PdfResponse(
render_to_string(template_list,
f_return,
request=request))
else:
template_list = [
'%s.html' % function.func_name, 'default.html'
]
return render(request, template or template_list, f_return)
else:
return f_return
def add_actions(self,
obj,
inline=False,
fieldset_title=None,
subset_name=None,
category=None):
from djangoplus.cache import loader
obj.request = self.request
if not self.actions_cache:
self.actions_cache = self.actions
self.hash = abs(datetime.now().__hash__())
self.actions = copy.deepcopy(self.actions_cache)
self.obj = obj
if inline:
if self.model in loader.add_inline_actions:
for add_inline_action in loader.add_inline_actions[self.model]:
if add_inline_action['subset'] is True or add_inline_action[
'subset'] == subset_name:
if permissions.check_group_or_permission(
self.request,
add_inline_action['can_execute']):
self.add_action(add_inline_action['title'],
add_inline_action['url'], 'popup',
'fa fa-plus')
for action_category in loader.actions[self.model]:
for view_name in loader.actions[self.model][action_category]:
action = loader.actions[self.model][action_category][view_name]
action_function = action.get('function')
action_title = action['title']
action_can_execute = action['can_execute']
action_condition = action['condition']
action_css = action['css']
action_input = action['input']
action_inline = action['inline']
action_icon = action['icon']
action_name = action_function.__name__
is_action_view = not hasattr(self.model, action_name)
if action_name and action_css == 'popup' and not is_action_view:
func = getattr(self.model, action_name)
action_css = (func.__code__.co_argcount > 1
or action_input) and action_css or 'ajax'
# it is a dropdown in a model panel
if fieldset_title is not None:
if fieldset_title:
if action_name not in loader.fieldset_actions[
self.model][fieldset_title]:
continue
else:
# if the action was included in any fieldset it can not be displayed in page's action panel
add_action = True
for fieldset_title2, action_names in list(
loader.fieldset_actions[self.model].items()):
if action_name in action_names:
add_action = False
break
if not add_action:
continue
else:
# it is a dropdown in a paginator
if action_inline is not True and (
subset_name
not in loader.subset_actions[self.model]
or action_name not in loader.subset_actions[
self.model][subset_name]):
continue
if not permissions.check_group_or_permission(
self.request, action_can_execute):
continue
if not check_condition(action_condition, obj):
continue
if is_action_view:
action_url = '/{}/{}/'.format(
get_metadata(self.model, 'app_label'), action_name)
else:
action_url = '/action/{}/{}/{}/'.format(
get_metadata(self.model, 'app_label'),
self.model.__name__.lower(), view_name)
self.add_action(action_title, action_url, action_css,
action_icon, category or action_category)
def action(request, app, cls, action_name, pk=None):
try:
_model = apps.get_model(app, cls)
except LookupError as e:
return page_not_found(request, e, 'error404.html')
for group in loader.instance_actions[_model]:
if action_name in loader.instance_actions[_model][group]:
break
form_action = loader.instance_actions[_model][group][action_name]
action_verbose_name = form_action['verbose_name']
action_can_execute = form_action['can_execute']
action_condition = form_action['condition']
action_function = form_action['function']
action_message = 'message' in form_action and form_action['message'] or None
action_permission = '{}.{}'.format(_model._meta.app_label,
action_function.__name__)
action_input = form_action['input']
action_display = form_action['display']
action_style = form_action['style']
action_redirect = form_action['redirect_to']
obj = pk and _model.objects.all(
request.user).distinct().get(pk=pk) or _model()
obj.request = request
obj._user = request.user
title = action_verbose_name
redirect_to = None
if check_condition(request.user, action_condition,
obj) and (not action_can_execute
or permissions.check_group_or_permission(
request, action_permission)):
f_return = None
func = getattr(_model, action_function.__name__, action_function)
form = factory.get_action_form(request, obj, form_action)
if count_parameters_names(func) > 1 or action_input:
if form.is_valid():
if 'instance' in form.fields:
obj = form.cleaned_data['instance']
func = getattr(obj, action_function.__name__, action_function)
params = []
for param in get_parameters_names(func,
include_annotated=True):
if param in form.cleaned_data:
params.append(form.cleaned_data[param])
else:
params.append(
get_role_value_for_action(func, request.user,
param))
try:
f_return = func(*params)
if not action_redirect:
if count_parameters_names(func) > 0 or action_display:
redirect_to = '..'
else:
redirect_to = '.'
else:
redirect_to = Template(action_redirect).render(
Context({'self': obj}))
except ValidationError as e:
form.add_error(None, str(e.message))
else:
try:
if form.fields and form.is_valid() or not form.fields:
if 'instance' in form.fields:
obj = form.cleaned_data['instance']
func = getattr(obj, action_function.__name__,
action_function)
params = []
for param in get_parameters_names(func,
include_annotated=True):
params.append(
get_role_value_for_action(func, request.user,
param))
f_return = func(*params)
if not action_redirect:
if count_parameters_names(func) > 0 or action_display:
redirect_to = '..'
else:
redirect_to = '.'
else:
redirect_to = Template(action_redirect).render(
Context({'self': obj}))
except ValidationError as e:
if form.fields:
form.add_error(None, str(e.message))
return httprr(request, '.', e.message, error=True)
if f_return:
template_name = '{}.html'.format(action_function.__name__)
return return_response(f_return, request, title, action_style,
template_name)
elif redirect_to:
return httprr(request, redirect_to, action_message)
if form.title == _('Form'):
form.title = action_verbose_name
if form.submit_label == _('Send'):
form.submit_label = action_verbose_name
return render(request, 'default.html', locals())
else:
return HttpResponseForbidden()
def add_actions(self,
obj,
fieldset=None,
subset_name=None,
category=None,
action_names=None):
from djangoplus.cache import CACHE
obj.request = self.request
if not self.actions_cache:
self.actions_cache = self.actions
if not action_names:
action_names = []
self.hash = abs(datetime.now().__hash__())
self.actions = copy.deepcopy(self.actions_cache)
self.obj = obj
for action_category in CACHE['INSTANCE_ACTIONS'][self.model]:
for view_name in CACHE['INSTANCE_ACTIONS'][
self.model][action_category]:
action = CACHE['INSTANCE_ACTIONS'][
self.model][action_category][view_name]
action_function = action.get('function')
action_verbose_name = action['verbose_name']
action_can_execute = get_can_execute(action)
action_condition = action['condition']
action_style = action['style']
action_input = action['input']
action_inline = action['inline']
action_subsets = action['subsets']
action_icon = action['icon']
action_display = action['display']
action_expose = action['expose']
action_name = action_function.__name__
is_action_view = not hasattr(self.model, action_name)
if action_name and action_style == 'popup' and not is_action_view:
func = getattr(self.model, action_name)
if not (count_parameters_names(func) > 1 or action_input
or action_display):
action_style = 'ajax'
# it is a dropdown in a model panel
if fieldset is not None:
if fieldset:
if action_name not in CACHE['FIELDSET_ACTIONS'][
self.model][fieldset]:
continue
else:
# if the action was included in any fieldset,
# it can not be displayed in page's action panel
add_action = True
for title, action_names in list(
CACHE['FIELDSET_ACTIONS'][self.model].items()):
if action_name in action_names:
add_action = False
break
if not add_action:
continue
else:
# it is a dropdown in a paginator
if action_names:
# it is a relation paginator
if view_name not in action_names:
continue
else:
# it is a list view paginator
should_add_this_action = should_add_action(
action_inline, action_subsets, subset_name)
add_action = view_name in action_names or should_add_this_action
if not add_action:
continue
lookups = self.request.user.get_permission_mapping(
self.model, obj).get(action_name)
if lookups:
forbidden = True
for key, value in lookups:
if self.model.objects.filter(pk=obj.pk,
**{
'{}__in'.format(key):
value
}).exists():
forbidden = False
break
if forbidden:
continue
if True not in action_expose and 'web' not in action_expose:
continue
if not permissions.check_group_or_permission(
self.request, action_can_execute):
continue
if not check_condition(self.request.user, action_condition,
obj):
continue
if is_action_view:
action_url = '/{}/{}/'.format(
get_metadata(self.model, 'app_label'), action_name)
else:
action_url = '/action/{}/{}/{}/'.format(
get_metadata(self.model, 'app_label'),
self.model.__name__.lower(), view_name)
action_category = category or action_category
self.add_action(action_verbose_name, action_url, action_style,
action_icon, action_category)
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 action(request, app, cls, action_name, pk=None):
try:
_model = apps.get_model(app, cls)
except LookupError as e:
return page_not_found(request, e, 'error404.html')
for group in loader.actions[_model]:
if action_name in loader.actions[_model][group]:
break
form_action = loader.actions[_model][group][action_name]
action_title = form_action['title']
action_can_execute = form_action['can_execute']
action_condition = form_action['condition']
action_function = form_action['function']
action_message = 'message' in form_action and form_action['message'] or None
action_permission = '{}.{}'.format(_model._meta.app_label,
action_function.__name__)
action_input = form_action['input']
redirect_to = form_action['redirect_to']
obj = pk and _model.objects.all(request.user).get(pk=pk) or _model()
obj.request = request
obj._user = request.user
title = action_title
if check_condition(action_condition,
obj) and (not action_can_execute
or permissions.check_group_or_permission(
request, action_permission)):
func = getattr(_model, action_function.__name__, action_function)
form = factory.get_action_form(request, obj, form_action)
if func.__code__.co_argcount > 1 or action_input:
if form.is_valid():
if 'instance' in form.fields:
obj = form.cleaned_data['instance']
func = getattr(obj, action_function.__name__, action_function)
params = []
for param in func.__code__.co_varnames[1:func.__code__.
co_argcount]:
if param in form.cleaned_data:
params.append(form.cleaned_data[param])
try:
f_return = func(*params)
if not redirect_to:
if func.__code__.co_argcount > 1:
return httprr(request, '..', action_message)
else:
return httprr(request, '.', action_message)
else:
return httprr(
request,
Template(redirect_to).render(Context({'self':
obj})),
action_message)
except ValidationError as e:
form.add_error(None, str(e.message))
else:
try:
if form.fields and form.is_valid() or not form.fields:
if form.fields:
obj = form.cleaned_data['instance']
func = getattr(obj, action_function.__name__,
action_function)
f_return = func()
if not redirect_to:
if func.__code__.co_argcount > 1:
return httprr(request, '..', action_message)
else:
return httprr(request, '.', action_message)
else:
return httprr(
request,
Template(redirect_to).render(Context({'self':
obj})),
action_message)
except ValidationError as e:
return httprr(request, '.', str(e.message))
if form.title == DEFAULT_FORM_TITLE:
form.title = action_title
if form.submit_label == DEFAULT_SUBMIT_LABEL:
form.submit_label = action_title
return render(request, 'default.html', locals())
else:
return HttpResponseForbidden()
def load_actions(self, action_names=None):
from djangoplus.cache import CACHE
export_url = self.request.get_full_path()
list_csv = get_metadata(self.qs.model, 'list_csv')
list_xls = get_metadata(self.qs.model, 'list_xls')
log = get_metadata(self.qs.model, 'log')
app_label = get_metadata(self.qs.model, 'app_label')
list_pdf = get_metadata(self.qs.model, 'list_pdf')
self.action_names = action_names or []
subset = self.subsets and list(self.subsets.keys())[0] or None
subsetp = self.request.GET.get('tab{}'.format(
self.request.GET.get('tid')))
subset_name = subsetp or subset
# class actions defined in the manager
if self.qs.model in CACHE['CLASS_ACTIONS']:
for group in CACHE['CLASS_ACTIONS'][self.qs.model]:
for view_name in CACHE['CLASS_ACTIONS'][self.qs.model][group]:
_action = CACHE['CLASS_ACTIONS'][
self.qs.model][group][view_name]
action_verbose_name = _action['verbose_name']
action_inline = _action['inline']
action_subsets = _action['subsets']
action_can_execute = _action['can_execute']
action_category = _action['group']
action_expose = _action['expose']
action_style = _action['style'] or 'popup'
if 'popup' not in action_style:
action_style = '{} popup'.format(action_style)
if self.is_list_view or view_name in self.action_names:
add_action = should_add_action(action_inline,
action_subsets,
subset_name)
add_action = add_action and (True in action_expose
or 'web' in action_expose)
if add_action and permissions.check_group_or_permission(
self.request, action_can_execute):
func = getattr(self.qs, view_name)
ignore_pdf = False
if count_parameters_names(func) > 0:
action_style = action_style.replace('pdf', '')
ignore_pdf = True
char = '?' in self.request.get_full_path(
) and '&' or '?'
url = '{}{}{}'.format(self.request.get_full_path(),
char,
'{}='.format(view_name))
self.add_action(action_verbose_name, url,
action_style, None,
action_category)
if view_name in self.request.GET:
self._proccess_request(func, _action,
ignore_pdf)
# subset actions defined in the manager
if self.qs.model in CACHE['QUERYSET_ACTIONS']:
for group in CACHE['QUERYSET_ACTIONS'][self.qs.model]:
for view_name in CACHE['QUERYSET_ACTIONS'][
self.qs.model][group]:
_action = CACHE['QUERYSET_ACTIONS'][
self.qs.model][group][view_name]
action_verbose_name = _action['verbose_name']
action_can_execute = _action['can_execute']
action_inline = _action['inline']
action_icon = _action['icon']
action_subsets = _action['subsets']
action_condition = _action['condition']
action_source = _action['source']
action_category = _action['group']
action_expose = _action['expose']
action_style = _action['style'] or 'popup'
if 'popup' not in action_style:
action_style = '{} popup'.format(action_style)
if view_name in self.action_names or (
self.is_list_view
and action_inline) or (self.current_tab
in action_subsets):
add_action = should_add_action(action_inline,
action_subsets,
subset_name)
add_action = add_action and (True in action_expose
or 'web' in action_expose)
if add_action and permissions.check_group_or_permission(
self.request, action_can_execute):
self.display_checkboxes = self.display_checkboxes or not action_source == 'view'
func = getattr(self.qs, view_name)
ignore_pdf = False
char = '?' in self.request.get_full_path(
) and '&' or '?'
url = '{}{}{}'.format(self.request.get_full_path(),
char,
'{}='.format(view_name))
if count_parameters_names(func) > 0:
ignore_pdf = True
action_style = action_style.replace('pdf', '')
self.add_queryset_action(action_verbose_name, url,
action_style, action_icon,
action_category,
action_condition)
if view_name in self.request.GET:
ids = self.get_selected_ids()
if ids:
qs = self.get_queryset(
paginate=False).filter(id__in=ids)
else:
break
func = getattr(qs, view_name)
self._proccess_request(func, _action,
ignore_pdf)
# class actions defined in views module
if self.qs.model in CACHE['CLASS_VIEW_ACTIONS']:
for group in CACHE['CLASS_VIEW_ACTIONS'][self.qs.model]:
for view_name in CACHE['CLASS_VIEW_ACTIONS'][
self.qs.model][group]:
_action = CACHE['CLASS_VIEW_ACTIONS'][
self.qs.model][group][view_name]
action_verbose_name = _action['verbose_name']
action_inline = _action['inline']
action_subsets = _action['subsets']
action_can_execute = _action['can_execute']
action_category = _action['group']
action_expose = _action['expose']
action_style = _action['style'] or 'popup'
url = '/{}/{}/'.format(
get_metadata(self.qs.model, 'app_label'), view_name)
action_style = action_style.replace('popup', '')
if self.is_list_view or view_name in self.action_names:
add_action = should_add_action(action_inline,
action_subsets,
subset_name)
add_action = add_action and (True in action_expose
or 'web' in action_expose)
if add_action and permissions.check_group_or_permission(
self.request, action_can_execute):
self.add_action(action_verbose_name, url,
action_style, None,
action_category)
if self.is_list_view:
# utility actions
if list_csv:
export_url = '?' in export_url and '{}&export=csv'.format(
export_url) or '{}?export=csv'.format(export_url)
self.add_action('Exportar CSV', export_url, 'ajax', 'fa-table')
if list_xls:
export_url = '?' in export_url and '{}&export=excel'.format(
export_url) or '{}?export=excel'.format(export_url)
self.add_action('Exportar Excel', export_url, 'ajax',
'fa-file-excel-o')
if log:
log_url = '/log/{}/{}/'.format(app_label,
self.qs.model.__name__.lower())
if self.request.user.has_perm('admin.list_log'):
self.add_action('Visualizar Log', log_url, 'ajax',
'fa-history')
if list_pdf:
pdf_url = '?' in export_url and '{}&export=pdf'.format(
export_url) or '{}?export=pdf'.format(export_url)
self.add_action('Imprimir', pdf_url, 'ajax', 'fa-print')
# registration action
subclasses = () #self.qs.model.__subclasses__()
if not subclasses and not self.subsets and permissions.has_add_permission(
self.request, self.qs.model):
instance = self.qs.model()
instance._user = self.request.user
if not hasattr(instance, 'can_add') or instance.can_add():
if self.relation:
verbose_name = get_metadata(self.qs.model,
'verbose_name')
add_label = get_metadata(
self.qs.model, 'add_label',
'{} {}'.format(_('Add'), verbose_name))
else:
add_label = get_metadata(self.qs.model, 'add_label',
_('Add'))
add_url = '/add/{}/{}/'.format(
app_label, self.qs.model.__name__.lower())
self.add_action(add_label, add_url, 'ajax', 'fa-plus')
for subclass in subclasses:
app = get_metadata(subclass, 'app_label')
verbose_name = get_metadata(subclass, 'verbose_name')
cls = subclass.__name__.lower()
if permissions.has_add_permission(self.request, subclass):
self.add_action(verbose_name,
'/add/{}/{}/'.format(app, cls), False,
'fa-plus')
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 listt(request, app, cls, subset=None):
try:
_model = apps.get_model(app, cls)
except LookupError as e:
return page_not_found(request, e, 'error404.html')
title = get_metadata(_model, 'verbose_name_plural')
subsetp = None
list_display = None
list_filter = None
search_fields = None
if subset:
subset_func = getattr(_model.objects.get_queryset(), subset)
can_view = subset_func._metadata['{}:can_view'.format(subset)]
list_display = subset_func._metadata['{}:list_display'.format(subset)]
list_filter = subset_func._metadata['{}:list_filter'.format(subset)]
search_fields = subset_func._metadata['{}:search_fields'.format(
subset)]
title = '{} - {}'.format(
title, subset_func._metadata['{}:title'.format(subset)])
else:
tid = request.GET.get('tid')
subsetp = request.GET.get('tab{}'.format(tid))
if tid and subsetp:
subset_func = getattr(_model.objects.get_queryset(), subsetp)
subset_title = subset_func._metadata['{}:title'.format(subsetp)]
can_view = subset_func._metadata['{}:can_view'.format(subsetp)]
title = '{} - {}'.format(
title, subset_func._metadata['{}:title'.format(subsetp)])
if not permissions.check_group_or_permission(request, can_view):
return httprr(
request,
'/admin/login/?next={}'.format(request.get_full_path()))
else:
permission = '{}.list_{}'.format(app, cls)
if not request.user.has_perm(permission):
return httprr(
request,
'/admin/login/?next={}'.format(request.get_full_path()))
qs = _model.objects.all(request.user)
list_subsets = subset and [subset] or None
paginator = Paginator(request,
qs,
title,
list_subsets=list_subsets,
is_list_view=True,
list_display=list_display,
list_filter=list_filter,
search_fields=search_fields)
paginator.process_request()
if _model in loader.class_actions:
for group in loader.class_actions[_model]:
for view_name in loader.class_actions[_model][group]:
_action = loader.class_actions[_model][group][view_name]
action_title = _action['title']
action_message = _action['message']
action_can_execute = _action['can_execute']
action_input = _action['input']
action_css = _action['css']
action_condition = _action['condition']
initial = _action['initial']
choices = _action['choices']
if subsetp:
if subsetp not in loader.subset_actions[
_model] or view_name not in loader.subset_actions[
_model][subsetp]:
continue
else:
if subset not in loader.subset_actions[
_model] or view_name not in loader.subset_actions[
_model][subset]:
continue
if permissions.check_group_or_permission(
request, action_can_execute):
func = hasattr(qs, view_name) and getattr(
qs, view_name) or None
if func:
char = '?' in request.get_full_path() and '&' or '?'
url = '{}{}{}'.format(request.get_full_path(), char,
'{}='.format(view_name))
has_input = func.__code__.co_argcount > 1
if not has_input:
action_css = action_css.replace('popup', '')
paginator.add_subset_action(action_title, url,
action_css, None,
action_condition)
if view_name in request.GET:
ids = paginator.get_selected_ids()
if ids:
qs = paginator.get_queryset(
paginate=False).filter(id__in=ids)
else:
qs = paginator.get_queryset(paginate=False)
func = getattr(qs, view_name)
redirect_url = None
if has_input:
form = factory.get_class_action_form(
request, _model, _action, func)
paginator = ''
if form.is_valid():
params = []
for param in func.__code__.co_varnames[
1:func.__code__.co_argcount]:
if param in form.cleaned_data:
params.append(
form.cleaned_data[param])
try:
f_return = func(*params)
redirect_url = '..'
except ValidationError as e:
form.add_error(None, str(e.message))
if not redirect_url:
return render(request, 'default.html',
locals())
else:
f_return = func()
redirect_url = '.'
if redirect_url:
request.GET._mutable = True
del request.GET['ids']
del request.GET[view_name]
request.GET._mutable = False
return httprr(request, redirect_url,
action_message)
else:
url = '/{}/{}/'.format(app, view_name)
if view_name in request.GET:
return httprr(request, url)
else:
action_css = action_css.replace('popup', '')
paginator.add_action(action_title, url, action_css,
None)
paginator.add_actions()
return render(request, 'default.html', locals())
