def get_issues_overiew(db_user: User, app_url: str) -> dict:
"""
Returns dictionary with keywords 'user' and 'others', which got lists with dicts with infos
IMPORTANT: URL's are generated for the frontend!
:param db_user: User
:param app_url: current applications url
:return: dict
"""
if not db_user or db_user.nickname == nick_of_anonymous_user:
return {'user': [], 'other': []}
user.update_last_action(db_user)
if db_user.is_admin():
db_issues_other_users = DBDiscussionSession.query(Issue).filter(
Issue.author_uid != db_user.uid).all()
else:
db_issues_other_users = get_visible_issues_for_user_as_query(
db_user.uid).filter(Issue.author_uid != db_user.uid).all()
db_issues_of_user = DBDiscussionSession.query(Issue).filter_by(
author_uid=db_user.uid).order_by(Issue.uid.asc()).all()
return {
'user':
[__create_issue_dict(issue, app_url) for issue in db_issues_of_user],
'other': [
__create_issue_dict(issue, app_url)
for issue in db_issues_other_users
]
}
def test_update_last_action(self):
db_user = DBDiscussionSession.query(User).filter_by(
nickname=str('Tobias')).first()
last_action_old = db_user.last_action
user.update_last_action(db_user)
last_action_new = db_user.last_action
self.assertNotEqual(last_action_old, last_action_new)
def delete_notifications(uids_list, db_user, ui_locales,
application_url) -> dict:
"""
Simply deletes a specific notification
:param uids_list: List of message ids which should be deleted
:param db_user: User
:param ui_locales: Language of current users session
:param application_url: Url of the App
:return: Dictionary with info and/or error
"""
user_handler.update_last_action(db_user)
_tn = Translator(ui_locales)
for uid in uids_list:
# inbox
DBDiscussionSession.query(Message).filter(
Message.uid == uid, Message.to_author_uid == db_user.uid,
Message.is_inbox == True).delete()
# send
DBDiscussionSession.query(Message).filter(
Message.uid == uid, Message.from_author_uid == db_user.uid,
Message.is_inbox == False).delete()
transaction.commit()
prepared_dict = dict()
prepared_dict['unread_messages'] = count_of_new_notifications(db_user)
prepared_dict['total_in_messages'] = str(
len(get_box_for(db_user, ui_locales, application_url, True)))
prepared_dict['total_out_messages'] = str(
len(get_box_for(db_user, ui_locales, application_url, False)))
prepared_dict['success'] = _tn.get(_.messageDeleted)
return prepared_dict
def set_issue(db_user: User, info: str, long_info: str, title: str,
db_lang: Language, is_public: bool, is_read_only: bool) -> dict:
"""
Sets new issue, which will be a new discussion
:param db_user: User
:param info: Short information about the new issue
:param long_info: Long information about the new issue
:param title: Title of the new issue
:param db_lang: Language
:param is_public: Boolean
:param is_read_only: Boolean
:rtype: dict
:return: Collection with information about the new issue
"""
user.update_last_action(db_user)
DBDiscussionSession.add(
Issue(title=title,
info=info,
long_info=long_info,
author_uid=db_user.uid,
is_read_only=is_read_only,
is_private=not is_public,
lang_uid=db_lang.uid))
DBDiscussionSession.flush()
transaction.commit()
db_issue = DBDiscussionSession.query(Issue).filter(
Issue.title == title, Issue.info == info).first()
return {'issue': get_issue_dict_for(db_issue, 0, db_lang.ui_locales)}
def set_position(db_user: User, db_issue: Issue, statement_text: str) -> dict:
"""
Set new position for current discussion and returns collection with the next url for the discussion.
:param statement_text: The text of the new position statement.
:param db_issue: The issue which gets the new position
:param db_user: The user who sets the new position.
:rtype: dict
:return: Prepared collection with statement_uids of the new positions and next url or an error
"""
logger('StatementsHelper', statement_text)
user.update_last_action(db_user)
new_statement = insert_as_statement(statement_text, db_user, db_issue, is_start=True)
_um = UrlManager(db_issue.slug)
url = _um.get_url_for_statement_attitude(new_statement.uid)
add_rep, broke_limit = add_reputation_for(db_user, rep_reason_first_position)
if not add_rep:
add_rep, broke_limit = add_reputation_for(db_user, rep_reason_new_statement)
# send message if the user is now able to review
if broke_limit:
url += '#access-review'
return {
'status': 'success',
'url': 'url',
'statement_uids': [new_statement.uid],
'error': ''
}
def set_positions_premise(db_issue: Issue, db_user: User,
db_conclusion: Statement,
premisegroups: List[List[str]], supportive: bool,
history: str, mailer) -> dict:
"""
Set new premise for a given position and returns dictionary with url for the next step of the discussion
:param mailer:
:param history:
:param supportive:
:param premisegroups:
:param db_conclusion:
:param db_user:
:param db_issue:
:rtype: dict
:return: Prepared collection with statement_uids of the new premises and an url or an error
"""
user.update_last_action(db_user)
prepared_dict = __process_input_of_start_premises(premisegroups,
db_conclusion,
supportive, db_issue,
db_user)
if prepared_dict['error']:
return prepared_dict
__set_url_of_start_premises(prepared_dict, db_conclusion, supportive,
db_issue, db_user, history, mailer)
__add_reputation(db_user, db_issue, prepared_dict['url'], prepared_dict)
return prepared_dict
def set_arguments_premises(db_issue: Issue, db_user: User, db_argument: Argument, premisegroups: List[List[str]],
attack_type: Relations, history, mailer) -> dict:
"""
Set new premise for a given conclusion and returns dictionary with url for the next step of the discussion
:param db_issue:
:param db_user:
:param db_argument:
:param premisegroups:
:param attack_type:
:param history:
:param mailer:
:rtype: dict
:return: Prepared collection with statement_uids of the new premises and next url or an error
"""
# escaping will be done in QueryHelper().set_statement(...)
langs = {'default_locale_name': db_issue.lang, 'discussion_lang': db_issue.lang}
arg_infos = {
'arg_id': db_argument.uid,
'attack_type': attack_type,
'premisegroups': premisegroups,
'history': history
}
url, statement_uids, error = __process_input_premises_for_arguments_and_receive_url(langs, arg_infos, db_issue,
db_user, mailer)
user.update_last_action(db_user)
prepared_dict = {
'error': error,
'statement_uids': statement_uids
}
if url is None:
return prepared_dict
# add reputation
had_access = has_access_to_review_system(db_user)
rep_added = add_reputation_for(db_user, get_reason_by_action(ReputationReasons.first_new_argument))
if not rep_added:
add_reputation_for(db_user, get_reason_by_action(ReputationReasons.new_statement))
broke_limit = has_access_to_review_system(db_user) and not had_access
if broke_limit:
url += '#access-review'
prepared_dict['url'] = url
prepared_dict['url'] = url
LOG.debug("Returning %s", prepared_dict)
return prepared_dict
def test_update_last_action(self):
user.update_last_action(self.user_tobi)
self.assertFalse(user.update_last_action(self.user_tobi))
old_ts = arrow.get(2016, 5, 5)
self.user_tobi.last_action = old_ts
self.user_tobi.last_login = old_ts
DBDiscussionSession.add(self.user_tobi)
settings = self.user_tobi.settings
settings.should_hold_the_login(False)
DBDiscussionSession.add(settings)
transaction.commit()
self.assertTrue(user.update_last_action(self.user_tobi))
self.assertFalse(user.update_last_action(self.user_tobi))
def main_admin(request):
"""
View configuration for the content view. Only logged in user can reach this page.
:param request: current webservers request
:return: dictionary with title and project name as well as a value, weather the user is logged in
"""
LOG.debug("def")
db_user = request.validated['user']
should_log_out = user.update_last_action(request.validated['user'])
if should_log_out:
return user_logout(request, True)
ui_locales = get_language_from_cookie(request)
extras_dict = DictionaryHelper(
ui_locales).prepare_extras_dict_for_normal_page(
request.registry, request.application_url, request.path, db_user)
dashboard_elements = {
'entities': lib.get_overview(request.path),
'api_tokens': lib.get_application_tokens()
}
return {
'language': str(ui_locales),
'title': 'Admin' if db_user.is_admin() else '(B)admin',
'project': project_name,
'extras': extras_dict,
'dashboard': dashboard_elements,
'discussion': {
'broke_limit': False
}
}
def main_table(request):
"""
View configuration for the content view. Only logged in user can reach this page.
:param request: current webservers request
:return: dictionary with title and project name as well as a value, weather the user is logged in
"""
LOG.debug("def")
should_log_out = user.update_last_action(request.validated['user'])
if should_log_out:
return user_logout(request, True)
ui_locales = get_language_from_cookie(request)
extras_dict = DictionaryHelper(
ui_locales).prepare_extras_dict_for_normal_page(
request.registry, request.application_url, request.path,
request.validated['user'])
table_name = request.matchdict['table']
if not table_name.lower() in lib.table_mapper:
return exception_response(400)
table_dict = lib.get_table_dict(table_name, request.application_url)
return {
'language': str(ui_locales),
'title': 'Admin - ' + table_name,
'project': project_name,
'extras': extras_dict,
'table': table_dict,
'discussion': {
'broke_limit': False
}
}
def set_arguments_premises(db_issue: Issue, db_user: User,
db_argument: Argument,
premisegroups: List[List[str]],
attack_type: Relations, history, mailer) -> dict:
"""
Set new premise for a given conclusion and returns dictionary with url for the next step of the discussion
:param data: dict if requests came via the API
:rtype: dict
:return: Prepared collection with statement_uids of the new premises and next url or an error
"""
# escaping will be done in QueryHelper().set_statement(...)
langs = {
'default_locale_name': db_issue.lang,
'discussion_lang': db_issue.lang
}
arg_infos = {
'arg_id': db_argument.uid,
'attack_type': attack_type,
'premisegroups': premisegroups,
'history': history
}
url, statement_uids, error = __process_input_premises_for_arguments_and_receive_url(
langs, arg_infos, db_issue, db_user, mailer)
user.update_last_action(db_user)
prepared_dict = {'error': error, 'statement_uids': statement_uids}
if url == -1:
return prepared_dict
# add reputation
add_rep, broke_limit = add_reputation_for(db_user,
rep_reason_first_new_argument)
if not add_rep:
add_rep, broke_limit = add_reputation_for(db_user,
rep_reason_new_statement)
# send message if the user is now able to review
if broke_limit:
url += '#access-review'
prepared_dict['url'] = url
prepared_dict['url'] = url
logger('ArgumentsHelper', 'returning {}'.format(prepared_dict))
return prepared_dict
def preparation_for_view(request):
"""
Does some elementary things like: getting nickname, session id and history.
Additionally boolean, if the session is expired
:param request: Current request
:return: nickname, session_id, session_expired, history
"""
session_expired = user.update_last_action(request.validated['user'])
return request.authenticated_userid, session_expired
def read_notifications(uids_list, db_user) -> dict:
"""
Simply marks a notification as read
:param uids_list: List of message ids notification which should be marked as read
:param db_user: User
:return: Dictionary with info and/or error
"""
prepared_dict = dict()
user_handler.update_last_action(db_user)
for uid in uids_list:
DBDiscussionSession.query(Message).filter(
Message.uid == uid, Message.to_author_uid == db_user.uid,
Message.is_inbox == True).first().set_read(True)
transaction.commit()
prepared_dict['unread_messages'] = count_of_new_notifications(db_user)
prepared_dict['error'] = ''
return prepared_dict
def set_position(db_user: User, db_issue: Issue, statement_text: str) -> dict:
"""
Set new position for current discussion and returns collection with the next url for the discussion.
:param statement_text: The text of the new position statement.
:param db_issue: The issue which gets the new position
:param db_user: The user who sets the new position.
:rtype: dict
:return: Prepared collection with statement_uids of the new positions and next url or an error
"""
LOG.debug("%s", statement_text)
user.update_last_action(db_user)
new_statement: Statement = insert_as_statement(statement_text,
db_user,
db_issue,
is_start=True)
_um = UrlManager(db_issue.slug)
url = _um.get_url_for_statement_attitude(new_statement.uid)
rep_added = add_reputation_for(
db_user, get_reason_by_action(ReputationReasons.first_position))
had_access = has_access_to_review_system(db_user)
if not rep_added:
add_reputation_for(
db_user, get_reason_by_action(ReputationReasons.new_statement))
broke_limit = has_access_to_review_system(db_user) and not had_access
if broke_limit:
url += '#access-review'
return {
'status': 'success',
'url': url,
'statement_uids': [new_statement.uid],
'error': ''
}
def __call_from_discussion_step(request, f: Callable[[Any, Any, Any], Any]):
"""
Checks for an expired session, the authentication and calls f the users nickname.
On error an HTTPNotFound-Error is raised, otherwise the discussion dict is returned.
:param request: A pyramid request
:param f: A function with three arguments
:return: prepared collection for the discussion
"""
logger('Views', 'def')
session_expired = user.update_last_action(request.validated['user'])
if session_expired:
request.session.invalidate()
headers = forget(request)
location = request.application_url + 'discuss?session_expired=true',
return HTTPFound(location=location, headers=headers)
request_dict = prepare_request_dict(request)
prepared_discussion = f(request_dict)
if prepared_discussion:
__modify_discussion_url(prepared_discussion)
__modify_discussion_bubbles(prepared_discussion)
return prepared_discussion, request_dict
def test_update_last_action(self):
last_action_old = self.user_tobi.last_action
user.update_last_action(self.user_tobi)
last_action_new = self.user_tobi.last_action
self.assertNotEqual(last_action_old, last_action_new)
