Project

General

Profile

Download (31.4 KB) Statistics
| Branch: | Tag: | Revision:

calebasse / calebasse / agenda / views.py @ 3a38fa86

1
# -*- coding: utf-8 -*-
2

    
3
import datetime
4
import logging
5
from itertools import chain
6

    
7
from django.contrib import messages
8
from django.db.models import Q
9
from django.shortcuts import redirect, get_object_or_404
10
from django.http import HttpResponseRedirect, HttpResponse
11
from django.conf import settings
12

    
13
from calebasse.cbv import TemplateView, CreateView, UpdateView
14
from calebasse.agenda.models import Event, EventType, EventWithAct
15
from calebasse.personnes.models import TimeTable, Holiday
16
from calebasse.agenda.appointments import get_daily_appointments, get_daily_usage
17
from calebasse.personnes.models import Worker
18
from calebasse.ressources.models import WorkerType, Room
19
from calebasse.actes.validation import (get_acts_of_the_day,
20
        get_days_with_acts_not_locked)
21
from calebasse.actes.validation_states import VALIDATION_STATES
22
from calebasse.actes.models import Act, ValidationMessage
23
from calebasse.actes.validation import (automated_validation, unlock_all_acts_of_the_day)
24
from calebasse import cbv
25

    
26
from calebasse.agenda.forms import (NewAppointmentForm, NewEventForm, UpdatePeriodicAppointmentForm,
27
        DisablePatientAppointmentForm, UpdateAppointmentForm, UpdatePeriodicEventForm, 
28
        UpdateEventForm, PeriodicEventsSearchForm)
29

    
30
logger = logging.getLogger(__name__)
31

    
32
def redirect_today(request, service):
33
    '''If not date is given we redirect on the agenda for today'''
34
    return redirect('agenda', date=datetime.date.today().strftime('%Y-%m-%d'),
35
            service=service)
36

    
37

    
38
class AgendaHomepageView(TemplateView):
39
    template_name = 'agenda/index.html'
40
    cookies_to_clear = []
41

    
42
    def post(self, request, *args, **kwargs):
43
        acte_id = request.POST.get('event-id')
44
        try:
45
            event = EventWithAct.objects.get(id=acte_id)
46
            event = event.today_occurrence(self.date)
47
            act = event.act
48
            if not act.validation_locked:
49
                state_name = request.POST.get('act_state')
50
                act.save()
51
                act.set_state(state_name, request.user)
52
        except Act.DoesNotExist:
53
            logger.warning('agenda homepage acte_id %d not found' % acte_id)
54
        return HttpResponseRedirect('#acte-frame-'+acte_id)
55

    
56
    def get_context_data(self, **kwargs):
57
        logger.info('AgendaHomepageView.get_context_data called')
58
        context = super(AgendaHomepageView, self).get_context_data(**kwargs)
59

    
60
        context['workers_types'] = []
61
        workers = Worker.objects.filter(enabled=True).select_related() \
62
                .prefetch_related('services')
63
        worker_by_type = {}
64
        for worker in workers:
65
            workers_for_type = worker_by_type.setdefault(worker.type, [])
66
            workers_for_type.append(worker)
67
        for worker_type, workers_for_type in worker_by_type.iteritems():
68
            context['workers_types'].append(
69
                    {'type': worker_type.name, 'workers': workers_for_type })
70
        context['workers'] = workers
71
        context['disponibility_start_times'] = range(8, 20)
72

    
73
        # ressources
74
        context['ressources_types'] = []
75
        data = {'type': Room._meta.verbose_name_plural,
76
                'ressources': Room.objects.all()}
77
        context['ressources_types'].append(data)
78

    
79
        return context
80

    
81
class AgendaServiceActivityView(TemplateView, cbv.ServiceViewMixin):
82
    template_name = 'agenda/service-activity.html'
83
    cookies_to_clear = [('agenda-tabs', ), ('active-agenda', ), ('last-ressource', )]
84

    
85
    def get_context_data(self, **kwargs):
86
        context = super(AgendaServiceActivityView, self).get_context_data(**kwargs)
87

    
88
        appointments_times = dict()
89
        events = Event.objects.for_today(self.date) \
90
                .exclude(event_type_id=1) \
91
                .filter(services=self.service) \
92
                .order_by('start_datetime', 'id') \
93
                .select_related() \
94
                .prefetch_related('participants', 'exceptions')
95
        eventswithact = EventWithAct.objects.for_today(self.date) \
96
                .filter(services=self.service) \
97
                .order_by('start_datetime', 'id') \
98
                .select_related() \
99
                .prefetch_related('participants', 'exceptions')
100
        events = [ e.today_occurrence(self.date) for e in events ] \
101
             + [ e.today_occurrence(self.date) for e in eventswithact ]
102
        for event in events:
103
            start_datetime = event.start_datetime.strftime("%H:%M")
104
            if not appointments_times.has_key(start_datetime):
105
                appointments_times[start_datetime] = dict()
106
                appointments_times[start_datetime]['row'] = 0
107
                appointments_times[start_datetime]['appointments'] = []
108
            appointment = dict()
109
            length = event.end_datetime - event.start_datetime
110
            if length.seconds:
111
                length = length.seconds / 60
112
                appointment['length'] = "%sm" % length
113
            if event.event_type_id == 1:
114
                appointment['type'] = 1
115
                appointment['label'] = event.patient.display_name
116
                appointment['paper_id'] = event.patient.paper_id
117
                appointment['act'] = event.act_type.name
118
                appointment['state'] = event.act.get_state()
119
                appointment['absent'] = event.act.is_absent()
120
            else:
121
                appointment['type'] = 2
122
                if event.event_type.label == 'Autre' and event.title:
123
                    appointment['label'] = event.title
124
                else:
125
                    appointment['label'] = '%s - %s' % (event.event_type.label,
126
                                                        event.title)
127
            appointment['participants'] = event.participants.filter(worker__enabled=True)
128
            appointment['len_participants'] = len(appointment['participants'])
129
            appointment['workers_absent'] = event.get_missing_participants()
130
            appointments_times[start_datetime]['row'] += 1
131
            appointments_times[start_datetime]['appointments'].append(appointment)
132
        context['appointments_times'] = sorted(appointments_times.items())
133
        return context
134

    
135

    
136
class NewAppointmentView(cbv.ReturnToObjectMixin, cbv.ServiceFormMixin, CreateView):
137
    model = EventWithAct
138
    form_class = NewAppointmentForm
139
    template_name = 'agenda/new-appointment.html'
140
    success_msg = u'Rendez-vous enregistré avec succès.'
141
    cookies_to_clear = []
142

    
143
    def get_initial(self):
144
        initial = super(NewAppointmentView, self).get_initial()
145
        initial['start_datetime'] = self.date
146
        initial['date'] = self.date
147
        initial['participants'] = self.request.GET.getlist('participants')
148
        initial['time'] = self.request.GET.get('time')
149
        initial['room'] = self.request.GET.get('room')
150
        return initial
151

    
152
    def get_form_kwargs(self):
153
        kwargs = super(NewAppointmentView, self).get_form_kwargs()
154
        kwargs['service'] = self.service
155
        return kwargs
156

    
157
    def get_success_url(self):
158
        return self.request.META.get('HTTP_REFERER', '..')
159

    
160
    def form_valid(self, form):
161
        messages.add_message(self.request, messages.INFO, self.success_msg)
162
        return super(NewAppointmentView, self).form_valid(form)
163

    
164

    
165
class TodayOccurrenceMixin(object):
166
    def get_object(self, queryset=None):
167
        o = super(TodayOccurrenceMixin, self).get_object(queryset)
168
        return o.today_occurrence(self.date)
169

    
170

    
171
class BaseAppointmentView(UpdateView):
172
    model = EventWithAct
173
    form_class = UpdateAppointmentForm
174
    template_name = 'agenda/update-rdv.html'
175
    success_url = '..'
176
    cookies_to_clear = []
177

    
178
    def get_initial(self):
179
        initial = super(BaseAppointmentView, self).get_initial()
180
        initial['start_datetime'] = self.date
181
        initial['date'] = self.object.start_datetime.date()
182
        initial['time'] = self.object.start_datetime.time()
183
        time = self.object.end_datetime - self.object.start_datetime
184
        if time:
185
            time = time.seconds / 60
186
        else:
187
            time = 0
188
        initial['duration'] = time
189
        initial['participants'] = self.object.participants.values_list('id', flat=True)
190
        return initial
191

    
192
    def get_form_kwargs(self):
193
        kwargs = super(BaseAppointmentView, self).get_form_kwargs()
194
        kwargs['service'] = self.service
195
        return kwargs
196

    
197

    
198
class UpdateAppointmentView(TodayOccurrenceMixin, BaseAppointmentView):
199

    
200
    def get_form_class(self):
201
        if self.object.exception_to and not self.object.exception_to.canceled:
202
            return DisablePatientAppointmentForm
203
        else:
204
            return self.form_class
205

    
206

    
207
class UpdatePeriodicAppointmentView(BaseAppointmentView):
208
    form_class = UpdatePeriodicAppointmentForm
209
    template_name = 'agenda/new-appointment.html'
210

    
211

    
212
class NewEventView(CreateView):
213
    model = Event
214
    form_class = NewEventForm
215
    template_name = 'agenda/new-event.html'
216
    cookies_to_clear = []
217

    
218
    def get_initial(self):
219
        initial = super(NewEventView, self).get_initial()
220
        initial['start_datetime'] = self.date
221
        initial['date'] = self.date
222
        initial['participants'] = self.request.GET.getlist('participants')
223
        initial['time'] = self.request.GET.get('time')
224
        initial['event_type'] = 2
225
        initial['room'] = self.request.GET.get('room')
226
        if not initial.has_key('services'):
227
            initial['services'] = [self.service]
228
        return initial
229

    
230
    def get_form_kwargs(self):
231
        kwargs = super(NewEventView, self).get_form_kwargs()
232
        kwargs['service'] = self.service
233
        return kwargs
234

    
235
    def get_success_url(self):
236
        return self.request.META.get('HTTP_REFERER', '..')
237

    
238
    def form_valid(self, form):
239
        messages.add_message(self.request, messages.INFO, u'Evénement enregistré avec succès.')
240
        return super(NewEventView, self).form_valid(form)
241

    
242

    
243
class BaseEventView(UpdateView):
244
    model = Event
245
    form_class = UpdateEventForm
246
    template_name = 'agenda/update-event.html'
247
    success_url = '..'
248
    cookies_to_clear = []
249

    
250
    def get_initial(self):
251
        initial = super(BaseEventView, self).get_initial()
252
        initial['start_datetime'] = self.date
253
        initial['date'] = self.object.start_datetime.date()
254
        initial['time'] = self.object.start_datetime.time()
255
        time = self.object.end_datetime - self.object.start_datetime
256
        if time:
257
            time = time.seconds / 60
258
        else:
259
            time = 0
260
        initial['duration'] = time
261
        initial['participants'] = self.object.participants.values_list('id', flat=True)
262
        return initial
263

    
264
    def get_form_kwargs(self):
265
        kwargs = super(BaseEventView, self).get_form_kwargs()
266
        kwargs['service'] = self.service
267
        return kwargs
268

    
269

    
270
class UpdateEventView(TodayOccurrenceMixin, BaseEventView):
271
    pass
272

    
273

    
274
class UpdatePeriodicEventView(BaseEventView):
275
    form_class = UpdatePeriodicEventForm
276
    template_name = 'agenda/new-event.html'
277

    
278
def delete_eventwithact(event):
279
    assert event.event_type == 1
280
    if event.act.id \
281
            and not event.act.is_billed:
282
        event.act.delete()
283
    if not event.act.id or \
284
            not event.act.is_billed:
285
        event.delete()
286

    
287
class DeleteOccurrenceView(TodayOccurrenceMixin, cbv.DeleteView):
288
    model = Event
289
    success_url = '..'
290
    cookies_to_clear = []
291

    
292
    def delete(self, request, *args, **kwargs):
293
        self.object = self.get_object()
294
        if self.object.event_type == 1:
295
            delete_eventwithact(self.object)
296
        else:
297
            self.object.delete()
298

    
299
        return HttpResponse(status=204)
300

    
301
class DeleteEventView(cbv.DeleteView):
302
    model = Event
303
    success_url = '..'
304
    cookies_to_clear = []
305

    
306
    def delete(self, request, *args, **kwargs):
307
        self.object = self.get_object()
308
        # If exceptions remove them only if act is not billed
309
        for exception in self.object.exceptions.all():
310
            exception.recurrence_periodicity = None
311
            exception.exception_to = None
312
            exception.save()
313
            if exception.event_type == 1:
314
                delete_eventwithact(exception)
315
            else:
316
                exception.delete()
317

    
318
        if self.object.event_type == 1:
319
            delete_eventwithact(self.object)
320
        else:
321
            self.object.delete()
322
        return HttpResponse(status=204)
323

    
324
class AgendaServiceActValidationView(TemplateView):
325
    template_name = 'agenda/act-validation.html'
326
    cookies_to_clear = [('agenda-tabs', ), ('active-agenda', ), ('last-ressource', )]
327

    
328
    def acts_of_the_day(self):
329
        acts = list(Act.objects \
330
                .filter(date=self.date, patient__service=self.service) \
331
                .select_related() \
332
                .prefetch_related('doctors',
333
                        'patient__patientcontact',
334
                        'actvalidationstate_set__previous_state') \
335
                .order_by('time'))
336
        event_ids = [ a.parent_event_id for a in acts if a.parent_event_id ]
337
        events = EventWithAct.objects.for_today(self.date) \
338
                .filter(patient__service=self.service) \
339
                .exclude(id__in=event_ids)
340
        events = [ event.today_occurrence(self.date) for event in events ]
341
        acts += [ event.act for event in events if event ]
342
        return sorted(acts, key=lambda a: (a.time or datetime.time.min, a.id))
343

    
344
    def post(self, request, *args, **kwargs):
345
        if 'unlock-all' in request.POST:
346
            #TODO: check that the user is authorized
347
            unlock_all_acts_of_the_day(self.date, self.service)
348
            ValidationMessage(validation_date=self.date,
349
                who=request.user, what='Déverrouillage',
350
                service=self.service).save()
351
        else:
352
            acte_id = request.POST.get('acte-id')
353
            try:
354
                act = Act.objects.get(id=acte_id)
355
                if 'lock' in request.POST or 'unlock' in request.POST:
356
                    #TODO: check that the user is authorized
357
                    act.validation_locked = 'lock' in request.POST
358
                    act.save()
359
                else:
360
                    state_name = request.POST.get('act_state')
361
                    act.set_state(state_name, request.user)
362
            except Act.DoesNotExist:
363
                pass
364
            return HttpResponseRedirect('#acte-frame-'+acte_id)
365
        return HttpResponseRedirect('')
366

    
367
    def get_context_data(self, **kwargs):
368
        context = super(AgendaServiceActValidationView, self).get_context_data(**kwargs)
369
        authorized_lock = True # is_authorized_for_locking(get_request().user)
370
        validation_msg = ValidationMessage.objects.\
371
            filter(validation_date=self.date, service=self.service).\
372
            order_by('-when')[:3]
373
        acts_of_the_day = self.acts_of_the_day()
374
        actes = list()
375
        for act in acts_of_the_day:
376
            if not act.id:
377
                if act.date < datetime.date(2013, 1, 1):
378
                    continue
379
                else:
380
                    act.save()
381
            state = act.get_state()
382
            display_name = None
383
            if state :
384
                display_name = VALIDATION_STATES[state.state_name]
385
                if not state.previous_state_id and state.state_name == 'NON_VALIDE':
386
                    state = None
387
            actes.append((act, state, display_name))
388
        validation_states = dict(VALIDATION_STATES)
389
        if self.service.name != 'CMPP' and \
390
                'ACT_DOUBLE' in validation_states:
391
            validation_states.pop('ACT_DOUBLE')
392
        vs = [('VALIDE', 'Présent')]
393
        validation_states.pop('VALIDE')
394
        validation_states.pop('ACT_LOST')
395
        validation_states = vs + sorted(validation_states.items(), key=lambda tup: tup[0])
396
        context['validation_states'] = validation_states
397
        context['actes'] = actes
398
        context['validation_msg'] = validation_msg
399
        context['authorized_lock'] = authorized_lock
400
        return context
401

    
402

    
403
class AutomatedValidationView(TemplateView):
404
    template_name = 'agenda/automated-validation.html'
405

    
406
    def post(self, request, *args, **kwargs):
407
        automated_validation(self.date, self.service,
408
            request.user)
409
        ValidationMessage(validation_date=self.date,
410
            who=request.user, what='Validation automatique',
411
            service=self.service).save()
412
        return HttpResponseRedirect('..')
413

    
414
    def get_context_data(self, **kwargs):
415
        context = super(AutomatedValidationView, self).get_context_data(**kwargs)
416
        request = self.request
417
        (nb_acts_total, nb_acts_validated, nb_acts_double,
418
        nb_acts_abs_non_exc, nb_acts_abs_exc, nb_acts_abs_inter, nb_acts_annul_nous,
419
        nb_acts_annul_famille, nb_acts_reporte, nb_acts_abs_ess_pps,
420
        nb_acts_enf_hosp, nb_acts_losts) = \
421
            automated_validation(self.date, self.service,
422
                request.user, commit = False)
423

    
424
        nb_acts_not_validated = nb_acts_double + \
425
            nb_acts_abs_non_exc + \
426
            nb_acts_abs_exc + \
427
            nb_acts_abs_inter + \
428
            nb_acts_annul_nous + \
429
            nb_acts_annul_famille + \
430
            nb_acts_reporte + \
431
            nb_acts_abs_ess_pps + \
432
            nb_acts_enf_hosp + \
433
            nb_acts_losts
434
        context.update({
435
            'nb_acts_total': nb_acts_total,
436
            'nb_acts_validated': nb_acts_validated,
437
            'nb_acts_not_validated': nb_acts_not_validated,
438
            'nb_acts_double': nb_acts_double,
439
            'nb_acts_abs_non_exc': nb_acts_abs_non_exc,
440
            'nb_acts_abs_exc': nb_acts_abs_exc,
441
            'nb_acts_abs_inter': nb_acts_abs_inter,
442
            'nb_acts_annul_nous': nb_acts_annul_nous,
443
            'nb_acts_annul_famille': nb_acts_annul_famille,
444
            'nb_acts_reporte': nb_acts_reporte,
445
            'nb_acts_abs_ess_pps': nb_acts_abs_ess_pps,
446
            'nb_acts_enf_hosp': nb_acts_enf_hosp,
447
            'nb_acts_losts': nb_acts_losts})
448
        return context
449

    
450
class UnlockAllView(CreateView):
451
    pass
452

    
453

    
454
class AgendasTherapeutesView(AgendaHomepageView):
455
    template_name = 'agenda/agendas-therapeutes.html'
456
    cookies_to_clear = [('agenda-tabs', ), ('active-agenda', ), ('last-ressource', )]
457

    
458
    def get_context_data(self, **kwargs):
459
        context = super(AgendasTherapeutesView, self).get_context_data(**kwargs)
460

    
461
        time_tables = TimeTable.objects.select_related('worker'). \
462
                filter(services=self.service). \
463
                for_today(self.date). \
464
                order_by('start_date')
465
        holidays = Holiday.objects.select_related('worker') \
466
                .for_period(self.date, self.date) \
467
                .order_by('start_date') \
468
                .select_related()
469
        events = Event.objects.for_today(self.date) \
470
                .exclude(event_type_id=1) \
471
                .filter(services=self.service) \
472
                .order_by('start_datetime') \
473
                .select_related() \
474
                .prefetch_related('services',
475
                        'exceptions',
476
                        'participants')
477
        eventswithact = EventWithAct.objects.for_today(self.date) \
478
                .filter(services=self.service) \
479
                .order_by('start_datetime') \
480
                .select_related() \
481
                .prefetch_related(
482
                        'services',
483
                        'patient__service',
484
                        'act_set__actvalidationstate_set',
485
                        'exceptions', 'participants')
486
        events = [ e.today_occurrence(self.date) for e in events ] \
487
             + [ e.today_occurrence(self.date) for e in eventswithact ]
488
        for e in events:
489
            e.workers_ids = set(p.id for p in e.participants.all())
490

    
491
        events_workers = {}
492
        time_tables_workers = {}
493
        holidays_workers = {}
494
        context['workers_agenda'] = []
495
        context['workers'] = context['workers'].filter(services=self.service)
496
        for worker in context['workers']:
497
            time_tables_worker = [tt for tt in time_tables if tt.worker.id == worker.id]
498
            events_worker = [o for o in events if worker.id in o.workers_ids ]
499
            holidays_worker = [h for h in holidays if h.worker_id in (None, worker.id)]
500
            events_workers[worker.id] = events_worker
501
            time_tables_workers[worker.id] = time_tables_worker
502
            holidays_workers[worker.id] = holidays_worker
503
            daily_appointments = get_daily_appointments(context['date'], worker, self.service,
504
                        time_tables_worker, events_worker, holidays_worker)
505
            if all(map(lambda x: x.holiday, daily_appointments)):
506
                continue
507
            context['workers_agenda'].append({'worker': worker,
508
                    'appointments': daily_appointments})
509

    
510
        for worker_agenda in context.get('workers_agenda', []):
511
            patient_appointments = [x for x in worker_agenda['appointments'] if x.patient_record_id]
512
            worker_agenda['summary'] = {
513
              'rdv': len(patient_appointments),
514
              'presence': len([x for x in patient_appointments if x.act_absence is None]),
515
              'absence': len([x for x in patient_appointments if x.act_absence is not None]),
516
              'doubles': len([x for x in patient_appointments if x.act_type == 'ACT_DOUBLE']),
517
              'valides': len([x for x in patient_appointments if x.act_type == 'ACT_VALIDE']),
518
            }
519

    
520
        return context
521

    
522
class JoursNonVerrouillesView(TemplateView):
523
    template_name = 'agenda/days-not-locked.html'
524

    
525
    def get_context_data(self, **kwargs):
526
        context = super(JoursNonVerrouillesView, self).get_context_data(**kwargs)
527
        acts = Act.objects.filter(is_billed=False,
528
            patient__service=self.service).order_by('date')
529
        days = set(acts.values_list('date', flat=True))
530
        if days:
531
            max_day, min_day = max(days), min(days)
532
            today = datetime.datetime.today().date()
533
            if max_day > today:
534
                max_day = today
535
            days &= set(get_days_with_acts_not_locked(min_day, max_day, self.service))
536
        context['days_not_locked'] = sorted(days)
537
        return context
538

    
539
class AjaxWorkerTabView(TemplateView):
540

    
541
    template_name = 'agenda/ajax-worker-tab.html'
542
    cookies_to_clear = []
543

    
544
    def get_context_data(self, worker_id, **kwargs):
545
        context = super(AjaxWorkerTabView, self).get_context_data(**kwargs)
546
        worker = Worker.objects.get(id=worker_id)
547

    
548
        time_tables_worker = TimeTable.objects.select_related('worker'). \
549
                filter(services=self.service, worker=worker) \
550
                .for_today(self.date) \
551
                .order_by('start_date') \
552
                .select_related()
553
        holidays_worker = Holiday.objects.for_worker(worker) \
554
                .for_period(self.date, self.date) \
555
                .order_by('start_date') \
556
                .select_related()
557
        events = Event.objects.for_today(self.date) \
558
                .exclude(event_type_id=1) \
559
                .filter(participants=worker) \
560
                .order_by('start_datetime') \
561
                .select_related() \
562
                .prefetch_related('services',
563
                        'exceptions',
564
                        'participants')
565
        eventswithact = EventWithAct.objects.for_today(self.date) \
566
                .filter(participants=worker) \
567
                .order_by('start_datetime') \
568
                .select_related() \
569
                .prefetch_related('patient__addresses',
570
                        'patient__addresses__patientcontact_set',
571
                        'services',
572
                        'patient__service',
573
                        'act_set__actvalidationstate_set',
574
                        'exceptions', 'participants')
575
        events = [ e.today_occurrence(self.date) for e in events ] \
576
             + [ e.today_occurrence(self.date) for e in eventswithact ]
577

    
578
        context['worker_agenda'] = {'worker': worker,
579
                    'appointments': get_daily_appointments(context['date'], worker, self.service,
580
                        time_tables_worker, events, holidays_worker)}
581

    
582
        if settings.RTF_TEMPLATES_DIRECTORY:
583
            context['mail'] = True
584
        return context
585

    
586
class AjaxRessourceTabView(TemplateView):
587
    template_name = 'agenda/ajax-ressource-tab.html'
588
    cookies_to_clear = []
589

    
590
    def get_context_data(self, ressource_id, **kwargs):
591
        context = super(AjaxRessourceTabView, self).get_context_data(**kwargs)
592
        ressource = Room.objects.get(pk=ressource_id)
593
        plain_events = Event.objects.for_today(self.date) \
594
                                    .order_by('start_datetime').select_subclasses()
595
        events = [ e.today_occurrence(self.date) for e in plain_events ]
596
        events_ressource = [e for e in events if ressource == e.room]
597
        context['ressource_agenda'] = {'appointments': get_daily_usage(context['date'],
598
                                                                       ressource,
599
                                                                       self.service,
600
                                                                       events_ressource)
601
        }
602
        return context
603

    
604
class AjaxDisponibilityColumnView(TemplateView):
605

    
606
    template_name = 'agenda/ajax-disponibility-column.html'
607
    cookies_to_clear = []
608

    
609
    def get_ressource_context_data(self, ressource_id, context):
610
        ressource = Room.objects.get(pk = ressource_id)
611
        context['initials'] = ressource.name[:3]
612
        disponibility = dict()
613
        start_datetime = datetime.datetime(self.date.year,
614
                                           self.date.month,
615
                                           self.date.day, 8, 0)
616
        end_datetime = datetime.datetime(self.date.year, self.date.month,
617
                                         self.date.day, 8, 15)
618
        events = Event.objects.filter(room__id=ressource_id).today_occurrences(self.date)
619

    
620
        while (start_datetime.hour <= 19):
621
            if start_datetime.hour not in disponibility:
622
                disponibility[start_datetime.hour] = [[], [], [], []]
623
                quarter = 0
624
            dispo = 'free'
625
            mins = quarter * 15
626

    
627
            if events:
628
                event = events[0]
629

    
630
                if event.start_datetime <= start_datetime and event.end_datetime >= end_datetime:
631
                    dispo = 'busy'
632
            disponibility[start_datetime.hour][quarter].append((mins, {'id': ressource_id, 'dispo': dispo}))
633
            quarter += 1
634
            start_datetime += datetime.timedelta(minutes=15)
635
            end_datetime += datetime.timedelta(minutes=15)
636
        context['disponibility'] = disponibility
637
        return context
638

    
639

    
640
    def get_worker_context_data(self, worker_id, context):
641
        worker = Worker.objects.get(pk=worker_id)
642

    
643
        time_tables_worker = TimeTable.objects.select_related('worker'). \
644
                filter(services=self.service, worker=worker). \
645
                for_today(self.date). \
646
                order_by('start_date')
647
        holidays_worker = Holiday.objects.for_worker(worker). \
648
                for_period(self.date, self.date). \
649
                order_by('start_date')
650
        events = Event.objects.for_today(self.date) \
651
                .exclude(event_type_id=1) \
652
                .filter(participants=worker) \
653
                .order_by('start_datetime') \
654
                .select_related() \
655
                .prefetch_related('participants', 'exceptions')
656
        eventswithact = EventWithAct.objects.for_today(self.date) \
657
                .filter(participants=worker) \
658
                .order_by('start_datetime') \
659
                .select_related() \
660
                .prefetch_related('participants', 'exceptions',
661
                        'act_set__actvalidationstate_set')
662

    
663
        events = list(events) + list(eventswithact)
664
        events = [ e.today_occurrence(self.date) for e in events ]
665
        time_tables_workers = {worker.id: time_tables_worker}
666
        events_workers = {worker.id: events}
667
        holidays_workers = {worker.id: holidays_worker}
668

    
669
        context['initials'] = worker.initials
670
        context['disponibility'] = Event.objects.daily_disponibilities(self.date,
671
                events_workers, [worker], time_tables_workers, holidays_workers)
672
        return context
673

    
674
    def get_context_data(self, ressource_type, ressource_id, **kwargs):
675
        context = super(AjaxDisponibilityColumnView, self).get_context_data(**kwargs)
676
        if ressource_type in ('worker', 'ressource',):
677
            context['ressource_type'] = ressource_type
678
            context['ressource_id'] = ressource_id
679
            getattr(self, 'get_%s_context_data' % ressource_type)(ressource_id, context)
680
        return context
681

    
682
class PeriodicEventsView(cbv.ListView):
683
    model = EventWithAct
684
    template_name = 'agenda/periodic-events.html'
685
    cookies_to_clear = [('agenda-tabs', ), ('active-agenda', ), ('last-ressource', )]
686

    
687
    def dispatch(self, request, *args, **kwargs):
688
        if 'worker_id' in kwargs:
689
            self.worker = get_object_or_404(Worker, id=kwargs['worker_id'])
690
        else:
691
            self.worker = None
692
        return super(PeriodicEventsView, self).dispatch(request, *args, **kwargs)
693

    
694
    def get_form(self):
695
        kwargs = {
696
                'initial': {
697
                    'start_date': self.date,
698
                }
699
        }
700
        if self.request.GET:
701
            kwargs['data'] = self.request.GET
702
        self.form = PeriodicEventsSearchForm(prefix='periodic-events-search-form', **kwargs)
703
        return self.form
704

    
705
    def get_queryset(self):
706
        qs1 = Event.objects.exclude(event_type_id=1)
707
        qs2 = EventWithAct.objects.all()
708
        form = self.get_form()
709
        if not self.request.GET:
710
            return ()
711
        qs1 = self.filter_queryset(form, qs1)
712
        qs2 = self.filter_queryset(form, qs2)
713
        if form.is_valid():
714
            patient = form.cleaned_data.get('patient')
715
            if patient is not None:
716
                qs1 = qs1.none()
717
                qs2 = qs2.filter(patient=patient)
718
            worker = form.cleaned_data.get('worker')
719
            if worker is not None:
720
                qs1 = qs1.filter(participants=worker)
721
                qs2 = qs2.filter(participants=worker)
722
        return sorted(chain(qs1, qs2),
723
                key=lambda x: (x.start_datetime, x.recurrence_end_date or datetime.date(9999,12,31)))
724

    
725
    def filter_queryset(self, form, qs):
726
        if self.worker is not None:
727
            qs = qs.filter(participants=self.worker)
728
        start_date = datetime.date.today()
729
        end_date = start_date+datetime.timedelta(days=90)
730
        if form.is_valid():
731
            if form.cleaned_data.get('start_date'):
732
                start_date = form.cleaned_data['start_date']
733
            if form.cleaned_data.get('end_date'):
734
                end_date = form.cleaned_data['end_date']
735
            else:
736
                end_date = start_date+datetime.timedelta(days=90)
737
            if len(form.cleaned_data.get('event_type')) != 2:
738
                if '0' in form.cleaned_data.get('event_type'):
739
                    qs = qs.filter(event_type_id=1)
740
                else:
741
                    qs = qs.exclude(event_type_id=1)
742
            if form.cleaned_data.get('no_end_date'):
743
                qs = qs.filter(recurrence_end_date__isnull=True)
744
        qs = qs.filter(canceled=False)
745
        qs = qs.filter(services=self.service)
746
        qs = qs.filter(recurrence_periodicity__isnull=False)
747
        qs = qs.filter(start_datetime__lt=end_date)
748
        qs = qs.filter(Q(recurrence_end_date__isnull=True)
749
                | Q(recurrence_end_date__gte=start_date))
750
        qs = qs.order_by('start_datetime', 'recurrence_end_date')
751
        qs = qs.select_related()
752
        qs = qs.prefetch_related('participants', 'services')
753
        return qs
754

    
755
    def get_context_data(self, **kwargs):
756
        ctx = super(PeriodicEventsView, self).get_context_data(**kwargs)
757
        ctx['search_form'] = self.form
758
        ctx['worker'] = self.worker
759
        return ctx
(10-10/10)