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())