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)