245 lines
7.7 KiB
Python
245 lines
7.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
# vi:si:et:sw=4:sts=4:ts=4
|
|
from __future__ import division
|
|
import os.path
|
|
from os.path import join
|
|
import re
|
|
from datetime import datetime
|
|
from urllib2 import unquote
|
|
import mimetypes
|
|
|
|
from django import forms
|
|
from django.core.paginator import Paginator
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.auth.models import User
|
|
from django.db.models import Q, Avg, Count, Sum
|
|
from django.http import HttpResponse, Http404
|
|
from django.shortcuts import render_to_response, get_object_or_404, get_list_or_404, redirect
|
|
from django.template import RequestContext
|
|
from django.conf import settings
|
|
|
|
from ox.utils import json
|
|
from ox.django.decorators import login_required_json
|
|
from ox.django.shortcuts import render_to_json_response, get_object_or_404_json, json_response
|
|
from ox.django.http import HttpFileResponse
|
|
import ox
|
|
from actions import actions
|
|
|
|
|
|
def api(request):
|
|
if request.META['REQUEST_METHOD'] == "OPTIONS":
|
|
response = render_to_json_response({'status': {'code': 200,
|
|
'text': 'use POST'}})
|
|
response['Access-Control-Allow-Origin'] = '*'
|
|
return response
|
|
if not 'action' in request.POST:
|
|
methods = actions.keys()
|
|
api = []
|
|
for f in sorted(methods):
|
|
api.append({'name': f,
|
|
'doc': actions.doc(f).replace('\n', '<br>\n')})
|
|
context = RequestContext(request, {'api': api,
|
|
'sitename': settings.SITENAME})
|
|
return render_to_response('api.html', context)
|
|
function = request.POST['action']
|
|
#FIXME: possible to do this in f
|
|
#data = json.loads(request.POST['data'])
|
|
|
|
f = actions.get(function, None)
|
|
if f:
|
|
response = f(request)
|
|
else:
|
|
response = render_to_json_response(json_response(status=400,
|
|
text='Unknown function %s' % function))
|
|
response['Access-Control-Allow-Origin'] = '*'
|
|
return response
|
|
|
|
#def api_api(request):
|
|
# '''
|
|
# returns list of all known api action
|
|
# return {'status': {'code': int, 'text': string},
|
|
# 'data': {actions: ['api', 'hello', ...]}}
|
|
# '''
|
|
# actions = globals().keys()
|
|
# actions = map(lambda a: a[4:], filter(lambda a: a.startswith('api_'), actions))
|
|
# actions.sort()
|
|
# ret = {}
|
|
# #FIXME: set cache to False for login, logout, etc.
|
|
# for a in actions:
|
|
# ret[a] = {
|
|
# 'cache': True
|
|
# }
|
|
# return render_to_json_response(json_response({'actions': ret}))
|
|
|
|
#def api_apidoc(request):
|
|
# '''
|
|
# returns array of actions with documentation
|
|
# '''
|
|
# actions = globals().keys()
|
|
# actions = map(lambda a: a[4:], filter(lambda a: a.startswith('api_'), actions))
|
|
# actions.sort()
|
|
# docs = {}
|
|
# for f in actions:
|
|
# docs[f] = get_api_doc(f)
|
|
# return render_to_json_response(json_response({'actions': docs}))
|
|
|
|
|
|
#FIXME: REMOVE THIS FUNCTION WHEN THERE ARE REAL USERS!!!!
|
|
def get_user_json(u):
|
|
return {'name': 'Guest', 'group': 'guest', 'preferences': {}}
|
|
|
|
def hello(request):
|
|
'''
|
|
return {'status': {'code': int, 'text': string},
|
|
'data': {user: object}}
|
|
'''
|
|
#data = json.loads(request.POST['data'])
|
|
response = json_response({})
|
|
if request.user.is_authenticated():
|
|
response['data']['user'] = get_user_json(request.user)
|
|
else:
|
|
response['data']['user'] = {'name': 'Guest', 'group': 'guest', 'preferences': {}}
|
|
return render_to_json_response(response)
|
|
actions.register(hello)
|
|
|
|
def error(request):
|
|
'''
|
|
trows 503 error
|
|
'''
|
|
success = error_is_success
|
|
return render_to_json_response({})
|
|
actions.register(error)
|
|
|
|
def find(request):
|
|
data = json.loads(request.POST['data'])
|
|
# print json.dumps(data)
|
|
model = getModel(data)
|
|
response = json_response({})
|
|
l = model.get_list(data)
|
|
if data.has_key('ids'):
|
|
ids = data['ids']
|
|
else:
|
|
ids = []
|
|
if data.has_key('range'):
|
|
response['data']['items'] = l
|
|
else:
|
|
response['data']['items'] = len(l)
|
|
response['data']['positions'] = _get_positions(ids, l)
|
|
response['status'] = {'code': 200}
|
|
return render_to_json_response(response)
|
|
actions.register(find)
|
|
|
|
def _get_positions(ids, l):
|
|
ret = {}
|
|
i = 0
|
|
for id in ids:
|
|
for obj in l:
|
|
if obj['id'] == id:
|
|
ret[id] = i
|
|
break
|
|
i += 1
|
|
return ret
|
|
|
|
|
|
def preview(request):
|
|
data = json.loads(request.POST['data'])
|
|
if not data.has_key('id'):
|
|
return render_to_json_response({'status': {'code': 404}})
|
|
id = int(data['id'])
|
|
model = getModel(data)
|
|
response = json_response({})
|
|
response['status'] = {'code': 200}
|
|
obj = get_object_or_404(model, pk=id)
|
|
response['data'] = obj.preview_dict()
|
|
response['template'] = getTemplate(data, "preview")
|
|
return render_to_json_response(response)
|
|
actions.register(preview)
|
|
|
|
#FIXME: Generalize based on these two functions being the same.
|
|
def info(request):
|
|
data = json.loads(request.POST['data'])
|
|
id = int(data['id'])
|
|
model = getModel(data)
|
|
response = json_response({})
|
|
response['status'] = {'code': 200}
|
|
obj = get_object_or_404(model, pk=id)
|
|
response['data'] = obj.info_dict()
|
|
response['template'] = getTemplate(data, "info")
|
|
return render_to_json_response(response)
|
|
actions.register(info)
|
|
|
|
|
|
def getTemplate(data, tmpl_name):
|
|
path = join(settings.PROJECT_PATH, "templates", data['module'], data['model'], tmpl_name + ".html")
|
|
return open(path).read().strip()
|
|
|
|
def getModel(data):
|
|
module = __import__(data['module'])
|
|
return module.models.__getattribute__(data['model'])
|
|
|
|
def get_api_doc(f):
|
|
f = 'api_' + f
|
|
|
|
import sys
|
|
def trim(docstring):
|
|
if not docstring:
|
|
return ''
|
|
# Convert tabs to spaces (following the normal Python rules)
|
|
# and split into a list of lines:
|
|
lines = docstring.expandtabs().splitlines()
|
|
# Determine minimum indentation (first line doesn't count):
|
|
indent = sys.maxint
|
|
for line in lines[1:]:
|
|
stripped = line.lstrip()
|
|
if stripped:
|
|
indent = min(indent, len(line) - len(stripped))
|
|
# Remove indentation (first line is special):
|
|
trimmed = [lines[0].strip()]
|
|
if indent < sys.maxint:
|
|
for line in lines[1:]:
|
|
trimmed.append(line[indent:].rstrip())
|
|
# Strip off trailing and leading blank lines:
|
|
while trimmed and not trimmed[-1]:
|
|
trimmed.pop()
|
|
while trimmed and not trimmed[0]:
|
|
trimmed.pop(0)
|
|
# Return a single string:
|
|
return '\n'.join(trimmed)
|
|
|
|
return trim(globals()[f].__doc__)
|
|
|
|
def apidoc(request):
|
|
'''
|
|
this is used for online documentation at http://127.0.0.1:8000/api/
|
|
'''
|
|
|
|
functions = filter(lambda x: x.startswith('api_'), globals().keys())
|
|
api = []
|
|
for f in sorted(functions):
|
|
api.append({
|
|
'name': f[4:],
|
|
'doc': get_api_doc(f[4:]).replace('\n', '<br>\n')
|
|
})
|
|
context = RequestContext(request, {'api': api,
|
|
'sitename': settings.SITENAME,})
|
|
return render_to_response('api.html', context)
|
|
|
|
def jsdoc(request):
|
|
'''
|
|
Used to document OxUI JS Widgets
|
|
'''
|
|
context = RequestContext(request, {})
|
|
return render_to_response("jsdoc.html", context)
|
|
|
|
|
|
'''
|
|
ajax html snapshots
|
|
http://code.google.com/web/ajaxcrawling/docs/html-snapshot.html
|
|
'''
|
|
def html_snapshot(request):
|
|
fragment = unquote(request.GET['_escaped_fragment_'])
|
|
url = request.build_absolute_uri('/ra')
|
|
url = 'http://'+settings.URL
|
|
response = HttpResponse('sorry, server side rendering for %s!#%s not yet implemented'%(url, fragment))
|
|
return response
|