def save(self, update_site=True, *args, **kwargs):
"""
Set default for ``publsh_date`` and ``description`` if none
given. Unless the ``update_site`` argument is ``False``, set
the site to the current site.
"""
from widget.widget_pool import get_widget
widg = get_widget(self.widget_class)
if hasattr(widg, 'Meta'):
self.author = widg.Meta.author
if hasattr(widg.Meta, 'page_less'):
self.page_less = widg.Meta.page_less
self.page = None
else:
self.author = ''
self.acts_on = ''
if self.publish_date is None:
self.publish_date = datetime.now()
if update_site:
self.site = Site.objects.get_current()
"""Some widget classes can appear on all pages.
E.g those placed in the base template
"""
if not self.page:
self.page_less = True
"""Generate Widget Title"""
if self.display_title is None:
self.display_title = "%s_%s" % (self.widget_class,
Widget.objects.count() + 1)
super(Widget, self).save(*args, **kwargs)
def widget_list(request):
"""
Renders widget options based on supplied widget
class or displays a select screen
"""
data = {}
#widget class exists so render widget options if any
ctx = RequestContext(request)
if request.user.is_superuser:
widget_form = WidgetForm(request.POST, restrict_list=None)
else:
widget_form = WidgetForm(request.POST)
widget_class = request.POST["widget_class"]
widget_class_obj = get_widget(widget_class)
#Widget has options, lets generate the options form
options_form = WidgetOptionsForm(widget_class)
if widget_form.is_valid():
extra_js = []
o = get_template("widget/options.html")
ctx.update({'options_form': options_form,
'widget_class': widget_class_obj})
model_form = get_model_form_for_widget(widget_class_obj)
if model_form:
ctx.update({'model_form': model_form})
extra_js += model_form.extra_js
options = o.render(ctx)
extra_js += options_form.extra_js
data = {'valid': False, 'type': 'fi', 'data': options, 'extra_js': extra_js}
else:
data = ajaxerror(widget_form)
return HttpResponse(json_serializer.encode(data), mimetype='application/json')
def hasOptions(self):
try:
from widget.widget_pool import get_widget
widg = get_widget(self.widget_class)
return hasattr(widg, "options")
except Exception, e:
return False
def render_widget(widget, widget_context):
"""
Render a single widgtet
"""
widget_class = get_widget(widget.widget_class)
widget_context.update({'widget': widget})
if widget_class is not None:
widget_options = None
widget_class = widget_class()
if hasattr(widget_class, "options"):
try:
widget_options = dict(((o["name"], o["value"])\
for o in widget.options.values("name", "value")))
widget_context.update({"opts": widget_options})
except Exception, e:
raise e
queryset = get_widget_model_queryset(widget, widget_class)
rendered_widget = render_template(widget_class\
._render(widget_context, widget.slot, queryset, widget_options),\
widget_class.template, raw=widget_class.raw)
return {'widget': widget,\
'meta': widget_class.Meta,\
'content': rendered_widget}
def render_widgets_for_slot(slot, widget_context):
"""
Renders all widgets assigned to a WidgetSlot
"""
page = widget_context.get("page", None)
user = widget_context["request"].user
rendered_widgets = []
"Render regular paged widgets and page less widgets (universal widgets)"
widgets = Widget.objects.published_for_page_or_pageless(page, slot, user)
for widget in widgets:
widget_class = get_widget(widget.widget_class)
widget_context.update({'widget': widget})
if widget_class is not None:
widget_options = None
widget_class = widget_class()
if hasattr(widget_class, "options"):
try:
widget_options = dict(((o["name"], o["value"])\
for o in widget.options.values("name", "value")))
widget_context.update({"opts": widget_options})
except Exception, e:
raise e
queryset = get_widget_model_queryset(widget, widget_class)
rendered_widget = render_template(widget_class\
._render(widget_context, slot, queryset, widget_options),\
widget_class.template, raw=widget_class.raw)
rendered_widgets.append({'widget': widget, \
'meta': widget_class.Meta, \
'content': rendered_widget})
def test_widget_creation(self):
test_widget = Widget()
test_widget.widget_class = "TestWidget"
test_widget.user_id = 1
widget_class = get_widget(test_widget.widget_class)
self.assertEqual(widget_class.Meta.name, "Test")
def render_widgets_for_slot(slot, widget_context):
"""
Renders all widgets assigned to a WidgetSlot
"""
page = widget_context.get("page", None)
user = widget_context["request"].user
rendered_widgets = []
"Render regular paged widgets and page less widgets (universal widgets)"
widgets = Widget.objects.published_for_page_or_pageless(page, slot, user)
for widget in widgets:
widget_class = get_widget(widget.widget_class)
widget_context.update({'widget': widget})
if widget_class is not None:
widget_options = None
widget_class = widget_class()
if hasattr(widget_class, "options"):
try:
widget_options = dict(((o["name"], o["value"]), for o in widget.options.values("name", "value")))
widget_context.update({"opts": widget_options})
except Exception, e:
raise e
queryset = get_widget_model_queryset(widget, widget_class)
rendered_widget = render_template(widget_class._render(widget_context, slot, queryset, widget_options),
widget_class.template, raw=widget_class.raw)
rendered_widgets.append({'widget': widget, 'meta': widget_class.Meta, 'content': rendered_widget})
def save(self, update_site=True, *args, **kwargs):
"""
Set default for ``publsh_date`` and ``description`` if none
given. Unless the ``update_site`` argument is ``False``, set
the site to the current site.
"""
from widget.widget_pool import get_widget
widg = get_widget(self.widget_class)
if hasattr(widg, 'Meta'):
self.author = widg.Meta.author
if hasattr(widg.Meta, 'page_less'):
self.page_less = widg.Meta.page_less
self.page = None
else:
self.author = ''
self.acts_on = ''
if self.publish_date is None:
self.publish_date = datetime.now()
if update_site:
self.site = Site.objects.get_current()
"""Some widget classes can appear on all pages.
E.g those placed in the base template
"""
if not self.page:
self.page_less = True
"""Generate Widget Title"""
if self.display_title is None:
self.display_title = "%s_%s" % (self.widget_class, Widget.objects.count()+1)
super(Widget, self).save(*args, **kwargs)
def widget_list(request):
"""
Renders widget options based on supplied widget
class or displays a select screen
"""
data = {}
#widget class exists so render widget options if any
ctx = RequestContext(request)
if request.user.is_superuser:
widget_form = WidgetForm(request.POST, restrict_list=None)
else:
widget_form = WidgetForm(request.POST)
widget_class = request.POST["widget_class"]
widget_class_obj = get_widget(widget_class)
#Widget has options, lets generate the options form
options_form = WidgetOptionsForm(widget_class)
if widget_form.is_valid():
extra_js = []
o = get_template("widget/options.html")
ctx.update({'options_form': options_form,
'widget_class': widget_class_obj})
model_form = get_model_form_for_widget(widget_class_obj)
if model_form:
ctx.update({'model_form': model_form})
extra_js += model_form.extra_js
options = o.render(ctx)
extra_js += options_form.extra_js
data = {'valid': False, 'type': 'fi', 'data': options, 'extra_js': extra_js}
else:
data = ajaxerror(widget_form)
return HttpResponse(json_serializer.encode(data), mimetype='application/json')
def hasOptions(self):
try:
from widget.widget_pool import get_widget
widg = get_widget(self.widget_class)
return hasattr(widg, "options")
except Exception, e:
return False
def edit_widget(request, **kwargs):
try:
widget = Widget.objects.get(id=kwargs.get("id"))
widget_class_obj = get_widget(widget.widget_class)
containsModel = hasModel(widget_class_obj)
if request.POST:
"get form populated with widget options"
options_form = WidgetOptionsForm(widget.widget_class, request.POST)
if options_form.is_valid():
if options_form.save(widget=widget):
data = {'valid': True, 'form': 'saved'}
elif options_form.errors:
data = ajaxerror(options_form)
if containsModel:
obj = get_widget_model_queryset(widget, widget_class_obj)
model_form = get_model_form_for_widget(widget_class_obj,
{"POST": request.POST, "FILES": request.FILES}, instance=obj,
widget=widget)
try:
if model_form.is_valid():
saved_obj = model_form.save()
data.update({"obj": saved_obj.id})
elif model_form.errors:
model_data = ajaxerror(model_form)
errors = dict(data.get("errors", {}), **model_data["errors"])
data = {'valid': False, "errors": errors}
except Exception:
raise
else:
"This is a request to get a form for widget"
ctx = RequestContext(request)
"get widget form populated with widget options"
initial = {'status': widget.status}
if widget.hasOptions:
initial.update(dict(("option_%s" % option.name, option.value), for option in widget.options.all()))
options_form = WidgetOptionsForm(widget.widget_class, data=initial)
extra_js = []
o = get_template("widget/options.html")
ctx.update({'options_form': options_form})
if containsModel:
obj = get_widget_model_queryset(widget, widget_class_obj)
model_form = get_model_form_for_widget(widget_class_obj, instance=obj, widget=widget)
if model_form:
ctx.update({'model_form': model_form})
extra_js += model_form.extra_js
options = o.render(ctx)
extra_js += options_form.extra_js
data = {'valid': False, 'type': 'ef', 'data': options, 'extra_js': extra_js}
return HttpResponse(json_serializer.encode(data), mimetype='application/json')
except Exception:
raise Http404()
def render_widget(widget, widget_context):
"""
Render a single widgtet
"""
widget_class = get_widget(widget.widget_class)
widget_context.update({'widget': widget})
if widget_class is not None:
widget_options = None
widget_class = widget_class()
if hasattr(widget_class, "options"):
try:
widget_options = dict(((o["name"], o["value"]), for o in widget.options.values("name", "value")))
widget_context.update({"opts": widget_options})
except Exception, e:
raise e
def render_widget(widget, widget_context):
"""
Render a single widgtet
"""
widget_class = get_widget(widget.widget_class)
widget_context.update({'widget': widget})
if widget_class is not None:
widget_options = None
widget_class = widget_class()
if hasattr(widget_class, "options"):
try:
widget_options = dict(((o["name"], o["value"]), for o in widget.options.values("name", "value")))
widget_context.update({"opts": widget_options})
except Exception, e:
raise e
queryset = get_widget_model_queryset(widget, widget_class)
rendered_widget = render_template(widget_class._render(widget_context, widget.slot, queryset, widget_options),
widget_class.template, raw=widget_class.raw)
return {'widget': widget, 'meta': widget_class.Meta, 'content': rendered_widget}
def render_widgets_for_slot(slot, widget_context):
"""
Renders all widgets assigned to a WidgetSlot
"""
page = widget_context.get("page", None)
user = widget_context["request"].user
rendered_widgets = []
"Render regular paged widgets and page less widgets (universal widgets)"
widgets = Widget.objects.published_for_page_or_pageless(page, slot, user)
for widget in widgets:
widget_class = get_widget(widget.widget_class)
widget_context.update({'widget': widget})
if widget_class is not None:
widget_options = None
widget_class = widget_class()
if hasattr(widget_class, "options"):
try:
widget_options = dict(((o["name"], o["value"]), for o in widget.options.values("name", "value")))
widget_context.update({"opts": widget_options})
except Exception, e:
raise e
def widget_list(request):
"""
Renders widget options based on supplied widget
class or displays a select screen
"""
data = {}
if not is_editable(Widget(), request):
response = _("Permission denied")
data = {
'error': [response],
'permission': False
}
else:
if request.POST:
"widget class exists so render widget options if any"
ctx = RequestContext(request)
widget_form = WidgetForm(request.POST)
widget_class = request.POST["widget_class"]
widget_class_obj = get_widget(widget_class)
# if hasattr(widget_class_obj, "options"):
"Widget has options, lets generate the options form"
options_form = WidgetOptionsForm(widget_class)
if widget_form.is_valid():
o = get_template("widget/options.html")
ctx.update({'options_form': options_form,
'widget_class': widget_class_obj })
options = o.render(ctx)
data = {'valid': False, 'type':'fi', 'data':options}
else:
data = ajaxerror(widget_form)
return HttpResponse(json_serializer.encode(data), mimetype='application/json')
else:
return HttpResponseRedirect("/")
def create_widget(request, **kwargs):
"""
Renders widget options based on supplied widget
class or displays a select screen
"""
data = {}
widget_class = request.POST["widget_class"]
widget_class_obj = get_widget(widget_class)
containsModel = hasModel(widget_class_obj)
slot = request.POST["widgetslot"]
try:
page = Page.objects.get(id=request.POST["page"])
### HANDLE OPTIONS FORM ####
options_form = WidgetOptionsForm(widget_class, request.POST, request.FILES)
widget = None
if options_form.is_valid():
try:
"update widget if it exists"
widget = Widget.objects.get(id=request.POST["widget"])
except Exception:
widget = Widget(widgetslot=slot,
widget_class=widget_class,
user=request.user, page=page)
widget.save()
if options_form.save(widget=widget):
data = {'valid': True, 'form': 'saved'}
elif options_form.errors:
data = ajaxerror(options_form)
if widget is None and not options_form.hasOptions and containsModel:
try:
"update widget if it exists"
widget = Widget.objects.get(id=request.POST["widget"])
except Exception:
widget = Widget(widgetslot=slot,
widget_class=widget_class,
user=request.user, page=page)
widget.save()
model_widget = None
if widget:
model_widget = widget
model_form = get_model_form_for_widget(widget_class_obj,
{"POST": request.POST, "FILES": request.FILES},
widget=model_widget
)
if model_form:
try:
if model_form.is_valid():
saved_obj = model_form.save()
data.update({"obj": saved_obj.id})
elif model_form.errors:
model_data = ajaxerror(model_form)
errors = dict(data.get("errors", {}), **model_data["errors"])
data = {'valid': False, "errors": errors}
except Exception:
raise
except Exception, e:
data = {"valid": False,
"errors": {"_all_": ["Something went wrong, please refresh the page"], "exception": e.message}}
def test_widget_class(self):
widget_class = get_widget(self.test_widgets[0].widget_class)
self.assertEqual(widget_class.Meta.name, "Test")
def create_widget(request, **kwargs):
"""
Renders widget options based on supplied widget
class or displays a select screen
"""
data = {}
widget_class = request.POST["widget_class"]
widget_class_obj = get_widget(widget_class)
containsModel = hasModel(widget_class_obj)
slot = request.POST["widgetslot"]
try:
page = Page.objects.get(id=request.POST["page"])
### HANDLE OPTIONS FORM ####
options_form = WidgetOptionsForm(widget_class, request.POST, request.FILES)
widget = None
if options_form.is_valid():
try:
"update widget if it exists"
widget = Widget.objects.get(id=request.POST["widget"])
except Exception:
widget = Widget(widgetslot=slot,
widget_class=widget_class,
user=request.user, page=page)
widget.save()
if options_form.save(widget=widget):
data = {'valid': True, 'form': 'saved'}
elif options_form.errors:
data = ajaxerror(options_form)
if widget is None and not options_form.hasOptions and containsModel:
try:
"update widget if it exists"
widget = Widget.objects.get(id=request.POST["widget"])
except Exception:
widget = Widget(widgetslot=slot,
widget_class=widget_class,
user=request.user, page=page)
widget.save()
model_widget = None
if widget: model_widget = widget
model_form = get_model_form_for_widget(widget_class_obj,
{"POST": request.POST, "FILES": request.FILES},
widget=model_widget
)
if model_form:
try:
if model_form.is_valid():
saved_obj = model_form.save()
data.update({"obj": saved_obj.id})
elif model_form.errors:
model_data = ajaxerror(model_form)
errors = dict(data.get("errors", {}), **model_data["errors"])
data = {'valid': False, "errors": errors}
except Exception:
raise
except Exception, e:
data = {"valid": False, \
"errors": {"_all_": ["Something went wrong, please refresh the page"], "exception": e.message}}
def test_widget_class(self):
widget_class = get_widget(self.test_widgets[0].widget_class)
self.assertEqual(widget_class.Meta.name, "Test")
