from django.conf.urls.defaults import *
from telemeta.models import MediaItem, MediaCollection, MediaItemMarker
-from telemeta.web.base import WebView, LastestRevisionsFeed
+from telemeta.web.base import GeneralView, AdminView, CollectionView, ItemView, \
+ InstrumentView, PlaylistView, ProfileView, GeoView, \
+ LastestRevisionsFeed
from jsonrpc import jsonrpc_site
import os.path
import telemeta.config
telemeta.config.check()
# initialization
-web_view = WebView()
+general_view = GeneralView()
+admin_view = AdminView()
+collection_view = CollectionView()
+item_view = ItemView()
+instrument_view = InstrumentView()
+playlist_view = PlaylistView()
+profile_view = ProfileView()
+geo_view = GeoView()
# query sets for Django generic views
all_items = { 'queryset': MediaItem.objects.enriched().order_by('code', 'old_code') }
# ID's regular expressions
-export_extensions = "|".join(web_view.list_export_extensions())
+export_extensions = "|".join(item_view.list_export_extensions())
htdocs = os.path.dirname(__file__) + '/htdocs'
urlpatterns = patterns('',
- url(r'^$', web_view.index, name="telemeta-home"),
+ url(r'^$', general_view.index, name="telemeta-home"),
# items
url(r'^items/$', 'django.views.generic.list_detail.object_list',
dict(all_items, paginate_by=20, template_name="telemeta/mediaitem_list.html"),
name="telemeta-items"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/$', web_view.item_detail,
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/$', item_view.item_detail,
name="telemeta-item-detail"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/dc/$', web_view.item_detail,
+ url(r'^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'^items/(?P<public_id>[A-Za-z0-9._-]+)/dc/xml/$', web_view.item_detail,
+ url(r'^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'^items/download/(?P<public_id>[A-Za-z0-9._-]+)\.(?P<extension>'
+ export_extensions + ')$',
- web_view.item_export,
+ item_view.item_export,
name="telemeta-item-export"),
url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/visualize/(?P<visualizer_id>[0-9a-z_]+)/(?P<width>[0-9A-Z]+)x(?P<height>[0-9A-Z]+)/$',
- web_view.item_visualize,
+ item_view.item_visualize,
name="telemeta-item-visualize"),
url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/analyze/xml/$',
- web_view.item_analyze_xml,
+ item_view.item_analyze_xml,
name="telemeta-item-analyze-xml"),
url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/item_xspf.xml$',
- web_view.item_playlist,
+ item_view.item_playlist,
dict(template="telemeta/mediaitem_xspf.xml", mimetype="application/xspf+xml"),
name="telemeta-item-xspf"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/edit/$', web_view.item_edit,
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/edit/$', item_view.item_edit,
dict(template='telemeta/mediaitem_edit.html'), name="telemeta-item-edit"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/copy/$', web_view.item_copy,
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/copy/$', item_view.item_copy,
dict(template='telemeta/mediaitem_copy.html'), name="telemeta-item-copy"),
- url(r'^item/add/$', web_view.item_add,
+ url(r'^item/add/$', item_view.item_add,
dict(template='telemeta/mediaitem_add.html'), name="telemeta-item-add"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/player/(?P<width>[0-9]+)x(?P<height>[0-9]+)/$', web_view.item_detail,
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/player/(?P<width>[0-9]+)x(?P<height>[0-9]+)/$', item_view.item_detail,
dict(template='telemeta/mediaitem_player.html'), name="telemeta-item-player"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/performances/$', web_view.item_performances_edit,
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/performances/$', item_view.item_performances_edit,
dict(template='telemeta/mediaitem_performances_edit.html'), name="telemeta-item-performances_edit"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/keywords/$', web_view.item_keywords_edit,
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/keywords/$', item_view.item_keywords_edit,
dict(template='telemeta/mediaitem_keywords_edit.html'), name="telemeta-item-keywords_edit"),
- url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/delete/$', web_view.item_delete, name="telemeta-item-delete"),
+ url(r'^items/(?P<public_id>[A-Za-z0-9._-]+)/delete/$', item_view.item_delete, name="telemeta-item-delete"),
# Markers
- url(r'^markers/(?P<marker_id>[A-Za-z0-9]+)/$', web_view.item_detail, name="telemeta-item-detail-marker"),
+ url(r'^markers/(?P<marker_id>[A-Za-z0-9]+)/$', item_view.item_detail, name="telemeta-item-detail-marker"),
# collections
url(r'^collections/$', 'django.views.generic.list_detail.object_list',
url(r'^collections/?page=(?P<page>[0-9]+)$',
'django.views.generic.list_detail.object_list',
dict(all_collections, paginate_by=20)),
- url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/$', web_view.collection_detail,
+ url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/$', collection_view.collection_detail,
dict(template="telemeta/collection_detail.html"), name="telemeta-collection-detail"),
- url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/dc/$', web_view.collection_detail,
+ url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/dc/$', collection_view.collection_detail,
dict(template="telemeta/collection_detail_dc.html"), name="telemeta-collection-dublincore"),
url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/collection_xspf.xml$',
- web_view.collection_playlist,
+ collection_view.collection_playlist,
dict(template="telemeta/collection_xspf.xml", mimetype="application/xspf+xml"),
name="telemeta-collection-xspf"),
url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/collection.m3u$',
- web_view.collection_playlist,
+ collection_view.collection_playlist,
dict(template="telemeta/collection.m3u", mimetype="audio/mpegurl"),
name="telemeta-collection-m3u"),
- url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/edit/$', web_view.collection_edit,
+ url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/edit/$', collection_view.collection_edit,
dict(template='telemeta/collection_edit.html'), name="telemeta-collection-edit"),
- url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/copy/$', web_view.collection_copy,
+ url(r'^collections/(?P<public_id>[A-Za-z0-9._-]+)/copy/$', collection_view.collection_copy,
dict(template='telemeta/collection_edit.html'), name="telemeta-collection-copy"),
- url(r'^collection/add/$', web_view.collection_add,
+ url(r'^collection/add/$', collection_view.collection_add,
dict(template='telemeta/collection_add.html'), name="telemeta-collection-add"),
- url(r'^collection/(?P<public_id>[A-Za-z0-9._-]+)/add_item/$', web_view.item_add,
+ url(r'^collection/(?P<public_id>[A-Za-z0-9._-]+)/add_item/$', item_view.item_add,
dict(template='telemeta/mediaitem_add.html'), name="telemeta-collection-additem"),
# search
- url(r'^search/$', web_view.search, name="telemeta-search"),
- url(r'^search/collections/$', web_view.search, {'type': 'collections'},
+ url(r'^search/$', general_view.search, name="telemeta-search"),
+ url(r'^search/collections/$', general_view.search, {'type': 'collections'},
name="telemeta-search-collections"),
- url(r'^search/items/$', web_view.search, {'type': 'items'},
+ url(r'^search/items/$', general_view.search, {'type': 'items'},
name="telemeta-search-items"),
- url(r'^search/criteria/$', web_view.edit_search, name="telemeta-search-criteria"),
- url(r'^complete_location/$', web_view.complete_location, name="telemeta-complete-location"),
+ url(r'^search/criteria/$', general_view.edit_search, name="telemeta-search-criteria"),
+ url(r'^complete_location/$', general_view.complete_location, name="telemeta-complete-location"),
# administration
- url(r'^admin/$', web_view.admin_index, name="telemeta-admin"),
- url(r'^admin/general/$', web_view.admin_general, name="telemeta-admin-general"),
- url(r'^admin/enumerations/$', web_view.admin_enumerations, name="telemeta-admin-enumerations"),
- url(r'^admin/users/$', web_view.admin_users, name="telemeta-admin-users"),
+ url(r'^admin/$', admin_view.admin_index, name="telemeta-admin"),
+ url(r'^admin/general/$', admin_view.admin_general, name="telemeta-admin-general"),
+ url(r'^admin/enumerations/$', admin_view.admin_enumerations, name="telemeta-admin-enumerations"),
+ url(r'^admin/users/$', admin_view.admin_users, name="telemeta-admin-users"),
# instruments administration
url(r'^admin/instruments/$',
- web_view.edit_instrument ,
+ instrument_view.edit_instrument ,
name="telemeta-instrument-edit"),
url(r'^admin/instruments/add/$',
- web_view.add_to_instrument,
+ instrument_view.add_to_instrument,
name="telemeta-instrument-add"),
url(r'^admin/instruments/update/$',
- web_view.update_instrument,
+ instrument_view.update_instrument,
name="telemeta-instrument-update"),
url(r'^admin/instruments/'
+ r'(?P<value_id>[0-9]+)/$',
- web_view.edit_instrument_value,
+ instrument_view.edit_instrument_value,
name="telemeta-instrument-record-edit"),
url(r'^admin/instruments/'
+ r'(?P<value_id>[0-9]+)/update/$',
- web_view.update_instrument_value,
+ instrument_view.update_instrument_value,
name="telemeta-instrument-record-update"),
# enumerations administration
url(r'^admin/enumerations/(?P<enumeration_id>[0-9a-z]+)/$',
- web_view.edit_enumeration ,
+ admin_view.edit_enumeration ,
name="telemeta-enumeration-edit"),
url(r'^admin/enumerations/(?P<enumeration_id>[0-9a-z]+)/add/$',
- web_view.add_to_enumeration,
+ admin_view.add_to_enumeration,
name="telemeta-enumeration-add"),
url(r'^admin/enumerations/(?P<enumeration_id>[0-9a-z]+)/update/$',
- web_view.update_enumeration,
+ admin_view.update_enumeration,
name="telemeta-enumeration-update"),
url(r'^admin/enumerations/(?P<enumeration_id>[0-9a-z]+)/'
+ r'(?P<value_id>[0-9]+)/$',
- web_view.edit_enumeration_value,
+ admin_view.edit_enumeration_value,
name="telemeta-enumeration-record-edit"),
url(r'^admin/enumerations/(?P<enumeration_id>[0-9a-z]+)/'
+ r'(?P<value_id>[0-9]+)/update/$',
- web_view.update_enumeration_value,
+ admin_view.update_enumeration_value,
name="telemeta-enumeration-record-update"),
# Geographic browsing
- url(r'^geo/$', web_view.list_continents, name="telemeta-geo-continents"),
- url(r'^geo/(?P<continent>[a-z_]+)/$', web_view.list_countries,
+ url(r'^geo/$', geo_view.list_continents, name="telemeta-geo-continents"),
+ url(r'^geo/(?P<continent>[a-z_]+)/$', geo_view.list_countries,
name="telemeta-geo-countries"),
url(r'^geo/collections/(?P<continent>[a-z_]+)/(?P<country>[a-z_]+)/$',
- web_view.list_country_collections,
+ geo_view.list_country_collections,
name="telemeta-geo-country-collections"),
url(r'^geo/items/(?P<continent>[a-z_]+)/(?P<country>[a-z_]+)/$',
- web_view.list_country_items,
+ geo_view.list_country_items,
name="telemeta-geo-country-items"),
url(r'^geo/country_info/(?P<id>[0-9a-z]+)/$',
- web_view.country_info, name="telemeta-country-info"),
+ geo_view.country_info, name="telemeta-country-info"),
# CSS+Images (FIXME: for developement only)
url(r'^css/(?P<path>.*)$', 'django.views.static.serve',
name="telemeta-timeside"),
# Flat pages
- url(r'^pages/(?P<path>.*)$', web_view.render_flatpage, name="telemeta-flatpage"),
+ url(r'^pages/(?P<path>.*)$', general_view.render_flatpage, name="telemeta-flatpage"),
# OAI-PMH Data Provider
- url(r'^oai/.*$', web_view.handle_oai_request, name="telemeta-oai"),
+ url(r'^oai/.*$', general_view.handle_oai_request, name="telemeta-oai"),
# Authentication
url(r'^login/$', 'django.contrib.auth.views.login', {'template_name': 'telemeta/login.html'},
name="telemeta-login"),
- url(r'^logout/$', web_view.logout, name="telemeta-logout"),
+ url(r'^logout/$', general_view.logout, name="telemeta-logout"),
# Profile
- url(r'^accounts/(?P<username>[A-Za-z0-9._-]+)/profile/$', web_view.profile_detail, name="telemeta-profile-detail"),
- url(r'^accounts/(?P<username>[A-Za-z0-9._-]+)/profile/edit/$', web_view.profile_edit, name="telemeta-profile-edit"),
+ url(r'^accounts/(?P<username>[A-Za-z0-9._-]+)/profile/$', profile_view.profile_detail, name="telemeta-profile-detail"),
+ url(r'^accounts/(?P<username>[A-Za-z0-9._-]+)/profile/edit/$', profile_view.profile_edit, name="telemeta-profile-edit"),
# Registration
url(r'^accounts/password_change/$', 'django.contrib.auth.views.password_change', {'template_name': 'telemeta/registration/password_change_form.html'}, name="telemeta-password-change"),
# url(r'json/browse/', 'jsonrpc.views.browse', name="jsonrpc_browser"),
# Playlists
- url(r'^playlists/(?P<public_id>[a-zA-Z0-9]+)/(?P<resource_type>[a-zA-Z0-9]+)/csv/$', web_view.playlist_csv_export, name="telemeta-playlist-csv-export"),
+ url(r'^playlists/(?P<public_id>[a-zA-Z0-9]+)/(?P<resource_type>[a-zA-Z0-9]+)/csv/$', playlist_view.playlist_csv_export, name="telemeta-playlist-csv-export"),
# RSS feeds
url(r'^rss/$', LastestRevisionsFeed(), name="telemeta-rss"),
break
yield __chunk
-
-class WebView(object):
- """Provide web UI methods"""
+def get_public_access(access, year_from=None, year_to=None):
+ # Rolling publishing date : public access is given when time between recorded year
+ # and current year is over the settings value PUBLIC_ACCESS_PERIOD
+ if year_from and not year_from == 0:
+ year = year_from
+ elif year_to and not year_to == 0:
+ year = year_to
+ else:
+ year = 0
+ if access == 'full':
+ public_access = True
+ else:
+ public_access = False
+ if year and not year == 'None':
+ year_now = datetime.datetime.now().strftime("%Y")
+ if int(year_now) - int(year) >= settings.TELEMETA_PUBLIC_ACCESS_PERIOD:
+ public_access = True
+ else:
+ public_access = False
+ return public_access
- graphers = timeside.core.processors(timeside.api.IGrapher)
- decoders = timeside.core.processors(timeside.api.IDecoder)
- encoders = timeside.core.processors(timeside.api.IEncoder)
- analyzers = timeside.core.processors(timeside.api.IAnalyzer)
- cache_data = TelemetaCache(settings.TELEMETA_DATA_CACHE_DIR)
- cache_export = TelemetaCache(settings.TELEMETA_EXPORT_CACHE_DIR)
+def get_revisions(nb):
+ last_revisions = Revision.objects.order_by('-time')[0:nb]
+ revisions = []
+ for revision in last_revisions:
+ if revision.element_type == 'item':
+ try:
+ element = MediaItem.objects.get(pk=revision.element_id)
+ except:
+ element = None
+ if revision.element_type == 'collection':
+ try:
+ element = MediaCollection.objects.get(pk=revision.element_id)
+ except:
+ element = None
+ if revision.element_type == 'marker':
+ try:
+ element = MediaItemMarker.objects.get(pk=revision.element_id)
+ except:
+ element = None
+ if not element == None:
+ revisions.append({'revision': revision, 'element': element})
+ return revisions
+
+def get_playlists(request, user=None):
+ if not user:
+ user = request.user
+ playlists = []
+ if user.is_authenticated():
+ user_playlists = Playlist.objects.filter(author=user)
+ for playlist in user_playlists:
+ playlist_resources = PlaylistResource.objects.filter(playlist=playlist)
+ resources = []
+ for resource in playlist_resources:
+ try:
+ if resource.resource_type == 'item':
+ element = MediaItem.objects.get(id=resource.resource_id)
+ if resource.resource_type == 'collection':
+ element = MediaCollection.objects.get(id=resource.resource_id)
+ if resource.resource_type == 'marker':
+ element = MediaItemMarker.objects.get(id=resource.resource_id)
+ except:
+ element = None
+ resources.append({'element': element, 'type': resource.resource_type, 'public_id': resource.public_id })
+ playlists.append({'playlist': playlist, 'resources': resources})
+ return playlists
+
+
+class GeneralView(object):
+ """Provide general web UI methods"""
def index(self, request):
"""Render the homepage"""
return HttpResponse(template.render(context))
else:
template='telemeta/home.html'
- playlists = self.get_playlists(request)
+ playlists = get_playlists(request)
revisions = get_revisions(15)
searches = Search.objects.filter(username=request.user)
return render(request, template, {'playlists': playlists, 'searches': searches,
'revisions': revisions,})
+
+ def edit_search(self, request, criteria=None):
+ year_min, year_max = MediaCollection.objects.all().recording_year_range()
+ rec_years = year_min and year_max and range(year_min, year_max + 1) or []
+ year_min, year_max = MediaCollection.objects.all().publishing_year_range()
+ pub_years = year_min and year_max and range(year_min, year_max + 1) or []
+ return render(request, 'telemeta/search_criteria.html', {
+ 'rec_years': rec_years,
+ 'pub_years': pub_years,
+ 'ethnic_groups': MediaItem.objects.all().ethnic_groups(),
+ 'criteria': criteria
+ })
+
+ def handle_oai_request(self, request):
+ host = request.META['HTTP_HOST']
+ url = 'http://' + host + request.path
+ datasource = TelemetaOAIDataSource()
+ admin = settings.ADMINS[0][1]
+ provider = oai.DataProvider(datasource, host, url, admin)
+ args = request.GET.copy()
+ args.update(request.POST)
+ return HttpResponse(provider.handle(args), mimetype='text/xml')
+ def render_flatpage(self, request, path):
+ try:
+ content = pages.get_page_content(request, path)
+ except pages.MalformedPagePath:
+ return redirect(request.path + '/')
+
+ if isinstance(content, pages.PageAttachment):
+ return HttpResponse(content, content.mimetype())
+ else:
+ return render(request, 'telemeta/flatpage.html', {'page_content': content })
+
+ def logout(self, request):
+ auth.logout(request)
+ return redirect('telemeta-home')
+
+ def search(self, request, type = None):
+ """Perform a search through collections and items metadata"""
+ collections = MediaCollection.objects.enriched()
+ items = MediaItem.objects.enriched()
+ input = request.REQUEST
+ criteria = {}
+
+ switch = {
+ 'pattern': lambda value: (
+ collections.quick_search(value),
+ items.quick_search(value)),
+ 'title': lambda value: (
+ collections.word_search('title', value),
+ items.by_title(value)),
+ 'location': lambda value: (
+ collections.by_location(Location.objects.get(name=value)),
+ items.by_location(Location.objects.get(name=value))),
+ 'continent': lambda value: (
+ collections.by_continent(value),
+ items.filter(continent = value)),
+ 'ethnic_group': lambda value: (
+ collections.by_ethnic_group(value),
+ items.filter(ethnic_group = value),
+ EthnicGroup.objects.get(pk=value)),
+ 'creator': lambda value: (
+ collections.word_search('creator', value),
+ items.word_search('collection__creator', value)),
+ 'collector': lambda value: (
+ collections.by_fuzzy_collector(value),
+ items.by_fuzzy_collector(value)),
+ 'rec_year_from': lambda value: (
+ collections.by_recording_year(int(value), int(input.get('rec_year_to', value))),
+ items.by_recording_date(datetime.date(int(value), 1, 1),
+ datetime.date(int(input.get('rec_year_to', value)), 12, 31))),
+ 'rec_year_to': lambda value: (collections, items),
+ 'pub_year_from': lambda value: (
+ collections.by_publish_year(int(value), int(input.get('pub_year_to', value))),
+ items.by_publish_year(int(value), int(input.get('pub_year_to', value)))),
+ 'pub_year_to': lambda value: (collections, items),
+ }
+
+ for key, value in input.items():
+ func = switch.get(key)
+ if func and value and value != "0":
+ try:
+ res = func(value)
+ if len(res) > 2:
+ collections, items, value = res
+ else:
+ collections, items = res
+ except ObjectDoesNotExist:
+ collections = collections.none()
+ items = items.none()
+
+ criteria[key] = value
+
+ if type is None:
+ if collections.count():
+ type = 'collections'
+ else:
+ type = 'items'
+
+ if type == 'items':
+ objects = items
+ else:
+ objects = collections
+
+ return list_detail.object_list(request, objects,
+ template_name='telemeta/search_results.html', paginate_by=20,
+ extra_context={'criteria': criteria, 'collections_num': collections.count(),
+ 'items_num': items.count(), 'type' : type})
+
+ def complete_location(self, request, with_items=True):
+ input = request.REQUEST
+
+ token = input['q']
+ limit = int(input['limit'])
+ if with_items:
+ locations = MediaItem.objects.all().locations()
+ else:
+ locations = Location.objects.all()
+
+ locations = locations.filter(name__istartswith=token).order_by('name')[:limit]
+ data = [unicode(l) + " (%d items)" % l.items().count() for l in locations]
+
+ return HttpResponse("\n".join(data))
+
+class CollectionView(object):
+ """Provide Collections web UI methods"""
+
def collection_detail(self, request, public_id, template='telemeta/collection_detail.html'):
collection = MediaCollection.objects.get(public_id=public_id)
messages.error(request, title)
return render(request, 'telemeta/messages.html', {'description' : description})
- public_access = self.get_public_access(collection.public_access, collection.recorded_from_year,
+ public_access = get_public_access(collection.public_access, collection.recorded_from_year,
collection.recorded_to_year)
- playlists = self.get_playlists(request)
+ playlists = get_playlists(request)
return render(request, template, {'collection': collection, 'playlists': playlists, 'public_access': public_access})
@method_decorator(permission_required('telemeta.change_mediacollection'))
form = MediaCollectionForm(instance=collection)
return render(request, template, {'collection': collection, "form": form,})
-
+
+ def collection_playlist(self, request, public_id, template, mimetype):
+ try:
+ collection = MediaCollection.objects.get(public_id=public_id)
+ except ObjectDoesNotExist:
+ raise Http404
+
+ template = loader.get_template(template)
+ context = RequestContext(request, {'collection': collection, 'host': request.META['HTTP_HOST']})
+ return HttpResponse(template.render(context), mimetype=mimetype)
+
+
+class ItemView(object):
+ """Provide Collections web UI methods"""
+
+ graphers = timeside.core.processors(timeside.api.IGrapher)
+ decoders = timeside.core.processors(timeside.api.IDecoder)
+ encoders = timeside.core.processors(timeside.api.IEncoder)
+ analyzers = timeside.core.processors(timeside.api.IAnalyzer)
+ cache_data = TelemetaCache(settings.TELEMETA_DATA_CACHE_DIR)
+ cache_export = TelemetaCache(settings.TELEMETA_EXPORT_CACHE_DIR)
+
def item_previous_next(self, item):
# Get previous and next items
pks = []
previous, next = self.item_previous_next(item)
self.item_analyze(item)
- playlists = self.get_playlists(request)
- public_access = self.get_public_access(item.public_access, str(item.recorded_from_date).split('-')[0],
+ playlists = get_playlists(request)
+ public_access = get_public_access(item.public_access, str(item.recorded_from_date).split('-')[0],
str(item.recorded_to_date).split('-')[0])
return render(request, template,
'previous' : previous, 'next' : next, 'marker': marker_id, 'playlists' : playlists,
'public_access': public_access, 'width': width, 'height': height,
})
-
- def get_public_access(self, access, year_from=None, year_to=None):
- # Rolling publishing date : public access is given when time between recorded year
- # and current year is over the settings value PUBLIC_ACCESS_PERIOD
- if year_from and not year_from == 0:
- year = year_from
- elif year_to and not year_to == 0:
- year = year_to
- else:
- year = 0
- if access == 'full':
- public_access = True
- else:
- public_access = False
- if year and not year == 'None':
- year_now = datetime.datetime.now().strftime("%Y")
- if int(year_now) - int(year) >= settings.TELEMETA_PUBLIC_ACCESS_PERIOD:
- public_access = True
- else:
- public_access = False
- return public_access
@method_decorator(permission_required('telemeta.change_mediaitem'))
def item_edit(self, request, public_id, template='telemeta/mediaitem_edit.html'):
"""Export a given media item in the specified format (OGG, FLAC, ...)"""
item = MediaItem.objects.get(public_id=public_id)
- public_access = self.get_public_access(item.public_access, str(item.recorded_from_date).split('-')[0],
+ public_access = get_public_access(item.public_access, str(item.recorded_from_date).split('-')[0],
str(item.recorded_to_date).split('-')[0])
if (not public_access or not extension in settings.TELEMETA_STREAMING_FORMATS) and \
response['Content-Disposition'] = 'attachment'
return response
- def edit_search(self, request, criteria=None):
- year_min, year_max = MediaCollection.objects.all().recording_year_range()
- rec_years = year_min and year_max and range(year_min, year_max + 1) or []
- year_min, year_max = MediaCollection.objects.all().publishing_year_range()
- pub_years = year_min and year_max and range(year_min, year_max + 1) or []
- return render(request, 'telemeta/search_criteria.html', {
- 'rec_years': rec_years,
- 'pub_years': pub_years,
- 'ethnic_groups': MediaItem.objects.all().ethnic_groups(),
- 'criteria': criteria
- })
-
- def complete_location(self, request, with_items=True):
- input = request.REQUEST
-
- token = input['q']
- limit = int(input['limit'])
- if with_items:
- locations = MediaItem.objects.all().locations()
- else:
- locations = Location.objects.all()
-
- locations = locations.filter(name__istartswith=token).order_by('name')[:limit]
- data = [unicode(l) + " (%d items)" % l.items().count() for l in locations]
-
- return HttpResponse("\n".join(data))
-
- def search(self, request, type = None):
- """Perform a search through collections and items metadata"""
- collections = MediaCollection.objects.enriched()
- items = MediaItem.objects.enriched()
- input = request.REQUEST
- criteria = {}
-
- switch = {
- 'pattern': lambda value: (
- collections.quick_search(value),
- items.quick_search(value)),
- 'title': lambda value: (
- collections.word_search('title', value),
- items.by_title(value)),
- 'location': lambda value: (
- collections.by_location(Location.objects.get(name=value)),
- items.by_location(Location.objects.get(name=value))),
- 'continent': lambda value: (
- collections.by_continent(value),
- items.filter(continent = value)),
- 'ethnic_group': lambda value: (
- collections.by_ethnic_group(value),
- items.filter(ethnic_group = value),
- EthnicGroup.objects.get(pk=value)),
- 'creator': lambda value: (
- collections.word_search('creator', value),
- items.word_search('collection__creator', value)),
- 'collector': lambda value: (
- collections.by_fuzzy_collector(value),
- items.by_fuzzy_collector(value)),
- 'rec_year_from': lambda value: (
- collections.by_recording_year(int(value), int(input.get('rec_year_to', value))),
- items.by_recording_date(datetime.date(int(value), 1, 1),
- datetime.date(int(input.get('rec_year_to', value)), 12, 31))),
- 'rec_year_to': lambda value: (collections, items),
- 'pub_year_from': lambda value: (
- collections.by_publish_year(int(value), int(input.get('pub_year_to', value))),
- items.by_publish_year(int(value), int(input.get('pub_year_to', value)))),
- 'pub_year_to': lambda value: (collections, items),
- }
-
- for key, value in input.items():
- func = switch.get(key)
- if func and value and value != "0":
- try:
- res = func(value)
- if len(res) > 2:
- collections, items, value = res
- else:
- collections, items = res
- except ObjectDoesNotExist:
- collections = collections.none()
- items = items.none()
-
- criteria[key] = value
+ def item_playlist(self, request, public_id, template, mimetype):
+ try:
+ item = MediaItem.objects.get(public_id=public_id)
+ except ObjectDoesNotExist:
+ raise Http404
- if type is None:
- if collections.count():
- type = 'collections'
- else:
- type = 'items'
+ template = loader.get_template(template)
+ context = RequestContext(request, {'item': item, 'host': request.META['HTTP_HOST']})
+ return HttpResponse(template.render(context), mimetype=mimetype)
- if type == 'items':
- objects = items
+ @method_decorator(permission_required('telemeta.change_mediaitem'))
+ def item_performances_edit(self, request, public_id, template):
+ item = MediaItem.objects.get(public_id=public_id)
+ PerformanceFormSet = inlineformset_factory(MediaItem, MediaItemPerformance, form=MediaItemPerformanceForm)
+ if request.method == 'POST':
+ formset = PerformanceFormSet(data=request.POST, instance=item)
+ if formset.is_valid():
+ formset.save()
+ return HttpResponseRedirect('/items/'+public_id)
else:
- objects = collections
+ formset = PerformanceFormSet(instance=item)
+ return render(request, template, {'item': item, 'formset': formset,})
+
+ @method_decorator(permission_required('telemeta.change_mediaitem'))
+ def item_keywords_edit(self, request, public_id, template):
+ item = MediaItem.objects.get(public_id=public_id)
+ FormSet = inlineformset_factory(MediaItem, MediaItemKeyword)
+ if request.method == 'POST':
+ formset = FormSet(data=request.POST, instance=item)
+ if formset.is_valid():
+ formset.save()
+ return HttpResponseRedirect('/items/'+public_id)
+ else:
+ formset = FormSet(instance=item)
+ return render(request, template, {'item': item, 'formset': formset,})
+
- return list_detail.object_list(request, objects,
- template_name='telemeta/search_results.html', paginate_by=20,
- extra_context={'criteria': criteria, 'collections_num': collections.count(),
- 'items_num': items.count(), 'type' : type})
- # ADMIN
+class AdminView(object):
+ """Provide Admin web UI methods"""
+
@method_decorator(permission_required('sites.change_site'))
def admin_index(self, request):
return render(request, 'telemeta/admin.html', self.__get_admin_context_vars())
@method_decorator(permission_required('sites.change_site'))
def admin_enumerations(self, request):
return render(request, 'telemeta/admin_enumerations.html', self.__get_admin_context_vars())
+
@method_decorator(permission_required('sites.change_site'))
def admin_users(self, request):
users = User.objects.all()
return render(request, 'telemeta/admin_users.html', {'users': users})
- # ENUMERATIONS
def __get_enumerations_list(self):
from django.db.models import get_models
models = get_models(telemeta.models)
def __get_admin_context_vars(self):
return {"enumerations": self.__get_enumerations_list()}
-
+
def __get_enumeration(self, id):
from django.db.models import get_models
models = get_models(telemeta.models)
return self.edit_enumeration(request, enumeration_id)
- # INSTRUMENTS
+class InstrumentView(object):
+ """Provide Instrument web UI methods"""
+
@method_decorator(permission_required('telemeta.change_instrument'))
def edit_instrument(self, request):
return self.edit_instrument(request)
- def collection_playlist(self, request, public_id, template, mimetype):
- try:
- collection = MediaCollection.objects.get(public_id=public_id)
- except ObjectDoesNotExist:
- raise Http404
-
- template = loader.get_template(template)
- context = RequestContext(request, {'collection': collection, 'host': request.META['HTTP_HOST']})
- return HttpResponse(template.render(context), mimetype=mimetype)
-
- def item_playlist(self, request, public_id, template, mimetype):
- try:
- item = MediaItem.objects.get(public_id=public_id)
- except ObjectDoesNotExist:
- raise Http404
-
- template = loader.get_template(template)
- context = RequestContext(request, {'item': item, 'host': request.META['HTTP_HOST']})
- return HttpResponse(template.render(context), mimetype=mimetype)
+
+class GeoView(object):
+ """Provide Geo web UI methods"""
def list_continents(self, request):
continents = MediaItem.objects.all().countries(group_by_continent=True)
template_name='telemeta/geo_country_items.html', paginate_by=20,
extra_context={'country': country, 'continent': continent})
- def handle_oai_request(self, request):
- host = request.META['HTTP_HOST']
- url = 'http://' + host + request.path
- datasource = TelemetaOAIDataSource()
- admin = settings.ADMINS[0][1]
- provider = oai.DataProvider(datasource, host, url, admin)
- args = request.GET.copy()
- args.update(request.POST)
- return HttpResponse(provider.handle(args), mimetype='text/xml')
-
- def render_flatpage(self, request, path):
- try:
- content = pages.get_page_content(request, path)
- except pages.MalformedPagePath:
- return redirect(request.path + '/')
-
- if isinstance(content, pages.PageAttachment):
- return HttpResponse(content, content.mimetype())
- else:
- return render(request, 'telemeta/flatpage.html', {'page_content': content })
-
- def logout(self, request):
- auth.logout(request)
- return redirect('telemeta-home')
+class MarkerView(object):
+ """Provide Collections web UI methods"""
- #MARKERS
@jsonrpc_method('telemeta.add_marker')
def add_marker(request, marker):
# marker must be a dict
marker = MediaItemMarker.objects.get(public_id=public_id)
return marker.id
- # PLAYLISTS
+class PlaylistView(object):
+ """Provide Collections web UI methods"""
+
@jsonrpc_method('telemeta.add_playlist')
def add_playlist(request, playlist):
# playlist must be a dict
m = Playlist.objects.get(public_id=public_id)
m.delete()
- def get_playlists(self, request, user=None):
- if not user:
- user = request.user
- playlists = []
- if user.is_authenticated():
- user_playlists = Playlist.objects.filter(author=user)
- for playlist in user_playlists:
- playlist_resources = PlaylistResource.objects.filter(playlist=playlist)
- resources = []
- for resource in playlist_resources:
- try:
- if resource.resource_type == 'item':
- element = MediaItem.objects.get(id=resource.resource_id)
- if resource.resource_type == 'collection':
- element = MediaCollection.objects.get(id=resource.resource_id)
- if resource.resource_type == 'marker':
- element = MediaItemMarker.objects.get(id=resource.resource_id)
- except:
- element = None
- resources.append({'element': element, 'type': resource.resource_type, 'public_id': resource.public_id })
- playlists.append({'playlist': playlist, 'resources': resources})
- return playlists
-
@jsonrpc_method('telemeta.update_playlist')
def update_playlist(request, playlist):
if isinstance(playlist, dict):
writer.writerow(data)
return response
- def rss(self, request):
- "Render the RSS feed of last revisions"
- rss_item_list = []
- organization = settings.TELEMETA_ORGANIZATION
- subjects = settings.TELEMETA_SUBJECTS
- rss_host = request.META['HTTP_HOST']
- date_now = datetime.datetime.now()
- revisions = self.get_revisions(50)
- tags = ['title', 'description', 'comment']
-
- for r in revisions:
- revision = r['revision']
- element = r['element']
- if element:
- link = 'http://' + rss_host + '/' + revision.element_type + 's/' + str(element.public_id)
- description = '<b>modified by ' + revision.user.username + ' on ' + unicode(revision.time) + '</b><br /><br />'
- dict = element.to_dict()
- for tag in dict.keys():
- try:
- value = dict[tag]
- if value != '':
- description += tag + ' : ' + value + '<br />'
- except:
- continue
- if tag == 'title':
- if element.title == '':
- title = str(element.public_id)
- else:
- title = element.title
- title = element.element_type + ' : ' + title
-
- rss_item_list.append(RSSItem(
- title = title,
- link = link,
- description = description.encode('utf-8'),
- guid = Guid(link),
- pubDate = revision.time,)
- )
-
- rss = RSS2(title = organization + ' - Telemeta - ' + ugettext('Last changes'),
- link = rss_host,
- description = ' '.join([subject.decode('utf-8') for subject in subjects]),
- lastBuildDate = str(date_now),
- items = rss_item_list,)
-
- feed = rss.to_xml(encoding='utf-8')
- response = HttpResponse(feed, mimetype='application/rss+xml')
- return response
-
+
+class ProfileView(object):
+ """Provide Collections web UI methods"""
+
@method_decorator(login_required)
def profile_detail(self, request, username, template='telemeta/profile_detail.html'):
user = User.objects.get(username=username)
profile = user.get_profile()
except:
profile = None
- playlists = self.get_playlists(request, user)
+ playlists = get_playlists(request, user)
return render(request, template, {'profile' : profile, 'usr': user, 'playlists': playlists})
def profile_edit(self, request, username, template='telemeta/profile_edit.html'):
forms = [user_form, profile_form]
return render(request, template, {'forms': forms, 'usr': user, 'user_hidden_fields': user_hidden_fields})
- @method_decorator(permission_required('telemeta.change_mediaitem'))
- def item_performances_edit(self, request, public_id, template):
- item = MediaItem.objects.get(public_id=public_id)
- PerformanceFormSet = inlineformset_factory(MediaItem, MediaItemPerformance, form=MediaItemPerformanceForm)
- if request.method == 'POST':
- formset = PerformanceFormSet(data=request.POST, instance=item)
- if formset.is_valid():
- formset.save()
- return HttpResponseRedirect('/items/'+public_id)
- else:
- formset = PerformanceFormSet(instance=item)
- return render(request, template, {'item': item, 'formset': formset,})
-
- @method_decorator(permission_required('telemeta.change_mediaitem'))
- def item_keywords_edit(self, request, public_id, template):
- item = MediaItem.objects.get(public_id=public_id)
- FormSet = inlineformset_factory(MediaItem, MediaItemKeyword)
- if request.method == 'POST':
- formset = FormSet(data=request.POST, instance=item)
- if formset.is_valid():
- formset.save()
- return HttpResponseRedirect('/items/'+public_id)
- else:
- formset = FormSet(instance=item)
- return render(request, template, {'item': item, 'formset': formset,})
-
-def get_revisions(nb):
- last_revisions = Revision.objects.order_by('-time')[0:nb]
- revisions = []
- for revision in last_revisions:
- if revision.element_type == 'item':
- try:
- element = MediaItem.objects.get(pk=revision.element_id)
- except:
- element = None
- if revision.element_type == 'collection':
- try:
- element = MediaCollection.objects.get(pk=revision.element_id)
- except:
- element = None
- if revision.element_type == 'marker':
- try:
- element = MediaItemMarker.objects.get(pk=revision.element_id)
- except:
- element = None
- if not element == None:
- revisions.append({'revision': revision, 'element': element})
- return revisions
-
class LastestRevisionsFeed(Feed):
"the RSS feed of the lastest revisions"
projects / telemeta.git / commitdiff