Como você usa o envio de imagens de FCKEditor e navegador com mod-wsgi?

Question

Eu estou usando FCKEditor dentro de um aplicativo Django servido pelo Apache / mod-wsgi. Eu não quero instalar php apenas para FCKEditor andI ver FCKEditor upload de imagens ofertas e navegação na imagem através de Python. Eu só não encontrei boas instruções sobre como configurar isso tudo.

Assim, atualmente Django está sendo executado através de uma interface WSGI usando essa configuração:

import os, sys

DIRNAME = os.sep.join(os.path.abspath(__file__).split(os.sep)[:-3])
sys.path.append(DIRNAME)
os.environ['DJANGO_SETTINGS_MODULE'] = 'myapp.settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()

Em fckeditor na redator> filemanager-> connectors-> py diretório existe um arquivo chamado wsgi.py:

from connector import FCKeditorConnector
from upload import FCKeditorQuickUpload

import cgitb
from cStringIO import StringIO

# Running from WSGI capable server (recomended)
def App(environ, start_response):
    "WSGI entry point. Run the connector"
    if environ['SCRIPT_NAME'].endswith("connector.py"):
        conn = FCKeditorConnector(environ)
    elif environ['SCRIPT_NAME'].endswith("upload.py"):
        conn = FCKeditorQuickUpload(environ)
    else:
        start_response ("200 Ok", [('Content-Type','text/html')])
        yield "Unknown page requested: "
        yield environ['SCRIPT_NAME']
        return
    try:
        # run the connector
        data = conn.doResponse()
        # Start WSGI response:
        start_response ("200 Ok", conn.headers)
        # Send response text
        yield data
    except:
        start_response("500 Internal Server Error",[("Content-type","text/html")])
        file = StringIO()
        cgitb.Hook(file = file).handle()
    yield file.getvalue()

Eu preciso essas duas coisas dois trabalham juntos por meio de modificar meu arquivo django wsgi para servir as partes fckeditor corretamente ou fazer apache servir tanto Django e fckeditor corretamente em um único domínio.

Answer 1

Edit: Em última análise, eu estava infeliz com esta solução também por isso fiz um Django app que cuida dos upload de arquivos e navegação.

Esta é a solução que finalmente cortado juntos depois de ler o código fckeditor:

import os, sys

def fck_handler(environ, start_response):
    path = environ['PATH_INFO']
    if path.endswith(('upload.py', 'connector.py')):
        sys.path.append('/#correct_path_to#/fckeditor/editor/filemanager/connectors/py/')
        if path.endswith('upload.py'):
            from upload import FCKeditorQuickUpload
            conn = FCKeditorQuickUpload(environ)
        else:
            from connector import FCKeditorConnector
            conn = FCKeditorConnector(environ)
        try:
            data = conn.doResponse()
            start_response('200 Ok', conn.headers)
            return data
        except:
            start_response("500 Internal Server Error",[("Content-type","text/html")])
            return "There was an error"
    else:
        sys.path.append('/path_to_your_django_site/')
        os.environ['DJANGO_SETTINGS_MODULE'] = 'your_django_site.settings'
        import django.core.handlers.wsgi
        handler = django.core.handlers.wsgi.WSGIHandler()
        return handler(environ, start_response)

application = fck_handler

Answer 2

Esta descreve como incorporar o editor FCK e permitir o upload de imagem.

Primeiro você precisa editar fckconfig.js para mudar o envio de imagens URL para apontar para algum URL dentro de seu servidor.

FCKConfig.ImageUploadURL = "/myapp/root/imageUploader";

Este irá apontar para a URL do servidor em relação a receber o upload. FCK vai enviar o arquivo enviado para que manipulador usando a variável CGI nome "NewFile" codificado utilizando várias partes / forma-dados. Infelizmente você terá de implementar / myapp / root / imageUploader, porque eu não acho que o material de distribuição FCK pode ser facilmente adaptada para outras estruturas.

O imageUploader deve extrair o NewFile e armazená-lo em algum lugar no servidor. A resposta gerada por / novaaplicacao / raiz / imageUploader devem imitar o HTML construído em /editor/.../fckoutput.py. Algo como isso (formato de modelo sopro)

{{env
    whiff.content_type: "text/html",
    whiff.headers: [
        ["Expires","Mon, 26 Jul 1997 05:00:00 GMT"],
        ["Cache-Control","no-store, no-cache, must-revalidate"],
        ["Cache-Control","post-check=0, pre-check=0"],
        ["Pragma","no-cache"]
        ]
/}}

<script>
//alert("!! RESPONSE RECIEVED");
errorNumber = 0;
fileUrl = "fileurl.png";
fileName = "filename.png";
customMsg = "";
window.parent.OnUploadCompleted(errorNumber, fileUrl, fileName, customMsg);
</script>

O material {{env ...}} no topo indicar o tipo de conteúdo e recomendado cabeçalhos HTTP para enviar. O fileUrl deve ser o URL para usar para encontrar a imagem no servidor.

Aqui estão os passos básicos para obter o fragmento de HTML que gera o widget editor FCK. A única parte complicada é que você tem que colocar o indentification cliente certo para o os.environ - é feia mas essa é a forma como a biblioteca FCK funciona agora (I entrou com um bug relatório).

import fckeditor # you must have the fck editor python support installed to use this module
import os

inputName = "myInputName" # the name to use for the input element in the form
basePath = "/server/relative/path/to/fck/installation/" # the location of FCK static files
if basePath[-1:]!="/":
        basePath+="/" # basepath must end in slash
oFCKeditor = fckeditor.FCKeditor(inputName)
oFCKeditor.BasePath = basePath
oFCKeditor.Height = 300 # the height in pixels of the editor
oFCKeditor.Value = "<h1>initial html to be editted</h1>"
os.environ["HTTP_USER_AGENT"] = "Mozilla/5.0 (Macintosh; U;..." # or whatever
# there must be some way to figure out the user agent in Django right?
htmlOut = oFCKeditor.Create()
# insert htmlOut into your page where you want the editor to appear
return htmlOut

A descrição acima é testado, mas é baseado na abaixo do qual é testada.

Aqui está como usar o editor FCK utilizando mod-wsgi: Tecnicamente, ele usa um par de características de aroma (veja WHIFF.sourceforge.net ), - na verdade, é parte da distribuição cheiro - mas as características cheiro são facilmente removidos.

Eu não sei como instalá-lo em Django, mas se Django permite que aplicativos WSGI a ser instalado facilmente, você deve ser capaz de fazê-lo.

NOTA: FCK permite que o cliente para injetar praticamente qualquer coisa em páginas HTML - você vai querer filtrar o valor retornado para o mal ataques. (Por exemplo: ver whiff.middleware.TestSafeHTML middleware para um exemplo de como fazer isso).

    
"""
Introduce an FCK editor input element. (requires FCKeditor http://www.fckeditor.net/).

Note: this implementation can generate values containing code injection attacks if you
  don't filter the output generated for evil tags and values.
"""

import fckeditor # you must have the fck editor python support installed to use this module
from whiff.middleware import misc
import os

class FCKInput(misc.utility):
    def __init__(self,
                 inputName, # name for input element
                 basePath, # server relative URL root for FCK HTTP install
                 value = ""):  # initial value for input
        self.inputName = inputName
        self.basePath = basePath
        self.value = value
    def __call__(self, env, start_response):
        inputName = self.param_value(self.inputName, env).strip()
        basePath = self.param_value(self.basePath, env).strip()
        if basePath[-1:]!="/":
            basePath+="/"
        value = self.param_value(self.value, env)
        oFCKeditor = fckeditor.FCKeditor(inputName)
        oFCKeditor.BasePath = basePath
        oFCKeditor.Height = 300 # this should be a require!
        oFCKeditor.Value = value
        # hack around a bug in fck python library: need to put the user agent in os.environ
        # XXX this hack is not safe for multi threaded servers (theoretically)... need to lock on os.env
        os_environ = os.environ
        new_os_env = os_environ.copy()
        new_os_env.update(env)
        try:
            os.environ = new_os_env
            htmlOut = oFCKeditor.Create()
        finally:
            # restore the old os.environ
            os.environ = os_environ
        start_response("200 OK", [('Content-Type', 'text/html')])
        return [htmlOut]

__middleware__ = FCKInput

def test():
    env = {
        "HTTP_USER_AGENT":
        "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.14) Gecko/20080404 Firefox/2.0.0.14"
        }
    f = FCKInput("INPUTNAME", "/MY/BASE/PATH", "THE HTML VALUE TO START WITH")
    r = f(env, misc.ignore)
    print "test result"
    print "".join(list(r))

if __name__=="__main__":
    test()

Veja este trabalho, por exemplo, na http://aaron.oirt.rutgers.edu/myapp/ docs / W1500.whyIsWhiffCool .

btw: obrigado. Eu precisava olhar para isso de qualquer maneira.