def get_basic_info_fields(self, request, obj=None):
basic_info_fields = get_real_fieldname_in_each_language('name') + \
['slug', ] + get_real_fieldname_in_each_language('description') + \
['workflow_status', 'tags', 'meta_desc', 'commentable']
if request.user.is_superuser:
basic_info_fields.append('owners')
return basic_info_fields
def get_basic_info_fields(self, request, obj=None):
basic_info_fields = get_real_fieldname_in_each_language('name') + \
['slug', ] + get_real_fieldname_in_each_language('description') + \
['workflow_status', 'tags', 'meta_desc', 'commentable']
if request.user.is_superuser:
basic_info_fields.append('owners')
return basic_info_fields
class BlogAdmin(admin.ModelAdmin):
list_display = ('name', 'slug', 'sort_order', 'created_by', 'created_on',
'updated_by', 'updated_on', 'status')
search_fields = get_real_fieldname_in_each_language('name') \
+ get_real_fieldname_in_each_language('description')
list_filter = ["status"]
#prepopulated_fields = {
# 'slug_en': ('name_en',),
# 'slug_es': ('name_es',),
#}
class Media:
js = (
'/static/js/ckeditor/ckeditor.js',
'/static/js/ckeditor.js',
)
def save_model(self, request, obj, form, change):
"""
Overrided because I want to also set who created this instance.
"""
instance = form.save(commit=False)
if instance.id is None:
new = True
instance.created_by = request.user
instance.updated_by = request.user
instance.save()
return instance
class ProductImagesAdmin(admin.ModelAdmin):
list_display = (
'name',
'product',
)
search_fields = get_real_fieldname_in_each_language('name') \
+ get_real_fieldname_in_each_language('product__product_tmpl__name')
extra = 0
def get_form(self, request, obj=None):
self.fieldsets = None
form = super(StandingOutAdmin, self).get_form(request, obj)
self.fieldsets = (
(_('Basic Options'), {
'fields': get_real_fieldname_in_each_language('title') +\
get_real_fieldname_in_each_language('short_description') +\
['url', 'obj', 'image']}),
(_('Advanced Options'), {
'fields': ('standing_out_category', 'related')}),
)
return form
def get_form(self, request, obj=None):
self.fieldsets = None
form = super(StandingOutAdmin, self).get_form(request, obj)
self.fieldsets = (
(_('Basic Options'), {
'fields': get_real_fieldname_in_each_language('title') +\
get_real_fieldname_in_each_language('short_description') +\
['url', 'obj', 'image']}),
(_('Advanced Options'), {
'fields': ('standing_out_category', 'related')}),
)
return form
def render(self, context):
form = template.Variable(self.form_variable).resolve(context)
fields = self.fields
# if it is a modelform, get real fieldnames of translated fields from transmeta
if hasattr(form, '_meta') and hasattr(form._meta, 'model'):
try:
from transmeta import get_all_translatable_fields, get_real_fieldname_in_each_language
trans_fields = get_all_translatable_fields(form._meta.model)
for field in trans_fields:
if field in fields:
fields.remove(field)
fields.extend(get_real_fieldname_in_each_language(field))
print fields
except ImportError:
pass
new_form = copy.copy(form)
new_form.fields = SortedDict([(key, value) for key, value in form.fields.items() if key in fields])
context[self.variable_name] = new_form
return u''
def south_trans_data(orm, trans_data):
fields = []
for model, trans_fields in trans_data.items():
for field_name in trans_fields:
for real_field in get_real_fieldname_in_each_language(field_name):
fields.append((real_field, orm['%s:%s' % (model, real_field)]))
return tuple(fields)
class ProductCategoryAdmin(admin.ModelAdmin):
list_display = (
'name',
)
search_fields = get_real_fieldname_in_each_language('name')
extra = 0
def south_trans_data(orm, trans_data):
fields = []
for model, trans_fields in trans_data.items():
for field_name in trans_fields:
for real_field in get_real_fieldname_in_each_language(field_name):
fields.append((real_field, orm['%s:%s' % (model, real_field)]))
return tuple(fields)
class ProductTemplateAdmin(admin.ModelAdmin):
list_display = (
'name',
)
search_fields = get_real_fieldname_in_each_language('name')
extra = 0
# list_filter = ["status"]
inlines = [ProductProductInline]
class ResCountryAdmin(admin.ModelAdmin):
search_fields = get_real_fieldname_in_each_language('name')
list_display = (
'name',
'code',
'status',
)
class ResPartnerTitleAdmin(admin.ModelAdmin):
search_fields = get_real_fieldname_in_each_language('name')
list_display = (
'name',
'shortcut',
'update_price',
)
def add_south_trans_fields(frozen_models, trans_data):
for model, field_data in trans_data.items():
for field_name, field_desc in field_data.items():
for real_field in get_real_fieldname_in_each_language(field_name):
field_lang = get_field_language(real_field)
real_field_desc = deepcopy(field_desc)
if field_lang != fallback_language():
real_field_desc[2].update({'null': 'True', 'blank': 'True'})
frozen_models[model][real_field] = real_field_desc
def pre_processing_transmeta_fields(model, field_list):
translatable_fields = transmeta.get_all_translatable_fields(model)
for translatable_field in translatable_fields:
fields_to_remove = transmeta.get_real_fieldname_in_each_language(translatable_field)
for i, field_to_remove in enumerate(fields_to_remove):
if i == 0:
index = field_list.index(field_to_remove)
field_list[index] = translatable_field
else:
field_list.remove(field_to_remove)
return field_list
def add_south_trans_fields(frozen_models, trans_data):
for model, field_data in trans_data.items():
for field_name, field_desc in field_data.items():
for real_field in get_real_fieldname_in_each_language(field_name):
field_lang = get_field_language(real_field)
real_field_desc = deepcopy(field_desc)
if field_lang != fallback_language():
real_field_desc[2].update({
'null': 'True',
'blank': 'True'
})
frozen_models[model][real_field] = real_field_desc
def add_south_trans_column(table, model_name, field_name, orm):
for real_field in get_real_fieldname_in_each_language(field_name):
db.add_column(table, real_field, orm['%s:%s' % (model_name, real_field)])
def add_south_trans_column(table, model_name, field_name, orm):
for real_field in get_real_fieldname_in_each_language(field_name):
db.add_column(table, real_field,
orm['%s:%s' % (model_name, real_field)])
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
def delete_south_trans_column(table, field_name):
for real_field in get_real_fieldname_in_each_language(field_name):
db.delete_column(table, real_field)
def _get_filters(self, q):
name_fields = get_real_fieldname_in_each_language('name')
filters = Q() # query without filters
for field_name in name_fields:
filters |= Q(**{'%s__icontains' % field_name: q})
return filters
def delete_south_trans_column(table, field_name):
for real_field in get_real_fieldname_in_each_language(field_name):
db.delete_column(table, real_field)
class Meta:
model = Menu
exclude = ['parent', 'status', ] + \
transmeta.get_real_fieldname_in_each_language('help_text') + \
list(set(transmeta.get_real_fieldname_in_each_language('name')).difference(
set([transmeta.get_real_fieldname('name', settings.LANGUAGE_CODE)])))
def populate_workflow(workflow):
"""
Populate the workflow with states, transitions and permissions
"""
from merengue.perms.models import Role, Permission
name_fields = get_real_fieldname_in_each_language('name')
old_lang = get_language()
activate(fallback_language())
for field in name_fields:
value = getattr(workflow, field, True)
if value == '':
setattr(workflow, field, None)
data = {get_real_fieldname('name'): ugettext('Draft')}
draft = State.objects.create(slug='draft', workflow=workflow, **data)
draft.set_permissions({
perms.ANONYMOUS_ROLE_SLUG: ('view', ),
perms.OWNER_ROLE_SLUG: ('edit', 'delete', 'can_draft', 'can_pending', ),
perms.REVIEWER_ROLE_SLUG: ('edit', 'delete', 'can_draft', 'can_pending', 'can_published'),
})
data = {get_real_fieldname('name'): ugettext('Pending')}
pending = State.objects.create(slug='pending', workflow=workflow, **data)
pending.set_permissions({
perms.ANONYMOUS_ROLE_SLUG: ('view', ),
perms.OWNER_ROLE_SLUG: ('edit', 'delete', 'can_draft', 'can_pending', ),
perms.REVIEWER_ROLE_SLUG: ('edit', 'delete', 'can_draft', 'can_pending', 'can_published'),
})
data = {get_real_fieldname('name'): ugettext('Published')}
published = State.objects.create(slug='published', workflow=workflow, **data)
published.set_permissions({
perms.ANONYMOUS_ROLE_SLUG: ('view', ),
perms.OWNER_ROLE_SLUG: (),
perms.REVIEWER_ROLE_SLUG: ('edit', 'delete', 'can_draft', 'can_pending', 'can_published'),
})
data = {get_real_fieldname('name'): ugettext('Set as pending')}
pending_permission = Permission.objects.get(codename='can_pending')
set_as_pending = Transition.objects.create(
slug='set-as-pending', workflow=workflow, destination=pending,
permission=pending_permission, **data)
data = {get_real_fieldname('name'): ugettext('Set as draft')}
draft_permission = Permission.objects.get(codename='can_draft')
set_as_draft = Transition.objects.create(
slug='set-as-draft', workflow=workflow, destination=draft,
permission=draft_permission, **data)
data = {get_real_fieldname('name'): ugettext('Publish')}
publish_permission = Permission.objects.get(codename='can_published')
publish = Transition.objects.create(
slug='publish', workflow=workflow, destination=published,
permission=publish_permission, **data)
draft.transitions.add(set_as_pending)
draft.transitions.add(publish)
pending.transitions.add(publish)
pending.transitions.add(set_as_draft)
published.transitions.add(set_as_pending)
published.transitions.add(set_as_draft)
try:
anonymous_role = Role.objects.get(slug=perms.ANONYMOUS_ROLE_SLUG)
except Role.DoesNotExist:
# maybe the role does not exist (for example when tests are running)
anonymous_role = Role.objects.create(id=1, slug=perms.ANONYMOUS_ROLE_SLUG)
try:
view_permission = Permission.objects.get(codename='view')
except Permission.DoesNotExist:
# maybe the permission does not exist (for example when tests are running)
view_permission = Permission.objects.create(id=1, codename='view')
StatePermissionRelation.objects.create(
state=published, permission=view_permission, role=anonymous_role,
)
for codename in ('view', 'edit', 'delete', 'can_draft', 'can_pending',
'can_published', 'manage_category', 'manage_link',
'manage_menu', 'manage_block', ):
WorkflowPermissionRelation.objects.create(
permission=Permission.objects.get(codename=codename),
workflow=workflow,
)
workflow.initial_state = draft
workflow.save()
activate(old_lang)
