def create_contribution_from_abstract(abstract, contrib_session=None):
event = abstract.event
contrib_person_links = set()
person_link_attrs = {
'_title', 'address', 'affiliation', 'first_name', 'last_name', 'phone',
'author_type', 'is_speaker', 'display_order'
}
for abstract_person_link in abstract.person_links:
link = ContributionPersonLink(person=abstract_person_link.person)
link.populate_from_attrs(abstract_person_link, person_link_attrs)
contrib_person_links.add(link)
duration = contrib_session.default_contribution_duration if contrib_session else timedelta(
minutes=15)
custom_fields_data = {
'custom_{}'.format(field_value.contribution_field.id): field_value.data
for field_value in abstract.field_values
}
return create_contribution(event, {
'friendly_id': abstract.friendly_id,
'title': abstract.title,
'duration': duration,
'description': abstract.description,
'type': abstract.accepted_contrib_type,
'track': abstract.accepted_track,
'session': contrib_session,
'person_link_data': {link: True
for link in contrib_person_links}
},
custom_fields_data=custom_fields_data)
def create_contribution_from_abstract(abstract, contrib_session=None):
event = abstract.event
contrib_person_links = set()
person_link_attrs = {'_title', 'address', 'affiliation', 'first_name', 'last_name', 'phone', 'author_type',
'is_speaker', 'display_order'}
for abstract_person_link in abstract.person_links:
link = ContributionPersonLink(person=abstract_person_link.person)
link.populate_from_attrs(abstract_person_link, person_link_attrs)
contrib_person_links.add(link)
if contrib_session:
duration = contrib_session.default_contribution_duration
else:
duration = contribution_settings.get(event, 'default_duration')
custom_fields_data = {'custom_{}'.format(field_value.contribution_field.id): field_value.data for
field_value in abstract.field_values}
return create_contribution(event, {'friendly_id': abstract.friendly_id,
'title': abstract.title,
'duration': duration,
'description': abstract.description,
'type': abstract.accepted_contrib_type,
'track': abstract.accepted_track,
'session': contrib_session,
'person_link_data': {link: True for link in contrib_person_links}},
custom_fields_data=custom_fields_data)
def test_access_everyone(dummy_contribution, dummy_user, dummy_event):
menu_entry = MenuEntry(event=dummy_event,
type=MenuEntryType.page,
access=MenuEntryAccess.everyone)
person = EventPerson.create_from_user(dummy_user, dummy_event)
assert menu_entry.can_access(dummy_user)
contrib_person_link = ContributionPersonLink(person=person)
dummy_contribution.person_links.append(contrib_person_link)
assert menu_entry.can_access(dummy_user)
contrib_person_link.is_speaker = True
assert menu_entry.can_access(dummy_user)
def test_access_participants_not_registered(dummy_contribution, dummy_user,
dummy_event):
menu_entry = MenuEntry(event=dummy_event,
type=MenuEntryType.page,
access=MenuEntryAccess.registered_participants)
person = EventPerson.create_from_user(dummy_user, dummy_event)
assert not menu_entry.can_access(dummy_user)
contrib_person_link = ContributionPersonLink(person=person)
dummy_contribution.person_links.append(contrib_person_link)
assert not menu_entry.can_access(dummy_user)
contrib_person_link.is_speaker = True
assert not menu_entry.can_access(dummy_user)
def create_contribution_from_abstract(abstract, contrib_session=None):
from indico.modules.events.abstracts.settings import abstracts_settings
event = abstract.event
contrib_person_links = set()
author_submission_rights = (
event.cfa.contribution_submitters == SubmissionRightsType.all)
person_link_attrs = {
'_title', 'address', 'affiliation', 'first_name', 'last_name', 'phone',
'author_type', 'is_speaker', 'display_order'
}
for abstract_person_link in abstract.person_links:
link = ContributionPersonLink(person=abstract_person_link.person)
link.populate_from_attrs(abstract_person_link, person_link_attrs)
contrib_person_links.add(link)
if contrib_session:
duration = contrib_session.default_contribution_duration
else:
duration = contribution_settings.get(event, 'default_duration')
custom_fields_data = {
f'custom_{field_value.contribution_field.id}': field_value.data
for field_value in abstract.field_values
}
contrib = create_contribution(event, {
'friendly_id': abstract.friendly_id,
'title': abstract.title,
'duration': duration,
'description': abstract.description,
'type': abstract.accepted_contrib_type,
'track': abstract.accepted_track,
'session': contrib_session,
'person_link_data': {
link: (author_submission_rights or link.is_speaker)
for link in contrib_person_links
}
},
custom_fields_data=custom_fields_data)
if abstracts_settings.get(event, 'copy_attachments') and abstract.files:
folder = AttachmentFolder.get_or_create_default(contrib)
for abstract_file in abstract.files:
attachment = Attachment(user=abstract.submitter,
type=AttachmentType.file,
folder=folder,
title=abstract_file.filename)
attachment.file = AttachmentFile(
user=abstract.submitter,
filename=abstract_file.filename,
content_type=abstract_file.content_type)
with abstract_file.open() as fd:
attachment.file.save(fd)
db.session.flush()
return contrib
def test_access_speakers_contrib(dummy_contribution, dummy_user, dummy_event):
set_feature_enabled(dummy_event, 'registration', True)
menu_entry = MenuEntry(event=dummy_event,
type=MenuEntryType.page,
access=MenuEntryAccess.speakers)
person = EventPerson.create_from_user(dummy_user, dummy_event)
assert not menu_entry.can_access(dummy_user)
contrib_person_link = ContributionPersonLink(person=person)
dummy_contribution.person_links.append(contrib_person_link)
assert not menu_entry.can_access(dummy_user)
contrib_person_link.is_speaker = True
assert menu_entry.can_access(dummy_user)
dummy_contribution.is_deleted = True
assert not menu_entry.can_access(dummy_user)
def _process(self):
contribution_persons = (ContributionPersonLink.find(
ContributionPersonLink.contribution.has(
self._membership_filter)).all())
contribution_persons.extend(
SubContributionPersonLink.find(
SubContributionPersonLink.subcontribution.has(
SubContribution.contribution.has(
self._membership_filter))).all())
contribution_persons_dict = defaultdict(lambda: {
'speaker': False,
'primary_author': False,
'secondary_author': False
})
for contrib_person in contribution_persons:
person_roles = contribution_persons_dict[contrib_person.person]
person_roles['speaker'] |= contrib_person.is_speaker
person_roles[
'primary_author'] |= contrib_person.author_type == AuthorType.primary
person_roles[
'secondary_author'] |= contrib_person.author_type == AuthorType.secondary
return jsonify_template(
'events/management/contribution_person_list.html',
event_persons=contribution_persons_dict,
event=self.event_new)
def _process(self):
contribution_persons = (ContributionPersonLink.find(
ContributionPersonLink.contribution.has(
self._membership_filter)).all())
contribution_persons.extend(
SubContributionPersonLink.find(
SubContributionPersonLink.subcontribution.has(
SubContribution.contribution.has(
self._membership_filter))).all())
registered_persons = get_registered_event_persons(self.event)
contribution_persons_dict = defaultdict(
lambda: {
'speaker': False,
'primary_author': False,
'secondary_author': False,
'not_registered': True
})
for contrib_person in contribution_persons:
person_roles = contribution_persons_dict[contrib_person.person]
person_roles['speaker'] |= contrib_person.is_speaker
person_roles[
'primary_author'] |= contrib_person.author_type == AuthorType.primary
person_roles[
'secondary_author'] |= contrib_person.author_type == AuthorType.secondary
person_roles[
'not_registered'] = contrib_person.person not in registered_persons
return jsonify_template(self.template,
event_persons=contribution_persons_dict,
event=self.event)
def contribution_from_abstract(abstract, sess):
from MaKaC.review import AbstractStatusAccepted
event = abstract.as_new.event_new
duration = sess.default_contribution_duration if sess else timedelta(
minutes=15)
links = []
for auth in abstract.getAuthorList():
author_type = AuthorType.primary if abstract.isPrimaryAuthor(
auth) else AuthorType.secondary
person_data = {
'title': UserTitle.from_legacy(to_unicode(auth.getTitle())),
'email': to_unicode(auth.getEmail()),
'address': to_unicode(auth.getAddress()),
'affiliation': to_unicode(auth.getAffiliation()),
'first_name': to_unicode(auth.getFirstName()),
'last_name': to_unicode(auth.getSurName()),
'phone': to_unicode(auth.getTelephone())
}
person = person_from_data(person_data, event)
person_data.pop('email')
links.append(
ContributionPersonLink(author_type=author_type,
person=person,
is_speaker=abstract.isSpeaker(auth),
**person_data))
custom_fields_data = {
'custom_{}'.format(field_val.contribution_field.id): field_val.data
for field_val in abstract.as_new.field_values
}
contrib = create_contribution(event, {
'friendly_id': abstract.as_new.friendly_id,
'title': to_unicode(abstract.getTitle()),
'duration': duration,
'person_link_data': {link: True
for link in links}
},
custom_fields_data=custom_fields_data)
contrib.abstract = abstract.as_new
contrib.description = abstract.as_new.description
# if this is an accepted abstract, set track and type if present
status = abstract.getCurrentStatus()
if isinstance(status, AbstractStatusAccepted):
track = abstract.as_new.accepted_track
contrib_type = abstract.as_new.accepted_type
if track:
contrib.track_id = int(track.getId())
if contrib_type:
contrib.type = contrib_type
if sess:
contrib.session = sess
return contrib
def test_unused_event_person(db, dummy_user, dummy_event, create_contribution,
create_subcontribution, create_abstract):
person = EventPerson.create_from_user(dummy_user, event=dummy_event)
assert not person.has_links
dummy_event.person_links.append(EventPersonLink(person=person))
db.session.flush()
assert person.has_links
dummy_event.person_links.clear()
db.session.flush()
assert not person.has_links
set_feature_enabled(dummy_event, 'abstracts', True)
abstract = create_abstract(dummy_event,
'Dummy abstract',
submitter=dummy_user,
person_links=[
AbstractPersonLink(
person=person,
is_speaker=True,
author_type=AuthorType.primary)
])
assert person.has_links
abstract.is_deleted = True
assert not person.has_links
contrib = create_contribution(
dummy_event,
'Dummy contribution',
person_links=[ContributionPersonLink(person=person, is_speaker=True)])
assert person.has_links
contrib.is_deleted = True
assert not person.has_links
db.session.delete(contrib)
contrib = create_contribution(dummy_event,
'Dummy contribution',
person_links=[])
assert not person.has_links
create_subcontribution(contrib,
'Dummy subcontribution',
person_links=[
SubContributionPersonLink(person=person,
is_speaker=True)
])
assert person.has_links
contrib.is_deleted = True
assert not person.has_links
db.session.delete(contrib)
assert not person.has_links
def _migrate_contribution_person_links(self, old_entry):
person_link_map = {}
person_link_data_map = defaultdict(list)
for speaker in getattr(old_entry, '_speakers', []):
person = self._get_person(speaker)
if not person:
continue
person_link_data = self._get_person_data(speaker)
person_link_data_map[person].append(person_link_data)
link = person_link_map.get(person)
if link:
self._update_link_data(link, person_link_data_map[person])
link.is_speaker = True
else:
link = ContributionPersonLink(person=person, is_speaker=True, **person_link_data)
person_link_map[person] = link
yield link
for author in getattr(old_entry, '_primaryAuthors', []):
person = self._get_person(author)
if not person:
continue
person_link_data = self._get_person_data(author)
person_link_data_map[person].append(person_link_data)
link = person_link_map.get(person)
if link:
self._update_link_data(link, person_link_data_map[person])
link.author_type = AuthorType.primary
else:
link = ContributionPersonLink(person=person, author_type=AuthorType.primary, **person_link_data)
person_link_map[person] = link
yield link
for coauthor in getattr(old_entry, '_coAuthors', []):
person = self._get_person(coauthor)
if not person:
continue
person_link_data = self._get_person_data(coauthor)
person_link_data_map[person].append(person_link_data)
link = person_link_map.get(person)
if link:
self._update_link_data(link, person_link_data_map[person])
if link.author_type == AuthorType.primary:
self.print_warning('%[yellow!]Primary author "{}" is also co-author'
.format(person.full_name))
else:
link.author_type = AuthorType.secondary
else:
link = ContributionPersonLink(person=person, author_type=AuthorType.secondary, **person_link_data)
person_link_map[person] = link
yield link
def create_contribution_from_abstract(abstract, contrib_session=None):
from indico.modules.events.abstracts.settings import abstracts_settings
event = abstract.event
contrib_person_links = set()
person_link_attrs = {'_title', 'address', 'affiliation', 'first_name', 'last_name', 'phone', 'author_type',
'is_speaker', 'display_order'}
for abstract_person_link in abstract.person_links:
link = ContributionPersonLink(person=abstract_person_link.person)
link.populate_from_attrs(abstract_person_link, person_link_attrs)
contrib_person_links.add(link)
if contrib_session:
duration = contrib_session.default_contribution_duration
else:
duration = contribution_settings.get(event, 'default_duration')
custom_fields_data = {'custom_{}'.format(field_value.contribution_field.id): field_value.data for
field_value in abstract.field_values}
contrib = create_contribution(event, {'friendly_id': abstract.friendly_id,
'title': abstract.title,
'duration': duration,
'description': abstract.description,
'type': abstract.accepted_contrib_type,
'track': abstract.accepted_track,
'session': contrib_session,
'person_link_data': {link: True for link in contrib_person_links}},
custom_fields_data=custom_fields_data)
if abstracts_settings.get(event, 'copy_attachments') and abstract.files:
folder = AttachmentFolder.get_or_create_default(contrib)
for abstract_file in abstract.files:
attachment = Attachment(user=abstract.submitter, type=AttachmentType.file, folder=folder,
title=abstract_file.filename)
attachment.file = AttachmentFile(user=abstract.submitter, filename=abstract_file.filename,
content_type=abstract_file.content_type)
with abstract_file.open() as fd:
attachment.file.save(fd)
db.session.flush()
return contrib
def _process(self):
contribution_persons = ContributionPersonLink.find(
ContributionPersonLink.contribution.has(self._membership_filter)
).all()
contribution_persons.extend(
SubContributionPersonLink.find(
SubContributionPersonLink.subcontribution.has(SubContribution.contribution.has(self._membership_filter))
).all()
)
contribution_persons_dict = defaultdict(
lambda: {"speaker": False, "primary_author": False, "secondary_author": False}
)
for contrib_person in contribution_persons:
person_roles = contribution_persons_dict[contrib_person.person]
person_roles["speaker"] |= contrib_person.is_speaker
person_roles["primary_author"] |= contrib_person.author_type == AuthorType.primary
person_roles["secondary_author"] |= contrib_person.author_type == AuthorType.secondary
return jsonify_template(
"events/management/contribution_person_list.html",
event_persons=contribution_persons_dict,
event=self.event_new,
)
def _process_args(self):
RHContributionDisplayBase._process_args(self)
self.author = (ContributionPersonLink.find_one(
ContributionPersonLink.author_type != AuthorType.none,
id=request.view_args['person_id'],
contribution=self.contrib))
def import_contributions_from_csv(event, f):
"""Import timetable contributions from a CSV file into an event."""
with csv_text_io_wrapper(f) as ftxt:
reader = csv.reader(ftxt.read().splitlines())
contrib_data = []
for num_row, row in enumerate(reader, 1):
try:
start_dt, duration, title, first_name, last_name, affiliation, email = (
value.strip() for value in row)
email = email.lower()
except ValueError:
raise UserValueError(
_('Row {}: malformed CSV data - please check that the number of columns is correct'
).format(num_row))
try:
parsed_start_dt = event.tzinfo.localize(
dateutil.parser.parse(start_dt)) if start_dt else None
except ValueError:
raise UserValueError(
_('Row {row}: can\'t parse date: "{date}"').format(
row=num_row, date=start_dt))
try:
parsed_duration = timedelta(
minutes=int(duration)) if duration else None
except ValueError:
raise UserValueError(
_("Row {row}: can't parse duration: {duration}").format(
row=num_row, duration=duration))
if not title:
raise UserValueError(
_('Row {}: contribution title is required').format(num_row))
if email and not validate_email(email):
raise UserValueError(
_('Row {row}: invalid email address: {email}').format(
row=num_row, email=email))
contrib_data.append({
'start_dt':
parsed_start_dt,
'duration':
parsed_duration or timedelta(minutes=20),
'title':
title,
'speaker': {
'first_name': first_name,
'last_name': last_name,
'affiliation': affiliation,
'email': email
}
})
# now that we're sure the data is OK, let's pre-allocate the friendly ids
# for the contributions in question
Contribution.allocate_friendly_ids(event, len(contrib_data))
contributions = []
all_changes = defaultdict(list)
for contrib_fields in contrib_data:
speaker_data = contrib_fields.pop('speaker')
with track_time_changes() as changes:
contribution = create_contribution(event,
contrib_fields,
extend_parent=True)
contributions.append(contribution)
for key, val in changes[event].items():
all_changes[key].append(val)
email = speaker_data['email']
if not email:
continue
# set the information of the speaker
person = get_event_person(event, speaker_data)
link = ContributionPersonLink(person=person, is_speaker=True)
link.populate_from_dict({
'first_name': speaker_data['first_name'],
'last_name': speaker_data['last_name'],
'affiliation': speaker_data['affiliation']
})
contribution.person_links.append(link)
return contributions, all_changes
def test_dump_contribution(db, dummy_user, dummy_event, dummy_contribution,
create_entry, scheduled):
from indico.modules.search.schemas import ContributionSchema
person = EventPerson.create_from_user(dummy_user, dummy_event)
dummy_contribution.person_links.append(
ContributionPersonLink(person=person))
dummy_contribution.description = 'A dummy contribution'
extra = {'start_dt': None, 'end_dt': None}
if scheduled:
create_entry(dummy_contribution,
utc.localize(datetime(2020, 4, 20, 4, 20)))
extra = {
'start_dt': dummy_contribution.start_dt.isoformat(),
'end_dt': dummy_contribution.end_dt.isoformat(),
}
db.session.flush()
category_id = dummy_contribution.event.category_id
schema = ContributionSchema()
assert schema.dump(dummy_contribution) == {
'description':
'A dummy contribution',
'location': {
'address': '',
'room_name': '',
'venue_name': ''
},
'persons': [{
'affiliation': None,
'name': 'Guinea Pig'
}],
'title':
'Dummy Contribution',
'category_id':
category_id,
'category_path': [
{
'id': 0,
'title': 'Home',
'url': '/'
},
{
'id': category_id,
'title': 'dummy',
'url': f'/category/{category_id}/'
},
],
'contribution_id':
dummy_contribution.id,
'duration':
20,
'event_id':
0,
'type':
'contribution',
'url':
f'/event/0/contributions/{dummy_contribution.id}/',
**extra
}
def _checkParams(self, params):
RHContributionDisplayBase._checkParams(self, params)
self.author = (ContributionPersonLink.find_one(ContributionPersonLink.author_type != AuthorType.none,
id=request.view_args['person_id'],
contribution=self.contrib))
def import_contributions_from_csv(event, f):
"""Import timetable contributions from a CSV file into an event."""
reader = csv.reader(f.read().splitlines())
contrib_data = []
for num_row, row in enumerate(reader, 1):
try:
start_dt, duration, title, first_name, last_name, affiliation, email = \
[to_unicode(value).strip() for value in row]
email = email.lower()
except ValueError:
raise UserValueError(_('Row {}: malformed CSV data - please check that the number of columns is correct')
.format(num_row))
try:
parsed_start_dt = event.tzinfo.localize(dateutil.parser.parse(start_dt)) if start_dt else None
except ValueError:
raise UserValueError(_("Row {row}: can't parse date: \"{date}\"").format(row=num_row, date=start_dt))
try:
parsed_duration = timedelta(minutes=int(duration)) if duration else None
except ValueError:
raise UserValueError(_("Row {row}: can't parse duration: {duration}").format(row=num_row,
duration=duration))
if not title:
raise UserValueError(_("Row {}: contribution title is required").format(num_row))
if email and not validate_email(email):
raise UserValueError(_("Row {row}: invalid email address: {email}").format(row=num_row, email=email))
contrib_data.append({
'start_dt': parsed_start_dt,
'duration': parsed_duration or timedelta(minutes=20),
'title': title,
'speaker': {
'first_name': first_name,
'last_name': last_name,
'affiliation': affiliation,
'email': email
}
})
# now that we're sure the data is OK, let's pre-allocate the friendly ids
# for the contributions in question
Contribution.allocate_friendly_ids(event, len(contrib_data))
contributions = []
all_changes = defaultdict(list)
for contrib_fields in contrib_data:
speaker_data = contrib_fields.pop('speaker')
with track_time_changes() as changes:
contribution = create_contribution(event, contrib_fields, extend_parent=True)
contributions.append(contribution)
for key, val in changes[event].viewitems():
all_changes[key].append(val)
email = speaker_data['email']
if not email:
continue
# set the information of the speaker
person = get_event_person(event, {
'firstName': speaker_data['first_name'],
'familyName': speaker_data['last_name'],
'affiliation': speaker_data['affiliation'],
'email': email
})
link = ContributionPersonLink(person=person, is_speaker=True)
link.populate_from_dict({
'first_name': speaker_data['first_name'],
'last_name': speaker_data['last_name'],
'affiliation': speaker_data['affiliation']
})
contribution.person_links.append(link)
return contributions, all_changes
def _process_args(self):
RHContributionDisplayBase._process_args(self)
self.author = (ContributionPersonLink.find_one(ContributionPersonLink.author_type != AuthorType.none,
id=request.view_args['person_id'],
contribution=self.contrib))
def test_filter_contrib_entries(app, db, dummy_event, create_user,
create_contribution, create_registration):
registered_user = create_user(1)
registered_speaker = create_user(2)
unregistered_user = create_user(3)
dummy_regform = RegistrationForm(event=dummy_event,
title='Registration Form',
currency='USD')
dummy_event.registrations.append(
create_registration(registered_user, dummy_regform))
dummy_event.registrations.append(
create_registration(registered_speaker, dummy_regform))
registered_speaker_contribution = create_contribution(
dummy_event,
'Registered Speaker',
person_links=[
ContributionPersonLink(person=EventPerson.create_from_user(
registered_speaker, dummy_event),
is_speaker=True)
])
registered_speaker_author_contribution = create_contribution(
dummy_event,
'Registered Speaker Author',
person_links=[
ContributionPersonLink(person=EventPerson.for_user(
registered_speaker, dummy_event),
is_speaker=True,
author_type=AuthorType.primary)
])
unregistered_speaker_registered_author_contribution = create_contribution(
dummy_event,
'Unregistered Speaker, Registered Author',
person_links=[
ContributionPersonLink(person=EventPerson.for_user(
unregistered_user, dummy_event),
is_speaker=True),
ContributionPersonLink(person=EventPerson.for_user(
registered_user, dummy_event),
author_type=AuthorType.primary)
])
registered_speaker_unregistered_author_contribution = create_contribution(
dummy_event,
'Registered Speaker, Unregistered Author',
person_links=[
ContributionPersonLink(person=EventPerson.for_user(
registered_user, dummy_event),
is_speaker=True),
ContributionPersonLink(person=EventPerson.for_user(
unregistered_user, dummy_event),
author_type=AuthorType.primary)
])
# Filter contributions with registered users
with app.test_request_context():
list_gen = ContributionListGenerator(dummy_event)
list_gen.list_config['filters'] = {'items': {'people': {'registered'}}}
result = list_gen.get_list_kwargs()
assert result['contribs'] == [
registered_speaker_contribution,
registered_speaker_author_contribution,
unregistered_speaker_registered_author_contribution,
registered_speaker_unregistered_author_contribution
]
# Filter contributions with registered speakers
list_gen.list_config['filters'] = {'items': {'speakers': {'registered'}}}
with app.test_request_context():
result = list_gen.get_list_kwargs()
assert result['contribs'] == [
registered_speaker_contribution,
registered_speaker_author_contribution,
registered_speaker_unregistered_author_contribution
]
# Filter contributions with unregistered speakers and registered users
list_gen.list_config['filters'] = {
'items': {
'speakers': {'not_registered'},
'people': {'registered'}
}
}
with app.test_request_context():
result = list_gen.get_list_kwargs()
assert result['contribs'] == [
unregistered_speaker_registered_author_contribution
]
def import_contributions_from_csv(event, f):
"""Import timetable contributions from a CSV file into an event."""
reader = csv.reader(f)
contributions = []
all_changes = defaultdict(list)
for num_row, row in enumerate(reader, 1):
try:
start_dt, duration, title, first_name, last_name, affiliation, email = row
except ValueError:
raise UserValueError(
_('Row {}: malformed CSV data - please check that the number of columns is correct'
).format(num_row))
try:
parsed_start_dt = event.tzinfo.localize(
dateutil.parser.parse(start_dt)) if start_dt else None
except ValueError:
raise UserValueError(
_("Row {}: can't parse date: \"{}\"").format(
num_row, start_dt))
try:
parsed_duration = timedelta(
minutes=int(duration)) if duration else None
except ValueError:
raise UserValueError(
_("Row {}: can't parse duration: {}").format(
num_row, duration))
if not title:
raise UserValueError(
_("Row {}: contribution title is required").format(num_row))
with track_time_changes() as changes:
contribution = create_contribution(
event, {
'start_dt': parsed_start_dt,
'duration': parsed_duration or timedelta(minutes=20),
'title': title
},
extend_parent=True)
contributions.append(contribution)
for key, val in changes[event].viewitems():
all_changes[key].append(val)
if not email:
continue
# set the information of the speaker
person = get_event_person(
event, {
'firstName': first_name,
'familyName': last_name,
'affiliation': affiliation,
'email': email
})
link = ContributionPersonLink(person=person, is_speaker=True)
link.populate_from_dict({
'first_name': first_name,
'last_name': last_name,
'affiliation': affiliation,
'email': email
})
contribution.person_links.append(link)
return contributions, all_changes
def test_dump_contribution(db, dummy_user, dummy_event, dummy_contribution,
create_entry, scheduled):
from .schemas import ContributionRecordSchema
person = EventPerson.create_from_user(dummy_user, dummy_event)
dummy_contribution.person_links.append(
ContributionPersonLink(person=person))
dummy_contribution.description = 'A dummy <strong>contribution</strong>'
extra = {}
if scheduled:
create_entry(dummy_contribution,
utc.localize(datetime(2020, 4, 20, 4, 20)))
extra = {
'start_dt': dummy_contribution.start_dt.isoformat(),
'end_dt': dummy_contribution.end_dt.isoformat(),
}
db.session.flush()
category_id = dummy_contribution.event.category_id
schema = ContributionRecordSchema(context={'schema': 'test-contribs'})
assert schema.dump(dummy_contribution) == {
'$schema':
'test-contribs',
'_access': {
'delete': ['IndicoAdmin'],
'owner': ['IndicoAdmin'],
'update': ['IndicoAdmin'],
},
'_data': {
'description': 'A dummy contribution',
'location': {
'address': '',
'room_name': '',
'venue_name': ''
},
'persons': [{
'name': 'Guinea Pig'
}],
'site': 'http://localhost',
'title': 'Dummy Contribution',
},
'category_id':
category_id,
'category_path': [
{
'id': 0,
'title': 'Home',
'url': '/'
},
{
'id': category_id,
'title': 'dummy',
'url': f'/category/{category_id}/'
},
],
'contribution_id':
dummy_contribution.id,
'duration':
20,
'event_id':
0,
'type':
'contribution',
'url':
f'http://localhost/event/0/contributions/{dummy_contribution.id}/',
**extra
}
def _checkParams(self, params):
RHContributionDisplayBase._checkParams(self, params)
self.author = (ContributionPersonLink.find_one(
ContributionPersonLink.author_type != AuthorType.none,
id=request.view_args['person_id'],
contribution=self.contrib))
