Changeset 6d9a741


Ignore:
Timestamp:
04/23/07 10:09:32 (6 years ago)
Author:
olivier <>
Branches:
master, crem, crem2, dev, dev2, diadems, forma, generic, instru_search, lam, nlivemulti, production, release/1.4.4, security, social, storage, test, video
Children:
e789173
Parents:
b503f0b
git-author:
olivier <> (04/23/07 10:09:32)
git-committer:
olivier <> (04/23/07 10:09:32)
Message:
  • coupled the web interface with the export layer
  • improved collections and items browsing
  • minor CSS improvements
  • now using Django typical models instead of "dynamic" ones
  • made simple models based on Dublin Core elements
Location:
telemeta
Files:
3 added
7 edited

Legend:

Unmodified
Added
Removed

  • telemeta/css/style.css

    rf04d8d5 r6d9a741  
    11body { 
    22    font-family: Verdana; 
     3    font-size: 11px; 
    34} 
    45 
    … …  
    1819    margin-bottom: 4px; 
    1920} 
     21 
     22#menu { 
     23    text-align: right; 
     24} 
     25 
     26#menu a:link, #menu a:visited { 
     27    border-bottom:1px dotted #BBBBBB; 
     28    color:#BB0000; 
     29    text-decoration:none; 
     30} 
     31 
     32#menu a:link:hover, #menu a:visited:hover { 
     33    background-color:#EEEEEE; 
     34    color:#555555; 
     35} 
     36 
     37#menu a { 
     38} 

  • telemeta/models.py

    rf04d8d5 r6d9a741  
    11import telemeta 
    22from django.db import models 
    3 from django.core import validators 
     3from telemeta.core import * 
    44 
    5 class Collection(models.Model): 
     5class MediaModel(Component): 
     6    pass 
     7 
     8class MediaCore: 
     9    def list(self): 
     10        fields_list = [] 
     11        for field in self._meta.fields: 
     12            fields_list.append({'name': field.name, 'value': getattr(self, field.name)}) 
     13        return fields_list 
     14 
     15    def to_dict(self):         
     16        fields_dict = {} 
     17        for field in self._meta.fields: 
     18            fields_dict[field.name] = getattr(self, field.name) 
     19        return fields_dict 
     20 
     21class MediaCollection(models.Model, MediaCore): 
    622    "Group related media items" 
    723 
    8     name = models.CharField(maxlength=250) 
     24    title = models.CharField(maxlength=250) 
     25    date = models.DateField() 
     26    contributor = models.CharField(maxlength=250, blank=True) 
     27    coverage = models.CharField(maxlength=250, blank=True) 
     28    creator = models.CharField(maxlength=250, blank=True) 
     29    description = models.CharField(maxlength=250, blank=True) 
     30    format = models.CharField(maxlength=250, blank=True) 
     31    identifier = models.CharField(maxlength=250, blank=True) 
     32    language = models.CharField(maxlength=250, blank=True) 
     33    publisher = models.CharField(maxlength=250, blank=True) 
     34    rights = models.CharField(maxlength=250, blank=True) 
     35    source = models.CharField(maxlength=250, blank=True) 
     36    subject = models.CharField(maxlength=250, blank=True) 
    937 
    1038    def __str__(self): 
    11         return self.name 
     39        return self.title 
     40 
     41    class Meta: 
     42        ordering = ['title'] 
     43        db_table = 'telemeta_collection' 
    1244 
    1345    class Admin: 
    1446        pass 
    1547 
    16 class MediaItem(models.Model): 
    17     "Describe an audio/video item with metadata"  
    18  
    19     collection = models.ForeignKey(Collection) 
    20     title = models.CharField(maxlength=250) 
    21     author = models.CharField(maxlength=250) 
    2248 
    2349 
     50class MediaItem(models.Model, MediaCore): 
     51    "Describe a item with metadata"  
    2452 
    25     def get_dynamic_properties(self): 
    26         "Retrieve dynamic properties associated with a given media item" 
    27  
    28         definitions = MediaItemPropertyDefinition.objects.all() 
    29         assigned = MediaItemProperty.objects.filter(media_item=self) 
    30         assigned_dict = {} 
    31         for p in assigned: 
    32             assigned_dict[p.definition.id] = p 
    33  
    34         properties = [] 
    35         for d in definitions: 
    36             enumeration = MediaItemPropertyEnumerationItem.objects.filter(definition=d) 
    37  
    38             if d.id in assigned_dict: 
    39                 if d.type == "text": 
    40                     value = assigned_dict[d.id].value 
    41                 else: 
    42                     value = assigned_dict[d.id].enum_item 
    43  
    44                 properties.append({ 
    45                     "id": d.id, "name": d.name, "value": value, 
    46                     "type" : d.type, "enumeration" : enumeration}) 
    47             else: 
    48                 properties.append({"id": d.id, "name": d.name, "value": "",  
    49                     "type" : d.type, "enumeration" : enumeration}) 
    50  
    51         return properties 
     53    collection = models.ForeignKey(MediaCollection, related_name="items") 
     54    collection.dublin_core = 'relation' 
     55    identifier = models.CharField(maxlength=250) 
     56    title = models.CharField(maxlength=250) 
     57    creator = models.CharField(maxlength=250) 
     58    date = models.DateField() 
     59    file = models.FileField(upload_to='items/%Y/%m/%d') 
     60    subject = models.CharField(maxlength=250, blank=True) 
     61    description = models.TextField(maxlength=250, blank=True) 
     62    contributor = models.CharField(maxlength=250, blank=True) 
     63    coverage = models.CharField(maxlength=250, blank=True) 
     64    format = models.CharField(maxlength=25, blank=True) 
     65    language = models.CharField(maxlength=250, blank=True) 
     66    publisher = models.CharField(maxlength=250, blank=True) 
     67    rights = models.CharField(maxlength=250, blank=True) 
     68    source = models.CharField(maxlength=250, blank=True) 
     69    duration = models.FloatField(max_digits=11, decimal_places=3, null=True, blank=True) 
    5270 
    5371    def __str__(self): 
    54         return self.author + " - " + self.title 
    55  
    56     class Meta: 
    57         pass 
     72        return self.title 
    5873 
    5974    class Admin: 
    6075        pass 
    6176 
    62 class MediaItemPropertyDefinition(models.Model): 
    63     "Define a media item dynamic property" 
     77    class Meta: 
     78        ordering = ['title'] 
     79        db_table = 'telemeta_item' 
    6480 
    65     TYPE_CHOICES = ( 
    66         ('text', 'Text'), 
    67         ('enumeration', 'Enumeration'), 
    68     )  
    6981 
    70     name = models.CharField(maxlength=64) 
    71     type = models.CharField(maxlength=64, choices = TYPE_CHOICES) 
     82class MediaPart(models.Model, MediaCore): 
     83    "Describe the part of a media item" 
     84 
     85    contributor = models.CharField(maxlength=250) 
     86    coverage = models.CharField(maxlength=250) 
     87    creator = models.CharField(maxlength=250) 
     88    date = models.DateField() 
     89    description = models.CharField(maxlength=250) 
     90    format = models.CharField(maxlength=250) 
     91    identifier = models.CharField(maxlength=250) 
     92    language = models.CharField(maxlength=250) 
     93    publisher = models.CharField(maxlength=250) 
     94    rights = models.CharField(maxlength=250) 
     95    source = models.CharField(maxlength=250) 
     96    subject = models.CharField(maxlength=250) 
     97    title = models.CharField(maxlength=250) 
     98    media_item = models.ForeignKey(MediaItem) 
     99    media_item.dublin_core = 'relation' 
     100    parent = models.ForeignKey('self', null=True, related_name='children') 
     101    media_item.dublin_core = 'relation' 
     102    start = models.FloatField(max_digits=11, decimal_places=3) 
     103    end = models.FloatField(max_digits=11, decimal_places=3) 
    72104 
    73105    def __str__(self): 
    74         return self.name 
     106        return self.title 
     107 
     108    class Meta: 
     109        ordering = ['title'] 
     110        db_table = 'telemeta_part' 
    75111 
    76112    class Admin: 
    77113        pass 
    78114 
    79 class MediaItemPropertyEnumerationItem(models.Model): 
    80     "Define a possible value for media item dynamic enumeration properties" 
    81115 
    82     definition = models.ForeignKey(MediaItemPropertyDefinition, core=True) 
    83     name = models.CharField(maxlength=250) 
    84  
    85     def __str__(self): 
    86         return self.definition.name + " / " + self.name 
    87  
    88     class Admin: 
    89         pass 
    90      
    91 class MediaItemProperty(models.Model): 
    92     "Associate a value to a media item dynamic property" 
    93  
    94     definition = models.ForeignKey(MediaItemPropertyDefinition, core=True) 
    95     media_item = models.ForeignKey(MediaItem) 
    96     value = models.CharField(maxlength=250) 
    97     enum_item = models.ForeignKey(MediaItemPropertyEnumerationItem, null=True) 
    98  
    99     def __str__(self): 
    100         return str(self.media_item) + " / " + str(self.definition) 
    101  
    102     class Meta: 
    103         unique_together = (("media_item", "definition"),) 
    104  
    105     class Admin: 
    106         pass 
    107    
    108  
    109 class Part: 
    110     media_item = models.ForeignKey(MediaItem) 
    111     parent = models.ForeignKey('self', null=True, related_name='children') 
    112     name = models.CharField(maxlength=250) 

  • telemeta/templates/base.html

    rf04d8d5 r6d9a741  
    11<html> 
    2 <link rel="stylesheet" href="/telemeta/css/style.css" /> 
     2<link rel="stylesheet" href="/css/style.css" /> 
    33<body> 
    44<div id="header"> 
    55Telemeta Web Interface 
    66</div> 
     7<div id="menu"> 
     8<a href="/collections">Collections</a> | 
     9<a href="/items">Items</a> 
     10</div> 
    711{% block content %}{% endblock %} 
    812</body> 

  • telemeta/templates/index.html

    rf04d8d5 r6d9a741  
    1 <pre>{% debug %}</pre> 
     1{% extends "base.html" %} 
    22 
    3 <h3>Pieces</h3> 
    4 {% if pieces %} 
     3{% block content %} 
     4<h3>Media items</h3> 
     5{% if object_list %} 
    56    <ul> 
    6     {% for p in pieces %} 
    7         <li><b>{{ p.author }}</b> - {{ p.title }}</li> 
     7    {% for p in object_list %} 
     8        <li><b>{{ p.author }}</b> - {{ p.title }} 
     9            <a href="{{ p.id }}">View</a> 
     10            <a href="#">Edit</a> 
     11            </li> 
    812    {% endfor %} 
    913    </ul> 
    1014{% else %} 
    11     <p>No pieces are available.</p> 
     15    <p>No media item available.</p> 
    1216{% endif %} 
     17{% endblock %} 

  • telemeta/templates/mediaitem_list.html

    rf04d8d5 r6d9a741  
    66    <ul> 
    77    {% for p in object_list %} 
    8         <li><b>{{ p.author }}</b> - {{ p.title }} 
     8        <li><b>{{ p.creator }}</b> - {{ p.title }} 
    99            <a href="{{ p.id }}">View</a> 
    1010            <a href="#">Edit</a> 

  • telemeta/urls.py

    rf04d8d5 r6d9a741  
    11from django.conf.urls.defaults import * 
    2 from telemeta.models import MediaItem 
     2from telemeta.models import MediaItem, MediaCollection 
    33 
    4 list_dict = { 
     4all_items = { 
    55    'queryset': MediaItem.objects.all(), 
     6} 
     7 
     8all_collections = { 
     9    'queryset': MediaCollection.objects.all(), 
    610} 
    711 
    812urlpatterns = patterns('', 
    913    (r'^$', 'telemeta.views.web.index'), 
    10     (r'^media_item/$', 'django.views.generic.list_detail.object_list',  
    11         dict(list_dict, paginate_by=10, template_name="mediaitem_list.html")), 
    12     (r'^media_item/(?P<media_item_id>[0-9]+)/$', 'telemeta.views.web.media_item_edit'), 
     14    (r'^items/$', 'django.views.generic.list_detail.object_list',  
     15        dict(all_items, paginate_by=10, template_name="mediaitem_list.html")), 
     16    (r'^items/(?P<item_id>[0-9]+)/$', 'telemeta.views.web.item_detail'), 
     17    (r'^items/(?P<item_id>[0-9]+)/download/(?P<format>[0-9A-Z]+)/$',  
     18        'telemeta.views.web.item_export'), 
     19    #(r'^media_item/(?P<media_item_id>[0-9]+)/$', 'telemeta.views.web.media_item_edit'), 
    1320    (r'^media_item/(?P<media_item_id>[0-9]+)/update/$', 'telemeta.views.web.media_item_update'), 
     21 
     22    (r'^collections/$', 'django.views.generic.list_detail.object_list', 
     23        dict(all_collections, paginate_by=10, template_name="collection_list.html")), 
     24    (r'^collections/(?P<object_id>[0-9]+)/$',  
     25        'django.views.generic.list_detail.object_detail', 
     26        dict(all_collections, template_name="collection_detail.html")), 
     27 
    1428 
    1529    # CSS (FIXME: for developement only) 

  • telemeta/views/web.py

    rf04d8d5 r6d9a741  
    33from django.template import Context, loader 
    44from django.http import HttpResponse 
     5from django.http import Http404 
    56from telemeta.models import MediaItem 
    6 from telemeta.models import MediaItemPropertyDefinition 
    7 from telemeta.models import MediaItemPropertyEnumerationItem 
    8 from telemeta.models import MediaItemProperty 
    97from django.shortcuts import render_to_response 
    108import re 
     9from telemeta.core import * 
     10from telemeta.core import ComponentManager 
     11from telemeta.export import * 
     12from django.conf import settings 
     13import os 
    1114 
    1215def index(request): 
    … …  
    1922    }) 
    2023    return HttpResponse(template.render(context)) 
     24 
     25class WebView(Component): 
     26 
     27    exporters = ExtensionPoint(IExporter) 
     28 
     29    def item_detail(self, request, item_id): 
     30        item = MediaItem.objects.get(pk=item_id) 
     31        formats = [] 
     32        for exporter in self.exporters: 
     33            formats.append(exporter.get_format()) 
     34        return render_to_response('mediaitem_detail.html',  
     35                    {'item': item, 'export_formats': formats}) 
     36 
     37    def file_stream(self, filepath): 
     38        buffer_size = 0xFFFF 
     39        f = open(filepath, 'rb') 
     40        chunk = f.read(buffer_size) 
     41        yield chunk 
     42        while chunk: 
     43            chunk = f.read(buffer_size) 
     44            yield chunk 
     45        f.close()             
     46 
     47    def item_export(self, request, item_id, format):                     
     48        for exporter in self.exporters: 
     49            if exporter.get_format() == format: 
     50                break 
     51 
     52        if exporter.get_format() != format: 
     53            raise Http404 
     54 
     55        mime_type = exporter.get_mime_type() 
     56 
     57        exporter.set_cache_dir(settings.TELEMETA_EXPORT_CACHE_DIR) 
     58 
     59        item = MediaItem.objects.get(pk=item_id) 
     60 
     61        infile = settings.MEDIA_ROOT + "/" + item.file 
     62        metadata = item.to_dict() 
     63        metadata['collection'] = str(metadata['collection']) 
     64        metadata['Collection'] = metadata['collection'] 
     65        metadata['Artist'] = metadata['creator'] 
     66        metadata['Title'] = metadata['title'] 
     67 
     68        outfile = exporter.process(item.id, infile, metadata, []) 
     69 
     70        return HttpResponse(self.file_stream(outfile), mimetype = mime_type) 
     71 
     72comp_mgr = ComponentManager() 
     73view = WebView(comp_mgr) 
     74item_detail = view.item_detail 
     75item_export = view.item_export 
    2176 
    2277def media_item_edit(request, media_item_id): 
Note: See TracChangeset for help on using the changeset viewer.