controllers.py

在线编辑器

#  ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1
# 
# The contents of this file are subject to the Mozilla Public License  
# Version
# 1.1 (the "License"); you may not use this file except in compliance  
# with
# the License. You may obtain a copy of the License at
# http://www.mozilla.org/MPL/
# 
# Software distributed under the License is distributed on an "AS IS"  
# basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the  
# License
# for the specific language governing rights and limitations under the
# License.
# 
# The Original Code is Bespin.
# 
# The Initial Developer of the Original Code is Mozilla.
# Portions created by the Initial Developer are Copyright (C) 2009
# the Initial Developer. All Rights Reserved.
# 
# Contributor(s):
# 
# ***** END LICENSE BLOCK *****
# 

import os
import urllib2
import httplib2
from urlparse import urlparse
import logging

from urlrelay import URLRelay, url, register
from paste.auth import auth_tkt
import simplejson
import tempfile
from webob import Request, Response

from bespin.config import c
from bespin.framework import expose, BadRequest
from bespin import model

log = logging.getLogger("bespin.controllers")

@expose(r'^/register/new/(?P<username>.*)$', 'POST', auth=False)
def new_user(request, response):
    try:
        username = request.kwargs['username']
        email = request.POST['email']
        password = request.POST['password']
    except KeyError:
        raise BadRequest("username, email and password are required.")
    user = request.user_manager.create_user(username, password, email)
    
    file_manager = request.file_manager
    settings_project = file_manager.get_project(user, user, 
                        "BespinSettings", create=True)
    file_manager.install_template(user, settings_project,
                                          'usertemplate')
    response.content_type = "application/json"
    response.body = "{}"
    request.environ['paste.auth_tkt.set_user'](username)
    return response()

@expose(r'^/register/userinfo/$', 'GET')
def get_registered(request, response):
    response.content_type = "application/json"
    if request.user:
        quota, amount_used = request.user.quota_info()
    else:
        quota = None
        amount_used = None
    response.body=simplejson.dumps(
        dict(username=request.username,
        quota=quota, amountUsed=amount_used)
    )
    return response()

@expose(r'^/register/login/(?P<login_username>.+)', 'POST', auth=False)
def login(request, response):
    username = request.kwargs['login_username']
    password = request.POST.get('password')
    user = request.user_manager.get_user(username)
    if not user or (user and user.password != password):
        response.status = "401 Not Authorized"
        response.body = "Invalid login"
        return response()
    
    request.environ['paste.auth_tkt.set_user'](username)
    
    response.content_type = "application/json"
    response.body="{}"
    return response()

@expose(r'^/register/logout/$')
def logout(request, response):
    request.environ['paste.auth_tkt.logout_user']()
    response.status = "200 OK"
    response.body = "Logged out"
    return response()

@expose(r'^/settings/$', 'POST')
def save_settings(request, response):
    """Saves one or more settings for the currently logged in user."""
    user = request.user
    user.settings.update(request.POST)
    # make it so that the user obj appears dirty to SQLAlchemy
    user.settings = user.settings
    return response()

@expose(r'^/settings/(?P<setting_name>.*)$', 'GET')
def get_settings(request, response):
    """Retrieves one setting or all (depending on URL)."""
    kwargs = request.kwargs
    user = request.user
    response.content_type='application/json'
    setting_name = kwargs['setting_name']
    if setting_name:
        try:
            response.body=simplejson.dumps(user.settings[setting_name])
        except KeyError:
            response.status = '404 Not Found'
            response.body = '%s not found' % setting_name
            response.content_type="text/plain"
    else:
        response.body=simplejson.dumps(user.settings)
    return response()

@expose(r'^/settings/(?P<setting_name>.+)$', 'DELETE')
def delete_setting(request, response):
    user = request.user
    kwargs = request.kwargs
    setting_name = kwargs['setting_name']
    try:
        del user.settings[setting_name]
        # get the user to appear dirty
        user.settings = user.settings
    except KeyError:
        response.status = "404 Not Found"
    return response()
    
def _split_path(request):
    path = request.kwargs['path']
    result = path.split('/', 1)
    if len(result) < 2:
        raise BadRequest("Project and path are both required.")
    return result
    
@expose(r'^/file/listopen/$', 'GET')
def listopen(request, response):
    fm = request.file_manager
    result = fm.list_open(request.user)
    response.content_type = "application/json"
    response.body = simplejson.dumps(result)
    return response()

@expose(r'^/file/at/(?P<path>.*)$', 'PUT')
def putfile(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project, create=True)
    
    fm.save_file(user, project, path,
                 request.body)
    return response()

@expose(r'^/file/at/(?P<path>.*)$', 'GET')
def getfile(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    mode = request.GET.get('mode', 'rw')
    contents = fm.get_file(user, project, path, mode)
    response.body = contents
    return response()
    
@expose(r'^/file/close/(?P<path>.*)$', 'POST')
def postfile(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    fm.close(user, project, path)
    return response()

@expose(r'^/file/at/(?P<path>.*)$', 'DELETE')
def deletefile(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    fm.delete(user, project, path)
    return response()

@expose(r'^/file/list/(?P<path>.*)$', 'GET')
def listfiles(request, response):
    fm = request.file_manager
    user = request.user
    
    path = request.kwargs['path']
    if not path:
        project = ''
        path = ''
    else:
        try:
            project, path = _split_path(request)
        except BadRequest:
            project = path
            path = ''
    
    if project:
        project = fm.get_project(user, user, project)
    
    files = fm.list_files(user, project, path)
    result = []
    for item in files:
        f = {'name' : item.short_name}
        _populate_stats(item, f)
        result.append(f)
        
    response.content_type = "application/json"
    response.body = simplejson.dumps(result)
    return response()
    
def _populate_stats(item, result):
    if isinstance(item, model.File):
        result['size'] = item.saved_size
        result['created'] = item.created.strftime("%Y%m%dT%H%M%S")
        result['modified'] = item.modified.strftime("%Y%m%dT%H%M%S")