def import_catalog(element):
try:
catalog = Catalog.objects.get(uri=element['uri'])
except Catalog.DoesNotExist:
log.info('Catalog not in db. Created with uri %s.', element['uri'])
catalog = Catalog()
catalog.uri_prefix = element['uri_prefix'] or ''
catalog.key = element['key'] or ''
catalog.comment = element['comment'] or ''
catalog.order = element['order']
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(catalog, 'title', element, lang_code, lang_field)
try:
CatalogUniqueKeyValidator(catalog).validate()
except ValidationError as e:
log.info('Catalog not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('Catalog saving to "%s".', element['uri'])
catalog.save()
def import_section(element):
try:
section = Section.objects.get(uri=element['uri'])
except Section.DoesNotExist:
log.info('Section not in db. Created with uri %s.', element['uri'])
section = Section()
try:
section.catalog = Catalog.objects.get(uri=element['catalog'])
except Catalog.DoesNotExist:
log.info('Catalog not in db. Skipping.')
return
section.uri_prefix = element['uri_prefix'] or ''
section.key = element['key'] or ''
section.comment = element['comment'] or ''
section.order = element['order']
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(section, 'title', element, lang_code, lang_field)
try:
SectionUniquePathValidator(section).validate()
except ValidationError as e:
log.info('Section not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('Section saving to "%s".', element['uri'])
section.save()
def import_option(element):
try:
option = Option.objects.get(uri=element['uri'])
except Option.DoesNotExist:
log.info('Option not in db. Created with uri %s.', element['uri'])
option = Option()
try:
option.optionset = OptionSet.objects.get(uri=element['optionset'])
except OptionSet.DoesNotExist:
log.info('OptionSet not in db. Skipping.')
return
option.uri_prefix = element['uri_prefix'] or ''
option.key = element['key'] or ''
option.comment = element['comment'] or ''
option.order = element['order']
option.additional_input = element['additional_input']
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(option, 'text', element, lang_code, lang_field)
try:
OptionUniquePathValidator(option).validate()
except ValidationError as e:
log.info('Option not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('Option saving to "%s".', element['uri'])
option.save()
def render_questionset(self, xml, questionset):
xml.startElement('questionset', {'dc:uri': questionset['uri']})
self.render_text_element(xml, 'uri_prefix', {}, questionset['uri_prefix'])
self.render_text_element(xml, 'key', {}, questionset['key'])
self.render_text_element(xml, 'path', {}, questionset['path'])
self.render_text_element(xml, 'dc:comment', {}, questionset['comment'])
self.render_text_element(xml, 'attribute', {'dc:uri': questionset['attribute']}, None)
self.render_text_element(xml, 'section', {'dc:uri': questionset['section']}, None)
self.render_text_element(xml, 'questionset', {'dc:uri': questionset['questionset']}, None)
self.render_text_element(xml, 'is_collection', {}, questionset['is_collection'])
self.render_text_element(xml, 'order', {}, questionset['order'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'title', {'lang': lang_code}, questionset['title_%s' % lang_code])
self.render_text_element(xml, 'help', {'lang': lang_code}, questionset['help_%s' % lang_code])
self.render_text_element(xml, 'verbose_name', {'lang': lang_code}, questionset['verbose_name_%s' % lang_code])
self.render_text_element(xml, 'verbose_name_plural', {'lang': lang_code}, questionset['verbose_name_plural_%s' % lang_code])
xml.startElement('conditions', {})
if 'conditions' in questionset and questionset['conditions']:
for condition in questionset['conditions']:
self.render_text_element(xml, 'condition', {'dc:uri': condition}, None)
xml.endElement('conditions')
xml.endElement('questionset')
if 'questionsets' in questionset and questionset['questionsets']:
for qs in questionset['questionsets']:
self.render_questionset(xml, qs)
if 'questions' in questionset and questionset['questions']:
for question in questionset['questions']:
self.render_question(xml, question)
def render_task(self, xml, task):
xml.startElement('task', {'dc:uri': task['uri']})
self.render_text_element(xml, 'uri_prefix', {}, task['uri_prefix'])
self.render_text_element(xml, 'key', {}, task['key'])
self.render_text_element(xml, 'dc:comment', {}, task['comment'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'title', {'lang': lang_code},
task['title_%s' % lang_code])
self.render_text_element(xml, 'text', {'lang': lang_code},
task['text_%s' % lang_code])
self.render_text_element(xml, 'start_attribute',
{'dc:uri': task['start_attribute']}, None)
self.render_text_element(xml, 'end_attribute',
{'dc:uri': task['end_attribute']}, None)
self.render_text_element(xml, 'days_before', {}, task['days_before'])
self.render_text_element(xml, 'days_after', {}, task['days_after'])
xml.startElement('conditions', {})
if 'conditions' in task and task['conditions']:
for condition in task['conditions']:
self.render_text_element(xml, 'condition',
{'dc:uri': condition}, None)
xml.endElement('conditions')
xml.startElement('catalogs', {})
if 'catalogs' in task and task['catalogs']:
for catalog in task['catalogs']:
self.render_text_element(xml, 'catalog', {'dc:uri': catalog},
None)
xml.endElement('catalogs')
xml.endElement('task')
def import_view(element):
try:
view = View.objects.get(uri=element['uri'])
except View.DoesNotExist:
log.info('View not in db. Created with uri %s.', element['uri'])
view = View()
view.uri_prefix = element['uri_prefix'] or ''
view.key = element['key'] or ''
view.comment = element['comment'] or ''
view.template = element['template'] or ''
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(view, 'title', element, lang_code, lang_field)
set_lang_field(view, 'help', element, lang_code, lang_field)
try:
ViewUniqueKeyValidator(view).validate()
except ValidationError as e:
log.info('View not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('View saving to "%s".', element['uri'])
view.save()
def set_lang_field(instance, field_name, element):
for lang_code, lang_string, lang_field in get_languages():
field = element.get('%s_%s' % (field_name, lang_code))
if field:
setattr(instance, '%s_%s' % (field_name, lang_field), field)
else:
setattr(instance, '%s_%s' % (field_name, lang_field), '')
def trans(self, field):
current_language = get_language()
languages = get_languages()
for lang_code, lang_string, lang_field in languages:
if lang_code == current_language:
return getattr(self, '%s_%s' % (field, lang_field)) or ''
primary_lang_field = languages[0][2]
return getattr(self, '%s_%s' % (field, primary_lang_field)) or ''
def get_instance_as_dict(self, instance):
model_data = super(TestTranslationMixin,
self).get_instance_as_dict(instance)
for lang_code, lang_string, lang_field in get_languages():
for field in self.trans_fields:
model_field = '%s_%s' % (field, lang_field)
data_field = '%s_%s' % (field, lang_code)
model_data[data_field] = model_data.get(model_field)
return model_data
def import_questionset(element):
try:
questionset = QuestionSet.objects.get(uri=element['uri'])
except QuestionSet.DoesNotExist:
log.info('QuestionSet not in db. Created with uri %s.', element['uri'])
questionset = QuestionSet()
try:
questionset.section = Section.objects.get(uri=element['section'])
except Section.DoesNotExist:
log.info('Section not in db. Skipping.')
return
questionset.uri_prefix = element['uri_prefix'] or ''
questionset.key = element['key'] or ''
questionset.comment = element['comment'] or ''
if element['attribute']:
try:
questionset.attribute = Attribute.objects.get(
uri=element['attribute'])
except Attribute.DoesNotExist:
pass
questionset.is_collection = element['is_collection']
questionset.order = element['order']
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(questionset, 'title', element, lang_code, lang_field)
set_lang_field(questionset, 'help', element, lang_code, lang_field)
set_lang_field(questionset, 'verbose_name', element, lang_code,
lang_field)
set_lang_field(questionset, 'verbose_name_plural', element, lang_code,
lang_field)
try:
QuestionSetUniquePathValidator(questionset).validate()
except ValidationError as e:
log.info('QuestionSet not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('QuestionSet saving to "%s".', element['uri'])
questionset.save()
questionset.conditions.clear()
if element['conditions'] is not None:
for condition in element['conditions']:
try:
questionset.conditions.add(
Condition.objects.get(uri=condition))
except Condition.DoesNotExist:
pass
def render_option(self, xml, option):
xml.startElement('option', {'dc:uri': option['uri']})
self.render_text_element(xml, 'uri_prefix', {}, option['uri_prefix'])
self.render_text_element(xml, 'key', {}, option['key'])
self.render_text_element(xml, 'path', {}, option['path'])
self.render_text_element(xml, 'dc:comment', {}, option['comment'])
self.render_text_element(xml, 'optionset', {'dc:uri': option['optionset']}, None)
self.render_text_element(xml, 'order', {}, option['order'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'title', {'lang': lang_code}, option['text_%s' % lang_code])
self.render_text_element(xml, 'additional_input', {}, option['additional_input'])
xml.endElement('option')
def render_view(self, xml, view):
xml.startElement('view', {'dc:uri': view['uri']})
self.render_text_element(xml, 'uri_prefix', {}, view['uri_prefix'])
self.render_text_element(xml, 'key', {}, view['key'])
self.render_text_element(xml, 'dc:comment', {}, view['comment'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'title', {'lang': lang_code},
view['title_%s' % lang_code])
self.render_text_element(xml, 'help', {'lang': lang_code},
view['help_%s' % lang_code])
self.render_text_element(xml, 'template', {}, view['template'])
xml.endElement('view')
def import_task(element):
try:
task = Task.objects.get(uri=element['uri'])
except Task.DoesNotExist:
log.info('Task not in db. Created with uri %s.', element['uri'])
task = Task()
task.uri_prefix = element['uri_prefix'] or ''
task.key = element['key'] or ''
task.comment = element['comment'] or ''
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(task, 'title', element, lang_code, lang_field)
set_lang_field(task, 'text', element, lang_code, lang_field)
if element['start_attribute']:
try:
task.start_attribute = Attribute.objects.get(
uri=element['start_attribute'])
except Attribute.DoesNotExist:
pass
if element['end_attribute']:
try:
task.end_attribute = Attribute.objects.get(
uri=element['end_attribute'])
except Attribute.DoesNotExist:
pass
task.days_before = element['days_before']
task.days_after = element['days_after']
try:
TaskUniqueKeyValidator(task).validate()
except ValidationError as e:
log.info('Task not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('Task saving to "%s".', element['uri'])
task.save()
task.conditions.clear()
if element['conditions'] is not None:
for condition in element['conditions']:
try:
task.conditions.add(Condition.objects.get(uri=condition))
except Condition.DoesNotExist:
pass
def trans(self, field):
current_language = get_language()
languages = get_languages()
for lang_code, lang_string, lang_field in languages:
if lang_code == current_language:
r = getattr(self, '%s_%s' % (field, lang_field)) or None
if r is not None:
return r
else:
for i in range(1, 6):
r = getattr(self, '%s_%s' % (field, 'lang' + str(i))) or None
if r is not None:
return r
return ''
def __init__(self, *args, **kwargs):
super(TranslationSerializerMixin, self).__init__(*args, **kwargs)
meta = getattr(self, 'Meta', None)
if meta:
for lang_code, lang_string, lang_field in get_languages():
for field in meta.trans_fields:
field_name = '%s_%s' % (field, lang_field)
model_field = meta.model._meta.get_field(field_name)
self.fields['%s_%s' % (field, lang_code)] = serializers.CharField(
source=field_name,
required=not model_field.blank,
allow_null=model_field.null,
allow_blank=model_field.blank)
def render_question(self, xml, question):
xml.startElement('question', {'dc:uri': question['uri']})
self.render_text_element(xml, 'uri_prefix', {}, question['uri_prefix'])
self.render_text_element(xml, 'key', {}, question['key'])
self.render_text_element(xml, 'path', {}, question['path'])
self.render_text_element(xml, 'dc:comment', {}, question['comment'])
self.render_text_element(xml, 'attribute',
{'dc:uri': question['attribute']}, None)
self.render_text_element(xml, 'questionset',
{'dc:uri': question['questionset']}, None)
self.render_text_element(xml, 'is_collection', {},
question['is_collection'])
self.render_text_element(xml, 'order', {}, question['order'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'help', {'lang': lang_code},
question['help_%s' % lang_code])
self.render_text_element(xml, 'text', {'lang': lang_code},
question['text_%s' % lang_code])
self.render_text_element(xml, 'verbose_name', {'lang': lang_code},
question['verbose_name_%s' % lang_code])
self.render_text_element(
xml, 'verbose_name_plural', {'lang': lang_code},
question['verbose_name_plural_%s' % lang_code])
self.render_text_element(xml, 'widget_type', {},
question['widget_type'])
self.render_text_element(xml, 'value_type', {}, question['value_type'])
self.render_text_element(xml, 'maximum', {}, question['maximum'])
self.render_text_element(xml, 'minimum', {}, question['minimum'])
self.render_text_element(xml, 'step', {}, question['step'])
self.render_text_element(xml, 'unit', {}, question['unit'])
xml.startElement('optionsets', {})
if 'optionsets' in question and question['optionsets']:
for optionset in question['optionsets']:
self.render_text_element(xml, 'optionset',
{'dc:uri': optionset}, None)
xml.endElement('optionsets')
xml.startElement('conditions', {})
if 'conditions' in question and question['conditions']:
for condition in question['conditions']:
self.render_text_element(xml, 'condition',
{'dc:uri': condition}, None)
xml.endElement('conditions')
xml.endElement('question')
def render_catalog(self, xml, catalog):
xml.startElement('catalog', {'dc:uri': catalog['uri']})
self.render_text_element(xml, 'uri_prefix', {}, catalog['uri_prefix'])
self.render_text_element(xml, 'key', {}, catalog['key'])
self.render_text_element(xml, 'dc:comment', {}, catalog['comment'])
self.render_text_element(xml, 'order', {}, catalog['order'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'title', {'lang': lang_code},
catalog['title_%s' % lang_code])
xml.endElement('catalog')
if 'sections' in catalog and catalog['sections']:
for section in catalog['sections']:
self.render_section(xml, section)
def render_section(self, xml, section):
xml.startElement('section', {'dc:uri': section['uri']})
self.render_text_element(xml, 'uri_prefix', {}, section['uri_prefix'])
self.render_text_element(xml, 'key', {}, section['key'])
self.render_text_element(xml, 'path', {}, section['path'])
self.render_text_element(xml, 'dc:comment', {}, section['comment'])
self.render_text_element(xml, 'catalog', {'dc:uri': section['catalog']}, None)
self.render_text_element(xml, 'order', {}, section['order'])
for lang_code, lang_string, lang_field in get_languages():
self.render_text_element(xml, 'title', {'lang': lang_code}, section['title_%s' % lang_code])
xml.endElement('section')
if 'questionsets' in section and section['questionsets']:
for questionset in section['questionsets']:
self.render_questionset(xml, questionset)
def import_question(element):
try:
question = Question.objects.get(uri=element['uri'])
except Question.DoesNotExist:
log.info('QuestionSet not in db. Created with uri %s.', element['uri'])
question = Question()
try:
question.questionset = QuestionSet.objects.get(
uri=element['questionset'])
except QuestionSet.DoesNotExist:
log.info('QuestionSet not in db. Skipping.')
return
question.uri_prefix = element['uri_prefix'] or ''
question.key = element['key'] or ''
question.comment = element['comment'] or ''
if element['attribute']:
try:
question.attribute = Attribute.objects.get(
uri=element['attribute'])
except Attribute.DoesNotExist:
pass
question.is_collection = element['is_collection']
question.order = element['order']
for lang_code, lang_string, lang_field in get_languages():
set_lang_field(question, 'text', element, lang_code, lang_field)
set_lang_field(question, 'help', element, lang_code, lang_field)
set_lang_field(question, 'verbose_name', element, lang_code,
lang_field)
set_lang_field(question, 'verbose_name_plural', element, lang_code,
lang_field)
question.widget_type = element['widget_type'] or ''
question.value_type = element['value_type'] or ''
question.maximum = element['maximum']
question.minimum = element['minimum']
question.step = element['step']
question.unit = element['unit'] or ''
try:
QuestionUniquePathValidator(question).validate()
except ValidationError as e:
log.info('Question not saving "%s" due to validation error (%s).',
element['uri'], e)
pass
else:
log.info('Question saving to "%s".', element['uri'])
question.save()
question.conditions.clear()
if element['conditions'] is not None:
for condition in element['conditions']:
try:
question.conditions.add(Condition.objects.get(uri=condition))
except Condition.DoesNotExist:
pass
question.optionsets.clear()
if element['optionsets'] is not None:
for condition in element['optionsets']:
try:
question.optionsets.add(OptionSet.objects.get(uri=condition))
except OptionSet.DoesNotExist:
pass
