source: telemeta/web/base.py @ 71de57c

cremcrem2crem3devdev2diademsdj1.6feature/breadcrumbsfeature/ts-0.5feature/ts-0.5.4feature/writecacheformagenericinstru_searchlamlam2mapsv3mergenlivemultiprobproductionrelease/1.4.4sabiodsearchsecurityserversocialstoragetelecastertestvideo
Last change on this file since 71de57c was 71de57c, checked in by yomguy <yomguy@…>, 3 years ago

separate forms, add MediaCollectionRelated? (but have to make an abstract object for related media), fix keyword form

  • Property mode set to 100644
File size: 57.9 KB
Line 
1# -*- coding: utf-8 -*-
2# Copyright (C) 2007-2010 Samalyse SARL
3# Copyright (C) 2010-2011 Parisson SARL
4
5# This software is a computer program whose purpose is to backup, analyse,
6# transcode and stream any audio content with its metadata over a web frontend.
7
8# This software is governed by the CeCILL  license under French law and
9# abiding by the rules of distribution of free software.  You can  use,
10# modify and/ or redistribute the software under the terms of the CeCILL
11# license as circulated by CEA, CNRS and INRIA at the following URL
12# "http://www.cecill.info".
13
14# As a counterpart to the access to the source code and  rights to copy,
15# modify and redistribute granted by the license, users are provided only
16# with a limited warranty  and the software's author,  the holder of the
17# economic rights,  and the successive licensors  have only  limited
18# liability.
19
20# In this respect, the user's attention is drawn to the risks associated
21# with loading,  using,  modifying and/or developing or reproducing the
22# software by the user in light of its specific status of free software,
23# that may mean  that it is complicated to manipulate,  and  that  also
24# therefore means  that it is reserved for developers  and  experienced
25# professionals having in-depth computer knowledge. Users are therefore
26# encouraged to load and test the software's suitability as regards their
27# requirements in conditions enabling the security of their systems and/or
28# data to be ensured and,  more generally, to use and operate it in the
29# same conditions as regards security.
30
31# The fact that you are presently reading this means that you have had
32# knowledge of the CeCILL license and that you accept its terms.
33
34# Authors: Olivier Guilyardi <olivier@samalyse.com>
35#          Guillaume Pellerin <yomguy@parisson.com>
36
37import re
38import os
39import sys
40import csv
41import time
42import random
43import datetime
44import timeside
45
46from jsonrpc import jsonrpc_method
47
48from django.utils.decorators import method_decorator
49from django.contrib.auth import authenticate, login
50from django.template import RequestContext, loader
51from django import template
52from django.http import HttpResponse, HttpResponseRedirect
53from django.http import Http404
54from django.shortcuts import render_to_response, redirect
55from django.views.generic import list_detail
56from django.conf import settings
57from django.contrib import auth
58from django.contrib import messages
59from django.contrib.auth.decorators import login_required, permission_required
60from django.core.context_processors import csrf
61from django.forms.models import modelformset_factory, inlineformset_factory
62from django.contrib.auth.models import User
63from django.utils.translation import ugettext
64from django.contrib.auth.forms import UserChangeForm
65from django.core.exceptions import ObjectDoesNotExist
66from django.contrib.syndication.views import Feed
67
68from telemeta.models import *
69import telemeta.models
70import telemeta.interop.oai as oai
71from telemeta.interop.oaidatasource import TelemetaOAIDataSource
72from telemeta.util.unaccent import unaccent
73from telemeta.util.unaccent import unaccent_icmp
74from telemeta.util.logger import Logger
75from telemeta.util.unicode import UnicodeWriter
76from telemeta.cache import TelemetaCache
77import telemeta.web.pages as pages
78from telemeta.forms import *
79
80
81def render(request, template, data = None, mimetype = None):
82    return render_to_response(template, data, context_instance=RequestContext(request), 
83                              mimetype=mimetype)
84
85def stream_from_processor(__decoder, __processor, __flag):
86    while True:
87        __frames, eodproc = __processor.process(*__decoder.process())
88        if eodproc:
89            __flag.value = True
90            __flag.save()
91            break
92        yield __processor.chunk
93
94def stream_from_file(__file):
95    chunk_size = 0x10000
96    f = open(__file, 'r')
97    while True:
98        __chunk = f.read(chunk_size)
99        if not len(__chunk):
100            f.close()
101            break
102        yield __chunk
103   
104def get_public_access(access, year_from=None, year_to=None):
105    # Rolling publishing date : public access is given when time between recorded year
106    # and current year is over the settings value PUBLIC_ACCESS_PERIOD
107    if year_from and not year_from == 0:
108        year = year_from
109    elif year_to and not year_to == 0:
110        year = year_to
111    else:
112        year = 0
113    if access == 'full':
114        public_access = True
115    else:
116        public_access = False
117        if year and not year == 'None':
118            year_now = datetime.datetime.now().strftime("%Y")
119            if int(year_now) - int(year) >= settings.TELEMETA_PUBLIC_ACCESS_PERIOD:
120                public_access = True
121        else:
122            public_access = False       
123    return public_access
124
125def get_revisions(nb):
126    last_revisions = Revision.objects.order_by('-time')[0:nb]
127    revisions = []
128    for revision in last_revisions:
129        if revision.element_type == 'item':
130            try:
131                element = MediaItem.objects.get(pk=revision.element_id)
132            except:
133                element = None
134        if revision.element_type == 'collection':
135            try:
136                element = MediaCollection.objects.get(pk=revision.element_id)
137            except:
138                element = None
139        if revision.element_type == 'marker':
140            try:
141                element = MediaItemMarker.objects.get(pk=revision.element_id)
142            except:
143                element = None
144        if not element == None:
145            revisions.append({'revision': revision, 'element': element})
146    return revisions
147
148def get_playlists(request, user=None):
149    if not user:
150        user = request.user
151    playlists = []
152    if user.is_authenticated():
153        user_playlists = Playlist.objects.filter(author=user)
154        for playlist in user_playlists:
155            playlist_resources = PlaylistResource.objects.filter(playlist=playlist)
156            resources = []
157            for resource in playlist_resources:
158                try:
159                    if resource.resource_type == 'item':
160                        element = MediaItem.objects.get(id=resource.resource_id)
161                    if resource.resource_type == 'collection':
162                        element = MediaCollection.objects.get(id=resource.resource_id)
163                    if resource.resource_type == 'marker':
164                        element = MediaItemMarker.objects.get(id=resource.resource_id)
165                except:
166                    element = None
167                resources.append({'element': element, 'type': resource.resource_type, 'public_id': resource.public_id })
168            playlists.append({'playlist': playlist, 'resources': resources})
169    return playlists
170
171
172class GeneralView(object):
173    """Provide general web UI methods"""
174   
175    def index(self, request):
176        """Render the homepage"""
177        if not request.user.is_authenticated():
178            template = loader.get_template('telemeta/index.html')
179           
180            sound_items = MediaItem.objects.sound()
181            _sound_pub_items = []
182            for item in sound_items:
183                if get_public_access(item.public_access,  str(item.recorded_from_date).split('-')[0], 
184                                                str(item.recorded_to_date).split('-')[0]):
185                    _sound_pub_items.append(item)
186           
187            random.shuffle(_sound_pub_items)
188            if len(_sound_pub_items) != 0:
189                sound_pub_item = _sound_pub_items[0]
190            else:
191                sound_pub_item = None
192            if len(_sound_pub_items) == 2:
193                sound_pub_items = [_sound_pub_items[1]]
194            elif len(_sound_pub_items) > 2:
195                sound_pub_items = _sound_pub_items[1:3]
196            else:
197                sound_pub_items = None
198               
199            revisions = get_revisions(4)
200            context = RequestContext(request, {
201                        'page_content': pages.get_page_content(request, 'home', ignore_slash_issue=True),
202                        'revisions': revisions,  'sound_pub_items': sound_pub_items, 
203                        'sound_pub_item': sound_pub_item })
204            return HttpResponse(template.render(context))
205        else:
206            template='telemeta/home.html'
207            playlists = get_playlists(request)
208            revisions = get_revisions(15)
209            searches = Search.objects.filter(username=request.user)
210            return render(request, template, {'playlists': playlists, 'searches': searches, 
211                                              'revisions': revisions,})
212
213    def edit_search(self, request, criteria=None):
214        year_min, year_max = MediaCollection.objects.all().recording_year_range()
215        rec_years = year_min and year_max and range(year_min, year_max + 1) or []
216        year_min, year_max = MediaCollection.objects.all().publishing_year_range()
217        pub_years = year_min and year_max and range(year_min, year_max + 1) or []
218        return render(request, 'telemeta/search_criteria.html', {
219            'rec_years': rec_years,
220            'pub_years': pub_years,
221            'ethnic_groups': MediaItem.objects.all().ethnic_groups(),
222            'criteria': criteria
223        })
224
225    def handle_oai_request(self, request):
226        host = request.META['HTTP_HOST']
227        datasource  = TelemetaOAIDataSource()
228        repository_name = settings.TELEMETA_ORGANIZATION
229        url         = 'http://' + host + request.path
230        admin       = settings.ADMINS[0][1]
231        provider    = oai.DataProvider(datasource, repository_name, url, admin)
232        args        = request.GET.copy()
233        args.update(request.POST)
234        return HttpResponse(provider.handle(args), mimetype='text/xml')
235       
236    def render_flatpage(self, request, path):
237        try:
238            content = pages.get_page_content(request, path)
239        except pages.MalformedPagePath:
240            return redirect(request.path + '/')
241
242        if isinstance(content, pages.PageAttachment):
243            return HttpResponse(content, content.mimetype())
244        else:
245            return render(request, 'telemeta/flatpage.html', {'page_content': content })
246
247    def logout(self, request):
248        auth.logout(request)
249        return redirect('telemeta-home')
250
251    def search(self, request, type = None):
252        """Perform a search through collections and items metadata"""
253        collections = MediaCollection.objects.enriched()
254        items = MediaItem.objects.enriched()
255        input = request.REQUEST
256        criteria = {}
257
258        switch = {
259            'pattern': lambda value: ( 
260                collections.quick_search(value), 
261                items.quick_search(value)),
262            'title': lambda value: (
263                collections.word_search('title', value), 
264                items.by_title(value)),
265            'location': lambda value: (
266                collections.by_location(Location.objects.get(name=value)), 
267                items.by_location(Location.objects.get(name=value))),
268            'continent': lambda value: (
269                collections.by_continent(value), 
270                items.filter(continent = value)),
271            'ethnic_group': lambda value: (
272                collections.by_ethnic_group(value), 
273                items.filter(ethnic_group = value),
274                EthnicGroup.objects.get(pk=value)),
275            'creator': lambda value: (
276                collections.word_search('creator', value),
277                items.word_search('collection__creator', value)),
278            'collector': lambda value: (
279                collections.by_fuzzy_collector(value),
280                items.by_fuzzy_collector(value)),
281            'rec_year_from': lambda value: (
282                collections.by_recording_year(int(value), int(input.get('rec_year_to', value))), 
283                items.by_recording_date(datetime.date(int(value), 1, 1), 
284                                        datetime.date(int(input.get('rec_year_to', value)), 12, 31))),
285            'rec_year_to': lambda value: (collections, items),
286            'pub_year_from': lambda value: (
287                collections.by_publish_year(int(value), int(input.get('pub_year_to', value))), 
288                items.by_publish_year(int(value), int(input.get('pub_year_to', value)))),
289            'pub_year_to': lambda value: (collections, items),
290        }
291       
292        for key, value in input.items():
293            func = switch.get(key)
294            if func and value and value != "0":
295                try:
296                    res = func(value)
297                    if len(res)  > 2:
298                        collections, items, value = res
299                    else: 
300                        collections, items = res
301                except ObjectDoesNotExist:
302                    collections = collections.none()
303                    items = items.none()
304
305                criteria[key] = value
306
307        if type is None:
308            if collections.count():
309                type = 'collections'
310            else:
311                type = 'items'
312
313        if type == 'items':
314            objects = items
315        else:
316            objects = collections
317
318        return list_detail.object_list(request, objects, 
319            template_name='telemeta/search_results.html', paginate_by=20,
320            extra_context={'criteria': criteria, 'collections_num': collections.count(), 
321                'items_num': items.count(), 'type' : type})
322
323    def complete_location(self, request, with_items=True):
324        input = request.REQUEST
325       
326        token = input['q']
327        limit = int(input['limit'])
328        if with_items:
329            locations = MediaItem.objects.all().locations()
330        else:
331            locations = Location.objects.all()
332
333        locations = locations.filter(name__istartswith=token).order_by('name')[:limit]
334        data = [unicode(l) + " (%d items)" % l.items().count() for l in locations]
335
336        return HttpResponse("\n".join(data))
337
338    def users(self, request):
339        users = User.objects.all()
340        return render(request, 'telemeta/users.html', {'users': users})
341       
342class CollectionView(object):
343    """Provide Collections web UI methods"""
344
345    def collection_detail(self, request, public_id, template='telemeta/collection_detail.html'):
346        collection = MediaCollection.objects.get(public_id=public_id)
347        items = collection.items.enriched()
348        items = items.order_by('code', 'old_code')
349       
350        if collection.public_access == 'none' and not (request.user.is_staff or request.user.is_superuser):
351            mess = ugettext('Access not allowed') 
352            title = ugettext('Collection') + ' : ' + public_id + ' : ' + mess
353            description = ugettext('Please login or contact the website administator to get a private access.')
354            messages.error(request, title)
355            return render(request, 'telemeta/messages.html', {'description' : description})
356
357        public_access = get_public_access(collection.public_access, collection.recorded_from_year, 
358                                                collection.recorded_to_year)
359        playlists = get_playlists(request)
360       
361        related_media = MediaCollectionRelated.objects.filter(collection=collection)
362        for media in related_media:
363            if not media.mime_type:
364                media.set_mime_type()
365                media.save()
366            if not media.title and media.url:
367                try:
368                    from lxml import etree
369                    parser = etree.HTMLParser()
370                    tree = etree.parse(media.url, parser)
371                    title = tree.find(".//title").text
372                    title = title.replace('\n', '').strip()
373                    media.title = title
374                except:
375                    media.title = media.url
376                media.save()
377               
378        return render(request, template, {'collection': collection, 'playlists': playlists, 'public_access': public_access, 'items': items, 'related_media': related_media})
379
380    @method_decorator(permission_required('telemeta.change_mediacollection'))
381    def collection_edit(self, request, public_id, template='telemeta/collection_edit.html'):
382        collection = MediaCollection.objects.get(public_id=public_id)
383        if request.method == 'POST':
384            form = MediaCollectionForm(data=request.POST, files=request.FILES, instance=collection)
385            if form.is_valid():
386                code = form.cleaned_data['code']
387                if not code:
388                    code = public_id
389                form.save()
390                collection.set_revision(request.user)
391                return HttpResponseRedirect('/collections/'+code)
392        else:
393            form = MediaCollectionForm(instance=collection)
394       
395        return render(request, template, {'collection': collection, "form": form,})
396
397    @method_decorator(permission_required('telemeta.add_mediacollection'))
398    def collection_add(self, request, template='telemeta/collection_add.html'):
399        collection = MediaCollection()
400        if request.method == 'POST':
401            form = MediaCollectionForm(data=request.POST, files=request.FILES, instance=collection)
402            if form.is_valid():
403                code = form.cleaned_data['code']
404                if not code:
405                    code = public_id
406                form.save()
407                collection.set_revision(request.user)
408                return HttpResponseRedirect('/collections/'+code)
409        else:
410            form = MediaCollectionForm(instance=collection)
411       
412        return render(request, template, {'collection': collection, "form": form,})
413
414    @method_decorator(permission_required('telemeta.add_mediacollection'))
415    def collection_copy(self, request, public_id, template='telemeta/collection_edit.html'):
416        if request.method == 'POST':
417            new_collection = MediaCollection()
418            form = MediaCollectionForm(data=request.POST, files=request.FILES, instance=new_collection)
419            if form.is_valid():
420                code = form.cleaned_data['code']
421                if not code:
422                    code = public_id
423                form.save()
424                new_collection.set_revision(request.user)
425                return HttpResponseRedirect('/collections/'+code)
426        else:
427            collection = MediaCollection.objects.get(public_id=public_id)
428            form = MediaCollectionForm(instance=collection)
429       
430        return render(request, template, {'collection': collection, "form": form,})
431
432    def collection_playlist(self, request, public_id, template, mimetype):
433        try:
434            collection = MediaCollection.objects.get(public_id=public_id)
435        except ObjectDoesNotExist:
436            raise Http404
437
438        template = loader.get_template(template)
439        context = RequestContext(request, {'collection': collection, 'host': request.META['HTTP_HOST']})
440        return HttpResponse(template.render(context), mimetype=mimetype)
441
442    @method_decorator(permission_required('telemeta.delete_mediacollection'))
443    def collection_delete(self, request, public_id):
444        """Delete a given collection"""
445        collection = MediaCollection.objects.get(public_id=public_id)
446        collection.delete()
447        return HttpResponseRedirect('/collections/')
448   
449    def related_media_collection_stream(self, request, collection_public_id, media_id):
450        collection = MediaCollection.objects.get(public_id=collection_public_id)
451        media = MediaCollectionRelated.objects.get(collection=collection, id=media_id)
452        response = HttpResponse(stream_from_file(media.file.path), mimetype=media.mime_type)
453#        response['Content-Disposition'] = 'attachment'
454        return response
455   
456    @method_decorator(permission_required('telemeta.change_mediacollection'))
457    def related_media_edit(self, request, public_id, template):
458        collection = MediaCollection.objects.get(public_id=public_id)
459        MediaCollectionRelatedFormSet = inlineformset_factory(MediaCollection, MediaCollectionRelated, form=MediaCollectionRelatedForm)
460        if request.method == 'POST':
461            formset = MediaCollectionRelatedFormSet(data=request.POST, files=request.FILES, instance=collection)
462            if formset.is_valid():
463                formset.save()
464                collection.set_revision(request.user)
465                return HttpResponseRedirect('/collections/'+public_id)
466        else:
467            formset = MediaCollectionRelatedFormSet(instance=collection)
468       
469        return render(request, template, {'collection': collection, 'formset': formset,})
470
471class ItemView(object):
472    """Provide Collections web UI methods"""
473
474    graphers = timeside.core.processors(timeside.api.IGrapher)
475    decoders = timeside.core.processors(timeside.api.IDecoder)
476    encoders = timeside.core.processors(timeside.api.IEncoder)
477    analyzers = timeside.core.processors(timeside.api.IAnalyzer)
478    cache_data = TelemetaCache(settings.TELEMETA_DATA_CACHE_DIR)
479    cache_export = TelemetaCache(settings.TELEMETA_EXPORT_CACHE_DIR)
480   
481    def item_previous_next(self, item):
482        # Get previous and next items
483        pks = []
484        items = MediaItem.objects.filter(collection=item.collection)
485        items = items.order_by('code', 'old_code')
486       
487        if len(items) > 1:
488            for it in items:
489                pks.append(it.pk)
490            for pk in pks:
491                if pk == item.pk:
492                    if pk == pks[0]:
493                        previous_pk = pks[-1]
494                        next_pk = pks[1]
495                    elif pk == pks[-1]:
496                        previous_pk = pks[-2]
497                        next_pk = pks[0]
498                    else:
499                        previous_pk = pks[pks.index(pk)-1]
500                        next_pk = pks[pks.index(pk)+1]
501                    for it in items:
502                        if it.pk == previous_pk:
503                            previous = it
504                        if it.pk == next_pk:
505                            next = it
506                    previous = previous.public_id
507                    next = next.public_id
508        else:
509             previous = item.public_id   
510             next = item.public_id
511       
512        return previous, next
513       
514    def item_detail(self, request, public_id=None, marker_id=None, width=None, height=None, 
515                        template='telemeta/mediaitem_detail.html'):
516        """Show the details of a given item"""
517       
518        if not public_id and marker_id:
519            marker = MediaItemMarker.objects.get(public_id=marker_id)
520            item_id = marker.item_id
521            item = MediaItem.objects.get(id=item_id)
522        else:
523            item = MediaItem.objects.get(public_id=public_id)
524       
525        item_public_access = item.public_access != 'none' or item.collection.public_access != 'none'
526        if not item_public_access and not (request.user.is_staff or request.user.is_superuser):
527            mess = ugettext('Access not allowed') 
528            title = ugettext('Item') + ' : ' + public_id + ' : ' + mess
529            description = ugettext('Please login or contact the website administator to get a private access.')
530            messages.error(request, title)
531            return render(request, 'telemeta/messages.html', {'description' : description})
532           
533        # Get TimeSide processors
534        formats = []
535        for encoder in self.encoders:
536            #FIXME: timeside cannot encode to FLAC and OGG now :'(
537            if encoder.file_extension() != 'ogg' and encoder.file_extension() != 'flac':
538                formats.append({'name': encoder.format(), 'extension': encoder.file_extension()})
539
540        graphers = []
541        for grapher in self.graphers:
542            graphers.append({'name':grapher.name(), 'id': grapher.id()})
543        if request.REQUEST.has_key('grapher_id'):
544            grapher_id = request.REQUEST['grapher_id']
545        else:
546            grapher_id = 'waveform'
547       
548        previous, next = self.item_previous_next(item)
549        self.item_analyze(item)
550        playlists = get_playlists(request)
551        public_access = get_public_access(item.public_access, str(item.recorded_from_date).split('-')[0], 
552                                                str(item.recorded_to_date).split('-')[0])
553       
554        related_media = MediaItemRelated.objects.filter(item=item)
555        for media in related_media:
556            if not media.mime_type:
557                media.set_mime_type()
558                media.save()
559            if not media.title and media.url:
560                try:
561                    from lxml import etree
562                    parser = etree.HTMLParser()
563                    tree = etree.parse(media.url, parser)
564                    title = tree.find(".//title").text
565                    title = title.replace('\n', '').strip()
566                    media.title = title
567                except:
568                    media.title = media.url
569                media.save()
570               
571        return render(request, template,
572                    {'item': item, 'export_formats': formats,
573                    'visualizers': graphers, 'visualizer_id': grapher_id,
574                    'audio_export_enabled': getattr(settings, 'TELEMETA_DOWNLOAD_ENABLED', True),
575                    'previous' : previous, 'next' : next, 'marker': marker_id, 'playlists' : playlists, 
576                    'public_access': public_access, 'width': width, 'height': height, 
577                    'related_media': related_media, 
578                    })
579       
580    @method_decorator(permission_required('telemeta.change_mediaitem'))
581    def item_edit(self, request, public_id, template='telemeta/mediaitem_edit.html'):
582        """Edit a given item"""
583        item = MediaItem.objects.get(public_id=public_id)
584       
585        formats = []
586        for encoder in self.encoders:
587            #FIXME: timeside cannot encode to FLAC and OGG now :'(
588            if encoder.file_extension() != 'ogg' and encoder.file_extension() != 'flac':
589                formats.append({'name': encoder.format(), 'extension': encoder.file_extension()})
590
591        graphers = []
592        for grapher in self.graphers:
593            graphers.append({'name':grapher.name(), 'id': grapher.id()})
594        if request.REQUEST.has_key('grapher_id'):
595            grapher_id = request.REQUEST['grapher_id']
596        else:
597            grapher_id = 'waveform'
598       
599        previous, next = self.item_previous_next(item)
600        self.item_analyze(item)
601       
602        if request.method == 'POST':
603            form = MediaItemForm(data=request.POST, files=request.FILES, instance=item)
604            if form.is_valid():
605                form.save()
606                code = form.cleaned_data['code']
607                if not code:
608                    code = str(item.id)
609                if form.files:
610                    self.cache_data.delete_item_data(code)
611                    self.cache_export.delete_item_data(code)
612                    flags = MediaItemTranscodingFlag.objects.filter(item=item)
613                    analyses = MediaItemAnalysis.objects.filter(item=item)
614                    for flag in flags:
615                        flag.delete()
616                    for analysis in analyses:
617                        analysis.delete()
618                item.set_revision(request.user)
619                return HttpResponseRedirect('/items/'+code)
620        else:
621            form = MediaItemForm(instance=item)
622       
623        return render(request, template, 
624                    {'item': item, 'export_formats': formats, 
625                    'visualizers': graphers, 'visualizer_id': grapher_id,
626                    'audio_export_enabled': getattr(settings, 'TELEMETA_DOWNLOAD_ENABLED', True), "form": form, 
627                    'previous' : previous, 'next' : next, 
628                    })
629   
630    def related_media_item_stream(self, request, item_public_id, media_id):
631        item = MediaItem.objects.get(public_id=item_public_id)
632        media = MediaItemRelated.objects.get(item=item, id=media_id)
633        response = HttpResponse(stream_from_file(media.file.path), mimetype=media.mime_type)
634#        response['Content-Disposition'] = 'attachment'
635        return response
636   
637    @method_decorator(permission_required('telemeta.change_mediaitem'))
638    def related_media_edit(self, request, public_id, template):
639        item = MediaItem.objects.get(public_id=public_id)
640        MediaItemRelatedFormSet = inlineformset_factory(MediaItem, MediaItemRelated, form=MediaItemRelatedForm)
641        if request.method == 'POST':
642            formset = MediaItemRelatedFormSet(data=request.POST, files=request.FILES, instance=item)
643            if formset.is_valid():
644                formset.save()
645                item.set_revision(request.user)
646                return HttpResponseRedirect('/items/'+public_id)
647        else:
648            formset = MediaItemRelatedFormSet(instance=item)
649       
650        return render(request, template, {'item': item, 'formset': formset,})
651       
652    @method_decorator(permission_required('telemeta.add_mediaitem'))
653    def item_add(self, request, public_id=None, template='telemeta/mediaitem_add.html'):
654        """Add an item"""
655        if public_id:
656            collection = MediaCollection.objects.get(public_id=public_id)
657            item = MediaItem(collection=collection)
658        else:
659            item = MediaItem()
660        if request.method == 'POST':
661            form = MediaItemForm(data=request.POST, files=request.FILES, instance=item)
662            if form.is_valid():
663                form.save()
664                item.set_revision(request.user)
665                code = form.cleaned_data['code']
666                if not code:
667                    code = str(item.id)
668                return HttpResponseRedirect('/items/'+code)
669        else:
670            form = MediaItemForm(instance=item)
671       
672        return render(request, template, {'item': item, 'form': form})
673   
674    @method_decorator(permission_required('telemeta.add_mediaitem'))
675    def item_copy(self, request, public_id, template='telemeta/mediaitem_copy.html'):
676        """Copy a given item"""       
677        if request.method == 'POST':
678            new_item = MediaItem()
679            form = MediaItemForm(data=request.POST, files=request.FILES, instance=new_item)
680            if form.is_valid():
681                form.save()
682                code = form.cleaned_data['code']
683                if not code:
684                    code = str(new_item.id)
685                new_item.set_revision(request.user)
686                return HttpResponseRedirect('/items/'+code)
687        else:
688            item = MediaItem.objects.get(public_id=public_id)
689            form = MediaItemForm(instance=item)
690            form.file = None
691       
692        return render(request, template, {'item': item, "form": form})
693       
694    @method_decorator(permission_required('telemeta.delete_mediaitem'))
695    def item_delete(self, request, public_id):
696        """Delete a given item"""
697        item = MediaItem.objects.get(public_id=public_id)
698        collection = item.collection
699        item.delete()
700        return HttpResponseRedirect('/collections/'+collection.code)
701       
702    def item_analyze(self, item):
703        analyses = MediaItemAnalysis.objects.filter(item=item)
704       
705        if analyses:
706            if not item.approx_duration:
707                for analysis in analyses:
708                    if analysis.id == 'duration':
709                        value = analysis.value
710                        time = value.split(':')
711                        time[2] = time[2].split('.')[0]
712                        time = ':'.join(time)
713                        item.approx_duration = str(time)
714                        item.save()
715        else:     
716            analyzers = []
717            analyzers_sub = []
718            if item.file:
719                decoder  = timeside.decoder.FileDecoder(item.file.path)
720                pipe = decoder
721                for analyzer in self.analyzers:
722                    subpipe = analyzer()
723                    analyzers_sub.append(subpipe)
724                    pipe = pipe | subpipe
725                pipe.run()
726
727                mime_type = decoder.format()
728                analysis = MediaItemAnalysis(item=item, name='MIME type', 
729                                             analyzer_id='mime_type', unit='', value=mime_type)
730                analysis.save()
731                analysis = MediaItemAnalysis(item=item, name='Channels', 
732                                             analyzer_id='channels', 
733                                             unit='', value=decoder.channels())
734                analysis.save()
735                analysis = MediaItemAnalysis(item=item, name='Samplerate', 
736                                             analyzer_id='samplerate', unit='Hz', 
737                                             value=unicode(decoder.audiorate))
738                analysis.save()
739                analysis = MediaItemAnalysis(item=item, name='Resolution', 
740                                             analyzer_id='resolution', unit='bits', 
741                                             value=unicode(decoder.audiowidth))
742                analysis.save()
743
744                for analyzer in analyzers_sub:
745                    value = analyzer.result()
746                    if analyzer.id() == 'duration':
747                        approx_value = int(round(value))
748                        item.approx_duration = approx_value
749                        try:
750                            item.save()
751                        except:
752                            pass
753                        value = datetime.timedelta(0,value)
754                   
755                    analysis = MediaItemAnalysis(item=item, name=analyzer.name(), 
756                                                 analyzer_id=analyzer.id(), 
757                                                 unit=analyzer.unit(), value=str(value))
758                    analysis.save()
759       
760    def item_analyze_xml(self, request, public_id):
761        item = MediaItem.objects.get(public_id=public_id)
762        analyses = MediaItemAnalysis.objects.filter(item=item)
763        analyzers = []
764        for analysis in analyses:
765            analyzers.append(analysis.to_dict())
766        mime_type = 'text/xml'
767        response = HttpResponse(self.cache_data.get_analyzer_xml(analyzers), mimetype=mime_type)
768        response['Content-Disposition'] = 'attachment; filename='+public_id+'.xml'       
769        return response       
770       
771    def item_visualize(self, request, public_id, visualizer_id, width, height):
772        item = MediaItem.objects.get(public_id=public_id)
773        mime_type = 'image/png'
774        grapher_id = visualizer_id
775       
776        for grapher in self.graphers:
777            if grapher.id() == grapher_id:
778                break
779
780        if grapher.id() != grapher_id:
781            raise Http404
782       
783        size = width + '_' + height
784        image_file = '.'.join([public_id, grapher_id, size, 'png'])
785
786        if not self.cache_data.exists(image_file):
787            if item.file:
788                path = self.cache_data.dir + os.sep + image_file
789                decoder  = timeside.decoder.FileDecoder(item.file.path)
790                graph = grapher(width = int(width), height = int(height))
791                pipe = decoder | graph
792                pipe.run()
793                graph.watermark('timeside', opacity=.6, margin=(5,5))
794                f = open(path, 'w')
795                graph.render(path)
796                f.close()
797               
798        response = HttpResponse(self.cache_data.read_stream_bin(image_file), mimetype=mime_type)
799        return response
800       
801    def list_export_extensions(self):
802        "Return the recognized item export file extensions, as a list"
803        list = []
804        for encoder in self.encoders:
805            list.append(encoder.file_extension())
806        return list
807
808    def item_export(self, request, public_id, extension):                   
809        """Export a given media item in the specified format (OGG, FLAC, ...)"""
810       
811        item = MediaItem.objects.get(public_id=public_id)
812        public_access = get_public_access(item.public_access, 
813                                          str(item.recorded_from_date).split('-')[0], 
814                                          str(item.recorded_to_date).split('-')[0])
815       
816        if (not public_access or not extension in settings.TELEMETA_STREAMING_FORMATS) and \
817                    not (request.user.has_perm('telemeta.can_play_all_items') or request.user.is_superuser):
818            mess = ugettext('Access not allowed') 
819            title = 'Item file : ' + public_id + '.' + extension + ' : ' + mess
820            description = ugettext('Please login or contact the website administator to get a private access.')
821            messages.error(request, title)
822            return render(request, 'telemeta/messages.html', {'description' : description})
823
824        for encoder in self.encoders:
825            if encoder.file_extension() == extension:
826                break
827
828        if encoder.file_extension() != extension:
829            raise Http404('Unknown export file extension: %s' % extension)
830
831        mime_type = encoder.mime_type()
832        file = public_id + '.' + encoder.file_extension()
833        audio = item.file.path
834       
835        flag = MediaItemTranscodingFlag.objects.filter(item=item, mime_type=mime_type)
836        if not flag:
837            flag = MediaItemTranscodingFlag(item=item, mime_type=mime_type)
838            flag.value = False
839            flag.save()
840        else:
841            flag = flag[0]
842       
843        analyzers = self.item_analyze(item)
844        if analyzers:
845            for analyzer in analyzers:
846                if analyzer['id'] == 'mime_type':
847                    format = analyzer['value']
848        else:
849            decoder = timeside.decoder.FileDecoder(audio)
850            format = decoder.format()
851       
852        dc_metadata = dublincore.express_item(item).to_list()
853        mapping = DublinCoreToFormatMetadata(extension)
854        metadata = mapping.get_metadata(dc_metadata)     
855       
856        if mime_type in format:
857            # source > stream
858            if not extension in mapping.unavailable_extensions:
859                proc = encoder(audio)
860                proc.set_metadata(metadata)
861                proc.write_metadata()
862            response = HttpResponse(stream_from_file(audio), mimetype = mime_type)
863        else:
864            media = self.cache_export.dir + os.sep + file
865            if not self.cache_export.exists(file) or flag.value == False:
866                # source > encoder > stream
867                decoder = timeside.decoder.FileDecoder(audio)
868                decoder.setup()
869                proc = encoder(media, streaming=True)
870                proc.setup(channels=decoder.channels(), samplerate=decoder.samplerate())
871                proc.set_metadata(metadata)
872                response = HttpResponse(stream_from_processor(decoder, proc, flag), mimetype = mime_type)
873            else:
874                # cache > stream
875                if not extension in mapping.unavailable_extensions:
876                    proc = encoder(media)
877                    proc.set_metadata(metadata)
878                    proc.write_metadata()
879                response = HttpResponse(self.cache_export.read_stream_bin(file), mimetype = mime_type)
880       
881        response['Content-Disposition'] = 'attachment'
882        return response
883
884    def item_playlist(self, request, public_id, template, mimetype):
885        try:
886            item = MediaItem.objects.get(public_id=public_id)
887        except ObjectDoesNotExist:
888            raise Http404
889
890        template = loader.get_template(template)
891        context = RequestContext(request, {'item': item, 'host': request.META['HTTP_HOST']})
892        return HttpResponse(template.render(context), mimetype=mimetype)
893
894    @method_decorator(permission_required('telemeta.change_mediaitem'))
895    def item_performances_edit(self, request, public_id, template):
896        item = MediaItem.objects.get(public_id=public_id)
897        PerformanceFormSet = inlineformset_factory(MediaItem, MediaItemPerformance, form=MediaItemPerformanceForm)
898        if request.method == 'POST':
899            formset = PerformanceFormSet(data=request.POST, instance=item)
900            if formset.is_valid():
901                formset.save()
902                return HttpResponseRedirect('/items/'+public_id)
903        else:
904            formset = PerformanceFormSet(instance=item)
905        return render(request, template, {'item': item, 'formset': formset,})
906   
907    @method_decorator(permission_required('telemeta.change_mediaitem'))
908    def item_keywords_edit(self, request, public_id, template):
909        item = MediaItem.objects.get(public_id=public_id)
910        FormSet = inlineformset_factory(MediaItem, MediaItemKeyword)
911        if request.method == 'POST':
912            formset = FormSet(data=request.POST, instance=item)
913            if formset.is_valid():
914                formset.save()
915                return HttpResponseRedirect('/items/'+public_id)
916        else:
917            formset = FormSet(instance=item)
918        return render(request, template, {'item': item, 'formset': formset,})
919
920
921class AdminView(object):
922    """Provide Admin web UI methods"""
923   
924    @method_decorator(permission_required('sites.change_site'))
925    def admin_index(self, request):
926        return render(request, 'telemeta/admin.html', self.__get_admin_context_vars())
927
928    @method_decorator(permission_required('sites.change_site'))
929    def admin_general(self, request):
930        return render(request, 'telemeta/admin_general.html', self.__get_admin_context_vars())
931   
932    @method_decorator(permission_required('sites.change_site'))
933    def admin_enumerations(self, request):
934        return render(request, 'telemeta/admin_enumerations.html', self.__get_admin_context_vars())
935
936    @method_decorator(permission_required('sites.change_site'))
937    def admin_users(self, request):
938        users = User.objects.all()
939        return render(request, 'telemeta/admin_users.html', {'users': users})
940
941    def __get_enumerations_list(self):
942        from django.db.models import get_models
943        models = get_models(telemeta.models)
944
945        enumerations = []
946        for model in models:
947            if issubclass(model, Enumeration):
948                enumerations.append({"name": model._meta.verbose_name, 
949                    "id": model._meta.module_name})
950
951        cmp = lambda obj1, obj2: unaccent_icmp(obj1['name'], obj2['name'])
952        enumerations.sort(cmp)
953        return enumerations                   
954   
955    def __get_admin_context_vars(self):
956        return {"enumerations": self.__get_enumerations_list()}
957
958    def __get_enumeration(self, id):
959        from django.db.models import get_models
960        models = get_models(telemeta.models)
961        for model in models:
962            if model._meta.module_name == id:
963                break
964
965        if model._meta.module_name != id:
966            return None
967
968        return model
969
970    @method_decorator(permission_required('telemeta.change_keyword'))
971    def edit_enumeration(self, request, enumeration_id):       
972
973        enumeration  = self.__get_enumeration(enumeration_id)
974        if enumeration == None:
975            raise Http404
976
977        vars = self.__get_admin_context_vars()
978        vars["enumeration_id"] = enumeration._meta.module_name
979        vars["enumeration_name"] = enumeration._meta.verbose_name           
980        vars["enumeration_values"] = enumeration.objects.all()
981        return render(request, 'telemeta/enumeration_edit.html', vars)
982
983    @method_decorator(permission_required('telemeta.add_keyword'))
984    def add_to_enumeration(self, request, enumeration_id):       
985
986        enumeration  = self.__get_enumeration(enumeration_id)
987        if enumeration == None:
988            raise Http404
989
990        enumeration_value = enumeration(value=request.POST['value'])
991        enumeration_value.save()
992
993        return self.edit_enumeration(request, enumeration_id)
994
995    @method_decorator(permission_required('telemeta.change_keyword'))
996    def update_enumeration(self, request, enumeration_id):       
997       
998        enumeration  = self.__get_enumeration(enumeration_id)
999        if enumeration == None:
1000            raise Http404
1001       
1002        if request.method == 'POST':
1003            enumeration.objects.filter(id__in=request.POST.getlist('sel')).delete()
1004
1005        return self.edit_enumeration(request, enumeration_id)
1006
1007    @method_decorator(permission_required('telemeta.change_keyword'))
1008    def edit_enumeration_value(self, request, enumeration_id, value_id):       
1009
1010        enumeration  = self.__get_enumeration(enumeration_id)
1011        if enumeration == None:
1012            raise Http404
1013       
1014        vars = self.__get_admin_context_vars()
1015        vars["enumeration_id"] = enumeration._meta.module_name
1016        vars["enumeration_name"] = enumeration._meta.verbose_name           
1017        vars["enumeration_record"] = enumeration.objects.get(id__exact=value_id)
1018        return render(request, 'telemeta/enumeration_edit_value.html', vars)
1019
1020    @method_decorator(permission_required('telemeta.change_keyword'))
1021    def update_enumeration_value(self, request, enumeration_id, value_id):       
1022
1023        if request.method == 'POST':
1024            enumeration  = self.__get_enumeration(enumeration_id)
1025            if enumeration == None:
1026                raise Http404
1027       
1028            record = enumeration.objects.get(id__exact=value_id)
1029            record.value = request.POST["value"]
1030            record.save()
1031
1032        return self.edit_enumeration(request, enumeration_id)
1033 
1034
1035class InstrumentView(object):
1036    """Provide Instrument web UI methods"""
1037
1038    @method_decorator(permission_required('telemeta.change_instrument'))
1039    def edit_instrument(self, request):       
1040       
1041        instruments = Instrument.objects.all().order_by('name')
1042        if instruments == None:
1043            raise Http404
1044        return render(request, 'telemeta/instrument_edit.html', {'instruments': instruments})
1045
1046    @method_decorator(permission_required('telemeta.add_instrument'))
1047    def add_to_instrument(self, request):       
1048
1049        if request.method == 'POST':
1050            instrument = Instrument(name=request.POST['value'])
1051            instrument.save()
1052
1053        return self.edit_instrument(request)
1054
1055    @method_decorator(permission_required('telemeta.change_instrument'))
1056    def update_instrument(self, request):       
1057       
1058        if request.method == 'POST':
1059            Instrument.objects.filter(id__in=request.POST.getlist('sel')).delete()
1060
1061        return self.edit_instrument(request)
1062
1063    @method_decorator(permission_required('telemeta.change_instrument'))
1064    def edit_instrument_value(self, request, value_id):       
1065        instrument = Instrument.objects.get(id__exact=value_id)
1066       
1067        return render(request, 'telemeta/instrument_edit_value.html', {'instrument': instrument})
1068
1069    @method_decorator(permission_required('telemeta.change_instrument'))
1070    def update_instrument_value(self, request, value_id):       
1071
1072        if request.method == 'POST':       
1073            instrument = Instrument.objects.get(id__exact=value_id)
1074            instrument.name = request.POST["value"]
1075            instrument.save()
1076
1077        return self.edit_instrument(request)
1078       
1079       
1080class GeoView(object):
1081    """Provide Geo web UI methods"""
1082
1083    def list_continents(self, request):
1084        continents = MediaItem.objects.all().countries(group_by_continent=True)
1085        return render(request, 'telemeta/geo_continents.html', 
1086                    {'continents': continents, 'gmap_key': settings.TELEMETA_GMAP_KEY })
1087
1088    def country_info(self, request, id):
1089        country = Location.objects.get(pk=id)
1090        return render(request, 'telemeta/country_info.html', {
1091            'country': country, 'continent': country.continents()[0]})
1092
1093    def list_countries(self, request, continent):                   
1094        continent = Location.objects.by_flatname(continent)[0]
1095        countries = MediaItem.objects.by_location(continent).countries()
1096
1097        return render(request, 'telemeta/geo_countries.html', {
1098            'continent': continent,
1099            'countries': countries
1100        })
1101
1102    def list_country_collections(self, request, continent, country):
1103        continent = Location.objects.by_flatname(continent)[0]
1104        country = Location.objects.by_flatname(country)[0]
1105        objects = MediaCollection.objects.enriched().by_location(country)
1106        return list_detail.object_list(request, objects, 
1107            template_name='telemeta/geo_country_collections.html', paginate_by=20,
1108            extra_context={'country': country, 'continent': continent})
1109
1110    def list_country_items(self, request, continent, country):
1111        continent = Location.objects.by_flatname(continent)[0]
1112        country = Location.objects.by_flatname(country)[0]
1113        objects = MediaItem.objects.enriched().by_location(country)
1114        return list_detail.object_list(request, objects, 
1115            template_name='telemeta/geo_country_items.html', paginate_by=20,
1116            extra_context={'country': country, 'continent': continent})
1117
1118class MarkerView(object):
1119    """Provide Collections web UI methods"""
1120
1121    @jsonrpc_method('telemeta.add_marker')
1122    def add_marker(request, marker):
1123        # marker must be a dict
1124        if isinstance(marker, dict):
1125            item_id = marker['item_id']
1126            item = MediaItem.objects.get(id=item_id)
1127            m = MediaItemMarker(item=item) 
1128            m.public_id = marker['public_id']
1129            m.time = float(marker['time'])
1130            m.title = marker['title']
1131            m.description = marker['description']
1132            m.author = User.objects.get(username=marker['author'])
1133            m.save()
1134            m.set_revision(request.user)
1135        else:
1136            raise 'Error : Bad marker dictionnary'
1137
1138    @jsonrpc_method('telemeta.del_marker')
1139    def del_marker(request, public_id):
1140        m = MediaItemMarker.objects.get(public_id=public_id)
1141        m.delete()
1142       
1143    @jsonrpc_method('telemeta.get_markers')
1144    def get_markers(request, item_id):
1145        item = MediaItem.objects.get(id=item_id)
1146        markers = MediaItemMarker.objects.filter(item=item)
1147        list = []
1148        for marker in markers:
1149            dict = {}
1150            dict['public_id'] = marker.public_id
1151            dict['time'] = str(marker.time)
1152            dict['title'] = marker.title
1153            dict['description'] = marker.description
1154            dict['author'] = marker.author.username
1155            list.append(dict)
1156        return list
1157
1158    @jsonrpc_method('telemeta.update_marker')
1159    def update_marker(request, marker):
1160        if isinstance(marker, dict):
1161            m = MediaItemMarker.objects.get(public_id=marker['public_id'])
1162            m.time = float(marker['time'])
1163            m.title = marker['title']
1164            m.description = marker['description']
1165            m.save()
1166            m.set_revision(request.user)
1167        else:
1168            raise 'Error : Bad marker dictionnary'
1169 
1170    @jsonrpc_method('telemeta.get_marker_id')
1171    def get_marker_id(request, public_id):
1172        marker = MediaItemMarker.objects.get(public_id=public_id)
1173        return marker.id
1174   
1175class PlaylistView(object):
1176    """Provide Collections web UI methods"""
1177
1178    @jsonrpc_method('telemeta.add_playlist')
1179    def add_playlist(request, playlist):
1180        # playlist must be a dict
1181        if isinstance(playlist, dict):
1182            m = Playlist()
1183            m.public_id = playlist['public_id']
1184            m.title = playlist['title']
1185            m.description = playlist['description']
1186            m.author = request.user
1187            m.save()
1188        else:
1189            raise 'Error : Bad playlist dictionnary'
1190
1191    @jsonrpc_method('telemeta.del_playlist')
1192    def del_playlist(request, public_id):
1193        m = Playlist.objects.get(public_id=public_id)
1194        m.delete()
1195       
1196    @jsonrpc_method('telemeta.update_playlist')
1197    def update_playlist(request, playlist):
1198        if isinstance(playlist, dict):
1199            m = Playlist.objects.get(public_id=playlist['public_id'])
1200            m.title = float(playlist['title'])
1201            m.description = playlist['description']
1202            m.save()
1203        else:
1204            raise 'Error : Bad playlist dictionnary'
1205 
1206    @jsonrpc_method('telemeta.add_playlist_resource')
1207    def add_playlist_resource(request, playlist_id, playlist_resource):
1208        # playlist_resource must be a dict
1209        if isinstance(playlist_resource, dict):
1210            m = PlaylistResource()
1211            m.public_id = playlist_resource['public_id']
1212            m.playlist = Playlist.objects.get(public_id=playlist_id, author=request.user)
1213            m.resource_type = playlist_resource['resource_type']
1214            m.resource_id = playlist_resource['resource_id']
1215            m.save()
1216        else:
1217            raise 'Error : Bad playlist_resource dictionnary'
1218
1219    @jsonrpc_method('telemeta.del_playlist_resource')
1220    def del_playlist_resource(request, public_id):
1221        m = PlaylistResource.objects.get(public_id=public_id)
1222        m.delete()
1223       
1224
1225    def playlist_csv_export(self, request, public_id, resource_type):
1226        playlist = Playlist.objects.get(public_id=public_id, author=request.user)
1227        resources = PlaylistResource.objects.filter(playlist=playlist)
1228        response = HttpResponse(mimetype='text/csv')
1229        response['Content-Disposition'] = 'attachment; filename='+playlist.title+'_'+resource_type+'.csv'
1230        writer = UnicodeWriter(response)
1231       
1232        elements = []
1233        for resource in resources:
1234            if resource_type == 'items':
1235                if resource.resource_type == 'collection':
1236                    collection = MediaCollection.objects.get(id=resource.resource_id)
1237                    collection_items = MediaItem.objects.filter(collection=collection)
1238                    for item in collection_items:
1239                        elements.append(item)
1240                elif resource.resource_type == 'item':
1241                    item = MediaItem.objects.get(id=resource.resource_id)
1242                    elements.append(item)
1243               
1244            elif resource_type == 'collections':
1245                if resource.resource_type == 'collection':
1246                    collection = MediaCollection.objects.get(id=resource.resource_id)
1247                    elements.append(collection)
1248               
1249        if elements:
1250            element = elements[0].to_dict()
1251            tags = element.keys()
1252            # code and title on the two first column
1253            tags.remove('code')
1254            tags.remove('title')
1255            tags.sort()
1256            tags.insert(0, 'title')
1257            tags.insert(0, 'code')
1258            writer.writerow(tags)
1259           
1260            for element in elements:
1261                data = []
1262                element = element.to_dict()
1263                for tag in tags:
1264                    data.append(element[tag])
1265                writer.writerow(data)
1266        return response
1267       
1268
1269class ProfileView(object):
1270    """Provide Collections web UI methods"""
1271
1272    @method_decorator(login_required)
1273    def profile_detail(self, request, username, template='telemeta/profile_detail.html'):
1274        user = User.objects.get(username=username)
1275        try:
1276            profile = user.get_profile()
1277        except:
1278            profile = None
1279        playlists = get_playlists(request, user)
1280        return render(request, template, {'profile' : profile, 'usr': user, 'playlists': playlists})
1281       
1282    def profile_edit(self, request, username, template='telemeta/profile_edit.html'):
1283        if request.user.is_superuser:
1284            user_hidden_fields = ['profile-user', 'user-password', 'user-last_login', 'user-date_joined']
1285        else:
1286            user_hidden_fields = ['user-username', 'user-is_staff', 'profile-user', 'user-is_active', 
1287                         'user-password', 'user-last_login', 'user-date_joined', 'user-groups', 
1288                         'user-user_permissions', 'user-is_superuser', 'profile-expiration_date']
1289       
1290        user = User.objects.get(username=username)
1291        if user != request.user and not request.user.is_staff:
1292            mess = ugettext('Access not allowed') 
1293            title = ugettext('User profile') + ' : ' + username + ' : ' + mess
1294            description = ugettext('Please login or contact the website administator to get a private access.')
1295            messages.error(request, title)
1296            return render(request, 'telemeta/messages.html', {'description' : description})
1297       
1298        try:
1299            profile = user.get_profile()
1300        except:
1301            profile = UserProfile(user=user)
1302           
1303        if request.method == 'POST':
1304            user_form = UserChangeForm(request.POST, instance=user, prefix='user')
1305            profile_form = UserProfileForm(request.POST, instance=profile, prefix='profile')
1306            if user_form.is_valid() and profile_form.is_valid():
1307                user_form.save()
1308                profile_form.save()
1309                return HttpResponseRedirect('/users/'+username+'/profile/')
1310        else:
1311            user_form = UserChangeForm(instance=user, prefix='user')
1312            profile_form = UserProfileForm(instance=profile, prefix='profile')
1313            forms = [user_form, profile_form]
1314        return render(request, template, {'forms': forms, 'usr': user, 'user_hidden_fields': user_hidden_fields})
1315
1316
1317class LastestRevisionsFeed(Feed):
1318    "the RSS feed of the lastest revisions"
1319       
1320    organization = settings.TELEMETA_ORGANIZATION
1321    subjects = settings.TELEMETA_SUBJECTS
1322    tags = ['title', 'description', 'comment']
1323    title = organization + ' - Telemeta - ' + ugettext('Last changes')
1324    link = ""
1325    description = ' '.join([subject.decode('utf-8') for subject in subjects])
1326    n_items = 100
1327
1328    def items(self):
1329        return get_revisions(self.n_items)
1330
1331    def item_title(self, r):
1332        element = r['element']
1333        if element.title == '':
1334            title = str(element.public_id)
1335        else:
1336            title = element.title
1337        return element.element_type + ' : ' + title
1338
1339    def item_description(self, r):
1340        revision = r['revision']
1341        element = r['element']
1342        description = '<b>modified by ' + revision.user.username + ' on ' + unicode(revision.time) + '</b><br /><br />'
1343        dict = element.to_dict()
1344        for tag in dict.keys():
1345            try:
1346                value = dict[tag]
1347                if value != '':
1348                    description += tag + ' : ' + value + '<br />'
1349            except:
1350                continue
1351        return description.encode('utf-8')
1352       
1353    def item_link(self, r):
1354        revision = r['revision']
1355        element = r['element']
1356        link = '/' + revision.element_type + 's/' + str(element.public_id) 
1357        return link
1358       
1359       
Note: See TracBrowser for help on using the repository browser.