def valid_issue_by_slug(request: Request) -> bool:
"""
Query issue by slug from the path.
:param request:
:return:
"""
if has_keywords_in_path(('slug', str))(request):
db_issue: Issue = DBDiscussionSession.query(Issue).filter(
Issue.slug == request.validated['slug']).one_or_none()
if db_issue:
if db_issue.is_disabled:
add_error(request,
'Issue no longer available',
location='path',
status_code=410)
return False
else:
request.validated['issue'] = db_issue
return True
add_error(request,
'Invalid slug \'{}\' for issue'.format(
request.validated['slug']),
location='path',
status_code=404)
return False
def __valid_id_from_location(request, entity_name, location='path') -> int:
"""
Find id in specified location.
:param request:
:param entity_name:
:param location:
:return:
"""
if location == 'path':
success = has_keywords_in_path((entity_name, int))(request)
return success
elif location == 'json_body':
if entity_name in request.json_body:
value = request.json_body.get(entity_name)
try:
request.validated[entity_name] = int(value)
return True
except ValueError:
add_error(request, '\'{}\' is not int parsable!'.format(value))
return False
else:
add_error(request,
'{} is missing in json_body'.format(entity_name))
return False
else:
raise KeyError("location has to be one of: ('path', 'json_body')")
def test_has_keywords_in_path():
request = construct_dummy_request()
fn = core.has_keywords_in_path(('foo', int))
response = fn(request)
assert type(response) == bool
assert response is False
request = construct_dummy_request(match_dict={'foo': 'bar'})
fn = core.has_keywords_in_path(('foo', int))
response = fn(request)
assert type(response) == bool
assert response is False
request = construct_dummy_request(match_dict={'foo': 2})
fn = core.has_keywords_in_path(('foo', int))
response = fn(request)
assert type(response) == bool
assert response is True
def valid_position(request):
"""
Check if given statement is a position and belongs to the queried issue.
:param request: Request
:return:
"""
if not valid_issue_by_slug(request):
return False
if has_keywords_in_path(('position_id', int))(request):
position_id = request.validated['position_id']
db_position: Statement = DBDiscussionSession.query(Statement).get(
position_id)
if not db_position:
add_error(request,
'Position with id {} not found'.format(position_id),
location='path')
return False
if db_position.is_disabled:
add_error(request,
'Position is disabled',
location='path',
status_code=410)
return False
if not db_position.is_position:
add_error(request,
'Queried statement is not a valid position',
location='path')
return False
db_statement2issues = DBDiscussionSession.query(
StatementToIssue).filter(
StatementToIssue.statement_uid == position_id,
StatementToIssue.issue_uid ==
request.validated['issue'].uid).first()
if not db_statement2issues:
add_error(request,
'Position does not belong to the queried issue',
location='path')
return False
request.validated['position']: Statement = db_position
return True
return False
def valid_reaction_arguments(request):
if not has_keywords_in_path(('arg_id_user', int),
('arg_id_sys', int))(request):
return False
if not valid_issue_by_slug(request):
return False
arg_id_user: int = request.validated['arg_id_user']
arg_id_sys: int = request.validated['arg_id_sys']
issue: Issue = request.validated['issue']
db_arg_user: Argument = __validate_enabled_entity(request, issue, Argument,
arg_id_user)
db_arg_sys: Argument = __validate_enabled_entity(request, issue, Argument,
arg_id_sys)
if not db_arg_sys or not db_arg_user:
return False
request.validated['arg_user'] = db_arg_user
request.validated['arg_sys'] = db_arg_sys
return True
def valid_attitude(request):
"""
Check if given statement is a position and belongs to the queried issue.
:param request: Request
:return:
"""
attitudes = [
attitude.value for attitude in Attitudes
if attitude is not Attitudes.DONT_KNOW
]
if has_keywords_in_path(('attitude', str))(request):
attitude = request.validated['attitude']
if attitude not in attitudes:
add_error(
request,
'Your attitude is not correct. Received \'{}\', expected one of {}'
.format(attitude, attitudes),
location='path')
return False
request.validated['attitude'] = attitude_mapper[attitude]
return True
return False
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.finish(db_issue, db_user,
request.validated['argument'],
history)
return {'bubbles': extract_items_and_bubbles(prepared_discussion)[0]}
# =============================================================================
# REFERENCES - Get references from database
# =============================================================================
@references.get()
@validate(has_keywords_in_path(('host', str), ('path', str),
location="params"))
def get_references(request: Request):
"""
Query database to get stored references from site. Generate a list with text versions of references.
:param request: request
:return: References assigned to the queried URL
"""
host = request.validated["host"]
path = request.validated["path"]
LOG.debug("Querying references for host: {}, path: {}".format(host, path))
refs_db: List[StatementReference] = DBDiscussionSession.query(
StatementReference).filter_by(host=host, path=path).all()
return {"references": [DataReference(ref) for ref in refs_db]}
db_user)
prepared_discussion['extras'] = dh.prepare_extras_dict_for_normal_page(
request.registry, request.application_url, request.path, db_user)
prepared_discussion['language'] = str(get_language_from_cookie(request))
prepared_discussion['show_summary'] = len(
prepared_discussion['summary']) != 0
prepared_discussion['discussion'] = {'broke_limit': False}
return prepared_discussion
@view_config(route_name='discussion_choose',
renderer='../../templates/discussion/main.pt',
permission='everybody')
@validate(check_authentication, valid_user_optional, valid_issue_by_slug,
valid_premisegroup_in_path, valid_list_of_premisegroups_in_path,
has_keywords_in_path(('is_argument', bool), ('is_supportive', bool)))
def choose(request):
"""
View configuration for discussion step, where the user has to choose between given statements.
:param request: request of the web server
:return: dictionary
"""
# '/discuss/{slug}/choose/{is_argument}/{supportive}/{id}*pgroup_ids'
LOG.debug("Choose a statement. %s", request.matchdict)
emit_participation(request)
db_user: User = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
def test_provided_string_expected_string_should_succeed(self):
request = construct_dummy_request(matchdict={'foo': 2})
fn = core.has_keywords_in_path(('foo', int))
response = fn(request)
self.assertIsInstance(response, bool)
self.assertTrue(response)
def test_empty_dummy_request(self):
request = construct_dummy_request(json_body={})
fn = core.has_keywords_in_path(('foo', int))
response = fn(request)
self.assertIsInstance(response, bool)
self.assertFalse(response)