View difference between Paste ID: LncqfQM2 and hWBUGX1H

 # -*- coding: utf-8 -*-
 
 """
-from django.utils.encoding import force_unicode
+Notes:
-from django.core.urlresolvers import reverse
+ - The javascript will only allow values provided by the callback. If nothing is selected, the text will revert back
-from django.forms.util import ErrorList, ValidationError
+   to the previously selected value (or blank, if nothing was set). Also no ID will be set.
-from django.utils.translation import ugettext as _
+
 -- TODO --
  - use a user-specified label-method to generate the label. Currently this is done in two places, which is not that nice
  - Write Tests
-<input type="text" class="ac_input" name="%(name)s_text" id="%(html_id)s_text" value="%(text)s"/>
+ - CSRF-Exempt neccessary?
-<input type="hidden" name="%(name)s" id="%(html_id)s" value="%(value)s" />
+ -
 
-    $(function(){
+>>> # The Models
-        $("#%(html_id)s_text").autocomplete({
+>>> class ModelB(models.Model):
-            'source': '%(url)s',
+>>>     value = models.CharField(max_length=255)
-            'minLength': 2,
+>>>
-            'select': function(event, ui) {
+>>>     def __repr__(self):
-                 $("#%(html_id)s")
+>>>         return self.value
 >>>
-                     .data('prev', ui.item.label)
+>>>
-                     .trigger('change');
+>>> class ModelA(models.Model):
-                %(callback)s
+>>>     #... some fields ...
-            },
+>>>     model_b = models.ForeignKey(ModelB)
-            'close': function(event, ui) {
+>>>
-                // dont restore the old value here. It should be better to restore it in the blur-function */
+>>>
-                /*setTimeout(function() {
+>>> # The Form
-                    var prev = $('#%(html_id)s').data('prev');
+>>> class MyForm(ModelForm):
-                    $("#%(html_id)s_text").val(prev);
+>>>     class Meta:
-                }, 100);*/
+>>>         model = ModelA
-            }
+>>>
-        })
+>>>     # Some Fields
-        .blur(function() {
+>>>     model_b = ModelAutocompleteField(ModelB, url=reverse("myproject.myapp.views.callback"))
-            var prev = $('#%(html_id)s').data('prev');
+>>>
-            $("#%(html_id)s_text").val(prev);
+>>>
-        })
+>>> # The callback in the view
-        .data("autocomplete")._renderItem = function( ul, item ) {
+>>> def callback(request):
 >>>     search_term = request.GET['term']
 >>>     matches = ModelB.objects.filter(value__contains = search_term).all()
 >>>     return_values = [{"id": match.pk, "label": match.value} for match in matches]
 >>>     return HttpResponse(simplejson.dumps(return_values))
-        };
+>>>
 """
-         // Speichern des initialien Werts
+
-        $("#%(html_id)s").data('prev', '%(value)s');
+
-    });
+from django.forms.util import ValidationError
 from django.utils.safestring import mark_safe
 
 
-class ModelAutoCompleteWidget(forms.widgets.TextInput):
+
 CLIENT_CODE = u"""
-    Autocomplete-Widget. Rendert die Inputs und das JAvascript um das AutoComplete-Field
+<input type="text" class="ac_input" name="{name}_label" id="{id}_label" value="{label}"/>
-    einzubinden. Kann nur in Verbindung mit dem ModelAutoCompleteField benutzt werden.
+<input type="hidden" name="{name}" id="{id}" value="{value}" />
-    (Fuer den Text-wert wird das Model benoetigt, es wird also vom Field an dieses Widget
+
-    weitergegeben)
+    $(function(){{
 
-    def __init__(self, url, model, callback=None, *args, **kw):
+        // Store the initial value into the hidden field
-        super(forms.widgets.TextInput, self).__init__(*args, **kw)
+        $("#{id}").data('previous_label', '{label}');
-        self.url = url
+        console.log($("#{id}_label"));
-        self.model = model
+        // attach the jquery-autocomplete to the label-input
-        self.callback = callback
+        $("#{id}_label").autocomplete({{
             'source': '{url}',
-
+            'minLength': 2, // length of inputs neccessary to trigger the autocomplete
             'select': function(event, ui) {{
                 // if a new value is selected from the autocomplete update the id-field and notify possible observer
                  $("#{id}")
-        Rendert das Widget
+
                      .data('previous_label', ui.item.label)
-            Der Name des Widgets
+                     .trigger('change')
                      .trigger('autocomplete:change', this, ui.item.id);
-            Der Wert den der Hauptinput (In diesem Fall ID) haben soll
+
             }},
-        # Defaults falls was nicht Ok ist:
+            'close': function(event, ui) {{
-        text = ''
+                // dont restore the old value here. It should be better to restore it in the blur-function
-        val = ''
+            }}
         }})
-        # Wenn Wert gegeben wurde versuchen die Daten zu holen
+        .blur(function() {{
             // if we blur (loose focus) restore the old value.
-            try:
+            // if we already selected a value, this will be the new value, otherwise it will be the old
-                text = self.model.objects.get(pk=value)
+            var previous_label = $('#{id}').data('previous_label');
-                val = value
+            $("#{id}_label").val(previous_label);
-            except Exception:
+        }})
-                pass
+        .data("ui-autocomplete")._renderItem = function( ul, item ) {{
             // Use a custom render function, so we use item.label instead of just item
             return $( "<li></li>" )
-        html_id = attrs.get('id', name)
+
-        url = self.url() if callable(self.url) else self.url
+
-        callback = u"%s(ui.item.id);" % self.callback if self.callback else ""
+
         }}
-        return mark_safe(CLIENT_CODE % dict(name=name, html_id=html_id, url=url, value=val, text=text, callback=callback))
+    }});
 </script>
 """
-    def value_from_datadict(self, data, files, name):
+
 class ModelAutocompleteWidget(forms.widgets.TextInput):
     """
     The autocomplete-widget for the autocomplete-field. This will render the above CLIENT_CODE
     containing the two inputs and the neccessary javascript.
 
-        return data.get(name, None)
+    To display the text this widget required the model, so it gets a reference. For the label-value, _repr_method is called with
     an instance of the model. Currently this defaults to repr
 
     The widget is based on a TextInput-Field
     """
-class ModelAutoCompleteField(forms.fields.CharField):
+    def __init__(self, url, model, *args, **kw):
         """
-    Autocomplete-Feld das die gelesenen Werte direkt zurueck in Django-Model-Objekte
+        Initing the Widget
-    konvertiert. Als Widget wird das AutoCOmpleteWidget von oben benutzt, was die
+        `url`
-    JavaScript-Logik und Felder korrekt fuellt.
+            The url used as callback. Must return a JSON-String in the format of [{"id": 1, "label": "..."}, {"id": 2, "label": "..."}, ...]
-    Momentan muss ein gueltiger WErt selektiert werden.
+
             The model the Autocomplete is based on
         """
         super(ModelAutocompleteWidget, self).__init__(*args, **kw)
-        'invalid_choice': mark_safe(u'Keine g&uuml;ltige Auswahl. Bitte eine g&uuml;ltige Option w&auml;hlen.'),
+        self._url = url
-        'no_choice' : mark_safe(u'Kein Eintrag ausgew&auml;hlt. Bitte w&auml;hlen sie einen Eintrag.'),
+        self._model = model
         self._repr_method = repr
 
     def render(self, name, value, attrs=None):
-    def __init__(self, model, url, callback=None,size=None, *args, **kwargs):
+
         Rendering the HTML-Code of the Widget
-        Neues AutoCOmpleteField anlegen
+
             The name of the widget. Used to specify the id- and name-tags of the input-field
         `value`
             The value is the id of the entity to display (=the id). It is used to load the label from the model
         """
 
-        self.model = model
+        # If there is a value try to load the Object
         if value != None:
-        # build attrs for widget
+            try:
                 value, label = value, self._repr_method(self._model.objects.get(pk=value))
-        attrs = {'size': size} if size else {}
+            except self.__model.DoesNotExist:
                 value, label = "", ""
-        super(ModelAutoCompleteField, self).__init__(
+        else:
-            widget = ModelAutoCompleteWidget(url=url, model=model, callback=callback, attrs=attrs),
+            value, label = "", ""
-            *args,
+
-            **kwargs)
+
         id = attrs.get('id', name)
-    def update_url(self, url):
+        _url = self._url
-        self.widget.url = url
+        _url = _url() if callable(_url) else _url
 
-    def clean(self, value):
+        return mark_safe(CLIENT_CODE.format(name=name, id=id, url=_url, value=value, label=label))
 
-        Die Methode konvertiert die ID des HiddenFields zurueck in ein Django-MOdel
+    # Not neccessary?
     #def value_from_datadict(self, data, files, name):
         """
-        # Kein WErt gegeben, es wird aber auch keiner gebraucht
+
-        if value=='' and not self.required:
+
         """
      #   return data.get(name, None)
-        # Wenn kein Wert gegeben ist kann auch kein Model gelesen werden
+
-        if value=='':
+
 
 
-        # Versuchen das Objekt zu lesen
+class ModelAutocompleteField(forms.fields.CharField):
-        try:
+
-            obj = self.model.objects.get(pk=value)
+    This field renders the associated modul-column using an hidden id-field and a visible
-        except self.model.DoesNotExist:
+    autocomplete textfield.
-            raise ValidationError(self.error_messages['invalid_choice'])
+    This inherits from CharField and just extends the init-function, for additional parameter
     and the to_python function, to convert the integer-value (Forein key) back to an instance of the Model
-        return obj
+
 
     default_error_messages = {
         'invalid_choice': mark_safe(u'Invalid Option. Please choose a valid option!'),
         'no_choice' : mark_safe(u'No option selected. Please choose a valid option!'),
     }
 
     def __init__(self, model, url, *args, **kwargs):
         """
         Create the autocomplete-field. Calls the parent-init-method and replaces the default-widget
         for a CharField with a ModelAutocompleteWidget
         `model`
             Das Model auf dem die Vervollstaendigung beruht.
         `url`
             Die URL aus der die Callbackdatan angefragt werden
         """
         self._model = model
         widget = ModelAutocompleteWidget(url=url, model=model)
         super(ModelAutocompleteField, self).__init__(widget=widget, *args, **kwargs)
 
     # Not neccessary anymore?
     #def update_url(self, url):
         #self.widget.url = url
 
     def to_python(self, value):
         """
         Converts the given value (PK of the model) to an instance of the model itself.
         If the id is not valid or empty, an appropriate ValidationError is thrown
         `value`
             The value from the POST
         """
         # if no value is given, but we arent required just return None
         if value == "" and not self.required:
             return None
 
         # If no value is given, but we need one
         elif value == "" and self.required:
             raise ValidationError(self.error_messages['no_choice'])
 
         # Else we have a value, try to load the object-instance and return it
         else:
             try:
                 return self._model.objects.get(pk=value)
             except self._model.DoesNotExist:
                 raise ValidationError(self.error_messages['invalid_choice'])