forms.py

__copyright__ = "Copyright 2016-2018, Stichting SciPost (SciPost Foundation)"
__license__ = "AGPL v3"


from django import forms
from django.contrib.auth.models import User, Group
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import ValidationError
from django.db import transaction
from django.db.models import Q

from captcha.fields import ReCaptchaField
from django_countries import countries
from django_countries.widgets import CountrySelectWidget
from django_countries.fields import LazyTypedChoiceField

from .constants import PARTNER_KINDS, PROSPECTIVE_PARTNER_PROCESSED, CONTACT_TYPES,\
                       PARTNER_STATUS_UPDATE, REQUEST_PROCESSED, REQUEST_DECLINED, CONTACT_GENERAL
from .models import Partner, ProspectivePartner, ProspectiveContact, ProspectivePartnerEvent,\
                    Institution, Contact, PartnerEvent, MembershipAgreement, ContactRequest,\
                    PartnersAttachment
from .utils import PartnerUtils

from scipost.models import TITLE_CHOICES


class MembershipAgreementForm(forms.ModelForm):
    class Meta:
        model = MembershipAgreement
        fields = (
            'partner',
            'status',
            'date_requested',
            'start_date',
            'end_date',
            'duration',
            'offered_yearly_contribution'
        )
        widgets = {
            'start_date': forms.TextInput(attrs={'placeholder': 'YYYY-MM-DD'}),
            'end_date': forms.TextInput(attrs={'placeholder': 'YYYY-MM-DD'}),
            'date_requested': forms.TextInput(attrs={'placeholder': 'YYYY-MM-DD'}),
        }

    def save(self, current_user, commit=True):
        agreement = super().save(commit=False)
        if commit:
            if agreement.partner and not self.instance.id:
                # Create PartnerEvent if Agreement is new
                event = PartnerEvent(
                    partner=agreement.partner,
                    event=PARTNER_STATUS_UPDATE,
                    comments='Membership Agreement added with start date %s' % agreement.start_date,
                    noted_by=current_user
                )
                event.save()
            # Save agreement afterwards to be able to detect edit/add difference
            agreement.save()
        return agreement


class ActivationForm(forms.ModelForm):
    class Meta:
        model = User
        fields = []

    description = forms.CharField(max_length=256, label="Title", required=False,
                                  widget=forms.TextInput(attrs={
                                    'placeholder': 'E.g.: Legal Agent at Stanford University'}))
    kind = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple, label="Contact type",
                                     choices=CONTACT_TYPES)
    password_new = forms.CharField(label='* Password', widget=forms.PasswordInput())
    password_verif = forms.CharField(label='* Verify password', widget=forms.PasswordInput(),
                                     help_text='Your password must contain at least 8 characters')

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        try:
            self.fields['kind'].initial = self.instance.partner_contact.kind
        except Contact.DoesNotExist:
            pass

    def clean(self, *args, **kwargs):
        try:
            self.instance.partner_contact
        except Contact.DoesNotExist:
            self.add_error(None, 'Your account is invalid, please contact the administrator.')
        return super().clean(*args, **kwargs)

    def clean_password(self):
        password = self.cleaned_data.get('password_new', '')
        try:
            validate_password(password, self.instance)
        except ValidationError as error_message:
            self.add_error('password_new', error_message)
        return password

    def clean_password_verif(self):
        if self.cleaned_data.get('password_new', '') != self.cleaned_data.get('password_verif', ''):
            self.add_error('password_verif', 'Your password entries must match')
        return self.cleaned_data.get('password_verif', '')

    @transaction.atomic
    def activate_user(self):
        if self.errors:
            return forms.ValidationError

        # Activate account
        self.instance.is_active = True
        self.instance.set_password(self.cleaned_data['password_new'])
        self.instance.save()

        # Set fields for Contact
        self.instance.partner_contact.description = self.cleaned_data['description']
        self.instance.partner_contact.kind = self.cleaned_data['kind']
        self.instance.partner_contact.save()

        # Add permission groups to user
        group = Group.objects.get(name='Partners Accounts')
        self.instance.groups.add(group)
        return self.instance


class PartnerEventForm(forms.ModelForm):
    class Meta:
        model = PartnerEvent
        fields = (
            'event',
            'comments',
        )


class InstitutionForm(forms.ModelForm):
    class Meta:
        model = Institution
        fields = (
            'kind',
            'name',
            'acronym',
            'address',
            'country',
            'logo',
            'css_class',
        )


class PartnerForm(forms.ModelForm):
    class Meta:
        model = Partner
        fields = (
            'institution',
            'organization',
            'status',
            'main_contact'
        )

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['main_contact'].queryset = self.instance.contact_set.all()


class RequestContactForm(forms.ModelForm):
    class Meta:
        model = ContactRequest
        fields = (
            'email',
            'title',
            'first_name',
            'last_name',
            'kind',
        )


class ProcessRequestContactForm(RequestContactForm):
    decision = forms.ChoiceField(choices=((None, 'No decision'), ('accept', 'Accept'), ('decline', 'Decline')),
                                 widget=forms.RadioSelect, label='Accept or Decline')

    class Meta:
        model = ContactRequest
        fields = RequestContactForm.Meta.fields + ('partner',)

    def process_request(self, current_user):
        if self.cleaned_data['decision'] == 'accept':
            self.instance.status = REQUEST_PROCESSED
            self.instance.save()
            contactForm = NewContactForm({
                'title': self.cleaned_data['title'],
                'email': self.cleaned_data['email'],
                'first_name': self.cleaned_data['first_name'],
                'last_name': self.cleaned_data['last_name'],
                'kind': self.cleaned_data['kind'],
            }, partner=self.cleaned_data['partner'])
            contactForm.is_valid()
            contactForm.save(current_user=current_user)
        elif self.cleaned_data['decision'] == 'decline':
            self.instance.status = REQUEST_DECLINED
            self.instance.save()


class RequestContactFormSet(forms.BaseModelFormSet):
    def process_requests(self, current_user):
        """
        Process all requests if status is eithter accept or decline.
        """
        for form in self.forms:
            form.process_request(current_user=current_user)


class ContactForm(forms.ModelForm):
    """
    This Contact form is mainly used for editing Contact instances.
    """
    class Meta:
        model = Contact
        fields = (
            'kind',
        )

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['kind'].required = False


class NewContactForm(ContactForm):
    """
    This Contact form is used to create new Contact instances, as it will also handle
    possible sending and activation of User instances coming with the new Contact.
    """
    title = forms.ChoiceField(choices=TITLE_CHOICES, label='Title')
    first_name = forms.CharField()
    last_name = forms.CharField()
    email = forms.CharField()
    existing_user = None

    def __init__(self, *args, **kwargs):
        """
        Partner is a required argument to tell the formset which Partner the Contact
        is being edited for in the current form.
        """
        self.partner = kwargs.pop('partner')
        super().__init__(*args, **kwargs)

    def clean_email(self):
        """
        Check if User already is known in the system.
        """
        email = self.cleaned_data['email']
        try:
            self.existing_user = User.objects.get(email=email)
            if not self.data.get('confirm_use_existing', '') == 'on':
                # Do not give error if user wants to use existing User
                self.add_error('email', 'This User is already registered.')
            self.fields['confirm_use_existing'] = forms.BooleanField(
                required=False, initial=False, label='Use the existing user instead: %s %s'
                                                     % (self.existing_user.first_name,
                                                        self.existing_user.last_name))
        except User.DoesNotExist:
            pass
        return email

    @transaction.atomic
    def save(self, current_user, commit=True):
        """
        If existing user is found, add it to the Partner.
        """
        if self.existing_user and self.data.get('confirm_use_existing', '') == 'on':
            # Do not create new Contact
            try:
                # Link Contact to new Partner
                contact = self.existing_user.partner_contact
                contact.partners.add(self.partner)
            except Contact.DoesNotExist:
                # Not yet a 'Contact-User'
                contact = super().save(commit=False)
                contact.title = self.existing_user.contributor.title
                contact.user = self.existing_user
                contact.save()
                contact.partners.add(self.partner)
            return contact

        # Create complete new Account (User + Contact)
        user = User(
            first_name=self.cleaned_data['first_name'],
            last_name=self.cleaned_data['last_name'],
            email=self.cleaned_data['email'],
            username=self.cleaned_data['email'],
            is_active=False,
        )
        user.save()
        contact = Contact(
            user=user,
            title=self.cleaned_data['title'],
            kind=self.cleaned_data['kind']
        )
        contact.generate_key()
        contact.save()
        contact.partners.add(self.partner)

        # Send email for activation
        PartnerUtils.load({'contact': contact})
        PartnerUtils.email_contact_new_for_activation(current_user=current_user)
        return contact


class ContactFormset(forms.BaseModelFormSet):
    """
    Use custom formset to make sure the delete action will not delete an entire Contact
    if the Contact still has relations with other Partners.
    """
    def __init__(self, *args, **kwargs):
        """
        Partner is a required argument to tell the formset which Partner the Contact
        is being edited for in the current form.
        """
        self.partner = kwargs.pop('partner')
        super().__init__(*args, **kwargs)

    def delete_existing(self, obj, commit=True):
        '''Deletes an existing model instance.'''
        if commit:
            obj.delete_or_remove_partner(self.partner)


class PromoteToPartnerForm(forms.ModelForm):
    address = forms.CharField(widget=forms.Textarea(), required=False)
    acronym = forms.CharField(max_length=16)

    class Meta:
        model = ProspectivePartner
        fields = (
            'kind',
            'institution_name',
            'country',
        )

    def promote_to_partner(self, current_user):
        # Create new instances
        institution = Institution(
            kind=self.cleaned_data['kind'],
            name=self.cleaned_data['institution_name'],
            acronym=self.cleaned_data['acronym'],
            address=self.cleaned_data['address'],
            country=self.cleaned_data['country']
        )
        institution.save()
        partner = Partner(
            institution=institution,
            main_contact=None
        )
        partner.save()
        event = PartnerEvent(
            partner=partner,
            event=PARTNER_STATUS_UPDATE,
            comments='ProspectivePartner has been upgraded to Partner by %s %s'
                     % (current_user.first_name, current_user.last_name),
            noted_by=current_user
        )
        event.save()

        # Close Prospect
        self.instance.status = PROSPECTIVE_PARTNER_PROCESSED
        self.instance.save()
        return (partner, institution,)


class PromoteToContactForm(forms.ModelForm):
    """
    This form is used to create a new `partners.Contact`
    """
    promote = forms.BooleanField(label='Activate/Promote this contact', initial=True,
                                 required=False)
    kind = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple, initial=[CONTACT_GENERAL],
                                     label='Contact types', choices=CONTACT_TYPES, required=False)

    class Meta:
        model = ProspectiveContact
        fields = (
            'title',
            'first_name',
            'last_name',
            'email',
        )

    def clean_email(self):
        """
        Check if email address is already used.
        """
        email = self.cleaned_data['email']
        if not self.cleaned_data.get('promote', False):
            # Don't promote the Contact
            return email
        if User.objects.filter(Q(email=email) | Q(username=email)).exists():
            self.add_error('email', 'This emailadres has already been used.')
        return email

    @transaction.atomic
    def promote_contact(self, partner, current_user):
        """
        Promote ProspectiveContact's to Contact's related to a certain Partner.
        The status update after promotion is handled outside this method, in the Partner model.
        """
        if not self.cleaned_data.get('promote', False):
            # Don't promote the Contact
            return

        # How to handle empty instances?
        if self.errors:
            return forms.ValidationError  # Is this a valid exception?

        # Create a new User and Contact linked to the partner given
        contact_form = NewContactForm(self.cleaned_data, partner=partner)
        if contact_form.is_valid():
            return contact_form.save(current_user=current_user)
        raise forms.ValidationError('NewContactForm invalid. Please contact Admin.')


class PromoteToContactFormset(forms.BaseModelFormSet):
    """
    This is a formset to process multiple `PromoteToContactForm`s at the same time
    designed for the 'promote prospect to partner' action.
    """
    def save(self, *args, **kwargs):
        raise DeprecationWarning(("This formset is not meant to used with the default"
                                  " `save` method. User the `promote_contacts` instead."))

    @transaction.atomic
    def promote_contacts(self, partner, current_user):
        """
        Promote ProspectiveContact's to Contact's related to a certain Partner.
        """
        contacts = []
        for form in self.forms:
            new_contact = form.promote_contact(partner, current_user)
            if new_contact:
                contacts.append(new_contact)
        try:
            partner.main_contact = contacts[0]
        except IndexError:
            # No contacts at all means no main-contact as well...
            pass
        partner.save()
        return contacts


ContactModelFormset = forms.modelformset_factory(ProspectiveContact, PromoteToContactForm,
                                                 formset=PromoteToContactFormset, extra=0)


class ProspectivePartnerForm(forms.ModelForm):
    """
    This form is used to internally add a ProspectivePartner.
    If an external agent requests membership of the SPB,
    the MembershipQueryForm below is used instead.
    """
    class Meta:
        model = ProspectivePartner
        fields = ('kind', 'institution_name', 'country')


class ProspectiveContactForm(forms.ModelForm):
    class Meta:
        model = ProspectiveContact
        fields = '__all__'
        widgets = {'prospartner': forms.HiddenInput()}


class ProspectivePartnerEventForm(forms.ModelForm):
    class Meta:
        model = ProspectivePartnerEvent
        fields = ('event', 'comments')
        widgets = {
            'comments': forms.Textarea(attrs={'cols': 16, 'rows': 3}),
        }


class MembershipQueryForm(forms.Form):
    """
    This form is to be used by an agent of the prospective Partner,
    in order to request more information about potentially joining the SPB.
    """
    title = forms.ChoiceField(choices=TITLE_CHOICES, label='* Your title')
    first_name = forms.CharField(label='* Your first name', max_length=100)
    last_name = forms.CharField(label='* Your last name', max_length=100)
    email = forms.EmailField(label='* Your email address')
    role = forms.CharField(label='* Your role in your organization')
    partner_kind = forms.ChoiceField(choices=PARTNER_KINDS, label='* Partner kind')
    institution_name = forms.CharField(label='* Name of your institution')
    country = LazyTypedChoiceField(
        choices=countries, label='* Country', initial='NL',
        widget=CountrySelectWidget(layout=(
            '{widget}<img class="country-select-flag" id="{flag_id}"'
            ' style="margin: 6px 4px 0" src="{country.flag}">')))
    captcha = ReCaptchaField(attrs={'theme': 'clean'}, label='*Please verify to continue:')


class PartnersAttachmentForm(forms.ModelForm):
    class Meta:
        model = PartnersAttachment
        fields = (
            'name',
            'attachment',
        )

    def save(self, to_object, commit=True):
        """
        This custom save method will automatically assign the file to the object
        given when its a valid instance type.
        """
        attachment = super().save(commit=False)

        # Formset's might save an empty Instance
        if not attachment.name or not attachment.attachment:
            return None

        if isinstance(to_object, MembershipAgreement):
            attachment.agreement = to_object
        else:
            raise forms.ValidationError('You cannot save Attachment to this type of object.')
        if commit:
            attachment.save()
        return attachment


class PartnersAttachmentFormSet(forms.BaseModelFormSet):
    def save(self, to_object, commit=True):
        """
        This custom save method will automatically assign the file to the object
        given when its a valid instance type.
        """
        returns = []
        for form in self.forms:
            returns.append(form.save(to_object))
        return returns