def __get_bubble_from_support_step(arg_uid_user: int, uid_system: int, db_user: User, lang: str) \ -> Optional[List[list]]: """ Creates bubbles for the support-keyword for an statement. :param arg_uid_user: User.uid :param uid_system: Argument.uid :param db_user: User :param lang: Language.ui_locales :return: [dict()] """ db_arg_user = DBDiscussionSession.query(Argument).get(arg_uid_user) db_arg_system = DBDiscussionSession.query(Argument).get(uid_system) if not db_arg_user or not db_arg_system: return None user_text = get_text_for_argument_uid(arg_uid_user) bubble_user = create_speechbubble_dict(BubbleTypes.USER, content=user_text, omit_bubble_url=True, argument_uid=arg_uid_user, is_supportive=db_arg_user.is_supportive, db_user=db_user, lang=lang) argument_text = get_text_for_argument_uid(uid_system, colored_position=True, with_html_tag=True, attack_type='jump') offset = len('</' + tag_type + '>') if argument_text.endswith('</' + tag_type + '>') else 1 while argument_text[:-offset].endswith(('.', '?', '!')): argument_text = argument_text[:-offset - 1] + argument_text[-offset:] text = get_text_for_support(db_arg_system, argument_text, db_user.nickname, Translator(lang)) db_other_author = DBDiscussionSession.query(User).get(db_arg_system.author_uid) bubble_system = create_speechbubble_dict(BubbleTypes.SYSTEM, content=text, omit_bubble_url=True, lang=lang, other_author=db_other_author) return [bubble_user, bubble_system]
def get_dict_for_supporting_each_other(self, uid_system_arg, uid_user_arg, nickname) -> dict: """ Returns the dictionary during the supporting step :param uid_system_arg: Argument.uid :param uid_user_arg: Argument.uid :param nickname: User.nickname :return: dict() """ logger('DictionaryHelper', str(uid_system_arg)) _tn = Translator(self.lang) bubbles_array = history_helper.create_bubbles_from_history( self.history, nickname, self.lang, self.slug) db_arg_system = DBDiscussionSession.query(Argument).get(uid_system_arg) db_arg_user = DBDiscussionSession.query(Argument).get(uid_user_arg) argument_text = get_text_for_argument_uid(uid_system_arg, colored_position=True, with_html_tag=True, attack_type='jump') offset = len('</' + tag_type + '>') if argument_text.endswith('</' + tag_type + '>') else 1 while argument_text[:-offset].endswith(('.', '?', '!')): argument_text = argument_text[:-offset - 1] + argument_text[-offset:] sys_text = get_text_for_support(db_arg_system, argument_text, nickname, _tn) self.__append_now_bubble(bubbles_array) user_text = get_text_for_argument_uid(uid_user_arg, nickname=nickname) bubble_user = create_speechbubble_dict( BubbleTypes.USER, content=user_text, omit_bubble_url=True, argument_uid=uid_user_arg, is_supportive=db_arg_user.is_supportive, lang=self.lang, nickname=nickname) bubbles_array.append(bubble_user) bubble = create_speechbubble_dict( BubbleTypes.SYSTEM, uid='question-bubble-{}'.format(uid_system_arg), content=sys_text, omit_bubble_url=True, lang=self.lang) bubbles_array.append(bubble) return { 'bubbles': bubbles_array, 'add_premise_text': '', 'save_statement_url': '', 'mode': '', 'broke_limit': self.broke_limit }
def get_user_with_same_opinion_for_argument(argument_uid, db_user, lang, main_page): """ Returns nested dictionary with all kinds of information about the votes of the argument. :param argument_uid: Argument.uid :param db_user: User :param lang: language :param main_page: url :return: {'users':[{nickname1.avatar_url, nickname1.vote_timestamp}*]} """ try: text = get_text_for_argument_uid(argument_uid, 'de') LOG.debug("Argument %s: %s", argument_uid, text) if not text: return {'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None} except TypeError: return {'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None} opinions = dict() all_users = [] _t = Translator(lang) text = get_text_for_argument_uid(argument_uid, lang) title = _t.get(_.reactionFor) + ': ' + start_with_capital(text) db_argument = DBDiscussionSession.query(Argument).get(argument_uid) if not db_argument: opinions = {'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None} opinions['uid'] = str(argument_uid) text = get_text_for_argument_uid(argument_uid, lang) opinions['text'] = start_with_capital(text) db_clicks = DBDiscussionSession.query(ClickedArgument).filter(ClickedArgument.argument_uid == argument_uid, ClickedArgument.is_up_vote == True, ClickedArgument.is_valid == True, ClickedArgument.author_uid != db_user.uid).all() for vote in db_clicks: voted_user = DBDiscussionSession.query(User).get(vote.author_uid) users_dict = create_users_dict(voted_user, vote.timestamp, main_page, lang) all_users.append(users_dict) opinions['users'] = all_users opinions['message'] = __get_text_for_clickcount(len(db_clicks), db_user.uid, _t) db_seen_by = DBDiscussionSession.query(SeenArgument).filter_by(argument_uid=int(argument_uid)).all() opinions['seen_by'] = len(db_seen_by) if db_seen_by else 0 return {'opinions': opinions, 'title': start_with_capital(title)}
def __get_base_subpage_dict(review_type, db_reviews, already_seen, first_time, db_user, already_reviewed): extra_info = '' if not db_reviews: already_seen = list() extra_info = 'already_seen' if not first_time else '' db_reviews = DBDiscussionSession.query(review_type).filter( review_type.is_executed == False, review_type.detector_uid != db_user.uid) if len(already_reviewed) > 0: db_reviews = db_reviews.filter( ~review_type.uid.in_(already_reviewed)) db_reviews = db_reviews.all() if not db_reviews: return None, None, None, None, None rnd_review = db_reviews[random.randint(0, len(db_reviews) - 1)] if rnd_review.statement_uid is None: db_argument = DBDiscussionSession.query(Argument).get( rnd_review.argument_uid) text = get_text_for_argument_uid(db_argument.uid) issue = DBDiscussionSession.query(Issue).get( db_argument.issue_uid).title else: db_statement = DBDiscussionSession.query(Statement).get( rnd_review.statement_uid) text = db_statement.get_text() issue = DBDiscussionSession.query(Issue).get( db_statement.issue_uid).title return rnd_review, already_seen, extra_info, text, issue
def __get_bubble_from_dont_know_step(step: str, db_user: User, lang: str) -> List[dict]: """ Creates bubbles for the don't-know-reaction for a statement. :param step: String :param db_user: User :param lang: ui_locales :return: [dict()] """ steps = step.split('/') uid = int(steps[1]) text = get_text_for_argument_uid(uid, rearrange_intro=True, attack_type='dont_know', with_html_tag=False, start_with_intro=True) db_argument = DBDiscussionSession.query(Argument).get(uid) if not db_argument: text = '' from dbas.strings.text_generator import get_name_link_of_arguments_author _tn = Translator(lang) data = get_name_link_of_arguments_author(db_argument, db_user.nickname, False) if data['is_valid']: intro = data['link'] + ' ' + _tn.get(_.thinksThat) else: intro = _tn.get(_.otherParticipantsThinkThat) sys_text = intro + ' ' + start_with_small(text) + '. ' sys_text += '<br><br>' + _tn.get(_.whatDoYouThinkAboutThat) + '?' sys_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM, content=sys_text, db_user=db_user, other_author=data['user']) text = _tn.get(_.showMeAnArgumentFor) + (' ' if lang == 'de' else ': ') + get_text_for_conclusion(db_argument) user_bubble = create_speechbubble_dict(BubbleTypes.USER, content=text, db_user=db_user) return [user_bubble, sys_bubble]
def get_dict_for_dont_know_reaction(self, uid, nickname) -> dict: """ Prepares the discussion dict with all bubbles for the third step, where an supportive argument will be presented. :param uid: Argument.uid :param nickname: :return: dict() """ LOG.debug("Entering get_dict_for_dont_know_reaction") _tn = Translator(self.lang) bubbles_array = history_handler.create_bubbles(self.history, self.nickname, self.lang, self.slug) add_premise_text = '' save_statement_url = 'set_new_start_statement' gender = '' b = '<' + tag_type + '>' e = '</' + tag_type + '>' statement_list = list() if int(uid) != 0: text = get_text_for_argument_uid(uid, rearrange_intro=True, attack_type='dont_know', with_html_tag=True, start_with_intro=True) db_argument = DBDiscussionSession.query(Argument).get(uid) if not db_argument: text = '' data = get_name_link_of_arguments_author(db_argument, nickname) gender = data['gender'] if data['is_valid']: intro = data['link'] + ' ' + b + _tn.get(_.thinksThat) + e else: intro = b + _tn.get(_.otherParticipantsThinkThat) + e sys_text = intro + ' ' + start_with_small(text) + '. ' sys_text += '<br><br> ' + b + _tn.get( _.whatDoYouThinkAboutThat) + '?' + e bubble_sys = create_speechbubble_dict(BubbleTypes.SYSTEM, is_markable=True, uid=uid, content=sys_text, other_author=data['user']) if not bubbles_already_last_in_list(bubbles_array, bubble_sys): bubbles_array.append(bubble_sys) # add statements of discussion to report them statement_list = self.__get_all_statement_texts_by_argument( db_argument) return { 'bubbles': bubbles_array, 'add_premise_text': add_premise_text, 'save_statement_url': save_statement_url, 'mode': '', 'extras': statement_list, 'gender': gender, 'broke_limit': self.broke_limit }
def __get_dict_for_argumentation_end(self, argument_uid: int, user_changed_opinion: bool, db_user: User) -> dict: """ Returns a special dict() when the discussion ends during an argumentation :param argument_uid: Argument.uid :param user_changed_opinion: Boolean :param db_user: User :return: String, String, String """ nickname = db_user.nickname if db_user and db_user.nickname != nick_of_anonymous_user else None _tn = Translator(self.lang) text = get_text_for_argument_uid( argument_uid, user_changed_opinion=user_changed_opinion, minimize_on_undercut=True, nickname=nickname) user_text = start_with_capital(text) sys_text = _tn.get(_.otherParticipantsDontHaveCounterForThat) + '.' trophy = '<i class="fa fa-trophy" aria-hidden="true"></i>' mid_text = '{} {} {} <br>{}'.format( trophy, _tn.get(_.congratulation), trophy, _tn.get(_.discussionCongratulationEnd)) if nickname is not None: mid_text += _tn.get(_.discussionEndLinkTextWithQueueLoggedIn) else: mid_text += _tn.get(_.discussionEndLinkTextWithQueueNotLoggedIn) return {'user': user_text, 'mid': mid_text, 'sys': sys_text}
def get_marked_elements_of(db_user: User, is_argument: bool, lang: str): """ Get all marked arguments/statements of the user :param db_user: User :param is_argument: Boolean :param lang: uid_locales :return: [{},...] """ return_array = [] if is_argument: db_votes = DBDiscussionSession.query(MarkedArgument).filter_by(author_uid=db_user.uid).all() else: db_votes = DBDiscussionSession.query(MarkedStatement).filter_by(author_uid=db_user.uid).all() for vote in db_votes: vote_dict = dict() vote_dict['uid'] = str(vote.uid) vote_dict['timestamp'] = sql_timestamp_pretty_print(vote.timestamp, lang) if is_argument: vote_dict['argument_uid'] = str(vote.argument_uid) vote_dict['content'] = get_text_for_argument_uid(vote.argument_uid, lang) else: vote_dict['statement_uid'] = str(vote.statement_uid) vote_dict['content'] = get_text_for_statement_uid(vote.statement_uid) return_array.append(vote_dict) return return_array
def get_dict_for_jump(self, uid) -> dict: """ Prepares the discussion dict with all bubbles for the jump step :param uid: Argument.uid :return: dict() """ logger('DictionaryHelper', 'argument ' + str(uid)) _tn = Translator(self.lang) argument_text = get_text_for_argument_uid(uid, colored_position=True, with_html_tag=True, attack_type='jump') bubbles_array = history_helper.create_bubbles_from_history( self.history, self.nickname, self.lang, self.slug) coming_from_jump = False if self.history: splitted_history = self.history.split('-') coming_from_jump = '/jump' in self.history[:-1] if len( splitted_history) > 0 else False intro = (_tn.get(_.canYouBeMorePrecise) + '<br><br>') if coming_from_jump else '' db_argument = DBDiscussionSession.query(Argument).get(uid) if db_argument.conclusion_uid is not None: intro += _tn.get(_.whatDoYouThinkArgument).strip() + ': ' else: bind = ', ' if self.lang == 'de' else ' ' intro += _tn.get(_.whatDoYouThinkAboutThat) + bind + _tn.get( _.that) + ' ' offset = len('</' + tag_type + '>') if argument_text.endswith('</' + tag_type + '>') else 1 while argument_text[:-offset].endswith(('.', '?', '!')): argument_text = argument_text[:-offset - 1] + argument_text[-offset:] text = intro + argument_text + '?' bubble = create_speechbubble_dict(BubbleTypes.SYSTEM, content=text, omit_bubble_url=True, lang=self.lang, uid='question-bubble-{}'.format(uid), is_markable=True) bubbles_array.append(bubble) # add statements of discussion to report them statement_list = self.__get_all_statement_texts_by_argument( db_argument) return { 'bubbles': bubbles_array, 'add_premise_text': '', 'save_statement_url': '', 'mode': '', 'extras': statement_list, 'broke_limit': self.broke_limit }
def get_clicked_elements_of(db_user: User, is_argument: bool, lang: str) -> list: """ Returns array with all clicked elements by the user. Each element is a dict with information like the uid, timestamp, up_Vote, validity, the clicked uid and content of the clicked element. :param db_user: User :param is_argument: Boolean :param lang: ui_locales :return: [{},...] """ return_array = [] db_type = ClickedArgument if is_argument else ClickedStatement db_clicks = DBDiscussionSession.query(db_type).filter_by(author_uid=db_user.uid).all() for click in db_clicks: click_dict = dict() click_dict['uid'] = click.uid click_dict['timestamp'] = sql_timestamp_pretty_print(click.timestamp, lang) click_dict['is_up_vote'] = click.is_up_vote click_dict['is_valid'] = click.is_valid if is_argument: click_dict['argument_uid'] = click.argument_uid click_dict['content'] = get_text_for_argument_uid(click.argument_uid, lang) else: click_dict['statement_uid'] = click.statement_uid click_dict['content'] = get_text_for_statement_uid(click.statement_uid) return_array.append(click_dict) return return_array
def get_text_for_argument(request): statement = int(request.matchdict["statement_uid"]) args = get_all_arguments_by_statement(statement) return list( map( lambda arg: { "uid": arg.uid, "text": get_text_for_argument_uid(arg.uid) }, args))
def get_dict_for_choosing(self, uid, is_uid_argument, is_supportive) -> dict: """ Prepares the discussion dict with all bubbles for the choosing an premise, when the user inserted more than one new premise. :param uid: Argument.uid :param is_uid_argument: Boolean :param is_supportive: Boolean :return: """ _tn = Translator(self.lang) bubbles_array = history_handler.create_bubbles(self.history, self.nickname, self.lang, self.slug) add_premise_text = '' save_statement_url = 'set_new_start_statement' LOG.debug("Choosing dictionary for bubbles.") a = _tn.get(_.soYouEnteredMultipleReasons) if is_uid_argument: c = get_text_for_argument_uid(uid) else: statement = DBDiscussionSession.query(Statement).get(uid) c = statement.get_text() if is_supportive: if is_uid_argument: b = _tn.get(_.whatIsYourMostImportantReasonForArgument) else: b = _tn.get(_.whatIsYourMostImportantReasonForStatement) else: if is_uid_argument: b = _tn.get(_.whatIsYourMostImportantReasonAgainstArgument) else: b = _tn.get(_.whatIsYourMostImportantReasonAgainstStatement) b = b.replace('{}', '') text = '{}. {}: {}?<br>{}...'.format(a, b, c, _tn.get(_.because)) self.__append_now_bubble(bubbles_array) question_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM, uid='question-bubble', content=text, omit_bubble_url=True, lang=self.lang) if not bubbles_already_last_in_list(bubbles_array, question_bubble): bubbles_array.append(question_bubble) return { 'bubbles': bubbles_array, 'add_premise_text': add_premise_text, 'save_statement_url': save_statement_url, 'mode': '', 'broke_limit': self.broke_limit }
def get_base_subpage_dict(review_type, db_reviews, already_seen, first_time, db_user, already_reviewed): """ :param review_type: :param db_reviews: :param already_seen: :param first_time: :param db_user: :param already_reviewed: :return: """ extra_info = '' if not db_reviews: already_seen = list() extra_info = 'already_seen' if not first_time else '' db_reviews = DBDiscussionSession.query(review_type).filter( review_type.is_executed == False, review_type.detector_uid != db_user.uid) if len(already_reviewed) > 0: db_reviews = db_reviews.filter( ~review_type.uid.in_(already_reviewed)) db_reviews = db_reviews.all() if not db_reviews: return { 'rnd_review': None, 'already_seen_reviews': None, 'extra_info': None, 'text': None, 'issue_titles': None, } rnd_review = random.choice(db_reviews) if rnd_review.statement_uid is None: db_argument = DBDiscussionSession.query(Argument).get( rnd_review.argument_uid) text = get_text_for_argument_uid(db_argument.uid) issue_titles = [ DBDiscussionSession.query(Issue).get(db_argument.issue_uid).title ] else: db_statement = DBDiscussionSession.query(Statement).get( rnd_review.statement_uid) text = db_statement.get_text() issue_titles = [ issue.title for issue in get_issues_for_statement_uids( [rnd_review.statement_uid]) ] return { 'rnd_review': rnd_review, 'already_seen_reviews': already_seen, 'extra_info': extra_info, 'text': text, 'issue_titles': issue_titles }
def get_text_of_element(self, db_review: ReviewDelete) -> str: """ Returns full text of the given element :param db_review: current review element :return: """ if db_review.statement_uid is None: return get_text_for_argument_uid(db_review.argument_uid) else: return DBDiscussionSession.query(Statement).get(db_review.statement_uid).get_text()
def get_all_infos_about_argument(db_argument: Argument, main_page, db_user, lang) -> dict: """ Returns bunch of information about the given argument :param db_argument: The argument :param main_page: url of the application :param db_user: User :param lang: Language :rtype: dict :return: dictionary with many information or an error """ _t = Translator(lang.ui_locales) return_dict = dict() db_votes = DBDiscussionSession.query(ClickedArgument).filter( ClickedArgument.argument_uid == db_argument.uid, ClickedArgument.is_valid == True, ClickedStatement.is_up_vote == True).all() db_author = DBDiscussionSession.query(User).get(db_argument.author_uid) return_dict['vote_count'] = str(len(db_votes)) return_dict['author'] = db_author.global_nickname return_dict['author_url'] = main_page + '/user/' + str(db_author.uid) return_dict['gravatar'] = get_profile_picture(db_author) return_dict['timestamp'] = sql_timestamp_pretty_print( db_argument.timestamp, db_argument.lang) text = get_text_for_argument_uid(db_argument.uid) return_dict['text'] = start_with_capital(text) supporters = [] gravatars = dict() public_page = dict() for vote in db_votes: db_author = DBDiscussionSession.query(User).get(vote.author_uid) name = db_author.global_nickname if db_user.nickname == db_author.nickname: name += ' (' + _t.get(_.itsYou) + ')' supporters.append(name) gravatars[name] = get_profile_picture(db_author) public_page[name] = main_page + '/user/' + str(db_author.uid) return_dict['supporter'] = supporters return_dict['gravatars'] = gravatars return_dict['public_page'] = public_page return return_dict
def _marked_element_to_dict(marked_object: Union[MarkedArgument, MarkedStatement], lang: str) -> Dict[str, Any]: """ Transform a given MarkedArgument or MarkedStatement object into a dictionary representation. :param marked_object: The MarkedArgument or MarkedStatement which shall be transformed. :param lang: The language in which the answer shall be returned. :return: A dictionary representing a MarkedArgument / MarkedStatement. """ dict_representation = marked_object.to_dict() if type(marked_object) is MarkedArgument: return dict_representation.update({ 'content': get_text_for_argument_uid(marked_object.argument_uid, lang) }) else: return dict_representation.update( {'content': marked_object.statement.get_text()})
def __create_argument_by_raw_input(db_user: User, premisegroup: [str], db_conclusion: Statement, is_supportive, db_issue: Issue) \ -> Tuple[Union[Argument, None], List[int]]: """ Consumes the input to create a new argument :param db_user: User :param premisegroup: String :param db_conclusion: Statement :param is_supportive: Boolean :param db_issue: Issue :return: """ logger('StatementsHelper', 'main with premisegroup {} as premisegroup, conclusion {} in issue {}'.format(premisegroup, db_conclusion.uid, db_issue.uid)) new_statements = [] for text in premisegroup: statement = insert_as_statement(text, db_user, db_issue) new_statements.append(statement) # second, set the new statements as premisegroup new_premisegroup = set_statements_as_new_premisegroup(new_statements, db_user, db_issue) logger('StatementsHelper', 'new pgroup ' + str(new_premisegroup.uid)) # third, insert the argument new_argument = __create_argument_by_uids(db_user, new_premisegroup.uid, db_conclusion.uid, None, is_supportive, db_issue) transaction.commit() if new_argument: _tn = Translator(db_issue.lang) _um = UrlManager(db_issue.slug) append_action_to_issue_rss(db_issue=db_issue, db_author=db_user, title=_tn.get(_.argumentAdded), description='...' + get_text_for_argument_uid(new_argument.uid, anonymous_style=True) + '...', url=_um.get_url_for_justifying_statement(new_argument.uid, Attitudes.DONT_KNOW)) return new_argument, [s.uid for s in new_statements]
def _clicked_argument_to_dict(clicked_argument: ClickedArgument, lang: str) -> Dict[str, Any]: """ Transforms a single ClickedArgument object into a dictionary representation of itself. :param clicked_argument: The object that shall be transformed. :param lang: Language that the answer shall be delivered in. :return: A dictionary representing `clicked_argument`. """ return { 'uid': clicked_argument.uid, 'timestamp': sql_timestamp_pretty_print(clicked_argument.timestamp, lang), 'is_up_vote': clicked_argument.is_up_vote, 'is_valid': clicked_argument.is_valid, 'argument_uid': clicked_argument.argument_uid, 'content': get_text_for_argument_uid(clicked_argument.argument_uid, lang) }
def test_get_text_for_argument_uid(self): s47 = 'we should close public swimming pools because our swimming pools are very old and it would take a major investment to repair them' s48 = 'Other participants said that we should close public swimming pools because our swimming pools are very old and it would take a major investment to repair them. You did not agree with this because schools need the swimming pools for their sports lessons.' s49 = 'we should close public swimming pools does not hold, because the rate of non-swimmers is too high' self.assertTrue(lib.get_text_for_argument_uid(47), s47) self.assertTrue(lib.get_text_for_argument_uid(48), s48) self.assertTrue(lib.get_text_for_argument_uid(49), s49) for attack in ['', None, 'jump']: self.assertTrue( lib.get_text_for_argument_uid(47, attack_type=attack), s47) self.assertTrue( lib.get_text_for_argument_uid(48, attack_type=attack), s48) self.assertTrue( lib.get_text_for_argument_uid(49, attack_type=attack), s49) self.assertTrue(lib.get_text_for_argument_uid(47, with_html_tag=True), s47) self.assertTrue(lib.get_text_for_argument_uid(48, with_html_tag=True), s48) self.assertTrue(lib.get_text_for_argument_uid(49, with_html_tag=True), s49) self.assertTrue( lib.get_text_for_argument_uid(47, start_with_intro=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, start_with_intro=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, start_with_intro=True), s49) self.assertTrue( lib.get_text_for_argument_uid(47, first_arg_by_user=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, first_arg_by_user=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, first_arg_by_user=True), s49) self.assertTrue( lib.get_text_for_argument_uid(47, is_users_opinion=False), s47) self.assertTrue( lib.get_text_for_argument_uid(48, is_users_opinion=False), s48) self.assertTrue( lib.get_text_for_argument_uid(49, is_users_opinion=False), s49) self.assertTrue( lib.get_text_for_argument_uid(47, rearrange_intro=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, rearrange_intro=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, rearrange_intro=True), s49) self.assertTrue( lib.get_text_for_argument_uid(47, support_counter_argument=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, support_counter_argument=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, support_counter_argument=True), s49) self.assertTrue(lib.get_text_for_argument_uid(47, nickname='Dieter'), s47) self.assertTrue(lib.get_text_for_argument_uid(48, nickname='Dieter'), s48) self.assertTrue(lib.get_text_for_argument_uid(49, nickname='Dieter'), s49) self.assertTrue( lib.get_text_for_argument_uid(47, minimize_on_undercut=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, minimize_on_undercut=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, minimize_on_undercut=True), s49) self.assertTrue( lib.get_text_for_argument_uid(47, colored_position=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, colored_position=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, colored_position=True), s49) self.assertTrue( lib.get_text_for_argument_uid(47, user_changed_opinion=True), s47) self.assertTrue( lib.get_text_for_argument_uid(48, user_changed_opinion=True), s48) self.assertTrue( lib.get_text_for_argument_uid(49, user_changed_opinion=True), s49)
def get_bubble_from_reaction_step(step, db_user, lang, splitted_history, url, color_steps=False): """ Creates bubbles for the reaction-keyword. :param step: String :param db_user: User :param lang: ui_locales :param splitted_history: [String].uid :param url: String :param color_steps: Boolean :return: [dict()] """ logger('history_handler', 'def: {}, {}'.format(step, splitted_history)) steps = step.split('/') uid = int(steps[1]) attack = Relations.SUPPORT if 'reaction' in step: additional_uid = int(steps[3]) attack = relation_mapper[steps[2]] else: additional_uid = int(steps[2]) if not check_reaction(uid, additional_uid, attack): logger('history_handler', 'wrong reaction') return None is_supportive = DBDiscussionSession.query(Argument).get(uid).is_supportive last_relation = splitted_history[-1].split('/')[2] if len(splitted_history) > 1 else '' user_changed_opinion = len(splitted_history) > 1 and '/undercut/' in splitted_history[-2] support_counter_argument = False if step in splitted_history: index = splitted_history.index(step) try: support_counter_argument = 'reaction' in splitted_history[index - 1] except IndexError: support_counter_argument = False color_steps = color_steps and attack != Relations.SUPPORT # special case for the support round current_arg = get_text_for_argument_uid(uid, user_changed_opinion=user_changed_opinion, support_counter_argument=support_counter_argument, colored_position=color_steps, nickname=db_user.nickname, with_html_tag=color_steps) db_argument = DBDiscussionSession.query(Argument).get(uid) db_confrontation = DBDiscussionSession.query(Argument).get(additional_uid) reply_for_argument = True if db_argument.conclusion_uid is not None: db_statement = DBDiscussionSession.query(Statement).get(db_argument.conclusion_uid) reply_for_argument = not (db_statement and db_statement.is_position) premise = db_argument.get_premisegroup_text() conclusion = get_text_for_conclusion(db_argument) sys_conclusion = get_text_for_conclusion(db_confrontation) confr = db_confrontation.get_premisegroup_text() user_is_attacking = not db_argument.is_supportive if lang != 'de': current_arg = current_arg[0:1].upper() + current_arg[1:] if current_arg.startswith('<'): pos = current_arg.index('>') current_arg = current_arg[0:pos] + current_arg[pos:pos + 1].upper() + current_arg[pos + 1:] premise = premise[0:1].lower() + premise[1:] _tn = Translator(lang) user_text = (_tn.get(_.otherParticipantsConvincedYouThat) + ': ') if last_relation == Relations.SUPPORT else '' user_text += '<{}>{}</{}>'.format(tag_type, current_arg if current_arg != '' else premise, tag_type) sys_text, tmp = get_text_for_confrontation(lang, db_user.nickname, premise, conclusion, sys_conclusion, is_supportive, attack, confr, reply_for_argument, user_is_attacking, db_argument, db_confrontation, color_html=False) bubble_user = create_speechbubble_dict(BubbleTypes.USER, content=user_text, omit_bubble_url=False, argument_uid=uid, is_supportive=is_supportive, nickname=db_user.nickname, lang=lang, bubble_url=url) db_tmp = DBDiscussionSession.query(User).get(db_confrontation.author_uid) if not attack: bubble_syst = create_speechbubble_dict(BubbleTypes.SYSTEM, content=sys_text, omit_bubble_url=True, nickname=db_user.nickname, lang=lang, other_author=db_tmp) else: bubble_syst = create_speechbubble_dict(BubbleTypes.SYSTEM, uid='question-bubble-' + str(additional_uid), content=sys_text, omit_bubble_url=True, nickname=db_user.nickname, lang=lang, other_author=db_tmp) return [bubble_user, bubble_syst]
def __get_executed_review_element_of(table, main_page, review, last_review_type, translator, is_executed): """ :param table: Shortcut for the table :param main_page: Main page of D-BAS :param review: Element :param last_review_type: Type of the last reviewer of the table :param translator: current ui_locales :param is_executed :return: Element """ length = 35 # getting text if table == 'duplicates': full_text = get_text_for_statement_uid(review.duplicate_statement_uid) elif table in ['splits', 'merges']: full_text = get_text_for_premisegroup_uid(review.premisegroup_uid) elif review.statement_uid is None: full_text = get_text_for_argument_uid(review.argument_uid) else: full_text = get_text_for_statement_uid(review.statement_uid) # pretty print intro = translator.get(_.otherUsersSaidThat) + ' ' if full_text.startswith(intro): short_text = full_text[len(intro):len(intro) + 1].upper() + full_text[len(intro) + 1:len(intro) + length] else: short_text = full_text[0:length] short_text += '...' if len(full_text) > length else '.' short_text = '<span class="text-primary">' + short_text + '</span>' all_votes = DBDiscussionSession.query(last_review_type).filter_by(review_uid=review.uid) is_okay = False if table == 'optimizations' else True if table is 'merges': pro_votes = all_votes.filter_by(should_merge=is_okay).all() con_votes = all_votes.filter(last_review_type.should_merge != is_okay).all() elif table is 'splits': pro_votes = all_votes.filter_by(should_split=is_okay).all() con_votes = all_votes.filter(last_review_type.should_split != is_okay).all() else: pro_votes = all_votes.filter_by(is_okay=is_okay).all() con_votes = all_votes.filter(last_review_type.is_okay != is_okay).all() # getting the users which have voted pro_list = [__get_user_dict_for_review(pro.reviewer_uid, main_page) for pro in pro_votes] con_list = [__get_user_dict_for_review(con.reviewer_uid, main_page) for con in con_votes] if table == 'duplicates': # switch it, because contra is: it should not be there! tmp_list = pro_list pro_list = con_list con_list = tmp_list # and build up some dict entry = dict() entry['entry_id'] = review.uid tmp = __handle_table_of_review_element(table, entry, review, short_text, full_text, length, is_executed) if not tmp: entry = None else: entry.update(tmp) entry['pro'] = pro_list entry['con'] = con_list entry['timestamp'] = sql_timestamp_pretty_print(review.timestamp, translator.get_lang()) entry['votes_pro'] = pro_list entry['votes_con'] = con_list entry['reporter'] = __get_user_dict_for_review(review.detector_uid, main_page) return entry
def get_queue_information(self, db_user: User, session: Session, application_url: str, translator: Translator): """ Setup the subpage for the optimization queue :param db_user: User :param session: session of current webserver request :param application_url: current url of the app :param translator: Translator :return: dict() """ LOG.debug("Setting up the sub-page for the optimization-queue") all_rev_dict = get_all_allowed_reviews_for_user( session, f'already_seen_{self.key}', db_user, ReviewOptimization, LastReviewerOptimization) extra_info = '' # if we have no reviews, try again with fewer restrictions if not all_rev_dict['reviews']: all_rev_dict['already_seen_reviews'] = list() extra_info = 'already_seen' if not all_rev_dict[ 'first_time'] else '' db_reviews = DBDiscussionSession.query(ReviewOptimization).filter( ReviewOptimization.is_executed == False, ReviewOptimization.detector_uid != db_user.uid) if len(all_rev_dict['already_voted_reviews']) > 0: db_reviews = db_reviews.filter(~ReviewOptimization.uid.in_( all_rev_dict['already_voted_reviews'])) all_rev_dict['reviews'] = db_reviews.all() if not all_rev_dict['reviews']: return { 'stats': None, 'text': None, 'reason': None, 'issue_titles': None, 'context': [], 'extra_info': None, 'session': session } rnd_review = random.choice(all_rev_dict['reviews']) if rnd_review.statement_uid is None: db_argument = DBDiscussionSession.query(Argument).get( rnd_review.argument_uid) text = get_text_for_argument_uid(db_argument.uid) issue_titles = [ DBDiscussionSession.query(Issue).get( db_argument.issue_uid).title ] parts = self.__get_text_parts_of_argument(db_argument) context = [text] else: db_statement = DBDiscussionSession.query(Statement).get( rnd_review.statement_uid) text = db_statement.get_text() issue_titles = [ issue.title for issue in get_issues_for_statement_uids( [rnd_review.statement_uid]) ] parts = [ self.__get_part_dict('statement', text, 0, rnd_review.statement_uid) ] context = [] args = get_all_arguments_by_statement(rnd_review.statement_uid) if args: html_wrap = '<span class="text-info"><strong>{}</strong></span>' context = [ get_text_for_argument_uid(arg.uid).replace( text, html_wrap.format(text)) for arg in args ] reason = translator.get(_.argumentFlaggedBecauseOptimization) stats = get_reporter_stats_for_review(rnd_review, translator.get_lang(), application_url) all_rev_dict['already_seen_reviews'].append(rnd_review.uid) session[f'already_seen_{self.key}'] = all_rev_dict[ 'already_seen_reviews'] return { 'stats': stats, 'text': text, 'reason': reason, 'issue_titles': issue_titles, 'extra_info': extra_info, 'context': context, 'parts': parts, 'session': session }
def __get_dict_for_argumentation(self, user_arg: Argument, confrontation_arg_uid: int, history: str, attack: Relations, nickname: str, is_supportive: bool) -> dict: """ Returns dict() for the reaction step :param user_arg: Argument :param confrontation_arg_uid: Argument.uid :param history: String :param attack: String :param nickname: User.nickname :param is_supportive: Boolean :return: dict() """ premise = user_arg.get_premisegroup_text() conclusion = get_text_for_conclusion(user_arg) db_confrontation = DBDiscussionSession.query(Argument).get( confrontation_arg_uid) confr = db_confrontation.get_premisegroup_text() sys_conclusion = (db_confrontation.get_conclusion_text()) if attack == Relations.UNDERMINE: if db_confrontation.conclusion_uid != 0: premise = db_confrontation.get_conclusion_text() else: premise = get_text_for_argument_uid( db_confrontation.argument_uid, True, colored_position=True, attack_type=attack) # did the user changed his opinion? history = history_handler.split(history) user_changed_opinion = len(history) > 1 and '/undercut/' in history[-2] # argumentation is a reply for an argument, if the arguments conclusion of the user is no position conclusion_uid = user_arg.conclusion_uid tmp_arg = user_arg while not conclusion_uid: tmp_arg = DBDiscussionSession.query(Argument).get( tmp_arg.argument_uid) conclusion_uid = tmp_arg.conclusion_uid db_statement = DBDiscussionSession.query(Statement).get(conclusion_uid) reply_for_argument = not (db_statement and db_statement.is_position) support_counter_argument = 'reaction' in self.history.split('-')[-1] current_argument = get_text_for_argument_uid( user_arg.uid, nickname=nickname, with_html_tag=True, colored_position=True, user_changed_opinion=user_changed_opinion, attack_type=attack, minimize_on_undercut=True, support_counter_argument=support_counter_argument) current_argument = start_with_capital(current_argument) if self.lang != 'de': premise = start_with_small(premise) # check for support and build text _tn = Translator(self.lang) user_text = (_tn.get(_.otherParticipantsConvincedYouThat) + ': ') if user_changed_opinion else '' user_text += current_argument if current_argument != '' else premise sys_text, gender = get_text_for_confrontation( self.lang, nickname, premise, conclusion, sys_conclusion, is_supportive, attack, confr, reply_for_argument, not user_arg.is_supportive, user_arg, db_confrontation) gender_of_counter_arg = gender return { 'user': user_text, 'sys': sys_text, 'gender': gender_of_counter_arg, 'confrontation': db_confrontation }
def get_dict_for_justify_argument(self, uid, is_supportive, attack): """ Prepares the discussion dict with all bubbles for a step in discussion, where the user justifies his attack she has done. :param uid: Argument.uid :param is_supportive: Boolean :param attack: String (undermine, support, undercut, rebut, ...) :return: dict() """ LOG.debug("Entering get_dict_for_justify_argument") _tn = Translator(self.lang) bubbles_array = history_handler.create_bubbles(self.history, self.nickname, self.lang, self.slug) add_premise_text = '' save_statement_url = 'set_new_premises_for_argument' db_argument = DBDiscussionSession.query(Argument).get(uid) if not db_argument: return { 'bubbles': bubbles_array, 'add_premise_text': add_premise_text, 'save_statement_url': save_statement_url, 'mode': '', 'broke_limit': self.broke_limit } confrontation = get_text_for_argument_uid(uid) premise = db_argument.get_premisegroup_text() conclusion = get_text_for_conclusion(db_argument, is_users_opinion=False) if db_argument.conclusion_uid is None: conclusion = start_with_small(conclusion) while premise.endswith(('.', '?', '!')): premise = premise[:-1] while conclusion.endswith(('.', '?', '!')): conclusion = premise[:-1] redirect_from_jump = 'jump/' in self.history.split('-')[-1] user_msg, sys_msg = get_header_for_users_confrontation_response( db_argument, self.lang, premise, attack, conclusion, False, is_supportive, self.nickname, redirect_from_jump=redirect_from_jump) add_premise_text = self.__get_add_premise_text_for_justify_argument( confrontation, premise, attack, conclusion, db_argument, is_supportive, user_msg) start = '<{} data-argumentation-type="position">'.format(tag_type) end = '</{}>'.format(tag_type) user_msg = user_msg.format(start, end) pro_tag = '<{} class="text-success">'.format(tag_type) con_tag = '<{} class="text-danger">'.format(tag_type) end_tag = '</{}>'.format(tag_type) if attack == Relations.UNDERCUT: sys_msg = _tn.get( _.whatIsYourMostImportantReasonForArgument).rstrip().format( pro_tag, end_tag) + ': ' dot = '.' else: dot = '?' if attack == Relations.UNDERMINE: sys_msg = _tn.get( _.whatIsYourMostImportantReasonAgainstStatement).rstrip( ).format(con_tag, end_tag) sys_msg += ', ' if self.lang == 'de' else ' ' else: sys_msg = _tn.get(_.whatIsYourMostImportantReasonForStatement ).rstrip().format(pro_tag, end_tag) + ': ' sys_msg += user_msg + dot + '<br>' + _tn.get(_.because) + '...' self.__append_now_bubble(bubbles_array) sys_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM, content=sys_msg, omit_bubble_url=True, lang=self.lang) if not bubbles_already_last_in_list(bubbles_array, sys_bubble): bubbles_array.append(sys_bubble) return { 'bubbles': bubbles_array, 'add_premise_text': add_premise_text, 'save_statement_url': save_statement_url, 'mode': '', 'attack_type': attack, 'arg_uid': uid, 'broke_limit': self.broke_limit }
def __create_reaction_history_bubbles(step: str, db_user: User, lang: str, split_history: list, url: str, color_steps: bool, uid: int, additional_uid: int, attack) -> list: is_supportive = DBDiscussionSession.query(Argument).get(uid).is_supportive last_relation = get_last_relation(split_history) user_changed_opinion = len( split_history) > 1 and '/undercut/' in split_history[-2] support_counter_argument = False if step in split_history: index = split_history.index(step) try: support_counter_argument = 'reaction' in split_history[index - 1] except IndexError: support_counter_argument = False color_steps = color_steps and attack != Relations.SUPPORT # special case for the support round current_arg = get_text_for_argument_uid( uid, user_changed_opinion=user_changed_opinion, support_counter_argument=support_counter_argument, colored_position=color_steps, nickname=db_user.nickname, with_html_tag=color_steps) db_argument = DBDiscussionSession.query(Argument).get(uid) db_confrontation = DBDiscussionSession.query(Argument).get(additional_uid) reply_for_argument = True if db_argument.conclusion_uid is not None: db_statement = DBDiscussionSession.query(Statement).get( db_argument.conclusion_uid) reply_for_argument = not (db_statement and db_statement.is_position) premise = db_argument.get_premisegroup_text() conclusion = get_text_for_conclusion(db_argument) sys_conclusion = get_text_for_conclusion(db_confrontation) confr = db_confrontation.get_premisegroup_text() user_is_attacking = not db_argument.is_supportive if lang != 'de': current_arg = start_with_capital(current_arg) if current_arg.startswith('<'): pos = current_arg.index('>') current_arg = current_arg[0:pos] + current_arg[pos:pos + 1].upper( ) + current_arg[pos + 1:] premise = start_with_small(premise) _tn = Translator(lang) user_text = '' if last_relation == Relations.SUPPORT: user_text = _tn.get(_.otherParticipantsConvincedYouThat) + ': ' user_text += '<{}>{}</{}>'.format( tag_type, current_arg if current_arg != '' else premise, tag_type) sys_text, tmp = get_text_for_confrontation(lang, db_user.nickname, premise, conclusion, sys_conclusion, is_supportive, attack, confr, reply_for_argument, user_is_attacking, db_argument, db_confrontation, color_html=False) bubble_user = create_speechbubble_dict(BubbleTypes.USER, bubble_url=url, content=user_text, omit_bubble_url=False, argument_uid=uid, is_supportive=is_supportive, db_user=db_user, lang=lang) db_tmp = DBDiscussionSession.query(User).get(db_confrontation.author_uid) if not attack: bubble_syst = create_speechbubble_dict(BubbleTypes.SYSTEM, content=sys_text, omit_bubble_url=True, db_user=db_user, lang=lang, other_author=db_tmp) else: bubble_syst = create_speechbubble_dict(BubbleTypes.SYSTEM, uid='question-bubble-' + str(additional_uid), content=sys_text, omit_bubble_url=True, db_user=db_user, lang=lang, other_author=db_tmp) return [bubble_user, bubble_syst]
def __resolve_argument_attribute(attribute, main_page, db_languages, db_users, tmp): text = get_text_for_argument_uid(attribute) if attribute is not None else 'None' tmp.append('{} - {}'.format(attribute, text))
def test_get_text_for_argument_uid(self): s47 = 'we should close public swimming pools because our swimming pools are very old and it would take a ' \ 'major investment to repair them' s48 = 'Other participants said that we should close public swimming pools because our swimming pools are ' \ 'very old and it would take a major investment to repair them. You did not agree with this because ' \ 'schools need the swimming pools for their sports lessons.' s49 = 'we should close public swimming pools does not hold, because the rate of non-swimmers is too high' self.assertEqual(lib.get_text_for_argument_uid(47), s47) self.assertEqual(lib.get_text_for_argument_uid(48), s48) self.assertEqual(lib.get_text_for_argument_uid(49), s49) self.assertEqual(lib.get_text_for_argument_uid(47, attack_type='doesnt-matter-parameter-should-be-a-boolean'), s47) self.assertEqual(lib.get_text_for_argument_uid(48, attack_type='doesnt-matter-parameter-should-be-a-boolean'), s48) self.assertEqual(lib.get_text_for_argument_uid(49, attack_type='doesnt-matter-parameter-should-be-a-boolean'), s49) self.assertEqual(lib.get_text_for_argument_uid(47, attack_type='jump'), '{}.'.format(s47)) self.assertEqual(lib.get_text_for_argument_uid(48, attack_type='jump'), 'our swimming pools are very old and it would take a major investment to repair them is not ' 'a good reason for we should close public swimming pools. Because schools need the swimming ' 'pools for their sports lessons.') self.assertEqual(lib.get_text_for_argument_uid(49, attack_type='jump'), 'we should close public swimming pools does not hold because the rate of non-swimmers is too ' 'high.') self.assertEqual(lib.get_text_for_argument_uid(47, with_html_tag=True), '<span>we should close public swimming pools</span> because our swimming pools are very old ' 'and it would take a major investment to repair them') self.assertEqual(lib.get_text_for_argument_uid(48, with_html_tag=True), 'Other participants said that we should close public swimming pools because our swimming ' 'pools are very old and it would take a major investment to repair them. You did not agree ' 'with this because<span data-argumentation-type="position"> schools need the swimming pools ' 'for their sports lessons.') self.assertEqual(lib.get_text_for_argument_uid(49, with_html_tag=True), '<span>we should close public swimming pools</span> <span> does not hold</span>, because the ' 'rate of non-swimmers is too high') self.assertEqual(lib.get_text_for_argument_uid(47, start_with_intro=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, start_with_intro=True), s48) self.assertEqual(lib.get_text_for_argument_uid(49, start_with_intro=True), s49) self.assertEqual(lib.get_text_for_argument_uid(47, first_arg_by_user=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, first_arg_by_user=True), 'We should close public swimming pools because our swimming pools are very old and it would ' 'take a major investment to repair them. Now you agree that schools need the swimming pools ' 'for their sports lessons.') self.assertEqual(lib.get_text_for_argument_uid(49, first_arg_by_user=True), s49) self.assertEqual(lib.get_text_for_argument_uid(47, is_users_opinion=False), s47) self.assertEqual(lib.get_text_for_argument_uid(48, is_users_opinion=False), s48) self.assertEqual(lib.get_text_for_argument_uid(49, is_users_opinion=False), s49) self.assertEqual(lib.get_text_for_argument_uid(47, rearrange_intro=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, rearrange_intro=True), s48) self.assertEqual(lib.get_text_for_argument_uid(49, rearrange_intro=True), s49) self.assertEqual(lib.get_text_for_argument_uid(47, support_counter_argument=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, support_counter_argument=True), s48) self.assertEqual(lib.get_text_for_argument_uid(49, support_counter_argument=True), s49) self.assertEqual(lib.get_text_for_argument_uid(47, nickname='Dieter'), s47) self.assertEqual(lib.get_text_for_argument_uid(48, nickname='Dieter'), s48) self.assertEqual(lib.get_text_for_argument_uid(49, nickname='Dieter'), s49) self.assertEqual(lib.get_text_for_argument_uid(47, minimize_on_undercut=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, minimize_on_undercut=True), s48) self.assertEqual(lib.get_text_for_argument_uid(49, minimize_on_undercut=True), s49) self.assertEqual(lib.get_text_for_argument_uid(47, colored_position=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, colored_position=True), s48) self.assertEqual(lib.get_text_for_argument_uid(49, colored_position=True), s49) self.assertEqual(lib.get_text_for_argument_uid(47, user_changed_opinion=True), s47) self.assertEqual(lib.get_text_for_argument_uid(48, user_changed_opinion=True), 'Earlier you argued that we should close public swimming pools because our swimming pools ' 'are very old and it would take a major investment to repair them. Other participants ' 'convinced you that schools need the swimming pools for their sports lessons.') self.assertEqual(lib.get_text_for_argument_uid(49, user_changed_opinion=True), s49)
def __get_subpage_dict_for_optimization(session, application_url, db_user, translator): """ Setup the subpage for the optimization queue :param session: session of current webserver request :param application_url: current url of the app :param db_user: User :param translator: Translator :return: dict() """ logger('ReviewSubpagerHelper', 'main') db_reviews, already_seen, already_reviewed, first_time = __get_all_allowed_reviews_for_user( session, 'already_seen_optimization', db_user, ReviewOptimization, LastReviewerOptimization) extra_info = '' # if we have no reviews, try again with fewer restrictions if not db_reviews: already_seen = list() extra_info = 'already_seen' if not first_time else '' db_reviews = DBDiscussionSession.query(ReviewOptimization).filter( ReviewOptimization.is_executed == False, ReviewOptimization.detector_uid != db_user.uid) if len(already_reviewed) > 0: db_reviews = db_reviews.filter( ~ReviewOptimization.uid.in_(already_reviewed)) db_reviews = db_reviews.all() if not db_reviews: return { 'stats': None, 'text': None, 'reason': None, 'issue': None, 'context': [], 'extra_info': None, 'session': session } rnd_review = db_reviews[random.randint(0, len(db_reviews) - 1)] if rnd_review.statement_uid is None: db_argument = DBDiscussionSession.query(Argument).get( rnd_review.argument_uid) text = get_text_for_argument_uid(db_argument.uid) issue = DBDiscussionSession.query(Issue).get( db_argument.issue_uid).title parts = __get_text_parts_of_argument(db_argument) context = [text] else: db_statement = DBDiscussionSession.query(Statement).get( rnd_review.statement_uid) text = db_statement.get_text() issue = DBDiscussionSession.query(Issue).get( db_statement.issue_uid).title parts = [ __get_part_dict('statement', text, 0, rnd_review.statement_uid) ] context = [] args = get_all_arguments_by_statement(rnd_review.statement_uid) if args: context = [ get_text_for_argument_uid(arg.uid).replace( text, '<span class="text-info"><strong>{}</strong></span>'. format(text)) for arg in args ] reason = translator.get(_.argumentFlaggedBecauseOptimization) stats = __get_stats_for_review(rnd_review, translator.get_lang(), application_url) already_seen.append(rnd_review.uid) session['already_seen_optimization'] = already_seen return { 'stats': stats, 'text': text, 'reason': reason, 'issue': issue, 'extra_info': extra_info, 'context': context, 'parts': parts, 'session': session }