Ejemplo n.º 1
0
 def test_related_name(self):
     """
     Regression test for #13963
     """
     self.assertEquals(label_for_field("location", Event, return_attr=True), ("location", None))
     self.assertEquals(label_for_field("event", Location, return_attr=True), ("awesome event", None))
     self.assertEquals(label_for_field("guest", Event, return_attr=True), ("awesome guest", None))
Ejemplo n.º 2
0
Archivo: admin.py Proyecto: ildus/ch
 def get_label_for_field(field_name, model, objects):
     from django.db.models import get_model
     
     if '.' in field_name:
         obj, field =  get_field_value(objects[0], field_name, return_field = True)
         return label_for_field(field, get_model(obj._meta.app_label, obj._meta.object_name))
     else:
         return label_for_field(field_name, model)
Ejemplo n.º 3
0
    def test_list_label_abc(self):
        # Ensure model data is correct
        self.assertEqual(ConcreteModel._translations_model._meta.get_field_by_name('tr_title')[0].verbose_name, "Translated Title")

        # See that the TranslatedFieldDescriptor of the concrete model properly routes to the proper model
        self.assertEqual(label_for_field('tr_title', ConcreteModel), "Translated Title")

        # See that the TranslatedFieldDescriptor of the abstract model handles the fallback properly.
        self.assertEqual(label_for_field('tr_title', AbstractModel), "Tr title")
Ejemplo n.º 4
0
def result_headers(cl):
    result = ['id']
    for field_name in cl.list_display:
        label = label_for_field(field_name, cl.model, model_admin = cl.model_admin)
        result.append(unicode(label))
        
    return result
Ejemplo n.º 5
0
 def test_related_name(self):
     """
     Regression test for #13963
     """
     self.assertEqual(
         label_for_field('location', Event, return_attr=True),
         ('location', None),
     )
     self.assertEqual(
         label_for_field('event', Location, return_attr=True),
         ('awesome event', None),
     )
     self.assertEqual(
         label_for_field('guest', Event, return_attr=True),
         ('awesome guest', None),
     )
Ejemplo n.º 6
0
def result_headers(cl):
    lookup_opts = cl.lookup_opts

    for i, field_name in enumerate(cl.list_display):
        header, attr = label_for_field(field_name, cl.model, model_admin=cl.model_admin, return_attr=True)
        if attr:
            # if the field is the action checkbox: no sorting and special class
            if field_name == "action_checkbox":
                yield {"text": header, "class_attrib": mark_safe(' class="action-checkbox-column"')}
                continue
            header = pretty_name(header)

            # It is a non-field, but perhaps one that is sortable
            admin_order_field = getattr(attr, "admin_order_field", None)
            if not admin_order_field:
                yield {"text": header}
                continue

            # So this _is_ a sortable non-field.  Go to the yield
            # after the else clause.
        else:
            admin_order_field = None

        th_classes = []
        new_order_type = "asc"
        if field_name == cl.order_field or admin_order_field == cl.order_field:
            th_classes.append("sorted %sending" % cl.order_type.lower())
            new_order_type = {"asc": "desc", "desc": "asc"}[cl.order_type.lower()]

        yield {
            "text": header,
            "sortable": True,
            "url": cl.get_query_string({ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
            "class_attrib": mark_safe(th_classes and ' class="%s"' % " ".join(th_classes) or ""),
        }
Ejemplo n.º 7
0
    def export_as_csv(modeladmin, request, queryset):
        response = HttpResponse(content_type='text/csv')
        response[
            'Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(
                modeladmin.opts).replace('.', '_')

        writer = csv.writer(response)
        if header:
            fields_header = []
            for field_name in fields:
                text, attr = label_for_field(field_name,
                                             modeladmin.model,
                                             model_admin=modeladmin,
                                             return_attr=True)
                fields_header.append(text.capitalize())
            writer.writerow(fields_header)

        for obj in queryset:
            line = []
            for field_name in fields:
                f, attr, value = lookup_field(field_name, obj, modeladmin)
                if f is None or f.auto_created:
                    result_repr = force_unicode(value)
                else:
                    if isinstance(f.rel, models.ManyToOneRel):
                        field_val = getattr(obj, f.name)
                        if field_val is None:
                            result_repr = '-'
                        else:
                            result_repr = field_val
                    else:
                        result_repr = display_for_field(value, f)
                line.append(strip_tags(result_repr))
            writer.writerow(line)
        return response
Ejemplo n.º 8
0
 def test_related_name(self):
     """
     Regression test for #13963
     """
     self.assertEqual(
         label_for_field('location', Event, return_attr=True),
         ('location', None),
     )
     self.assertEqual(
         label_for_field('event', Location, return_attr=True),
         ('awesome event', None),
     )
     self.assertEqual(
         label_for_field('guest', Event, return_attr=True),
         ('awesome guest', None),
     )
Ejemplo n.º 9
0
    def export_as_csv(modeladmin, request, queryset):
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(modeladmin.opts).replace('.', '_')

        writer = csv.writer(response)
        if header:
            fields_header = []
            for field_name in fields:
                text, attr = label_for_field(
                    field_name, modeladmin.model,
                    model_admin=modeladmin,
                    return_attr=True
                )
                fields_header.append(text.capitalize())
            writer.writerow(fields_header)

        for obj in queryset:
            line = []
            for field_name in fields:
                f, attr, value = lookup_field(field_name, obj, modeladmin)
                if f is None or f.auto_created:
                    result_repr = force_unicode(value)
                else:
                    if isinstance(f.rel, models.ManyToOneRel):
                        field_val = getattr(obj, f.name)
                        if field_val is None:
                            result_repr = '-'
                        else:
                            result_repr = field_val
                    else:
                        result_repr = display_for_field(value, f)
                line.append(strip_tags(result_repr))
            writer.writerow(line)
        return response
Ejemplo n.º 10
0
 def __init__(self, parent_model, model_admin, **kwargs):
     if not issubclass(self.model, models.OrderableModel):
         raise ImproperlyConfigured("%s may only be used with OrderableModel models" % self.__class__.__name__)
     self.order_field = self.model.ordering_field
     self.order_field_label = label_for_field(self.model.ordering_field, 
                                              self.model, model_admin)
     super(OrderableInline, self).__init__(parent_model, model_admin, **kwargs)
Ejemplo n.º 11
0
def export_model_as_csv(modeladmin, request, queryset):
    if hasattr(modeladmin, 'exportable_fields'):
        field_list = modeladmin.exportable_fields
    else:
        # Copy modeladmin.list_display to remove action_checkbox
        field_list = modeladmin.list_display[:]
        field_list.remove('action_checkbox')

    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=%s-%s-export-%s.csv' % (
        __package__.lower(),
        queryset.model.__name__.lower(),
        datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
    )

    writer = csv.writer(response)
    writer.writerow(
        [admin_util.label_for_field(f, queryset.model, modeladmin) for f in field_list],
    )

    for obj in queryset:
        csv_line_values = []
        for field in field_list:
            field_obj, attr, value = admin_util.lookup_field(field, obj, modeladmin)
            csv_line_values.append(value)

        writer.writerow(csv_line_values)

    return response
Ejemplo n.º 12
0
def export_model_as_csv(modeladmin, request, queryset):
    if hasattr(modeladmin, 'exportable_fields'):
        field_list = modeladmin.exportable_fields
    else:
        # Copy modeladmin.list_display to remove action_checkbox
        field_list = modeladmin.list_display[:]
        #field_list.remove('action_checkbox')

    response = HttpResponse(mimetype='text/csv')
    response[
        'Content-Disposition'] = 'attachment; filename=%s-%s-export-%s.csv' % (
            __package__.lower(),
            queryset.model.__name__.lower(),
            datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
        )

    writer = csv.writer(response)
    writer.writerow([
        admin_util.label_for_field(f, queryset.model, modeladmin)
        for f in field_list
    ], )

    for obj in queryset:
        csv_line_values = []
        for field in field_list:
            field_obj, attr, value = admin_util.lookup_field(
                field, obj, modeladmin)
            csv_line_values.append(value)

        writer.writerow(csv_line_values)

    return response
Ejemplo n.º 13
0
    def export_as_csv(modeladmin, request, queryset):
        """
        Generic csv export admin action.
        based on http://djangosnippets.org/snippets/1697/
        """
        model = modeladmin.model
        if fields:
            field_names = set(fields)
        else:
            field_names = set([field.name for field in model._meta.fields])
            if exclude:
                excludeset = set(exclude)
                field_names = field_names - excludeset

        response = HttpResponse(mimetype='text/csv')
        response['Content-Disposition'] = 'attachment; filename=%s.csv' % (
                unicode(model._meta).replace('.', '_'),)

        writer = csv.writer(response)
        if header:
            write_encoded(writer, (label_for_field(field, model, modeladmin)
                                   for field in field_names))
        for obj in queryset:
            write_encoded(writer, (lookup_field(field, obj, modeladmin)[2]
                                   for field in field_names))
        return response
Ejemplo n.º 14
0
def export_model_as_excel(modeladmin, request, queryset):
    has_name_fields = [
        'village', 'cell', 'sector', 'health_centre', 'referral_hospital',
        'district', 'province', 'role'
    ]
    is_date_fields = ['date_of_birth', 'dob', 'join_date']
    workbook = xlwt.Workbook()
    sheet_name = "%s" % (queryset.model.__name__.lower(), )
    sheet = workbook.add_sheet(sheet_name)
    if hasattr(modeladmin, 'exportable_fields'):
        field_list = modeladmin.exportable_fields
        #field_list = field_list.__add__(('village__code', 'cell__code', ))
    else:
        # Copy modeladmin.list_display to remove action_checkbox
        field_list = modeladmin.list_display[:]
        #field_list.remove('action_checkbox')

    response = HttpResponse(mimetype="application/ms-excel")
    response[
        'Content-Disposition'] = 'attachment; filename=%s.xls' % sheet_name

    row = col = 0
    for f in field_list:
        if f.__contains__('__code'):
            sheet.write(row, col, f.upper())
        else:
            sheet.write(
                row, col,
                admin_util.label_for_field(f, queryset.model,
                                           modeladmin).upper())
        col = col + 1

    row = row + 1
    for obj in queryset:
        excel_line_values = []
        col = 0
        for field in field_list:
            if field.__contains__('__code'):
                field_obj, attr, value = admin_util.lookup_field(
                    field.replace('__code', ''), obj, modeladmin)
                if value: value = value.code
            else:
                field_obj, attr, value = admin_util.lookup_field(
                    field, obj, modeladmin)

            try:
                if field in has_name_fields: sheet.write(row, col, value.name)
                elif field in is_date_fields:
                    sheet.write(
                        row, col,
                        "%d/%d/%d" % (value.day, value.month, value.year))
                else:
                    sheet.write(row, col, value)
            except Exception, e:
                try:
                    sheet.write(row, col, value)
                except:
                    sheet.write(row, col, "NULL")
            col = col + 1
        row = row + 1
Ejemplo n.º 15
0
    def test_list_label(self):
        # Ensure model data is correct
        self.assertEqual(SimpleModel._translations_model._meta.get_field_by_name('tr_title')[0].verbose_name, "Translated Title")

        # See that adding a field to the admin list_display also receives the translated title
        # This happens by TranslatedFieldDescriptor.short_description
        self.assertEqual(label_for_field('tr_title', SimpleModel), "Translated Title")
Ejemplo n.º 16
0
Archivo: utils.py Proyecto: mkwm/casia
 def items(self):
     for f in self.fields:
         try:
             key = label_for_field(f.field, self.user)
             value = f.serializer.to_html(self.user, f.field)
             yield key, value
         except AttributeError:
             # TODO: Should it be ignored?
             pass
Ejemplo n.º 17
0
 def changelist_view(self, request, extra_context=None):
     extra_context = extra_context or {}
     label = label_for_field(self.model.ordering_field, self.model, 
                             model_admin=self)
     extra_context.update({
         'ordering_field': self.model.ordering_field,
         'ordering_field_label': label
     })
     return super(OrderableAdmin, self).changelist_view(request, extra_context)
Ejemplo n.º 18
0
    def __init__(self, field, instance):
        if callable(field):
            class_name = field.__name__ != '<lambda>' and field.__name__ or ''
        else:
            class_name = field

        self.name = class_name
        self.label = label_for_field(field, instance.__class__)
        self.field_repr = get_field_value(field, instance)
        self.help_text = get_field_attr(field, instance, "help_text", "")
Ejemplo n.º 19
0
def result_headers(cl):
    """
    Generates the list column headers.
    """
    lookup_opts = cl.lookup_opts

    for i, field_name in enumerate(cl.list_display):
        header, attr = label_for_field(field_name,
                                       cl.model,
                                       model_admin=cl.model_admin,
                                       return_attr=True)
        if attr:
            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    "text": header,
                    "class_attrib":
                    mark_safe(' class="action-checkbox-column"')
                }
                continue

            # It is a non-field, but perhaps one that is sortable
            admin_order_field = getattr(attr, "admin_order_field", None)
            if not admin_order_field:
                yield {"text": header}
                continue

            # So this _is_ a sortable non-field.  Go to the yield
            # after the else clause.
        else:
            admin_order_field = None

        th_classes = []
        new_order_type = 'asc'
        if field_name == cl.order_field or admin_order_field == cl.order_field:
            th_classes.append('sorted %sending' % cl.order_type.lower())
            new_order_type = {
                'asc': 'desc',
                'desc': 'asc'
            }[cl.order_type.lower()]

        yield {
            "text":
            header,
            "sortable":
            True,
            "url":
            cl.get_query_string({
                ORDER_VAR: i,
                ORDER_TYPE_VAR: new_order_type
            }),
            "class_attrib":
            mark_safe(th_classes and ' class="%s"' % ' '.join(th_classes)
                      or '')
        }
Ejemplo n.º 20
0
 def fields(self):
     fk = getattr(self.formset, "fk", None)
     for i, field in enumerate(flatten_fieldsets(self.fieldsets)):
         if fk and fk.name == field:
             continue
         if field in self.readonly_fields:
             label = label_for_field(field, self.opts.model, self.model_admin)
             yield (False, forms.forms.pretty_name(label))
         else:
             field = self.formset.form.base_fields[field]
             yield (field.widget.is_hidden, field.label)
Ejemplo n.º 21
0
def result_headers_csv(cl):
    """
    Generates the list column headers.
    """
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(field_name,
                                     cl.model,
                                     model_admin=cl.model_admin,
                                     return_attr=True)
        yield {"text": text}
Ejemplo n.º 22
0
 def label_tag(self):
     attrs = {}
     if not self.is_first:
         attrs["class"] = "inline"
     name = forms.forms.pretty_name(
         label_for_field(self.field, self.model_admin.model,
                         self.model_admin))
     contents = force_unicode(escape(name)) + u":"
     return mark_safe('<label%(attrs)s>%(contents)s</label>' % {
         "attrs": flatatt(attrs),
         "contents": contents,
     })
Ejemplo n.º 23
0
 def fields(self):
     for i, field in enumerate(flatten_fieldsets(self.fieldsets)):
         if field in self.readonly_fields:
             yield {
                 'label': label_for_field(field, self.opts.model, self.opts),
                 'widget': {
                     'is_hidden': False
                 },
                 'required': False
             }
         else:
             yield self.formset.form.base_fields[field]
Ejemplo n.º 24
0
 def label_tag(self):
     attrs = {}
     if not self.is_first:
         attrs["class"] = "inline"
     name = forms.forms.pretty_name(
         label_for_field(self.field, self.model_admin.model, self.model_admin)
     )
     contents = force_unicode(escape(name)) + u":"
     return mark_safe('<label%(attrs)s>%(contents)s</label>' % {
         "attrs": flatatt(attrs),
         "contents": contents,
     })
Ejemplo n.º 25
0
 def fields(self):
     fk = getattr(self.formset, "fk", None)
     for i, field in enumerate(flatten_fieldsets(self.fieldsets)):
         if fk and fk.name == field:
             continue
         if field in self.readonly_fields:
             label = label_for_field(field, self.opts.model,
                                     self.model_admin)
             yield (False, forms.forms.pretty_name(label))
         else:
             field = self.formset.form.base_fields[field]
             yield (field.widget.is_hidden, field.label)
Ejemplo n.º 26
0
def export_as_csv(modeladmin, request, queryset):
    """
    Generic csv export admin action.
    based on http://djangosnippets.org/snippets/1697/ and /2020/
    """
    header = True
    # TODO Also create export_as_csv for exporting all columns including list_display
    if not request.user.is_staff:
        raise PermissionDenied
    opts = modeladmin.model._meta
    field_names = modeladmin.list_display
    if 'action_checkbox' in field_names:
        field_names.remove('action_checkbox')

    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(
        opts).replace('.', '_')

    writer = csv.writer(response)
    if header:
        headers = []
        for field_name in list(field_names):
            label = str(
                label_for_field(field_name, modeladmin.model, modeladmin))
            #print 'label is: ', label
            if str.islower(label):
                label = str.title(label)
            headers.append(label)
        writer.writerow(headers)
    for row in queryset:
        #print 'trace row:', row
        values = []
        for field in field_names:
            #print 'trace field:', field
            if field[:8] == 'link_to_':
                field = field[8:]
            value = (getattr(row, field))
            if callable(value):
                try:
                    value = value() or ''
                except:
                    value = 'Error retrieving value'
            if value is None:
                value = ''
            #print 'trace value:', value
            values.append(unicode(value).encode('utf-8'))
        writer.writerow(values)
    return response


#    export_as_csv.short_description = description
#    return export_as_cs
Ejemplo n.º 27
0
    def test_label_for_property(self):
        # NOTE: cannot use @property decorator, because of
        # AttributeError: 'property' object has no attribute 'short_description'
        class MockModelAdmin(object):
            def my_property(self):
                return "this if from property"
            my_property.short_description = 'property short description'
            test_from_property = property(my_property)

        self.assertEqual(
            label_for_field("test_from_property", Article, model_admin=MockModelAdmin),
            'property short description'
        )
Ejemplo n.º 28
0
    def test_label_for_property(self):
        # NOTE: cannot use @property decorator, because of
        # AttributeError: 'property' object has no attribute 'short_description'
        class MockModelAdmin(object):
            def my_property(self):
                return "this if from property"
            my_property.short_description = 'property short description'
            test_from_property = property(my_property)

        self.assertEqual(
            label_for_field("test_from_property", Article, model_admin=MockModelAdmin),
            'property short description'
        )
Ejemplo n.º 29
0
 def fields(self):
     fk = getattr(self.formset, "fk", None)
     for i, field in enumerate(flatten_fieldsets(self.fieldsets)):
         if fk and fk.name == field:
             continue
         if field in self.readonly_fields:
             yield {
                 "label": label_for_field(field, self.opts.model, self.opts),
                 "widget": {"is_hidden": False},
                 "required": False,
             }
         else:
             yield self.formset.form.base_fields[field]
Ejemplo n.º 30
0
    def get_change_column_form(self):

        choices = [
            (field, (label_for_field(field, self.model, model_admin=self)).capitalize()) \
            for field in self.list_display
        ]

        class AdjustableColumnsForm(forms.Form):
            columns = forms.MultipleChoiceField(
                choices=choices,
                widget=FilteredSelectMultiple('columns', False)
            )

        return AdjustableColumnsForm
Ejemplo n.º 31
0
    def __init__(self,
                 queryset,
                 display_fields=None,
                 request=None,
                 bordered=True,
                 condensed=True,
                 hover=True,
                 striped=False,
                 auto_append_padding_column=True):
        Table.__init__(self, bordered, condensed, hover, striped)

        self.queryset = queryset
        self.display_fields = display_fields or ('pk', '__unicode__')
        self.request = request
        self.model = queryset.model
        self.model_fields = {}
        append_padding_column = auto_append_padding_column

        for name in display_fields:
            attrs = {}
            if name in ('pk', 'id'):
                label = '#'
                attrs['class'] = 'id'
            elif callable(name):
                label = getattr(name, 'verbose_name', name.__name__)
                attrs['class'] = 'nowrap'
            else:
                label = label_for_field(name, self.model)
                try:
                    field = self.queryset.model._meta.get_field_by_name(
                        name)[0]
                    if isinstance(field, models.TextField):
                        if auto_append_padding_column:
                            append_padding_column = False
                    elif isinstance(field, models.DateField):
                        attrs['class'] = 'datetime'
                    elif isinstance(field,
                                    (models.IntegerField, models.FloatField,
                                     models.DecimalField)):
                        attrs['class'] = 'number'
                    else:
                        attrs['class'] = 'nowrap'
                    self.model_fields[name] = field
                except models.FieldDoesNotExist:
                    pass
            self.add_column(label, name, attrs=attrs)

        if append_padding_column:
            self.add_column(None)
Ejemplo n.º 32
0
def export_as_csv(modeladmin, request, queryset):
    """
    Generic csv export admin action.
    based on http://djangosnippets.org/snippets/1697/ and /2020/
    """
    header = True
    # TODO Also create export_as_csv for exporting all columns including list_display
    if not request.user.is_staff:
        raise PermissionDenied
    opts = modeladmin.model._meta
    field_names = modeladmin.list_display
    if 'action_checkbox' in field_names:
        field_names.remove('action_checkbox')

    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(opts).replace('.', '_')

    writer = csv.writer(response)
    if header:
        headers = []
        for field_name in list(field_names):            
            label = str(label_for_field(field_name,modeladmin.model,modeladmin))
            #print 'label is: ', label
            if str.islower(label):
               label = str.title(label)
            headers.append(label)
        writer.writerow(headers)
    for row in queryset:
        #print 'trace row:', row
        values = []
        for field in field_names:
            #print 'trace field:', field
            if field[:8] == 'link_to_':            
                field= field[8:]
            value = (getattr(row, field))
            if callable(value):
                try:
                    value = value() or ''
                except:
                    value = 'Error retrieving value'
            if value is None:
                value = ''
            #print 'trace value:', value
            values.append(unicode(value).encode('utf-8'))
        writer.writerow(values)
    return response

#    export_as_csv.short_description = description
#    return export_as_cs
Ejemplo n.º 33
0
 def fields(self):
     fk = getattr(self.formset, "fk", None)
     for i, field in enumerate(flatten_fieldsets(self.fieldsets)):
         if fk and fk.name == field:
             continue
         if field in self.readonly_fields:
             yield {
                 'label': label_for_field(field, self.opts.model, self.opts),
                 'widget': {
                     'is_hidden': False
                 },
                 'required': False
             }
         else:
             yield self.formset.form.base_fields[field]
Ejemplo n.º 34
0
 def __init__(self, form, field, is_first, model_admin=None):
     label = label_for_field(field, form._meta.model, model_admin)
     # Make self.field look a little bit like a field. This means that
     # {{ field.name }} must be a useful class name to identify the field.
     # For convenience, store other field-related data here too.
     self.field = {
         'name': force_unicode(label != '--' and label or ''),
         'label': label,
         'field': field,
     }
     self.form = form
     self.model_admin = model_admin
     self.is_first = is_first
     self.is_checkbox = False
     self.is_readonly = True
Ejemplo n.º 35
0
 def fields(self):
     fk = getattr(self.formset, "fk", None)
     for i, field in enumerate(flatten_fieldsets(self.fieldsets)):
         if fk and fk.name == field:
             continue
         if field in self.readonly_fields:
             yield {
                 'label': label_for_field(field, self.opts.model, self.model_admin),
                 'widget': {
                     'is_hidden': False
                 },
                 'required': False
             }
         else:
             yield self.formset.form.base_fields[field]
def result_headers(cl):
    """
    Generates the list column headers.
    """
    lookup_opts = cl.lookup_opts

    for i, field_name in enumerate(cl.list_display):
        header, attr = label_for_field(field_name, cl.model,
            model_admin = cl.model_admin,
            return_attr = True
        )
        if attr:
            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    "text": header,
                    "class_attrib": mark_safe(' class="action-checkbox-column"')
                }
                continue

            # It is a non-field, but perhaps one that is sortable
            admin_order_field = getattr(attr, "admin_order_field", None)
            if not admin_order_field:
                yield {"text": header}
                continue

            # So this _is_ a sortable non-field.  Go to the yield
            # after the else clause.
        else:
            admin_order_field = None

        th_classes = []
        new_order_type = 'asc'
        if field_name == cl.order_field or admin_order_field == cl.order_field:
            th_classes.append('sorted %sending' % cl.order_type.lower())
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[cl.order_type.lower()]

        # This is used to write a class hidden-phone for bootstrap2
        if i > 3: th_classes.append('hidden-phone')

        yield {
            "text": header,
            "sortable": True,
            "url": cl.get_query_string({ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
            "class_attrib": mark_safe(th_classes and ' class="%s"' % ' '.join(th_classes) or '')
        }
Ejemplo n.º 37
0
    def labels(self):
        """
        Get field label for fields
        """

        if type(self.object_list) == type([]):
            model = self.formset.model
        else:
            model = self.object_list.model

        for field in self.visible_fields:
            name = None
            if self.formset:
                f = self.formset.empty_form.fields.get(field, None)
                if f:
                    name = f.label

            if name is None:
                name = label_for_field(field, model)

            if name == model._meta.verbose_name:
                name = self.model_name and self.model_name or \
                            model._meta.verbose_name

            stype = None
            cur_sorted = False

            sortable = False

            if self.order_type:
                sortable = get_sort_field(field, model)
                stype = self.ASC

                # change order_type so that next sorting on the same
                # field will give reversed results
                if sortable and field == self.sort_field:
                    cur_sorted = True
                    if self.order_type == self.ASC:
                        stype = self.DESC
                    elif self.order_type == self.DESC:
                        stype = self.ASC
                    else:
                        stype = self.ASC


            yield AdminListLabel(name, field, stype, cur_sorted, bool(sortable))
Ejemplo n.º 38
0
    def exporta_a_csv(modeladmin, request, queryset):
        """
        Generic csv export admin action.
        based on http://djangosnippets.org/snippets/1697/ and /2020/
        """
        if not request.user.is_staff:
            raise PermissionDenied
        opts = modeladmin.model._meta
        field_names = modeladmin.list_display
        if 'action_checkbox' in field_names:
            field_names.remove('action_checkbox')
#        field_names = set([field.name for field in opts.fields])
#        if fields:
#            fieldset = set(fields)
#            field_names = field_names & fieldset
#        elif exclude:
#            excludeset = set(exclude)
#            field_names = field_names - excludeset

        response = HttpResponse(mimetype='text/csv')
        response['Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(opts).replace('.', '_')

        writer = csv.writer(response, delimiter=';')
        if header:
            headers = []
            for field_name in list(field_names):
                label = label_for_field(field_name,modeladmin.model,modeladmin)
                if str.islower(label):
                    label = str.title(label)
                headers.append(label)
            writer.writerow(headers)
        for row in queryset:
            values = []
            for field in field_names:
                value = (getattr(row, field))
                if callable(value):
                    try:
                        value = value() or ''
                    except:
                        value = 'Error retrieving value'
                if value is None:
                    value = ''
                values.append(unicode(value).encode('utf-8'))
            writer.writerow(values)
        return response
Ejemplo n.º 39
0
def export_model_as_excel(modeladmin, request, queryset):
    has_name_fields = ['village', 'cell', 'sector', 'health_centre', 'referral_hospital', 'district', 'province','role']
    is_date_fields = ['date_of_birth', 'dob', 'join_date']
    workbook = xlwt.Workbook()
    sheet_name = "%s" % ( queryset.model.__name__.lower(), )
    sheet = workbook.add_sheet(sheet_name)
    if hasattr(modeladmin, 'exportable_fields'):
        field_list = modeladmin.exportable_fields
        #field_list = field_list.__add__(('village__code', 'cell__code', ))        
    else:
        # Copy modeladmin.list_display to remove action_checkbox
        field_list = modeladmin.list_display[:]
        #field_list.remove('action_checkbox')

    response = HttpResponse(mimetype = "application/ms-excel")
    response['Content-Disposition'] = 'attachment; filename=%s.xls' % sheet_name

    row = col = 0
    for f in field_list:
        if f.__contains__('__code'):
                sheet.write(row , col, f.upper())
        else:
            sheet.write(row , col, admin_util.label_for_field(f, queryset.model, modeladmin).upper())
        col = col + 1

    row = row + 1
    for obj in queryset:
        excel_line_values = []
        col = 0
        for field in field_list:
            if field.__contains__('__code'):
                field_obj, attr, value = admin_util.lookup_field(field.replace('__code', ''), obj, modeladmin)
                if value:   value = value.code
            else:
                field_obj, attr, value = admin_util.lookup_field(field, obj, modeladmin)

            try:
                if field in has_name_fields:  sheet.write(row, col, value.name)
                elif field in is_date_fields: sheet.write(row, col, "%d/%d/%d" % (value.day, value.month, value.year))
                else:   sheet.write(row, col, value)
            except Exception, e:
                try:    sheet.write(row, col, value)
                except: sheet.write(row, col, "NULL")
            col = col + 1
        row = row + 1
Ejemplo n.º 40
0
 def __init__(self, form, field, is_first, model_admin=None):
     label = label_for_field(field, form._meta.model, model_admin)
     # Make self.field look a little bit like a field. This means that
     # {{ field.name }} must be a useful class name to identify the field.
     # For convenience, store other field-related data here too.
     if callable(field):
         class_name = field.__name__ != '<lambda>' and field.__name__ or ''
     else:
         class_name = field
     self.field = {
         'name': class_name,
         'label': label,
         'field': field,
     }
     self.form = form
     self.model_admin = model_admin
     self.is_first = is_first
     self.is_checkbox = False
     self.is_readonly = True
Ejemplo n.º 41
0
 def __init__(self, form, field, is_first, model_admin=None):
     label = label_for_field(field, form._meta.model, model_admin)
     # Make self.field look a little bit like a field. This means that
     # {{ field.name }} must be a useful class name to identify the field.
     # For convenience, store other field-related data here too.
     if callable(field):
         class_name = field.__name__ != '<lambda>' and field.__name__ or ''
     else:
         class_name = field
     self.field = {
         'name': class_name,
         'label': label,
         'field': field,
     }
     self.form = form
     self.model_admin = model_admin
     self.is_first = is_first
     self.is_checkbox = False
     self.is_readonly = True
Ejemplo n.º 42
0
 def __init__(self, form, field, is_first, model_admin=None):
     label = label_for_field(field, form._meta.model, model_admin)
     # Make self.field look a little bit like a field. This means that
     # {{ field.name }} must be a useful class name to identify the field.
     # For convenience, store other field-related data here too.
     if callable(field):
         class_name = field.__name__ if field.__name__ != "<lambda>" else ""
     else:
         class_name = field
     self.field = {
         "name": class_name,
         "label": label,
         "field": field,
         "help_text": help_text_for_field(class_name, form._meta.model),
     }
     self.form = form
     self.model_admin = model_admin
     self.is_first = is_first
     self.is_checkbox = False
     self.is_readonly = True
Ejemplo n.º 43
0
def result_headers(cl):
    lookup_opts = cl.lookup_opts

    for i, field_name in enumerate(cl.list_display):
        attr = None
        try:
            f = lookup_opts.get_field(field_name)
            admin_order_field = None
            header = f.verbose_name
        except models.FieldDoesNotExist:
            header = label_for_field(field_name, cl.model, cl.model_admin)
            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {"text": header,
                       "class_attrib": mark_safe(' class="action-checkbox-column"')}
                continue
            header = pretty_name(header)

            # It is a non-field, but perhaps one that is sortable
            admin_order_field = getattr(attr, "admin_order_field", None)
            if not admin_order_field:
                yield {"text": header}
                continue

            # So this _is_ a sortable non-field.  Go to the yield
            # after the else clause.

        th_classes = []
        new_order_type = 'asc'
        if field_name == cl.order_field or admin_order_field == cl.order_field:
            th_classes.append('sorted %sending' % cl.order_type.lower())
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[cl.order_type.lower()]

        yield {
            "text": header,
            "sortable": True,
            "url": cl.get_query_string({ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
            "class_attrib": mark_safe(th_classes and ' class="%s"' % ' '.join(th_classes) or '')
        }
Ejemplo n.º 44
0
def result_headers(cl):
    """
    Generates the list column headers.
    """
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(field_name, cl.model,
            model_admin = cl.model_admin,
            return_attr = True
        )
        if attr:
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    "text": text,
                    "class_attrib": mark_safe(' class="action-checkbox-column"'),
                    "sortable": False,
                }
                continue

            admin_order_field = getattr(attr, "admin_order_field", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    "text": text,
                    "class_attrib": format_html(' class="column-{0}"', field_name),
                    "sortable": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{0}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = [] # URL for making this field the primary sort
        o_list_remove  = [] # URL for removing this field from sort
        o_list_toggle  = [] # URL for toggling order type for this field
        make_qs_param = lambda t, n: ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i: # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))


        yield {
            "text": text,
            "sortable": True,
            "sorted": sorted,
            "ascending": order_type == "asc",
            "sort_priority": sort_priority,
            "url_primary": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            "url_remove": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            "url_toggle": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            "class_attrib": format_html(' class="{0}"', ' '.join(th_classes))
                            if th_classes else '',
        }
Ejemplo n.º 45
0
 def get_column_title(self, name):
     """Return the title of a column."""
     return admin_util.label_for_field(name, self.model)
Ejemplo n.º 46
0
	def header_list(self):
		u'''Возврвщает заголовки столбцов'''
		for i, field_name in enumerate(self.list_display):
			label = label_for_field(field_name, self.model)
			yield {'text': label}
Ejemplo n.º 47
0
 def get_label(field):
     label = util.label_for_field(field, model, modeladmin)
     return force_unicode(label).title().encode('utf-8')
Ejemplo n.º 48
0
    def test_label_for_field(self):
        """
        Tests for label_for_field
        """
        self.assertEqual(label_for_field("title", Article), "title")
        self.assertEqual(label_for_field("title2", Article), "another name")
        self.assertEqual(label_for_field("title2", Article, return_attr=True),
                         ("another name", None))

        self.assertEqual(label_for_field("__unicode__", Article), "article")
        self.assertEqual(label_for_field("__str__", Article), str("article"))

        self.assertRaises(AttributeError,
                          lambda: label_for_field("unknown", Article))

        def test_callable(obj):
            return "nothing"

        self.assertEqual(label_for_field(test_callable, Article),
                         "Test callable")
        self.assertEqual(
            label_for_field(test_callable, Article, return_attr=True),
            ("Test callable", test_callable))

        self.assertEqual(label_for_field("test_from_model", Article),
                         "Test from model")
        self.assertEqual(
            label_for_field("test_from_model", Article, return_attr=True),
            ("Test from model", Article.test_from_model))
        self.assertEqual(
            label_for_field("test_from_model_with_override", Article),
            "not What you Expect")

        self.assertEqual(label_for_field(lambda x: "nothing", Article), "--")

        class MockModelAdmin(object):
            def test_from_model(self, obj):
                return "nothing"

            test_from_model.short_description = "not Really the Model"

        self.assertEqual(
            label_for_field("test_from_model",
                            Article,
                            model_admin=MockModelAdmin),
            "not Really the Model")
        self.assertEqual(
            label_for_field("test_from_model",
                            Article,
                            model_admin=MockModelAdmin,
                            return_attr=True),
            ("not Really the Model", MockModelAdmin.test_from_model))
Ejemplo n.º 49
0
def export_model_as_excel_xlsx(modeladmin, request, queryset):
    has_name_fields = ['village', 'cell', 'sector', 'health_centre', 'referral_hospital', 'district', 'province','role', 'type', 'location', 'nation']
    is_date_fields = ['date_of_birth', 'dob', 'join_date', 'date',  'edd_date' ,  'edd_anc2_date' ,  'edd_anc3_date',  'edd_anc4_date' ,  'edd_pnc1_date' ,  'edd_pnc2_date' ,  'edd_pnc3_date' ,'created']
    is_person_fields = ['reporter', 'patient'] 
    sheet_name = "%s" % ( queryset.model.__name__.lower(), )
    # create a workbook in memory
    output = StringIO.StringIO()
    workbook = xlsxwriter.Workbook(output)
    sheet = workbook.add_worksheet(sheet_name)
    if hasattr(modeladmin, 'exportable_fields'):
        field_list = modeladmin.exportable_fields
    else:
        # Copy modeladmin.list_display to remove action_checkbox
        field_list = modeladmin.list_display[:]
        #field_list.remove('action_checkbox')

    #response = HttpResponse(mimetype = "application/ms-excel")
    #response['Content-Disposition'] = 'attachment; filename=%s.xlsx' % sheet_name

    row = col = 0
    last_col = []
    for f in field_list:
        sheet.write(row , col, admin_util.label_for_field(f, queryset.model, modeladmin).upper())
        col = col + 1       

    row = row + 1
    for obj in queryset:
        excel_line_values = []
        col = 0
        for field in field_list:
            field_obj, attr, value = admin_util.lookup_field(field, obj, modeladmin)

            try:
                if field in has_name_fields:  sheet.write(row, col, value.name)
                elif field in is_date_fields: sheet.write(row, col, "%d/%d/%d" % (value.day, value.month, value.year))
                elif field in is_person_fields: sheet.write(row, col, "%s" % (value.national_id))
                else:   sheet.write(row, col, value)
                                        
            except Exception, e:
                try:    sheet.write(row, col, value)
                except: sheet.write(row, col, "NULL")
            col = col + 1
        if queryset.model.__name__ == 'Report':
            details = obj.fields.all()
            #print row,col, "BEFORE"
            if details:
                for d in details:
                    lc = [lc for lc in last_col if lc['name'] == d.type.key]
                    mcol = col
                    if lc:
                        mcol = lc[0]['index']#;print mcol,d
                        if d.type.has_value:
                            sheet.write(row,mcol, d.value)
                        else:
                            sheet.write(row,mcol, d.type.description)
                        
                    else:
                        li = [lc for lc in last_col if lc['index'] == col]
                        
                        if li:
                            mcol = last_col[len(last_col)-1]['index']+1

                        #print mcol, d 
                        last_col.append({'name': d.type.key, 'index': mcol}) 
                        sheet.write(0, mcol, d.type.key)  
                        if d.type.has_value:
                            sheet.write(row,mcol, d.value)
                        else:
                            sheet.write(row,mcol, d.type.description)
        
                    col = col+1
            #print last_col
            #print row,col, "AFTER"
        row = row + 1