def __get_text_parts_of_argument(argument): """ Get all parts of ana rgument as string :param argument: Argument.uid :return: list of strings """ logger('ReviewSubpagerHelper', 'main') ret_list = list() # get premise of current argument db_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=argument.premisegroup_uid).all() premises_uids = [premise.uid for premise in db_premises] for uid in premises_uids: logger('ReviewSubpagerHelper', 'add premise of argument ' + str(argument.uid)) text = get_text_for_statement_uid(uid) ret_list.append(__get_part_dict('premise', text, argument.uid, uid)) if argument.argument_uid is None: # get conclusion of current argument conclusion = argument.get_conclusion_text() logger('ReviewSubpagerHelper', 'add statement of argument ' + str(argument.uid)) ret_list.append( __get_part_dict('conclusion', conclusion, argument.uid, argument.conclusion_uid)) else: # or get the conclusions argument db_conclusions_argument = DBDiscussionSession.query(Argument).get( argument.argument_uid) while db_conclusions_argument.argument_uid is not None: # get further conclusions arguments # get premise of conclusions arguments db_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=argument.premisegroup_uid).all() premises_uids = [premise.uid for premise in db_premises] for uid in premises_uids: text = get_text_for_statement_uid(uid) logger( 'ReviewSubpagerHelper', 'add premise of argument ' + str(db_conclusions_argument.uid)) ret_list.append( __get_part_dict('premise', text, db_conclusions_argument.uid, uid)) db_conclusions_argument = DBDiscussionSession.query(Argument).get( db_conclusions_argument.argument_uid) # get the last conclusion of the chain conclusion = db_conclusions_argument.get_conclusion_text() logger('ReviewSubpagerHelper', 'add statement of argument ' + str(db_conclusions_argument.uid)) ret_list.append( __get_part_dict('conclusion', conclusion, db_conclusions_argument.uid, db_conclusions_argument.conclusion_uid)) return ret_list[::-1]
def test_get_text_for_statement_uid(self): # id for no statement self.assertIsNone(lib.get_text_for_statement_uid(uid=0)) # id for statement, which ends with '.' self.assertEqual(lib.get_text_for_statement_uid(uid=3), 'we should get a dog') # id for statement, which ends with '!' self.assertEqual(lib.get_text_for_statement_uid(uid=31), 'it is important, that pets are small and fluffy') # negative uid self.assertIsNone(lib.get_text_for_statement_uid(uid=-30))
def __validate_reference_data(self, uids, ddict): for key in ddict: self.assertIn(key, uids) refs = ddict[key] for ref in refs: self.assertIn('uid', ref) self.assertIn('statement_text', ref) self.assertEquals(ref['statement_text'], get_text_for_statement_uid(key)) db_ref = DBDiscussionSession.query(StatementReference).get( ref['uid']) self.assertEquals( ref['statement_text'], get_text_for_statement_uid(db_ref.statement_uid))
def get_logfile_for_statements(uids, lang, main_page): """ Returns the logfile for the given statement uid :param uids: requested statement uid :param lang: ui_locales ui_locales :param main_page: URL :return: dictionary with the logfile-rows """ logger('StatementsHelper', 'def with uid: ' + str(uids)) main_dict = dict() for uid in uids: db_textversions = DBDiscussionSession.query(TextVersion).filter_by(statement_uid=uid).order_by( TextVersion.uid.asc()).all() # TODO #432 if len(db_textversions) == 0: continue return_dict = dict() content_dict = dict() # add all corrections for index, version in enumerate(db_textversions): content_dict[str(index)] = __get_logfile_dict(version, main_page, lang) return_dict['content'] = content_dict main_dict[get_text_for_statement_uid(uid)] = return_dict return main_dict
def __handle_table_of_review_duplicate(review, length, entry): text = get_text_for_statement_uid(review.original_statement_uid) if text is None: text = '...' entry['statement_duplicate_shorttext'] = text[0:length] + ('...' if len(text) > length else '') entry['statement_duplicate_fulltext'] = text return entry
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 insert_as_statement(text: str, db_user: User, db_issue: Issue, is_start=False) -> Statement: """ Inserts the given text as statement and returns the uid :param text: String :param db_user: User :param db_issue: Issue :param is_start: Boolean :return: Statement """ new_statement, is_duplicate = set_statement(text, db_user, is_start, db_issue) # add marked statement DBDiscussionSession.add(MarkedStatement(statement=new_statement.uid, user=db_user.uid)) DBDiscussionSession.add(SeenStatement(statement_uid=new_statement.uid, user_uid=db_user.uid)) DBDiscussionSession.flush() _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(_.positionAdded if is_start else _.statementAdded), description='...' + get_text_for_statement_uid(new_statement.uid) + '...', url=_um.get_url_for_statement_attitude(new_statement.uid)) return new_statement
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_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_helper.create_bubbles_from_history( self.history, self.nickname, self.lang, self.slug) add_premise_text = '' save_statement_url = 'set_new_start_statement' logger('DictionaryHelper', 'at_choosing') a = _tn.get(_.soYouEnteredMultipleReasons) c = get_text_for_argument_uid( uid) if is_uid_argument else get_text_for_statement_uid(uid) 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 __handle_table_of_review_merge(review, length, entry): db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=review.premisegroup_uid).all() oem_fulltext = str([get_text_for_statement_uid(p.statement_uid) for p in db_premises]) full_text = oem_fulltext db_values = DBDiscussionSession.query(ReviewMergeValues).filter_by(review_uid=review.uid).all() if db_values: full_text = str([value.content for value in db_values]) full_text = ' and '.join(full_text) entry['argument_oem_shorttext'] = oem_fulltext[0:length] + '...' if len(oem_fulltext) > length else oem_fulltext entry['argument_oem_fulltext'] = oem_fulltext entry['argument_shorttext'] = full_text[0:length] + '...' if len(full_text) > length else full_text entry['argument_fulltext'] = full_text return entry
def get_references_for_statements(uids, main_page): """ Returns all references for the current given statements :param uid: uids of the statement :param main_page: current main page :return: dict """ data = {} text = {} for uid in uids: references_array = __get_references_for_statement(uid, main_page)[uid] data[uid] = references_array text[uid] = get_text_for_statement_uid(uid) return data, text
def __get_opinions_for_uid(uid, is_supportive, db_user, lang, _t, main_page): none_dict = { 'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None } statement_dict = dict() all_users = [] db_statement = DBDiscussionSession.query(Statement).get(uid) if not db_statement: statement_dict.update(none_dict) statement_dict['uid'] = str(uid) text = get_text_for_statement_uid(uid) try: if db_statement.is_position and lang == 'de': text = _t.get(_.statementIsAbout) + ' ' + text statement_dict['text'] = text except TypeError: statement_dict.update(none_dict) is_supportive = (True if str(is_supportive) == 'True' else False) if is_supportive is not None else False db_votes = DBDiscussionSession.query(ClickedStatement).filter( ClickedStatement.statement_uid == uid, ClickedStatement.is_up_vote == is_supportive, ClickedStatement.is_valid == True, ClickedStatement.author_uid != db_user.uid).all() for vote in db_votes: 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) statement_dict['users'] = all_users statement_dict['message'] = __get_text_for_clickcount( len(db_votes), db_user.uid, _t) db_seen_by = DBDiscussionSession.query(SeenStatement).filter_by( statement_uid=int(uid)).all() statement_dict['seen_by'] = len(db_seen_by) if db_seen_by else 0 return statement_dict
def get_references_for_argument(uid, main_page): """ Returns all references for the premises group of given argument :param uid: uid of the argument :param main_page: current main page :return: dict """ logger('ReferenceHelper', str(uid)) if not is_integer(uid): return {}, {} db_arguments = get_enabled_arguments_as_query() db_argument = db_arguments.filter_by(uid=uid).first() if not db_argument: return {}, {} db_premises = get_enabled_premises_as_query() db_premises = db_premises.filter_by( premisegroup_uid=db_argument.premisegroup_uid).all() data = {} text = {} for premise in db_premises: tmp_uid = premise.statement_uid references_array = __get_references_for_statement(tmp_uid, main_page)[tmp_uid] data[premise.statement_uid] = references_array text[premise.statement_uid] = premise.get_text() if db_argument.conclusion_uid is not None: tmp_uid = db_argument.conclusion_uid references_array = __get_references_for_statement(tmp_uid, main_page)[tmp_uid] data[tmp_uid] = references_array text[tmp_uid] = get_text_for_statement_uid(tmp_uid) else: d, t = get_references_for_argument(db_argument.argument_uid, main_page) data.update(d) text.update(t) return data, text
def get_user_bubble_text_for_justify_statement(stmt_uid, db_user, is_supportive, _tn): """ Returns user text for a bubble when the user has to justify a statement and text for the add-premise-container :param stmt_uid: Statement.uid :param db_user: User :param is_supportive: Boolean :param _tn: Translator :return: String, String """ logger('BubbleHelper', '{} {}'.format(stmt_uid, is_supportive)) text = get_text_for_statement_uid(stmt_uid) if _tn.get_lang() == 'de': intro = _tn.get(_.itIsTrueThat if is_supportive else _.itIsFalseThat) add_premise_text = intro[0:1].upper() + intro[1:] + ' ' + text else: add_premise_text = text + ' ' + _tn.get(_.holds if is_supportive else _.isNotAGoodIdea).strip() add_premise_text += ', ...' is_users_opinion = False if db_user: db_marked_statement = DBDiscussionSession.query(MarkedStatement).filter( MarkedStatement.statement_uid == stmt_uid, MarkedStatement.author_uid == db_user.uid ).first() is_users_opinion = db_marked_statement is not None if is_users_opinion: intro = _tn.get(_.youHaveTheOpinionThat) outro = '' if is_supportive else ', ' + _tn.get(_.isNotAGoodIdea) text = intro.format(text) + outro return text, add_premise_text if is_supportive: intro = _tn.get(_.youAgreeWith) if _tn.get_lang() == 'de' else '{}' else: intro = _tn.get(_.youDisagreeWith) text = intro.format(text) return text, add_premise_text
def __get_bubble_from_attitude_step(step, nickname, lang, url): """ Creates bubbles for the attitude-keyword for an statement. :param step: String :param nickname: User.nickname :param lang: ui_locales :param url: String :return: [dict()] """ logger('history_handler', 'def') steps = step.split('/') uid = int(steps[1]) text = get_text_for_statement_uid(uid) if lang != 'de': text = text[0:1].upper() + text[1:] bubble = create_speechbubble_dict(BubbleTypes.USER, content=text, omit_bubble_url=False, statement_uid=uid, nickname=nickname, lang=lang, bubble_url=url) return [bubble]
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_subpage_dict_for_duplicates(session, application_url, db_user, translator): """ Setup the subpage for the duplicates 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_duplicate', db_user, ReviewDuplicate, LastReviewerDuplicate) extra_info = '' # if we have no reviews, try again with fewer restrictions if not db_reviews: logger('ReviewSubpagerHelper', 'no unseen reviews') already_seen = list() extra_info = 'already_seen' if not first_time else '' db_reviews = DBDiscussionSession.query(ReviewDuplicate).filter( ReviewDuplicate.is_executed == False, ReviewDuplicate.detector_uid != db_user.uid) if len(already_reviewed) > 0: logger('ReviewSubpagerHelper', 'everything was seen') db_reviews = db_reviews.filter( ~ReviewDuplicate.uid.in_(already_reviewed)) db_reviews = db_reviews.all() if not db_reviews: logger('ReviewSubpagerHelper', 'no reviews') return { 'stats': None, 'text': None, 'reason': None, 'issue': None, 'extra_info': None, 'session': session } rnd_review = db_reviews[random.randint(0, len(db_reviews) - 1)] db_statement = DBDiscussionSession.query(Statement).get( rnd_review.duplicate_statement_uid) text = db_statement.get_text() issue = DBDiscussionSession.query(Issue).get(db_statement.issue_uid).title reason = translator.get(_.argumentFlaggedBecauseDuplicate) duplicate_of_text = get_text_for_statement_uid( rnd_review.original_statement_uid) stats = __get_stats_for_review(rnd_review, translator.get_lang(), application_url) already_seen.append(rnd_review.uid) session['already_seen_duplicate'] = already_seen return { 'stats': stats, 'text': text, 'duplicate_of': duplicate_of_text, 'reason': reason, 'issue': issue, 'extra_info': extra_info, 'session': session }
def __validate_reference_text(self, uids, ddict): for key in ddict: self.assertIn(key, uids) self.assertEquals(ddict[key], get_text_for_statement_uid(key))
def __resolve_statement_attribute(attribute, main_page, db_languages, db_users, tmp): text = get_text_for_statement_uid(attribute) if attribute is not None else 'None' tmp.append(str(attribute) + ' - ' + str(text))