-
Notifications
You must be signed in to change notification settings - Fork 2
/
Copy pathdoctor_co.py
5733 lines (4472 loc) · 235 KB
/
doctor_co.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import logging
_logger = logging.getLogger(__name__)
import openerp
import re
import codecs
from openerp.osv import fields, osv
from openerp.tools.translate import _
from openerp.osv.orm import setup_modifiers
from lxml import etree
import time
import pooler
from datetime import date, datetime, timedelta
import openerp.addons.decimal_precision as dp
from pytz import timezone
import pytz
from dateutil import parser
from dateutil import rrule
from dateutil.relativedelta import relativedelta
import math
from openerp import SUPERUSER_ID, tools
import sale
import netsvc
import doctor
import thread
from thread import start_new_thread
import threading
class doctor_patient_co(osv.osv):
_name = "doctor.patient"
_inherit = 'doctor.patient'
_description = "Information about the patient"
_rec_name = 'nombre'
SELECTION_LIST = [
('1', u'Años'),
('2', 'Meses'),
('3', 'Dias'),
]
#Semestre actual
semestre = [
(1, 'UNO'),
(2, 'DOS'),
(3, 'TRES'),
(4, 'CUATRO'),
(5, 'CINCO'),
(6, 'SEIS'),
(7, 'SIETE'),
(8, 'OCHO'),
(9, 'NUEVE'),
(10, 'DIEZ'),
(11, 'ONCE'),
(12, 'DOCE'),
]
#Niveles de estudio
nivel_estudio = [
('5', 'JARDIN'),
('6', 'PRIMARIA'),
('7', 'SECUNDARIA'),
('1', 'PREGRADO'),
('2', 'POSGRADO'),
('3', u'MAESTRÍAS'),
('4', u'ESPECIALIZACIÓN'),
]
#Lateralidad
lateralidad = [
('1', 'DIESTRO'),
('2', 'ZURDO'),
('3', 'AMBIDIESTRO'),
]
#Discapacidad
cognitivas = [
('1', 'Autismo'),
('2', u'Síndrome de Down'),
('3', u'Síndrome de Asperger'),
('4', 'Retraso Mental'),
('5', 'Otros'),
]
#Discapacidad
fisicas = [
('1', u'lesión medular'),
('2', 'Esclerosis Multiple'),
('3', 'Paralisis Cerebral'),
('4', 'Mal de Parkinson'),
('5', 'Espina Bifida'),
('6', 'Acondroplasia'),
('7', 'Albinismo'),
('8', 'Otros'),
]
#Discapacidad
sensorial = [
('1', 'Discapacidad Visual'),
('2', 'Discapacidad Auditiva'),
('3', 'Otras'),
]
#Discapacidad
problemasAprendizaje = [
('1', 'Dislexia'),
('2', 'Disgrafia'),
('3', 'Discalculia'),
('4', 'Otra'),
]
#Poblacion especial
etnia = [
('1', u'Indígena'),
('2', 'Rom'),
('3', 'Afrodescendientes'),
('4', 'Raizal'),
('5', 'Palenqueros'),
('6', 'Otros'),
]
#Discapacidad
data_stratum = [
('1', '1'),
('2', '2'),
('3', '3'),
('4', '4'),
('5', '5'),
('6', '6')
]
def _get_edad(self, cr, uid, ids, field_name, arg, context=None):
res = {}
for datos in self.browse(cr, uid, ids):
edad = self.pool.get('doctor.attentions').calcular_edad(datos.birth_date)
res[datos.id] = edad
return res
def _get_unidad_edad(self, cr, uid, ids, field_name, arg, context=None):
res = {}
for datos in self.browse(cr, uid, ids):
unidad_edad = self.pool.get('doctor.attentions').calcular_age_unit(datos.birth_date)
res[datos.id] = unidad_edad
return res
def _get_nc(self, cr, uid, ids, field_name, arg, context=None):
res = {}
modelo_atencion = self.pool.get('doctor.attentions')
nc = ""
for datos in self.browse(cr,uid,ids):
doctor_id = self.pool.get('doctor.professional').search(cr,uid,[('user_id','=',uid)],context=context)
notas_ids =modelo_atencion.search(cr, uid, [('patient_id', '=', datos.id),
('professional_id', 'in', doctor_id),
('notas_confidenciales', '!=', None)], context=context)
if notas_ids:
for notas in modelo_atencion.browse(cr, uid, notas_ids, context=context):
nc += notas.notas_confidenciales + "\n"
res[datos.id] = nc
return res
_columns = {
'city_id' : fields.many2one('res.country.state.city', 'Ciudad/Localidad', domain="[('state_id','=',state_id)]", required=True),
'edad_calculada' : fields.function(_get_edad, type="integer", store= True,
readonly=True, method=True, string='Edad Actual',),
'email' : fields.char('Email'),
'estadocivil_id': fields.many2one('doctor.patient.estadocivil' , 'Estado Civil' , required=False),
'es_profesionalsalud': fields.boolean('Es profesional de la salud?', help="Marcar cuando el paciente a crear ya existe como profesional de la salud."),
#'lugar_nacimiento_id' : fields.many2one('res.country.state.city', 'lugar nacimiento', required=False ),
'movil' :fields.char(u'Móvil', size=12),
'nc_paciente': fields.function(_get_nc, type="text", store= False,
readonly=True, method=True),
'nombre': fields.char('Nombre', size=70),
'nombre_acompaniante': fields.char('Nombre', size=70),
'nombre_responsable': fields.char('Nombre', size=70),
'nombre_madre':fields.char('Madre', size=70),
'telefono_madre':fields.char(u'Teléfono', size=12),
'direccion_madre':fields.char(u'Dirección', size=70),
'nombre_padre':fields.char('Padre', size=70),
'telefono_padre':fields.char(u'Teléfono', size=12),
'direccion_padre':fields.char(u'Dirección', size=70),
'completar_datos_acom':fields.boolean('Desea completar los datos de los padres:'),
'notas_paciente': fields.text('Notas'),
'ocupacion_id' : fields.many2one('doctor.patient.ocupacion' , u'Profesión' , required=False),
'ocupacion_madre' : fields.many2one('doctor.patient.ocupacion' , u'Ocupación Madre' , required=False),
'ocupacion_padre' : fields.many2one('doctor.patient.ocupacion' , u'Ocupación Padre' , required=False),
'parentesco_id': fields.many2one('doctor.patient.parentesco' , 'Parentesco' , required=False),
'parentesco_acompaniante_id': fields.many2one('doctor.patient.parentesco' , 'Parentesco' , required=False),
'ref' : fields.char(u'Identificación', required=True, ),
'state_id' : fields.many2one('res.country.state', 'Departamento/Provincia', domain="[('country_id','=',country_id)]", required=True),
'country_id':fields.many2one('res.country', u'País/Nación', required=True),
'street' : fields.char(u'Dirección', required=False),
'tdoc': fields.selection((('11','Registro civil'), ('12','Tarjeta de identidad'),
('13',u'Cédula de ciudadanía'), ('21',u'Cédula de extranjería'), ('41','Pasaporte'),
('AS',u'Adulto sin identificación'), ('MS',u'Menor sin identificación')),
'Tipo de Documento', required=True),
'telefono' : fields.char(u'Teléfono', size=12),
'telefono_acompaniante' : fields.char(u'Teléfono', size=12),
'telefono_responsable' : fields.char(u'Teléfono', size=12),
'tipo_usuario': fields.many2one('doctor.tipousuario.regimen', 'Tipo usuario'),
'unidad_edad_calculada': fields.function(_get_unidad_edad, type="selection", method=True,
selection= SELECTION_LIST, string='Unidad de la edad',readonly=True, store=True),
'ver_nc': fields.boolean('Ver Nc', store=False),
'zona': fields.selection ((('U','Urbana'), ('R','Rural')), 'Zona de residencia', required=True),
'nro_afiliacion': fields.char(u'Nº de Afiliación'),
'poliza_medicina_prepagada': fields.boolean(u'Tiene Póliza de medicina prepagada'),
'insurer_prepagada_id': fields.many2one('doctor.insurer', "Aseguradora", required=False, domain="[('tipousuario_id.name','=', 'Otro')]"),
'plan_prepagada_id' : fields.many2one('doctor.insurer.plan', 'Plan', domain="[('insurer_id','=',insurer_prepagada_id)]"),
'numero_poliza_afiliacion': fields.char(u'Póliza- # Afiliación'),
'eps_predeterminada': fields.boolean('Predeterminada'),
'prepagada_predeterminada': fields.boolean('Predeterminada'),
'particular_predeterminada': fields.boolean('Predeterminar Particular'),
'semestre_actual':fields.selection(semestre, 'Semestre Actual'),
'filter_ocupacion': fields.char(u'Filtro ocupación', size=5),
'neighborhood_id':fields.many2one('res.country.state.city.neighborhood', 'Barrio', required=False, domain="[('country_id','=',country_id),('state_id','=',state_id), ('city_id','=',city_id)]"),
'description_others': fields.char(u'Descripción', size=32),
'dependencia_empleado_id': fields.many2one('doctor.dependencia', 'Dependencia'),
'nivel_educativo':fields.selection(nivel_estudio, 'Nivel de Estudio'),
'programa_id':fields.many2one('doctor.programa_academico', 'Programa Academico', required=False, domain="[('nivel_estudio','=', (nivel_educativo))]"),
'lateralidad_id':fields.selection(lateralidad, 'Lateralidad'),
#campos agregados para pais y estado de nacimiento
'nacimiento_city_id' : fields.many2one('res.country.state.city', 'Ciudad/Localidad', required=False ,),
'nacimiento_country_id':fields.many2one('res.country', u'País/Nación'),
'seleccion_discapacidad': fields.boolean('Discapacidad'),
'discapacidad_cognitiva':fields.selection(cognitivas, u'Cognitivas'),
'discapacidad_fisica':fields.selection(fisicas, u'Físicas'),
'discapacidad_sensorial':fields.selection(sensorial, u'Sensorial'),
'discapacidad_aprendizaje':fields.selection(problemasAprendizaje, u'Problemas de Aprendizaje'),
'seleccion_poblacion': fields.boolean(u'Población Especial'),
'Poblacion_espacial':fields.selection(etnia, u'Etnia'),
'desplazado': fields.char(u'Desplazado'),
'desmovilizado': fields.char(u'Desmovilizado'),
'victima_conflicto': fields.char(u'Victima del Conflicto'),
'localidad_otros_paises_id':fields.many2one('doctor.localidad.country', u'Localidad/Ciudad', domain="[('country_id','=',nacimiento_country_id)]"),
'codigo_prestador':fields.char('Codigo de prestador', size=12),
'ocupacion_actual': fields.char(u'Ocupación'),
'creencias': fields.char('Creencias'),
'stratum': fields.selection(data_stratum, 'Estrato Socioeconomico')
}
def onchange_ocupacion_id(self, cr, uid, ids, ocupacion_id, context=None):
res={'value':{}}
_logger.info(ocupacion_id)
nombre_ocupacion=''
if ocupacion_id:
for ocupacion in self.pool.get('doctor.patient.ocupacion').browse(cr, uid, [ocupacion_id]):
nombre_ocupacion= ocupacion.name
_logger.info(nombre_ocupacion)
if nombre_ocupacion == 'Estudiante':
res['value']['filter_ocupacion'] = 'estu'
res['value']['ocupacion_actual'] = 'Estudiante'
res['value']['ocupacion_id'] = None
if nombre_ocupacion == 'Docente':
res['value']['filter_ocupacion'] = 'doc'
res['value']['ocupacion_actual'] = 'Docente'
res['value']['ocupacion_id'] = None
if nombre_ocupacion == 'Egresado':
res['value']['filter_ocupacion'] = 'egre'
res['value']['ocupacion_actual'] = 'Egresado'
res['value']['ocupacion_id'] = None
if nombre_ocupacion == 'Empleado':
res['value']['filter_ocupacion'] = 'emp'
res['value']['ocupacion_actual'] = 'Empleado'
res['value']['ocupacion_id'] = None
if nombre_ocupacion == 'Otros':
res['value']['filter_ocupacion'] = 'otro'
if nombre_ocupacion != 'Estudiante' and nombre_ocupacion != 'Docente' and nombre_ocupacion != 'Egresado' and nombre_ocupacion != 'Empleado' and nombre_ocupacion != 'Otros':
res['value']['semestre_actual'] = ''
res['value']['nivel_estudio']= ''
res['value']['programa_academico_id']= ''
res['value']['filter_ocupacion'] = ''
return res
def create(self, cr, uid, vals, context=None):
_logger.info(vals)
res_user_id = self.pool.get('res.users').search(cr, uid, [('id', '=', uid)], context=context)
for compania in self.pool.get('res.users').browse(cr, uid, res_user_id, context=context):
codigo_prestador = compania.company_id.cod_prestadorservicio
if codigo_prestador:
vals['codigo_prestador'] = codigo_prestador
return super(doctor_patient_co,self).create(cr, uid, vals, context=context)
def onchange_completar_datos(self, cr, uid, ids,id_parentesco, completar_datos_acompaniante,nom_acompanante, tel_acompaniante, context=None):
res={'value':{}}
if (completar_datos_acompaniante):
if id_parentesco:
name_parentesco= self.pool.get('doctor.patient.parentesco').browse(cr,uid, id_parentesco, context=context).name
if name_parentesco== 'Padre':
_logger.info(name_parentesco)
res['value']['nombre_padre'] = nom_acompanante
res['value']['telefono_padre']= tel_acompaniante
if name_parentesco == 'Madre':
_logger.info(name_parentesco)
res['value']['nombre_madre'] = nom_acompanante
res['value']['telefono_madre']= tel_acompaniante
if not completar_datos_acompaniante:
res['value']['nombre_padre'] = ''
res['value']['telefono_padre']= ''
res['value']['nombre_madre'] = ''
res['value']['telefono_madre']= ''
return res
def onchange_seleccion(self, cr, uid, ids, poliza_medicina_prepagada, context=None):
res = {'value':{}}
if poliza_medicina_prepagada:
res['value']['prepagada_predeterminada'] = True
res['value']['eps_predeterminada'] = False
res['value']['particular_predeterminada'] = False
return res
def onchange_seleccion_particular(self, cr, uid, ids, particular_predeterminada, context=None):
res = {'value':{}}
if particular_predeterminada:
res['value']['prepagada_predeterminada'] = False
res['value']['eps_predeterminada'] = False
return res
def onchange_seleccion_eps(self, cr, uid, ids, eps_predeterminada, context=None):
res = {'value':{}}
if eps_predeterminada:
res['value']['prepagada_predeterminada'] = False
res['value']['particular_predeterminada'] = False
return res
def onchange_seleccion_prepagada(self, cr, uid, ids, prepagada_predeterminada, context=None):
res = {'value':{}}
if prepagada_predeterminada:
res['value']['eps_predeterminada'] = False
res['value']['particular_predeterminada'] = False
return res
def onchange_calcular_edad(self, cr, uid, ids, fecha_nacimiento, context=None):
res = {'value':{}}
if fecha_nacimiento:
edad = self.pool.get('doctor.attentions').calcular_edad(fecha_nacimiento)
unidad_edad = self.pool.get('doctor.attentions').calcular_age_unit(fecha_nacimiento)
res['value']['edad_calculada'] = edad
res['value']['unidad_edad_calculada'] = unidad_edad
return res
def onchange_existe(self, cr, uid, ids, ref, context=None):
res = {'value':{'lastname' : '', 'surnanme' : '', 'firstname' : '', 'middlename' : '', 'tdoc' : '', 'email' : '', 'phone' : '', 'mobile' : '', 'state_id' : '',
'city_id' : '', 'street' : ''}}
if ref:
registros = self.pool.get('res.partner').search(cr, uid,[])
for record in self.pool.get('res.partner').browse(cr, uid, registros):
if ref == record.ref and record.tdoc!='31' and record.tdoc!='43' : #comparando si la identificacion digitada es igual a la de un paciente existente res['value']['lastname'] = record.lastname.upper()
#si el numero de documento coincide y no es nit o número de Dian
if record.es_paciente:
res['value']['lastname'] = record.lastname.upper()
if record.surname:
res['value']['surname'] = record.surname.upper()
if record.middlename:
res['value']['middlename'] = record.middlename.upper()
res['value']['firstname'] = record.firtsname.upper()
res['value']['tdoc'] = record.tdoc
res['value']['email'] = record.email
res['value']['telefono'] = record.phone
res['value']['movil'] = record.mobile
res['value']['state_id'] =record.state_id.id
res['value']['city_id'] =record.city_id.id
res['value']['street'] =record.street
res['value']['photo']= record.image
res['value']['es_profesionalsalud'] = True
return res
else:
raise osv.except_osv(_('Error!'),
_('El paciente %s %s ya fue registrado.') % (record.lastname, record.firtsname))
return True
def onchange_patient_data(self, cr, uid, ids, patient, photo, ref, dpto, mun, direccion, context=None):
values = {}
if not patient:
return values
patient_data = self.pool.get('res.partner').browse(cr, uid, patient, context=context)
patient_img = patient_data.image_medium
patient_ref = patient_data.ref
patient_dpto = patient_data.state_id.id
patient_mun = patient_data.city_id.id
patient_direccion = patient_data.street
values.update({
'photo' : patient_img,
'ref' : patient_ref,
'dpto' : patient_dpto,
'mun' : patient_mun,
'direccion' : patient_direccion,
})
return {'value' : values}
def write(self, cr, uid, ids, vals, context=None):
vals['ver_nc'] = False
patient_data = self.browse(cr,uid,ids)[0]
partner = patient_data.patient.id
firstname = patient_data.patient.firtsname
middlename = patient_data.patient.middlename
lastname = patient_data.patient.lastname
surname = patient_data.patient.surname
if 'ref' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'ref': vals['ref']})
if 'tdoc' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'tdoc': vals['tdoc']})
if 'email' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'email': vals['email']})
if 'telefono' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'phone': vals['telefono']})
if 'movil' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'mobile': vals['movil']})
if 'firstname' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'firtsname': vals['firstname'],'name': surname+' '+lastname+' '+middlename+' '+vals['firstname']})
if 'middlename' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'middlename': vals['middlename'],'name': surname+' '+lastname+' '+vals['middlename']+' '+firstname})
if 'lastname' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'lastname': vals['lastname'],'name': surname+' '+vals['lastname']+' '+middlename+' '+firstname})
if 'surname' in vals:
partner_data = self.pool.get('res.partner').write(cr, uid, partner, {'surname': vals['surname'],'name': vals['surname']+' '+lastname+' '+middlename+' '+firstname})
return super(doctor_patient_co,self).write(cr, uid, ids, vals, context)
_defaults = {
'country_id' : lambda self, cr, uid, context: self.pool.get('res.country').browse(cr, uid, self.pool.get('res.country').search(cr, uid, [('code','=','CO')]))[0].id,
'state_id' : lambda self, cr, uid, context: self.pool.get('res.country.state').browse(cr, uid, self.pool.get('res.country.state').search(cr, uid, [('code','=','11')]))[0].id,
'city_id' : lambda self, cr, uid, context: self.pool.get('res.country.state.city').browse(cr, uid, self.pool.get('res.country.state.city').search(cr, uid, [('code','=','1')]))[0].id,
'zona' : 'U',
'eps_predeterminada': True,
'nacimiento_country_id': lambda self, cr, uid, context: self.pool.get('doctor.doctor')._model_default_get(cr, uid, 'res.country', [('name', '=', 'Colombia')]),
}
# Función para evitar número de documento duplicado
def _check_unique_ident(self, cr, uid, ids, context=None):
for record in self.browse(cr, uid, ids):
ref_ids = self.search(cr, uid, [('ref', '=', record.ref), ('id', '<>', record.id)])
if ref_ids:
return False
return True
# Función para validar Email
def _check_email(self, cr, uid, ids, context=None):
for record in self.browse(cr, uid, ids):
if record.email:
email= record.email
if (email.find("@") == -1) :
return False
elif (email.find(".") == -1):
return False
return True
# Función para validar que solo se seleccione una aseguradora como predeterminada
def _check_seleccion(self, cr, uid, ids, context=None):
for record in self.browse(cr, uid, ids):
if record.prepagada_predeterminada and record.eps_predeterminada:
return False
return True
_constraints = [(_check_unique_ident, u'¡Error! Número de intentificación ya existe en el sistema', ['ref']),
(_check_email, u'El formato es inválido.', ['email']),
(_check_seleccion, u'Aviso importante!, Solamente puede tener una Aseguradora como predeterminada', ['prepagada_predeterminada', 'eps_predeterminada'])
]
doctor_patient_co()
class doctor_dependencia(osv.osv):
_name= 'doctor.dependencia'
_rec_name='name'
_order= 'name'
_columns = {
'code':fields.char(u'Código', required=True),
'name':fields.char(u'Programa Académico', required=True),
}
doctor_dependencia()
#Programas academicos
class doctor_programa_academico(osv.osv):
#Niveles de estudio
nivel = [
('1', 'PREGRADO'),
('2', 'POSGRADO'),
('3', u'MAESTRÍAS'),
('4', u'ESPECIALIZACIÓN'),
]
_name= 'doctor.programa_academico'
_rec_name='name'
_columns = {
'code':fields.char(u'Código', required=True),
'name':fields.char(u'Programa Académico', required=True),
'nivel_estudio':fields.selection(nivel, 'Nivel de Estudios', required=True),
}
_sql_constraints = [('programa_academico_code_constraint', 'unique(code)', u'Este código de programa académico ya existe en la base de datos.'),
('programa_academico_name_constraint', 'unique(name)', u'Este nombre de programa académico ya existe en la base de datos.') ]
def create(self, cr, uid, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_create', "crear", u"un Programa Académico")
res = super(doctor_programa_academico,self).create(cr, uid, vals, context)
return res
def write(self, cr, uid, ids, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_edit', "editar", u"un Programa Académico")
res= super(doctor_programa_academico,self).write(cr, uid, ids, vals, context)
return res
doctor_programa_academico()
class doctor_patient_co_estadocivil(osv.Model):
_name = 'doctor.patient.estadocivil'
_columns = {
'codigo' : fields.char('Codigo Estado Civil' ,size = 2 ,required = True ),
'name' : fields.char('Descripcion',required = False )
}
_sql_constraints = [('ec_constraint', 'unique(codigo)', 'Estado civil ya existe en la base de datos.')]
def create(self, cr, uid, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_create', "crear", "un Estado Civil")
res = super(doctor_patient_co_estadocivil,self).create(cr, uid, vals, context)
return res
def write(self, cr, uid, ids, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_edit', "editar", "un Estado Civil")
res= super(doctor_patient_co_estadocivil,self).write(cr, uid, ids, vals, context)
return res
doctor_patient_co_estadocivil()
class doctor_patient_co_parentesco(osv.Model):
_name = 'doctor.patient.parentesco'
_columns = {
'codigo' : fields.char('Codigo Parentesco' ,size = 3 ,required = True ),
'name' : fields.char('Descripcion',required = False )
}
_sql_constraints = [('parentesco_constraint', 'unique(codigo)', 'Este parentesco ya existe en la base de datos.')]
def create(self, cr, uid, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_create', "crear", "un Parentesco")
res = super(doctor_patient_co_parentesco,self).create(cr, uid, vals, context)
return res
def write(self, cr, uid, ids, vals, context=None):
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_edit', "editar", "un Parentesco")
res= super(doctor_patient_co_parentesco,self).write(cr, uid, ids, vals, context)
return res
doctor_patient_co_parentesco()
class doctor_patient_co_ocupacion(osv.Model):
_name = 'doctor.patient.ocupacion'
_rec_name='name'
_order= 'name'
_columns = {
'codigo' : fields.char(u'Código Ocupación' ,size = 3 ,required = False ),
'name' : fields.char(u'Descripción',required = False )
}
_sql_constraints = [(u'ocupacion_constraint', 'unique(name)', u'Esta ocupación ya existe en la base de datos.')]
def create(self, cr, uid, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_create', "crear", u"una Profesión")
res = super(doctor_patient_co_ocupacion,self).create(cr, uid, vals, context)
return res
def write(self, cr, uid, ids, vals, context=None):
if self.pool.get('doctor.doctor').modulo_instalado(cr, uid, 'l10n_co_doctor', context=context) == True:
self.pool.get('doctor.doctor').doctor_validate_group(cr, uid, 'group_l10n_co_doctor_edit', "editar", u"una Profesión")
res= super(doctor_patient_co_ocupacion,self).write(cr, uid, ids, vals, context)
return res
doctor_patient_co_ocupacion()
class doctor_appointment_co(osv.osv):
_name = "doctor.appointment"
_inherit = "doctor.appointment"
ambito = [
(1, 'Ambulatorio'),
(2, 'En Urgencias'),
(3, 'Hospitalario'),
]
finalidad = [
(1, u'Diagnóstico'),
(2, u'Protección Especifica'),
(3, u'Terapéutica'),
(4, u'Detección Temprana de enf. General'),
(5, u'Detección Temprana de enf. profesional'),
]
_columns = {
'create_date': fields.datetime(u'Fecha Creación'),
'contract_id': fields.many2one('doctor.contract.insurer', 'Contrato',required=False),
'insurer_id': fields.many2one('doctor.insurer', "insurer", required=False,
states={'invoiced': [('readonly', True)]},),
'plan_id' : fields.many2one('doctor.insurer.plan', 'Plan'),
'ref' : fields.related ('patient_id', 'ref', type="char", relation="doctor.patient", string=u'Nº de identificación', required=True, readonly= True),
'phone' : fields.related ('patient_id', 'telefono', type="char", relation="doctor.patient", string=u'Teléfono', required=False, readonly= True),
'tipo_usuario_id' : fields.many2one('doctor.tipousuario.regimen', 'Tipo usuario', required=False, states={'invoiced':[('readonly',True)]}),
'tipo_usuario_ocultar' : fields.char('tipo usuario ocultar', required=False, readonly=False, store=False),
'realiza_procedimiento': fields.boolean(u'Se realizará procedimiento? '),
'ambito': fields.selection(ambito, u'Ámbito'),
'finalidad': fields.selection(finalidad, 'Finalidad'),
'nro_afilicion_poliza': fields.char(u'# Afiliación - Póliza'),
'repetir_cita': fields.boolean('Repetir Cita'),
'repetir_cita_fecha_inicio':fields.datetime('Asignar Cita Desde'),
'repetir_cita_fecha_fin':fields.datetime('Asignar Cita Hasta'),
'lunes' : fields.boolean('Lunes'),
'martes' : fields.boolean('Martes'),
'miercoles' : fields.boolean('Miercoles'),
'jueves' : fields.boolean('Jueves'),
'viernes' : fields.boolean('Viernes'),
'sabado' : fields.boolean('sabado'),
'domingo' : fields.boolean('Domingo'),
'todos_los_dias_semana': fields.boolean('Marcar Todo'),
'enero' : fields.boolean('Enero'),
'febrero' : fields.boolean('Febrero'),
'marzo' : fields.boolean('Marzo'),
'abril' : fields.boolean('Abril'),
'mayo' : fields.boolean('Mayo'),
'junio' : fields.boolean('Junio'),
'julio' : fields.boolean('Julio'),
'agosto' : fields.boolean('Agosto'),
'septiembre' : fields.boolean('Septiembre'),
'octubre' : fields.boolean('Octubre'),
'noviembre' : fields.boolean('Noviembre'),
'diciembre' : fields.boolean('Diciembre'),
'todos_los_meses': fields.boolean('Marcar Todo'),
'appointmet_note_ids':fields.one2many('doctor.patient_note', 'appointmet_note_id', 'Notas Paciente'),
'notas_paciente_cita':fields.text('Notas'),
'cita_eliminada':fields.boolean('cita Eliminada'),
}
_defaults = {
"ambito": 1,
"finalidad": 1,
'cita_eliminada': False,
}
def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
res = super(doctor_appointment_co, self).fields_view_get(cr, uid, view_id=view_id, view_type=view_type, context=context, toolbar=toolbar, submenu=submenu)
doc = etree.XML(res['arch'])
for node in doc.xpath("//filter[@name='citas_profesional']"):
doctor_id = self.pool.get('doctor.professional').search(cr,uid,[('user_id','=',uid)],context=context)
_logger.info(doctor_id)
if doctor_id:
dominio=[('professional_id','=',doctor_id[0]),]
node.set('domain', repr(dominio))
res['arch'] = etree.tostring(doc)
return res
#Funcion para seleccionar y no seleccionar los dias de la semana y meses. Haciendo uso de la funcion que se encuentra en doctor.schedule
def onchange_seleccion(self, cr, uid, ids, marcar_todo, seleccion, context=None):
res= self.pool.get('doctor.schedule').onchange_seleccionar_todo(cr, uid, ids, marcar_todo, seleccion, context=context)
return res
#Funcion para validar cuando sea seccionado el check de repetir cita, que se encuentre seleccionado el tipo de cita
def onchange_cargar_hora(self, cr, uid, ids, type_id, time_begin, time_end, context=None):
res={'value':{}}
#Si se seleccionado el tipo de la cita se asignan los mismo valores que contengan el time_begin y time_end
#En los campos de fecha de repetir cita
if type_id:
res['value']['repetir_cita_fecha_inicio']=time_begin
res['value']['repetir_cita_fecha_fin']=time_end
return res
else:
res['value']['repetir_cita']=False
raise osv.except_osv(_('Aviso Importante!'),_('Debe Seleccionar el tipo de la cita'))
return res
def create(self, cr, uid, vals, context=None):
schedule_id_appoitment=vals['schedule_id']
appointment_date_begin= vals['time_begin']
appointment_date_end= vals['time_end']
type_id_appointment= vals['type_id']
professional_appointment_id= vals['professional_id']
patient_id_appointment=vals['patient_id']
repetir_cita=vals['repetir_cita']
fecha_inicio=None
fecha_fin=None
try:
consultorio_id_appointment= vals['consultorio_id']
except Exception, e:
consultorio_id_appointment= None
estado=''
result_estado=False
res={}
res_editar={}
validar_espacio=False
validar_espacio_multipaciente=False
espacio_cita_multipaciente=False
id_type = self.pool.get('doctor.appointment.type').search(cr, uid, [('id', '=', type_id_appointment)])
if consultorio_id_appointment:
consultorio_id= self.pool.get('doctor.room').browse(cr, uid, consultorio_id_appointment, context=context)
consultorio_multipaciente= consultorio_id.multi_paciente
consultorio_numero_pacientes=consultorio_id.numero_pacientes
else:
consultorio_multipaciente = None
for duration_appointment_id in self.pool.get('doctor.appointment.type').browse(cr, uid, id_type, context=context):
duration_appointment=duration_appointment_id.duration
tiempo_espacios=0
for record in self.pool.get('doctor.time_space').browse(cr, uid, [1], context=context):
tiempo_espacios= int(record.tiempo_espacio)
if (tiempo_espacios * (duration_appointment/tiempo_espacios)) != duration_appointment:
raise osv.except_osv(_('Lo Sentimos!'),
_('Para poder crear la cita, el tiempo de la cita debe ser como minimo %s minutos. O el tiempo del espacio debe ser multiplo del tiempo de la cita (%s, %s, %s...). \n\n Para cambiar el tiempo de los espacios se debe dirigir a: \n -> Configuración Espacios \n -> Modificar el tiempo del espacio')% (tiempo_espacios, tiempo_espacios, (tiempo_espacios*2), (tiempo_espacios*3)) )
fecha_hora = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
fecha_hora_act = datetime.strptime(fecha_hora, "%Y-%m-%d %H:%M:%S")
fecha_hora_actual = fecha_hora_act.replace(minute=00)
date_beging_appo = datetime.strptime(appointment_date_begin, "%Y-%m-%d %H:%M:%S")
date_beging_appointment = date_beging_appo.replace(minute=00)
#Validamos si la hora actual es menor que la date_beging_appointment
#De tal manera que no se pueda asignar una cita
data_appointment={}
dia_semana = ['lunes', 'martes', 'miercoles','jueves', 'viernes','sabado','domingo',]
meses_anio = ['enero', 'febrero', 'marzo', 'abril','mayo', 'junio','julio', 'agosto',
'septiembre', 'octubre', 'noviembre', 'diciembre',]
dias_usuario = {
'lunes': vals['lunes'], 'martes': vals['martes'], 'miercoles': vals['miercoles'],
'jueves': vals['jueves'], 'viernes': vals['viernes'], 'sabado': vals['sabado'],
'domingo': vals['domingo'],
}
meses_usuario = {
'enero' : vals['enero'], 'febrero': vals['febrero'], 'marzo': vals['marzo'],'abril': vals['abril'],
'mayo': vals['mayo'], 'junio': vals['junio'], 'julio': vals['julio'], 'agosto': vals['agosto'],
'septiembre': vals['septiembre'], 'octubre': vals['octubre'], 'noviembre': vals['noviembre'], 'diciembre': vals['diciembre'],
}
if schedule_id_appoitment:
if patient_id_appointment:
validar_fecha_inicio= str(date_beging_appointment)[15:16]
#Validamos los minutos de la citas para tener un control sobre ellas
if (validar_fecha_inicio == '0') or (validar_fecha_inicio == '5'):
#Validamos si la agenda es multiconsultorio no mas
if consultorio_multipaciente and repetir_cita==False:
_logger.info('Entro al multipaciente solito')
res['estado_cita_espacio']= 'Asignado'
res['fecha_inicio']= appointment_date_begin
res['fecha_fin']= appointment_date_end
res['patient_id']=patient_id_appointment
res['schedule_espacio_id']=schedule_id_appoitment
self.pool.get('doctor.espacios').create(cr, uid, res, context=context)
#Validamos si la agenda es multiconsultorio y se ha seleccionado la opcion repetir cita
if consultorio_multipaciente and repetir_cita:
_logger.info('Es multipcaciente y es cita repetida')
cita_id= self.multiconsultorio_repetir_cita(cr, uid, vals, professional_appointment_id, schedule_id_appoitment, type_id_appointment, res_editar, res, patient_id_appointment, dia_semana, meses_usuario, dias_usuario, meses_anio, data_appointment)
#Si seleccionan repetir cita y no es multipaciente
if repetir_cita and not consultorio_multipaciente:
_logger.info('Es una cita repetida normal')
cita_id= self.consultorio_repetir_cita(cr, uid, vals, professional_appointment_id, schedule_id_appoitment, type_id_appointment, res_editar, res, patient_id_appointment, dia_semana, meses_usuario, dias_usuario, meses_anio, data_appointment)
#Si no es una cita repetitiva ni multipaciente. Una cita normal
if not repetir_cita and not consultorio_multipaciente:
_logger.info('Entro en la cita normal')
#Buscamos en los espacios cuales de estos cumplen la condicion
id_sechedule_espacio=self.pool.get('doctor.espacios').search(cr, uid, [('schedule_espacio_id', '=', schedule_id_appoitment), ('fecha_inicio', '>=', appointment_date_begin), ('fecha_fin', '<=', appointment_date_end)], context=context)
#Recorremos los ids para saber el estado de dichos espacios
for espacios in self.pool.get('doctor.espacios').browse(cr, uid, id_sechedule_espacio, context=context):
fecha= espacios.fecha_inicio
fecha_otra= espacios.fecha_fin
estado= espacios.estado_cita_espacio
#Si el estado es Asignado la variable result_estado nos devolvera True
if estado=='Asignado':
result_estado= True
#Validamos si el estado del espacio no esta Asignado
if result_estado != True:
if id_sechedule_espacio:
#Modificaremos dicho espacio, ya que no se puede eliminar el espacio aun
#Por talrazon pondremos valores vacios o nulos
res_editar['estado_cita_espacio']= ''
res_editar['fecha_inicio']= None
res_editar['fecha_fin']= None
res_editar['patient_id']=''
res_editar['schedule_espacio_id']=''
#Ejecutamos la modificacion del espacio
self.pool.get('doctor.espacios').write(cr, uid, id_sechedule_espacio, res_editar, context)
res['estado_cita_espacio']= 'Asignado'
res['fecha_inicio']= appointment_date_begin
res['fecha_fin']= appointment_date_end
res['patient_id']=patient_id_appointment
res['schedule_espacio_id']=schedule_id_appoitment
self.pool.get('doctor.espacios').write(cr, uid, id_sechedule_espacio[0], res, context)
id_espacios= self.pool.get('doctor.espacios').search(cr, uid, [('estado_cita_espacio', '=', '')])
self.pool.get('doctor.espacios').unlink(cr, uid, id_espacios, context)
else:
raise osv.except_osv(_('Aviso importante!'),_('En este horario ya se ha asignado una cita.\n\n Por favor escoja otro horario para la cita.'))
else:
raise osv.except_osv(_('Aviso importante!'),_('No se puede asignar la cita en esta hora.\n Sólo se puede en intervalos de cinco minutos'))
if not repetir_cita:
cita_id= super(doctor_appointment_co,self).create(cr, uid, vals, context=context)
return cita_id
def multiconsultorio_repetir_cita(self, cr, uid, vals, professional_appointment_id, schedule_id_appoitment, type_id_appointment, res_editar, res, patient_id_appointment, dia_semana, meses_usuario, dias_usuario, meses_anio, data_appointment, context=None):
#Son las fechas en las cuales se capturan el rango de las citas repetidas
fecha_inicio = datetime.strptime(vals['repetir_cita_fecha_inicio'], "%Y-%m-%d %H:%M:%S")
fecha_fin = datetime.strptime(vals['repetir_cita_fecha_fin'], "%Y-%m-%d %H:%M:%S")
fecha_sin_hora = str(fecha_inicio)[0:10]
fecha_sin_hora = datetime.strptime(fecha_sin_hora, "%Y-%m-%d")
#Se calcula duracion en dias
if not ':' in str(fecha_fin - fecha_inicio)[0:3].strip():
if not str(fecha_fin - fecha_inicio)[0:3].strip().isdigit():
duracion_dias = int(str(fecha_fin - fecha_inicio)[0:1].strip())
else:
duracion_dias = int(str(fecha_fin - fecha_inicio)[0:3].strip())
else:
raise osv.except_osv(_('Lo Sentimos!'),_('Las fechas no coinciden para ser una cita repetida ya que son iguales'))
if not True in meses_usuario.values():
raise osv.except_osv(_('Lo Sentimos!'),_('Debe Seleccionar los meses que se repite la cita'))
if not True in dias_usuario.values():
raise osv.except_osv(_('Lo Sentimos!'),_('Debe Seleccionar los dias que se repite la cita'))
#Estas variables se utilizan para poder calcular cuales agendas repetidas hay creadas en este rango de fechas
#Se hace una diferencia de 5 horas ya que la hora que guarda el openerp es + 5
cita_inicio= datetime.strptime(vals['repetir_cita_fecha_inicio'], "%Y-%m-%d %H:%M:%S")
cita_fin= datetime.strptime(vals['repetir_cita_fecha_fin'], "%Y-%m-%d %H:%M:%S")
cita_fin= cita_fin + timedelta(hours=5)
cita_fin=cita_fin+ timedelta(days=1)
cita_inicio= cita_inicio - timedelta(hours=5)
fecha_inicio_sin_hora = str(cita_inicio)[0:10]
fecha_inicio_sin_hora = datetime.strptime(fecha_inicio_sin_hora, "%Y-%m-%d")
#Hacemos la consulta para saber cuantas agendas repetidas hay
id_sechedule_cita= self.pool.get('doctor.schedule').search(cr, uid, [('professional_id', '=', professional_appointment_id), ('repetir_agenda', '=', True), ('id', '>=', schedule_id_appoitment), ('date_begin', '>=', str(fecha_inicio_sin_hora)),('date_end', '<', str(cita_fin))], context=context)
#Calculamos la duracion de la cita
time_cita= self.pool.get('doctor.appointment.type').search(cr, uid, [('id', '=', type_id_appointment)], context=context)
for duration in self.pool.get('doctor.appointment.type').browse(cr, uid , time_cita, context=context):
duracion_cita_repetida= duration.duration
#Esta variable sentinela se encargara recorrer la lista del id_sechedule_cita
i=0
#Se valida la cantidad de agendas a las cuales se le van asignar dicha cita
#De ser mayor se envia un mensaje de alerta
#if duracion_dias+1 > len(id_sechedule_cita):
# raise osv.except_osv(_('Lo sentimos!'),_('Para poder crear las citas repetitivas. Debes crear primero una agenda. \n Verifica la fecha final de la citas.'))
#_logger.info(len(id_sechedule_cita))
dias_traba=[]
j=0
for fecha_trabajar in self.pool.get('doctor.schedule').browse(cr, uid , id_sechedule_cita, context=context):
dias_a_trabajar=fecha_trabajar.date_begin
fecha_de_trabajo = str(dias_a_trabajar)[0:10]
fecha_de_trabajo = datetime.strptime(fecha_de_trabajo, "%Y-%m-%d")
dias_traba.append(fecha_de_trabajo)
#Se encierra en un while para asignaler un valor diferente al vals['schedule_id']
#En cada iteracion de acuerdo a la lista del id_schedule_cita
while i < len(id_sechedule_cita):
#Se ejecuta este for para la creacion de un registro diferente en cada iteracion
for dias in range(0, duracion_dias+1, 1):
fecha_sin_h = fecha_sin_hora + timedelta(days=dias)
dias_inicia_trabaja = fecha_inicio + timedelta(days=dias)
fecha_validar_trabajo = str(dias_inicia_trabaja)[0:10]
fecha_validar_trabajo = datetime.strptime(fecha_validar_trabajo, "%Y-%m-%d")
if str(dias_traba[j]) == str(fecha_validar_trabajo):
j=j+1
dia=dias_inicia_trabaja.weekday()
mes = int(dias_inicia_trabaja.strftime('%m'))-1
#Se valida si estan los dias y los meses
if (dias_usuario[dia_semana[dia]]) and meses_usuario[meses_anio[mes]]:
#La data_appointment contiene todos los valores de la cita
#Cambian de acuerdo a su iteracion
data_appointment['time_begin'] = dias_inicia_trabaja
data_appointment['time_end'] = dias_inicia_trabaja + timedelta(minutes=duracion_cita_repetida)
data_appointment['type_id'] = vals['type_id']
data_appointment['repetir_cita_fecha_inicio'] = dias_inicia_trabaja
data_appointment['repetir_cita_fecha_fin'] = dias_inicia_trabaja + timedelta(minutes=duracion_cita_repetida)
if 'consultorio_id' in vals:
data_appointment['consultorio_id'] = vals['consultorio_id']
data_appointment['professional_id'] = vals['professional_id']
data_appointment['repetir_cita'] = vals['repetir_cita']
data_appointment['tipo_usuario_id'] = vals['tipo_usuario_id']