make a CBV for item detail view

diff --git a/telemeta/urls.py b/telemeta/urls.py
index 1a194ff051a88bbf243f1524f46d455dc5e485d3..301466396f72f91e9eca039c5745c7b1bd7e2ca3 100644 (file)
--- a/telemeta/urls.py
+++ b/telemeta/urls.py
@@ -74,7 +74,7 @@ urlpatterns = patterns('',
     url(r'^archives/items_unpublished/$', ItemUnpublishedListView.as_view(), name="telemeta-items-unpublished"),
     url(r'^archives/items_published/$', ItemPublishedListView.as_view(), name="telemeta-items-published"),
 
-    url(r'^archives/items/(?P<public_id>[A-Za-z0-9._-]+)/$', item_view.item_detail, name="telemeta-item-detail"),
+    url(r'^archives/items/(?P<public_id>[A-Za-z0-9._-]+)/$', ItemDetailView.as_view(), name="telemeta-item-detail"),
     url(r'^archives/items/(?P<public_id>[A-Za-z0-9._-]+)/dc/$', item_view.item_detail, {'template': 'telemeta/mediaitem_detail_dc.html'}, name="telemeta-item-dublincore"),
     url(r'^archives/items/(?P<public_id>[A-Za-z0-9._-]+)/dc/xml/$', item_view.item_detail, {'format': 'dublin_core_xml'}, name="telemeta-item-dublincore-xml"),
     url(r'^archives/items/download/(?P<public_id>[A-Za-z0-9._-]+)\.(?P<extension>' + export_extensions + ')$', item_view.item_export, name="telemeta-item-export"),

diff --git a/telemeta/views/collection.py b/telemeta/views/collection.py
index 78824fb35047157e7875340c363d85e3fc11a20b..a3cf0567fa5b7ec2f7c44e16de1dc2111dc38aed 100644 (file)
--- a/telemeta/views/collection.py
+++ b/telemeta/views/collection.py
@@ -281,14 +281,6 @@ class CollectionDetailView(CollectionViewMixin, DetailView):
         items = collection.items.enriched()
         context['collection'] = collection
         context['items'] = items.order_by('code', 'old_code')
-
-        if collection.public_access == 'none' and not (self.request.user.is_staff or self.request.user.is_superuser):
-            mess = ugettext('Access not allowed')
-            title = ugettext('Collection') + ' : ' + collection.public_id + ' : ' + mess
-            description = ugettext('Please login or contact the website administator to get a private access.')
-            messages.error(self.request, title)
-            return render(self.request, 'telemeta/messages.html', {'description' : description})
-
         context['playlists'] = get_playlists_names(self.request)
         context['related_media'] = MediaCollectionRelated.objects.filter(collection=collection)
         check_related_media(context['related_media'])

diff --git a/telemeta/views/core.py b/telemeta/views/core.py
index f5c5eae3ebcec85607b0dc8311eb2b4cad206928..6979598a0b41061175fb911c1878b2b38ed74c80 100644 (file)
--- a/telemeta/views/core.py
+++ b/telemeta/views/core.py
@@ -278,3 +278,9 @@ def get_room(content_type=None, id=None, name=None):
         room = rooms[0]
     return room
 
+
+def get_kwargs_or_none(key, kwargs):
+    if key in kwargs.keys():
+        return kwargs[key]
+    else:
+        return None
\ No newline at end of file

diff --git a/telemeta/views/item.py b/telemeta/views/item.py
index 74f20a5814246613c629c5f897ffe29885a69b26..438edf744fb407a73230921bb1f1ee9cab4fa65c 100644 (file)
--- a/telemeta/views/item.py
+++ b/telemeta/views/item.py
@@ -476,7 +476,6 @@ class ItemView(ItemBaseMixin):
                 path = self.cache_data.dir + os.sep + image_file
                 decoder  = timeside.decoder.file.FileDecoder(source)
                 graph = grapher(width = int(width), height = int(height))
-                print graph.id()
                 (decoder | graph).run()
                 graph.watermark('timeside', opacity=.6, margin=(5,5))
                 f = open(path, 'w')
@@ -781,3 +780,160 @@ class ItemCopyView(ItemAddView):
     def get_success_url(self):
         return reverse_lazy('telemeta-items')
 
+
+class ItemDetailView(ItemViewMixin, DetailView):
+
+    template_name = 'telemeta/mediaitem_detail.html'
+
+    def item_analyze(self, item):
+        analyses = item.analysis.all()
+        mime_type = ''
+
+        if analyses:
+            for analysis in analyses:
+                if not item.approx_duration and analysis.analyzer_id == 'duration':
+                    value = analysis.value
+                    time = value.split(':')
+                    time[2] = time[2].split('.')[0]
+                    time = ':'.join(time)
+                    item.approx_duration = time
+                    item.save()
+                if analysis.analyzer_id == 'mime_type':
+                    mime_type = analysis.value
+        else:
+            analyzers = []
+            analyzers_sub = []
+            graphers_sub = []
+
+            source = item.get_source()
+            if source:
+                decoder  = timeside.decoder.file.FileDecoder(source)
+                pipe = decoder
+
+                for analyzer in self.value_analyzers:
+                    subpipe = analyzer()
+                    analyzers_sub.append(subpipe)
+                    pipe = pipe | subpipe
+
+                default_grapher = self.get_grapher(self.default_grapher_id)
+                for size in self.default_grapher_sizes:
+                    width = size.split('x')[0]
+                    height = size.split('x')[1]
+                    image_file = '.'.join([item.public_id, self.default_grapher_id, size.replace('x', '_'), 'png'])
+                    path = self.cache_data.dir + os.sep + image_file
+                    graph = default_grapher(width = int(width), height = int(height))
+                    graphers_sub.append({'graph' : graph, 'path': path})
+                    pipe = pipe | graph
+
+                pipe.run()
+
+                for grapher in graphers_sub:
+                    grapher['graph'].watermark('timeside', opacity=.6, margin=(5,5))
+                    f = open(grapher['path'], 'w')
+                    grapher['graph'].render(grapher['path'])
+                    f.close()
+
+                mime_type = mimetypes.guess_type(source)[0]
+                analysis = MediaItemAnalysis(item=item, name='MIME type',
+                                             analyzer_id='mime_type', unit='', value=mime_type)
+                analysis.save()
+                analysis = MediaItemAnalysis(item=item, name='Channels',
+                                             analyzer_id='channels',
+                                             unit='', value=decoder.input_channels)
+                analysis.save()
+                analysis = MediaItemAnalysis(item=item, name='Samplerate',
+                                             analyzer_id='samplerate', unit='Hz',
+                                             value=unicode(decoder.input_samplerate))
+                analysis.save()
+                analysis = MediaItemAnalysis(item=item, name='Resolution',
+                                             analyzer_id='resolution', unit='bits',
+                                             value=unicode(decoder.input_width))
+                analysis.save()
+                analysis = MediaItemAnalysis(item=item, name='Duration',
+                                             analyzer_id='duration', unit='s',
+                                             value=unicode(datetime.timedelta(0,decoder.input_duration)))
+                analysis.save()
+                analysis = MediaItemAnalysis(item=item, name='Size',
+                                             analyzer_id='size', unit='', value=item.size())
+                analysis.save()
+
+                for analyzer in analyzers_sub:
+                    for key in analyzer.results.keys():
+                        result = analyzer.results[key]
+                        value = result.data_object.value
+                        if value.shape[0] == 1:
+                            value = value[0]
+                        analysis = MediaItemAnalysis(item=item, name=result.name,
+                                analyzer_id=result.id, unit=result.unit, value = unicode(value))
+                        analysis.save()
+
+#                FIXME: parse tags on first load
+#                tags = decoder.tags
+
+        self.mime_type = mime_type
+
+    def get_context_data(self, **kwargs):
+        context = super(ItemDetailView, self).get_context_data(**kwargs)
+
+        public_id = get_kwargs_or_none('public_id', self.kwargs)
+        marker_id = get_kwargs_or_none('marker_id', self.kwargs)
+        width = get_kwargs_or_none('width', self.kwargs)
+        height = get_kwargs_or_none('height', self.kwargs)
+
+        # get item with one of its given marker_id
+        if not public_id and marker_id:
+            marker = MediaItemMarker.objects.get(public_id=marker_id)
+            item_id = marker.item_id
+            item = MediaItem.objects.get(id=item_id)
+        else:
+            item = MediaItem.objects.get(public_id=public_id)
+
+        access = get_item_access(item, self.request.user)
+
+        if access == 'none':
+            mess = ugettext('Access not allowed.')
+            title = ugettext('Item') + ' : ' + public_id + ' : ' + mess
+            description = ugettext('Please login or contact the website administator to get a private access.')
+            message = title + '\n' + description
+            messages.error(self.request, title)
+            context['access'] = None
+
+        previous, next = self.item_previous_next(item)
+
+        self.item_analyze(item)
+
+        #FIXME: use mimetypes.guess_type
+        if 'quicktime' in self.mime_type:
+            self.mime_type = 'video/mp4'
+
+        playlists = get_playlists_names(self.request)
+        related_media = MediaItemRelated.objects.filter(item=item)
+        check_related_media(related_media)
+        revisions = Revision.objects.filter(element_type='item', element_id=item.id).order_by('-time')
+        if revisions:
+            last_revision = revisions[0]
+        else:
+            last_revision = None
+
+        format = ''
+        if Format.objects.filter(item=item):
+            format = item.format.get()
+
+        context['item'] = item
+        context['export_formats'] = self.get_export_formats()
+        context['visualizers'] = self.get_graphers()
+        context['auto_zoom'] = self.auto_zoom
+        context['audio_export_enabled'] = self.export_enabled
+        context['previous'] = previous
+        context['next'] = next
+        context['marker'] = marker_id
+        context['playlists'] = playlists
+        context['access'] = access
+        context['width'] = width
+        context['height'] = height
+        context['related_media'] = related_media
+        context['mime_type'] = self.mime_type
+        context['last_revision'] = last_revision
+        context['format'] = format
+
+        return context
\ No newline at end of file