Analyzers are now managed though the DB. Please syncdb before continue.

diff --git a/telemeta/cache.py b/telemeta/cache.py
index 83946785569309bce4c4bd0576e76e55bbb181db..dcd8e3b4007e51c9133b2093d22dd1b2ec06d1d8 100644 (file)
--- a/telemeta/cache.py
+++ b/telemeta/cache.py
@@ -105,6 +105,12 @@ class TelemetaCache(object):
         
     def write_analyzer_xml(self, data_list, file):
         path = self.dir + os.sep + file
+        data = self.get_analyzer_xml(data_list)
+        f = open(path, "w")
+        f.write(data)
+        f.close()
+
+    def get_analyzer_xml(self, data_list):
         doc = xml.dom.minidom.Document()
         root = doc.createElement('telemeta')
         doc.appendChild(root)
@@ -119,6 +125,4 @@ class TelemetaCache(object):
             node.setAttribute('unit', unit)
             node.setAttribute('value', str(value))
             root.appendChild(node)
-        f = open(path, "w")
-        f.write(xml.dom.minidom.Document.toprettyxml(doc))
-        f.close()
+        return xml.dom.minidom.Document.toprettyxml(doc)

diff --git a/telemeta/models/media.py b/telemeta/models/media.py
index ad922f35b1b9e9f39d927639cbf7bf99eeb05511..eb37a53bff05651066ed134ad9bc1cf541e8570f 100644 (file)
--- a/telemeta/models/media.py
+++ b/telemeta/models/media.py
@@ -369,12 +369,16 @@ class MediaItemAnalysis(ModelCore):
     element_type = 'analysis'    
     item  = ForeignKey('MediaItem', related_name="analysis", verbose_name=_('item'))
     analyzer_id = CharField(_('id'), required=True)
-    analyzer_name = CharField(_('name'))
-    analyzer_value = CharField(_('value'))
-    analyzer_unit = CharField(_('unit'))
+    name = CharField(_('name'))
+    value = CharField(_('value'))
+    unit = CharField(_('unit'))
     
     class Meta(MetaCore):
         db_table = 'media_analysis'
+        ordering = ['name']
+        
+    def to_dict(self):
+        return {'id': self.analyzer_id, 'name': self.name, 'value': self.value, 'unit': self.unit}
         
         
 class MediaPart(MediaResource):

diff --git a/telemeta/web/base.py b/telemeta/web/base.py
index 6e5a8f608bf62e92004671f9786de331c098480e..c35a1af422cfc093d3386f9114e652fac110949c 100644 (file)
--- a/telemeta/web/base.py
+++ b/telemeta/web/base.py
@@ -270,13 +270,13 @@ class WebView(object):
             grapher_id = 'waveform'
         
         previous, next = self.item_previous_next(item)
-        analyzers = self.item_analyze(item)
+        self.item_analyze(item)
         playlists = self.get_playlists(request)
         public_access = self.get_public_access(item.public_access, item.recorded_from_date, item.recorded_to_date)
                 
         return render(request, template,
                     {'item': item, 'export_formats': formats,
-                    'visualizers': graphers, 'visualizer_id': grapher_id,'analysers': analyzers,
+                    'visualizers': graphers, 'visualizer_id': grapher_id,
                     'audio_export_enabled': getattr(settings, 'TELEMETA_DOWNLOAD_ENABLED', True),
                     'previous' : previous, 'next' : next, 'marker': marker_id, 'playlists' : playlists, 
                     'public_access': public_access,
@@ -321,7 +321,7 @@ class WebView(object):
             grapher_id = 'waveform'
         
         previous, next = self.item_previous_next(item)
-        analyzers = self.item_analyze(item)
+        self.item_analyze(item)
         
         if request.method == 'POST':
             form = MediaItemForm(data=request.POST, files=request.FILES, instance=item)
@@ -391,15 +391,13 @@ class WebView(object):
         return render(request, template, {'item': item, "form": form})
         
     def item_analyze(self, item):
-        public_id = str(item.public_id)
-        analyze_file = public_id + '.xml'
+        analyses = MediaItemAnalysis.objects.filter(item=item)
         
-        if self.cache_data.exists(analyze_file):
-            analyzers = self.cache_data.read_analyzer_xml(analyze_file)
+        if analyses:
             if not item.approx_duration:
-                for analyzer in analyzers:
-                    if analyzer['id'] == 'duration':
-                        value = analyzer['value']
+                for analysis in analyses:
+                    if analysis.id == 'duration':
+                        value = analysis.value
                         time = value.split(':')
                         time[2] = time[2].split('.')[0]
                         time = ':'.join(time)
@@ -418,8 +416,10 @@ class WebView(object):
                 pipe.run()
 
                 mime_type = decoder.format()
-                analyzers.append({'name': 'Mime type', 'id': 'mime_type', 'unit': '', 'value': mime_type})
-                analyzers.append({'name': 'Channels', 'id': 'channels', 'unit': '', 'value': decoder.channels()})
+                analysis = MediaItemAnalysis(item=item, name='MimeType', analyzer_id='mime_type', unit='', value=mime_type)
+                analysis.save()
+                analysis = MediaItemAnalysis(item=item, name='Channels', analyzer_id='channels', unit='', value=decoder.channels())
+                analysis.save()
                 
                 for analyzer in analyzers_sub:
                     value = analyzer.result()
@@ -432,22 +432,18 @@ class WebView(object):
                             pass
                         value = datetime.timedelta(0,value)
                     
-                    analyzers.append({'name':analyzer.name(),
-                                      'id':analyzer.id(),
-                                      'unit':analyzer.unit(),
-                                      'value':str(value)})
-                  
-                self.cache_data.write_analyzer_xml(analyzers, analyze_file)
-            
-        return analyzers
-    
+                    analysis = MediaItemAnalysis(item=item, name=analyzer.name(), analyzer_id=analyzer.id(), 
+                                                 unit=analyzer.unit(), value=str(value))
+                    analysis.save()
+        
     def item_analyze_xml(self, request, public_id):
         item = MediaItem.objects.get(public_id=public_id)
-        analyze_file = public_id + '.xml'
-        if not self.cache_data.exists(analyze_file):
-            self.item_analyze(item)
+        analyses = MediaItemAnalysis.objects.filter(item=item)
+        analyzers = []
+        for analysis in analyses:
+            analyzers.append(analysis.to_dict())
         mime_type = 'text/xml'
-        response = HttpResponse(self.cache_data.read_stream_bin(analyze_file), mimetype=mime_type)
+        response = HttpResponse(self.cache_data.get_analyzer_xml(analyzers), mimetype=mime_type)
         response['Content-Disposition'] = 'attachment; filename='+public_id+'.xml'        
         return response