path: root/backend/views.py

# Create your views here.

from django.conf import settings
from django.contrib import auth
from django.http import HttpResponse
from django.http import HttpResponsePermanentRedirect
from django.template import loader
from django.template import Context
from django.shortcuts import render_to_response
from django.views.decorators.http import require_POST
from django.db.models import Q
from datetime import datetime
from datetime import timedelta

import sha
import time
import cStringIO

from backend.models import SJLike
from backend.models import SJRoom
from backend.models import SJContent
from backend.models import SJUserProfile

API_HEADER = '#@scanjam 0.3b\n'
ROOM_CHAT_LOG_SIZE = 50
ROOM_VIDEO_LOG_SIZE = 50
ACCESS_USER = 0
ACCESS_MODERATOR = 1
ACCESS_ADMIN = 9

#
# Common funtions
#

def headers(response):
    """ Setup additional headers for response
    """
    response['Access-Control-Allow-Origin'] = '*'
    response['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
    response['Access-Control-Allow-Headers'] = 'x-requested-with'
    response['Access-Control-Max-Age'] = '3628800'
    response['Content-type'] = 'text/plain; charset=UTF-8'

def response_error(error, response=None):
    """ Add API error name with setup headers to response
    """
    if not response:
        response = HttpResponse()
    headers(response)
    response.write(API_HEADER)
    response.write('0\t%s\n' % error)
    return response

def response_success(message='OK', response=None):
    """ Add API OK with setup headers to response
    """
    if not response:
        response = HttpResponse()
    headers(response)
    response.write(API_HEADER)
    response.write(message + '\n')
    return response

def check_form_fields(request, form_fields):
    """ Check form fields presence
    """
    for field, value in request.POST.iteritems():
        print field, '= "%s"' % value
    for field in form_fields:
        if field not in request.POST:
            return response_error('incomplete form')
        if not request.POST[field]:
            return response_error('no %s' % field)

def user_response_str(request, user=None):
    """ Return API response string for user
    """
    if not user:
        user = request.user
    if user.is_authenticated():
        user_id = user.id
        username = user.username
        session_id = request.session.session_key
        user_access = user.get_profile().access
    else:
        user_id = 0
        username = 'anonymous'
        session_id = sha.new('No valid session').hexdigest()
        user_access = 0
    return '%d\t%s\t%s\t%d\n' % (user_id, username, session_id, user_access)

def video_response_str(videos):
    """ Return string with list of videos
    """
    strio = cStringIO.StringIO()
    for v in videos:
       s = v.settings
       strio.write('VIDEO\t')
       strio.write('%s\n' % '\t'.join([
           str(v.id),
           str(datetime_to_timestamp(v.datetime)),
           str(v.user.id),
           v.user.username,
           s['url'],
           s['title'],
       ]))
    return strio.getvalue()

def thraw(settings_text):
    settings = dict()
    if settings_text:
        for line in settings_text.split('\n'):
            column = line.split('\t')
            if len(column) == 2:
                settings[column[0]] = column[1]
    return settings

def freeze(settings):
    return '\n'.join(['%s\t%s' % (str(key), str(value)) for key, value in settings.iteritems()])

def datetime_to_timestamp(dt):
    return int(time.mktime(dt.timetuple()))

def now_timestamp():
    return int(time.mktime(time.localtime()))

def yesterday_datetime():
    return datetime.now() - timedelta(days=1)

#
# AUTH API
#

@require_POST
def api_auth_login(request):
    """ Log in user. Public API
    """
    form_fields = ['username', 'password']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    user = auth.authenticate(username=request.POST['username'],
                             password=request.POST['password'])
    if user:
       if user.is_active:
           auth.login(request, user)
           response = response_success()
           response.write(user_response_str(request))
           return response
       else:
           return response_error('user disabled')
    else:
        if auth.models.User.objects.filter(username=request.POST['username']):
            return response_error('wrong password')
        else:
            return response_error('no such user')

@require_POST
def api_auth_logout(request):
    """ Log out user. Public API
    """
    auth.logout(request)
    return response_success()

@require_POST
def api_auth_sneakin(request):
    """ Sneak in user. Public API
    """
    form_fields = ['userid', 'username']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    try:
        user = auth.models.User.objects.get(username=request.POST['username'])
        if user.id != int(request.POST['userid']):
            return response_error('no match')
    except:
       return response_error('no such user')
    # Hack to authenticate user manually
    for backend in auth.get_backends():
        user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)
        break
    auth.login(request, user)
    response = response_success()
    response.write(user_response_str(request, user))
    return response

@require_POST
def api_auth_register(request):
    """ Register new user. Public API
    """
    form_fields = ['username', 'password']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if auth.models.User.objects.filter(username=request.POST['username']):
        return response_error('user exists')
    user = auth.models.User.objects.create_user(username=request.POST['username'],
                                                email='default@noemail.com',
                                                password=request.POST['password'])
    user.is_active = True
    try:
        user.save()
    except:
        return response_error('db error')
    user_profile = SJUserProfile(user=user)
    try:
        user_profile.save()
    except:
        return response_error('db error')
    response = response_success()
    response.write(user_response_str(request, user))
    return response

@require_POST
def api_auth_available(request):
    """ Check if user exists. Public API
    """
    form_fields = ['username']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if auth.models.User.objects.filter(username=request.POST['username']):
        return response_error('user exists')
    return response_success()

@require_POST
def api_auth_checkin(request):
    """ Check in user. Private API
    """
    if request.user.is_authenticated():
        response = response_success()
        response.write(user_response_str(request))
        return response
    return HttpResponse()

@require_POST
def api_auth_password(request):
    """ Change user password. Private API
    """
    form_fields = ['username', 'password']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if request.user.is_authenticated() and request.user.username == request.POST['username']:
        try:
            user = auth.models.User.objects.get(username=request.POST['username'])
            user.set_password(request.POST['password'])
            user.save()
            user_profile = user.get_profile()
            user_profile.save()
        except auth.models.User.DoesNotExist:
            return response_error('no such user')
        except:
            return response_error('db error')
        return response_success()
    return HttpResponse()

#
# USER API
#

@require_POST
def api_user_videos(request):
    """ View list of user videos. Public API
    """
    form_fields = ['user']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    try:
        query = Q(user=auth.models.User.objects.get(id=request.POST['user']))
    except auth.models.User.DoesNotExist:
        return response_error('no such user')
    except:
        return response_error('db error')
    if 'start' in request.POST:
        try:
            timestamp = float(request.POST['start'])
            query = query & Q(datetime__lte=datetime.fromtimestamp(timestamp))
        except:
            pass
    videos = SJContent.objects.filter(content_type='video').filter(query).order_by('-datetime')[0:ROOM_VIDEO_LOG_SIZE]
    if not videos:
        return response_error('no videos')
    response = response_success()
    for v in videos:
        s = v.settings
        l = '\t'.join([
            str(v.id),
            str(v.datetime),
            str(v.user.id),
            v.user.username,
            s['url'],
            s['title'],
        ])
        response.write(l + '\n')
    return response

@require_POST
def api_user_likes(request):
    """ View list of liked videos. Public API
    """
    form_fields = ['user']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    try:
        query = Q(sjlike__user=auth.models.User.objects.get(id=request.POST['user']))
    except auth.models.User.DoesNotExist:
        return response_error('no such user')
    except:
        return response_error('db error')
    if 'start' in request.POST:
        try:
            timestamp = float(request.POST['start'])
            query = query & Q(datetime__lte=datetime.fromtimestamp(timestamp))
        except:
            pass
    videos = SJContent.objects.filter(content_type='video').filter(query).order_by('-datetime')[0:ROOM_VIDEO_LOG_SIZE]
    if not videos:
        return response_error('no videos')
    response = response_success()
    for v in videos:
        l = '\t'.join([str(v.user.id), str(v.id), str(v.datetime)])
        response.write(l + '\n')
    return response

@require_POST
def api_user_top(request):
    """ Public API
    """
    form_fields = ['user']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_user_settings(request):
    """ Update user settings. Private API
    """
    user = request.user
    if not user.is_authenticated():
        return response_error('no logged in')
    user_profile = user.get_profile()
    form_fields = ['userid', 'bio', 'settings']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if (user.id != int(request.POST['userid'])) and (user_profile.access < ACCESS_ADMIN):
        return response_error('you can only edit yourself man')
    settings = user_profile.settings
    settings.update(thraw(request.POST['settings']))
    user_profile.settings = settings
    user_profile.save()
    return response_success()

#
# ROOM API
#

@require_POST
def api_room_watch(request):
    """ View room videos. Public API
    """
    form_fields = ['room']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    try:
        room = SJRoom.objects.get(name=request.POST['room'])
    except:
        return response_error('no room')
    response = response_success(str(now_timestamp()))
    last = 0
    if 'last' in request.POST:
        last =int(request.POST['last']) - 1
    videos = SJContent.objects.filter(room=room, content_type='video').order_by('-datetime')
    if videos and last <= datetime_to_timestamp(videos[0].datetime):
        response.write(video_response_str(videos))
    return response

@require_POST
def api_room_list(request):
    """ View list of rooms. Public API
    """
    videos = SJContent.objects.filter(content_type='video', datetime__gt=yesterday_datetime())
    s = ''
    for room in SJRoom.objects.filter(private=False):
        s += '\t'.join([
           str(room.id),
           room.name,
           str(datetime_to_timestamp(room.datetime)),
           str(videos.filter(room=room).count()),
           room.settings.get('bg', ''),
        ])
        s += '\n'
    return response_success(s)

@require_POST
def api_room_view(request):
    """ View room's video, settings and chats. Private API
    """
    user = request.user
    if not user.is_authenticated():
        return response_error('no logged in')
    user_profile = user.get_profile()
    form_fields = ['room']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    try:
        room = SJRoom.objects.get(name=request.POST['room'])
    except:
        return response_error('no room')
    user_profile.lastseen_chat = datetime.now()
    user_profile.save()
    response = response_success('\t'.join([u.username for u in room.users.all()]))
    videos = SJContent.objects.filter(room=room, content_type='video').order_by('-datetime')
    response.write(video_response_str(videos))
    for key, value in room.settings.iteritems():
        response.write('%s\n' % '\t'.join(['ROOM', key, value]))
    for text in SJContent.objects.filter(room=room, content_type='text').order_by('-datetime').distinct()[0:ROOM_CHAT_LOG_SIZE]:
        response.write('%d\t%s\t%d\t%d\t%s\t%s\n' % (
            text.id,
            datetime_to_timestamp(text.datetime),
            text.user.id,
            room.id,
            text.user.username,
            text.settings.get('text', '')
        ))
    return response

@require_POST
def api_room_join(request):
    """ Private API
    """
    form_fields = ['room', 'enqueue']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_read(request):
    """ Private API
    """
    form_fields = ['room', 'enqueue']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_poll(request):
    """ Private API
    """
    form_fields = ['room', 'last', 'cam']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_settings(request):
    """ Private API
    """
    form_fields = ['room', 'settings']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_say(request):
    """ Private API
    """
    form_fields = ['room', 'msg']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_video(request):
    """ Private API
    """
    form_fields = ['room', 'msg']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

#
# VIDEO API
#

@require_POST
def api_video_date(request):
    """ Public API
    """
    form_fields = ['day', 'month', 'year']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_view(request):
    """ Private API
    """
    form_fields = ['video']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_like(request):
    """ Private API
    """
    form_fields = ['video']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_unlike(request):
    """ Private API
    """
    form_fields = ['video']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_remove(request):
    """ Private API
    """
    form_fields = ['video', 'room']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_search(request):
    """ Private API
    """
    form_fields = ['q', 'start', 'limit']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

#
# Common views
#

def stats(request):
    """ View statistics
    """
    uptime = str(datetime.now() - settings.START_TIME)
    videos_today = None
    videos_total = None
    likes_today = None
    likes_total = None
    users_total = None
    users_today = None
    users_in_main_room = None
    new_users_today = None
    rooms_total = None
    main_room_peak = None
    return render_to_response('stats.html', {'users_total': users_total,
                                             'users_today': users_today,
                                             'new_users_today': new_users_today,
                                             'videos_total': videos_total,
                                             'videos_today': videos_today,
                                             'likes_total': likes_total,
                                             'likes_today': likes_today,
                                             'rooms_total': rooms_total,
                                             'main_room_peak': main_room_peak,
                                             'uptime': uptime})

def redirect(request):
    """ Permanent redirect
    """
    response = HttpResponsePermanentRedirect(redirect_to='http://scannerjammer.com')
    template = loader.get_template('redirect.html')
    response.write(template.render(Context()))
    return response