eva/evapp/views.py

from smtplib import SMTPException
import collections

from django.views.generic.edit import CreateView
from django.urls import reverse
from django.http import HttpResponse, HttpResponseRedirect
from django.core.mail import send_mail, BadHeaderError
from django.template.loader import get_template
from formtools.wizard.views import CookieWizardView
from django.shortcuts import render

from .models import Employee, DEPARTMENT_CHOICES, LAPTOP_CHOICES, OS_CHOICES,\
                    MOBILE_CHOICES, LANG_CHOICES, ACCOUNT_CHOICES, TRANSPONDER_CHOICES
from .forms import PersonalForm, WorkingForm, ITForm, OfficeForm, DummyForm,\
                   ChangeForm, TYPE_CHOICES
from .settings import MAILS, EVA_MAIL, BASIC_DATA

def success(request):
    return HttpResponse("Vielen Dank! Du hast E.V.A. erfolgreich ausgefüllt. Die Mails an die Abteilungen wurden versendet.")

def long_process(wizard):
    # step = wizard.steps.step0
    # if step == 0:
    #     return True
    #print(f"gathering data for step {step}")
    data = wizard.get_cleaned_data_for_step('0') or {}
    print(data)
    if data.get('choice') != 'CHANGE':
        wizard.set_choice('IN')
        print('PROZESS IN')
        return True
    else:
        wizard.set_choice('CHANGE')
        print('PROZESS NOT IN')
        return False

def change_process(wizard):
    print('CHANGE PROZESS')
    return not long_process(wizard)
    # elif step < 3:
    #     return True
    # elif step == 4:
    #     return True
    # else:
    #     return False


class EvaFormView(CookieWizardView):
    template_name = 'evapp/employee_form.html'
    form_list = [PersonalForm, WorkingForm, ITForm, OfficeForm, ChangeForm, DummyForm]
    instance = None
    choice = 'IN'

    # maybe we dont need this, if *_process() would be class methods,
    # but unsure if this would work fine with the entries in urls.py
    def set_choice(self, c):
        self.choice = c

    # this deletes data which is only used temporary and is not in the modell
    def get_all_cleaned_data(self):
        data = super().get_all_cleaned_data()
        print("delete CHOICE FROM DATA")
        if 'choice' in data:
            del data['choice']
        return data

    # we need this to display all the data in the last step
    def get_context_data(self, form, **kwargs):
        print('GETCONTEXT')
        context = super().get_context_data(form=form, **kwargs)
        context.update({'choice': self.choice})
        if (self.steps.current == 5 or (self.choice == 'CHANGE' and self.steps.current ==3)):
            context.update({'data': self.beautify_data(self.get_all_cleaned_data())})
        return context

    #this makes shure, that we use the same model instance for all steps
    def get_form_instance(self,step):
        if self.instance == None:
            self.instance = Employee()
        return self.instance

    def done(self, form_list, **kwargs):
        print ('INSTANCE_DICT')
        print(self.instance_dict)

        # save data to database
        for form in form_list:
            form.save()

        # send data to departments
        for dep in MAILS:
            self.send_mail_to_department(dep)
        return HttpResponseRedirect('success')

    # def get_form(self, step=None, data=None, files=None):
    #     '''this function determines which process aut of E/V/A we will do'''
    #
    #     if step is None:
    #         step = self.steps.current
    #     print ("get_form() step " + step)
    #
    #     form =  super().get_form(step, data, files)
    #
    #     if step == '1': # why do we need step 2 here not 1???!
    #         prev_data = self.get_cleaned_data_for_step('0')
    #         choice = prev_data.get('choice')
    #         print(f'choice detection: {TYPE_CHOICES[choice]}')
    #         self.choice = choice
    #         if choice == 'CHANGE':
    #             print("process choosen: CHANGE")
    #             form = ChangeForm(data)
    #             # self.form_list = [PersonalForm, ChangeForm, DummyForm,]
    #         elif choice == 'OUT':
    #             print("process choosen: OUT")
    #             form = WorkingForm(data)
    #         elif choice == 'IN':
    #             print("process choosen: IN")
    #             form = WorkingForm(data)
    #         else:
    #             raise RuntimeError(f'ERROR! UNKNOWN FORMTYPE {choice} in EvaFormView')
    #
    #     return form

    # send a mail to the department with all needed data
    def send_mail_to_department(self, department):
        'send a mail to the given department with the nececcary notifications'

        print(f'send mail to department {department}...')

        data = self.get_all_cleaned_data()
        # some data should be in every mail
        newdata = {k: v for k, v in data.items() if (k in BASIC_DATA)}
        # only the relevant data should be in the context
        newdata.update({k: v for k, v in data.items() if (k in MAILS[department]['DATA'])})

        context = {'data': self.beautify_data(newdata)}

        try:
             mail_template = get_template(f'evapp/department_mail.txt')
             send_mail(
                 'EVA: Neuzugang',
                 mail_template.render(context),
                 EVA_MAIL,
                 [MAILS[department]['MAIL']],
                 fail_silently=False)
        except BadHeaderError:
            self.instance.delete()
            return HttpResponse('Invalid header found. Data not saved!')
        except SMTPException:
            self.instance.delete()
            return HttpResponse('Error in sending mails (propably wrong adress?). Data not saved!')

    # use long form for contextdata instead of short form if available
    #
    # ATTENTION!
    # This implementation works only for unique keys over all of these dicts from model.py
    #
    def beautify_data(self, data):
        print("BEAUTIFY")
        # update values in data dictionary with keys from *_CHOICES if present there
        choices = {**DEPARTMENT_CHOICES, **LAPTOP_CHOICES, **TRANSPONDER_CHOICES,
                   **OS_CHOICES, **MOBILE_CHOICES, **LANG_CHOICES,}
        data.update({k:choices[v] for k,v in data.items() \
            if isinstance(v,collections.abc.Hashable) \
            and v in choices})

        # replace values in accounts array from *_CHOICES
        if 'accounts' in data:
            data['accounts'] = [ACCOUNT_CHOICES[c] for c in data['accounts']]

        # replace keys in data dictionary with verbose_name
        newdata = {self.instance._meta.get_field(k).verbose_name.title() : v for k,v in data.items()}

        return newdata