def create_normalize_collection(slug, name, model, create_display_field=True,
create_filter_field=True):
ct = ContentType.objects.get_for_model(model)
sp = transaction.savepoint()
collection, created = Collection.objects.get_or_create(slug=slug)
transaction.savepoint_commit(sp)
if created:
collection.status = 'published'
collection.no_deletable = True
setattr(collection,
get_real_fieldname('name', settings.LANGUAGE_CODE),
name)
collection.no_changeable_fields = [
'slug', 'name', get_real_fieldname('name', settings.LANGUAGE_CODE)]
collection.save()
if create_filter_field:
IncludeCollectionFilter.objects.create(
collection=collection, filter_field='status',
filter_operator='exact', filter_value='published')
if create_display_field:
dfield = CollectionDisplayField.objects.create(
field_name='description', safe=True,
show_label=False, collection=collection)
CollectionDisplayFieldFilter.objects.create(
display_field=dfield,
filter_module='django.template.defaultfilters.truncatewords_html',
filter_params='15')
collection.content_types.add(ct)
return collection
def save(self, commit=False):
section = section = self.get_section()
if self.is_menu():
menu = super(HotLinkForm, self).save(commit)
menu_parent = section.main_menu
menu.parent = menu_parent
menu.save()
ContentLink.objects.create(content=self.content, menu=menu)
return menu
elif self.is_standingout():
standinouts = self.get_standingout_of_section(section)
order = 0
if standinouts:
if standinouts[0].order:
order = standinouts[0].order + 1
else:
order = standinouts.count() + 1
from plugins.standingout.models import StandingOut
stand = StandingOut.objects.create(obj=self.content,
related=section,
order=order)
name_lang = transmeta.get_real_fieldname('name', settings.LANGUAGE_CODE)
name_text = self.cleaned_data.get(name_lang)
if name_text and name_text != self.content.name:
title_lang = transmeta.get_real_fieldname('title', settings.LANGUAGE_CODE)
setattr(stand, title_lang, name_text)
stand.save()
return stand
def forum_index(request, extra_context=None):
section = get_section(request, extra_context)
forum_list = Forum.objects.published().order_by(
transmeta.get_real_fieldname('category__name', get_language()),
transmeta.get_real_fieldname('name', get_language()))
forum_list = filtering_in_section(forum_list, section)
return content_list(request,
forum_list,
template_name='forum/forum_list.html',
paginate_by=PAGINATE_BY)
def __new__(cls, name, bases, dct):
new_dct = copy.copy(dct)
if 'prepopulated_fields_translate' in dct:
# First, we create the prepopulated fields entry
if 'prepopulated_fields' not in dct:
new_dct['prepopulated_fields'] = {}
# Then, we loop through each of them, creating one prepopulated field per language
for slug_field, other_fields in dct.get('prepopulated_fields_translate', {}).iteritems():
for lang, _ in getattr(settings, 'LANGUAGES', ()):
new_dct['prepopulated_fields'][transmeta.get_real_fieldname(slug_field, lang)] = \
tuple([transmeta.get_real_fieldname(other_field, lang) for other_field in other_fields])
return super(SlugMeta, cls).__new__(cls, name, bases, new_dct)
def forwards(self, orm):
# Deleting field 'BaseSection.status'
db.delete_column('section_basesection', 'status')
# Deleting field 'BaseSection.slug'
db.delete_column('section_basesection', 'slug')
# Deleting field 'BaseSection.main_image'
db.delete_column('section_basesection', 'main_image')
# Deleting field 'BaseSection.id'
db.delete_column('section_basesection', 'id')
for field in (
'name',
'description',
'plain_description',
):
for lang, lang_name in settings.LANGUAGES:
db.delete_column('section_basesection',
get_real_fieldname(field, lang))
# Swapping primary key from id to basecontent_ptr_id
db.create_primary_key('section_basesection', ['basecontent_ptr_id'])
# Add new foreign key to section_basesection_related_content.basesection_id
db.alter_column(
'section_basesection_related_content', 'basesection_id',
models.ForeignKey(orm['section.BaseSection'],
null=False,
blank=False))
def autoslug_transmeta_func(sender, instance, *args, **kwargs):
for lang, _ in getattr(settings, 'LANGUAGES', ()):
activate(lang)
value = slugify(getattr(instance, populate_from))
setattr(instance, transmeta.get_real_fieldname(populate_to, lang),
value)
deactivate()
def get_sync_sql(self, field_name, missing_langs, model):
""" returns SQL needed for sync schema for a new translatable field """
qn = connection.ops.quote_name
style = no_style()
sql_output = []
db_table = model._meta.db_table
was_translatable_before = self.was_translatable_before(field_name, db_table)
for lang in missing_langs:
new_field = get_real_fieldname(field_name, lang)
f = model._meta.get_field(new_field)
col_type = f.db_type()
field_sql = [style.SQL_FIELD(qn(f.column)), style.SQL_COLTYPE(col_type)]
# column creation
sql_output.append("ALTER TABLE %s ADD COLUMN %s;" % (qn(db_table), ' '.join(field_sql)))
if lang == self.default_lang and not was_translatable_before:
# data copy from old field (only for default language)
sql_output.append("UPDATE %s SET %s = %s" % (qn(db_table), \
qn(f.column), qn(field_name)))
if not f.null and lang == self.default_lang:
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s MODIFY COLUMN %s %s %s;" % \
(qn(db_table), qn(f.column), col_type, \
style.SQL_KEYWORD('NOT NULL')))
if not was_translatable_before:
# we drop field only if field was no translatable before
sql_output.append("ALTER TABLE %s DROP COLUMN %s;" % (qn(db_table), qn(field_name)))
return sql_output
def send_mail_content_as_pending(obj,
review_task,
users=None,
template='review/email_as_pending.html'):
"""
Send a notification mail about that an object has been created as pending
"""
if not users:
users = User.objects.all()
subject = ugettext(u'%s has been set as pending') % getattr(
obj, get_real_fieldname('name'), obj.name)
domain = 'http://%s' % Site.objects.get(id=settings.SITE_ID).domain
body = render_to_string(
template, {
'content':
obj,
'content_url':
'%s%s' % (domain, obj.get_absolute_url()),
'admin_content_url':
'%s%s' % (domain, obj.get_admin_absolute_url()),
'task_admin_url':
'%s%s' % (domain,
reverse('admin:review_reviewtask_change',
args=(review_task.pk, )))
})
from_mail = settings.EMAIL_HOST_USER
recipers = list(set([user.email for user in users if user.email]))
for reciper in recipers:
email = EmailMessage(subject, body, from_mail, [reciper])
email.content_subtype = "html"
email.send()
def autoslug_transmeta_func(sender, instance, *args, **kwargs):
for lang, _ in getattr(settings, 'LANGUAGES', ()):
activate(lang)
value = slugify(getattr(instance, populate_from))
setattr(instance, transmeta.get_real_fieldname(populate_to, lang),
value)
deactivate()
def get_displayfield_data(self, display_field, item):
"""
returns dictionary with data that will be processed by collection view
to display an item as defined in display_field option.
This method may be overriden in Collection subclasses.
"""
field_name = display_field.field_name
if field_name == 'content_type_name':
verbose_name = ugettext('Content type name')
else:
try:
field = item._meta.get_field(field_name)
verbose_name = field.verbose_name
except models.FieldDoesNotExist:
try:
lang = fallback_language()
field = item._meta.get_field(get_real_fieldname(field_name, lang))
verbose_name = unicode(field.verbose_name)[:-len(lang) - 1]
except:
# TODO: make this except not empty and discriminate errors
return None
return {
'name': verbose_name,
'field_name': field_name,
'show_label': display_field.show_label,
'value': _get_value(display_field, field_name, item),
'type': field.get_internal_type(),
'safe': display_field.safe,
}
def get_sync_sql(self, field_name, missing_langs, model):
""" returns SQL needed for sync schema for a new translatable field """
qn = connection.ops.quote_name
style = no_style()
sql_output = []
db_table = model._meta.db_table
was_translatable_before = self.was_translatable_before(
field_name, db_table)
for lang in missing_langs:
new_field = get_real_fieldname(field_name, lang)
f = model._meta.get_field(new_field)
col_type = f.db_type()
field_sql = [
style.SQL_FIELD(qn(f.column)),
style.SQL_COLTYPE(col_type)
]
# column creation
sql_output.append("ALTER TABLE %s ADD COLUMN %s" %
(qn(db_table), ' '.join(field_sql)))
if lang == self.default_lang and not was_translatable_before:
# data copy from old field (only for default language)
sql_output.append("UPDATE %s SET %s = %s" % (qn(db_table), \
qn(f.column), qn(field_name)))
if not f.null and lang == self.default_lang:
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s ALTER COLUMN %s SET %s" % \
(qn(db_table), qn(f.column), \
style.SQL_KEYWORD('NOT NULL')))
if not was_translatable_before:
# we drop field only if field was no translatable before
sql_output.append("ALTER TABLE %s DROP COLUMN %s" %
(qn(db_table), qn(field_name)))
return sql_output
def get_missing_languages(self, field_name, db_table):
""" get only missings fields """
db_table_fields = self.get_table_fields(db_table)
for lang_code, lang_name in settings.LANGUAGES:
if get_real_fieldname(field_name,
lang_code) not in db_table_fields:
yield lang_code
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = obj._meta.get_field_by_name(field_name)[0]
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(
transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.CharField):
adaptor = 'text'
if getattr(field, 'choices', None):
adaptor = 'choices'
elif isinstance(field, models.TextField):
adaptor = 'textarea'
elif isinstance(field, models.BooleanField):
adaptor = 'boolean'
elif isinstance(field, models.DateTimeField):
adaptor = 'datetime'
elif isinstance(field, models.DateField):
adaptor = 'date'
elif isinstance(field, ForeignKey):
adaptor = 'fk'
elif isinstance(field, ManyToManyField):
adaptor = 'm2mcomma'
from inplaceeditform.fields import BaseAdaptorField
path_adaptor = adaptor and (
(getattr(settings, 'ADAPTOR_INPLACEEDIT', None)
and settings.ADAPTOR_INPLACEEDIT.get(adaptor, None)) or
(DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None)))
if not path_adaptor:
return BaseAdaptorField
path_module, class_adaptor = ('.'.join(path_adaptor.split('.')[:-1]),
path_adaptor.split('.')[-1])
return getattr(import_module(path_module), class_adaptor)
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = obj._meta.get_field_by_name(field_name)[0]
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.CharField):
adaptor = 'text'
if getattr(field, 'choices', None):
adaptor = 'choices'
elif isinstance(field, models.TextField):
adaptor = 'textarea'
elif isinstance(field, models.BooleanField):
adaptor = 'boolean'
elif isinstance(field, models.DateTimeField):
adaptor = 'datetime'
elif isinstance(field, models.DateField):
adaptor = 'date'
elif isinstance(field, ForeignKey):
adaptor = 'fk'
elif isinstance(field, ManyToManyField):
adaptor = 'm2mcomma'
from inplaceeditform.fields import BaseAdaptorField
path_adaptor = adaptor and ((getattr(settings, 'ADAPTOR_INPLACEEDIT', None) and
settings.ADAPTOR_INPLACEEDIT.get(adaptor, None)) or
(DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None)))
if not path_adaptor:
return BaseAdaptorField
path_module, class_adaptor = ('.'.join(path_adaptor.split('.')[:-1]), path_adaptor.split('.')[-1])
return getattr(import_module(path_module), class_adaptor)
def __init__(self, user, content, data=None, *args, **kwargs):
super(HotLinkForm, self).__init__(data, *args, **kwargs)
self.content = content
if user.is_superuser:
choices = BaseSection.objects.all()
else:
class_names = ['basesection']
subclasses = BaseSection.__subclasses__()
class_names += [subclass.__name__.lower() for subclass in subclasses]
choices = user.contents_owned.filter(class_name__in=class_names)
if choices.count() == 1:
self.fields['section'] = forms.ModelChoiceField(initial=choices[0],
queryset=choices,
label='',
widget=forms.HiddenInput)
else:
self.fields['section'] = forms.ModelChoiceField(queryset=choices,
label=_('Section'),
required=True,
help_text=_('Choose a section where save the menu'))
name_lang = transmeta.get_real_fieldname('name', settings.LANGUAGE_CODE)
self.fields['slug'].required = False
if not data:
self.fields['slug'].label = ''
self.fields['slug'].widget = forms.HiddenInput()
self.fields[name_lang].label = _('Name')
self.fields[name_lang].initial = getattr(content, name_lang, unicode(content))
def get_displayfield_data(self, display_field, item):
"""
returns dictionary with data that will be processed by collection view
to display an item as defined in display_field option.
This method may be overriden in Collection subclasses.
"""
field_name = display_field.field_name
if field_name == 'content_type_name':
verbose_name = ugettext('Content type name')
else:
try:
field = item._meta.get_field(field_name)
verbose_name = field.verbose_name
except models.FieldDoesNotExist:
try:
lang = fallback_language()
field = item._meta.get_field(
get_real_fieldname(field_name, lang))
verbose_name = unicode(field.verbose_name)[:-len(lang) - 1]
except:
# TODO: make this except not empty and discriminate errors
return None
return {
'name': verbose_name,
'field_name': field_name,
'show_label': display_field.show_label,
'value': _get_value(display_field, field_name, item),
'type': field.get_internal_type(),
'safe': display_field.safe,
}
def get_type_of_db_field(self, field_name, model):
field = self.get_default_field(field_name, model)
if not field:
field = model._meta.get_field(get_real_fieldname(field_name))
try:
col_type = field.db_type(connection)
except TypeError: # old django
col_type = field.db_type()
return col_type
def get_type_of_db_field(self, field_name, model, lang):
field = self.get_default_field(field_name, model)
if not field:
field = model._meta.get_field(get_real_fieldname(field_name, lang))
try:
col_type = field.db_type(connection)
except TypeError: # old django
col_type = field.db_type()
return col_type
def get_default_field(self, field_name, model):
for lang_code, lang_name in settings.LANGUAGES:
field_name_i18n = get_real_fieldname(field_name, lang_code)
f = model._meta.get_field(field_name_i18n)
if not f.null:
return f
try:
return model._meta.get_field(field_name)
except FieldDoesNotExist:
return None
def __setattr__(self, name, get_field_callback):
'''
Method tried to set full bunch of translatable field using get_field_callback method inside respect_to_language statement
'''
if callable(get_field_callback) and hasattr(self._meta, 'translatable_fields') and name in self._meta.translatable_fields:
for lang in settings.LANGUAGES:
with respect_to_language(lang[0]):
setattr(self, get_real_fieldname(name, lang[0]), get_field_callback())
else:
return super(SetTransMetaAttribute, self).__setattr__(name, get_field_callback)
def handle(self, *args, **options):
""" command execution """
# assume_yes = options.get('assume_yes', False)
# for each language
default_language = fallback_language()
for lang in get_languages():
lang_code = lang[LANGUAGE_CODE]
if lang_code == default_language:
continue
for model in REGISTRY:
fields = REGISTRY[model].values()
total = model.objects.count()
current = 0
for instance in model.objects.all():
current += 1
save = False
# for each field in this model
for field in fields:
# get the real field name (with language suffix)
realname = get_real_fieldname(field.name, lang_code)
# original language
original = get_real_fieldname(field.name,
default_language)
# original value
original_value = getattr(instance, original)
# get current value
value = getattr(instance, realname)
if value == None:
value = ""
new_value = KeyValue.objects.lookup(
original_value, lang_code)
# if it's not the default message
if new_value != value:
# if it's not the same value
setattr(instance, realname, new_value)
save = True
print "(Lang %s) Processed %s model, %04d / %04d" % (
lang_code, model, current, total),
if save:
instance.save()
print " (changed)"
else:
print ""
def get_default_field(self, field_name, model):
for lang_code, lang_name in get_languages():
field_name_i18n = get_real_fieldname(field_name, lang_code)
f = model._meta.get_field(field_name_i18n)
if not f.null:
return f
try:
return model._meta.get_field(field_name)
except FieldDoesNotExist:
return None
def get_sync_sql(self, field_name, missing_langs, model):
""" returns SQL needed for sync schema for a new translatable field """
qn = connection.ops.quote_name
db_engine = connection.settings_dict['ENGINE']
style = no_style()
sql_output = []
db_table = model._meta.db_table
was_translatable_before = self.was_translatable_before(field_name, db_table)
default_f = self.get_default_field(field_name, model)
for lang in missing_langs:
new_field = get_real_fieldname(field_name, lang)
f = model._meta.get_field(new_field)
col_type = f.db_type()
field_sql = [style.SQL_FIELD(qn(f.column)), style.SQL_COLTYPE(col_type)]
# column creation
if not new_field in self.get_table_fields(db_table):
sql_output.append("ALTER TABLE %s ADD COLUMN %s" % (qn(db_table), ' '.join(field_sql)))
if lang == self.default_lang and not was_translatable_before:
# data copy from old field (only for default language)
sql_output.append("UPDATE %s SET %s = %s" % (qn(db_table), \
qn(f.column), qn(field_name)))
if not f.null:
# changing to NOT NULL after having data copied
if db_engine == "django.db.backends.mysql":
sql_output.append("ALTER TABLE %s MODIFY %s %s %s" % \
(qn(db_table), qn(f.column), col_type, \
style.SQL_KEYWORD('NOT NULL')))
elif db_engine == "django.db.backends.sqlite3":
pass
else:
sql_output.append("ALTER TABLE %s ALTER COLUMN %s SET %s" % \
(qn(db_table), qn(f.column), \
style.SQL_KEYWORD('NOT NULL')))
elif default_f and not default_f.null and lang == self.default_lang:
# data copy from old field (only for default language)
sql_output.append("UPDATE %(db_table)s SET %(f_colum)s = '%(value_default)s'\
WHERE %(f_colum)s is %(null)s or %(f_colum)s = '' " % \
{'db_table': qn(db_table),
'f_colum': qn(f.column),
'value_default': qn(VALUE_DEFAULT),
'null': style.SQL_KEYWORD('NULL'),
})
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s ALTER COLUMN %s DROP %s" % \
(qn(db_table), qn(default_f.column), \
style.SQL_KEYWORD('NOT NULL')))
sql_output.append("ALTER TABLE %s ALTER COLUMN %s SET %s" % \
(qn(db_table), qn(f.column), \
style.SQL_KEYWORD('NOT NULL')))
if not was_translatable_before:
# we drop field only if field was no translatable before
sql_output.append("ALTER TABLE %s DROP COLUMN %s" % (qn(db_table), qn(field_name)))
return sql_output
def _transmeta_processing(self):
if has_transmeta:
import transmeta
translatable_fields = self._get_translatable_fields(self.model)
if self.field_name in translatable_fields:
self.field_name = transmeta.get_real_fieldname(self.field_name)
self.transmeta = True
if not self.render_value(self.field_name):
self.initial = {self.field_name: ugettext('Write a traslation')}
return
self.transmeta = False
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = obj._meta.get_field_by_name(field_name)[0]
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.URLField):
adaptor = 'url'
elif isinstance(field, models.EmailField):
adaptor = 'email'
elif isinstance(field, models.CharField):
adaptor = 'text'
elif isinstance(field, models.TextField):
adaptor = 'textarea'
elif isinstance(field, models.NullBooleanField):
adaptor = 'nullboolean'
elif isinstance(field, models.BooleanField):
adaptor = 'boolean'
elif isinstance(field, models.DateTimeField):
adaptor = 'datetime'
elif isinstance(field, models.DateField):
adaptor = 'date'
elif isinstance(field, models.TimeField):
adaptor = 'time'
elif isinstance(field, models.IntegerField):
adaptor = 'integer'
elif isinstance(field, models.FloatField):
adaptor = 'float'
elif isinstance(field, models.DecimalField):
adaptor = 'decimal'
elif isinstance(field, ForeignKey):
adaptor = 'fk'
elif isinstance(field, ManyToManyField):
adaptor = 'm2mcomma'
elif isinstance(field, models.ImageField):
adaptor = 'image'
elif isinstance(field, models.FileField):
adaptor = 'file'
elif gismodels:
if isinstance(field, gismodels.PointField):
adaptor = 'point'
if getattr(field, 'choices', None):
adaptor = 'choices'
from inplaceeditform.fields import BaseAdaptorField
path_adaptor = adaptor and (inplace_settings.ADAPTOR_INPLACEEDIT.get(adaptor, None) or
DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None))
if not path_adaptor and adaptor:
return get_adaptor_class(obj=obj, field_name=field_name)
elif not path_adaptor:
return BaseAdaptorField
path_module, class_adaptor = ('.'.join(path_adaptor.split('.')[:-1]), path_adaptor.split('.')[-1])
return getattr(import_module(path_module), class_adaptor)
def get_db_change_languages(self, field_name, db_table_fields):
""" get only db changes fields """
for lang_code, lang_name in get_languages():
if get_real_fieldname(field_name, lang_code) not in db_table_fields:
yield lang_code
for db_table_field in db_table_fields:
pattern = re.compile('^%s_(?P<lang>\w{2})$' % field_name)
m = pattern.match(db_table_field)
if not m:
continue
lang = m.group('lang')
yield lang
def _transmeta_processing(self):
if has_transmeta:
import transmeta
translatable_fields = self._get_translatable_fields(self.model)
if self.field_name in translatable_fields:
self.field_name = transmeta.get_real_fieldname(self.field_name)
self.transmeta = True
if not self.render_value(self.field_name):
message_translation = unicode(inplace_settings.INPLACEEDIT_EDIT_MESSAGE_TRANSLATION)
self.initial = {self.field_name: message_translation}
return
self.transmeta = False
def _transmeta_processing(self):
if has_transmeta:
import transmeta
translatable_fields = self._get_translatable_fields(self.model)
if self.field_name in translatable_fields:
self.field_name = transmeta.get_real_fieldname(self.field_name)
self.transmeta = True
if not self.render_value(self.field_name):
message_translation = unicode(inplace_settings.INPLACEEDIT_EDIT_MESSAGE_TRANSLATION)
self.initial = {self.field_name: message_translation}
return
self.transmeta = False
def get_db_change_languages(self, field_name, db_table_fields):
""" get only db changes fields """
for lang_code, lang_name in get_languages():
if get_real_fieldname(field_name, lang_code) not in db_table_fields:
yield lang_code
for db_table_field in db_table_fields:
pattern = re.compile('^%s_(?P<lang>\w{2})$' % field_name)
m = pattern.match(db_table_field)
if not m:
continue
lang = m.group('lang')
yield lang
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = getattr(obj, field_name)
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(
transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.URLField):
adaptor = 'url'
elif isinstance(field, models.EmailField):
adaptor = 'email'
elif isinstance(field, models.CharField):
adaptor = 'text'
elif isinstance(field, models.TextField):
adaptor = 'textarea'
elif isinstance(field, models.NullBooleanField):
adaptor = 'nullboolean'
elif isinstance(field, models.BooleanField):
adaptor = 'boolean'
elif isinstance(field, models.DateTimeField):
adaptor = 'datetime'
elif isinstance(field, models.DateField):
adaptor = 'date'
elif isinstance(field, models.TimeField):
adaptor = 'time'
elif isinstance(field, models.IntegerField):
adaptor = 'integer'
elif isinstance(field, models.FloatField):
adaptor = 'float'
elif isinstance(field, models.DecimalField):
adaptor = 'decimal'
elif isinstance(field, ForeignKey):
adaptor = 'fk'
elif isinstance(field, ManyToManyField):
adaptor = 'm2mcomma'
elif isinstance(field, models.ImageField):
adaptor = 'image'
elif isinstance(field, models.FileField):
adaptor = 'file'
if getattr(field, 'choices', None):
adaptor = 'choices'
from inplaceeditform.fields import BaseAdaptorField
path_adaptor = adaptor and (inplace_settings.ADAPTOR_INPLACEEDIT.get(
adaptor, None) or DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None))
if not path_adaptor and adaptor:
return get_adaptor_class(obj=obj, field_name=field_name)
elif not path_adaptor:
return BaseAdaptorField
path_module, class_adaptor = ('.'.join(path_adaptor.split('.')[:-1]),
path_adaptor.split('.')[-1])
return getattr(import_module(path_module), class_adaptor)
def handle(self, *args, **options):
""" command execution """
# assume_yes = options.get('assume_yes', False)
# for each language
default_language = fallback_language()
for lang in get_languages():
lang_code = lang[LANGUAGE_CODE]
if lang_code == default_language:
continue
for model in REGISTRY:
fields = REGISTRY[model].values()
total = model.objects.count()
current = 0
for instance in model.objects.all():
current += 1
save = False
# for each field in this model
for field in fields:
# get the real field name (with language suffix)
realname = get_real_fieldname(field.name, lang_code)
# original language
original = get_real_fieldname(field.name, default_language)
# original value
original_value = getattr(instance, original)
# get current value
value = getattr(instance, realname)
if value == None:
value = ""
new_value = KeyValue.objects.lookup(original_value, lang_code)
# if it's not the default message
if new_value != value:
# if it's not the same value
setattr(instance, realname, new_value)
save = True
print "(Lang %s) Processed %s model, %04d / %04d" % (lang_code, model, current, total),
if save:
instance.save()
print " (changed)"
else:
print ""
def get_sync_sql(self, field_name, missing_langs, model):
""" returns SQL needed for sync schema for a new translatable field """
qn = connection.ops.quote_name
style = no_style()
sql_output = []
db_table = model._meta.db_table
was_translatable_before = self.was_translatable_before(
field_name, db_table)
default_f = self.get_default_field(field_name, model)
for lang in missing_langs:
new_field = get_real_fieldname(field_name, lang)
f = model._meta.get_field(new_field)
col_type = f.db_type()
field_sql = [
style.SQL_FIELD(qn(f.column)),
style.SQL_COLTYPE(col_type)
]
# column creation
if not new_field in self.get_table_fields(db_table):
sql_output.append("ALTER TABLE %s ADD COLUMN %s" %
(qn(db_table), ' '.join(field_sql)))
if lang == self.default_lang and not was_translatable_before:
# data copy from old field (only for default language)
sql_output.append("UPDATE %s SET %s = %s" % (qn(db_table), \
qn(f.column), qn(field_name)))
if not f.null:
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s ALTER COLUMN %s SET %s" % \
(qn(db_table), qn(f.column), \
style.SQL_KEYWORD('NOT NULL')))
elif default_f and not default_f.null and lang == self.default_lang:
# data copy from old field (only for default language)
sql_output.append("UPDATE %(db_table)s SET %(f_colum)s = '%(value_default)s'\
WHERE %(f_colum)s is %(null)s or %(f_colum)s = '' " % \
{'db_table': qn(db_table),
'f_colum': qn(f.column),
'value_default': qn(VALUE_DEFAULT),
'null': style.SQL_KEYWORD('NULL'),
})
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s ALTER COLUMN %s DROP %s" % \
(qn(db_table), qn(default_f.column), \
style.SQL_KEYWORD('NOT NULL')))
sql_output.append("ALTER TABLE %s ALTER COLUMN %s SET %s" % \
(qn(db_table), qn(f.column), \
style.SQL_KEYWORD('NOT NULL')))
if not was_translatable_before:
# we drop field only if field was no translatable before
sql_output.append("ALTER TABLE %s DROP COLUMN %s" %
(qn(db_table), qn(field_name)))
return sql_output
def _transmeta_processing(self):
if has_transmeta:
import transmeta
translatable_fields = self._get_translatable_fields(self.model)
if self.field_name in translatable_fields:
self.field_name = transmeta.get_real_fieldname(self.field_name)
self.transmeta = True
if not self.render_value(self.field_name):
self.initial = {
self.field_name: ugettext('Write a traslation')
}
return
self.transmeta = False
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 get_field_by_name(model, field_name, checked_transmeta=True, api=None):
try:
return (field_name, model._meta.get_field_by_name(field_name)[0])
except models.FieldDoesNotExist, e:
if checked_transmeta and has_transmeta():
field_name_transmeta = transmeta.get_real_fieldname(field_name, get_language())
try:
field_name_transmeta, field = get_field_by_name(model,
field_name_transmeta,
checked_transmeta=False)
return (field_name, field)
except models.FieldDoesNotExist, e:
pass
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 get_sync_sql(self, field_name, missing_langs, model):
""" returns SQL needed for sync schema for a new translatable field """
qn = connection.ops.quote_name
style = no_style()
sql_output = []
db_table = model._meta.db_table
was_translatable_before = self.was_translatable_before(field_name, db_table)
default_f = self.get_default_field(field_name, model)
for lang in missing_langs:
new_field = get_real_fieldname(field_name, lang)
f = model._meta.get_field(new_field)
col_type = f.db_type()
field_sql = [style.SQL_FIELD(qn(f.column)), style.SQL_COLTYPE(col_type)]
# column creation
if not new_field in self.get_table_fields(db_table):
sql_output.append("ALTER TABLE %s ADD COLUMN %s" % (qn(db_table), " ".join(field_sql)))
if lang == self.default_lang and not was_translatable_before:
# data copy from old field (only for default language)
sql_output.append("UPDATE %s SET %s = %s" % (qn(db_table), qn(f.column), qn(field_name)))
if not f.null:
# changing to NOT NULL after having data copied
sql_output.append(
"ALTER TABLE %s ALTER COLUMN %s SET %s"
% (qn(db_table), qn(f.column), style.SQL_KEYWORD("NOT NULL"))
)
elif default_f and not default_f.null and lang == self.default_lang:
# data copy from old field (only for default language)
sql_output.append(
"UPDATE %(db_table)s SET %(f_colum)s = '%(value_default)s'\
WHERE %(f_colum)s is %(null)s or %(f_colum)s = '' "
% {
"db_table": qn(db_table),
"f_colum": qn(f.column),
"value_default": qn(VALUE_DEFAULT),
"null": style.SQL_KEYWORD("NULL"),
}
)
# changing to NOT NULL after having data copied
sql_output.append(
"ALTER TABLE %s ALTER COLUMN %s DROP %s"
% (qn(db_table), qn(default_f.column), style.SQL_KEYWORD("NOT NULL"))
)
sql_output.append(
"ALTER TABLE %s ALTER COLUMN %s SET %s"
% (qn(db_table), qn(f.column), style.SQL_KEYWORD("NOT NULL"))
)
if not was_translatable_before:
# we drop field only if field was no translatable before
sql_output.append("ALTER TABLE %s DROP COLUMN %s" % (qn(db_table), qn(field_name)))
return sql_output
def forwards(self, orm):
sections_to_migrate = orm['section.BaseSection'].objects.all()
for section in sections_to_migrate:
old_section_id = section.id
new_content = orm['base.BaseContent'].objects.create(
slug=section.slug,
status=section.status,
main_image=section.main_image,
)
for field in (
'name',
'description',
'plain_description',
):
for lang, lang_name in settings.LANGUAGES:
attr = get_real_fieldname(field, lang)
setattr(new_content, attr, getattr(section, attr))
new_content.class_name = 'basesection'
new_content.save()
section.basecontent_ptr = new_content
section.save()
# save ID mapping done to allow a possible traceback
orm['section.SectionContentMapping'].objects.create(
old_id=old_section_id,
new_id=new_content.id,
)
if table_exists('microsite_microsite'):
try:
old_section = orm['section.Section'].objects.get(
id=old_section_id)
old_section.basesection_ptr_id = section.basecontent_ptr_id
old_section.save()
try:
microsite = orm['microsite.MicroSite'].objects.get(
section_ptr_id=old_section_id)
microsite.basesection_ptr_id = new_content.id
microsite.save(force_update=True)
except orm['microsite.MicroSite'].DoesNotExist:
pass
except orm['section.Section'].DoesNotExist:
# this should be caused because old_section is broken (i.e. a basesection with no section model
print 'WARNING: BaseSection %d is broken. Check manually' % old_section_id
# re-referencing all the related contents to the section
for related_content in orm[
'section.SectionRelatedContent'].objects.filter(
basesection=section.id):
related_content.basesection_id = new_content.id
related_content.save()
def make_single_item(self, feed_item, entry):
feed_item.item_cached = base64.encodestring(pickle.dumps(entry))
if self.order_by:
feed_item.order_field = getattr(entry, self.order_by, None)
else:
feed_item.order_field = None
if self.group_by:
feed_item.group_field = getattr(entry, self.group_by, None)
else:
feed_item.group_field = None
title_field = self.title_field or 'title'
field_name = get_real_fieldname('name', fallback_language())
setattr(feed_item, field_name, getattr(entry, title_field, getattr(entry, 'id', None)))
feed_item.excluded = self.is_excluded(entry)
feed_item.save()
def search(request):
q = request.GET['q'].strip()
results = {}
results['resources'] = Resource.objects.filter(name__icontains=q)
results['tags'] = Tag.objects.filter(value__icontains=q)
from transmeta import get_real_fieldname
fname = get_real_fieldname('name')
results['views'] = View.objects.filter(**{'%s__icontains' % fname : q})
import wiki
results['pages'] = wiki.models.Article.objects.filter(content__icontains=q)
return render_to_response('openresources/search_results.html', RequestContext(request, locals()))
def make_single_item(self, feed_item, entry):
feed_item.item_cached = base64.encodestring(pickle.dumps(entry))
if self.order_by:
feed_item.order_field = getattr(entry, self.order_by, None)
else:
feed_item.order_field = None
if self.group_by:
feed_item.group_field = getattr(entry, self.group_by, None)
else:
feed_item.group_field = None
title_field = self.title_field or 'title'
field_name = get_real_fieldname('name', fallback_language())
setattr(feed_item, field_name,
getattr(entry, title_field, getattr(entry, 'id', None)))
feed_item.excluded = self.is_excluded(entry)
feed_item.save()
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = obj._meta.get_field_by_name(field_name)[0]
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(
transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.BooleanField):
adaptor = 'boolean'
elif isinstance(field, models.DateField):
adaptor = 'date'
elif isinstance(field, models.DateTimeField):
adaptor = 'datetime'
elif isinstance(field, ForeignKey):
adaptor = 'fk'
elif isinstance(field, ManyToManyField):
adaptor = 'm2mcomma'
elif isinstance(field, models.ImageField):
adaptor = 'image'
elif isinstance(field, models.FileField):
adaptor = 'file'
elif isinstance(field, (models.IntegerField, models.DecimalField)):
adaptor = 'number'
if getattr(field, 'choices', None):
adaptor = 'choices'
elif isinstance(field, models.CharField):
adaptor = 'text'
if getattr(field, 'choices', None):
adaptor = 'choices'
elif isinstance(field, models.TextField):
adaptor = 'textarea'
else:
adaptor = 'default'
path_adaptor = ((getattr(settings, 'ADAPTOR_INPLACEEDIT', None)
and settings.ADAPTOR_INPLACEEDIT.get(adaptor, None))
or (DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None)))
if not path_adaptor and adaptor:
return get_adaptor_class(obj=obj, field_name=field_name)
parts = path_adaptor.split('.')
path_module, class_adaptor = ('.'.join(parts[:-1]), parts[-1])
return getattr(import_module(path_module), class_adaptor)
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = obj._meta.get_field_by_name(field_name)[0]
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.BooleanField):
adaptor = "boolean"
elif isinstance(field, models.DateField):
adaptor = "date"
elif isinstance(field, models.DateTimeField):
adaptor = "datetime"
elif isinstance(field, ForeignKey):
adaptor = "fk"
elif isinstance(field, ManyToManyField):
adaptor = "m2mcomma"
elif isinstance(field, models.ImageField):
adaptor = "image"
elif isinstance(field, models.FileField):
adaptor = "file"
elif isinstance(field, (models.IntegerField, models.DecimalField)):
adaptor = "number"
if getattr(field, "choices", None):
adaptor = "choices"
elif isinstance(field, models.CharField):
adaptor = "text"
if getattr(field, "choices", None):
adaptor = "choices"
elif isinstance(field, models.TextField):
adaptor = "textarea"
else:
adaptor = "default"
path_adaptor = (
getattr(settings, "ADAPTOR_INPLACEEDIT", None) and settings.ADAPTOR_INPLACEEDIT.get(adaptor, None)
) or (DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None))
if not path_adaptor and adaptor:
return get_adaptor_class(obj=obj, field_name=field_name)
parts = path_adaptor.split(".")
path_module, class_adaptor = (".".join(parts[:-1]), parts[-1])
return getattr(import_module(path_module), class_adaptor)
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 get_common_field_translated_name(collection, field):
"""
Return the translation field if it exists for all collection models,
or the original field otherwise.
"""
model = collection.get_first_parents_of_content_types()
if not model:
return field
import transmeta
translatables = transmeta.get_all_translatable_fields(model)
common_fields = get_common_fields(collection)
if field in translatables:
real_field = get_real_fieldname(field)
if real_field in common_fields:
return real_field
return field
def handle_feed_item_pre_save(sender, instance, **kwargs):
field_name = get_real_fieldname('name', fallback_language())
name = getattr(instance, field_name, None)
if not name:
return
slug = defaultfilters.slugify(name)
slug_num = slug
n = 2
filter_param = 'slug__exact'
filters = {filter_param: slug_num}
exclude = {}
if instance.basecontent_ptr:
exclude = {'id': instance.basecontent_ptr.id}
while BaseContent.objects.filter(**filters).exclude(**exclude).count():
slug_num = slug + u'-%s' % n
filters[filter_param] = slug_num
n += 1
instance.slug = slug_num
def handle_feed_item_pre_save(sender, instance, **kwargs):
field_name = get_real_fieldname('name', fallback_language())
name = getattr(instance, field_name, None)
if not name:
return
slug = defaultfilters.slugify(name)
slug_num = slug
n = 2
filter_param = 'slug__exact'
filters = {filter_param: slug_num}
exclude = {}
if instance.basecontent_ptr:
exclude = {'id': instance.basecontent_ptr.id}
while BaseContent.objects.filter(**filters).exclude(**exclude).count():
slug_num = slug + u'-%s' % n
filters[filter_param] = slug_num
n += 1
instance.slug = slug_num
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 forwards(self, orm):
sections_to_migrate = orm['section.BaseSection'].objects.all()
for section in sections_to_migrate:
old_section_id = section.id
new_content = orm['base.BaseContent'].objects.create(
slug=section.slug,
status=section.status,
main_image=section.main_image,
)
for field in ('name', 'description', 'plain_description', ):
for lang, lang_name in settings.LANGUAGES:
attr = get_real_fieldname(field, lang)
setattr(new_content, attr, getattr(section, attr))
new_content.class_name = 'basesection'
new_content.save()
section.basecontent_ptr = new_content
section.save()
# save ID mapping done to allow a possible traceback
orm['section.SectionContentMapping'].objects.create(
old_id=old_section_id, new_id=new_content.id,
)
if table_exists('microsite_microsite'):
try:
old_section = orm['section.Section'].objects.get(id=old_section_id)
old_section.basesection_ptr_id = section.basecontent_ptr_id
old_section.save()
try:
microsite = orm['microsite.MicroSite'].objects.get(section_ptr_id=old_section_id)
microsite.basesection_ptr_id = new_content.id
microsite.save(force_update=True)
except orm['microsite.MicroSite'].DoesNotExist:
pass
except orm['section.Section'].DoesNotExist:
# this should be caused because old_section is broken (i.e. a basesection with no section model
print 'WARNING: BaseSection %d is broken. Check manually' % old_section_id
# re-referencing all the related contents to the section
for related_content in orm['section.SectionRelatedContent'].objects.filter(
basesection=section.id):
related_content.basesection_id = new_content.id
related_content.save()
def forwards(self, orm):
# Deleting field 'BaseSection.status'
db.delete_column('section_basesection', 'status')
# Deleting field 'BaseSection.slug'
db.delete_column('section_basesection', 'slug')
# Deleting field 'BaseSection.main_image'
db.delete_column('section_basesection', 'main_image')
# Deleting field 'BaseSection.id'
db.delete_column('section_basesection', 'id')
for field in ('name', 'description', 'plain_description', ):
for lang, lang_name in settings.LANGUAGES:
db.delete_column('section_basesection', get_real_fieldname(field, lang))
# Swapping primary key from id to basecontent_ptr_id
db.create_primary_key('section_basesection', ['basecontent_ptr_id'])
# Add new foreign key to section_basesection_related_content.basesection_id
db.alter_column('section_basesection_related_content', 'basesection_id', models.ForeignKey(orm['section.BaseSection'], null=False, blank=False))
def get_adaptor_class(adaptor=None, obj=None, field_name=None):
if not adaptor:
try:
field = obj._meta.get_field_by_name(field_name)[0]
except FieldDoesNotExist:
if has_transmeta:
field = obj._meta.get_field_by_name(transmeta.get_real_fieldname(field_name))[0]
if isinstance(field, models.CharField):
adaptor = "text"
if getattr(field, "choices", None):
adaptor = "choices"
elif isinstance(field, models.TextField):
adaptor = "textarea"
elif isinstance(field, models.BooleanField):
adaptor = "boolean"
elif isinstance(field, models.DateTimeField):
adaptor = "datetime"
elif isinstance(field, models.DateField):
adaptor = "date"
elif isinstance(field, ForeignKey):
adaptor = "fk"
elif isinstance(field, ManyToManyField):
adaptor = "m2mcomma"
elif isinstance(field, models.ImageField):
adaptor = "image"
elif isinstance(field, models.FileField):
adaptor = "file"
from inplaceeditform.fields import BaseAdaptorField
path_adaptor = adaptor and (
inplace_settings.ADAPTOR_INPLACEEDIT.get(adaptor, None) or DEFAULT_ADAPTOR_INPLACEEDIT.get(adaptor, None)
)
if not path_adaptor and adaptor:
return get_adaptor_class(obj=obj, field_name=field_name)
elif not path_adaptor:
return BaseAdaptorField
path_module, class_adaptor = (".".join(path_adaptor.split(".")[:-1]), path_adaptor.split(".")[-1])
return getattr(import_module(path_module), class_adaptor)
def send_mail_content_as_pending(obj, review_task, users=None,
template='review/email_as_pending.html'):
"""
Send a notification mail about that an object has been created as pending
"""
if not users:
users = User.objects.all()
subject = ugettext(u'%s has been set as pending') % getattr(obj, get_real_fieldname('name'),
obj.name)
domain = 'http://%s' % Site.objects.get(id=settings.SITE_ID).domain
body = render_to_string(template, {
'content': obj,
'content_url': '%s%s' % (domain, obj.get_absolute_url()),
'admin_content_url': '%s%s' % (domain, obj.get_admin_absolute_url()),
'task_admin_url': '%s%s' % (domain, reverse('admin:review_reviewtask_change',
args=(review_task.pk,)))})
from_mail = settings.EMAIL_HOST_USER
recipers = list(set([user.email for user in users if user.email]))
for reciper in recipers:
email = EmailMessage(subject, body, from_mail, [reciper])
email.content_subtype = "html"
email.send()
def __init__(self, user, content, data=None, *args, **kwargs):
super(HotLinkForm, self).__init__(data, *args, **kwargs)
self.content = content
self.only_menu = True
if user.is_superuser:
choices = BaseSection.objects.all()
else:
class_names = ['basesection']
subclasses = BaseSection.get_subclasses()
class_names += [subclass.__name__.lower() for subclass in subclasses]
choices = user.contents_owned.filter(class_name__in=class_names)
if choices.count() == 1:
self.fields['section'] = forms.ModelChoiceField(initial=choices[0],
queryset=choices,
label='',
widget=forms.HiddenInput)
else:
self.fields['section'] = forms.ModelChoiceField(queryset=choices,
label=_('Section'),
required=True,
help_text=_('Choose a section where save the menu'))
name_lang = transmeta.get_real_fieldname('name', settings.LANGUAGE_CODE)
self.fields['slug'].required = False
if not data:
self.fields['slug'].label = ''
self.fields['slug'].widget = forms.HiddenInput()
self.fields[name_lang].label = _('Name')
self.fields[name_lang].initial = getattr(content, name_lang, unicode(content))
try:
get_plugin('standingout')
self.fields['where_link'] = forms.ChoiceField(label=_('How do you want link?'),
choices=(('m', _('menu'),),
('s', _('standing out'),)))
self.fields['visible_by_roles'].help_text = _('The roles that will see this menu. Only if you select the choice link like menu')
self.only_menu = False
except ImportError:
pass
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 get_sync_sql(self, field_name, db_change_langs, model,
db_table_fields):
""" returns SQL needed for sync schema for a new translatable field """
qn = connection.ops.quote_name
style = no_style()
sql_output = []
db_table = model._meta.db_table
was_translatable_before = self.was_translatable_before(
field_name, db_table_fields)
default_f = self.get_default_field(field_name, model)
default_f_required = default_f and self.get_field_required_in_db(
db_table, default_f.name, value_not_implemented=False)
for lang in db_change_langs:
new_field = get_real_fieldname(field_name, lang)
try:
f = model._meta.get_field(new_field)
col_type = self.get_type_of_db_field(field_name, model)
field_column = f.column
except FieldDoesNotExist: # columns in db, removed the settings.LANGUGES
field_column = new_field
col_type = self.get_type_of_db_field(field_name, model)
field_sql = [
style.SQL_FIELD(qn(field_column)),
style.SQL_COLTYPE(col_type)
]
alter_colum_set = 'ALTER COLUMN %s SET' % qn(field_column)
if default_f:
alter_colum_drop = 'ALTER COLUMN %s DROP' % qn(field_column)
not_null = style.SQL_KEYWORD('NOT NULL')
if 'mysql' in backend.__name__:
alter_colum_set = 'MODIFY %s %s' % (qn(field_column), col_type)
not_null = style.SQL_KEYWORD('NULL')
if default_f:
alter_colum_drop = 'MODIFY %s %s' % (qn(field_column),
col_type)
# column creation
if not new_field in db_table_fields:
sql_output.append("ALTER TABLE %s ADD COLUMN %s" %
(qn(db_table), ' '.join(field_sql)))
if lang == self.default_lang and not was_translatable_before:
# data copy from old field (only for default language)
sql_output.append("UPDATE %s SET %s = %s" % (qn(db_table), \
qn(field_column), qn(field_name)))
if not f.null:
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s %s %s" % \
(qn(db_table), alter_colum_set, \
style.SQL_KEYWORD('NOT NULL')))
elif default_f and not default_f.null:
if lang == self.default_lang:
f_required = self.get_field_required_in_db(
db_table, field_column, value_not_implemented=False)
if default_f.name == new_field and default_f_required:
continue
if not f_required:
# data copy from old field (only for default language)
sql_output.append((
"UPDATE %(db_table)s SET %(f_colum)s = '%(value_default)s' "
"WHERE %(f_colum)s is %(null)s or %(f_colum)s = '' "
% {
'db_table': qn(db_table),
'f_colum': qn(field_column),
'value_default': self.get_value_default(),
'null': style.SQL_KEYWORD('NULL'),
}))
# changing to NOT NULL after having data copied
sql_output.append("ALTER TABLE %s %s %s" % \
(qn(db_table), alter_colum_set, \
style.SQL_KEYWORD('NOT NULL')))
else:
f_required = self.get_field_required_in_db(
db_table, field_column, value_not_implemented=True)
if f_required:
sql_output.append(
("ALTER TABLE %s %s %s" %
(qn(db_table), alter_colum_drop, not_null)))
if not was_translatable_before:
# we drop field only if field was no translatable before
sql_output.append("ALTER TABLE %s DROP COLUMN %s" %
(qn(db_table), qn(field_name)))
return sql_output
def save(self, request, content, contact_form):
data = self.cleaned_data
if contact_form.subject_fixed:
subject = contact_form.subject
else:
subject = data['subject']
if contact_form.sender_email:
from_mail = data['sender_email']
else:
if request.user.is_authenticated():
from_mail = request.user.email
else:
from_mail = settings.DEFAULT_FROM_EMAIL
opts_to_save = {}
opts_to_send = SortedDict()
files = {}
for opt in contact_form.opts.all():
name = opt.name or 'option_%s' % opt.id
val = data.get(name, _('Unset'))
if val is None:
val = ''
label_field = transmeta.get_real_fieldname('label',
settings.LANGUAGE_CODE)
label = defaultfilters.slugify(getattr(opt, label_field))
if opt.field_type == 'file':
files[label] = val
else:
opts_to_send[opt.label] = val
opts_to_save[label] = val
contactuser = {}
opts_to_save[u'subject'] = subject
if request.user.is_authenticated():
opts_to_save[u'user'] = request.user.username
contactuser[u'name'] = request.user.get_full_name()
contactuser[u'username'] = request.user.username
else:
opts_to_save[u'user'] = '******'
contactuser[u'name'] = _('Anonymous')
contactuser[u'username'] = '******'
opts_to_save[u'mailfrom'] = from_mail
sent = SentContactForm(contact_form=contact_form,
sent_msg=simplejson.dumps(
opts_to_save, cls=DateTimeAwareJSONEncoder))
if request.user.is_authenticated():
sent.sender = request.user
sent.save()
html_content = render_to_string(
'contactform/email.html', {
'opts': opts_to_send,
'site_domain': Site.objects.get_current().domain,
'content': content,
'contact_form': contact_form,
'contactuser': contactuser
},
context_instance=RequestContext(request))
def mailstr_to_list(mailstr):
return map(unicode.strip, mailstr.split(','))
to_mail = mailstr_to_list(contact_form.email)
bcc_mail = mailstr_to_list(contact_form.bcc)
attachs = [(f.name, f.read(), f.content_type) for f in files.values()
if f]
plain_content = defaultfilters.striptags(html_content)
email = EmailMultiAlternatives(subject,
plain_content,
from_mail,
to_mail,
bcc=bcc_mail,
attachments=attachs)
email.attach_alternative(html_content, "text/html")
try:
email.send()
except SMTPException, e:
send_error(request, _('Mail Server Error: %s') % e)
return None
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)
