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