1 # -*- encoding: utf-8 -*-
2 import simplejson
, uuid
, datetime
, caldav
, vobject
, uuid
3 from django
.contrib
.auth
.models
import User
4 from django
.db
import models
5 from django
.db
.models
import Q
6 from django
.db
.models
.signals
import pre_delete
7 from timezones
.fields
import TimeZoneField
8 from auf_savoirs_en_partage
.backend_config
import RESOURCES
9 from savoirs
.globals import META
10 from settings
import CALENDRIER_URL
11 from datamaster_modeles
.models
import Thematique
, Pays
, Region
12 from lib
.calendrier
import combine
13 from caldav
.lib
import error
15 class Discipline(models
.Model
):
16 id = models
.IntegerField(primary_key
=True, db_column
='id_discipline')
17 nom
= models
.CharField(max_length
=765, db_column
='nom_discipline')
19 def __unicode__ (self
):
23 db_table
= u
'discipline'
26 class SourceActualite(models
.Model
):
27 nom
= models
.CharField(max_length
=255)
28 url
= models
.CharField(max_length
=255)
30 def __unicode__(self
,):
31 return u
"%s" % self
.nom
33 class ActualiteManager(models
.Manager
):
35 def get_query_set(self
):
36 return ActualiteQuerySet(self
.model
)
38 def search(self
, text
):
39 return self
.get_query_set().search(text
)
41 class ActualiteQuerySet(models
.query
.QuerySet
):
43 def search(self
, text
):
44 return self
.filter(Q(titre__icontains
=text
) |
Q(texte__icontains
=text
))
46 class Actualite(models
.Model
):
47 id = models
.AutoField(primary_key
=True, db_column
='id_actualite')
48 titre
= models
.CharField(max_length
=765, db_column
='titre_actualite')
49 texte
= models
.TextField(db_column
='texte_actualite')
50 url
= models
.CharField(max_length
=765, db_column
='url_actualite')
51 date
= models
.DateField(db_column
='date_actualite')
52 visible
= models
.BooleanField(db_column
='visible_actualite', default
= False)
53 ancienid
= models
.IntegerField(db_column
='ancienId_actualite', blank
= True, null
= True)
54 source
= models
.ForeignKey(SourceActualite
, blank
= True, null
= True)
55 disciplines
= models
.ManyToManyField(Discipline
, blank
=True, related_name
="actualites")
56 regions
= models
.ManyToManyField(Region
, blank
=True, related_name
="actualites", verbose_name
='Régions')
58 objects
= ActualiteManager()
61 db_table
= u
'actualite'
64 def __unicode__ (self
):
65 return "%s" % (self
.titre
)
67 def assigner_disciplines(self
, disciplines
):
68 self
.disciplines
.add(*disciplines
)
70 def assigner_regions(self
, regions
):
71 self
.regions
.add(*regions
)
73 class EvenementManager(models
.Manager
):
75 def get_query_set(self
):
76 return EvenementQuerySet(self
.model
)
78 def search(self
, text
):
79 return self
.get_query_set().search(text
)
81 class EvenementQuerySet(models
.query
.QuerySet
):
83 def search(self
, text
):
86 for word
in text
.split():
87 part
= (Q(titre__icontains
=word
) |
88 Q(mots_cles__icontains
=word
) |
89 Q(discipline__nom__icontains
=word
) |
90 Q(discipline_secondaire__nom__icontains
=word
) |
91 Q(type__icontains
=word
) |
92 Q(lieu__icontains
=word
) |
93 Q(description__icontains
=word
) |
94 Q(contact__icontains
=word
))
99 return qs
.filter(q
) if q
is not None else qs
101 def search_titre(self
, text
):
103 for word
in text
.split():
104 qs
= qs
.filter(titre__icontains
=word
)
107 class Evenement(models
.Model
):
108 TYPE_CHOICES
= ((u
'Colloque', u
'Colloque'),
109 (u
'Conférence', u
'Conférence'),
110 (u
'Appel à contribution', u
'Appel à contribution'),
111 (u
'Journée d\'étude', u
'Journée d\'étude'),
114 uid
= models
.CharField(max_length
= 255, default
= str(uuid
.uuid1()))
115 approuve
= models
.BooleanField(default
= False)
116 titre
= models
.CharField(max_length
=255)
117 discipline
= models
.ForeignKey('Discipline', related_name
= "discipline",
118 blank
= True, null
= True)
119 discipline_secondaire
= models
.ForeignKey('Discipline', related_name
= \
120 "discipline_secondaire",
122 "Discipline secondaire",
123 blank
= True, null
= True)
124 mots_cles
= models
.TextField('Mots-Clés', blank
= True, null
= True)
125 type = models
.CharField(max_length
=255, choices
=TYPE_CHOICES
)
126 fuseau
= TimeZoneField(verbose_name
= 'Fuseau horaire')
127 debut
= models
.DateTimeField(default
= datetime
.datetime
.now
)
128 fin
= models
.DateTimeField(default
= datetime
.datetime
.now
)
129 lieu
= models
.TextField()
130 description
= models
.TextField(blank
= True, null
= True)
132 contact
= models
.TextField(blank
= True, null
= True)
133 url
= models
.CharField(max_length
=255, blank
= True, null
= True)
134 regions
= models
.ManyToManyField(Region
, blank
=True, related_name
="evenements", verbose_name
='Régions')
136 objects
= EvenementManager()
139 ordering
= ['-debut']
141 def __unicode__(self
,):
142 return "[%s] %s" % (self
.uid
, self
.titre
)
145 from django
.core
.exceptions
import ValidationError
146 if self
.debut
> self
.fin
:
147 raise ValidationError('La date de fin ne doit pas être antérieure à la date de début')
149 def save(self
, *args
, **kwargs
):
150 """Sauvegarde l'objet dans django et le synchronise avec caldav s'il a été
154 super(Evenement
, self
).save(*args
, **kwargs
)
156 # methodes de commnunications avec CALDAV
158 """Retourne l'evenement django sous forme d'objet icalendar"""
159 cal
= vobject
.iCalendar()
162 # fournit son propre uid
163 if self
.uid
in [None, ""]:
164 self
.uid
= str(uuid
.uuid1())
166 cal
.vevent
.add('uid').value
= self
.uid
168 cal
.vevent
.add('summary').value
= self
.titre
170 if self
.mots_cles
is None:
173 kw
= self
.mots_cles
.split(",")
176 kw
.append(self
.discipline
.nom
)
177 kw
.append(self
.discipline_secondaire
.nom
)
181 kw
= [x
.strip() for x
in kw
if len(x
.strip()) > 0 and x
is not None]
183 cal
.vevent
.add('x-auf-keywords').value
= k
185 description
= self
.description
187 if len(self
.description
) > 0:
189 description
+= u
"Mots-clés: " + ", ".join(kw
)
191 cal
.vevent
.add('dtstart').value
= combine(self
.debut
, self
.fuseau
)
192 cal
.vevent
.add('dtend').value
= combine(self
.fin
, self
.fuseau
)
193 cal
.vevent
.add('created').value
= combine(datetime
.datetime
.now(), "UTC")
194 cal
.vevent
.add('dtstamp').value
= combine(datetime
.datetime
.now(), "UTC")
195 if len(description
) > 0:
196 cal
.vevent
.add('description').value
= description
197 if len(self
.contact
) > 0:
198 cal
.vevent
.add('contact').value
= self
.contact
199 if len(self
.url
) > 0:
200 cal
.vevent
.add('url').value
= self
.url
201 if len(self
.lieu
) > 0:
202 cal
.vevent
.add('location').value
= self
.lieu
205 def update_vevent(self
,):
206 """Essaie de créer l'évènement sur le serveur ical.
207 En cas de succès, l'évènement local devient donc inactif et approuvé"""
210 event
= self
.as_ical()
211 client
= caldav
.DAVClient(CALENDRIER_URL
)
212 cal
= caldav
.Calendar(client
, url
= CALENDRIER_URL
)
213 e
= caldav
.Event(client
, parent
= cal
, data
= event
.serialize(), id=self
.uid
)
216 self
.approuve
= False
218 def delete_vevent(self
,):
219 """Supprime l'evenement sur le serveur caldav"""
222 event
= self
.as_ical()
223 client
= caldav
.DAVClient(CALENDRIER_URL
)
224 cal
= caldav
.Calendar(client
, url
= CALENDRIER_URL
)
225 e
= cal
.event(self
.uid
)
227 except error
.NotFoundError
:
230 def assigner_regions(self
, regions
):
231 self
.regions
.add(*regions
)
233 def assigner_disciplines(self
, disciplines
):
234 if len(disciplines
) == 1:
236 self
.discipline_secondaire
= disciplines
[0]
238 self
.discipline
= disciplines
[0]
239 elif len(disciplines
) >= 2:
240 self
.discipline
= disciplines
[0]
241 self
.discipline_secondaire
= disciplines
[1]
244 # Surcharge du comportement de suppression
245 # La méthode de connexion par signals est préférable à surcharger la méthode delete()
246 # car dans le cas de la suppression par lots, cell-ci n'est pas invoquée
247 def delete_vevent(sender
, instance
, *args
, **kwargs
):
248 instance
.delete_vevent()
250 pre_delete
.connect(delete_vevent
, sender
= Evenement
)
253 class ListSet(models
.Model
):
254 spec
= models
.CharField(primary_key
= True, max_length
= 255)
255 name
= models
.CharField(max_length
= 255)
256 server
= models
.CharField(max_length
= 255)
257 validated
= models
.BooleanField(default
= True)
259 def __unicode__(self
,):
262 class RecordManager(models
.Manager
):
264 def get_query_set(self
):
265 return RecordQuerySet(self
.model
)
267 def search(self
, text
):
268 return self
.get_query_set().search(text
)
271 return self
.get_query_set().validated()
273 class RecordQuerySet(models
.query
.QuerySet
):
275 def search(self
, text
):
279 # Ne garder que les ressources qui contiennent tous les mots
283 part
= (Q(title__icontains
=word
) |
Q(description__icontains
=word
) |
284 Q(creator__icontains
=word
) |
Q(contributor__icontains
=word
) |
285 Q(subject__icontains
=word
) |
Q(disciplines__nom__icontains
=word
) |
286 Q(regions__nom__icontains
=word
) |
Q(pays__nom__icontains
=word
))
292 qs
= qs
.filter(q
).distinct()
294 # On donne un point pour chaque mot présent dans le titre.
296 score_expr
= ' + '.join(['(title LIKE %s)'] * len(words
))
297 score_params
= ['%' + word
+ '%' for word
in words
]
299 select
={'score': score_expr
},
300 select_params
=score_params
305 def search_auteur(self
, text
):
307 for word
in text
.split():
308 qs
= qs
.filter(Q(creator__icontains
=word
) |
Q(contributor__icontains
=word
))
311 def search_sujet(self
, text
):
313 for word
in text
.split():
314 qs
= qs
.filter(subject__icontains
=word
)
317 def search_titre(self
, text
):
319 for word
in text
.split():
320 qs
= qs
.filter(title__icontains
=word
)
324 """Ne garder que les ressources validées et qui sont soit dans aucun
325 listset ou au moins dans un listset validé."""
326 qs
= self
.filter(validated
=True)
327 qs
= qs
.extra(where
=['''((savoirs_record.id NOT IN (SELECT record_id FROM savoirs_record_listsets)) OR
328 ((SELECT MAX(l.validated) FROM savoirs_listset l
329 INNER JOIN savoirs_record_listsets rl ON rl.listset_id = l.spec
330 WHERE rl.record_id = savoirs_record.id) = TRUE))'''])
333 class Record(models
.Model
):
335 #fonctionnement interne
336 id = models
.AutoField(primary_key
= True)
337 server
= models
.CharField(max_length
= 255)
338 last_update
= models
.CharField(max_length
= 255)
339 last_checksum
= models
.CharField(max_length
= 255)
340 validated
= models
.BooleanField(default
= True)
343 title
= models
.TextField(null
= True, blank
= True)
344 creator
= models
.TextField(null
= True, blank
= True)
345 description
= models
.TextField(null
= True, blank
= True)
346 modified
= models
.CharField(max_length
= 255, null
= True, blank
= True)
347 identifier
= models
.CharField(max_length
= 255, null
= True, blank
= True, unique
= True)
348 uri
= models
.CharField(max_length
= 255, null
= True, blank
= True, unique
= True)
349 source
= models
.TextField(null
= True, blank
= True)
350 contributor
= models
.TextField(null
= True, blank
= True)
351 subject
= models
.TextField(null
= True, blank
= True)
352 publisher
= models
.TextField(null
= True, blank
= True)
353 type = models
.TextField(null
= True, blank
= True)
354 format
= models
.TextField(null
= True, blank
= True)
355 language
= models
.TextField(null
= True, blank
= True)
357 listsets
= models
.ManyToManyField(ListSet
, null
= True, blank
= True)
359 #SEP 2 (aucune données récoltées)
360 alt_title
= models
.TextField(null
= True, blank
= True)
361 abstract
= models
.TextField(null
= True, blank
= True)
362 creation
= models
.CharField(max_length
= 255, null
= True, blank
= True)
363 issued
= models
.CharField(max_length
= 255, null
= True, blank
= True)
364 isbn
= models
.TextField(null
= True, blank
= True)
365 orig_lang
= models
.TextField(null
= True, blank
= True)
367 # Metadata AUF multivaluées
368 disciplines
= models
.ManyToManyField(Discipline
)
369 thematiques
= models
.ManyToManyField(Thematique
)
370 pays
= models
.ManyToManyField(Pays
)
371 regions
= models
.ManyToManyField(Region
, verbose_name
='Régions')
374 objects
= RecordManager()
376 def __unicode__(self
):
377 return "[%s] %s" % (self
.server
, self
.title
)
379 def getServeurURL(self
):
380 """Retourne l'URL du serveur de provenance"""
381 return RESOURCES
[self
.server
]['url']
383 def est_complet(self
):
384 """teste si le record à toutes les données obligatoires"""
385 return self
.disciplines
.count() > 0 and \
386 self
.thematiques
.count() > 0 and \
387 self
.pays
.count() > 0 and \
388 self
.regions
.count() > 0
390 def assigner_regions(self
, regions
):
391 self
.regions
.add(*regions
)
393 def assigner_disciplines(self
, disciplines
):
394 self
.disciplines
.add(*disciplines
)
397 class Serveur(models
.Model
):
398 """Identification d'un serveur d'ou proviennent les références"""
399 nom
= models
.CharField(primary_key
= True, max_length
= 255)
401 def __unicode__(self
,):
404 def conf_2_db(self
,):
405 for k
in RESOURCES
.keys():
406 s
, created
= Serveur
.objects
.get_or_create(nom
=k
)
410 class Profile(models
.Model
):
411 user
= models
.ForeignKey(User
, unique
=True)
412 serveurs
= models
.ManyToManyField(Serveur
, null
= True, blank
= True)
414 class HarvestLog(models
.Model
):
415 context
= models
.CharField(max_length
= 255)
416 name
= models
.CharField(max_length
= 255)
417 date
= models
.DateTimeField(auto_now
= True)
418 added
= models
.IntegerField(null
= True, blank
= True)
419 updated
= models
.IntegerField(null
= True, blank
= True)
420 processed
= models
.IntegerField(null
= True, blank
= True)
421 record
= models
.ForeignKey(Record
, null
= True, blank
= True)
425 logger
= HarvestLog()
426 if message
.has_key('record_id'):
427 message
['record'] = Record
.objects
.get(id=message
['record_id'])
428 del(message
['record_id'])
430 for k
,v
in message
.items():
431 setattr(logger
, k
, v
)