Hoe gebruik jy FckEditor se beeld oplaai en leser met mod-wsgi?

Question

Ek gebruik FckEditor binne 'n Django app gedien deur Apache / mod-wsgi. Ek wil nie PHP te installeer net vir FckEditor Andi sien FckEditor bied beeld oplaai en beeld blaai deur Python. Ek het net nog nie gevind nie 'n goeie instruksies oor hoe om dit alles op te stel.

So tans Django loop deur 'n wsgi koppelvlak met behulp van hierdie opstel:

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()

In FckEditor in die editor-> filemanager-> Connectors-> py gids is daar 'n lêer met die naam 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()

Ek moet hierdie twee dinge twee werk saam aan die hand van die wysiging van my Django wsgi lêer om die FckEditor dele korrek te dien of maak apache dien beide Django en FckEditor korrek op 'n enkele domein.

Answer 1

Edit: Uiteindelik Ek was ongelukkig met hierdie oplossing ook so ek het 'n Django app wat sorg vir die lêers wat gelaai en blaai.

Dit is die oplossing het ek uiteindelik saam gekap na die lees van die FckEditor kode:

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

Dit beskryf hoe die FCK redakteur insluit en in staat stel om foto oplaai.

Eerstens moet jy fckconfig.js wysig om die oplaai beeld te verander URL om te verwys na 'n paar URL in jou bediener.

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

Dit sal wys op die bediener relatiewe URL na die oplaai ontvang. FCK sal die opgelaaide lêer te stuur na wat hanteerder met behulp van die CGI veranderlike noem "NewFile" geïnkripteer met behulp van multipart / form-data. Ongelukkig jy sal moet implementeer / myapp / root / imageUploader, want ek dink nie die FCK verspreiding dinge kan maklik aangepas word om ander raamwerke.

Die imageUploader moet die NewFile onttrek en stoor dit iewers op die bediener. Die reaksie wat deur / myapp / root / imageUploader moet navolg die HTML gebou in /editor/.../fckoutput.py. Iets soos hierdie (whiff sjabloon formaat)

{{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>

Die {{env ...}} dinge by die top dui die tipe inhoud en aanbevole HTTP-hoofde te stuur. Die fileUrl moet die Url te wees gebruik om die beeld op die bediener vind.

Hier is die basiese stappe om die html fragment kry wat genereer die FCK redakteur widget. Die enigste moeilike deel is jy die plaas reg kliënt identifikasie in die os.environ - dis lelik maar dit is die manier waarop die FCK biblioteek werk nou (Ek geliasseer 'n fout verslag).

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

Die bogenoemde is ongetoets, maar dit is gebaseer op die onderstaande wat getoets word.

Hier is hoe om FCK redakteur te gebruik met behulp van mod-wsgi: Tegnies is dit gebruik 'n paar kenmerke van whiff (sien WHIFF.sourceforge.net ), - in werklikheid is dit deel van die reuk verspreiding -  maar die reuk funksies is maklik verwyder.

Ek weet nie hoe om dit in Django installeer, maar as Django kan wsgi programme maklik geïnstalleer word, jy moet in staat wees om dit te doen.

NOTA: FCK laat die kliënt om pretty much enigiets te spuit in HTML-bladsye - jy sal wil hê om die teruggekeer waarde ten kwade filtreer aanvalle. (Bv: sien whiff.middleware.TestSafeHTML middleware vir 'n voorbeeld van hoe om dit te doen).

    
"""
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()

Sien hierdie werk, byvoorbeeld, by http://aaron.oirt.rutgers.edu/myapp/ docs / W1500.whyIsWhiffCool .

btw: dankie. Ek nodig het om te kyk na dit in elk geval.