mirror of
https://github.com/fergalmoran/dss.git
synced 2025-12-22 17:48:51 +00:00
298 lines
11 KiB
Python
Executable File
298 lines
11 KiB
Python
Executable File
from datetime import datetime
|
|
import os
|
|
import logging
|
|
|
|
from django.conf.urls import url
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.core.files.base import ContentFile
|
|
from django.core.files.storage import FileSystemStorage
|
|
from django.db.models import get_model
|
|
from django.http import HttpResponse, HttpResponseNotFound
|
|
from annoying.decorators import render_to
|
|
from django.shortcuts import render_to_response
|
|
from django.utils import simplejson
|
|
from django.views.decorators.csrf import csrf_exempt, csrf_protect
|
|
from django.views.decorators.http import require_POST
|
|
from jfu.http import upload_receive, UploadResponse
|
|
|
|
from core.utils import live
|
|
from dss import localsettings, settings
|
|
from spa.models import UserProfile, Release
|
|
from spa.models.mix import Mix
|
|
from spa.models.comment import Comment
|
|
from core.serialisers import json
|
|
from core.tasks import create_waveform_task
|
|
from spa.models.notification import Notification
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class AjaxHandler(object):
|
|
# Get an instance of a logger
|
|
|
|
def __init__(self, api_name="v1"):
|
|
self.api_name = api_name
|
|
|
|
@property
|
|
def urls(self):
|
|
pattern_list = [
|
|
url(r'^mix/add_comment/$', 'spa.ajax.mix_add_comment', name='mix_add_comment'),
|
|
url(r'^mix/comments/(?P<mix_id>\d+)/$', 'spa.ajax.mix_comments', name='ajax_mix_comments'),
|
|
url(r'^header/$', 'spa.ajax.header', name='header'),
|
|
url(r'^session_play_count/$', 'spa.ajax.session_play_count'),
|
|
url(r'^mix_stream_url/(?P<mix_id>\d+)/$', 'spa.ajax.get_mix_stream_url'),
|
|
url(r'^release_player/(?P<release_id>\d+)/$', 'spa.ajax.release_player'),
|
|
url(r'^live_now_playing/$', 'spa.ajax.live_now_playing'),
|
|
url(r'^mark_read/$', 'spa.ajax.mark_read'),
|
|
url(r'^facebook_post_likes_allowed/$', 'spa.ajax.facebook_post_likes_allowed',
|
|
name='ajax_facebook_post_likes_allowed'),
|
|
url(r'^upload_mix_image/(?P<mix_id>\d+)/$', 'spa.ajax.upload_mix_image', name='ajax_upload_mix_image'),
|
|
url(r'^upload_release_image/(?P<release_id>\d+)/$', 'spa.ajax.upload_release_image',
|
|
name='ajax_upload_release_image'),
|
|
url(r'^upload_avatar_image/$', 'spa.ajax.upload_avatar_image', name='ajax_upload_avatar_image'),
|
|
url(r'^lookup/search/$', 'spa.ajax.lookup_search', name='ajax_lookup'),
|
|
url(r'^lookup/(?P<source>\w+)/$', 'spa.ajax.lookup', name='ajax_lookup'),
|
|
]
|
|
return pattern_list
|
|
|
|
|
|
def _get_json(payload, key='value'):
|
|
data = {
|
|
key: payload
|
|
}
|
|
return simplejson.dumps(data)
|
|
|
|
|
|
@render_to('inc/header.html')
|
|
def header(request):
|
|
return HttpResponse(render_to_response('inc/header.html'))
|
|
|
|
|
|
def session_play_count(request):
|
|
"""
|
|
|
|
:param request:
|
|
:return: Number of tracks played in this session
|
|
"""
|
|
if not request.user.is_authenticated():
|
|
if 'play_count' in request.session:
|
|
result = simplejson.dumps({
|
|
'play_count': request.session['play_count']
|
|
})
|
|
else:
|
|
result = simplejson.dumps({
|
|
'play_count': '0'
|
|
})
|
|
else:
|
|
result = simplejson.dumps({
|
|
'play_count': '0'
|
|
})
|
|
return HttpResponse(result, mimetype='application/json')
|
|
|
|
|
|
def get_mix_stream_url(request, mix_id):
|
|
try:
|
|
if not request.user.is_authenticated():
|
|
if 'play_count' in request.session:
|
|
request.session['play_count'] += 1
|
|
else:
|
|
request.session['play_count'] = 1
|
|
|
|
mix = Mix.objects.get(pk=mix_id)
|
|
mix.add_play(request.user)
|
|
data = {
|
|
'stream_url': mix.get_stream_path(),
|
|
'description': mix.description,
|
|
'item_url': mix.get_absolute_url(),
|
|
'title': mix.title
|
|
}
|
|
return HttpResponse(simplejson.dumps(data), mimetype="application/json")
|
|
except Exception, e:
|
|
logger.exception("Error getting mix stream url")
|
|
raise #HttpResponse("Error getting mix stream url", status=401)
|
|
|
|
|
|
def live_now_playing(request):
|
|
now_playing_info = live.get_now_playing(
|
|
localsettings.JS_SETTINGS['LIVE_STREAM_URL'],
|
|
localsettings.JS_SETTINGS['LIVE_STREAM_PORT'],
|
|
localsettings.JS_SETTINGS['LIVE_STREAM_MOUNT'])
|
|
try:
|
|
if now_playing_info is not None:
|
|
return HttpResponse(
|
|
simplejson.dumps({
|
|
'stream_url': 'http://%s:%s/%s' % (
|
|
localsettings.JS_SETTINGS['LIVE_STREAM_URL'],
|
|
localsettings.JS_SETTINGS['LIVE_STREAM_PORT'],
|
|
localsettings.JS_SETTINGS['LIVE_STREAM_MOUNT']),
|
|
'description': now_playing_info['stream_description'],
|
|
'title': now_playing_info['current_song']
|
|
}), mimetype="application/json")
|
|
except:
|
|
return HttpResponseNotFound(now_playing_info)
|
|
|
|
return None
|
|
|
|
|
|
@render_to('inc/release_player.html')
|
|
def release_player(request, release_id):
|
|
return HttpResponse('Hello Sailor')
|
|
|
|
|
|
def mix_add_comment(request):
|
|
if request.POST:
|
|
comment = Comment()
|
|
comment.mix_id = request.POST['mixid']
|
|
comment.user = request.user
|
|
comment.comment = request.POST['comment']
|
|
comment.time_index = request.POST['position']
|
|
comment.save()
|
|
|
|
return HttpResponse(_get_json('Comment posted', 'description'))
|
|
else:
|
|
return HttpResponse(_get_json('Error posting', 'description'))
|
|
|
|
|
|
@render_to('inc/comment_list.html')
|
|
def mix_comments(request, mix_id):
|
|
return {
|
|
"results": Comment.objects.filter(mix_id=mix_id),
|
|
}
|
|
|
|
|
|
@login_required
|
|
def mark_read(request):
|
|
profile = request.user.get_profile()
|
|
if profile is not None:
|
|
Notification.objects.filter(to_user=profile).update(accepted_date=datetime.now())
|
|
return HttpResponse('Success', status=200)
|
|
pass
|
|
|
|
return HttpResponse('Unauthorized', status=401)
|
|
|
|
|
|
@login_required()
|
|
def facebook_post_likes_allowed(request):
|
|
profile = request.user.get_profile()
|
|
if profile is not None:
|
|
likes_allowed = profile.activity_sharing & UserProfile.ACTIVITY_SHARE_LIKES
|
|
facebook_allowed = profile.activity_sharing_networks & UserProfile.ACTIVITY_SHARE_NETWORK_FACEBOOK
|
|
|
|
return HttpResponse(_get_json(bool(likes_allowed & facebook_allowed)), mimetype="application/json")
|
|
|
|
return HttpResponse(_get_json(False), mimetype="application/json")
|
|
|
|
|
|
@csrf_exempt
|
|
def upload_release_image(request, release_id):
|
|
try:
|
|
if 'release_image' in request.FILES and release_id is not None:
|
|
release = Release.objects.get(pk=release_id)
|
|
if release is not None:
|
|
release.release_image = request.FILES['release_image']
|
|
release.save()
|
|
return HttpResponse(_get_json("Success"))
|
|
except Exception, ex:
|
|
logger.exception("Error uploading release image")
|
|
return HttpResponse(_get_json("Failed"))
|
|
|
|
|
|
def upload_mix_image(request, mix_id):
|
|
try:
|
|
if len(request.FILES) != 0:
|
|
mix = Mix.objects.get(pk=mix_id)
|
|
if mix:
|
|
mix.mix_image = request.FILES[request.FILES.keys()[0]]
|
|
mix.save()
|
|
return HttpResponse(json.dumps({'status': 'OK', 'url': mix.get_image_url()}))
|
|
except Exception, ex:
|
|
logger.exception("Error uploading avatar: %s", ex.message)
|
|
return HttpResponse(json.dumps({'status': 'failed', 'message': ex.message}))
|
|
|
|
return HttpResponse(json.dumps({'status': 'failed', 'message': 'No image file found'}))
|
|
|
|
|
|
def upload_avatar_image(request):
|
|
# TODO: fergal.moran@gmail.com
|
|
# Problem here that only the current user can update avatar
|
|
# Might need to allow staff to change other's avatars?
|
|
try:
|
|
if len(request.FILES) != 0:
|
|
profile = request.user.get_profile()
|
|
if profile:
|
|
profile.avatar_image = request.FILES[request.FILES.keys()[0]]
|
|
profile.avatar_type = 'custom'
|
|
profile.save()
|
|
return HttpResponse(json.dumps({'status': 'OK', 'url': profile.get_avatar_image()}))
|
|
except Exception, ex:
|
|
logger.exception("Error uploading avatar: %s", ex.message)
|
|
return HttpResponse(json.dumps({'status': 'failed', 'message': ex.message}))
|
|
|
|
return HttpResponse(json.dumps({'status': 'failed', 'message': 'No image file found'}))
|
|
|
|
|
|
@require_POST
|
|
@login_required
|
|
@csrf_protect
|
|
def upload(request):
|
|
# The assumption here is that jQuery File Upload
|
|
# has been configured to send files one at a time.
|
|
# If multiple files can be uploaded simultaneously,
|
|
# 'file' may be a list of files.
|
|
try:
|
|
uid = request.POST['upload-hash']
|
|
in_file = request.FILES['file'] if request.FILES else None
|
|
file_name, extension = os.path.splitext(in_file.name)
|
|
|
|
file_storage = FileSystemStorage(location=os.path.join(settings.CACHE_ROOT, "mixes"))
|
|
cache_file = file_storage.save("%s%s" % (uid, extension), ContentFile(in_file.read()))
|
|
response = ''
|
|
|
|
try:
|
|
create_waveform_task.delay(in_file=os.path.join(file_storage.base_location, cache_file), uid=uid)
|
|
except:
|
|
logger.debug("Unable to connect to celery")
|
|
response = 'Unable to connect to waveform generation task, there may be a delay in getting your mix online'
|
|
|
|
file_dict = {
|
|
'response': response,
|
|
'size': in_file.size,
|
|
'uid': uid
|
|
}
|
|
|
|
return UploadResponse(request, file_dict)
|
|
except Exception, ex:
|
|
logger.exception(ex.message)
|
|
raise
|
|
|
|
|
|
@csrf_exempt
|
|
def lookup_search(request):
|
|
query = request.GET['query'] if 'query' in request.GET else request.GET['q'] if 'q' in request.GET else ''
|
|
if query != '':
|
|
filter_field = Mix.get_lookup_filter_field()
|
|
kwargs = {
|
|
'{0}__{1}'.format(filter_field, 'icontains'): query,
|
|
}
|
|
rows = Mix.objects.values("title").filter(**kwargs)
|
|
#results = serializers.serialize("json", rows, fields="title",)
|
|
results = json.dumps(rows)
|
|
return HttpResponse(results, mimetype='application/json')
|
|
|
|
|
|
@csrf_exempt
|
|
def lookup(request, source):
|
|
query = request.GET['query'] if 'query' in request.GET else request.GET['q'] if 'q' in request.GET else ''
|
|
if query != '':
|
|
model = get_model('spa', source)
|
|
if model is not None:
|
|
filter_field = model.get_lookup_filter_field()
|
|
kwargs = {
|
|
'{0}__{1}'.format(filter_field, 'icontains'): query,
|
|
}
|
|
rows = model.objects.filter(**kwargs)
|
|
results = json.to_ajax(rows, filter_field)
|
|
return HttpResponse(simplejson.dumps(results), mimetype='application/json')
|
|
return HttpResponse(_get_json("Key failure in lookup"), mimetype='application/json')
|