foerderbarometer/input/models.py

from contextlib import suppress
from datetime import date

from django import forms
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.db.models.signals import pre_save
from django.dispatch import receiver
from django.forms import ModelMultipleChoiceField, CheckboxSelectMultiple
from django.utils.functional import cached_property, classproperty
from django.utils.html import format_html
from django.utils.safestring import mark_safe

from foerderbarometer.constants import *


EMAIL_STATES = {
    'NONE': 'noch keine Mail versendet',
    'INF': 'die Benachrichtigung zur Projektabschlussmail wurde versendet',
    'CLOSE': 'die Projektabschlussmail wurde versendet',
    'END': 'alle automatischen Mails, auch surveyMail, wurden versendet',
}


class TermsConsentMixin(models.Model):
    """Abstract mixin to add a terms_accepted field for documenting user consent."""

    terms_accepted = models.BooleanField(default=False, verbose_name='Nutzungsbedingungen zugestimmt')

    class Meta:
        abstract = True


class RequestUrlMixin(models.Model):
    """
    Abstract mixin for adding an OTRS request URL field to admin models.

    This field stores a direct link to the related OTRS ticket.
    Note: OTRS links may contain semicolons, which must not be URL-encoded.
    """

    request_url = models.URLField(max_length=2000, null=True, verbose_name='Antrag (URL)')

    class Meta:
        abstract = True


class Volunteer(models.Model):
    realname = models.CharField(max_length=200, null=True, verbose_name='Realname',
                                help_text='Bitte gib deinen Vornamen und deinen Nachnamen ein.', default='')
    email = models.EmailField(max_length=200, null=True, verbose_name='E-Mail-Adresse',
                              help_text=mark_safe('Bitte gib deine E-Mail-Adresse ein, damit dich<br>Wikimedia Deutschland bei Rückfragen oder für<br>die Zusage kontaktieren kann.'))

    # the following Fields are not supposed to be edited by users

    granted = models.BooleanField(null=True, verbose_name='bewilligt')
    granted_date = models.DateField(null=True, verbose_name='bewilligt am')
    survey_mail_date = models.DateField(verbose_name='Umfragemail wurde verschickt am', null=True, blank=True)
    mail_state = models.CharField(max_length=6, choices=EMAIL_STATES.items(), default='NONE')
    survey_mail_send = models.BooleanField(default=False, verbose_name='Keine Umfragemail schicken')

    @classmethod
    def set_granted(cl, key, b):
        obj = cl.objects.get(pk=key)
        obj.granted = b
        obj.granted_date = date.today()
        obj.save()

    class Meta:
        abstract = True


class Extern(Volunteer):
    ''' abstract basis class for all data entered by extern volunteers '''

    username = models.CharField(max_length=200, null=True, verbose_name='Benutzer_innenname',
                                help_text=mark_safe('Wikimedia Benutzer_innenname'))

    # the following Fields are not supposed to be edited by users
    service_id = models.CharField(max_length=15, null=True, blank=True)

    def save(self, *args, **kwargs):
        # we don't call save with args/kwargs to avoid UNIQUE CONSTRAINT errors
        # but maybe there is a better solution?
        super().save()
        self.service_id = type(self).__name__ + str(self.pk)
        super().save()

    class Meta:
        abstract = True


class ConcreteExtern(Extern):
    ''' needed because we can't initiate abstract base classes in the view'''
    pass


class Account(models.Model):
    code = models.CharField('Kostenstelle', max_length=5, default='DEF', null=False, primary_key=True)
    description = models.CharField('Beschreibung', max_length=60, default='NO DESCRIPTION')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')

    def __str__(self):
        return f'{self.code} {self.description}'

    @property
    def has_subaccounts(self):
        return self.code == '21111'


class BaseProjectCategory(models.Model):
    OTHER: str

    name = models.CharField('Name', max_length=200)
    order = models.PositiveIntegerField('Reihenfolge')

    class Meta:
        abstract = True
        ordering = ['order']

    def __str__(self):
        return self.name

    @cached_property
    def project_count(self):
        return self.projects.count()

    @classproperty
    def other(cls):
        return cls(id=0, name=cls.OTHER)


class ProjectCategory(BaseProjectCategory):
    OTHER = 'Sonstiges'

    class Meta(BaseProjectCategory.Meta):
        verbose_name = 'Projektkategorie'
        verbose_name_plural = 'Projektkategorien'


class WikimediaProject(BaseProjectCategory):
    OTHER = 'Anderes'

    class Meta(BaseProjectCategory.Meta):
        verbose_name = 'Wikimedia Projekt'
        verbose_name_plural = 'Wikimedia Projekte'


class ProductCategoryChoiceIterator(ModelMultipleChoiceField.iterator):

    def __iter__(self):
        yield from ModelMultipleChoiceField.iterator.__iter__(self)
        yield f'{self.field.other.id}', self.field.other.name


class ProductCategoryFormField(ModelMultipleChoiceField):
    widget = CheckboxSelectMultiple
    iterator = ProductCategoryChoiceIterator

    def __init__(self, *, other, **kwargs):
        super().__init__(**kwargs)
        self.other = other

    def _check_values(self, value, *, other=False):
        with suppress(TypeError):
            value = set(value)

            if other := f'{self.other.id}' in value:
                value.remove(f'{self.other.id}')

        queryset = super()._check_values(value)

        if other:
            return [*queryset, self.other]

        return list(queryset)


class ProjectCategoryField(models.ManyToManyField):

    def __init__(self, to, **kwargs):
        kwargs['to'] = to
        kwargs['related_name'] = 'projects'

        super().__init__(**kwargs)

        self.other_field = models.CharField(max_length=200, blank=True)

    def contribute_to_class(self, cls, name, **kwargs):
        super().contribute_to_class(cls, name, **kwargs)

        model, other_field = self.remote_field.model, self.other_field

        if not isinstance(model, str):
            self.verbose_name = self._verbose_name = verbose_name = model._meta.verbose_name_plural
            other_field.verbose_name = other_field._verbose_name = f'{verbose_name} ({model.OTHER})'

        other_field.contribute_to_class(cls, f'{name}_other')

    def formfield(self, **kwargs):
        kwargs['form_class'] = ProductCategoryFormField
        kwargs['other'] = self.remote_field.model.other

        return super().formfield(**kwargs)

    def save_form_data(self, instance, data):
        data = list(data)

        with suppress(ValueError):
            data.remove(self.remote_field.model.other)

        return super().save_form_data(instance, data)


class Project(Volunteer):
    end_mail_send = models.BooleanField(default=False, verbose_name='Keine Projektabschlussmail schicken')
    name = models.CharField(max_length=200, verbose_name='Name des Projekts')
    description = models.CharField(max_length=500, verbose_name='Kurzbeschreibung', null=True)
    start = models.DateField('Startdatum', null=True)
    end = models.DateField('Erwartetes Projektende', null=True)
    otrs = models.URLField(max_length=300, null=True, verbose_name='OTRS-Link')
    plan = models.URLField(max_length=2000, null=True, blank=True, verbose_name='Link zum Förderplan')
    page = models.URLField(max_length=2000, null=True, blank=True, verbose_name='Link zur Projektseite')
    urls = models.CharField(max_length=2000, null=True, blank=True, verbose_name='Weitere Links')
    group = models.CharField(max_length=2000, null=True, blank=True, verbose_name='Mitorganisierende')
    location = models.CharField(max_length=2000, null=True, blank=True, verbose_name='Ort/Adresse/Location')
    participants_estimated = models.IntegerField(blank=True, null=True, verbose_name='Teilnehmende angefragt')
    participants_real = models.IntegerField(blank=True, null=True, verbose_name='Teilnehmende ausgezählt')
    insurance = models.BooleanField(default=False, verbose_name='Haftpflichtversicherung')
    insurance_technic = models.BooleanField(default=False, verbose_name='Technikversicherung Ausland')
    support = models.CharField(max_length=300, blank=True, null=True, verbose_name='Betreuungsperson und Vertretung')
    cost = models.IntegerField(blank=True, null=True, verbose_name='Kosten')
    account = models.ForeignKey('Account', on_delete=models.CASCADE, blank=True, null=True, to_field='code', db_constraint=False)
    granted_date = models.DateField(blank=True, null=True, verbose_name='Bewilligt am')
    granted_from = models.CharField(max_length=100, blank=True, null=True, verbose_name='Bewilligt von')
    notes = models.TextField(max_length=1000, null=True, blank=True, verbose_name='Anmerkungen')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')

    categories = ProjectCategoryField(ProjectCategory)
    wikimedia_projects = ProjectCategoryField(WikimediaProject)

    # the following Fields are not supposed to be edited by users
    pid = models.CharField(max_length=15, null=True, blank=True)
    status = models.CharField(max_length=3,choices=(('RUN', 'läuft'),('END','beendet'),('NOT','nicht stattgefunden')),default='RUN')
    finance_id = models.CharField(max_length=15, null= True, blank=True)
    project_of_year = models.IntegerField(default=0)
    end_quartal = models.CharField(max_length=15, null=True, blank=True, verbose_name='Quartal Projekt Ende')

    class Meta:
        verbose_name = 'Projekt'
        verbose_name_plural = 'Projekte'

    def __str__(self):
        return f'{self.pid or self.id} {self.name}'

    def save(self, *, using=None, **kwargs):
        kwargs['using'] = using

        if self.end:
            self.end_quartal = f'Q{self.end.month // 4 + 1}'
        else:
            self.end_quartal = ''

        if not self.account:
            self.finance_id = ''
            self.project_of_year = 0

            return super().save(**kwargs)

        if self.should_generate_finance_id():
            self.generate_finance_id()

        super().save(**kwargs)

        if not self.pid:
            self.pid = f'{self.account.code}{self.id:08d}'
            super().save(update_fields=['pid'], using=using)

    def should_generate_finance_id(self):
        if self.id is None:
            return True

        if not self.finance_id:
            return True

        start, account_id = type(self).objects.values_list('start', 'account').get(id=self.id)

        return not (self.start.year == start.year and self.account_id == account_id)

    def generate_finance_id(self):
        """
        This is an improved version of the old code for generating a finance id.
        There is still no protection by constraints against duplicate finance ids!
        """

        queryset = Project.objects.exclude(id=self.id).filter(start__year=self.start.year)
        max_project_of_year = queryset.aggregate(max=models.Max('project_of_year')).get('max') or 0

        self.project_of_year = project_of_year = max_project_of_year + 1

        if self.account.has_subaccounts:
            self.finance_id = f'{self.account.code}-{project_of_year:03d}'
        else:
            self.finance_id = self.account.code

    def clean(self):
        if (self.start and self.end) and (self.end < self.start):
            raise forms.ValidationError({
                'end': [
                    forms.ValidationError('Das erwartete Projektende muss nach dem Startdatum liegen.'),
                ],
            })


class ProjectRequest(Project):

    class Meta:
        proxy = True
        verbose_name = 'Projekt (beantragt)'
        verbose_name_plural = 'Projekte (beantragt)'


class ProjectDeclined(Project):

    class Meta:
        proxy = True
        verbose_name = 'Projekt (abgelehnt)'
        verbose_name_plural = 'Projekte (abgelehnt)'


class Intern(Volunteer):
    '''abstract base class for data entry from /intern (except Project)'''
    request_url = models.URLField(max_length=2000, verbose_name='Antrag (URL)')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')

    class Meta:
        abstract = True


class ConcreteVolunteer(Volunteer):
    ''' needed because we can't initiate abstract base classes in the view'''
    pass


class HonoraryCertificate(Intern):
    ''' this class is also used for accreditations '''

    project = models.ForeignKey(Project, null=True, blank=True, on_delete=models.SET_NULL)

    def __str__(self):
        return f'Certificate for {self.realname}'


TRANSPORT_CHOICES = {
    'BAHN': 'Bahn',
    'NONE': 'Keine Fahrtkosten',
    'OTHER': 'Sonstiges (mit Begründung)',
}

PAYEDBY_CHOICES = {
    'WMDE': 'WMDE',
    'REQU': 'Antragstellender Mensch',
}

HOTEL_CHOICES = {
    'TRUE': mark_safe('Hotelzimmer benötigt'),
    'FALSE': mark_safe('Kein Hotelzimmer benötigt'),
}


class Travel(Extern):
    # project variable is now null true and blank true, which means it can be saved without project id to be later on filled out by admins
    project = models.ForeignKey(Project, on_delete=models.CASCADE, null=True, blank=True)
    project_name = models.CharField(max_length=50, null=True, blank=True, verbose_name='Projektname:')
    transport = models.CharField(max_length=5, choices=TRANSPORT_CHOICES.items(), default='BAHN', verbose_name='Transportmittel:')
    other_transport = models.CharField(max_length=200, null=True, blank=True, verbose_name='Sonstige Transportmittel (mit Begründung)')
    travelcost = models.CharField(max_length=10, default='0', verbose_name='Fahrtkosten')
    checkin = models.DateField(blank=True, null=True, verbose_name='Anreise')
    checkout = models.DateField(blank=True, null=True, verbose_name='Abreise')
    payed_for_hotel_by = models.CharField(max_length=4, choices=PAYEDBY_CHOICES.items(), blank=True, null=True, verbose_name='Kostenauslage Hotel durch')
    payed_for_travel_by = models.CharField(max_length=4, choices=PAYEDBY_CHOICES.items(), blank=True, null=True, verbose_name='Kostenauslage Fahrt durch')
    hotel = models.CharField(max_length=10, choices=HOTEL_CHOICES.items(), verbose_name='Hotelzimmer benötigt:')
    notes = models.TextField(max_length=1000, blank=True, verbose_name='Anmerkungen')
    request_url = models.URLField(max_length=2000, verbose_name='Antrag (URL)')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')
    project_end = models.DateField(blank=True, null=True, verbose_name='Projektende')
    # use content type model to get the end date for the project foreign key
    project_end_quartal = models.CharField(max_length=15, null=True, blank=True, verbose_name='Quartal Projekt Ende')


@receiver(pre_save, sender=Travel, dispatch_uid='get_project_end')
def get_project_end(sender, instance, **kwargs):
    if instance.project:
        instance.project_end = instance.project.end
        instance.project_end_quartal = instance.project.end_quartal


# abstract base class for Library and IFG
class Grant(RequestUrlMixin, Extern):
    cost = models.CharField(max_length=10, verbose_name='Kosten',
                            help_text='Bitte gib die ungefähr zu erwartenden Kosten in Euro an.')
    notes = models.TextField(max_length=1000, blank=True, verbose_name='Anmerkungen',
                             help_text='Bitte gib an wofür Du das Stipendium verwenden willst.')

    class Meta:
        abstract = True


def type_link(path, label):
    return format_html(
        format_string='<a href="{href}" target="_blank" rel="noopener">{label}</a>',
        href=f'https://de.wikipedia.org/wiki/Wikipedia:Förderung/{path}',
        label=label,
    )


TYPE_CHOICES = {
    TYPE_BIB: type_link('Zugang_zu_Fachliteratur#Bibliotheksstipendium', 'Bibliotheksstipendium'),
    TYPE_ELIT: type_link('Zugang_zu_Fachliteratur#eLiteraturstipendium', 'eLiteraturstipendium'),
    TYPE_MAIL: type_link('E-Mail-Adressen_und_Visitenkarten#E-Mail-Adressen', 'E-Mail-Adresse'),
    TYPE_IFG: type_link('Gebührenerstattungen_für_Behördenanfragen', 'Kostenübernahme IFG-Anfrage'),
    TYPE_LIT: type_link('Zugang_zu_Fachliteratur#Literaturstipendium', 'Literaturstipendium'),
    TYPE_LIST: type_link('E-Mail-Adressen_und_Visitenkarten#Mailinglisten', 'Mailingliste'),
    TYPE_TRAV: type_link('Reisekostenerstattungen', 'Reisekosten'),
    TYPE_SOFT: type_link('Software-Stipendien', 'Softwarestipendium'),
    TYPE_VIS: type_link('E-Mail-Adressen_und_Visitenkarten#Visitenkarten', 'Visitenkarten'),
    TYPE_PROJ: type_link('Projektplanung', 'Projektförderung unter 1000 EUR'),
}

LIBRARY_TYPES = TYPE_BIB, TYPE_ELIT, TYPE_SOFT
LIBRARY_TYPE_CHOICES = [(choice, TYPE_CHOICES[choice]) for choice in LIBRARY_TYPES]


# same model is used for Library, ELitStip and Software!
class Library(Grant):
    TYPE = TYPE_BIB
    LIBRARY_LABEL = 'Bibliothek'
    LIBRARY_HELP_TEXT = 'Für welche Bibliothek gilt das Stipendium?'
    DURATION_HELP_TEXT = mark_safe('In welchem Zeitraum möchtest du recherchieren oder<br>wie lange ist der Bibliotheksausweis gültig?')

    type = models.CharField(max_length=4, choices=LIBRARY_TYPE_CHOICES, default=TYPE_BIB)
    library = models.CharField(max_length=200)
    duration = models.CharField(max_length=100, verbose_name='Dauer')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')

    def __str__(self):
        return self.library

    def save(self, **kwargs):
        self.type = self.TYPE

        return super().save(**kwargs)


class ELiterature(Library):
    TYPE = TYPE_ELIT
    LIBRARY_LABEL = 'Datenbank/Online-Ressource'
    LIBRARY_HELP_TEXT = 'Für welche Datenbank/Online-Ressource gilt das Stipendium?'
    DURATION_HELP_TEXT = 'Wie lange gilt der Zugang?'

    class Meta:
        proxy = True


class Software(Library):
    TYPE = TYPE_SOFT
    LIBRARY_LABEL = 'Software'
    LIBRARY_HELP_TEXT = 'Für welche Software gilt das Stipendium?'
    DURATION_HELP_TEXT = 'Wie lange gilt die Lizenz?'

    class Meta:
        proxy = True


SELFBUY_CHOICES = {
    'TRUE': mark_safe('Ich möchte das Werk selbst kaufen und per Kostenerstattung bei Wikimedia Deutschland abrechnen.'),
    'FALSE': mark_safe('Ich möchte, dass Wikimedia Deutschland das Werk für mich kauft'),
}


class Literature(TermsConsentMixin, Grant):
    info = models.CharField(max_length=500, verbose_name='Informationen zum Werk',
                            help_text=mark_safe('Bitte gib alle Informationen zum benötigten Werk an,<br>\
                            die eine eindeutige Identifizierung ermöglichen (Autor, Titel, Verlag, ISBN, ...)'))
    source = models.CharField(max_length=200, verbose_name='Bezugsquelle',
                              help_text='Bitte gib an, wo du das Werk kaufen möchtest.')
    selfbuy = models.CharField( max_length=10, verbose_name='Selbstkauf?', choices=SELFBUY_CHOICES.items(), default='TRUE')
    selfbuy_give_data = models.BooleanField(verbose_name=mark_safe('Datenweitergabe erlauben'), help_text=mark_safe('Ich stimme der Weitergabe meiner Daten (Name, Postadresse) an den von mir angegebenen Anbieter/Dienstleister zu.'))
    selfbuy_data = models.TextField(max_length=1000, verbose_name='Persönliche Daten sowie Adresse', default='',\
                            help_text=mark_safe('Bitte gib hier alle persönlichen Daten an, die wir benötigen, um das Werk<br>\
                            für dich zu kaufen und es dir anschließend zu schicken (z.B. Vorname Nachname, Anschrift, <br>\
                            Telefonnummer, E-Mail-Adresse usw.). Trenne die einzelnen Angaben durch Zeilenumbrüche.'))
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')


class IFG(Grant):
    url = models.URLField(max_length=2000, verbose_name='URL',
                          help_text='Bitte gib den Link zu deiner Anfrage bei Frag den Staat an.')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')

    def __str__(self):
        return 'IFG-Anfrage von ' + self.realname


DOMAIN_CHOICES = {
    'PEDIA': '@wikipedia.de',
    'BOOKS': '@wikibooks.de',
    'QUOTE': '@wikiquote.de',
    'SOURCE': '@wikisource.de',
    'VERSITY': '@wikiversity.de',
}


class Domain(RequestUrlMixin, Extern):
    domain = models.CharField(max_length=10,
                              choices=DOMAIN_CHOICES.items(),
                              default='PEDIA')

    class Meta:
        abstract = True


MAIL_CHOICES = {
    'REALNAME': 'Vorname.Nachname',
    'USERNAME': 'Username',
    'OTHER': 'Sonstiges:',
}

ADULT_CHOICES = {
    'TRUE': mark_safe('Ich bin volljährig.'),
    'FALSE': mark_safe('Ich bin noch nicht volljährig.'),
}


class Email(TermsConsentMixin, Domain):
    address = models.CharField(max_length=50,
                               choices=MAIL_CHOICES.items(),
                               default='USERNAME', verbose_name='Adressbestandteil',
                               help_text=mark_safe('Bitte gib hier den gewünschten Adressbestandteil an,<br>der sich vor der Domain befinden soll.'))

    other = models.CharField(max_length=50, blank=True, null=True, verbose_name='Sonstiges')
    adult = models.CharField(max_length=10, verbose_name='Volljährigkeit', choices=ADULT_CHOICES.items(), default='FALSE')
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')


class List(TermsConsentMixin, Domain):
    address = models.CharField(max_length=50, default='NO_ADDRESS',
                               verbose_name='Adressbestandteil für Projektmailingliste',
                               help_text=mark_safe('Bitte gib hier den gewünschten Adressbestandteil an,<br>der sich vor der Domain befinden soll.'))
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')


PROJECT_CHOICE = {
    'PEDIA': 'Wikipedia',
    'SOURCE': 'Wikisource',
    'BOOKS': 'Wikibooks',
    'QUOTE': 'Wikiquote',
    'VERSITY': 'Wikiversity',
    'VOYAGE': 'Wikivoyage',
    'DATA': 'Wikidata',
    'NEWS': 'Wikinews',
    'COMMONS': 'Wikimedia Commons',
}

BC_VARIANT = {
    'PIC': 'mit Bild',
    'NOPIC': 'ohne Bild',
}


class BusinessCard(RequestUrlMixin, TermsConsentMixin, Extern):
    project = models.CharField(max_length=20, choices=PROJECT_CHOICE.items(),
                               default='PEDIA', verbose_name='Wikimedia-Projekt',
                               help_text='Für welches Wikimedia-Projekt möchtest Du Visitenkarten?')

    data = models.TextField(max_length=1000, verbose_name='Persönliche Daten für die Visitenkarten', default='',
                            help_text=mark_safe('Bitte gib hier alle persönlichen Daten an, und zwar genau so,<br>\
                            wie sie (auch in der entsprechenden Reihenfolge) auf den Visitenkarten stehen sollen<br>\
                            (z.B. Vorname Nachname, Benutzer:/Benutzerin:, Benutzer-/-innenname, Anschrift,<br>\
                            Telefonnummer, E-Mail-Adresse usw.). Trenne die einzelnen Angaben durch Zeilenumbrüche.<br>\
                            Hinweis: Telefonnummern bilden wir üblicherweise im internationalen Format gemäß<br>\
                            DIN 5008 ab. Als anzugebende E-Mail-Adresse empfehlen wir dir eine Wikimedia-Projekt-<br>\
                            Adresse, die du ebenfalls beantragen kannst, sofern du nicht bereits eine besitzt.'))
    variant = models.CharField(max_length=5, choices=BC_VARIANT.items(),
                               default='NOPIC', verbose_name='Variante',
                               help_text=mark_safe('so sehen die Varianten aus: <a href="https://upload.wikimedia.org/wikipedia/commons/c/cd/Muster_Visitenkarten_WMDE_2018.jpg">\
                               mit Bild</a> <a href="https://upload.wikimedia.org/wikipedia/commons/d/d3/Muster_Visitenkarte_WMDE.png">ohne Bild</a>'))

    url_of_pic = models.CharField(max_length=200, verbose_name='Url des Bildes', default='', help_text='Bitte gib die Wikimedia-Commons-URL des Bildes an.')

    sent_to = models.TextField(max_length=1000, verbose_name='Versandadresse',
                               default='', help_text='Bitte gib den Namen und die vollständige Adresse ein, an welche die Visitenkarten geschickt werden sollen.')
    send_data_to_print = models.BooleanField(default=False, verbose_name=mark_safe('Datenweitergabe erlauben'), help_text=mark_safe('Hiermit erlaube ich die Weitergabe meiner Daten (Name, Postadresse) an den von Wikimedia<br> Deutschland ausgewählten Dienstleister (z. B. <a href="wir-machen-druck.de">wir-machen-druck.de</a>) zum Zwecke des direkten <br> Versands der Druckerzeugnisse an mich.'))
    intern_notes = models.TextField(max_length=1000, blank=True, verbose_name='interne Anmerkungen')


MODELS = {
    TYPE_BIB: Library,
    TYPE_ELIT: ELiterature,
    TYPE_MAIL: Email,
    TYPE_IFG: IFG,
    TYPE_LIT: Literature,
    TYPE_LIST: List,
    TYPE_TRAV: Travel,
    TYPE_SOFT: Software,
    TYPE_VIS: BusinessCard,
}