ex_themes = cache.get(THEME_CACHE_KEY)
if ex_themes:
themes.extend(simplejson.loads(ex_themes))
else:
ex_themes = []
try:
watch_themes = simplejson.loads(urllib.urlopen("http://api.bootswatch.com/").read())["themes"]
ex_themes.extend(
[
{
"name": t["name"],
"description": t["description"],
"css": t["css-min"],
"thumbnail": t["thumbnail"],
}
for t in watch_themes
]
)
except Exception:
pass
cache.set(THEME_CACHE_KEY, simplejson.dumps(ex_themes), 24 * 3600)
themes.extend(ex_themes)
nodes.append(
loader.render_to_string("admin/blocks/toptheme.html", {"themes": themes, "select_css": select_css})
)
site.register_plugin(ThemePlugin, BaseAdminView)
if not self.title:
self.title = unicode(bookmark)
req = self.make_get_request("", data.items())
self.list_view = self.get_view_class(ListAdminView, model, list_per_page=10, list_editable=[])(req)
def has_perm(self):
return True
def context(self, context):
list_view = self.list_view
list_view.make_result_list()
base_fields = list_view.base_list_display
if len(base_fields) > 5:
base_fields = base_fields[0:5]
context['result_headers'] = [c for c in list_view.result_headers().cells if c.field_name in base_fields]
context['results'] = [[o for i,o in \
enumerate(filter(lambda c:c.field_name in base_fields, r.cells))] \
for r in list_view.results()]
context['result_count'] = list_view.result_count
context['page_url'] = self.bookmark.url
site.register(Bookmark, BookmarkAdmin)
site.register_plugin(BookmarkPlugin, ListAdminView)
site.register_modelview(r'^bookmark/$', BookmarkView, name='%s_%s_bookmark')
for i, yfname in enumerate(self.y_fields):
yf, yattrs, yv = lookup_field(yfname, obj, self)
datas[i]["data"].append((value, yv))
option = {'series': {'lines': { 'show': True }, 'points': { 'show': False }},
'grid': { 'hoverable': True, 'clickable': True }}
try:
xfield = self.opts.get_field(self.x_field)
if type(xfield) in (models.DateTimeField, models.DateField, models.TimeField):
option['xaxis'] = { 'mode': "time", 'tickLength': 5}
if type(xfield) is models.DateField:
option['xaxis']['timeformat'] = "%y/%m/%d";
elif type(xfield) is models.TimeField:
option['xaxis']['timeformat'] = "%H:%M:%S";
else:
option['xaxis']['timeformat'] = "%y/%m/%d %H:%M:%S";
except Exception:
pass
option.update(self.chart.get('option', {}))
content = {'data': datas, 'option': option}
json = simplejson.dumps(content, cls=JSONEncoder, ensure_ascii=False)
return HttpResponse(json)
site.register_plugin(ChartsPlugin, ListAdminView)
site.register_modelview(r'^chart/(.+)/$', ChartsView, name='%s_%s_chart')
def init_request(self, obj):
self.obj = obj
self.org_obj = obj
class DetailInlineFormsetPlugin(InlineFormsetPlugin):
def _get_formset_instance(self, inline):
formset = inline.instance_form(extra=0, max_num=0, can_delete=0)
formset.detail_page = True
if formset.helper.layout:
replace_field_to_value(formset.helper.layout, inline)
model = inline.model
opts = model._meta
fake_admin_class = type.__new__(type, '%s%sFakeAdmin' % (opts.app_label, opts.module_name), (object, ), {'model': model})
for form in formset.forms:
instance = form.instance
if instance.pk:
form.detail = self.get_view(DetailAdminUtil, fake_admin_class, instance)
return formset
def get_model_form(self, form, **kwargs):
self.formsets = [self._get_formset_instance(inline) for inline in self.inline_instances]
return form
site.register_plugin(InlineFormsetPlugin, ModelFormAdminView)
site.register_plugin(DetailInlineFormsetPlugin, DetailAdminView)
class RefreshPlugin(BaseAdminPlugin):
refresh_times = []
# Media
def get_media(self, media):
if self.refresh_times and self.request.GET.get(REFRESH_VAR):
media.add_js([self.static('exadmin/js/refresh.js')])
return media
# Block Views
def block_top_toolbar(self, context, nodes):
if self.refresh_times:
current_refresh = self.request.GET.get(REFRESH_VAR)
context.update({
'has_refresh': bool(current_refresh),
'clean_refresh_url': self.admin_view.get_query_string(remove=(REFRESH_VAR,)),
'current_refresh': current_refresh,
'refresh_times': [{
'time': r,
'url': self.admin_view.get_query_string({REFRESH_VAR: r}),
'selected': str(r) == current_refresh,
} for r in self.refresh_times],
})
nodes.append(loader.render_to_string('admin/blocks/refresh.html', context_instance=context))
site.register_plugin(RefreshPlugin, ListAdminView)
return form_list.keyOrder[key]
return None
def get_step_index(self, step=None):
"""
Returns the index for the given `step` name. If no step is given,
the current step will be used to get the index.
"""
if step is None:
step = self.steps.current
return self.get_form_list().keyOrder.index(step)
def block_before_fieldsets(self, context, nodes):
context.update(self.storage.extra_data)
context['wizard'] = {
'steps': self.steps,
'management_form': ManagementForm(prefix=self.prefix, initial={
'current_step': self.steps.current,
}),
}
nodes.append(loader.render_to_string('admin/blocks/wizard_nav.html', context_instance=context))
def block_submit_line(self, context, nodes):
context.update(self.storage.extra_data)
context['wizard'] = {
'steps': self.steps
}
nodes.append(loader.render_to_string('admin/blocks/wizard_btn.html', context_instance=context))
site.register_plugin(WizardFormPlugin, ModelFormAdminView)
class UserFieldPlugin(BaseAdminPlugin):
user_fields = []
def get_field_attrs(self, __, db_field, **kwargs):
if self.user_fields and db_field.name in self.user_fields:
return {'widget': forms.HiddenInput}
return __()
def get_form_datas(self, datas):
if self.user_fields and datas.has_key('data'):
for f in self.user_fields:
datas['data'][f] = self.user.id
return datas
site.register_plugin(UserFieldPlugin, ModelFormAdminView)
class ModelPermissionPlugin(BaseAdminPlugin):
user_can_access_owned_objects_only = False
user_owned_objects_field = 'user'
def queryset(self, qs):
if self.user_can_access_owned_objects_only and \
not self.user.is_superuser:
filters = {self.user_owned_objects_field: self.user}
qs = qs.filter(**filters)
return qs
site.register_plugin(ModelPermissionPlugin, ModelAdminView)
response.write(getattr(self, "get_%s_export" % file_type)(context))
return response
# View Methods
def result_header(self, item, field_name, row):
if self.request.GET.get("_do_") == "export":
item.export = True
if item.attr and not getattr(item.attr, "allow_export", False):
item.export = False
return item
def result_item(self, item, obj, field_name, row):
if self.request.GET.get("_do_") == "export":
item.export = True
if item.field is None and not getattr(item.attr, "allow_export", False):
item.export = False
return item
def block_top_toolbar(self, context, nodes):
if self.list_export:
context.update(
{
"form_params": self.admin_view.get_form_params({"_do_": "export"}, ("export_type",)),
"export_types": [{"type": et, "name": self.export_names[et]} for et in self.list_export],
}
)
nodes.append(loader.render_to_string("admin/exports.html", context_instance=context))
site.register_plugin(ExportPlugin, ListAdminView)
user_fields = []
def get_field_attrs(self, __, db_field, **kwargs):
if self.user_fields and db_field.name in self.user_fields:
return {"widget": forms.HiddenInput}
return __()
def get_form_datas(self, datas):
if self.user_fields and datas.has_key("data"):
for f in self.user_fields:
datas["data"][f] = self.user.id
return datas
site.register_plugin(UserFieldPlugin, ModelFormAdminView)
class ModelPermissionPlugin(BaseAdminPlugin):
user_can_access_owned_objects_only = False
user_owned_objects_field = "user"
def queryset(self, qs):
if self.user_can_access_owned_objects_only and not self.user.is_superuser:
filters = {self.user_owned_objects_field: self.user}
qs = qs.filter(**filters)
return qs
site.register_plugin(ModelPermissionPlugin, ModelAdminView)
class DetailsPlugin(BaseAdminPlugin):
show_detail_fields = []
show_all_rel_details = True
def result_item(self, item, obj, field_name, row):
if hasattr(item.field, 'rel') and isinstance(item.field.rel, models.ManyToOneRel) \
and (self.show_all_rel_details or (field_name in self.show_detail_fields)):
rel_obj = getattr(obj, field_name)
if rel_obj and self.has_model_perm(rel_obj.__class__, 'view'):
opts = rel_obj._meta
item_res_uri = reverse('%s:%s_%s_detail' % (self.admin_site.app_name, opts.app_label, opts.module_name), \
args=(getattr(rel_obj, opts.pk.attname),))
if item_res_uri:
edit_url = reverse('%s:%s_%s_change' % (self.admin_site.app_name, opts.app_label, opts.module_name), \
args=(getattr(rel_obj, opts.pk.attname),))
item.btns.append('<a data-res-uri="%s" data-edit-uri="%s" class="details-handler" rel="tooltip" title="%s"><i class="icon-info-sign"></i></a>' \
% (item_res_uri, edit_url, _(u'Details of %s' % str(rel_obj))))
return item
# Media
def get_media(self, media):
if self.show_all_rel_details or self.show_detail_fields:
media.add_js([self.static('exadmin/js/details.js')])
media.add_css({'screen': [self.static('exadmin/css/bootstrap-modal.css'), self.static('exadmin/css/form.css')]})
return media
site.register_plugin(DetailsPlugin, ListAdminView)
from django.http import HttpResponse
from django.utils import simplejson
from django.utils.html import escape
from exadmin.sites import site
from exadmin.views import BaseAdminPlugin, ModelFormAdminView
class QuickFormPlugin(BaseAdminPlugin):
def init_request(self, *args, **kwargs):
if self.request.method == 'GET' and self.request.is_ajax() or self.request.GET.get('_ajax'):
self.admin_view.add_form_template = 'admin/quick_form.html'
self.admin_view.change_form_template = 'admin/quick_form.html'
def get_context(self, context):
context['form_url'] = self.request.path
return context
site.register_plugin(QuickFormPlugin, ModelFormAdminView)
def do_action_func(self, __):
def _method():
self.revision_context_manager.set_user(self.user)
action_view = self.admin_view
comment = action_view.description % model_format_dict(self.opts)
self.revision_context_manager.set_comment(comment)
return __()
return _method
def do_action(self, __, queryset):
return self.revision_context_manager.create_revision(manage_manually=False)(self.do_action_func(__))()
site.register(Revision)
site.register(Version)
site.register_modelview(r'^recover/$', RecoverListView, name='%s_%s_recoverlist')
site.register_modelview(r'^recover/([^/]+)/$', RecoverView, name='%s_%s_recover')
site.register_modelview(r'^([^/]+)/revision/$', RevisionListView, name='%s_%s_revisionlist')
site.register_modelview(r'^([^/]+)/revision/([^/]+)/$', RevisionView, name='%s_%s_revision')
site.register_plugin(ReversionPlugin, ListAdminView)
site.register_plugin(ReversionPlugin, ModelFormAdminView)
site.register_plugin(ReversionPlugin, DeleteAdminView)
site.register_plugin(InlineRevisionPlugin, InlineModelAdmin)
site.register_plugin(ActionRevisionPlugin, BaseActionView)
def post_response(self, response):
if isinstance(response, basestring) and response != self.admin_urlname('index'):
return self._get_url(response)
return response
def get_context(self, context):
if context.has_key('delete_url'):
context['delete_url'] = self._get_url(context['delete_url'])
return context
def block_after_fieldsets(self, context, nodes):
return self._get_input()
class DeleteRelateDisplayPlugin(BaseRelateDisplayPlugin):
def post_response(self, response):
if isinstance(response, basestring) and response != self.admin_urlname('index'):
return self._get_url(response)
return response
def block_form_fields(self, context, nodes):
return self._get_input()
site.register_plugin(RelateMenuPlugin, ListAdminView)
site.register_plugin(ListRelateDisplayPlugin, ListAdminView)
site.register_plugin(EditRelateDisplayPlugin, CreateAdminView)
site.register_plugin(EditRelateDisplayPlugin, UpdateAdminView)
site.register_plugin(DeleteRelateDisplayPlugin, DeleteAdminView)
try:
layout_pos = UserSettings.objects.get(user=self.user, key=self._portal_key()).value
layout_cs = layout_pos.split('|')
for i, c in enumerate(cs):
c.fields = [fs_map.pop(j) for j in layout_cs[i].split(',') if fs_map.has_key(j)] if len(layout_cs) > i else []
if fs_map and cs:
cs[0].fields.extend(fs_map.values())
except Exception:
pass
return helper
def block_form_top(self, context, node):
# put portal key and submit url to page
return "<input type='hidden' id='_portal_key' value='%s' />" % self._portal_key()
class ModelDetailPlugin(ModelFormPlugin):
def _portal_key(self):
return '%s_%s_detail_portal' % (self.opts.app_label, self.opts.module_name)
def block_after_fieldsets(self, context, node):
# put portal key and submit url to page
return "<input type='hidden' id='_portal_key' value='%s' />" % self._portal_key()
site.register_plugin(ModelFormPlugin, ModelFormAdminView)
site.register_plugin(ModelDetailPlugin, DetailAdminView)
attrs['class'] = attrs['class'] + ' select-search'
attrs['data-search-url'] = self.admin_view.admin_urlname('%s_%s_changelist' % (to_opts.app_label, to_opts.module_name))
attrs['data-placeholder'] = _('Search for a %s') % to_opts.verbose_name
if value:
attrs['data-label'] = self.label_for_value(value)
return super(ForeignKeySearchWidget, self).render(name, value, attrs)
def label_for_value(self, value):
key = self.rel.get_related_field().name
try:
obj = self.rel.to._default_manager.using(self.db).get(**{key: value})
return '%s' % escape(Truncator(obj).words(14, truncate='...'))
except (ValueError, self.rel.to.DoesNotExist):
return ""
class RelateFieldPlugin(BaseAdminPlugin):
def get_field_style(self, attrs, db_field, style, **kwargs):
# search able fk field
if style == 'fk-ajax' and isinstance(db_field, models.ForeignKey):
if (db_field.rel.to in self.admin_view.admin_site._registry) and \
self.has_model_perm(db_field.rel.to, 'change'):
db = kwargs.get('using')
return dict(attrs or {}, widget=ForeignKeySearchWidget(db_field.rel, self.admin_view, using=db))
return attrs
site.register_plugin(RelateFieldPlugin, ModelFormAdminView)
"admin/blocks/topnav.html", {"search_models": search_models, "search_name": SEARCH_VAR}
)
)
def block_top_nav_btn(self, context, nodes):
add_models = []
site_name = self.admin_site.name
models = self.globe_add_models or self.admin_site._registry.keys()
for model in models:
app_label = model._meta.app_label
if self.has_model_perm(model, "add"):
info = (app_label, model._meta.module_name)
try:
add_models.append(
{
"title": _("Add %s") % capfirst(model._meta.verbose_name),
"url": reverse("admin:%s_%s_add" % info, current_app=site_name),
"model": model,
}
)
except NoReverseMatch:
pass
nodes.append(loader.render_to_string("admin/blocks/topnav.html", {"add_models": add_models}))
site.register_plugin(TopNavPlugin, CommAdminView)
result['errors'] = JsonErrorDict(form.errors, form).as_json()
return self.render_response(result)
class AjaxDetailPlugin(BaseAdminPlugin):
def get_response(self, __):
if not (self.request.is_ajax() or self.request.GET.get('_ajax')):
return __()
if self.request.GET.get('_format') == 'html':
self.admin_view.detail_template = 'admin/quick_detail.html'
return __()
form = self.admin_view.form_obj
layout = form.helper.layout
results = []
for p, f in layout.get_field_names():
result = self.admin_view.get_field_result(f)
results.append((result.label, result.val))
return self.render_response(SortedDict(results))
site.register_plugin(AjaxListPlugin, ListAdminView)
site.register_plugin(AjaxFormPlugin, ModelFormAdminView)
site.register_plugin(AjaxDetailPlugin, DetailAdminView)
def get_action(self, action):
if not issubclass(action, BaseActionView) or not action.has_perm(self.admin_view):
return None
return action, getattr(action, "action_name"), getattr(action, "description")
# View Methods
def result_header(self, item, field_name, row):
if item.attr and field_name == "action_checkbox":
item.classes.append("action-checkbox-column")
return item
def result_item(self, item, obj, field_name, row):
if item.field is None and field_name == u"action_checkbox":
item.classes.append("action-checkbox")
return item
# Media
def get_media(self, media):
if self.actions and self.admin_view.result_count:
media.add_js([self.static("exadmin/js/actions.js")])
return media
# Block Views
def block_results_bottom(self, context, nodes):
if self.actions and self.admin_view.result_count:
nodes.append(loader.render_to_string("admin/actions.html", context_instance=context))
site.register_plugin(ActionPlugin, ListAdminView)
pk = getattr(self.org_obj, self.org_obj._meta.pk.attname)
model_fields = [str(pk) + '-' + f.name for f in self.opts.fields]
fields = [f[len(str(pk)) + 1:] for f in request.POST.keys() if f in model_fields]
defaults = {
"form": forms.ModelForm,
"fields": fields,
"formfield_callback": self.formfield_for_dbfield,
}
form_class = modelform_factory(self.model, **defaults)
form = form_class(instance=self.org_obj, data=request.POST, files=request.FILES)
form.prefix = str(pk)
result = {}
if form.is_valid():
form.save(commit=True)
result['result'] = 'success'
result['new_data'] = form.cleaned_data
result['new_html'] = dict([(f, self.get_new_field_html(f)) for f in fields])
else:
result['result'] = 'error'
result['errors'] = JsonErrorDict(form.errors, form).as_json()
return self.render_response(result)
site.register_plugin(EditablePlugin, ListAdminView)
site.register_modelview(r'^(.+)/patch/$', EditPatchView, name='%s_%s_patch')
# Media
def get_media(self, media):
if bool(filter(lambda s: isinstance(s, DateFieldListFilter), self.filter_specs)):
media.add_js([self.static('exadmin/js/date.js')])
media.add_js([self.static('exadmin/js/daterangepicker.js')])
media.add_js([self.static('exadmin/js/bootstrap-datepicker.js')])
media.add_css({'screen': [self.static('exadmin/css/daterangepicker.css')]})
if bool(filter(lambda s: isinstance(s, RelatedFieldSearchFilter), self.filter_specs)):
media.add_js([self.static('exadmin/js/select2.js')])
media.add_js([self.static('exadmin/js/form.js')])
media.add_css({'screen': [self.static('exadmin/css/select2.css')]})
media.add_js([self.static('exadmin/js/filters.js')])
return media
# Block Views
def block_nav_menu(self, context, nodes):
if self.has_filters:
nodes.append(loader.render_to_string('admin/filters.html', context_instance=context))
def block_nav_form(self, context, nodes):
if self.search_fields:
nodes.append(loader.render_to_string('admin/blocks/search_form.html', \
{'search_var': SEARCH_VAR,
'remove_search_url': self.admin_view.get_query_string(remove=[SEARCH_VAR]),
'search_form_params': self.admin_view.get_form_params(remove=[SEARCH_VAR])}, \
context_instance=context))
site.register_plugin(FilterPlugin, ListAdminView)
