]> git.openstreetmap.org Git - osqa.git/blob - forum_modules/exporter/exporter.py
Pagination updates
[osqa.git] / forum_modules / exporter / exporter.py
1 from __future__ import with_statement
2
3 import os, tarfile, datetime, logging, re, ConfigParser, shutil, zipfile
4
5 from django.core.cache import cache
6 from django.utils.translation import ugettext as _
7 from forum.models import *
8 from forum.settings import APP_URL
9 from forum.templatetags.extra_tags import diff_date
10 import xml.etree.ElementTree
11 from xml.etree import ElementTree as ET
12 from xml.etree.ElementTree import Comment, _encode, ProcessingInstruction, QName, _escape_attrib, _escape_cdata, _namespace_map
13 from forum import settings
14 from django.conf import settings as djsettings
15 import settings as selfsettings
16 import string
17
18 try:
19     from xml.etree.ElementTree import fixtag
20 except ImportError:
21     def fixtag(tag, namespaces):
22         # given a decorated tag (of the form {uri}tag), return prefixed
23         # tag and namespace declaration, if any
24         if isinstance(tag, QName):
25             tag = tag.text
26         namespace_uri, tag = string.split(tag[1:], "}", 1)
27         prefix = namespaces.get(namespace_uri)
28         if prefix is None:
29             prefix = _namespace_map.get(namespace_uri)
30             if prefix is None:
31                 prefix = "ns%d" % len(namespaces)
32             namespaces[namespace_uri] = prefix
33             if prefix == "xml":
34                 xmlns = None
35             else:
36                 xmlns = ("xmlns:%s" % prefix, namespace_uri)
37         else:
38             xmlns = None
39         return "%s:%s" % (prefix, tag), xmlns
40
41 CACHE_KEY = "%s_exporter_state" % APP_URL
42 EXPORT_STEPS = []
43
44 TMP_FOLDER = os.path.join(os.path.dirname(__file__), 'tmp')
45
46 DATE_AND_AUTHOR_INF_SECTION = 'DateAndAuthor'
47 OPTIONS_INF_SECTION = 'Options'
48 META_INF_SECTION = 'Meta'
49
50 DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
51 DATE_FORMAT = "%Y-%m-%d"
52
53 def Etree_pretty__write(self, file, node, encoding, namespaces,
54                         level=0, identator="    "):
55     tag = node.tag
56     if tag is Comment:
57         file.write(level * identator + "<!-- %s -->" % _escape_cdata(node.text, encoding))
58     elif tag is ProcessingInstruction:
59         file.write("<?%s?>" % _escape_cdata(node.text, encoding))
60     else:
61         items = node.items()
62         xmlns_items = [] # new namespaces in this scope
63         try:
64             if isinstance(tag, QName) or tag[:1] == "{":
65                 tag, xmlns = fixtag(tag, namespaces)
66                 if xmlns: xmlns_items.append(xmlns)
67         except TypeError:
68             raise #_raise_serialization_error(tag)
69         file.write("\n" + level * identator + "<" + _encode(tag, encoding))
70         if items or xmlns_items:
71             items.sort() # lexical order
72             for k, v in items:
73                 try:
74                     if isinstance(k, QName) or k[:1] == "{":
75                         k, xmlns = fixtag(k, namespaces)
76                         if xmlns: xmlns_items.append(xmlns)
77                 except TypeError:
78                     raise #_raise_serialization_error(k)
79                 try:
80                     if isinstance(v, QName):
81                         v, xmlns = fixtag(v, namespaces)
82                         if xmlns: xmlns_items.append(xmlns)
83                 except TypeError:
84                     raise #_raise_serialization_error(v)
85                 file.write(u" %s=\"%s\"" % (_encode(k, encoding),
86                                             _escape_attrib(v, encoding)))
87             for k, v in xmlns_items:
88                 file.write(u" %s=\"%s\"" % (_encode(k, encoding),
89                                             _escape_attrib(v, encoding)))
90         if node.text or len(node):
91             file.write(">")
92             if node.text:
93                 file.write(_escape_cdata(node.text, encoding))
94             for n in node:
95                 self._write(file, n, encoding, namespaces, level + 1, identator)
96             if node.text and len(node.text) < 125:
97                 file.write("</" + _encode(tag, encoding) + ">")
98             else:
99                 file.write("\n" + level * identator + "</" + _encode(tag, encoding) + ">")
100         else:
101             file.write(" />")
102         for k, v in xmlns_items:
103             del namespaces[v]
104     if node.tail:
105         file.write(_escape_cdata(node.tail.replace("\n", (level * identator )+ "\n"), encoding))
106
107 def make_date(date, with_time=True):
108     try:
109         return date.strftime(with_time and DATETIME_FORMAT or DATE_FORMAT)
110     except ValueError, e:
111         return date.replace(year=1900).strftime(with_time and DATETIME_FORMAT or DATE_FORMAT)
112
113
114 def ET_Element_add_tag(el, tag_name, content = None, **attrs):
115     tag = ET.SubElement(el, tag_name)
116
117     if content:
118         try:
119             tag.text = unicode(content)
120         except Exception, e:
121             #logging.error('error converting unicode characters')
122             #import traceback
123             #logging.error(traceback.print_exc())
124
125             import string
126             tag.text = unicode("".join([c for c in content if c in string.printable]))
127
128     for k, v in attrs.items():
129         tag.set(k, unicode(v))
130
131     return tag
132
133 GOOD_TAG_NAME = re.compile("^\w+$")
134
135 def make_extra(el, v):
136     if v is None:
137         return
138
139
140     if isinstance(v, (int, long, str, unicode, float, bool, dict, list, tuple)):
141         if isinstance(v, tuple):
142             t = 'list'
143         else:
144             t = v.__class__.__name__
145     else:
146         t = 'unknown'
147
148     value = el.add('value', type=t)
149
150     if isinstance(v, (list, tuple)):
151         for i in v:
152             item = value.add('item')
153             make_extra(item, i)
154
155     elif isinstance(v, dict):
156         for k, i in v.items():
157             item = value.add('item', key=k)
158             make_extra(item, i)
159     else:
160         value.text = unicode(v)
161
162 def write_to_file(root, tmp, filename):
163     tree = ET.ElementTree(root)
164     tree.write(os.path.join(tmp, filename), encoding='UTF-8')
165
166 def create_targz(tmp, files, start_time, options, user, state, set_state, file_format):
167     now = datetime.datetime.now()
168     domain = re.match('[\w-]+\.[\w-]+(\.[\w-]+)*', djsettings.APP_URL)
169     if domain:
170         domain = '_'.join(domain.get(0).split('.'))
171     else:
172         domain = 'localhost'
173
174     fname = "%s-%s" % (domain, now.strftime('%Y%m%d%H%M'))
175     if file_format == 'zip':
176         full_fname = "%s.zip" % fname
177     else:
178         full_fname = "%s.tar.gz" % fname
179
180     if file_format == 'zip':
181         t = zipfile.ZipFile(os.path.join(selfsettings.EXPORTER_BACKUP_STORAGE, full_fname), 'w')
182
183         def add_to_file(f, a):
184             t.write(f, a)
185     else:
186         t = tarfile.open(os.path.join(selfsettings.EXPORTER_BACKUP_STORAGE, full_fname), mode = 'w:gz')
187
188         def add_to_file(f, a):
189             t.add(f, a)
190
191     state['overall']['status'] = _('Compressing xml files')
192     set_state()
193
194     for f in files:
195         add_to_file(os.path.join(tmp, f), "/%s" % f)
196
197     if options.get('uplodaded_files', False):
198         state['overall']['status'] = _('Importing uploaded files')
199         set_state()
200         export_upfiles(t)
201
202     if options.get('import_skins_folder', False):
203         state['overall']['status'] = _('Importing skins folder')
204         set_state()
205         export_skinsfolder(t)
206
207     state['overall']['status'] = _('Writing inf file.')
208     set_state()
209
210     inf = ConfigParser.SafeConfigParser()
211
212     inf.add_section(DATE_AND_AUTHOR_INF_SECTION)
213
214     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'file-name', full_fname)
215     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'author', unicode(user.id))
216     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'site', djsettings.APP_URL)
217     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'started', start_time.strftime(DATETIME_FORMAT))
218     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'finished', now.strftime(DATETIME_FORMAT))
219
220     inf.add_section(OPTIONS_INF_SECTION)
221     inf.set(OPTIONS_INF_SECTION, 'anon-data', str(options.get('anon_data', False)))
222     inf.set(OPTIONS_INF_SECTION, 'with-upfiles', str(options.get('uplodaded_files', False)))
223     inf.set(OPTIONS_INF_SECTION, 'with-skins', str(options.get('import_skins_folder', False)))
224
225     inf.add_section(META_INF_SECTION)
226
227     for id, s in state.items():
228         inf.set(META_INF_SECTION, id, str(s['count']))
229
230     with open(os.path.join(tmp, '%s.backup.inf' % fname), 'wb') as inffile:
231         inf.write(inffile)
232
233     add_to_file(os.path.join(tmp, '%s.backup.inf' % fname), '/backup.inf')
234     state['overall']['status'] = _('Saving backup file')
235     set_state()
236     t.close()
237     return full_fname
238
239
240 def export_upfiles(tf):
241     folder = str(settings.UPFILES_FOLDER)
242
243     if os.path.exists(folder):
244         if isinstance(tf, zipfile.ZipFile):
245             tf.write(folder, arcname='/upfiles')
246         else:
247             tf.add(folder, arcname='/upfiles')
248
249
250 def export_skinsfolder(tf):
251     folder = djsettings.TEMPLATE_DIRS[0]
252
253     if os.path.exists(folder):
254         if isinstance(tf, zipfile.ZipFile):
255             tf.write(folder, arcname='/skins')
256         else:
257             tf.add(folder, arcname='/skins')
258
259
260 def export(options, user):
261     original__write = xml.etree.ElementTree.ElementTree.write
262     xml.etree.ElementTree.ElementTree._write = Etree_pretty__write
263     xml.etree.ElementTree._ElementInterface.add = ET_Element_add_tag
264
265     start_time = datetime.datetime.now()
266     tmp = TMP_FOLDER
267     anon_data = options.get('anon_data', False)
268
269     steps = [s for s in EXPORT_STEPS if not (anon_data and s['fn'].is_user_data())]
270
271     state = dict([(s['id'], {
272         'status': _('Queued'), 'count': s['fn'].count(start_time), 'parsed': 0
273     }) for s in steps] + [
274         ('overall', {
275             'status': _('Starting'), 'count': sum([s['fn'].count(start_time) for s in steps]), 'parsed': 0
276         })
277     ])
278
279     full_state = dict(running=True, state=state, time_started="")
280
281     def set_state():
282         full_state['time_started'] = diff_date(start_time)
283         cache.set(CACHE_KEY, full_state)
284
285     set_state()
286
287     def ping_state(name):
288         state[name]['parsed'] += 1
289         state['overall']['parsed'] += 1
290         set_state()
291
292     def run(fn, name):
293         def ping():
294             ping_state(name)
295
296         state['overall']['status'] = _('Exporting %s') % s['name']
297         state[name]['status'] = _('Exporting')
298
299         root, fname = fn(ping, start_time, anon_data)
300
301         state[name]['status'] = _('Writing temp file')
302         state['overall']['status'] = _('Writing %s temp file') % s['name']
303
304         set_state()
305
306         write_to_file(root, tmp, fname)
307         state[name]['status'] = _('Done')
308
309         set_state()
310
311         return fname
312
313     try:
314         dump_files = []
315
316         for s in steps:
317             dump_files.append(run(s['fn'], s['id']))
318
319         state['overall']['status'] = _('Compressing files')
320         set_state()
321
322         fname = create_targz(tmp, dump_files, start_time, options, user, state, set_state, options['file_format'])
323         full_state['running'] = False
324         full_state['errors'] = False
325         state['overall']['status'] = _('Done')
326         state['overall']['fname'] = fname
327
328         set_state()
329     except Exception, e:
330         full_state['running'] = False
331         full_state['errors'] = "%s: %s" % (e.__class__.__name__, unicode(e))
332         set_state()
333         
334         import traceback
335         logging.error("Error executing xml backup: \n %s" % (traceback.format_exc()))
336     finally:
337         xml.etree.ElementTree.ElementTree._write = original__write
338         del xml.etree.ElementTree._ElementInterface.add
339
340
341 def exporter_step(queryset, root_tag_name, el_tag_name, name, date_lock=None, user_data=False):
342
343     def decorator(fn):
344         def qs(lock):
345             if date_lock:
346                 return queryset.filter(**{"%s__lte" % date_lock: lock})
347             return queryset
348
349         def decorated(ping, lock, anon_data):
350             root = ET.Element(root_tag_name)
351
352             for item in qs(lock).order_by('id').select_related():
353                 el = root.add(el_tag_name)
354                 fn(item, el, anon_data)
355                 ping()
356
357             return root, "%s.xml" % root_tag_name
358
359         def count(lock):
360             return qs(lock).count()
361
362         def is_user_data():
363             return user_data
364
365         decorated.count = count
366         decorated.is_user_data = is_user_data
367
368         EXPORT_STEPS.append(dict(id=root_tag_name, name=name, fn=decorated))
369
370         return decorated
371
372     return decorator
373
374 @exporter_step(Tag.objects.all(), 'tags', 'tag', _('Tags'))
375 def export_tags(t, el, anon_data):
376     el.add('name', t.name)
377     if not anon_data:
378         el.add('author', t.created_by.id)
379     el.add('used', t.used_count)
380
381
382 @exporter_step(User.objects.all(), 'users', 'user', _('Users'), 'date_joined', True)
383 def export_users(u, el, anon_data):
384     el.add('id', u.id)
385     el.add('username', u.username)
386     el.add('password', u.password)
387     el.add('email', u.email, validated=u.email_isvalid and 'true' or 'false')
388     el.add('reputation', u.reputation)
389     el.add('badges', bronze=u.bronze, silver=u.silver, gold=u.gold)
390     el.add('joindate', make_date(u.date_joined))
391     el.add('active', u.is_active and 'true' or 'false')
392
393     el.add('realname', u.real_name)
394     el.add('bio', u.about)
395     el.add('location', u.location)
396     el.add('website', u.website)
397     el.add('birthdate', u.date_of_birth and make_date(u.date_of_birth, with_time=False) or "")
398
399     roles = el.add('roles')
400
401     if u.is_superuser:
402         roles.add('role', 'superuser')
403
404     if u.is_staff:
405         roles.add('role', 'moderator')
406
407     auth = el.add('authKeys')
408     for a in u.auth_keys.all():
409         key = auth.add('key')
410         key.add('provider', a.provider)
411         key.add('key', a.key)
412
413     try:
414         ss = u.subscription_settings
415
416         notify = el.add('notifications', enabled=ss.enable_notifications and 'true' or 'false')
417
418         notify.add('notify', **dict([(t, ss.__dict__.get(t, 'n') == 'i' and 'true' or 'false') for t in ['member_joins', 'new_question', 'new_question_watched_tags', 'subscribed_questions']]))
419
420         notify.add('autoSubscribe', **dict([(t, ss.__dict__.get(t, False) and 'true' or 'false') for t in [
421                 'all_questions', 'all_questions_watched_tags', 'questions_asked', 'questions_answered', 'questions_commented', 'questions_viewed']]))
422
423         notify.add('notifyOnSubscribed', **dict([(t, ss.__dict__.get("notify_%s" % t, False) and 'true' or 'false') for t in [
424                 'answers', 'reply_to_comments', 'comments_own_post', 'comments', 'accepted']]))
425
426         notify.add('digest', ss.send_digest and 'on' or 'off')
427     except SubscriptionSettings.DoesNotExist:
428         pass
429
430     watched = el.add('watchedTags')
431     rejected = el.add('rejectedTags')
432
433     for m in u.tag_selections.all():
434         try:
435             if m.reason == 'good':
436                 watched.add('tag', m.tag.name)
437             else:
438                 rejected.add('tag', m.tag.name)
439         except Tag.DoesNotExist:
440             pass
441
442     
443
444 @exporter_step(Node.objects.all(), 'nodes', 'node', _('Nodes'), 'added_at')
445 def export_nodes(n, el, anon_data):
446     el.add('id', n.id)
447     el.add('type', n.node_type)
448
449     if not anon_data:
450         el.add('author', n.author.id)
451     el.add('date', make_date(n.added_at))
452     el.add('parent', n.parent and n.parent.id or "")
453     el.add('absparent', n.abs_parent and n.abs_parent.id or "")
454
455     act = el.add('lastactivity')
456     act.add('by', n.last_activity_by and n.last_activity_by.id or "")
457     act.add('at', n.last_activity_at and make_date(n.last_activity_at) or "")
458
459     el.add('title', n.title)
460     el.add('body', n.body)
461
462     el.add('score', n.score)
463
464     tags = el.add('tags')
465
466     for t in n.tagname_list():
467         tags.add('tag', t)
468
469     try:
470         active = n.active_revision and n.active_revision.revision or n.revisions.order_by('revision')[0].revision
471     except IndexError:
472         active = 0
473
474     revs = el.add('revisions', active=active)
475
476     for r in n.revisions.order_by('revision'):
477         rev = revs.add('revision')
478         rev.add('number', r.revision)
479         rev.add('summary', r.summary)
480         if not anon_data:
481             rev.add('author', r.author.id)
482         rev.add('date', make_date(r.revised_at))
483
484         rev.add('title', r.title)
485         rev.add('body', r.body)
486         rev.add('tags', ", ".join(r.tagname_list()))
487
488     el.add('marked', n.marked and 'true' or 'false')
489     el.add('wiki', n.nis.wiki and 'true' or 'false')
490     el.add('extraRef', n.extra_ref and n.extra_ref.id or "")
491     make_extra(el.add('extraData'), n.extra)
492     el.add('extraCount', n.extra_count and n.extra_count or "")
493
494
495 @exporter_step(Action.objects.all(), 'actions', 'action', _('Actions'), 'action_date')
496 def export_actions(a, el, anon_data):
497     el.add('id', a.id)
498     el.add('type', a.action_type)
499     el.add('date', make_date(a.action_date))
500
501     if not anon_data:
502         el.add('user', a.user.id)
503         el.add('realUser', a.real_user and a.real_user.id or "")
504         el.add('ip', a.ip)
505     el.add('node', a.node and a.node.id or "")
506
507     make_extra(el.add('extraData'), a.extra)
508
509     canceled = el.add('canceled', state=a.canceled and 'true' or 'false')
510
511     if a.canceled:
512         if not anon_data:
513             canceled.add('user', a.canceled_by.id)
514             canceled.add('ip', a.canceled_ip)
515
516         canceled.add('date', make_date(a.canceled_at))        
517
518     if not anon_data:
519         reputes = el.add('reputes')
520
521         for r in a.reputes.all():
522             repute = reputes.add('repute', byCanceled=r.by_canceled and 'true' or 'false')
523             repute.add('user', r.user.id)
524             repute.add('value', r.value)
525
526
527 #@exporter_step(NodeState.objects.all(), 'states', 'state', _('Node states'), 'action__action_date')
528 #def export_states(s, el, anon_data):
529 #    el.add('type', s.state_type)
530 #    el.add('node', s.node.id)
531 #    el.add('trigger', s.action.id)
532
533
534 #@exporter_step(Badge.objects.all(), 'badges', 'badge', _('Badges'), user_data=True)
535 #def export_badges(b, el, anon_data):
536 #    el.add('type', ["", 'gold', 'silver', 'bronze'][b.type])
537 #    el.add('name', b.cls)
538 #    el.add('count', b.awarded_count)
539
540
541 @exporter_step(Award.objects.all(), 'awards', 'award', _('Awards'), 'awarded_at', True)
542 def export_awards(a, el, anon_data):
543     el.add('badge', a.badge.cls)
544     el.add('user', a.user.id)
545     el.add('node', a.node and a.node.id or "")
546     el.add('trigger', a.trigger and a.trigger.id or "")
547     el.add('action', a.action.id)
548
549 @exporter_step(KeyValue.objects.all(), 'settings', 'setting', _('Settings'))
550 def export_settings(s, el, anon_data):
551     el.add('key', s.key)
552     make_extra(el.add('value'), s.value)