def _process(self):
if self.editable:
raise UserValueError(_('Editable already exists'))
args = parser.parse({
'files':
EditingFilesField(self.event,
self.contrib,
self.editable_type,
required=True)
})
service_url = editing_settings.get(self.event, 'service_url')
initial_state = InitialRevisionState.new if service_url else InitialRevisionState.ready_for_review
editable = create_new_editable(self.contrib, self.editable_type,
session.user, args['files'],
initial_state)
if service_url:
try:
service_handle_new_editable(editable, session.user)
except ServiceRequestFailed:
raise ServiceUnavailable(
_('Submission failed, please try again later.'))
return '', 201
def _process(self, action, comment):
argmap = {'tags': EditingTagsField(self.event, missing=set())}
if action in (EditingReviewAction.update,
EditingReviewAction.update_accept):
argmap['files'] = EditingFilesField(self.event,
self.contrib,
self.editable_type,
allow_claimed_files=True,
required=True)
args = parser.parse(argmap, unknown=EXCLUDE)
service_url = editing_settings.get(self.event, 'service_url')
new_revision = review_editable_revision(self.revision, session.user,
action, comment, args['tags'],
args.get('files'))
publish = True
if service_url:
try:
resp = service_handle_review_editable(self.editable,
session.user, action,
self.revision,
new_revision)
publish = resp.get('publish', True)
except ServiceRequestFailed:
raise ServiceUnavailable(
_('Failed processing review, please try again later.'))
if publish and action in (EditingReviewAction.accept,
EditingReviewAction.update_accept):
publish_editable_revision(new_revision or self.revision)
return '', 204
def _parse_review_args(event, review_type):
args_schema = {
'proposed_action': EnumField(PaperAction, required=True),
'comment': fields.String(missing='')
}
for question in event.cfp.get_questions_for_review_type(review_type):
attrs = {}
if question.is_required:
attrs['required'] = True
else:
attrs['missing'] = None
if question.field_type == 'rating':
field_cls = fields.Integer
elif question.field_type == 'text':
validators = []
if question.field_data['max_length']:
validators.append(validate.Length(max=question.field_data['max_length']))
if question.field_data['max_words']:
validators.append(max_words(question.field_data['max_words']))
attrs['validate'] = validators
field_cls = fields.String
elif question.field_type == 'bool':
field_cls = fields.Bool
else:
raise Exception('Invalid question field type: {}'.format(question.field_type))
args_schema['question_{}'.format(question.id)] = field_cls(**attrs)
data = parser.parse(args_schema)
questions_data = {k: v for k, v in data.iteritems() if k.startswith('question_')}
review_data = {k: v for k, v in data.iteritems() if not k.startswith('question_')}
return questions_data, review_data
def _process(self):
args = parser.parse({
'files': EditingFilesField(self.event, self.contrib, allow_claimed_files=True, required=True)
})
create_submitter_revision(self.revision, session.user, args['files'])
return '', 204
def _process_args(self):
RHManageEventBase._process_args(self)
args = parser.parse({
'values': PrincipalDict(allow_groups=True, allow_external_users=True, allow_event_roles=True,
allow_category_roles=True, event_id=self.event.id, missing={})
})
self.values = args['values']
def _process(self, comment):
args = parser.parse({
'files': EditingFilesField(self.event, self.contrib, allow_claimed_files=True, required=True)
})
replace_revision(self.revision, session.user, comment, args['files'])
return '', 204
def _process(self, action, comment):
argmap = {'tags': EditingTagsField(self.event, missing=set())}
if action == EditingReviewAction.update:
argmap['files'] = EditingFilesField(self.event, self.contrib, allow_claimed_files=True, required=True)
args = parser.parse(argmap)
review_editable_revision(self.revision, session.user, action, comment, args['tags'], args.get('files'))
return '', 204
def _process_args(self):
RHEditingManagementBase._process_args(self)
self.editable_type = EditableType[request.view_args['type']]
self.editables = parser.parse({
'editables': EditableList(required=True, event=self.event, editable_type=self.editable_type,
validate=not_empty)
})['editables']
def _process_POST(self):
if not self._can_register():
raise ExpectedError(_('You cannot register for this event'))
schema = make_registration_schema(self.regform)()
form_data = parser.parse(schema)
registration = create_registration(self.regform, form_data, self.invitation)
return jsonify({'redirect': url_for('.display_regform', registration.locator.registrant)})
def _process(self, comment, state):
args = parser.parse({
'tags': EditingTagsField(self.event, allow_system_tags=self.is_service_call, missing=set()),
'files': EditingFilesField(self.event, self.contrib, self.editable_type, allow_claimed_files=True,
required=True)
})
user = User.get_system_user() if self.is_service_call else session.user
replace_revision(self.revision, user, comment, args['files'], args['tags'], state)
return '', 204
def _process(self):
if self.editable:
raise UserValueError(_('Editable already exists'))
args = parser.parse({
'files': EditingFilesField(self.event, self.contrib, required=True)
})
create_new_editable(self.contrib, self.editable_type, session.user, args['files'])
return '', 201
def _process_POST(self):
optional_fields = self._get_optional_fields()
schema = make_registration_schema(
self.regform, management=self.management, registration=self.registration
)(partial=optional_fields)
form_data = parser.parse(schema)
notify_user = not self.management or form_data.pop('notify_user', False)
if self.management:
session['registration_notify_user_default'] = notify_user
modify_registration(self.registration, form_data, management=self.management, notify_user=notify_user)
return jsonify({'redirect': self.success_url})
def _process_POST(self, accept, reason):
move_requests = parser.parse(
{
'requests':
EventRequestList(
required=True, category=self.category, validate=not_empty)
},
unknown=EXCLUDE)['requests']
for rq in move_requests:
update_event_move_request(rq, accept, reason)
notify_move_request_closure(move_requests, accept, reason)
return '', 204
def _process_POST(self):
if self.regform.is_purged:
raise Forbidden(
_('Registration is disabled due to an expired retention period'
))
schema = make_registration_schema(self.regform, management=True)()
form = parser.parse(schema)
session['registration_notify_user_default'] = notify_user = form.pop(
'notify_user', False)
create_registration(self.regform,
form,
management=True,
notify_user=notify_user)
flash(_('The registration was created.'), 'success')
return jsonify({'redirect': url_for('.manage_reglist', self.regform)})
def _process(self):
args = parser.parse({
'files': EditingFilesField(self.event, self.contrib, self.editable_type, allow_claimed_files=True,
required=True)
})
service_url = editing_settings.get(self.event, 'service_url')
new_revision = create_submitter_revision(self.revision, session.user, args['files'])
if service_url:
try:
service_handle_review_editable(self.editable, session.user, EditingReviewAction.update,
self.revision, new_revision)
except ServiceRequestFailed:
raise ServiceUnavailable(_('Failed processing review, please try again later.'))
return '', 204
