def _save_phrases(self, meeting):
phrases_default = (PhraseDefault.query.filter_by(
meeting_type_slug=meeting.meeting_type_slug))
for phrase_default in phrases_default:
phrase = copy_attributes(Phrase(), phrase_default)
phrase.description = (
copy_attributes(Translation(), phrase_default.description)
if phrase_default.description else Translation(english=''))
phrase.meeting = meeting
db.session.add(phrase)
db.session.flush()
def add_custom_field_sex(ctx, meeting):
# previously named add_custom_sex_field(ctx):
app = ctx.obj['app']
with app.test_request_context():
meeting_obj = Meeting.query.filter_by(id=meeting).scalar()
meetings = [meeting_obj] if meeting_obj else Meeting.query.all()
for meeting in meetings:
query = (CustomField.query.filter_by(slug='sex', meeting=meeting))
if query.scalar():
continue
custom_field = CustomField()
custom_field.meeting = meeting
custom_field.slug = 'sex'
custom_field.label = Translation(english=u'Sex')
custom_field.required = False
custom_field.field_type = CustomField.SELECT
custom_field.is_primary = True
custom_field.visible_on_registration_form = True
custom_field.is_protected = True
db.session.add(custom_field)
_add_choice_values_for_custom_field(custom_field,
Participant.SEX_CHOICES)
click.echo(u'Sex field added for meeting %s \n' % meeting.id)
db.session.commit()
def _clone_categories(self, meeting, categories):
for category in categories:
with db.session.no_autoflush:
clone = copy_attributes(Category(), category)
clone.tags = category.tags
clone.title = copy_attributes(Translation(), category.title)
clone.meeting = meeting
db.session.add(clone)
db.session.flush()
def _save_categories(self, meeting):
for category_default in meeting.meeting_type.default_categories:
category = copy_attributes(Category(), category_default)
category.title = copy_attributes(Translation(),
category_default.title)
category.tags = category_default.tags
category.meeting = meeting
db.session.add(category)
db.session.flush()
def _clone_custom_fields(self, meeting, custom_fields,
translation_attrs=[]):
for custom_field in custom_fields:
clone = copy_attributes(custom_field.__class__(), custom_field)
for attr in translation_attrs:
setattr(clone, attr, copy_attributes(Translation(),
getattr(custom_field, attr)))
clone.meeting = meeting
db.session.add(clone)
for choice in custom_field.choices:
if choice.value.english == 'Nomenclature specialist':
continue
choice_clone = CustomFieldChoice(custom_field=clone)
setattr(choice_clone, 'value', copy_attributes(Translation(),
getattr(choice, 'value')))
db.session.add(choice_clone)
db.session.flush()
def _clone_relation(self, meeting, children, translation_attrs=[],
exclude_fk=True):
for child in children:
clone = copy_attributes(child.__class__(), child,
exclude_fk=exclude_fk)
for attr in translation_attrs:
setattr(clone, attr,
copy_attributes(Translation(), getattr(child, attr)))
clone.meeting = meeting
db.session.add(clone)
db.session.flush()
def migrate_hint(ctx):
app = ctx.obj['app']
with app.app_context():
for custom_field in CustomField.query.all():
if not custom_field.description:
continue
hint = Translation(english=custom_field.description)
db.session.add(hint)
db.session.flush()
custom_field.hint = hint
db.session.commit()
def _save_custom_field(self, meeting):
add_custom_fields_for_meeting(meeting, form_class=ParticipantDummyForm)
query = (CustomField.query.filter_by(meeting=meeting).with_entities(
CustomField.sort).order_by(desc(CustomField.sort)).first())
last_sort = query[0] + 1
# Copy default custom fields for meeting type
for field_default in meeting.meeting_type.default_fields:
field = copy_attributes(CustomField(), field_default)
field.label = copy_attributes(Translation(), field_default.label)
field.sort = last_sort
last_sort += 1
field.meeting = meeting
db.session.add(field)
db.session.flush()
def add_participant_custom_fields(meeting, form_class=ParticipantDummyForm):
"""Adds participants fields as CustomFields to meeting."""
for i, field in enumerate(form_class()):
custom_field = CustomField()
custom_field.meeting = meeting
custom_field.slug = field.name
custom_field.label = Translation(english=unicode(field.label.text))
custom_field.required = field.flags.required
custom_field.field_type = _CUSTOM_FIELD_MAPPER[field.type]
custom_field.custom_field_type = form_class.CUSTOM_FIELD_TYPE
custom_field.is_primary = True
custom_field.sort = i + 1
custom_field.visible_on_registration_form = True
db.session.add(custom_field)
if custom_field.field_type == CustomField.SELECT:
_add_choice_values_for_custom_field(custom_field, field.choices)
db.session.commit()
def add_verified_flag_mp(ctx):
app = ctx.obj['app']
with app.test_request_context():
for meeting in Meeting.query.all():
if meeting.settings.get('media_participant_enabled', False):
if meeting.custom_fields.filter_by(
custom_field_type=CustomField.MEDIA,
slug='verified').count():
continue
cf = CustomField(slug='verified',
meeting_id=meeting.id,
field_type=CustomField.CHECKBOX,
is_primary=True,
custom_field_type=CustomField.MEDIA)
cf.label = Translation(english='Acknowledged')
cf.sort = meeting.custom_fields.filter_by(
custom_field_type=CustomField.MEDIA).count() + 1
db.session.add(cf)
db.session.commit()
def save(self):
categories_default = CategoryDefault.query.filter(
CategoryDefault.id.in_(self.categories.data))
for category_default in categories_default:
category = copy_attributes(Category(),
category_default,
exclude=('background', ))
translation = Translation(english=category_default.title.english)
db.session.add(translation)
db.session.flush()
category.title = translation
category.tags = category_default.tags
category.meeting = g.meeting
filename = duplicate_uploaded_file(category_default.background,
'backgrounds')
if filename:
category.background = filename.basename()
db.session.add(category)
db.session.commit()
def add_custom_fields_for_meeting(meeting, form_class=ParticipantDummyForm):
"""Adds participants fields as CustomFields to meeting."""
form = form_class()
for i, field in enumerate(form):
query = (
CustomField.query
.filter_by(slug=field.name, meeting=meeting)
.filter_by(custom_field_type=form.CUSTOM_FIELD_TYPE)
)
if query.scalar():
continue
custom_field = CustomField()
custom_field.meeting = meeting
custom_field.slug = field.name
custom_field.label = Translation(english=unicode(field.label.text))
custom_field.required = field.flags.required
custom_field.field_type = _CUSTOM_FIELD_MAPPER[field.type]
custom_field.is_primary = True
custom_field.custom_field_type = form.CUSTOM_FIELD_TYPE
custom_field.max_length = _extract_max_length_from_field(field)
if field.name in form.meta.visible_on_registration_form:
custom_field.visible_on_registration_form = True
else:
custom_field.visible_on_registration_form = False
if field.name in form.meta.protected_fields:
custom_field.is_protected = True
else:
custom_field.is_protected = False
custom_field.sort = i + 1
db.session.add(custom_field)
if custom_field.field_type in (CustomField.SELECT,
CustomField.LANGUAGE):
_add_choice_values_for_custom_field(custom_field, field.choices)
db.session.commit()
def save(self):
cf = self.obj or CustomField()
self.populate_obj(cf)
cf.meeting = g.meeting
is_choice_field_disabled = self.custom_field_choices.flags.disabled
if (cf.field_type in (CustomField.MULTI_CHECKBOX, CustomField.RADIO)
and not is_choice_field_disabled):
CustomFieldChoice.query.filter_by(custom_field_id=cf.id).delete()
for choice in self.custom_field_choices.data:
cf_choice = CustomFieldChoice(custom_field=cf)
cf_choice.value = Translation(english=choice)
db.session.add(cf_choice)
if not cf.id:
last_sort = (CustomField.query.filter_by(
meeting=g.meeting).with_entities(CustomField.sort).order_by(
desc(CustomField.sort)).first())
if last_sort:
cf.sort = last_sort[0] + 1
db.session.add(cf)
db.session.commit()
def _add_choice_values_for_custom_field(custom_field, choices):
"""Adds CustomFieldChoices for CustomField."""
for value, label in (choices or []):
custom_field_choice = CustomFieldChoice(custom_field=custom_field)
custom_field_choice.value = Translation(english=value)
db.session.add(custom_field_choice)
def sync_cites_meetings(ctx):
app = ctx.obj['app']
cites_meetings_urls = {
'english': 'https://cites.org/ws/meetings-mrt',
'french': 'https://cites.org/fra/ws/meetings-mrt',
'spanish': 'https://cites.org/esp/ws/meetings-mrt',
}
retrieved_meetings = defaultdict(dict)
headers = {'Accept': 'application/json'}
for language in cites_meetings_urls:
response = requests.get(cites_meetings_urls[language], headers=headers)
response.raise_for_status()
for meeting in response.json():
unique_id = meeting.get('id', '')
meeting_dict = retrieved_meetings[unique_id]
meeting_dict['{}_title'.format(language)] = meeting.get(
'title', '')
meeting_dict['{}_city'.format(language)] = meeting.get('city', '')
meeting_dict['description'] = meeting.get('description', '')
meeting_dict['meeting_type'] = meeting.get('type', '')
meeting_dict['start'] = meeting.get('start', '')
meeting_dict['end'] = meeting.get('end', '')
meeting_dict['location'] = meeting.get('location', '')
meeting_dict['country'] = meeting.get('country', '')
meeting_dict['country_code2'] = meeting.get('country_code2', '')
meeting_dict['country_code3'] = meeting.get('country_code3', '')
meeting_dict['meeting_number'] = meeting.get('meeting_number', '')
meeting_dict['link'] = meeting.get('link', '')
meeting_dict['acronym'] = meeting_dict[
'meeting_type'] + meeting_dict['meeting_number']
with app.test_request_context():
for meeting in retrieved_meetings:
meeting_dict = retrieved_meetings[meeting]
if Meeting.query.filter_by(
acronym=meeting_dict['acronym']).count():
# Meeting already exists
continue
else:
curr_meeting_type = MeetingType.query.filter_by(
label=meeting_dict['meeting_type']).first()
if not curr_meeting_type:
curr_meeting_type = MeetingType(
label=meeting_dict['meeting_type'],
slug=slugify(meeting_dict['meeting_type']))
db.session.add(curr_meeting_type)
date_start = datetime.strptime(
re.sub(re.compile('<.*?>'), '', meeting_dict['start']),
'%d/%m/%Y')
date_end = datetime.strptime(
re.sub(re.compile('<.*?>'), '', meeting_dict['end']),
'%d/%m/%Y')
curr_meeting = Meeting(acronym=meeting_dict['acronym'],
date_start=date_start,
date_end=date_end)
curr_meeting.meeting_type = curr_meeting_type
curr_meeting.venue_country = meeting_dict['country_code2']
curr_meeting.venue_city = Translation(
english=meeting_dict['english_city'],
french=meeting_dict['french_city'],
spanish=meeting_dict['spanish_city'])
curr_meeting.title = Translation(
english=meeting_dict['english_title'],
french=meeting_dict['french_title'],
spanish=meeting_dict['spanish_title'])
db.session.add(curr_meeting)
db.session.commit()
