class Meta:
model = Thread
fields = (
get_fallback_fieldname('name'),
get_fallback_fieldname('description'),
'tags',
)
def post_install(self):
name_field = get_fallback_fieldname('name')
for slug in ('section', 'content', 'slideshow'):
if not StandingOutCategory.objects.filter(slug=slug).exists():
standingout_category = StandingOutCategory(context_variable=slug, slug=slug)
setattr(standingout_category, name_field, slug)
standingout_category.save()
class BaseContentSearchForm(SearchForm):
fields = SortedDict((
('name', TextSearchTerm(_(u'The name'), _(u'Name'), _(u'which name'))),
(get_fallback_fieldname('plain_description'),
TextSearchTerm(_(u'The description'), _(u'Description'),
_(u'which description'))),
))
def post_install(self):
name_field = get_fallback_fieldname('name')
for slug in ('section', 'content', 'slideshow'):
if not StandingOutCategory.objects.filter(slug=slug).exists():
standingout_category = StandingOutCategory(
context_variable=slug, slug=slug)
setattr(standingout_category, name_field, slug)
standingout_category.save()
class Meta:
verbose_name = _('base content')
verbose_name_plural = _('base contents')
translate = ('cached_plain_text', )
abstract = False
#content_view_template = 'content_view.html' # default definition by BaseContentMeta metaclass
ordering = ('position', get_fallback_fieldname('name'), )
check_slug_uniqueness = True
def _test_save_fields(self, model, field_names=None):
client = self.__client_login()
obj = model.objects.all()[0]
module_name = model._meta.module_name
app_label = model._meta.app_label
field_names = field_names or model._meta.get_all_field_names()
for field_name in field_names:
if field_name in transmeta.get_all_translatable_fields(model):
field = model._meta.get_field_by_name(transmeta.get_fallback_fieldname(field_name))[0]
else:
field = model._meta.get_field_by_name(field_name)[0]
if field_name == 'id' or field_name.endswith('_id'): # id or id fk
continue
if isinstance(field, models.FileField):
continue
url = reverse('inplace_save')
value = getattr(obj, field_name)
if isinstance(value, datetime.datetime):
value = '"1982-11-14 03:13:12"'
elif isinstance(value, datetime.date):
value = '"1982-11-14"'
elif isinstance(value, datetime.time):
value = '"03:13:12"'
else:
if hasattr(value, 'all'):
value = [str(obj_rel.pk) for obj_rel in value.model.objects.all()]
elif isinstance(value, decimal.Decimal):
value = float(value) + 10
elif (isinstance(value, string) and
isinstance(field, models.CharField) and
not isinstance(field, models.CommaSeparatedIntegerField) and
not isinstance(field, models.EmailField)):
if field.choices:
value = field.choices[0][0]
else:
value += '_save'
elif isinstance(field, models.CommaSeparatedIntegerField):
value += ',44'
elif isinstance(field, models.EmailField):
value = '*****@*****.**'
elif isinstance(field, models.ForeignKey):
value = field.rel.to.objects.all()[0].pk
elif isinstance(field, bool):
value = not value
value = json.dumps(value)
adaptor = get_adaptor_class(obj=obj, field_name=field_name)(None, obj, field_name).name
data = {'app_label': app_label,
'module_name': module_name,
'field_name': field_name,
'value': value,
'obj_id': obj.pk,
'adaptor': adaptor}
response = client.post(url, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content.decode('utf-8')).get('errors', None), False)
def createChannels(self):
from plugins.tv.models import Channel
print "Creating channels...",
for name, slug in self.channels:
(channel, created) = Channel.objects.get_or_create(slug=slug)
if created:
setattr(channel, get_fallback_fieldname('name'), name)
channel.status = 'published'
channel.save()
print "DONE"
def create_menus(sender, **kwargs):
if issubclass(sender, BaseSection):
created = kwargs.get('created', False)
instance = kwargs.get('instance')
if created:
menu_name = 'Main menu of %s' % unicode(instance)
instance.main_menu = Menu.objects.create(**{'slug': defaultfilters.slugify(menu_name),
get_fallback_fieldname('name'): menu_name})
from merengue.cache import invalidate_johnny_cache
invalidate_johnny_cache(instance.__class__, True, BaseSection)
instance.save()
class EventAdmin(BaseContentAdmin):
ordering = (get_fallback_fieldname('name'), )
exclude = ('expire_date', )
list_display = ('__unicode__', 'start', 'end', 'workflow_status',
'user_modification_date', 'last_editor')
form = EventAdminForm
if settings.USE_GIS:
list_display = list_display + ('google_minimap', )
list_filter = (
'categories',
'workflow_status',
'user_modification_date',
)
def create_itag_from_tag(sender, instance, **kwargs):
try:
instance.itag
except ITag.DoesNotExist:
itag = ITag(tag_ptr=instance)
lang = get_plugin('itags').get_config().get('main_language', None)
lang = lang and lang.value or None
if lang in dict(settings.LANGUAGES).keys():
setattr(itag, get_real_fieldname('tag_name', lang), instance.name)
else:
setattr(itag, get_fallback_fieldname('tag_name'), instance.name)
itag.save_base(raw=True)
def create_itag_from_tag(sender, instance, **kwargs):
try:
instance.itag
except ITag.DoesNotExist:
itag = ITag(tag_ptr=instance)
lang = get_plugin('itags').get_config().get('main_language', None)
lang = lang and lang.value or None
if lang in dict(settings.LANGUAGES).keys():
setattr(itag, get_real_fieldname('tag_name', lang), instance.name)
else:
setattr(itag, get_fallback_fieldname('tag_name'), instance.name)
itag.save_base(raw=True)
class ContactFormRelatedContactFormOptAdmin(RelatedModelAdmin,
ContactFormOptAdmin):
tool_name = 'contact_form_opt'
tool_label = _('contact form option')
one_to_one = False
related_field = 'contact_form'
prepopulated_fields = {'name': (get_fallback_fieldname('label'), )}
def get_form(self, request, obj=None, **kwargs):
form = super(ContactFormRelatedContactFormOptAdmin,
self).get_form(request, obj, **kwargs)
form.contactform = self.basecontent
return form
def render(self, request, place, context, block_content_relation=None,
*args, **kwargs):
(category, created) = StandingOutCategory.objects.get_or_create(slug='slideshow')
name_field = get_fallback_fieldname('name')
if (created):
setattr(category, name_field, 'slideshow')
category.save()
standingouts = StandingOut.objects.filter(standing_out_category=category)
limit = self.get_config().get('limit', None)
if limit:
standingouts = standingouts[:limit.get_value()]
return self.render_block(request, template_name='block_slideshow.html',
block_title=_('Slideshow'),
context={'standingouts': standingouts})
def clean(self):
# validate uniqueness of tag names (see #1201)
cleaned_data = super(ITagForm, self).clean()
tag_name_field = get_fallback_fieldname('tag_name')
tag_name = cleaned_data.get(tag_name_field)
qs = Tag.objects.filter(name=tag_name)
if self.instance.pk is not None:
# exclude the current object from the query if we are editing
qs = qs.exclude(pk=self.instance.pk)
if qs:
self._errors[tag_name_field] = self.error_class(
[ugettext('This tag name already exists')], )
del cleaned_data[tag_name_field]
return cleaned_data
def create_menus(sender, **kwargs):
if issubclass(sender, BaseSection):
created = kwargs.get('created', False)
instance = kwargs.get('instance')
if created:
menu_name = 'Main menu of %s' % unicode(instance)
instance.main_menu = Menu.objects.create(
**{
'slug': defaultfilters.slugify(menu_name),
get_fallback_fieldname('name'): menu_name
})
from merengue.cache import invalidate_johnny_cache
invalidate_johnny_cache(instance.__class__, True, BaseSection)
instance.save()
def clean(self):
# validate uniqueness of tag names (see #1201)
cleaned_data = super(ITagForm, self).clean()
tag_name_field = get_fallback_fieldname('tag_name')
tag_name = cleaned_data.get(tag_name_field)
qs = Tag.objects.filter(name=tag_name)
if self.instance.pk is not None:
# exclude the current object from the query if we are editing
qs = qs.exclude(pk=self.instance.pk)
if qs:
self._errors[tag_name_field] = self.error_class(
[ugettext('This tag name already exists')],
)
del cleaned_data[tag_name_field]
return cleaned_data
def inplace_chunk(context, key, default_text='Text created automatically', mode="textarea"):
"""
Render a chunk, with the possibility to edit it inplace.
``mode`` is "textarea" or "text". "textarea" will use a HTML visual editor.
"""
try:
chunk = Chunk.objects.get(key=key)
except Chunk.DoesNotExist:
content_field = get_fallback_fieldname('content')
chunk = Chunk(key=key)
setattr(chunk, content_field, default_text)
chunk.save()
return {'object': chunk,
'MEDIA_URL': context.get('MEDIA_URL', ''),
'request': context['request'],
'mode': mode,
}
def add_defined_field(self, def_field, initial_data=None):
no_read_activiti = def_field.form_builder_settings['settings'].get('noReadActiviti', False)
if def_field.field_class != 'django.forms.FileField' and initial_data and not no_read_activiti and initial_data.has_key(def_field.name):
initial_fieldname = get_fallback_fieldname('initial')
if not def_field.field_class in ('django.forms.MultipleChoiceField', 'django.forms.ModelMultipleChoiceField'):
setattr(def_field, initial_fieldname, initial_data.get(def_field.name))
else:
setattr(def_field, initial_fieldname, initial_data.getlist(def_field.name))
field_class = get_class(def_field.field_class)
field = field_class(**def_field.get_form_field_init_args(field_class))
self.fields[def_field.name] = field
if isinstance(field, forms.FileField):
field_settings_lang = def_field.form_builder_settings['settings'][django_settings.LANGUAGE_CODE]
title = field_settings_lang.get('title', None)
if title:
self.fields['%s_title' % def_field.name] = forms.CharField(initial=title, widget=forms.HiddenInput)
self.file_fields.append(def_field)
def views(request):
order_field = 'name'
try:
from transmeta import get_real_fieldname, get_fallback_fieldname
order_fallback_field = get_fallback_fieldname(order_field)
order_field = get_real_fieldname(order_field)
if order_field == order_fallback_field:
select_extra = {'%s_lower' % order_field: 'lower(%s)' % order_field}
else:
select_extra = {'%s_lower' % order_field: "lower(coalesce(%s,'')) || lower(coalesce(%s,''))" % (order_field, order_fallback_field)}
except ImportError:
select_extra = {'%s_lower' % order_field: 'lower(%s)' % order_field}
order_by = ['%s_lower' % order_field]
views = View.objects.extra(select=select_extra, order_by=order_by)
if not request.user.is_authenticated():
views = views.filter(protected=False)
return render_to_response('openresources/views.html', RequestContext(request, locals()))
def index(request):
protect_attrs = {
True: {},
False: {'protected':False}
}[request.user.is_authenticated()]
order_field = 'name'
try:
from transmeta import get_real_fieldname, get_fallback_fieldname
order_fallback_field = get_fallback_fieldname(order_field)
order_field = get_real_fieldname(order_field)
if order_field == order_fallback_field:
select_extra = {'view_order': 'lower(%s)' % order_field}
else:
select_extra = {'view_order': "lower(coalesce(%s,'')) || lower(coalesce(%s,''))" % (order_field, order_fallback_field)}
except ImportError:
select_extra = {'view_order': 'lower(%s)' % order_field}
featured_views = View.objects.filter(featured=True, **protect_attrs).extra(select=select_extra).order_by('view_order')
featured_resources = Resource.objects.filter(featured=True, **protect_attrs)
latest_resources = Resource.objects.filter(**protect_attrs).order_by('-creation_date')[:15]
upcoming_resources = Resource.objects\
.filter(tags__value_date__gte=datetime.now().replace(hour=0, minute=0, second=0, microsecond=0), tags__key='start_date', **protect_attrs)\
.extra(select={
'start_date':"select value_date from openresources_tag where resource_id = openresources_resource.id and openresources_tag.key = 'start_date'",
'end_date':"select value_date from openresources_tag where resource_id = openresources_resource.id and openresources_tag.key = 'end_date'"
})\
.order_by('tags__value_date')[:15]
try:
view_all = View.objects.get(shortname='all')
icon_mappings = view_all.mappings.exclude(icon=None)
except View.DoesNotExist:
# no "all" view - we cannot provide icon mappings
pass
context = _get_context(request)
context_form = ContextForm(instance=context)
map_attribution = settings.MAP_ATTRIBUTION
default_resource_icon = settings.DEFAULT_RESOURCE_ICON
return render_to_response('openresources/index.html', RequestContext(request, locals()))
def active_default_plugins(*args, **kwargs):
""" active default plugins and creates the portal menu in each language """
# Only want to run this signal after all application was migrated, but
# south have not a "post all migrations" signal.
# The workaround is "collab" have to be the last application migrated
if is_last_application(kwargs['app']):
# register required plugins
for plugin_dir in settings.REQUIRED_PLUGINS:
active_plugin_with_deps(plugin_dir)
# populate menu
from merengue.section.models import Menu
name_attr = get_fallback_fieldname('name')
attrs = {name_attr: 'Portal menu', 'slug': settings.MENU_PORTAL_SLUG}
try:
portal_menu = Menu.objects.get(slug=settings.MENU_PORTAL_SLUG)
except Menu.DoesNotExist:
# creating portal menu if does not exist
portal_menu = Menu.objects.create(**attrs)
for lang_code, lang_text in settings.LANGUAGES:
setattr(portal_menu, 'name_%s' % lang_code, ugettext('portal menu'))
portal_menu.save()
def inplace_chunk(context,
key,
default_text='Text created automatically',
mode="textarea"):
"""
Render a chunk, with the possibility to edit it inplace.
``mode`` is "textarea" or "text". "textarea" will use a HTML visual editor.
"""
try:
chunk = Chunk.objects.get(key=key)
except Chunk.DoesNotExist:
content_field = get_fallback_fieldname('content')
chunk = Chunk(key=key)
setattr(chunk, content_field, default_text)
chunk.save()
return {
'object': chunk,
'MEDIA_URL': context.get('MEDIA_URL', ''),
'request': context['request'],
'mode': mode,
}
def active_default_plugins(*args, **kwargs):
""" active default plugins and creates the portal menu in each language """
# Only want to run this signal after all application was migrated, but
# south have not a "post all migrations" signal.
# The workaround is "collab" have to be the last application migrated
if is_last_application(kwargs['app']):
# register required plugins
for plugin_dir in settings.REQUIRED_PLUGINS:
active_plugin_with_deps(plugin_dir)
# populate menu
from merengue.section.models import Menu
name_attr = get_fallback_fieldname('name')
attrs = {name_attr: 'Portal menu', 'slug': settings.MENU_PORTAL_SLUG}
try:
portal_menu = Menu.objects.get(slug=settings.MENU_PORTAL_SLUG)
except Menu.DoesNotExist:
# creating portal menu if does not exist
portal_menu = Menu.objects.create(**attrs)
for lang_code, lang_text in settings.LANGUAGES:
setattr(portal_menu, 'name_%s' % lang_code,
ugettext('portal menu'))
portal_menu.save()
def render(self,
request,
place,
context,
block_content_relation=None,
*args,
**kwargs):
(category,
created) = StandingOutCategory.objects.get_or_create(slug='slideshow')
name_field = get_fallback_fieldname('name')
if (created):
setattr(category, name_field, 'slideshow')
category.save()
standingouts = StandingOut.objects.filter(
standing_out_category=category)
limit = self.get_config().get('limit', None)
if limit:
standingouts = standingouts[:limit.get_value()]
return self.render_block(request,
template_name='block_slideshow.html',
block_title=_('Slideshow'),
context={'standingouts': standingouts})
class PortalLinkAdmin(BaseAdmin):
list_display = BaseAdmin.list_display + ('category', )
list_filter = ('visible_by_roles', 'category', )
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
form = PortalLinkForm
def has_add_permission(self, request):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return perms_api.has_global_permission(request.user, 'manage_link')
def has_change_permission(self, request, obj=None):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return self.has_add_permission(request)
def has_delete_permission(self, request, obj=None):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return self.has_add_permission(request)
class TransitionRelatedModelAdmin(RelatedModelAdmin):
tool_name = 'transitions'
tool_label = _('transitions')
related_field = 'workflow'
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
def has_delete_permission(self, request, obj=None):
if obj and obj.slug in settings.STATIC_WORKFLOW_DATA['transitions']:
return False
elif obj:
return True
else:
if request.method == 'POST' and \
request.POST.get('action', None) == u'delete_selected':
selected_objs = [
Transition.objects.get(id=int(key))
for key in request.POST.getlist('_selected_action')
]
for sel_obj in selected_objs:
if not self.has_delete_permission(request, sel_obj):
return False
return True
return False
def get_form(self, request, obj=None, **kwargs):
form = super(TransitionRelatedModelAdmin,
self).get_form(request, obj, **kwargs)
if obj:
workflow = obj.workflow
form.base_fields['destination'].queryset = State.objects.filter(
workflow=workflow)
if obj.slug in settings.STATIC_WORKFLOW_DATA['transitions']:
set_field_read_only(form.base_fields['slug'], 'slug', obj)
else:
form.base_fields[
'destination'].queryset = self.basecontent.states.all()
return form
class ThreadRelatedAdmin(RelatedModelAdmin):
html_fields = ('description', )
removed_fields = (
'map_icon',
'commentable',
)
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
exclude = ('adquire_global_permissions', )
related_field = 'forum'
def get_form(self, request, obj=None, **kwargs):
if obj:
form = super(RelatedModelAdmin,
self).get_form(request, obj, **kwargs)
else:
form = super(ThreadRelatedAdmin,
self).get_form(request, obj, **kwargs)
return form
def save_form(self, request, form, change):
if not change:
form.instance.user = request.user
if not self.related_field in form.base_fields.keys():
form.cleaned_data[self.related_field] = self.basecontent
return super(RelatedModelAdmin, self).save_form(request, form, change)
def response_change(self, request, obj):
if '_continue' in request.POST.keys():
# we need change request.path because manager may change the forum
# of this thread, and then you have to redirect to the new
# forum->thread related admin (see #997)
request.path = obj.get_admin_absolute_url()
return super(ThreadRelatedAdmin, self).response_change(request, obj)
def has_change_permission(self, request, obj=None):
return self.has_add_permission(request)
def from_jquery_to_django_forms(form, form_data):
fields = {}
for key in form_data.keys():
if key.startswith(u'fields'):
field, attr = key.split('.')
if field in fields:
fields[field][attr] = form_data.get(key)
else:
fields[field] = {attr: form_data.get(key)}
form_settings = json.loads(form_data.get('settings'))['es']
setattr(form, transmeta.get_fallback_fieldname('title'), form_settings['name'])
for key in fields.keys():
field_data = fields[key]
if not field_data['id'] or field_data['id'] == 'null':
field = FormDefinitionField(form_definition=form)
else:
try:
field = FormDefinitionField.objects.get(id=field_data['id'],
form_definition=form)
except FormDefinitionField.DoesNotExists:
field = FormDefinitionField(id=field_data['id'],
form_definition=form)
if field_data['status'] == 'D' and field.pk:
field.delete()
continue
field.name = field_data['name'].encode('ascii', 'ignore')
field.position = field_data['sequence']
field.field_class = FIELDS_MAPPING[field_data['type']]
field_settings = json.loads(field_data['settings'])
field_settings_lang = field_settings[settings.LANGUAGE_CODE]
setattr(field, transmeta.get_fallback_fieldname('label'), field_settings_lang.get('label', ''))
setattr(field, transmeta.get_fallback_fieldname('help_text'), field_settings_lang.get('description', ''))
setattr(field, transmeta.get_fallback_fieldname('initial'), field_settings_lang.get('value', ''))
field.required = field_settings.get('required', False)
options = field_settings.get('options', [])
if options:
choice_labels = []
choice_values = []
for opt in options:
choice_labels.append(opt[0])
choice_values.append(opt[1])
setattr(field, transmeta.get_fallback_fieldname('choice_labels'), "\n".join(choice_labels))
field.choice_values = "\n".join(choice_values)
radios = field_settings.get('radios', [])
if radios:
choice_labels = []
choice_values = []
field.widget = 'django.forms.widgets.RadioSelect'
for rad in radios:
choice_labels.append(rad[0])
choice_values.append(rad[1])
setattr(field, transmeta.get_fallback_fieldname('choice_labels'), "\n".join(choice_labels))
field.choice_values = "\n".join(choice_values)
if field_data['type'] == 'TextField':
field.widget = 'django.forms.widgets.Textarea'
field.form_builder_settings = {
'settings': field_settings,
'type': field_data['type'],
}
field.save()
form.save()
class Meta:
verbose_name = _('State')
verbose_name_plural = _('States')
translate = ('name', )
ordering = (get_fallback_fieldname('name'), )
class Deserializer(xml_serializer.Deserializer):
"""
Deserialize XML.
Like Django XML deserializer, with these improvements:
* Translations fields support.
* Option for not overwrite objects previously loaded in your site.
"""
def next(self):
for event, node in self.event_stream:
if event == "START_ELEMENT" and node.nodeName == "object":
if node.hasAttribute("overwrite") and \
node.getAttribute("overwrite") == 'no':
Model = self._get_model_from_node(node, "model")
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
if not node.hasAttribute("compare-by"):
filters = {'pk': Model._meta.pk.to_python(pk)}
else: # comparing by custom field defined in the fixture
field = str(node.getAttribute("compare-by"))
value = node.getAttribute(field)
filters = {field: value}
if Model._base_manager.filter(**filters):
# if object is found we will not overwrite it
# because is marked as non overridable
continue
self.event_stream.expandNode(node)
return self._handle_object(node)
raise StopIteration
def _handle_object(self, node):
"""
Convert an <object> node to a DeserializedObject.
"""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node, "model")
# Start building a data dictionary from the object. If the node is
# missing the pk attribute, fail.
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
data = {Model._meta.pk.attname: Model._meta.pk.to_python(pk)}
# Also start building a dict of m2m data (this is saved as
# {m2m_accessor_attribute : [list_of_related_objects]})
m2m_data = {}
# Deseralize each field.
for field_node in node.getElementsByTagName("field"):
# If the field is missing the name attribute, bail (are you
# sensing a pattern here?)
field_name = field_node.getAttribute("name")
if not field_name:
raise base.DeserializationError(
"<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly.
try:
field = Model._meta.get_field(field_name)
except FieldDoesNotExist, e:
try:
language = get_field_language(field_name)
except:
raise e
else:
lang_codes = [l[0] for l in settings.LANGUAGES]
if language not in lang_codes:
# fails silently because the LANGUAGES in these settings
# are not same as fixtures data
continue
else:
raise e
# As is usually the case, relation fields get the special treatment.
if field.rel and isinstance(field.rel, models.ManyToManyRel):
m2m_data[field.name] = self._handle_m2m_field_node(
field_node, field)
elif field.rel and isinstance(field.rel, models.ManyToOneRel):
data[field.attname] = self._handle_fk_field_node(
field_node, field)
else:
if field_node.getElementsByTagName('None'):
value = None
else:
value = field.to_python(
xml_serializer.getInnerText(field_node).strip())
data[field.name] = value
# check there is not any mandatory translatable fields in the fixtures without
# a value in the fallback language. In that case use the english language.
# This is to make the initial fixtures work in languages not included by default
# in fixtures
for trans_field in get_all_translatable_fields(Model):
fallback_fieldname = get_fallback_fieldname(trans_field)
if Model._meta.get_field(fallback_fieldname).null:
continue # not a mandatory field
en_fieldname = get_real_fieldname(trans_field, 'en')
if data.get(fallback_fieldname, None) is None and data.get(
en_fieldname, None) is not None:
data[fallback_fieldname] = data[en_fieldname]
obj = Model(**data)
for field in obj._meta.local_fields:
if isinstance(field, JSONField):
field_name = field.name
setattr(obj, field_name,
getattr(obj, 'get_%s_json' % field_name)())
# Return a DeserializedObject so that the m2m data has a place to live.
return DeserializedObject(obj, m2m_data)
def test_save_fields_news(self):
obj = News.objects.filter(
**{transmeta.get_fallback_fieldname('description'): ''})[0]
self._test_save_fields(News,
obj=obj,
field_names=['title', 'description'])
def _test_save_fields(self,
model,
obj=None,
field_names=None,
client=None,
has_error=False):
client = client or self.__client_login()
obj = obj or model.objects.all()[0]
self.assertEqual(model, obj.__class__)
module_name = get_module_name(model)
app_label = model._meta.app_label
field_names = field_names or model._meta.get_all_field_names()
for field_name in field_names:
extra_data = {}
if field_name in transmeta.get_all_translatable_fields(model):
field = model._meta.get_field_by_name(
transmeta.get_fallback_fieldname(field_name))[0]
else:
field = model._meta.get_field_by_name(field_name)[0]
if field_name == 'id' or field_name.endswith('_id'): # id or id fk
continue
url = reverse('inplace_save')
value = getattr(obj, field_name)
if isinstance(field, models.FileField):
value = '"example1.jpg"'
file_path = os.path.join(settings.MEDIA_ROOT, 'images',
'example1.jpg')
extra_data['attachment'] = open(file_path, 'rb')
elif isinstance(value, datetime.datetime):
value = '"1982-11-14 03:13:12"'
elif isinstance(value, datetime.date):
value = '"1982-11-14"'
elif isinstance(value, datetime.time):
value = '"03:13:12"'
else:
if hasattr(value, 'all'):
value = [
str(obj_rel.pk)
for obj_rel in value.model.objects.all()
]
elif isinstance(value, decimal.Decimal):
value = float(value) + 10
elif (isinstance(value, string)
and isinstance(field, models.CharField) and
not isinstance(field, models.CommaSeparatedIntegerField)
and not isinstance(field, models.EmailField)):
if field.choices:
value = field.choices[0][0]
else:
value += '_save'
elif isinstance(field, models.CommaSeparatedIntegerField):
value += ',44'
elif isinstance(field, models.EmailField):
value = '*****@*****.**'
elif isinstance(field, models.ForeignKey):
value = field.rel.to.objects.all()[0].pk
elif isinstance(field, bool):
value = not value
value = json.dumps(value)
adaptor = get_adaptor_class(obj=obj,
field_name=field_name)(None, obj,
field_name).name
data = {
'app_label': app_label,
'module_name': module_name,
'field_name': field_name,
'value': value,
'obj_id': obj.pk,
'adaptor': adaptor
}
data.update(extra_data)
response = client.post(url, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(
bool(
json.loads(response.content.decode('utf-8')).get(
'errors', None)), has_error)
def __init__(self, forum, *args, **kwargs):
super(CreateThreadForm, self).__init__(*args, **kwargs)
self.forum = forum
self.fields[get_fallback_fieldname('name')].label = _('Name')
self.fields[get_fallback_fieldname('description')].label = _(
'Description')
class MenuAdmin(BaseAdmin):
list_display = ('level', 'display_move_to', 'name', 'slug', )
list_display_links = ('name', )
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
ordering = ('lft', )
actions = []
inherit_actions = False
inlines = [AbsoluteLinkInline, ContentLinkInline, ViewletLinkInline]
form = MenuAdminModelForm
menu_slug = None
class Media:
css = {'all': ('merengue/css/ajaxautocompletion/jquery.autocomplete.css',
'merengue/css/ajax_select/iconic.css')}
js = ('merengue/js/ajaxautocompletion/jquery.autocomplete.js',
'merengue/js/ajax_select/ajax_select.js')
def __init__(self, *args, **kwargs):
super(MenuAdmin, self).__init__(*args, **kwargs)
self.old_inline_instances = [instance for instance in self.inline_instances]
def get_menu(self, request, *args, **kwargs):
return Menu.tree.get(slug=self.menu_slug or settings.MENU_PORTAL_SLUG)
def queryset(self, request):
return self.get_menu(request).get_descendants()
def has_add_permission(self, request):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return perms_api.has_global_permission(request.user, 'manage_menu')
def has_change_permission(self, request, obj=None):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return self.has_add_permission(request)
def has_delete_permission(self, request, obj=None):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return self.has_add_permission(request)
def display_move_to(self, menu):
hidden = u'<input type="hidden" class="thisMenu" name="next" value="%s" />' % menu.id
init_move = u'<a href="#" class="initMoveMenu" title="%(title)s">%(title)s</a>' % {'title': ugettext(u'Move this menu')}
cancel_move = u'<a href="#" class="cancelMoveMenu hide" title="%(title)s">%(title)s</a>' % {'title': ugettext(u'Cancel move')}
options = (
u'<li><a href="#" class="insertPrev" title="%(title)s">%(title)s</a></li>' % {'title': ugettext(u'Before')},
u'<li><a href="#" class="insertNext" title="%(title)s">%(title)s</a></li>' % {'title': ugettext(u'After')},
u'<li><a href="#" class="insertChild" title="%(title)s">%(title)s</a></li>' % {'title': ugettext(u'Child')},
)
options = u'<ul class="insertOptions hide">' + u''.join(options) + u'</ul>'
return mark_safe('%s%s%s%s' % (hidden, init_move, cancel_move, options))
display_move_to.allow_tags = True
def get_formsets(self, request, obj=None):
self.inline_instances = []
res = []
for inline in self.old_inline_instances:
formset = inline.get_formset(request, obj)
if formset:
self.inline_instances.append(inline)
res.append(formset)
return res
def get_form(self, request, obj=None, **kwargs):
form = super(MenuAdmin, self).get_form(request, obj, **kwargs)
form.section = getattr(self, 'basecontent', None)
return form
def move_menus(self, request):
source_id = request.GET.pop('source', None)
target_id = request.GET.pop('target', None)
movement = request.GET.pop('movement', None)
if not source_id and not target_id and not movement:
return
if source_id and target_id and movement:
query = self.queryset(request)
try:
source_menu = query.get(id=source_id[0])
target_menu = query.get(id=target_id[0])
source_menu.move_to(target_menu, movement[0])
return source_id[0]
except:
pass
def changelist_view(self, request, extra_context={}):
source = self.move_menus(request)
media = self.media
media.add_js([settings.MEDIA_URL + "merengue/js/section/CollapsableMenuTree.js"])
extra_context.update({'media': media.render(),
'moved_source': source})
return super(MenuAdmin, self).changelist_view(request, extra_context)
class StateRelatedModelAdmin(RelatedModelAdmin):
tool_name = 'states'
tool_label = _('states')
related_field = 'workflow'
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
def has_delete_permission(self, request, obj=None):
if obj and obj.slug in settings.STATIC_WORKFLOW_DATA['states']:
return False
elif obj:
return True
else:
if request.method == 'POST' and \
request.POST.get('action', None) == u'delete_selected':
selected_objs = [
State.objects.get(id=int(key))
for key in request.POST.getlist('_selected_action')
]
for sel_obj in selected_objs:
if not self.has_delete_permission(request, sel_obj):
return False
return True
return False
def get_urls(self):
from django.conf.urls.defaults import patterns
def wrap(view):
def wrapper(*args, **kwargs):
#kwargs['model_admin'] = self
return self.admin_site.admin_view(view)(*args, **kwargs)
return update_wrapper(wrapper, view)
urls = super(StateRelatedModelAdmin, self).get_urls()
my_urls = patterns(
'', (r'^([^/]+)/permissions/$', wrap(self.permissions_view)))
return my_urls + urls
def get_form(self, request, obj=None, **kwargs):
form = super(StateRelatedModelAdmin,
self).get_form(request, obj, **kwargs)
if obj:
workflow = obj.workflow
form.base_fields[
'transitions'].queryset = Transition.objects.filter(
workflow=workflow)
if obj.slug in settings.STATIC_WORKFLOW_DATA['states']:
set_field_read_only(form.base_fields['slug'], 'slug', obj)
else:
form.base_fields[
'transitions'].queryset = self.basecontent.transitions.all()
return form
def object_tools(self, request, mode, url_prefix):
tools = super(StateRelatedModelAdmin,
self).object_tools(request, mode, url_prefix)
if mode == 'change':
tools = [{
'url': url_prefix + 'permissions/',
'label': ugettext('Permissions'),
'class': 'permissions',
'permission': 'change'
}] + tools
return tools
def permissions_view(self,
request,
object_id,
extra_context=None,
parent_model_admin=None,
parent_object=None):
extra_context = self._update_extra_context(request, extra_context,
parent_model_admin,
parent_object)
state = get_object_or_404(State, id=object_id)
roles = Role.objects.all()
permissions = [
i.permission
for i in parent_object.workflowpermissionrelation_set.all()
]
if request.method == 'POST':
state_perms = request.POST.getlist('selected_perm')
for perm in permissions:
for role in roles:
rel_id = '%s_%s' % (role.id, perm.id)
if rel_id in state_perms:
StatePermissionRelation.objects.get_or_create(
role=role, permission=perm, state=state)
else:
StatePermissionRelation.objects.filter(
permission=perm, role=role, state=state).delete()
msg = ugettext('State permissions were saved successfully. To make your changes effective you have to update permissions <a href="%(url)s">here</a>') \
% {'url': reverse('admin:update_permissions')}
self.message_user(request, msg)
return HttpResponseRedirect('..')
role_permissions = {}
for perm in permissions:
role_permissions[perm] = []
for role in roles:
role_permissions[perm].append(
(role,
StatePermissionRelation.objects.filter(
role=role, permission=perm, state=state) and True
or False))
context = {
'roles': roles,
'role_permissions': role_permissions,
'model_admin': self,
'original': state,
'title': _(u'Manage state permissions'),
}
context.update(extra_context)
return render_to_response('admin/workflow/state_permissions.html',
context,
context_instance=template.RequestContext(
request,
current_app=self.admin_site.name))
def _test_save_fields(self, model, obj=None, field_names=None, client=None, has_error=False):
client = client or self.__client_login()
obj = obj or model.objects.all()[0]
self.assertEqual(model, obj.__class__)
module_name = model._meta.module_name
app_label = model._meta.app_label
field_names = field_names or model._meta.get_all_field_names()
for field_name in field_names:
extra_data = {}
if field_name in transmeta.get_all_translatable_fields(model):
field = model._meta.get_field_by_name(transmeta.get_fallback_fieldname(field_name))[0]
else:
field = model._meta.get_field_by_name(field_name)[0]
if field_name == "id" or field_name.endswith("_id"): # id or id fk
continue
url = reverse("inplace_save")
value = getattr(obj, field_name)
if isinstance(field, models.FileField):
value = '"example1.jpg"'
file_path = os.path.join(settings.MEDIA_ROOT, "images", "example1.jpg")
extra_data["attachment"] = open(file_path, "rb")
elif isinstance(value, datetime.datetime):
value = '"1982-11-14 03:13:12"'
elif isinstance(value, datetime.date):
value = '"1982-11-14"'
elif isinstance(value, datetime.time):
value = '"03:13:12"'
else:
if hasattr(value, "all"):
value = [str(obj_rel.pk) for obj_rel in value.model.objects.all()]
elif isinstance(value, decimal.Decimal):
value = float(value) + 10
elif (
isinstance(value, string)
and isinstance(field, models.CharField)
and not isinstance(field, models.CommaSeparatedIntegerField)
and not isinstance(field, models.EmailField)
):
if field.choices:
value = field.choices[0][0]
else:
value += "_save"
elif isinstance(field, models.CommaSeparatedIntegerField):
value += ",44"
elif isinstance(field, models.EmailField):
value = "*****@*****.**"
elif isinstance(field, models.ForeignKey):
value = field.rel.to.objects.all()[0].pk
elif isinstance(field, bool):
value = not value
value = json.dumps(value)
adaptor = get_adaptor_class(obj=obj, field_name=field_name)(None, obj, field_name).name
data = {
"app_label": app_label,
"module_name": module_name,
"field_name": field_name,
"value": value,
"obj_id": obj.pk,
"adaptor": adaptor,
}
data.update(extra_data)
response = client.post(url, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(bool(json.loads(response.content.decode("utf-8")).get("errors", None)), has_error)
class CustomPortletAdmin(BaseOrderableAdmin):
sortablefield = 'order'
ordering = ('order', )
html_fields = BaseOrderableAdmin.html_fields + ('description', )
form = CustomPortletAdminModelForm
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
class WorkflowAdmin(BaseAdmin):
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
def get_urls(self):
from django.conf.urls.defaults import patterns, url
def wrap(view):
def wrapper(*args, **kwargs):
#kwargs['model_admin'] = self
return self.admin_site.admin_view(view)(*args, **kwargs)
return update_wrapper(wrapper, view)
urls = super(WorkflowAdmin, self).get_urls()
my_urls = patterns(
'',
url(r'^update_permissions/$',
wrap(self.update_permissions_view),
name='update_permissions'),
(r'^(?P<workflow_id>\d+)/graphic_workflow/$',
wrap(self.graphic_workflow_view)))
return my_urls + urls
def object_tools(self, request, mode, url_prefix):
tools = super(WorkflowAdmin,
self).object_tools(request, mode, url_prefix)
if mode == 'list':
tools = [{
'url': url_prefix + 'update_permissions/',
'label': ugettext('Update permissions'),
'class': 'default',
'permission': 'change'
}] + tools
elif mode == 'change':
tools = [{
'url': url_prefix + 'graphic_workflow/',
'label': ugettext('Graphic workflow'),
'class': 'default',
'permission': 'change'
}] + tools
return tools
def has_delete_permission(self, request, obj=None):
if obj and obj.slug == DEFAULT_WORKFLOW:
return False
elif obj:
return True
else:
if request.method == 'POST' and \
request.POST.get('action', None) == u'delete_selected':
selected_objs = [
Workflow.objects.get(id=int(key))
for key in request.POST.getlist('_selected_action')
]
for sel_obj in selected_objs:
if not self.has_delete_permission(request, sel_obj):
return False
return True
return False
def get_form(self, request, obj=None, **kwargs):
form = super(WorkflowAdmin, self).get_form(request, obj, **kwargs)
if obj:
form.base_fields['initial_state'].queryset = obj.states.all()
if obj.slug == DEFAULT_WORKFLOW:
set_field_read_only(form.base_fields['slug'], 'slug', obj)
elif 'initial_state' in form.base_fields.keys():
del form.base_fields['initial_state']
return form
def update_permissions_view(self, request, extra_context=None):
extra_context = self._base_update_extra_context(extra_context)
if request.method == 'POST':
update_objects_permissions()
return HttpResponseRedirect('..')
return render_to_response('admin/workflow/update_permissions.html',
extra_context,
context_instance=template.RequestContext(
request,
current_app=self.admin_site.name))
def graphic_workflow_view(self, request, workflow_id, extra_context=None):
workflow = get_object_or_404(Workflow, id=workflow_id)
pairs = []
transitions = {}
for transition in workflow.transitions.all():
for origin in transition.states.all():
pair = origin.name, transition.destination.name
if (pair[1], pair[0]) in pairs:
transitions[(pair[1], pair[0])] = '%s / %s' % (transitions[
(pair[1], pair[0])], transition.name)
elif not pair in pairs:
pairs.append(pair)
transitions[pair] = transition.name
tmp_pairs, pairs = pairs[:], []
pairs = [(pair[0], pair[1], transitions[pair]) for pair in tmp_pairs]
context = extra_context or {}
context.update({
'pairs': pairs,
'original': workflow,
'title': unicode(workflow)
})
return render_to_response('admin/workflow/graphic_workflow.html',
context,
context_instance=template.RequestContext(
request,
current_app=self.admin_site.name))
def view(request, name=None, area=None, mode=None):
# normalize default view url
if name == 'all' and not mode:
kwargs = {}
if area: kwargs['area'] = area
return HttpResponseRedirect(reverse('openresources_view', kwargs=kwargs))
view_name = name
if mode == 'json': return view_json(request, name)
if name == None or name == 'all':
is_default_view = True
if area: area = get_object_or_404(Area, shortname=area)
view = get_object_or_404(View, shortname=name or 'all')
if not mode:
# TODO: auto-discover appropriate mode?
if view.show_map: mode = 'map'
else: mode = 'list'
if not mode in ['map','list','export','embed','fullscreen']:
raise Http404()
template = 'openresources/view_%s.html' % mode
if view.protected and not request.user.is_authenticated():
return HttpResponse(status=403) # forbidden
resources = view.get_resources()
if not request.user.is_authenticated():
resources = resources.filter(protected=False)
default_ordering = '-creation_date'
order_field = request.GET.get('order', default_ordering)
_base_field = order_field.lstrip('-')
if _base_field not in ['name','creation_date']:
raise Http404
if order_field == 'name':
resources = resources.extra(select={'name_lower': 'lower(name)'}, order_by=['name_lower'])
else:
resources = resources.order_by(order_field)
# extract tags for list display
q = None
for mapping in view.mappings.filter(show_in_list=True):
q = q and q | Q(key=str(mapping.key)) or Q(key=str(mapping.key))
if q:
tags = Tag.objects.filter(q).select_related('resource').order_by('resource__shortname','key','value').values('resource_id','key','value')
tags_dict = {}
for tag in tags:
# just append key valur pairs, will be grouped in the template
if tag['resource_id'] in tags_dict:
tags_dict[tag['resource_id']].append({'key': tag['key'], 'value': tag['value']})
else:
tags_dict[tag['resource_id']] = [{'key': tag['key'], 'value': tag['value']}]
tags = tags_dict
# ???
# for resource in resources:
# if resource.id in tags_dict:
# setattr(resource, 'view_tags', tags_dict[resource.id])
icon_mappings = view.mappings.exclude(icon=None)
#context = _get_context(request)
#context_form = ContextForm(instance=context)
map_attribution = settings.MAP_ATTRIBUTION
default_resource_icon = settings.DEFAULT_RESOURCE_ICON
_order_field = 'name'
try:
from transmeta import get_real_fieldname, get_fallback_fieldname
_order_fallback_field = get_fallback_fieldname(_order_field)
_order_field = get_real_fieldname(_order_field)
if _order_field == _order_fallback_field:
select_extra = {'%s_lower' % _order_field: 'lower(%s)' % _order_field}
else:
select_extra = {'%s_lower' % _order_field: "lower(coalesce(%s,'') || coalesce(%s,''))" % (_order_field, _order_fallback_field)}
except ImportError:
select_extra = {'%s_lower' % _order_field: 'lower(%s)' % _order_field}
_order_by = ['feature_order','%s_lower' % _order_field]
featured_areas = Area.objects.filter(featured=True).extra(select=select_extra, order_by=_order_by)
featured_views = View.objects.filter(featured=True).extra(select=select_extra, order_by=_order_by)
if not request.user.is_authenticated():
featured_views = featured_views.filter(protected=False)
def is_valid_bounds(bounds):
bounds = bounds.split(',')
if len(bounds) != 4: return False
import re
for coord in bounds:
if not re.match('-?\d+\.?\d*',coord): return False
return True
if is_valid_bounds(request.GET.get('bounds','')):
bounds = request.GET['bounds']
return render_to_response(template, RequestContext(request, locals()))
class EventCategoryAdmin(BaseCategoryAdmin):
ordering = (get_fallback_fieldname('name'), )
search_fields = (get_fallback_fieldname('name'), )
class BaseSectionAdmin(BaseContentAdmin, PermissionAdmin):
sortablefield = 'order'
ordering = ('order', )
list_display = BaseContentAdmin.list_display[:-1]
search_fields = tuple(get_real_fieldname_in_each_language('name'))
html_fields = ()
removed_fields = ('description', )
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
exclude = BaseContentAdmin.exclude + ('commentable', )
def get_object(self, request, object_id):
"""
Overrides the django behaviour
"""
queryset = self.queryset(request, bypass_perms=True)
model = queryset.model
try:
object_id = model._meta.pk.to_python(object_id)
return queryset.get(pk=object_id)
except (model.DoesNotExist, ValidationError):
return None
def queryset(self, request, bypass_perms=False):
"""
Overrides the Django behaviour to take permissions into account
"""
qs = super(BaseSectionAdmin, self).queryset(request)
if not bypass_perms and not perms_api.can_manage_site(request.user) and \
not perms_api.has_global_permission(request.user, 'edit'):
qs = qs.filter(Q(owners=request.user))
return qs
def has_add_permission(self, request):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return perms_api.has_global_permission(request.user, 'manage_section')
def has_change_permission(self, request, obj=None):
"""
Overrides Django admin behaviour to add ownership based access control
"""
permission = super(BaseSectionAdmin, self).has_change_permission(request, obj)
if permission:
return permission
if perms_api.has_global_permission(request.user, 'manage_section'):
return True
elif obj is None:
return True
return False
def has_delete_permission(self, request, obj=None):
"""
Overrides Django admin behaviour to add ownership based access control
"""
return perms_api.has_global_permission(request.user, 'manage_section')
def get_form(self, request, obj=None, **kwargs):
form = super(BaseSectionAdmin, self).get_form(request, obj, **kwargs)
if 'main_content' in form.base_fields.keys():
field = form.base_fields['main_content']
qs = field.queryset
if not obj:
qs = qs.model.objects.get_empty_query_set()
else:
qs = qs.filter(sections=obj)
# Como Document no esta registrado en el admin site, no tiene
# sentido mostrar este campo si no tiene opciones ya que no
# se pueden crear nuevos documentos desde aqui
if qs.count():
field.queryset = qs
else:
form.base_fields.pop('main_content')
return form
class HighlightAdmin(PluginAdmin):
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
html_fields = ('description', )
class Meta:
abstract = True
translate = ('name', 'description', 'plain_description', )
ordering = (get_fallback_fieldname('name'), )
def __init__(self, forum, *args, **kwargs):
super(CreateThreadForm, self).__init__(*args, **kwargs)
self.forum = forum
self.fields[get_fallback_fieldname('name')].label = _('Name')
self.fields[get_fallback_fieldname('description')].label = _('Description')
def test_save_fields_news(self):
obj = News.objects.filter(**{transmeta.get_fallback_fieldname("description"): ""})[0]
self._test_save_fields(News, obj=obj, field_names=["title", "description"])
def test_save_fields_news(self):
obj = News.objects.filter(**{transmeta.get_fallback_fieldname('description'): ''})[0]
self._test_save_fields(News, obj=obj, field_names=['title', 'description'])
class DocumentAdmin(BaseContentAdmin):
list_display = ('__unicode__', 'slug', 'workflow_status', )
html_fields = ('description', 'body', )
prepopulated_fields = {'slug': (get_fallback_fieldname('name'), )}
actions = BaseAdmin.actions + ['set_as_published', 'set_as_draft']
