Changeset 1544

Timestamp:

04/30/08 13:35:20 (14 months ago)

Author:

JensDiemer

Message:

Experimental new Preferences!

• New editor used the newforms models in the plugin class
  
• Doesn't realy use the preferences (in search and find_and_replace) only display it
  
• the system_settings doesn't used, too. Only for display the data.
  
• Not ready in all cases
  
• there can exist some print debug!
  

Location:

trunk

Files:

• dev_scripts/local_tests/prefereces_test.py (added)
• pylucid/media/PyLucid/internal_page/admin_menu/sub_menu.html (modified) (1 diff)
• pylucid/media/PyLucid/internal_page/preferences/edit_form.html (modified) (1 diff)
• pylucid/media/PyLucid/internal_page/preferences/select.html (modified) (1 diff)
• pylucid/media/PyLucid/internal_page/preferences/select.js (added)
• pylucid/PyLucid/db/preferences.py (added)
• pylucid/PyLucid/install/install.py (modified) (1 diff)
• pylucid/PyLucid/models.py (modified) (3 diffs)
• pylucid/PyLucid/plugins_internal/find_and_replace/find_and_replace.py (modified) (2 diffs)
• pylucid/PyLucid/plugins_internal/plugin_admin/plugin_admin.py (modified) (1 diff)
• pylucid/PyLucid/plugins_internal/preferences/preferences.py (modified) (6 diffs, 2 props)
• pylucid/PyLucid/plugins_internal/preferences/preferences_cfg.py (modified) (1 prop)
• pylucid/PyLucid/plugins_internal/preferences/__init__.py (modified) (1 prop)
• pylucid/PyLucid/plugins_internal/search/search.py (modified) (2 diffs)
• pylucid/PyLucid/plugins_internal/system_settings (added)
• pylucid/PyLucid/plugins_internal/system_settings/system_settings.py (added)
• pylucid/PyLucid/plugins_internal/system_settings/system_settings_cfg.py (added)
• pylucid/PyLucid/plugins_internal/system_settings/__init__.py (added)
• pylucid/PyLucid/system/BasePlugin.py (modified) (2 diffs)
• pylucid/PyLucid/system/page_msg.py (modified) (1 diff)
• pylucid/PyLucid/system/plugin_import.py (added)
• pylucid/PyLucid/system/plugin_manager.py (modified) (4 diffs)

trunk/pylucid/media/PyLucid/internal_page/admin_menu/sub_menu.html

@@ -55 +55 @@
     </li>
     <li>
-        <a href="{{ commandURLprefix }}/preferences/select/">{% trans 'Low level preferneces editor' %}</a>
+        <a href="{{ commandURLprefix }}/preferences/select/">{% trans 'Preferences editor' %}</a>
     </li>
     <!--

trunk/pylucid/media/PyLucid/internal_page/preferences/edit_form.html

@@ -1 @@
-<fieldset><legend>{{ plugin_name }} - {{ pref_name }}</legend>
-<p>{{ description }}</p>
+<fieldset><legend>{{ plugin_name }}</legend>
 <form method="post" action=".">
-{{ form.as_p }}
+<ul id="input_fields">
+    {% for field in form %}
+        <li title="{{ field.help_text }}" class="{{ field.html_name }}">
+        <label for="{{ field.auto_id }}">{{ field.label }} :</label>
+        {{ field }}
+        <span class="field_help_text">{{ field.help_text }}</span>
+        {% if field.errors %}<li class="field_errors">{{ field.errors }}</li>{% endif %}
+    </li>
+    {% endfor %}
+</ul>
 <input type="submit" name="save" value="{% trans 'save' %}" />
-<input type="submit" name="validate" value="{% trans 'validate' %}" />
 <input onclick="self.location.href='{{ url_abort }}'" name="abort" value="{% trans 'abort' %}" type="reset" />
 </form>
-<p><strong>Note:</strong><br />
-{% blocktrans %}
-Validate checks only, if the input is a valid Python expression string.<br />
-It not examined if the data are logically correct.
-{% endblocktrans %}
-</p>
 </fieldset>

trunk/pylucid/media/PyLucid/internal_page/preferences/select.html

@@ -1 @@
-{% for plugin, data in preferences.items %}
-<fieldset><legend>{{ plugin }}</legend>
+<fieldset><legend>select for edit</legend>
 <ul>
-  {% for pref in data %}
-  <li><a href="{{ pref.link }}">{{ pref.name }}</a><br />
-  {{ pref.description }}</li>
-  {% endfor %}
+{% for item in preferences %}
+  <li><a href="{{ item.edit_link }}">{{ item.plugin_name }}</a> - {{ item.plugin_description }}</li>
+{% endfor %}
 </ul>
+<small>
+({% trans 'Low level edit in the' %} <a href="{{ admin_link }}" onclick="OpenInWindow(this); return false">{% trans 'django admin panel' %}</a>.)
+</small>
 </fieldset>
-{% endfor %}

trunk/pylucid/PyLucid/install/install.py

@@ -31 +31 @@
     DROP_TABLES = (
         "PyLucid_pagearchiv",
+        "PyLucid_preference2",
     )
 

trunk/pylucid/PyLucid/models.py

@@ -542 +542 @@
 
     def __unicode__(self):
-        return self.plugin_name.replace("_"," ")
-
+        txt = u"%s - %s" % (self.package_name, self.plugin_name)
+        return txt.replace(u"_",u" ")
+
+#______________________________________________________________________________
+# Preference
 
 class Preference(models.Model):
+    """
+    Stores preferences
+
+    Any pickleable Python object can be stored.
+
+    Use a small cache, so the pickle.loads() method would only be used on the
+    first access.
+
+    Note:
+        - This model has no Admin class. Because it makes no sense to edit
+            pickled data strings in the django admin panel ;)
+    """
+    plugin = models.ForeignKey("Plugin", help_text="The associated plugin")
+    repr_string = models.TextField(
+        help_text="printable representation of the newform data dictionary"
+    )
+
+    lastupdatetime = models.DateTimeField(auto_now=True, editable=False)
+    lastupdateby = models.ForeignKey(
+        User, null=True, blank=True, editable=False,
+    )
+
+    #__________________________________________________________________________
+
+    def __unicode__(self):
+        return u"Preference object for '%s'" % self.plugin
+
+    class Admin:
+        pass
+
+    class Meta:
+        # Use a new table
+        db_table = u'PyLucid_preference2'
+
+
+class PreferenceOld(models.Model):
     """
     Stores preferences for the PyLucid system and all Plugins.
@@ -648 +687 @@
     lastupdateby = models.ForeignKey(
         User, null=True, blank=True, editable=False,
-        related_name="preferences_lastupdateby",
     )
 
@@ -669 +707 @@
         return "%s '%s'" % (self.plugin, self.name)
 
+    class Meta:
+        # Use the old table
+        db_table = u'PyLucid_preference'
+
+
+#______________________________________________________________________________
 
 

trunk/pylucid/PyLucid/plugins_internal/find_and_replace/find_and_replace.py

@@ -41 +41 @@
 MAX_TERM_LEN = 150
 
+class PreferencesForm(forms.Form):
+    min_term_len = forms.IntegerField(
+        help_text="Min length of a search term",
+        initial=2, min_value=1
+    )
+    max_term_len = forms.IntegerField(
+        help_text="Max length of a search term",
+        initial=150, min_value=1, max_value=500
+    )
+
 
 # for FindReplaceForm ChoiceField
@@ -69 +79 @@
 
     def find_and_replace(self):
+        self.page_msg("Preferences:", self.preferences)
+
         context = {}
         if self.request.method == 'POST':

trunk/pylucid/PyLucid/plugins_internal/plugin_admin/plugin_admin.py

@@ -25 +25 @@
 import os
 
+from django.utils.translation import ugettext as _
 from django import newforms as forms
-from django.utils.translation import ugettext as _
 from django.conf import settings
 
+from PyLucid.system.plugin_manager import get_plugin_list, install_plugin
+from PyLucid.system.plugin_import import get_plugin_config
+from PyLucid.system.BasePlugin import PyLucidBasePlugin
 from PyLucid.models import Plugin
-from PyLucid.system.plugin_manager import get_plugin_list, get_plugin_config, \
-                                                                install_plugin
-from PyLucid.system.BasePlugin import PyLucidBasePlugin
 
 

trunk/pylucid/PyLucid/plugins_internal/preferences/preferences.py

@@ -12 +12 @@
     $LastChangedDate$
     $Rev$
-    $Author: JensDiemer $
+    $Author$
 
     :copyleft: 2008 by the PyLucid team.
@@ -26 +26 @@
 from django.utils.translation import ugettext as _
 
-from PyLucid.models import Preference
+from PyLucid.db.preferences import get_all_prefs, Preferences
 from PyLucid.system.BasePlugin import PyLucidBasePlugin
 from PyLucid.tools.data_eval import data_eval, DataEvalError
-
-INTERNAL_NAME = "[system]"
-
-
-class DataEvalField(forms.CharField):
-    def clean(self, raw_value):
-        raw_value = super(DataEvalField, self).clean(raw_value)
-        try:
-            value = data_eval(raw_value)
-        except DataEvalError, e:
-            raise ValidationError(_(u"data eval error: %s") % e)
-        else:
-            return value
-
-class PformatWidget(forms.Textarea):
-    def __init__(self, attrs=None):
-        self.attrs={'rows': '10'}
-
-    def render(self, name, value, attrs=None):
-        if not isinstance(value, basestring):
-            value = pformat(value)
-        return super(PformatWidget, self).render(name, value, attrs=None)
-
-class EditForm(forms.Form):
-    """
-    Form for editing a preferences
-    """
-    raw_value = DataEvalField(widget=PformatWidget())
 
 
@@ -63 +35 @@
 
     def _vebose_plugin_name(self, pref):
-        if pref.plugin == None:
-            return INTERNAL_NAME
-        else:
-            return pref.plugin.plugin_name.replace("_", " ")
+        return pref.plugin.plugin_name.replace("_", " ")
 
     def select(self):
@@ -72 +41 @@
         Display the sub menu
         """
-        self.context["PAGE"].title = _("Low level preferences editor")
+        self.context["PAGE"].title = _("preferences editor")
 
-        preferences = {}
-        for pref in Preference.objects.all():
-            plugin_name = self._vebose_plugin_name(pref)
+        items = []
+        for pref in get_all_prefs():
+            edit_link = self.URLs.methodLink("edit", args=pref.id)
 
-            pref.link = self.URLs.methodLink("edit", args=(pref.id, pref.name))
-
-            if plugin_name not in preferences:
-                preferences[plugin_name] = [pref]
-            else:
-                preferences[plugin_name].append(pref)
+            items.append({
+                "plugin_name": self._vebose_plugin_name(pref),
+                "plugin_description": pref.plugin.description,
+                "edit_link": edit_link,
+            })
 
         context = {
-            "preferences": preferences,
+            "preferences": items,
+            "admin_link": self.URLs.adminLink("PyLucid/preference"),
         }
         self._render_template("select", context)#, debug=True)
 
-    def edit(self, url_args=None):
+    def edit(self, url_args):
         try:
-            url_args = url_args.strip("/").split("/",1)[0]
+            url_args = url_args.strip("/")
             pref_id = int(url_args)
         except Exception, e:
@@ -98 +67 @@
             return
 
-        p = Preference.objects.get(id = pref_id)
+        p = Preferences()
+        p.init_via_id(pref_id)
+        data_dict = p.data_dict
+
+        p.load_form(self.request)
+        unbound_form = p.form
 
         if self.request.method == 'POST':
-            form = EditForm(self.request.POST)
+            form = unbound_form(self.request.POST)
             if form.is_valid():
-                value = form.cleaned_data["raw_value"]
-                if "validate" in self.request.POST:
-                    # rebuild the form for pformat with the eval data
-                    form = EditForm({"raw_value": value})
-                    self.page_msg("validate only...")
-                else:
-                    # save the form
-                    p.value = value
-                    p.save()
-                    self.page_msg.green("new value saved!")
-                    return self.select() # Display the menu
+                new_data_dict = form.cleaned_data
+                p.update_and_save(new_data_dict)
+                self.page_msg("New preferences saved.")
+                return self.select() # Display the menu
         else:
-            form = EditForm({"raw_value": p.value})
+            form = unbound_form(data_dict)
 
         context = {
             "plugin_name": self._vebose_plugin_name(p),
-            "pref_name": p.name,
-            "description": p.description,
             "form": form,
             "url_abort": self.URLs.methodLink("select"),
         }
         self._render_template("edit_form", context)#, debug=True)
-#        self._render_string_template(EDIT_TEMPLATE, context)#, debug=True)
 
 
@@ -133 +97 @@
 
 
-
-
-
-
-
-
-
-

trunk/pylucid/PyLucid/plugins_internal/search/search.py

@@ -49 +49 @@
 
 
+class PreferencesForm(forms.Form):
+    min_term_len = forms.IntegerField(
+        help_text="Min length of a search term",
+        initial=3, min_value=1
+    )
+    max_term_len = forms.IntegerField(
+        help_text="Max length of a search term",
+        initial=50, min_value=1, max_value=200
+    )
+    max_results = forms.IntegerField(
+        help_text="Number of the paged for the result page",
+        initial=20, min_value=1, max_value=200
+    )
+    text_cutout_len = forms.IntegerField(
+        help_text="The length of the text-hit-cutouts",
+        initial=50, min_value=1, max_value=200
+    )
+    text_cutout_lines = forms.IntegerField(
+        help_text="Max. cutout lines for every search term",
+        initial=5, min_value=1, max_value=20
+    )
+
 
 class SearchForm(forms.Form):
@@ -63 +85 @@
         Insert a empty search form into the page.
         """
+        self.page_msg("Preferences:", self.preferences)
         search_form = SearchForm()
         context = {

trunk/pylucid/PyLucid/system/BasePlugin.py

@@ -40 +40 @@
 from PyLucid.tools.utils import escape
 from PyLucid.system.internal_page import InternalPage, InternalPageNotFound
-from PyLucid.system.plugin_manager import get_plugin_config, debug_plugin_config
+from PyLucid.system.plugin_import import get_plugin_config, debug_plugin_config
 from PyLucid.models import Plugin
 
@@ -59 +59 @@
 
         self.current_page = self.context["PAGE"]
+        self.preferences = self.context.preferences
 
     def build_menu(self):

trunk/pylucid/PyLucid/system/page_msg.py

@@ -54 +54 @@
 
         request = context["request"]
-        self.debug_mode = request.debug
+        self.debug_mode = getattr(request, "debug", False)
 
         self._charset = settings.DEFAULT_CHARSET

trunk/pylucid/PyLucid/system/plugin_manager.py

@@ -34 +34 @@
 from django.http import HttpResponse, Http404
 
+from PyLucid.db.preferences import Preferences, preference_cache, \
+                                                        PreferenceDoesntExist
+from PyLucid.system.plugin_import import get_plugin_module, get_plugin_config
 from PyLucid.system.exceptions import *
-from PyLucid.models import Plugin, Preference
-
-
-def _import(request, from_name, object_name):
-    """
-    from 'from_name' import 'object_name'
-    """
-    try:
-        return __import__(from_name, {}, {}, [object_name])
-    except (ImportError, SyntaxError), e:
-        if request.user.is_superuser or request.debug:
-            raise
-        raise ImportError, "Can't import %s from %s: %s" % (
-            object_name, from_name, e
-        )
-
-def get_plugin_class(request, package_name, plugin_name):
-    """
-    import the plugin/plugin and returns the class object
-    """
-    plugin = _import(request,
-        from_name = ".".join([package_name, plugin_name, plugin_name]),
-        object_name = plugin_name
-    )
-    plugin_class = getattr(plugin, plugin_name)
-    return plugin_class
-
-def debug_plugin_config(page_msg, plugin_config):
-    for item in dir(plugin_config):
-        if item.startswith("_"):
-            continue
-        page_msg("'%s':" % item)
-        page_msg(getattr(plugin_config, item))
-
-def get_plugin_config(request, package_name, plugin_name,
-                            dissolve_version_string=False, extra_verbose=False):
-    """
-    imports the plugin and the config plugin and returns a merge config-object
-
-    dissolve_version_string == True -> get the version string (__version__)
-        from the plugin and put it into the config object
-    """
-    config_name = "%s_cfg" % plugin_name
-
-    def get_plugin(object_name):
-        from_name = ".".join([package_name, plugin_name, object_name])
-        if extra_verbose:
-            print "from %s import %s" % (from_name, object_name)
-        return _import(request, from_name, object_name)
-
-    config_plugin = get_plugin(config_name)
-
-    if dissolve_version_string:
-        plugin_plugin = get_plugin(plugin_name)
-
-        plugin_version = getattr(plugin_plugin, "__version__", None)
-        if plugin_version:
-            # Cleanup a SVN Revision Number
-            plugin_version = plugin_version.strip("$ ")
-        config_plugin.__version__ = plugin_version
-
-    return config_plugin
+from PyLucid.models import Plugin
+
+
+
 
 def _run(context, local_response, plugin_name, method_name, url_args,
@@ -167 +112 @@
     URLs.current_plugin = plugin_name
 
-    plugin_class=get_plugin_class(request, plugin.package_name, plugin_name)
+    plugin_module = get_plugin_module(request, plugin.package_name, plugin_name)
+
+    if plugin_name in preference_cache:
+        context.preferences = preference_cache[plugin_name]
+    else:
+        if hasattr(plugin_module, "PreferencesForm"):
+            # Get the preferences dict data from the database
+            try:
+                p = Preferences()
+                p.set_plugin(plugin)
+                p.load_from_db()
+                context.preferences = p.data_dict
+            except PreferenceDoesntExist, e:
+                error("Can't get preferences: %s" % e)
+                return
+        else:
+            # plugin has no preferences
+            context.preferences = None
+
+    plugin_class = getattr(plugin_module, plugin_name)
     class_instance = plugin_class(context, local_response)
     unbound_method = getattr(class_instance, method_name)
@@ -275 +239 @@
     return plugin
 
-def _insert_preferences(plugin, plugin_config):
-    preferences = getattr(plugin_config, "preferences", None)
-    if preferences == None:
-        # The plugin has no preferences
+
+def _insert_preferences(request, plugin, package_name, plugin_name):
+    """
+    insertet the initial values from the newforms preferences class into the
+    database.
+    """
+    plugin_module = get_plugin_module(request, package_name, plugin_name)
+
+    pref_form = getattr(plugin_module, "PreferencesForm", None)
+    if pref_form == None:
+        # Has no preferences newform class
         return
 
-    for pref in preferences:
-        print plugin, type(plugin), pref
-        Preference(
-            plugin = plugin,
-            name = pref["name"],
-            description = pref["description"],
-            value = pref["value"],
-        ).save()
+    p = Preferences()
+    p.set_plugin(plugin)
+    p.create_initial(pref_form)
+
 
 def install_plugin(request, package_name, plugin_name, active,
@@ -315 +282 @@
         package_name, plugin_name, plugin_config, active, extra_verbose
     )
-    _insert_preferences(plugin, plugin_config)
+    _insert_preferences(request, plugin, package_name, plugin_name)