Produits Entr'ouvert » Calebasse

# -*- coding: utf-8 -*-

import os

import logging

from datetime import datetime, date

from django.conf import settings

from django.db import models

from django.http import HttpResponseRedirect, HttpResponse

from django.views.generic import View

from django.views.generic.edit import DeleteView

from django.contrib import messages

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

from django.core.files import File

from django.forms import Form

from django.utils import formats

from django.shortcuts import get_object_or_404

from calebasse import cbv

from calebasse.doc_templates import make_doc_from_template

from calebasse.dossiers import forms

from calebasse.dossiers.views_utils import get_next_rdv, get_last_rdv, get_status

from calebasse.dossiers.transport import render_transport

from calebasse.agenda.models import Event, EventWithAct

from calebasse.actes.models import Act

from calebasse.agenda.appointments import Appointment

from calebasse.dossiers.models import (PatientRecord, PatientContact,

        PatientAddress, Status, FileState, create_patient, CmppHealthCareTreatment,

        CmppHealthCareDiagnostic, SessadHealthCareNotification, HealthCare,

        TransportPrescriptionLog, ProtectionState)

from calebasse.dossiers.states import STATES_MAPPING, STATES_BTN_MAPPER

from calebasse.ressources.models import (Service,

    SocialisationDuration, MDPHRequest, MDPHResponse)

from calebasse.facturation.list_acts import list_acts_for_billing_CMPP_per_patient

from calebasse.facturation.invoice_header import render_to_pdf_file

from calebasse.decorators import validator_only

from ..utils import get_service_setting, is_validator, get_last_file

logger = logging.getLogger('calebasse.dossiers')

if settings.CV2PARSER:

    from cv2parser import cvitale

class NewPatientRecordView(cbv.FormView, cbv.ServiceViewMixin):

    form_class = forms.NewPatientRecordForm

    template_name = 'dossiers/patientrecord_new.html'

    success_url = '..'

    patient = None

    def post(self, request, *args, **kwarg):

        self.user = request.user

        return super(NewPatientRecordView, self).post(request, *args, **kwarg)

    def form_valid(self, form):

        self.patient = create_patient(form.data['first_name'], form.data['last_name'], self.service,

                self.user, date_selected=datetime.strptime(form.data['date_selected'], "%d/%m/%Y"))

        return super(NewPatientRecordView, self).form_valid(form)

    def get_success_url(self):

        return '%s/view' % self.patient.id

new_patient_record = NewPatientRecordView.as_view()

class RecordPatientRecordIdMixing(object):

    def dispatch(self, request, *args, **kwargs):

        self.patientrecord_id = request.session['patientrecord_id'] = int(kwargs['patientrecord_id'])

        return super(RecordPatientRecordIdMixing, self).dispatch(request, *args, **kwargs)

    def get_form_kwargs(self):

        kwargs = super(RecordPatientRecordIdMixing, self).get_form_kwargs()

        kwargs['patient'] = PatientRecord.objects.get(id=self.patientrecord_id)

        return kwargs

class NewPatientContactView(RecordPatientRecordIdMixing, cbv.CreateView):

    model = PatientContact

    form_class = forms.PatientContactForm

    template_name = 'dossiers/patientcontact_new.html'

    success_url = '../view#tab=2'

    def get_initial(self):

        initial = super(NewPatientContactView, self).get_initial()

        fields = self.form_class.base_fields.keys()

        for arg in self.request.GET.keys():

            if arg in fields:

                if arg == 'addresses':

                    value = self.request.GET.getlist(arg)

                else:

                    value = self.request.GET.get(arg)

                initial[arg] = value

        if initial:

            if not initial.has_key('addresses'):

                initial['addresses'] = []

            patient = PatientRecord.objects.get(id=self.patientrecord_id)

            addresses = patient.addresses.order_by('-id')

            if addresses:

                initial['addresses'].append(addresses[0].pk)

        return initial

new_patient_contact = NewPatientContactView.as_view()

class UpdatePatientContactView(RecordPatientRecordIdMixing, cbv.NotificationDisplayView, cbv.UpdateView):

    model = PatientContact

    form_class = forms.PatientContactForm

    template_name = 'dossiers/patientcontact_new.html'

    success_url = '../../view#tab=2'

update_patient_contact = UpdatePatientContactView.as_view()

class DeletePatientContactView(cbv.DeleteView):

    model = PatientContact

    form_class = forms.PatientContactForm

    template_name = 'dossiers/patientcontact_confirm_delete.html'

    success_url = '../../view#tab=2'

    def post(self, request, *args, **kwargs):

        try:

            patient = PatientRecord.objects.get(id=kwargs.get('pk'))

        except PatientRecord.DoesNotExist:

            return super(DeletePatientContactView, self).post(request, *args, **kwargs)

        # the contact is also a patient record; it shouldn't be deleted; just

        # altered to remove an address

        patient.addresses.remove(self.request.GET['address'])

        return HttpResponseRedirect(self.get_success_url())

delete_patient_contact = DeletePatientContactView.as_view()

class NewPatientAddressView(cbv.CreateView):

    model = PatientAddress

    form_class = forms.PatientAddressForm

    template_name = 'dossiers/patientaddress_new.html'

    success_url = '../view#tab=2'

    def get_success_url(self):

        return self.success_url

    def form_valid(self, form):

        patientaddress = form.save()

        patientrecord = PatientRecord.objects.get(id=self.kwargs['patientrecord_id'])

        patientrecord.addresses.add(patientaddress)

        messages.add_message(self.request, messages.INFO, u'Nouvelle adresse enregistrée avec succès.')

        return HttpResponseRedirect(self.get_success_url())

new_patient_address = NewPatientAddressView.as_view()

class UpdatePatientAddressView(cbv.NotificationDisplayView, cbv.UpdateView):

    model = PatientAddress

    form_class = forms.PatientAddressForm

    template_name = 'dossiers/patientaddress_new.html'

    success_url = '../../view#tab=2'

update_patient_address = UpdatePatientAddressView.as_view()

class DeletePatientAddressView(cbv.DeleteView):

    model = PatientAddress

    form_class = forms.PatientAddressForm

    template_name = 'dossiers/patientaddress_confirm_delete.html'

    success_url = '../../view#tab=2'

delete_patient_address = DeletePatientAddressView.as_view()

class NewHealthCareView(cbv.CreateView):

    def get_initial(self):

        initial = super(NewHealthCareView, self).get_initial()

        initial['author'] = self.request.user.id

        initial['patient'] = self.kwargs['patientrecord_id']

        return initial

new_healthcare_treatment = \

    NewHealthCareView.as_view(model=CmppHealthCareTreatment,

        template_name = 'dossiers/generic_form.html',

        success_url = '../view#tab=3',

        form_class=forms.CmppHealthCareTreatmentForm)

new_healthcare_diagnostic = \

    NewHealthCareView.as_view(model=CmppHealthCareDiagnostic,

        template_name = 'dossiers/generic_form.html',

        success_url = '../view#tab=3',

        form_class=forms.CmppHealthCareDiagnosticForm)

new_healthcare_notification = \

    NewHealthCareView.as_view(model=SessadHealthCareNotification,

        template_name = 'dossiers/generic_form.html',

        success_url = '../view#tab=3',

        form_class=forms.SessadHealthCareNotificationForm)

update_healthcare_treatment = \

    cbv.UpdateView.as_view(model=CmppHealthCareTreatment,

        template_name = 'dossiers/generic_form.html',

        success_url = '../../view#tab=3',

        form_class=forms.CmppHealthCareTreatmentForm)

update_healthcare_diagnostic = \

    cbv.UpdateView.as_view(model=CmppHealthCareDiagnostic,

        template_name = 'dossiers/generic_form.html',

        success_url = '../../view#tab=3',

        form_class=forms.CmppHealthCareDiagnosticForm)

update_healthcare_notification = \

    cbv.UpdateView.as_view(model=SessadHealthCareNotification,

        template_name = 'dossiers/generic_form.html',

        success_url = '../../view#tab=3',

        form_class=forms.SessadHealthCareNotificationForm)

delete_healthcare_treatment = \

    cbv.DeleteView.as_view(model=CmppHealthCareTreatment,

        template_name = 'dossiers/generic_confirm_delete.html',

        success_url = '../../view#tab=3')

delete_healthcare_diagnostic = \

    cbv.DeleteView.as_view(model=CmppHealthCareDiagnostic,

        template_name = 'dossiers/generic_confirm_delete.html',

        success_url = '../../view#tab=3')

delete_healthcare_notification = \

    cbv.DeleteView.as_view(model=SessadHealthCareNotification,

        template_name = 'dossiers/generic_confirm_delete.html',

        success_url = '../../view#tab=3')

class StateFormView(cbv.FormView):

    template_name = 'dossiers/state.html'

    form_class = forms.StateForm

    success_url = './view#tab=0'

    def post(self, request, *args, **kwarg):

        self.user = request.user

        return super(StateFormView, self).post(request, *args, **kwarg)

    def form_valid(self, form):

        service = Service.objects.get(id=form.data['service_id'])

        status = Status.objects.filter(services=service).filter(type=form.data['state_type'])

        patient = PatientRecord.objects.get(id=form.data['patient_id'])

        date_selected = datetime.strptime(form.data['date'], "%d/%m/%Y")

        patient.set_state(status[0], self.user, date_selected, form.data['comment'])

        return super(StateFormView, self).form_valid(form)

state_form = StateFormView.as_view()

class PatientRecordView(cbv.UpdateView):

    model = PatientRecord

    template_name = 'dossiers/patientrecord_update.html'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordView, self).get_context_data(**kwargs)

        ctx['object'].create_diag_healthcare(self.request.user)

        ctx['object'].automated_switch_state(self.request.user)

        current_state = ctx['object'].get_current_state()

        if not current_state:

            current_state = ctx['object'].get_state()

            ctx['future_state'] = True

        if STATES_MAPPING.has_key(current_state.status.type):

            state = STATES_MAPPING[current_state.status.type]

        else:

            state = current_state.status.name

        ctx['current_state'] = current_state

        ctx['service_id'] = self.service.id

        ctx['states'] = FileState.objects.filter(patient=self.object) \

                .filter(status__services=self.service) \

                .order_by('-date_selected')

        return ctx

patient_record = PatientRecordView.as_view()

class PatientRecordPrint(cbv.DetailView):

    model = PatientRecord

    content_type = 'application/pdf'

    template_name = 'dossiers/patientrecord_print.html'

    def get_context_data(self, *args, **kwargs):

        context = super(PatientRecordPrint, self).get_context_data(*args, **kwargs)

        for view in (PatientRecordGeneralView, PatientRecordAdmView,

                     PatientRecordAddrView, PatientRecordNotifsView, PatientRecordOldActs,

                     PatientRecordNextAppointmentsView, PatientRecordSocialisationView):

            view_instance = view(request=self.request, object=self.object,

                                 service=self.service)

            context.update(view_instance.get_context_data(object=self.object))

        return context

    def get(self, request, *args, **kwargs):

        self.object = self.get_object()

        path = render_to_pdf_file([self.template_name],

                                  self.get_context_data(object = self.object))

        content = File(file(path))

        response = HttpResponse(content, self.content_type)

        response['Content-Length'] = content.size

        output = 'dossier_%s.pdf' % self.object.id

        response['Content-Disposition'] = \

            'attachment; filename="%s"' % output

        return response

patient_record_print = PatientRecordPrint.as_view()

class PatientRecordGeneralView(cbv.UpdateView):

    model = PatientRecord

    form_class = forms.GeneralForm

    template_name = 'dossiers/patientrecord_tab1_general.html'

    success_url = './view'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordGeneralView, self).get_context_data(**kwargs)

        ctx['nb_place_of_lifes'] = ctx['object'].addresses.filter(place_of_life=True).count()

        ctx['initial_state'] = ctx['object'].get_initial_state()

        ctx['last_rdv'] = get_last_rdv(ctx['object'])

        ctx['next_rdv'] = get_next_rdv(ctx['object'])

        current_state = ctx['object'].get_current_state()

        if current_state.status and STATES_MAPPING.has_key(current_state.status.type):

            state = STATES_MAPPING[current_state.status.type]

        elif current_state.status:

            state = current_state.status.name

        else:

            state = "Aucun"

        ctx['current_state'] = current_state

        ctx['status'], ctx['hc_status'] = get_status(ctx, self.request.user)

        ctx['missing_policy'] = False

        if not self.object.policyholder or \

                not self.object.policyholder.health_center or \

                not self.object.policyholder.social_security_id:

            ctx['missing_policy'] = True

        ctx['missing_birthdate'] = False

        if not self.object.birthdate:

            ctx['missing_birthdate'] = True

        return ctx

tab1_general = PatientRecordGeneralView.as_view()

class PatientRecordAdmView(cbv.UpdateView):

    model = PatientRecord

    form_class = forms.AdministrativeForm

    template_name = 'dossiers/patientrecord_tab2_fiche_adm.html'

    success_url = './view#tab=1'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordAdmView, self).get_context_data(**kwargs)

        try:

            ctx['last_prescription'] = TransportPrescriptionLog.objects.filter(patient=ctx['object']).latest('created')

        except:

            pass

        return ctx

tab2_fiche_adm = PatientRecordAdmView.as_view()

class PatientRecordAddrView(cbv.ServiceViewMixin, cbv.NotificationDisplayView, cbv.MultiUpdateView):

    model = PatientRecord

    forms_classes = {

            'contact': forms.PatientContactForm,

            'policyholder': forms.PolicyHolderForm,

            'comment' : forms.AddrCommentForm,

            }

    template_name = 'dossiers/patientrecord_tab3_adresses.html'

    success_url = './view#tab=2'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordAddrView, self).get_context_data(**kwargs)

        ctx['nb_place_of_lifes'] = ctx['object'].addresses.filter(place_of_life=True).count()

        ctx['addresses'] = ctx['object'].addresses.order_by('-place_of_life', 'id')

        cv_files_path = get_service_setting('cv_files_path')

        if settings.CV2PARSER and is_validator(self.request.user) and cv_files_path and os.path.isdir(cv_files_path):

            ctx['cv2_reading'] = True

        return ctx

tab3_addresses = PatientRecordAddrView.as_view()

class ReadCV2View(cbv.FormView):

    template_name = 'dossiers/cv2.html'

    form_class = Form

    success_url = './view#tab=2'

    def get_context_data(self, **kwargs):

        ctx = super(ReadCV2View, self).get_context_data(**kwargs)

        cv_files_path = get_service_setting('cv_files_path')

        if not cv_files_path or not os.path.isdir(cv_files_path):

            return ctx

        reader_identifier = None

        try:

            reader_identifier = self.request.user.userworker.worker.cv2_reader_name

        except:

            pass

        filename = get_last_file(cv_files_path,

                prefix=reader_identifier, suffix='.xml')

        ctx['cv'] = None

        try:

            ctx['cv'] = cvitale.parse(filename)

        except Exception, e:

            logger.warning("%s" % str(e))

        try:

            ctx['object'] = PatientRecord.objects.get(id=self.kwargs['patientrecord_id'])

        except:

            pass

        return ctx

if settings.CV2PARSER:

    read_cv2 = validator_only(ReadCV2View.as_view())

class PatientRecordNotifsView(cbv.DetailView):

    model = PatientRecord

    template_name = 'dossiers/patientrecord_tab4_notifs.html'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordNotifsView, self).get_context_data(**kwargs)

        ctx['status'], ctx['hc_status'] = get_status(ctx, self.request.user)

        if ctx['object'].service.slug == "cmpp":

            (acts_not_locked, days_not_locked, acts_not_valide,

            acts_not_billable, acts_pause, acts_per_hc, acts_losts) = \

                list_acts_for_billing_CMPP_per_patient(self.object,

                    datetime.today(), self.service)

            ctx['acts_losts'] = acts_losts

            ctx['acts_pause'] = acts_pause

            hcs_used = acts_per_hc.keys()

            hcs = None

            if not hcs_used:

                hcs = [(hc, None) for hc in HealthCare.objects.filter(patient=self.object).order_by('-start_date')]

            else:

                hcs = []

                for hc in HealthCare.objects.filter(patient=self.object).order_by('-start_date'):

                    acts = None

                    if hasattr(hc, 'cmpphealthcarediagnostic') and hc.cmpphealthcarediagnostic in hcs_used:

                        acts = acts_per_hc[hc.cmpphealthcarediagnostic]

                    elif hasattr(hc, 'cmpphealthcaretreatment') and hc.cmpphealthcaretreatment in hcs_used:

                        acts = acts_per_hc[hc.cmpphealthcaretreatment]

                    hcs.append((hc, acts))

            ctx['hcs'] = []

            for hc, acts in hcs:

                ctx['hcs'].append((hc, acts, hc.act_set.order_by('date', 'time')))

        elif ctx['object'].service.slug == "sessad-ted" or ctx['object'].service.slug == "sessad-dys":

            ctx['hcs'] = HealthCare.objects.filter(patient=self.object).order_by('-start_date')

        return ctx

tab4_notifs = PatientRecordNotifsView.as_view()

class PatientRecordOldActs(cbv.DetailView):

    model = PatientRecord

    template_name = 'dossiers/patientrecord_tab5_actes_passes.html'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordOldActs, self).get_context_data(**kwargs)

        ctx['last_rdvs'] = []

        for act in Act.objects.last_acts(ctx['object']).prefetch_related('doctors'):

            state = act.get_state()

            if state and not state.previous_state and state.state_name == 'NON_VALIDE':

                state = None

            missing_workers = []

            try:

                missing_workers = [participant.worker for participant in act.event.get_missing_participants()]

            except:

                pass

            ctx['last_rdvs'].append((act, state, missing_workers))

        history = []

        i = 0

        for state in ctx['object'].filestate_set.order_by('-date_selected'):

            acts = []

            try:

                while ctx['last_rdvs'][i][0].date >= state.date_selected.date():

                    acts.append(ctx['last_rdvs'][i])

                    i += 1

            except:

                pass

            history.append((state, acts))

        if i < len(ctx['last_rdvs']) - 1:

            history.append((None, ctx['last_rdvs'][i:]))

        ctx['history'] = history

        return ctx

tab5_old_acts = PatientRecordOldActs.as_view()

class PatientRecordNextAppointmentsView(cbv.DetailView):

    model = PatientRecord

    template_name = 'dossiers/patientrecord_tab6_next_rdv.html'

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordNextAppointmentsView, self).get_context_data(**kwargs)

        ctx['next_rdvs'] = []

        Q = models.Q

        today = date.today()

        qs = EventWithAct.objects.filter(patient=ctx['object']) \

                .filter(exception_to__isnull=True, canceled=False) \

                .filter(Q(start_datetime__gte=today) \

                |  Q(exceptions__isnull=False) \

                | ( Q(recurrence_periodicity__isnull=False) \

                & (Q(recurrence_end_date__gte=today) \

                | Q(recurrence_end_date__isnull=True) \

                ))) \

                .distinct() \

                .select_related() \

                .prefetch_related('participants', 'exceptions__eventwithact',

                        'act_set__actvalidationstate_set')

        occurrences = []

        for event in qs:

            occurrences.extend(filter(lambda e: e.start_datetime.date() >= today,

                event.all_occurences(limit=180)))

        occurrences = sorted(occurrences, key=lambda e: e.start_datetime)

        for event in occurrences:

            state = None

            if event.act:

                state = event.act.get_state()

            if state and not state.previous_state and state.state_name == 'NON_VALIDE':

                state = None

            ctx['next_rdvs'].append((event, state, event.get_missing_participants(), event.get_inactive_participants()))

        return ctx

tab6_next_rdv = PatientRecordNextAppointmentsView.as_view()

class PatientRecordSocialisationView(cbv.DetailView):

    model = PatientRecord

    template_name = 'dossiers/patientrecord_tab7_socialisation.html'

tab7_socialisation = PatientRecordSocialisationView.as_view()

class PatientRecordMedicalView(cbv.UpdateView):

    model = PatientRecord

    form_class = forms.PhysiologyForm

    template_name = 'dossiers/patientrecord_tab8_medical.html'

    success_url = './view#tab=7'

tab8_medical = PatientRecordMedicalView.as_view()

class PatientRecordsHomepageView(cbv.ListView):

    model = PatientRecord

    template_name = 'dossiers/index.html'

    def _get_search_result(self, paginate_patient_records):

        patient_records = []

        for patient_record in paginate_patient_records:

            next_rdv = get_next_rdv(patient_record)

            last_rdv = get_last_rdv(patient_record)

            current_status = patient_record.last_state.status

            state = current_status.name

            state_class = current_status.type.lower()

            patient_records.append(

                    {

                        'object': patient_record,

                        'next_rdv': next_rdv,

                        'last_rdv': last_rdv,

                        'state': state,

                        'state_class': state_class

                        }

                    )

        return patient_records

    def get_queryset(self):

        first_name = self.request.GET.get('first_name')

        last_name = self.request.GET.get('last_name')

        paper_id = self.request.GET.get('paper_id')

        id = self.request.GET.get('id')

        social_security_id = self.request.GET.get('social_security_id')

        if not (first_name or last_name or paper_id or id or social_security_id):

            return None

        if (first_name and len(first_name) < 2) or (last_name and len(last_name) < 2):

            return None

        qs = super(PatientRecordsHomepageView, self).get_queryset()

        states = self.request.GET.getlist('states')

        if last_name:

            qs = qs.filter(last_name__istartswith=last_name)

        if first_name:

            qs = qs.filter(first_name__istartswith=first_name)

        if paper_id:

            qs = qs.filter(paper_id__startswith=paper_id)

        if id:

            qs = qs.filter(id__startswith=id)

        if social_security_id:

            qs = qs.filter(models.Q(social_security_id__startswith=social_security_id) | \

                models.Q(contacts__social_security_id__startswith=social_security_id))

        if states:

            qs = qs.filter(last_state__status__id__in=states)

        else:

            qs = qs.filter(last_state__status__type__in="")

        qs = qs.filter(service=self.service).order_by('last_name').\

                prefetch_related('last_state',

                        'patientcontact', 'last_state__status')

        return qs

    def get_context_data(self, **kwargs):

        ctx = super(PatientRecordsHomepageView, self).get_context_data(**kwargs)

        ctx['search_form'] = forms.SearchForm(service=self.service, data=self.request.GET or None)

        ctx['stats'] = [["Dossiers", 0]]

        for status in Status.objects.filter(services=self.service):

            ctx['stats'].append([status.name, 0])

        page = self.request.GET.get('page')

        if ctx['object_list']:

            patient_records = ctx['object_list'].filter()

        else:

            patient_records = []

        # TODO: use a sql query to do this

        for patient_record in patient_records:

            ctx['stats'][0][1] += 1

            for elem in ctx['stats']:

                if elem[0] == patient_record.last_state.status.name:

                    elem[1] += 1

        paginator = Paginator(patient_records, 50)

        try:

            paginate_patient_records = paginator.page(page)

        except PageNotAnInteger:

            paginate_patient_records = paginator.page(1)

        except EmptyPage:

            paginate_patient_records = paginator.page(paginator.num_pages)

        query = self.request.GET.copy()

        if 'page' in query:

            del query['page']

        ctx['query'] = query.urlencode()

        ctx['paginate_patient_records'] = paginate_patient_records

        ctx['patient_records'] = self._get_search_result(paginate_patient_records)

        return ctx

patientrecord_home = PatientRecordsHomepageView.as_view()

class PatientRecordDeleteView(DeleteView):

    model = PatientRecord

    success_url = ".."

    template_name = 'dossiers/patientrecord_confirm_delete.html'

patientrecord_delete = validator_only(PatientRecordDeleteView.as_view())

class PatientRecordPaperIDUpdateView(cbv.UpdateView):

    model = PatientRecord

    form_class = forms.PaperIDForm

    template_name = 'dossiers/generic_form.html'

    success_url = '../view#tab=0'

update_paper_id = PatientRecordPaperIDUpdateView.as_view()

class NewSocialisationDurationView(cbv.CreateView):

    model = SocialisationDuration

    form_class = forms.SocialisationDurationForm

    template_name = 'dossiers/generic_form.html'

    success_url = '../view#tab=6'

    def get_success_url(self):

        return self.success_url

    def get(self, request, *args, **kwargs):

        if kwargs.has_key('patientrecord_id'):

            request.session['patientrecord_id'] = kwargs['patientrecord_id']

        return super(NewSocialisationDurationView, self).get(request, *args, **kwargs)

    def form_valid(self, form):

        duration = form.save()

        patientrecord = PatientRecord.objects.get(id=self.kwargs['patientrecord_id'])

        patientrecord.socialisation_durations.add(duration)

        return HttpResponseRedirect(self.get_success_url())

new_socialisation_duration = NewSocialisationDurationView.as_view()

class UpdateSocialisationDurationView(cbv.UpdateView):

    model = SocialisationDuration

    form_class = forms.SocialisationDurationForm

    template_name = 'dossiers/generic_form.html'

    success_url = '../../view#tab=6'

    def get(self, request, *args, **kwargs):

        if kwargs.has_key('patientrecord_id'):

            request.session['patientrecord_id'] = kwargs['patientrecord_id']

        return super(UpdateSocialisationDurationView, self).get(request, *args, **kwargs)

update_socialisation_duration = UpdateSocialisationDurationView.as_view()

class DeleteSocialisationDurationView(cbv.DeleteView):

    model = SocialisationDuration

    form_class = forms.SocialisationDurationForm

    template_name = 'dossiers/socialisationduration_confirm_delete.html'

    success_url = '../../view#tab=6'

delete_socialisation_duration = DeleteSocialisationDurationView.as_view()

class NewMDPHRequestView(cbv.CreateView):

    def get(self, request, *args, **kwargs):

        if kwargs.has_key('patientrecord_id'):

            request.session['patientrecord_id'] = kwargs['patientrecord_id']

        return super(NewMDPHRequestView, self).get(request, *args, **kwargs)

    def form_valid(self, form):

        request = form.save()

        patientrecord = PatientRecord.objects.get(id=self.kwargs['patientrecord_id'])

        patientrecord.mdph_requests.add(request)

        return HttpResponseRedirect(self.success_url)

class UpdateMDPHRequestView(cbv.UpdateView):

    def get(self, request, *args, **kwargs):

        if kwargs.has_key('patientrecord_id'):

            request.session['patientrecord_id'] = kwargs['patientrecord_id']

        return super(UpdateMDPHRequestView, self).get(request, *args, **kwargs)

new_mdph_request = \

    NewMDPHRequestView.as_view(model=MDPHRequest,

        template_name = 'dossiers/generic_form.html',

        success_url = '../view#tab=6',

        form_class=forms.MDPHRequestForm)

update_mdph_request = \

    UpdateMDPHRequestView.as_view(model=MDPHRequest,

        template_name = 'dossiers/generic_form.html',

        success_url = '../../view#tab=6',

        form_class=forms.MDPHRequestForm)

delete_mdph_request = \

    cbv.DeleteView.as_view(model=MDPHRequest,

        template_name = 'dossiers/generic_confirm_delete.html',

        success_url = '../../view#tab=6')

class NewMDPHResponseView(cbv.CreateView):

    def get(self, request, *args, **kwargs):

        if kwargs.has_key('patientrecord_id'):

            request.session['patientrecord_id'] = kwargs['patientrecord_id']

        return super(NewMDPHResponseView, self).get(request, *args, **kwargs)

    def form_valid(self, form):

        response = form.save()

        patientrecord = PatientRecord.objects.get(id=self.kwargs['patientrecord_id'])

        patientrecord.mdph_responses.add(response)

        return HttpResponseRedirect(self.success_url)

class UpdateMDPHResponseView(cbv.UpdateView):

    def get(self, request, *args, **kwargs):