def test_get_reputation_of(self):
count, has_all_rights = ReviewReputationHelper.get_reputation_of(
'Tobias')
self.assertTrue(count > 20)
self.assertTrue(has_all_rights)
count, has_all_rights = ReviewReputationHelper.get_reputation_of(
'Tobiass')
self.assertTrue(count == 0)
self.assertFalse(has_all_rights)
def __get_history_information(self):
"""
Returns some information of the history queue
:return:
"""
count, all_rights = get_reputation_of(self.db_user)
return {
'task_name':
self.translator.get(_.queueHistory),
'id':
key_history,
'url':
f'{self.application_url}/review/{key_history}',
'icon':
reputation_icons[key_history],
'task_count':
self.__get_review_count_for_history(True),
'is_allowed':
count >= reputation_borders[key_history] or all_rights,
'is_allowed_text':
self.translator.get(_.visitHistoryQueue),
'is_not_allowed_text':
self.translator.get(_.visitHistoryQueueLimitation).format(
str(reputation_borders[key_history])),
'last_reviews':
list()
}
def get_summary_of_today(db_user: User) -> dict:
"""
Returns summary of today's actions
:param nickname: User.nickname
:return: dict()
"""
if not db_user:
return {}
arg_votes, stat_votes = get_mark_count_of(db_user, True)
arg_clicks, stat_clicks = get_click_count_of(db_user, True)
reputation, tmp = get_reputation_of(db_user, True)
timestamp = arrow.utcnow().to('Europe/Berlin')
timestamp.format('DD.MM.')
ret_dict = {
'firstname': db_user.firstname,
'statements_posted': get_statement_count_of(db_user, True),
'edits_done': get_edit_count_of(db_user, True),
'discussion_arg_votes': arg_votes,
'discussion_stat_votes': stat_votes,
'discussion_arg_clicks': arg_clicks,
'discussion_stat_clicks': stat_clicks,
'statements_reported': get_reviews_of(db_user, True),
'reputation_collected': reputation
}
return ret_dict
def index(request):
"""
View configuration for the review index.
:param request: current request of the server
:return: dictionary with title and project name as well as a value, weather the user is logged in
"""
LOG.debug("Review Index: %s / %s", request.matchdict, request.params)
db_user = request.validated['user']
_tn = Translator(get_language_from_cookie(request))
adapter = QueueAdapter(db_user=db_user,
main_page=request.application_url,
translator=_tn)
review_dict = adapter.get_review_queues_as_lists()
count, all_rights = get_reputation_of(db_user)
prep_dict = main_dict(request, _tn.get(_.review))
prep_dict.update({
'review': review_dict,
'privilege_list': get_privilege_list(_tn),
'reputation_list': get_reputation_reasons_list(_tn),
'reputation': {
'count': count,
'has_all_rights': all_rights
}
})
return prep_dict
def get_complete_review_count(db_user: User) -> int:
"""
Sums up the review points of the user
:param db_user: User
:return: int
"""
count, all_rights = get_reputation_of(db_user)
rights1 = count >= reputation_borders[key_deletes] or all_rights
rights2 = count >= reputation_borders[key_optimizations] or all_rights
rights3 = count >= reputation_borders[key_edits] or all_rights
rights4 = count >= reputation_borders[key_duplicates] or all_rights
rights5 = count >= reputation_borders[key_split] or all_rights
rights6 = count >= reputation_borders[key_merge] or all_rights
count = [
__get_review_count_for(ReviewDelete, LastReviewerDelete, db_user)
if rights1 else 0,
__get_review_count_for(ReviewOptimization, LastReviewerOptimization,
db_user) if rights2 else 0,
__get_review_count_for(ReviewEdit, LastReviewerEdit, db_user)
if rights3 else 0,
__get_review_count_for(ReviewDuplicate, LastReviewerDuplicate, db_user)
if rights4 else 0,
__get_review_count_for(ReviewSplit, LastReviewerSplit, db_user)
if rights5 else 0,
__get_review_count_for(ReviewMerge, LastReviewerMerge, db_user)
if rights6 else 0,
]
return sum(count)
def main_review(request):
"""
View configuration for the review index.
:param request: current request of the server
:return: dictionary with title and project name as well as a value, weather the user is logged in
"""
logger('main_review', 'def {}'.format(request.matchdict))
nickname = request.authenticated_userid
_tn = Translator(get_language_from_cookie(request))
review_dict = review_queue_helper.get_review_queues_as_lists(
request.application_url, _tn, nickname)
count, all_rights = review_reputation_helper.get_reputation_of(nickname)
prep_dict = __main_dict(request, _tn.get(_.review))
prep_dict.update({
'review':
review_dict,
'privilege_list':
review_reputation_helper.get_privilege_list(_tn),
'reputation_list':
review_reputation_helper.get_reputation_list(_tn),
'reputation': {
'count': count,
'has_all_rights': all_rights
}
})
return prep_dict
def __has_access_to_history(db_user):
"""
Does the user has access to the history?
:param nickname: User.nickname
:return: Boolean
"""
reputation_count, is_user_author = get_reputation_of(db_user)
return is_user_author or reputation_count > reputation_borders['history']
def __has_access_to_history(db_user):
"""
Does the user has access to the history?
:param db_user: User
:return: Boolean
"""
reputation_count, is_user_author = get_reputation_of(db_user)
rights = db_user.is_admin() or db_user.is_author()
points = reputation_count > reputation_borders['history']
return rights or points
def __has_access_to_history(db_user, is_executed: bool) -> bool:
"""
Does the user has access to the history?
:param db_user: User
:return: Boolean
"""
reputation_count, is_user_author = get_reputation_of(db_user)
rights = db_user.is_admin() or db_user.is_author()
queue_key = key_history if is_executed else key_ongoing
points = reputation_count > reputation_borders[queue_key]
return rights or points
def get_complete_review_count(db_user: User) -> int:
"""
Sums up the review points of the user
:param db_user: User
:return: int
"""
user_rep, all_rights = get_reputation_of(db_user)
count = 0
mapping = get_review_modal_mapping()
for key in mapping:
if user_rep >= reputation_borders[key] or all_rights:
last_reviewer = get_last_reviewer_by_key(key)
count += get_review_count_for(mapping[key], last_reviewer, db_user)
return count
def get_information_of(db_user: User, lang):
"""
Returns public information of the given user
:param db_user: User
:param lang: ui_locales
:return: dict()
"""
if db_user.nickname == nick_of_anonymous_user:
return __get_special_infos(lang)
db_group = DBDiscussionSession.query(Group).get(db_user.group_uid)
ret_dict = dict()
ret_dict['public_nick'] = db_user.global_nickname
ret_dict['last_action'] = sql_timestamp_pretty_print(
db_user.last_action, lang)
ret_dict['last_login'] = sql_timestamp_pretty_print(
db_user.last_login, lang)
ret_dict['registered'] = sql_timestamp_pretty_print(
db_user.registered, lang)
ret_dict['group'] = start_with_capital(db_group.name)
ret_dict['is_male'] = db_user.gender == 'm'
ret_dict['is_female'] = db_user.gender == 'f'
ret_dict['is_neutral'] = db_user.gender != 'm' and db_user.gender != 'f'
arg_votes, stat_votes = get_mark_count_of(db_user, False)
db_reviews_duplicate = DBDiscussionSession.query(
ReviewDuplicate).filter_by(detector_uid=db_user.uid).all()
db_reviews_edit = DBDiscussionSession.query(ReviewEdit).filter_by(
detector_uid=db_user.uid).all()
db_reviews_delete = DBDiscussionSession.query(ReviewDelete).filter_by(
detector_uid=db_user.uid).all()
db_reviews_optimization = DBDiscussionSession.query(
ReviewOptimization).filter_by(detector_uid=db_user.uid).all()
db_reviews = db_reviews_duplicate + db_reviews_edit + db_reviews_delete + db_reviews_optimization
get_tv_dict = get_textversions(db_user, lang)
ret_dict['statements_posted'] = len(get_tv_dict.get('statements', []))
ret_dict['edits_done'] = len(get_tv_dict.get('edits', []))
ret_dict['reviews_proposed'] = len(db_reviews)
ret_dict['discussion_arg_votes'] = arg_votes
ret_dict['discussion_stat_votes'] = stat_votes
ret_dict['avatar_url'] = get_profile_picture(db_user, 120)
ret_dict['discussion_stat_rep'], trash = get_reputation_of(db_user)
return ret_dict
def get_information_of(user: User, lang: str) -> Dict[str, Any]:
"""
Returns public information of the given user.
:param user: User whose information is queried.
:param lang: Language-string representing language of the answer.
:return: A dictionary containing the public information.
"""
if user.nickname == nick_of_anonymous_user:
return _get_special_infos(lang)
ret_dict = dict()
ret_dict['public_nick'] = user.global_nickname
ret_dict['last_action'] = sql_timestamp_pretty_print(
user.last_action, lang)
ret_dict['last_login'] = sql_timestamp_pretty_print(user.last_login, lang)
ret_dict['registered'] = sql_timestamp_pretty_print(user.registered, lang)
ret_dict['group'] = start_with_capital(user.group.name)
ret_dict['is_male'] = user.gender == 'm'
ret_dict['is_female'] = user.gender == 'f'
ret_dict['is_neutral'] = user.gender != 'm' and user.gender != 'f'
arg_votes, stat_votes = get_mark_count_of(user, False)
db_reviews_duplicate = DBDiscussionSession.query(
ReviewDuplicate).filter_by(detector_uid=user.uid).all()
db_reviews_edit = DBDiscussionSession.query(ReviewEdit).filter_by(
detector_uid=user.uid).all()
db_reviews_delete = DBDiscussionSession.query(ReviewDelete).filter_by(
detector_uid=user.uid).all()
db_reviews_optimization = DBDiscussionSession.query(
ReviewOptimization).filter_by(detector_uid=user.uid).all()
db_reviews = db_reviews_duplicate + db_reviews_edit + db_reviews_delete + db_reviews_optimization
get_tv_dict = get_textversions(user, lang)
ret_dict['statements_posted'] = len(get_tv_dict.get('statements', []))
ret_dict['edits_done'] = len(get_tv_dict.get('edits', []))
ret_dict['reviews_proposed'] = len(db_reviews)
ret_dict['discussion_arg_votes'] = arg_votes
ret_dict['discussion_stat_votes'] = stat_votes
ret_dict['avatar_url'] = get_profile_picture(user, 120)
ret_dict['discussion_stat_rep'], _ = get_reputation_of(user)
return ret_dict
def valid_user_has_review_access(request):
"""
Given a user and a name for a queue, validates the access to our review system
:param request:
:return:
"""
db_user = request.validated.get('user')
queue = request.validated.get('queue')
if not db_user or not queue:
_tn = Translator(get_language_from_cookie(request))
add_error(request, 'Invalid user or queue', _tn.get(_.internalError))
return False
rep_count, all_rights = get_reputation_of(db_user)
if rep_count >= reputation_borders[queue] or all_rights:
return True
else:
_tn = Translator(get_language_from_cookie(request))
add_error(request, 'Invalid user rights', _tn.get(_.internalError))
return False
def get_review_queues_as_lists(main_page, translator, nickname):
"""
Prepares dictionary for the edit section.
:param main_page: URL
:param translator: Translator
:param nickname: Users nickname
:return: Array
"""
logger('ReviewQueues', 'main')
db_user = DBDiscussionSession.query(User).filter_by(
nickname=nickname).first()
if not db_user:
return None
count, all_rights = get_reputation_of(nickname)
review_list = list()
review_list.append(
__get_delete_dict(main_page, translator, db_user, count, all_rights))
review_list.append(
__get_optimization_dict(main_page, translator, db_user, count,
all_rights))
review_list.append(
__get_edit_dict(main_page, translator, db_user, count, all_rights))
review_list.append(
__get_duplicates_dict(main_page, translator, db_user, count,
all_rights))
review_list.append(
__get_split_dict(main_page, translator, db_user, count, all_rights))
review_list.append(
__get_merge_dict(main_page, translator, db_user, count, all_rights))
review_list.append(
__get_history_dict(main_page, translator, count, all_rights))
if db_user.is_author() or db_user.is_admin():
review_list.append(__get_ongoing_dict(main_page, translator))
return review_list
def get_reputation_history_of(nickname, translator):
"""
Returns the reputation history of an user
:param nickname: User.nickname
:param translator: Translator
:return: dict()
"""
db_user = DBDiscussionSession.query(User).filter_by(nickname=nickname).first()
if not db_user:
return dict()
ret_dict = dict()
count, all_rights = get_reputation_of(nickname)
ret_dict['count'] = count
ret_dict['all_rights'] = all_rights
db_reputation = DBDiscussionSession.query(ReputationHistory) \
.filter_by(reputator_uid=db_user.uid) \
.join(ReputationReason, ReputationReason.uid == ReputationHistory.reputation_uid) \
.order_by(ReputationHistory.uid.asc())\
.all()
rep_list = list()
for rep in db_reputation:
date = sql_timestamp_pretty_print(rep.timestamp, translator.get_lang(), humanize=False)
points_data = ('+' if rep.reputations.points > 0 else '') + str(rep.reputations.points)
points = rep.reputations.points
action = translator.get(rep.reputations.reason)
rep_list.append({'date': date,
'points_data': points_data,
'action': action,
'points': points})
ret_dict['history'] = list(reversed(rep_list))
return ret_dict
def __get_queue_information(self, queue_name: str):
"""
Returns some information of the current queue
:param queue_name: name of the queue
:return:
"""
last_reviewer = get_last_reviewer_by_key(queue_name)
table = get_review_model_by_key(queue_name)
task_count = get_review_count_for(table, last_reviewer, self.db_user)
count, all_rights = get_reputation_of(self.db_user)
visit_key_str = _.get_key_by_string('visit{}Queue'.format(
start_with_capital(queue_name)))
visit_limit_key_str = _.get_key_by_string(
'visit{}QueueLimitation'.format(start_with_capital(queue_name)))
return {
'task_name':
self.translator.get(get_title_by_key(queue_name)),
'id':
queue_name,
'url':
f'{self.application_url}/review/{queue_name}',
'icon':
reputation_icons[queue_name],
'task_count':
task_count,
'is_allowed':
count >= reputation_borders[queue_name] or all_rights,
'is_allowed_text':
self.translator.get(visit_key_str),
'is_not_allowed_text':
self.translator.get(visit_limit_key_str).format(
str(reputation_borders[queue_name])),
'last_reviews':
self.__get_last_reviewer_of(last_reviewer, self.application_url)
}
def prepare_extras_dict(self,
current_slug: str,
is_reportable: bool,
show_bar_icon: bool,
show_graph_icon: bool,
registry: Registry,
application_url: str,
path: str,
db_user: User,
broke_limit=False,
add_premise_container_style='display: none',
add_statement_container_style='display: none',
ongoing_discussion=True):
"""
Creates the extras.dict() with many options!
:param current_slug:
:param is_reportable: Same as discussion.bubbles.last.is_markable, but TAL has no last indicator
:param show_bar_icon: True, if the discussion space should show the graph icon
:param show_graph_icon: True, if the discussion space should show the barometer icon
:param registry: Pyramids registry
:param application_url: current app url
:param path: current path
:param db_user: User
:param broke_limit: Boolean
:param add_premise_container_style: style string, default 'display:none;'
:param add_statement_container_style: style string, default 'display:none;'
:param ongoing_discussion: Boolean
:return: dict()
"""
LOG.debug("Entering prepare_extras_dict")
is_user_from_ldap = False
is_logged_in = False
nickname = None
public_nickname = None
is_user_male = False
is_user_female = False
is_admin = False
is_special = False
if db_user:
is_user_from_ldap = db_user.validate_password(PW_FOR_LDAP_USER)
is_logged_in = True
nickname = db_user.nickname
public_nickname = db_user.public_nickname
is_user_male = db_user.gender == 'm'
is_user_female = db_user.gender == 'f'
is_admin = db_user.is_admin()
is_special = db_user.is_special()
if db_user.nickname == nick_of_anonymous_user:
db_user = None
is_logged_in = False
return_dict = dict()
return_dict['url'] = get_global_url()
return_dict['year'] = datetime.datetime.now().year
return_dict['restart_url'] = current_slug
return_dict['is_in_discussion'] = 'discuss' in path
return_dict['logged_in'] = is_logged_in
return_dict['nickname'] = nickname
return_dict['public_nickname'] = public_nickname
return_dict[
'add_premise_container_style'] = add_premise_container_style
return_dict[
'add_statement_container_style'] = add_statement_container_style
return_dict['users_avatar'] = get_profile_picture(db_user, 25)
return_dict['ongoing_discussion'] = ongoing_discussion
return_dict['slug'] = current_slug
return_dict['is_user_male'] = is_user_male
return_dict['is_user_female'] = is_user_female
return_dict['is_user_neutral'] = not return_dict[
'is_user_male'] and not return_dict['is_user_female']
return_dict['broke_limit'] = 'true' if broke_limit else 'false'
return_dict['use_with_ldap'] = is_user_from_ldap
return_dict['development_mode'] = is_development_mode(registry)
return_dict['is_development'] = registry.settings.get(
'mode', '') == 'development'
return_dict['is_production'] = registry.settings.get(
'mode', '') == 'production'
return_dict['review_count'] = get_complete_review_count(db_user)
return_dict['modern_bubbles'] = usage_of_modern_bubbles(registry)
return_dict['usage_of_matomo'] = usage_of_matomo(registry)
self.add_language_options_for_extra_dict(return_dict)
is_author, points = get_reputation_of(db_user)
is_author_bool = is_author or points > limit_to_open_issues
return_dict['is_reportable'] = is_reportable
return_dict['is_admin'] = is_admin
return_dict['is_special'] = is_special
return_dict['is_author'] = is_author_bool
return_dict['is_user'] = not (is_admin or is_author_bool or is_special)
return_dict['show_bar_icon'] = show_bar_icon
return_dict['show_graph_icon'] = show_graph_icon
return_dict['close_premise_container'] = True
return_dict['close_statement_container'] = True
return_dict['date'] = arrow.utcnow().format('DD-MM-YYYY')
return_dict['count_of'] = {
'arguments': DBDiscussionSession.query(Argument).count(),
'users': DBDiscussionSession.query(User).count(),
'discussions': DBDiscussionSession.query(Issue).count(),
'reviews': get_count_of_all(),
}
self.__add_title_text(return_dict, is_logged_in)
self.__add_button_text(return_dict)
self.__add_tag_text(return_dict)
self.__add_login_button_properties(return_dict)
message_dict = dict()
message_dict['new_count'] = count_of_new_notifications(
db_user) if db_user else 0
message_dict['has_unread'] = message_dict['new_count'] > 0
inbox = get_box_for(db_user, self.system_lang, application_url,
True) if db_user else []
outbox = get_box_for(db_user, self.system_lang, application_url,
False) if db_user else []
message_dict['inbox'] = inbox
message_dict['outbox'] = outbox
message_dict['total_in'] = len(inbox)
message_dict['total_out'] = len(outbox)
return_dict['notifications'] = message_dict
return return_dict
def get_subpage_elements_for(nickname, session, application_url, subpage_name,
translator):
"""
Returns subpage for a specific review queue
:param nickname: current nickname in the request
:param session: current session in the request
:param application_url: current application_url in the request
:param subpage_name: String
:param translator: Translator
:return: dict()
"""
logger('ReviewSubpagerHelper', subpage_name)
db_user = DBDiscussionSession.query(User).filter_by(
nickname=nickname).first()
user_has_access = False
no_arguments_to_review = False
button_set = {
'is_delete': False,
'is_optimize': False,
'is_edit': False,
'is_duplicate': False,
'is_split': False,
'is_merge': False
}
# does the subpage exists
if subpage_name not in review_queues and subpage_name != 'history':
logger('ReviewSubpagerHelper', 'No page found', error=True)
return __get_subpage_dict(None, user_has_access,
no_arguments_to_review, button_set)
rep_count, all_rights = get_reputation_of(nickname)
user_has_access = rep_count >= reputation_borders[
subpage_name] or all_rights
# does the user exists and does he has the rights for this queue?
if not db_user or not user_has_access:
logger('ReviewSubpagerHelper', 'No user found', error=True)
return __get_subpage_dict(None, user_has_access,
no_arguments_to_review, button_set)
ret_dict = {'page_name': subpage_name}
text = translator.get(_.internalError)
issue = translator.get(_.internalError)
reason = ''
stats = ''
if subpage_name == 'deletes':
subpage_dict = __get_subpage_dict_for_deletes(session, application_url,
db_user, translator)
button_set['is_delete'] = True
elif subpage_name == 'optimizations':
subpage_dict = __get_subpage_dict_for_optimization(
session, application_url, db_user, translator)
button_set['is_optimize'] = True
elif subpage_name == 'edits':
subpage_dict = __get_subpage_dict_for_edits(session, application_url,
db_user, translator)
button_set['is_edit'] = True
elif subpage_name == 'duplicates':
subpage_dict = __get_subpage_dict_for_duplicates(
session, application_url, db_user, translator)
button_set['is_duplicate'] = True
elif subpage_name == 'splits':
subpage_dict = __get_subpage_dict_for_splits(session, application_url,
db_user, translator)
button_set['is_split'] = True
elif subpage_name == 'merges':
subpage_dict = __get_subpage_dict_for_merges(session, application_url,
db_user, translator)
button_set['is_merge'] = True
else:
subpage_dict = {
'stats': stats,
'text': text,
'reason': reason,
'issue': issue,
'session': {}
}
# logger('ReviewSubpagerHelper', 'get_subpage_elements_for', 'subpage_dict ' + str(subpage_dict))
ret_dict['reviewed_element'] = subpage_dict
ret_dict['session'] = subpage_dict['session']
if subpage_dict['text'] is None and subpage_dict[
'reason'] is None and subpage_dict['stats'] is None:
no_arguments_to_review = True
return __get_subpage_dict(None, user_has_access,
no_arguments_to_review, button_set)
return __get_subpage_dict(ret_dict, True, no_arguments_to_review,
button_set)
def prepare_settings_dict(self, pw_change_success, old_pw, new_pw,
confirm_pw, pw_change_error, message, db_user,
main_page, use_with_ldap):
"""
Prepares the dictionary for settings.ow
:param pw_change_success: Boolean
:param old_pw: String
:param new_pw: String
:param confirm_pw: String
:param pw_change_error: Boolean
:param message: String
:param db_user: User
:param main_page: String
:param use_with_ldap: Boolean
:return: dict()
"""
_tn = Translator(self.system_lang)
edits = user.get_edit_count_of(db_user, False)
statements = user.get_statement_count_of(db_user, False)
arg_vote, stat_vote = user.get_mark_count_of(db_user)
arg_clicks, stat_clicks = user.get_click_count_of(db_user)
public_nick = db_user.global_nickname
db_group = DBDiscussionSession.query(Group).get(db_user.group_uid)
db_settings = db_user.settings
db_language = DBDiscussionSession.query(Language).get(
db_settings.lang_uid)
group = db_group.name if db_group else '-'
gravatar_public_url = get_profile_picture(db_user, 80)
reputation, tmp = get_reputation_of(db_user)
return {
'passwordold': '' if pw_change_success else old_pw,
'password': '' if pw_change_success else new_pw,
'passwordconfirm': '' if pw_change_success else confirm_pw,
'pw_change_error': pw_change_error,
'pw_change_success': pw_change_success,
'message': message,
'db_firstname': db_user.firstname,
'db_surname': db_user.surname,
'db_nickname': db_user.nickname,
'db_public_nickname': public_nick,
'db_mail': db_user.email,
'has_mail': db_user.email != 'None',
'can_change_password': not use_with_ldap
and db_user.oauth_provider is None,
'db_group': group,
'avatar_public_url': gravatar_public_url,
'edits_done': edits,
'statements_posted': statements,
'discussion_arg_votes': arg_vote,
'discussion_stat_votes': stat_vote,
'discussion_arg_clicks': arg_clicks,
'discussion_stat_clicks': stat_clicks,
'send_mails': db_settings.should_send_mails,
'send_notifications': db_settings.should_send_notifications,
'public_nick': db_settings.should_show_public_nickname,
'title_mails': _tn.get(_.mailSettingsTitle),
'title_notifications': _tn.get(_.notificationSettingsTitle),
'title_public_nick': _tn.get(_.publicNickTitle),
'title_preferred_lang': _tn.get(_.preferredLangTitle),
'public_page_url': main_page + '/user/' + str(db_user.uid),
'on': _tn.get(_.on),
'off': _tn.get(_.off),
'current_lang': db_language.name,
'current_ui_locales': db_language.ui_locales,
'reputation': reputation
}
def test_get_reputation_of(self):
count, has_all_rights = get_reputation_of(self.user_tobi)
self.assertTrue(count > 20)
self.assertTrue(has_all_rights)
