forms.py

import datetime, os
from email.utils import parseaddr

from django import forms
from django.conf import settings
from django.forms.util import ErrorList
from django.core.validators import validate_email, ValidationError
from django.template.loader import render_to_string

import debug                            # pyflakes:ignore

from ietf.liaisons.accounts import (can_add_outgoing_liaison, can_add_incoming_liaison,
                                    get_person_for_user, is_secretariat, is_sdo_liaison_manager)
from ietf.liaisons.utils import IETFHM
from ietf.liaisons.widgets import (FromWidget, ReadOnlyWidget, ButtonWidget,
                                   ShowAttachmentsWidget)
from ietf.liaisons.models import LiaisonStatement, LiaisonStatementPurposeName
from ietf.liaisons.fields import SearchableLiaisonStatementField
from ietf.group.models import Group, Role
from ietf.person.models import Person, Email
from ietf.doc.models import Document
from ietf.utils.fields import DatepickerDateField


class LiaisonForm(forms.Form):
    person = forms.ModelChoiceField(Person.objects.all())
    from_field = forms.ChoiceField(widget=FromWidget, label=u'From')
    replyto = forms.CharField(label=u'Reply to')
    organization = forms.ChoiceField()
    to_poc = forms.CharField(widget=ReadOnlyWidget, label="POC", required=False)
    response_contact = forms.CharField(required=False, max_length=255)
    technical_contact = forms.CharField(required=False, max_length=255)
    cc1 = forms.CharField(widget=forms.Textarea, label="CC", required=False, help_text='Please insert one email address per line.')
    purpose = forms.ChoiceField()
    related_to = SearchableLiaisonStatementField(label=u'Related Liaison Statement', required=False)
    deadline_date = DatepickerDateField(date_format="yyyy-mm-dd", picker_settings={"autoclose": "1" }, label='Deadline', required=True)
    submitted_date = DatepickerDateField(date_format="yyyy-mm-dd", picker_settings={"autoclose": "1" }, label='Submission date', required=True, initial=datetime.date.today())
    title = forms.CharField(label=u'Title')
    body = forms.CharField(widget=forms.Textarea, required=False)
    attachments = forms.CharField(label='Attachments', widget=ShowAttachmentsWidget, required=False)
    attach_title = forms.CharField(label='Title', required=False)
    attach_file = forms.FileField(label='File', required=False)
    attach_button = forms.CharField(label='',
                                    widget=ButtonWidget(label='Attach', show_on='id_attachments',
                                                        require=['id_attach_title', 'id_attach_file'],
                                                        required_label='title and file'),
                                    required=False)

    fieldsets = [('From', ('from_field', 'replyto')),
                 ('To', ('organization', 'to_poc')),
                 ('Other email addresses', ('response_contact', 'technical_contact', 'cc1')),
                 ('Purpose', ('purpose', 'deadline_date')),
                 ('Reference', ('related_to', )),
                 ('Liaison Statement', ('title', 'submitted_date', 'body', 'attachments')),
                 ('Add attachment', ('attach_title', 'attach_file', 'attach_button')),
                ]

    def __init__(self, user, *args, **kwargs):
        self.user = user
        self.fake_person = None
        self.person = get_person_for_user(user)
        if kwargs.get('data', None):
            if is_secretariat(self.user) and 'from_fake_user' in kwargs['data'].keys():
                self.fake_person = Person.objects.get(pk=kwargs['data']['from_fake_user'])
                kwargs['data'].update({'person': self.fake_person.pk})
            else:
                kwargs['data'].update({'person': self.person.pk})

        self.instance = kwargs.pop("instance", None)
        
        super(LiaisonForm, self).__init__(*args, **kwargs)
        
        # now copy in values from instance, like a ModelForm
        if self.instance:
            self.initial["person"] = self.instance.from_contact.person_id if self.instance.from_contact else None
            self.initial["replyto"] = self.instance.reply_to
            self.initial["to_poc"] = self.instance.to_contact
            self.initial["response_contact"] = self.instance.response_contact
            self.initial["technical_contact"] = self.instance.technical_contact
            self.initial["cc1"] = self.instance.cc
            self.initial["purpose"] = self.instance.purpose.order
            self.initial["deadline_date"] = self.instance.deadline
            self.initial["submitted_date"] = self.instance.submitted.date() if self.instance.submitted else None
            self.initial["title"] = self.instance.title
            self.initial["body"] = self.instance.body
            self.initial["attachments"] = self.instance.attachments.all()
            self.initial["related_to"] = self.instance.related_to
            if "approved" in self.fields:
                self.initial["approved"] = bool(self.instance.approved)

        self.fields["purpose"].choices = [("", "---------")] + [(str(l.order), l.name) for l in LiaisonStatementPurposeName.objects.all()]
        self.hm = IETFHM
        self.set_from_field()
        self.set_replyto_field()
        self.set_organization_field()

    def __unicode__(self):
        return self.as_div()

    def get_post_only(self):
        return False

    def set_required_fields(self):
        purpose = self.data.get('purpose', None)
        if purpose in ['1', '2']:
            self.fields['deadline_date'].required = True
        else:
            self.fields['deadline_date'].required = False

    def reset_required_fields(self):
        self.fields['deadline_date'].required = True

    def set_from_field(self):
        assert NotImplemented

    def set_replyto_field(self):
        self.fields['replyto'].initial = self.person.email()[1]

    def set_organization_field(self):
        assert NotImplemented

    def as_div(self):
        return render_to_string('liaisons/liaisonform.html', {'form': self})

    def get_fieldsets(self):
        if not self.fieldsets:
            yield dict(name=None, fields=self)
        else:
            for fieldset, fields in self.fieldsets:
                fieldset_dict = dict(name=fieldset, fields=[])
                for field_name in fields:
                    if field_name in self.fields:
                        fieldset_dict['fields'].append(self[field_name])
                    if not fieldset_dict['fields']:
                        # if there is no fields in this fieldset, we continue to next fieldset
                        continue
                yield fieldset_dict

    def full_clean(self):
        self.set_required_fields()
        super(LiaisonForm, self).full_clean()
        self.reset_required_fields()

    def has_attachments(self):
        for key in self.files.keys():
            if key.startswith('attach_file_') and key.replace('file', 'title') in self.data.keys():
                return True
        return False

    def check_email(self, value):
        if not value:
            return
        emails = value.split(',')
        for email in emails:
            name, addr = parseaddr(email)
            try:
                validate_email(addr)
            except ValidationError:
                raise forms.ValidationError('Invalid email address: %s' % addr)
            try:
                addr.encode('ascii')
            except UnicodeEncodeError as e:
                raise forms.ValidationError('Invalid email address: %s (check character %d)' % (addr,e.start))

    def clean_response_contact(self):
        value = self.cleaned_data.get('response_contact', None)
        self.check_email(value)
        return value

    def clean_technical_contact(self):
        value = self.cleaned_data.get('technical_contact', None)
        self.check_email(value)
        return value

    def clean_reply_to(self):
        value = self.cleaned_data.get('reply_to', None)
        self.check_email(value)
        return value

    def clean(self):
        if not self.cleaned_data.get('body', None) and not self.has_attachments():
            self._errors['body'] = ErrorList([u'You must provide a body or attachment files'])
            self._errors['attachments'] = ErrorList([u'You must provide a body or attachment files'])
        return self.cleaned_data

    def get_from_entity(self):
        organization_key = self.cleaned_data.get('from_field')
        return self.hm.get_entity_by_key(organization_key)

    def get_to_entity(self):
        organization_key = self.cleaned_data.get('organization')
        return self.hm.get_entity_by_key(organization_key)

    def get_poc(self, organization):
        return ', '.join(u"%s <%s>" % i.email() for i in organization.get_poc())

    def clean_cc1(self):
        value = self.cleaned_data.get('cc1', '')
        result = []
        errors = []
        for address in value.split('\n'):
            address = address.strip();
            if not address:
                continue
            try:
                self.check_email(address)
            except forms.ValidationError:
                errors.append(address)
            result.append(address)
        if errors:
            raise forms.ValidationError('Invalid email addresses: %s' % ', '.join(errors))
        return ','.join(result)

    def get_cc(self, from_entity, to_entity):
        return self.cleaned_data.get('cc1', '')

    def save(self, *args, **kwargs):
        l = self.instance
        if not l:
            l = LiaisonStatement()

        l.title = self.cleaned_data["title"]
        l.purpose = LiaisonStatementPurposeName.objects.get(order=self.cleaned_data["purpose"])
        l.body = self.cleaned_data["body"].strip()
        l.deadline = self.cleaned_data["deadline_date"]
        l.related_to = self.cleaned_data["related_to"]
        l.reply_to = self.cleaned_data["replyto"]
        l.response_contact = self.cleaned_data["response_contact"]
        l.technical_contact = self.cleaned_data["technical_contact"]
        
        now = datetime.datetime.now()
        
        l.modified = now
        l.submitted = datetime.datetime.combine(self.cleaned_data["submitted_date"], now.time())
        if not l.approved:
            l.approved = now

        self.save_extra_fields(l)
        
        l.save() # we have to save here to make sure we get an id for the attachments
        self.save_attachments(l)
        
        return l

    def save_extra_fields(self, liaison):
        from_entity = self.get_from_entity()
        liaison.from_name = from_entity.name
        liaison.from_group = from_entity.obj
        e = self.cleaned_data["person"].email_set.order_by('-active', '-time')
        if e:
            liaison.from_contact = e[0]

        organization = self.get_to_entity()
        liaison.to_name = organization.name
        liaison.to_group = organization.obj
        liaison.to_contact = self.get_poc(organization)

        liaison.cc = self.get_cc(from_entity, organization)

    def save_attachments(self, instance):
        written = instance.attachments.all().count()
        for key in self.files.keys():
            title_key = key.replace('file', 'title')
            if not key.startswith('attach_file_') or not title_key in self.data.keys():
                continue
            attached_file = self.files.get(key)
            extension=attached_file.name.rsplit('.', 1)
            if len(extension) > 1:
                extension = '.' + extension[1]
            else:
                extension = ''
            written += 1
            name = instance.name() + ("-attachment-%s" % written)
            attach, _ = Document.objects.get_or_create(
                name = name,
                defaults=dict(
                    title = self.data.get(title_key),
                    type_id = "liai-att",
                    external_url = name + extension, # strictly speaking not necessary, but just for the time being ...
                    )
                )
            instance.attachments.add(attach)
            attach_file = open(os.path.join(settings.LIAISON_ATTACH_PATH, attach.name + extension), 'w')
            attach_file.write(attached_file.read())
            attach_file.close()

    def clean_title(self):
        title = self.cleaned_data.get('title', None)
        if self.instance and self.instance.pk:
            exclude_filter = {'pk': self.instance.pk}
        else:
            exclude_filter = {}
        if LiaisonStatement.objects.exclude(**exclude_filter).filter(title__iexact=title).exists():
            raise forms.ValidationError('A liaison statement with the same title has previously been submitted.')
        return title


class IncomingLiaisonForm(LiaisonForm):

    def set_from_field(self):
        if is_secretariat(self.user):
            sdos = Group.objects.filter(type="sdo", state="active")
        else:
            sdos = Group.objects.filter(type="sdo", state="active", role__person=self.person, role__name__in=("liaiman", "auth")).distinct()
        self.fields['from_field'].choices = [('sdo_%s' % i.pk, i.name) for i in sdos.order_by("name")]
        self.fields['from_field'].widget.submitter = unicode(self.person)

    def set_replyto_field(self):
        e = Email.objects.filter(person=self.person, role__group__state="active", role__name__in=["liaiman", "auth"])
        if e:
            addr = e[0].address
        else:
            addr = self.person.email_address()
        self.fields['replyto'].initial = addr

    def set_organization_field(self):
        self.fields['organization'].choices = self.hm.get_all_incoming_entities()

    def get_post_only(self):
        from_entity = self.get_from_entity()
        if is_secretariat(self.user) or Role.objects.filter(person=self.person, group=from_entity.obj, name="auth"):
            return False
        return True

    def clean(self):
        if 'send' in self.data.keys() and self.get_post_only():
            self._errors['from_field'] = ErrorList([u'As an IETF Liaison Manager you can not send an incoming liaison statements, you only can post them'])
        return super(IncomingLiaisonForm, self).clean()


def liaison_manager_sdos(person):
    return Group.objects.filter(type="sdo", state="active", role__person=person, role__name="liaiman").distinct()

class OutgoingLiaisonForm(LiaisonForm):

    to_poc = forms.CharField(label="POC", required=True)
    approved = forms.BooleanField(label="Obtained prior approval", required=False)
    other_organization = forms.CharField(label="Other SDO", required=True)

    def get_to_entity(self):
        organization_key = self.cleaned_data.get('organization')
        organization = self.hm.get_entity_by_key(organization_key)
        if organization_key == 'othersdo' and self.cleaned_data.get('other_organization', None):
            organization.name=self.cleaned_data['other_organization']
        return organization

    def set_from_field(self):
        if is_secretariat(self.user): 
            self.fields['from_field'].choices = self.hm.get_all_incoming_entities()
        elif is_sdo_liaison_manager(self.person):
            self.fields['from_field'].choices = self.hm.get_all_incoming_entities()
            all_entities = []
            for i in self.hm.get_entities_for_person(self.person):
                all_entities += i[1]
            if all_entities:
                self.fields['from_field'].widget.full_power_on = [i[0] for i in all_entities]
                self.fields['from_field'].widget.reduced_to_set = ['sdo_%s' % i.pk for i in liaison_manager_sdos(self.person)]
        else:
            self.fields['from_field'].choices = self.hm.get_entities_for_person(self.person)
        self.fields['from_field'].widget.submitter = unicode(self.person)
        self.fieldsets[0] = ('From', ('from_field', 'replyto', 'approved'))

    def set_replyto_field(self):
        e = Email.objects.filter(person=self.person, role__group__state="active", role__name__in=["ad", "chair"])
        if e:
            addr = e[0].address
        else:
            addr = self.person.email_address()
        self.fields['replyto'].initial = addr

    def set_organization_field(self):
        # If the user is a liaison manager and is nothing more, reduce the To field to his SDOs
        if not self.hm.get_entities_for_person(self.person) and is_sdo_liaison_manager(self.person):
            self.fields['organization'].choices = [('sdo_%s' % i.pk, i.name) for i in liaison_manager_sdos(self.person)]
        else:
            self.fields['organization'].choices = self.hm.get_all_outgoing_entities()
        self.fieldsets[1] = ('To', ('organization', 'other_organization', 'to_poc'))

    def set_required_fields(self):
        super(OutgoingLiaisonForm, self).set_required_fields()
        organization = self.data.get('organization', None)
        if organization == 'othersdo':
            self.fields['other_organization'].required=True
        else:
            self.fields['other_organization'].required=False

    def reset_required_fields(self):
        super(OutgoingLiaisonForm, self).reset_required_fields()
        self.fields['other_organization'].required=True

    def get_poc(self, organization):
        return self.cleaned_data['to_poc']

    def save_extra_fields(self, liaison):
        super(OutgoingLiaisonForm, self).save_extra_fields(liaison)
        from_entity = self.get_from_entity()
        needs_approval = from_entity.needs_approval(self.person)
        if not needs_approval or self.cleaned_data.get('approved', False):
            liaison.approved = datetime.datetime.now()
        else:
            liaison.approved = None

    def clean_to_poc(self):
        value = self.cleaned_data.get('to_poc', None)
        self.check_email(value)
        return value

    def clean_organization(self):
        to_code = self.cleaned_data.get('organization', None)
        from_code = self.cleaned_data.get('from_field', None)
        if not to_code or not from_code:
            return to_code
        all_entities = []
        person = self.fake_person or self.person
        for i in self.hm.get_entities_for_person(person):
            all_entities += i[1]
        # If the from entity is one in which the user has full privileges the to entity could be anyone
        if from_code in [i[0] for i in all_entities]:
            return to_code
        sdo_codes = ['sdo_%s' % i.pk for i in liaison_manager_sdos(person)]
        if to_code in sdo_codes:
            return to_code
        entity = self.get_to_entity()
        entity_name = entity and entity.name or to_code
        if self.fake_person:
            raise forms.ValidationError('%s is not allowed to send a liaison to: %s' % (self.fake_person, entity_name))
        else:
            raise forms.ValidationError('You are not allowed to send a liaison to: %s' % entity_name)


class EditLiaisonForm(LiaisonForm):

    from_field = forms.CharField(widget=forms.TextInput, label=u'From')
    replyto = forms.CharField(label=u'Reply to', widget=forms.TextInput)
    organization = forms.CharField(widget=forms.TextInput)
    to_poc = forms.CharField(widget=forms.TextInput, label="POC", required=False)
    cc1 = forms.CharField(widget=forms.TextInput, label="CC", required=False)

    class Meta:
        fields = ('from_raw_body', 'to_body', 'to_poc', 'cc1', 'last_modified_date', 'title',
                  'response_contact', 'technical_contact', 'body',
                  'deadline_date', 'purpose', 'replyto', 'related_to')

    def __init__(self, *args, **kwargs):
        super(EditLiaisonForm, self).__init__(*args, **kwargs)
        self.edit = True

    def set_from_field(self):
        self.fields['from_field'].initial = self.instance.from_name

    def set_replyto_field(self):
        self.fields['replyto'].initial = self.instance.reply_to

    def set_organization_field(self):
        self.fields['organization'].initial = self.instance.to_name

    def save_extra_fields(self, liaison):
        liaison.from_name = self.cleaned_data.get('from_field')
        liaison.to_name = self.cleaned_data.get('organization')
        liaison.to_contact = self.cleaned_data['to_poc']
        liaison.cc = self.cleaned_data['cc1']

def liaison_form_factory(request, **kwargs):
    user = request.user
    force_incoming = 'incoming' in request.GET.keys()
    liaison = kwargs.pop('liaison', None)
    if liaison:
        return EditLiaisonForm(user, instance=liaison, **kwargs)
    if not force_incoming and can_add_outgoing_liaison(user):
        return OutgoingLiaisonForm(user, **kwargs)
    elif can_add_incoming_liaison(user):
        return IncomingLiaisonForm(user, **kwargs)
    return None