controllers.py

在线编辑器

        result['openedBy'] = [fs.user.username for fs in item.users]
    
@expose(r'^/file/stats/(?P<path>.+)$', 'GET')
def filestats(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    file_obj = fm.get_file_object(user, project, path)
    result = {}
    _populate_stats(file_obj, result)
    response.content_type = "application/json"
    response.body = simplejson.dumps(result)
    return response()
    
@expose(r'^/edit/at/(?P<path>.*)$', 'PUT')
def save_edit(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_edit(user, project, path, 
                 request.body)
    return response()

def _get_edit_list(request, response, start_at=0):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    edits = fm.list_edits(user, project, path, start_at)
    response.content_type = "application/json"
    response.body = simplejson.dumps(edits)
    return response()

@expose(r'^/edit/list/(?P<path>.*)$', 'GET')
def list_edits(request, response):
    return _get_edit_list(request, response)

@expose(r'^/edit/recent/(?P<start_at>\d+)/(?P<path>.*)$', 'GET')
def list_recent(request, response):
    start_at = int(request.kwargs['start_at'])
    return _get_edit_list(request, response, start_at)
    
@expose(r'^/edit/reset/$', 'POST')
def reset_all(request, response):
    request.file_manager.reset_edits(request.user)
    return response()
    
@expose(r'^/edit/reset/(?P<path>.+)$', 'POST')
def reset(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    fm.reset_edits(user, project, path)
    return response()

@expose(r'^/(?P<filename>editor|dashboard)\.html', 'GET', auth=False)
def static_with_login(request, response):
    """Ensure that the user is logged in. Redirect them to the front
    page if they're not. If they are logged in, go ahead and serve
    up the static file."""
    if not 'REMOTE_USER' in request.environ:
        response.location = "/"
        response.status = "302 Not logged in"
        response.body = ""
    else:
        response.status = "200 OK"
        response.content_type = "text/html"
        response.body = open("%s/%s.html" % (c.static_dir, 
                request.kwargs['filename'])).read()
    return response()

@expose(r'^/project/import/(?P<project_name>[^/]+)', "POST")
def import_project(request, response):
    project_name = request.kwargs['project_name']
    input_file = request.POST['filedata']
    filename = input_file.filename
    _perform_import(request.file_manager, 
                    request.user, project_name, filename,
                    input_file.file)
    return response()
    
def _perform_import(file_manager, user, project_name, filename, fileobj):
    if filename.endswith(".tgz") or filename.endswith(".tar.gz"):
        func = file_manager.import_tarball
    elif filename.endswith(".zip"):
        func = file_manager.import_zipfile
    else:
        raise BadRequest(
            "Import only supports .tar.gz, .tgz and .zip at this time.")
        
    project = file_manager.get_project(user, user, project_name, clean=True)
    
    func(user,
        project, filename, fileobj)
    return
    
@expose(r'^/project/fromurl/(?P<project_name>[^/]+)', "POST")
def import_from_url(request, response):
    project_name = request.kwargs['project_name']
    
    url = request.body
    try:
        resp = httplib2.Http().request(url, method="HEAD")
    except httplib2.HttpLib2Error, e:
        raise BadRequest(str(e))
        
    # chech the content length to see if the user has enough quota
    # available before we download the whole file
    content_length = resp[0].get("content-length")
    if content_length:
        content_length = int(content_length)
        if not request.user.check_save(content_length):
            raise model.OverQuota()
    
    try:
        datafile = urllib2.urlopen(url)
    except urllib2.URLError, e:
        raise BadRequest(str(e))
    tempdatafile = tempfile.NamedTemporaryFile()
    tempdatafile.write(datafile.read())
    datafile.close()
    tempdatafile.seek(0)
    url_parts = urlparse(url)
    filename = os.path.basename(url_parts[2])
    _perform_import(request.file_manager, request.user,
                    project_name, filename, tempdatafile)
    tempdatafile.close()
    return response()

@expose(r'^/project/export/(?P<project_name>.*(\.zip|\.tgz))')
def export_project(request, response):
    fm = request.file_manager
    user = request.user
    
    project_name = request.kwargs['project_name']
    project_name, extension = os.path.splitext(project_name)
    if extension == ".zip":
        func = fm.export_zipfile
        response.content_type = "application/zip"
    else:
        response.content_type = "application/x-tar-gz"
        func = fm.export_tarball
    
    project = fm.get_project(user, user, project_name)
    
    output = func(user, project)
    def filegen():
        data = output.read(8192)
        while data:
            yield data
            data = output.read(8192)
        raise StopIteration
    response.app_iter = filegen()
    return response()
    
@expose(r'^/preview/at/(?P<path>.+)$')
def preview_file(request, response):
    fm = request.file_manager
    user = request.user
    
    project, path = _split_path(request)
    project = fm.get_project(user, user, project)
    
    file_obj = fm.get_file_object(user, project, path)
    response.body = str(file_obj.data)
    response.content_type = file_obj.mimetype
    return response()
    
@expose(r'^/project/rename/(?P<project_name>.+)/$', 'POST')
def rename_project(request, response):
    fm = request.file_manager
    user = request.user
    
    project_name = request.kwargs['project_name']
    project = fm.get_project(user, user, project_name)
    fm.rename(user, project, "", request.body)
    response.body = ""
    response.content_type = "text/plain"
    return response()
    
def db_middleware(app):
    def wrapped(environ, start_response):
        from bespin import model
        session = c.sessionmaker(bind=c.dbengine)
        environ['bespin.dbsession'] = session
        environ['bespin.docommit'] = True
        environ['user_manager'] = model.UserManager(session)
        environ['file_manager'] = model.FileManager(session)
        environ['db'] = model.DB(environ['user_manager'], environ['file_manager'])
        try:
            result = app(environ, start_response)
            if environ['bespin.docommit']:
                session.commit()
            else:
                session.rollback()
        except:
            session.rollback()
            log.exception("Error raised during request: %s", environ)
            raise
        return result
    return wrapped

def pathpopper_middleware(app, num_to_pop=1):
    def new_app(environ, start_response):
        req = Request(environ)
        for i in range(0, num_to_pop):
            req.path_info_pop()
        return app(environ, start_response)
    return new_app

def make_app():
    from webob import Response
    import static
    static_app = static.Cling(c.static_dir)
    
    docs_app = pathpopper_middleware(static.Cling(c.docs_dir))
    code_app = pathpopper_middleware(static.Cling(c.static_dir + "/js"), 2)
    
    register("^/docs/code/", code_app)
    register("^/docs/", docs_app)
    
    app = URLRelay(default=static_app)
    app = auth_tkt.AuthTKTMiddleware(app, c.secret, secure=c.secure_cookie, 
                include_ip=False, httponly=True,
                current_domain_cookie=True, wildcard_cookie=True)
    app = db_middleware(app)
    
    return app