Wie verwenden Sie FCKEditor die Bild-Upload und Browser mit mod-wsgi?

Question

Ich bin mit FCKEditor innerhalb eines Django-App von Apache / mod-wsgi serviert. Ich will nicht, php installieren nur für FCKEditor andI sehen FCKEditor bietet Hochladen von Bildern und Bild-Browsing durch Python. Ich habe gerade nicht gefunden gute Anleitung, wie dies setzen alle auf.

So zur Zeit Django läuft durch eine wsgi Schnittstelle mit dieser Einstellung:

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 der Editor-> filemanager-> Stecker-> py Verzeichnis befindet sich eine Datei namens 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()

Ich brauche diese beiden Dinge zwei zusammenarbeiten, um durch meine django wsgi Datei Modifizieren der fckeditor Teile richtig zu dienen oder Apache beide django und fckeditor korrekt auf einer einzelnen Domäne machen dienen.

Answer 1

Edit: Letztlich war ich mit dieser Lösung unzufrieden auch so machte ich ein Django app dass kümmert sich um die Datei-Uploads und Browsing.

Dies ist die Lösung, die ich schließlich zusammen gehackt, nachdem die fckeditor Codelese:

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

Diese beschreibt, wie der FCK Editor einzubetten und Hochladen von Bildern ermöglichen.

Zuerst müssen Sie fckconfig.js bearbeiten das Hochladen von Bildern ändern URL in Ihrem Server zu einem gewissen URL zu verweisen.

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

Dies wird an den Server relativen URL verweist mit dem Hochladen zu erhalten. FCK wird die hochgeladene Datei zu diesem Handler mit dem CGI-Variable senden name "NewFile" kodiert unter Verwendung von Multipart / Form-Daten. Leider Sie haben / myapp / root / imageUploader zu implementieren, weil ich nicht glaube, die Verteilung FCK Zeug zu anderen Frameworks leicht angepasst werden kann.

Die imageUploader sollte die NewFile extrahieren und speichern irgendwo auf dem Server. Die Antwort, die von / MeineAnw / root / imageUploader sollte emulieren die HTML in /editor/.../fckoutput.py aufgebaut. So etwas wie dieses (whiff Template-Format)

{{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 ...}} Sachen an der Spitze geben Sie den Inhaltstyp und empfohlene HTTP-Header zu senden. Die fileURL sollte die URL sein verwenden Sie das Bild auf dem Server zu finden.

Hier sind die grundlegenden Schritte, um das HTML-Fragment zu erhalten, die erzeugt den Herausgeber-Widget FCK. Der einzige schwierige Teil ist, dass Sie die setzen müssen Recht Client indentification in die os.environ - es ist hässlich aber das ist die Art und Weise der FCK-Bibliothek jetzt funktioniert (eingereicht am ich einen Fehler Bericht).

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 oben ist nicht getestet, aber es basiert auf der unter dem geprüft wird.

Hier ist, wie FCK-Editor mod-wsgi zu verwenden: Technisch gesehen (es ein paar Features von WHIFF verwendet sehen WHIFF.sourceforge.net ), - in der Tat ist es ein Teil der Verteilung WHIFF -  aber die WHIFF Merkmale sind leicht entfernt werden.

Ich weiß nicht, wie es in Django zu installieren, aber wenn Django ermöglicht wsgi Anwendungen leicht installiert werden, Sie sollte es tun können.

HINWEIS: FCK kann der Client so ziemlich alles injizieren in HTML-Seiten - wollen Sie den Rückgabewert für das Böse filtern Anschläge. (ZB: siehe whiff.middleware.TestSafeHTML Middleware für ein Beispiel dafür, wie dies zu tun).

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

Sehen Sie diese Arbeiten, zum Beispiel bei http://aaron.oirt.rutgers.edu/myapp/ docs / W1500.whyIsWhiffCool .

btw: Dank. Ich musste in dieser ohnehin suchen.