def collection_get(self): return DBDiscussionSession.query(Issue).filter(Issue.is_disabled == False, Issue.is_private == False).all()
def add_review_opinion_for_merge(db_user, main_page, db_review, should_merge, _t): """ Adds row to the merge review :param request: Pyramids request object :param review_uid: ReviewMerge :param should_merge: True, if it should be merged :param _t: Translator :return: String """ logger('review.opinions', 'main {}'.format(db_review.uid)) db_user_created_flag = DBDiscussionSession.query(User).get( db_review.detector_uid) # add new vote __add_vote_for(db_user, db_review, should_merge, LastReviewerMerge) broke_limit = False # get all keep and delete votes count_of_keep, count_of_reset = __get_review_count(LastReviewerMerge, db_review.uid) logger('review.opinions', 'result ' + str(count_of_keep) + ':' + str(count_of_reset)) # do we reached any limit? reached_max = max(count_of_keep, count_of_reset) >= max_votes if reached_max: if count_of_keep > count_of_reset: # split pgroup logger('review.opinions', 'max reached for review {}'.format(db_review.uid)) __merge_premisegroup(db_review) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_success_flag) else: # just close the review logger( 'review.opinions', 'max reached / forget about review {}'.format(db_review.uid)) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_bad_flag) db_review.set_executed(True) db_review.update_timestamp() elif count_of_reset - count_of_keep >= min_difference: # just close the review logger('review.opinions', 'vote says forget about review {}'.format(db_review.uid)) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_bad_flag) db_review.set_executed(True) db_review.update_timestamp() elif count_of_keep - count_of_reset >= min_difference: # split pgroup logger('review.opinions', 'vote says merge for review {}'.format(db_review.uid)) __merge_premisegroup(db_review) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_success_flag) db_review.set_executed(True) db_review.update_timestamp() DBDiscussionSession.add(db_review) DBDiscussionSession.flush() transaction.commit() if broke_limit: send_request_for_info_popup_to_socketio( db_user_created_flag.nickname, _t.get(_.youAreAbleToReviewNow), main_page + '/review') return ''
def __merge_premisegroup(review): """ Merges a premisegroup into the items, which are mapped with the given review :param review: ReviewSplit.uid :return: None """ db_values = DBDiscussionSession.query(ReviewMergeValues).filter_by( review_uid=review.uid).all() db_old_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=review.premisegroup_uid).all() db_issue = DBDiscussionSession.query(Issue).get( db_old_premises[0].issue_uid) db_first_old_statement = DBDiscussionSession.query(Statement).get( db_old_premises[0].uid) discussion_lang = db_first_old_statement.lang db_user = DBDiscussionSession.query(User).get(review.detector_uid) if db_values: logger('review.opinions', 'merge given premisegroup with the mapped, new statements') texts = [values.content for values in db_values] translator_discussion = Translator(discussion_lang) new_text = ' {} '.format(translator_discussion.get(_.aand)).join(texts) else: logger('review.opinions', 'just merge the premisegroup') new_text = get_text_for_premisegroup_uid(review.premisegroup_uid) # now we have new text as a variable, let's set the statement new_statement, tmp = set_statement(new_text, db_user, db_first_old_statement.is_position, db_issue) # new premisegroup for the statement db_new_premisegroup = PremiseGroup(author=db_user.uid) DBDiscussionSession.add(db_new_premisegroup) DBDiscussionSession.flush() # new premise db_new_premise = Premise(db_new_premisegroup.uid, new_statement.uid, False, db_user.uid, new_statement.issue_uid) DBDiscussionSession.add(db_new_premise) DBDiscussionSession.flush() logger( 'review.opinions', 'Added new premise {} with pgroup {}'.format(db_new_premise.uid, db_new_premisegroup.uid)) # swap the premisegroup occurence in every argument db_arguments = DBDiscussionSession.query(Argument).filter_by( premisegroup_uid=review.premisegroup_uid).all() for argument in db_arguments: logger( 'review.opinions', 'Reset argument {} from pgroup {} to new pgroup {}'.format( argument.uid, argument.premisegroup_uid, db_new_premisegroup.uid)) argument.set_premisegroup(db_new_premisegroup.uid) DBDiscussionSession.add(argument) DBDiscussionSession.flush() # add swap to database DBDiscussionSession.add( PremiseGroupMerged(review.uid, review.premisegroup_uid, db_new_premisegroup.uid)) # swap the conclusion in every argument old_statement_ids = [p.statement_uid for p in db_old_premises] for old_statement_id in old_statement_ids: db_arguments = DBDiscussionSession.query(Argument).filter_by( conclusion_uid=old_statement_id).all() for argument in db_arguments: logger( 'review.opinions', 'Reset arguments {} from conclusion {} to new merges statement {}' .format(argument.uid, argument.conclusion_uid, new_statement.uid)) argument.set_conclusion(new_statement.uid) DBDiscussionSession.add(argument) DBDiscussionSession.add( StatementReplacementsByPremiseGroupMerge( review.uid, old_statement_id, new_statement.uid)) DBDiscussionSession.flush() # finish DBDiscussionSession.flush() transaction.commit()
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 add_review_opinion_for_duplicate(db_user, main_page, db_review, is_duplicate, _t): """ Adds row to the duplicate review :param request: Pyramids request object :param is_duplicate: Boolean :param review_uid: ReviewDuplicate.uid :param _t: Translator :return: String """ logger('review.opinions', 'main {}, duplicate {}'.format(db_review.uid, is_duplicate)) db_user_created_flag = DBDiscussionSession.query(User).get( db_review.detector_uid) # add new vote __add_vote_for(db_user, db_review, not is_duplicate, LastReviewerDuplicate) broke_limit = False # get all keep and delete votes count_of_keep, count_of_reset = __get_review_count(LastReviewerDuplicate, db_review.uid) logger('review.opinions', 'result ' + str(count_of_keep) + ':' + str(count_of_reset)) # do we reached any limit? reached_max = max(count_of_keep, count_of_reset) >= max_votes if reached_max: if count_of_reset > count_of_keep: # disable the flagged part logger('review.opinions', 'max reached / bend for review {}'.format(db_review.uid)) __bend_objects_of_duplicate_review(db_review) add_rep, broke_limit = add_reputation_for( db_user_created_flag, rep_reason_success_duplicate) else: # just close the review logger( 'review.opinions', 'max reached / forget about review {}'.format(db_review.uid)) add_rep, broke_limit = add_reputation_for( db_user_created_flag, rep_reason_bad_duplicate) db_review.set_executed(True) db_review.update_timestamp() elif count_of_keep - count_of_reset >= min_difference: # just close the review logger('review.opinions', 'vote says forget about review {}'.format(db_review.uid)) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_bad_duplicate) db_review.set_executed(True) db_review.update_timestamp() elif count_of_reset - count_of_keep >= min_difference: # disable the flagged part logger('review.opinions', 'vote says bend for review {}'.format(db_review.uid)) __bend_objects_of_duplicate_review(db_review) add_rep, broke_limit = add_reputation_for( db_user_created_flag, rep_reason_success_duplicate) db_review.set_executed(True) db_review.update_timestamp() DBDiscussionSession.add(db_review) DBDiscussionSession.flush() transaction.commit() if broke_limit: send_request_for_info_popup_to_socketio( db_user_created_flag.nickname, _t.get(_.youAreAbleToReviewNow), main_page + '/review') return True
def setUp(self): self.config = testing.setUp() self.user = DBDiscussionSession.query(User).filter_by( nickname='Tobias').first()
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 }
def test_get_public_profile_picture(self): user = DBDiscussionSession.query(User).get(1) self.assertIn('gravatar.com', lib.get_profile_picture(user)) self.assertIn('80', lib.get_profile_picture(user)) self.assertIn('gravatar.com', lib.get_profile_picture(user, size=120)) self.assertIn('120', lib.get_profile_picture(user, size=120))
def test_get_enabled_issues_as_query(self): query_len = get_enabled_issues_as_query().count() res_len = DBDiscussionSession.query(Issue).filter_by(is_disabled=False).count() self.assertEqual(res_len, query_len)
def test_is_user_author_or_admin(self): db_user1 = DBDiscussionSession.query(User).filter_by(nickname='Tobias').first() db_user2 = DBDiscussionSession.query(User).filter_by(nickname='Pascal').first() self.assertTrue(db_user1.is_admin() or db_user1.is_author()) self.assertFalse(db_user2.is_admin() or db_user2.is_author())
def test_is_user_admin(self): self.assertTrue(DBDiscussionSession.query(User).filter_by(nickname='Tobias').first().is_admin()) self.assertFalse(DBDiscussionSession.query(User).filter_by(nickname='Pascal').first().is_admin())
def test_get_user_by_case_insensitive_public_nickname(self): user = DBDiscussionSession.query(User).get(2) self.assertIsNotNone(lib.get_user_by_case_insensitive_public_nickname(user.public_nickname.lower())) self.assertIsNotNone(lib.get_user_by_case_insensitive_public_nickname(user.public_nickname.upper())) self.assertIsNone(lib.get_user_by_case_insensitive_public_nickname('puh_der_bär'))
def get_queue_information(self, db_user: User, session: Session, application_url: str, translator: Translator): """ Setup the sub-page for the split queue :param db_user: User :param session: session of current web-server request :param application_url: current url of the app :param translator: Translator :return: dict() """ LOG.debug("Setting up the sub-page for the split queue") all_rev_dict = get_all_allowed_reviews_for_user( session, f'already_seen_{self.key}', db_user, ReviewSplit, LastReviewerSplit) extra_info = '' # if we have no reviews, try again with fewer restrictions if not all_rev_dict['reviews']: LOG.debug("No unseen reviews") all_rev_dict['already_seen_reviews'] = list() extra_info = 'already_seen' if not all_rev_dict[ 'first_time'] else '' db_reviews = DBDiscussionSession.query(ReviewSplit).filter( ReviewSplit.is_executed == False, ReviewSplit.detector_uid != db_user.uid) if len(all_rev_dict['already_voted_reviews']) > 0: LOG.debug("Everything was seen") db_reviews = db_reviews.filter(~ReviewSplit.uid.in_( all_rev_dict['already_voted_reviews'])) all_rev_dict['reviews'] = db_reviews.all() if not all_rev_dict['reviews']: LOG.debug("No reviews available") return { 'stats': None, 'text': None, 'reason': None, 'issue': None, 'extra_info': None, 'issue_titles': [], 'session': session } rnd_review = random.choice(all_rev_dict['reviews']) premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=rnd_review.premisegroup_uid).all() text = DBDiscussionSession.query(PremiseGroup).get( rnd_review.premisegroup_uid).get_text() db_review_values = DBDiscussionSession.query( ReviewSplitValues).filter_by(review_uid=rnd_review.uid).all() if db_review_values: splitted_text = [rsv.content for rsv in db_review_values] pgroup_only = False else: splitted_text = [premise.get_text() for premise in premises] pgroup_only = True issue = DBDiscussionSession.query(Issue).get( premises[0].issue_uid).title reason = translator.get(_.argumentFlaggedBecauseSplit) statement_uids = [p.statement_uid for p in premises] issue_titles = [ issue.title for issue in get_issues_for_statement_uids(statement_uids) ] 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, 'splitted_text': splitted_text, 'reason': reason, 'issue': issue, 'extra_info': extra_info, 'pgroup_only': pgroup_only, 'issue_titles': issue_titles, 'session': session }
def collection_get(): db_users: List[User] = DBDiscussionSession.query(User).all() return [ApiUser.external_view(db_user) for db_user in db_users]
def tearDown(self): testing.tearDown() DBDiscussionSession.query(Argument).get(1).set_disabled(False) transaction.commit()
def test_is_argument_disabled_due_to_disabled_statements(self): arg1 = DBDiscussionSession.query(Argument).get(1) arg2 = DBDiscussionSession.query(Argument).get(2) self.assertFalse(lib.is_argument_disabled_due_to_disabled_statements(arg2)) self.assertTrue(lib.is_argument_disabled_due_to_disabled_statements(arg1))
def get_array_for_start(self, db_user: User) -> dict: """ Prepares the dict with all items for the first step in discussion, where the user chooses a position. :param db_user: User :return: """ LOG.debug("Entering get_array_for_start with user: %s", db_user.nickname) statements = [el.statement_uid for el in DBDiscussionSession.query(StatementToIssue).filter_by(issue_uid=self.db_issue.uid).all()] db_statements = DBDiscussionSession.query(Statement) \ .filter(Statement.is_disabled == False, Statement.is_position == True, Statement.uid.in_(statements)).all() uids = [element.uid for element in db_statements if db_statements] slug = self.db_issue.slug statements_array = [] _um = UrlManager(slug, history=self.path) ed = EditQueue() for statement in db_statements: if statement.uid in uids: # add seen by if the statement is visible add_seen_statement(statement.uid, db_user) position_dict = self.__create_answer_dict(statement.uid, [{ 'title': statement.get_text(), 'id': statement.uid }], 'start', _um.get_url_for_statement_attitude(statement.uid), is_editable=not ed.is_statement_in_edit_queue( statement.uid), is_markable=True, is_author=is_author_of_statement(db_user, statement.uid), is_visible=statement.uid in uids) if self.db_issue.decision_process: position_dict['cost'] = DBDiscussionSession.query(PositionCost).get(statement.uid).cost statements_array.append(position_dict) _tn = Translator(self.lang) shuffle_list_by_user(db_user, statements_array) if not self.issue_read_only: if db_user.nickname == nick_of_anonymous_user: statements_array.append(self.__create_answer_dict('login', [{ 'id': '0', 'title': _tn.get(_.wantToStateNewPosition) }], 'justify', 'login')) else: title = _tn.get(_.newConclusionRadioButtonText) if len(db_statements) > 0 else _tn.get( _.newConclusionRadioButtonTextNewIdea) statements_array.append(self.__create_answer_dict('start_statement', [{'title': title, 'id': 0}], 'start', 'add')) return {'elements': statements_array, 'extras': {'cropped_list': len(uids) < len(db_statements)}}
def test_unlock_optimization_review(self): _tn = Translator('en') db_review = DBDiscussionSession.query(ReviewOptimization).get(2) rqh.unlock_optimization_review(db_review, _tn) self.assertFalse(rqh.is_review_locked(db_review.uid))
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 test_get_complete_review_count(self): u1 = DBDiscussionSession.query(User).get(1) u2 = DBDiscussionSession.query(User).get(2) self.assertEqual(0, rqh.get_complete_review_count(u1)) self.assertLess(0, rqh.get_complete_review_count(u2))
def __get_subpage_dict_for_edits(session, application_url, db_user, translator): """ Setup the subpage for the edits 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_edit', db_user, ReviewEdit, LastReviewerEdit) rnd_review, already_seen, extra_info, text, issue = __get_base_subpage_dict( ReviewEdit, db_reviews, already_seen, first_time, db_user, already_reviewed) if not rnd_review: return { 'stats': None, 'text': None, 'reason': None, 'issue': None, 'extra_info': None, 'session': session } reason = translator.get(_.argumentFlaggedBecauseEdit) # build correction db_edit_value = DBDiscussionSession.query(ReviewEditValue).filter_by( review_edit_uid=rnd_review.uid).first() stats = __get_stats_for_review(rnd_review, translator.get_lang(), application_url) if not db_edit_value: logger('ReviewSubpagerHelper', 'ReviewEdit {} has no edit value!'.format(rnd_review.uid), error=True) # get all valid reviews db_allowed_reviews = DBDiscussionSession.query(ReviewEdit).filter( ReviewEdit.uid.in_( DBDiscussionSession.query( ReviewEditValue.review_edit_uid))).all() if len(db_allowed_reviews) > 0: return __get_subpage_dict_for_edits(session, db_user, translator, application_url) else: return { 'stats': None, 'text': None, 'reason': None, 'issue': None, 'extra_info': None, 'session': session } correction_list = [char for char in text] __difference_between_string(text, db_edit_value.content, correction_list) correction = ''.join(correction_list) already_seen.append(rnd_review.uid) session['already_seen_edit'] = already_seen return { 'stats': stats, 'text': text, 'corrected_version': db_edit_value.content, 'corrections': correction, 'reason': reason, 'issue': issue, 'extra_info': extra_info, 'session': session }
def __create_reaction_history_bubbles(step: str, db_user: User, lang: str, splitted_history: list, url: str, color_steps: list, uid: int, additional_uid: int, attack) -> list: 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 = 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 __get_subpage_dict_for_merges(session, application_url, db_user, translator): """ :param session: session of current webserver request :param application_url: current url of the app :param db_user: User :param translator: Translator :return: """ logger('ReviewSubpagerHelper', 'main') db_reviews, already_seen, already_reviewed, first_time = __get_all_allowed_reviews_for_user( session, 'already_seen_merge', db_user, ReviewMerge, LastReviewerMerge) 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(ReviewMerge).filter( ReviewMerge.is_executed == False, ReviewMerge.detector_uid != db_user.uid) if len(already_reviewed) > 0: logger('ReviewSubpagerHelper', 'everything was seen') db_reviews = db_reviews.filter( ~ReviewMerge.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)] premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=rnd_review.premisegroup_uid).all() text = [premise.get_text() for premise in premises] db_review_values = DBDiscussionSession.query(ReviewMergeValues).filter_by( review_uid=rnd_review.uid).all() discussion_lang = DBDiscussionSession.query(Statement).get( premises[0].uid).lang translator_discussion = Translator(discussion_lang) if db_review_values: aand = translator_discussion.get(_.aand) merged_text = ' {} '.format(aand).join( [rsv.content for rsv in db_review_values]) pgroup_only = False else: merged_text = get_text_for_premisegroup_uid( rnd_review.premisegroup_uid) pgroup_only = True issue = DBDiscussionSession.query(Issue).get(premises[0].issue_uid).title reason = translator.get(_.argumentFlaggedBecauseMerge) stats = __get_stats_for_review(rnd_review, translator.get_lang(), application_url) already_seen.append(rnd_review.uid) session['already_seen_merge'] = already_seen return { 'stats': stats, 'text': text, 'merged_text': merged_text, 'reason': reason, 'issue': issue, 'extra_info': extra_info, 'pgroup_only': pgroup_only, 'session': session }
def get_text_for_argument_uid(uid, nickname=None, with_html_tag=False, start_with_intro=False, first_arg_by_user=False, user_changed_opinion=False, rearrange_intro=False, colored_position=False, attack_type=None, minimize_on_undercut=False, is_users_opinion=True, anonymous_style=False, support_counter_argument=False): """ Returns current argument as string like "conclusion, because premise1 and premise2" :param uid: Integer :param nickname: String :param with_html_tag: Boolean :param start_with_intro: Boolean :param first_arg_by_user: Boolean :param user_changed_opinion: Boolean :param rearrange_intro: Boolean :param colored_position: Boolean :param attack_type: String :param minimize_on_undercut: Boolean :param anonymous_style: Boolean :param support_counter_argument: Boolean :param is_users_opinion: Boolean :return: String """ LOG.debug("main %s", uid) db_argument = DBDiscussionSession.query(Argument).get(uid) if not db_argument: return None lang = db_argument.lang _t = Translator(lang) premisegroup_by_user = False author_uid = None db_user = DBDiscussionSession.query(User).filter_by(nickname=str(nickname)).first() if db_user: author_uid = db_user.uid pgroup = DBDiscussionSession.query(PremiseGroup).get(db_argument.premisegroup_uid) marked_argument = DBDiscussionSession.query(MarkedArgument).filter_by( argument_uid=uid, author_uid=db_user.uid).first() premisegroup_by_user = pgroup.author_uid == db_user.uid or marked_argument is not None # getting all argument id arg_array = [db_argument] while db_argument.argument_uid: db_argument = DBDiscussionSession.query(Argument).get(db_argument.argument_uid) arg_array.append(db_argument) if attack_type == 'jump': return __build_argument_for_jump(arg_array, with_html_tag) if len(arg_array) == 1: # build one argument only return __build_single_argument(arg_array[0], rearrange_intro, with_html_tag, colored_position, attack_type, _t, start_with_intro, is_users_opinion, anonymous_style, support_counter_argument, author_uid) else: # get all pgroups and at last, the conclusion return __build_nested_argument(arg_array, first_arg_by_user, user_changed_opinion, with_html_tag, start_with_intro, minimize_on_undercut, anonymous_style, premisegroup_by_user, _t)
def add_review_opinion_for_delete(db_user, main_page, db_review, should_delete, _t): """ :param db_user: :param main_page: :param review_uid: :param should_delete: :param _t: :return: """ logger('review.opinions', 'main') db_user_created_flag = DBDiscussionSession.query(User).get( db_review.detector_uid) # add new vote __add_vote_for(db_user, db_review, not should_delete, LastReviewerDelete) broke_limit = False # get all keep and delete votes count_of_keep, count_of_delete = __get_review_count( LastReviewerDelete, db_review.uid) logger('review.opinions', 'result ' + str(count_of_keep) + ':' + str(count_of_delete)) # do we reached any limit? reached_max = max(count_of_keep, count_of_delete) >= max_votes if reached_max: if count_of_delete > count_of_keep: # disable the flagged part logger('review.opinions', 'max reached / delete for review {}'.format(db_review.uid)) set_able_object_of_review(db_review, True) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_success_flag) else: # just close the review logger('review.opinions', 'max reached / keep for review {}'.format(db_review.uid)) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_bad_flag) db_review.set_executed(True) db_review.update_timestamp() elif count_of_keep - count_of_delete >= min_difference: # just close the review logger('review.opinions', 'vote says keep for review {}'.format(db_review.uid)) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_bad_flag) db_review.set_executed(True) db_review.update_timestamp() elif count_of_delete - count_of_keep >= min_difference: # disable the flagged part logger('review.opinions', 'vote says delete for review {}'.format(db_review.uid)) set_able_object_of_review(db_review, True) add_rep, broke_limit = add_reputation_for(db_user_created_flag, rep_reason_success_flag) db_review.set_executed(True) db_review.update_timestamp() DBDiscussionSession.add(db_review) DBDiscussionSession.flush() transaction.commit() if broke_limit: send_request_for_info_popup_to_socketio( db_user_created_flag.nickname, _t.get(_.youAreAbleToReviewNow), main_page + '/review') return True
def create_speechbubble_dict(bubble_type: BubbleTypes, is_markable: bool = False, is_author: bool = False, uid: str = '', bubble_url: str = '', content: str = '', omit_bubble_url: bool = False, omit_vote_info: bool = False, argument_uid: int = None, statement_uid: int = None, is_supportive: bool = False, db_user: User = None, lang: str = 'en', is_users_opinion: bool = False, other_author: User = None): """ Creates an dictionary which includes every information needed for a bubble. :param bubble_type: BubbleTypes :param is_markable: True if the content itself could be flagged :param is_author: True if the current user is author of the content :param uid: Identifier for the bubble :param bubble_url: URL for the click event of the bubble :param content: Text of the bubble :param omit_bubble_url: True if the bubble should have a link :param omit_vote_info: True if the bubble have the little, grey information text :param argument_uid: Argument.uid :param statement_uid: Statement.uid :param is_supportive: Boolean :param db_user: current :param omit_bubble_url: Boolean :param lang: is_users_opinion :param is_users_opinion: Boolean :param other_author: :return: dict() """ gravatar_link = get_global_url() + '/static/images/icon.png' profile = None is_enemy_user = { 'admin': False, 'author': False, 'special': False } if uid != 'now': content = pretty_print_options(content) if bubble_type is BubbleTypes.SYSTEM and other_author is not None: gravatar_link = get_profile_picture(other_author, 25) profile = '/user/{}'.format(other_author.uid), is_enemy_user['admin'] = other_author.is_admin() is_enemy_user['author'] = other_author.is_author() is_enemy_user['special'] = other_author.is_special() # check for users opinion if bubble_type is BubbleTypes.USER and db_user and db_user.nickname != nick_of_anonymous_user: db_marked = None gravatar_link = get_profile_picture(db_user, 25) if argument_uid is not None and db_user is not None: db_marked = DBDiscussionSession.query(MarkedArgument).filter( MarkedArgument.argument_uid == argument_uid, MarkedArgument.author_uid == db_user.uid).first() if statement_uid is not None and db_user is not None: db_marked = DBDiscussionSession.query(MarkedStatement).filter( MarkedStatement.statement_uid == statement_uid, MarkedStatement.author_uid == db_user.uid).first() is_users_opinion = db_marked is not None speech = { 'is_user': bubble_type is BubbleTypes.USER, 'is_system': bubble_type is BubbleTypes.SYSTEM, 'is_status': bubble_type is BubbleTypes.STATUS, 'is_info': bubble_type is BubbleTypes.INFO, 'is_markable': is_markable, 'is_author': is_author, 'is_enemy_user': is_enemy_user, 'id': uid if len(str(uid)) > 0 else uuid4().hex, 'bubble_url': bubble_url, 'message': content, 'omit_bubble_url': omit_bubble_url, 'omit_vote_info': omit_vote_info, 'data_type': 'argument' if argument_uid else 'statement' if statement_uid else 'None', 'data_argument_uid': argument_uid, 'data_statement_uid': statement_uid, 'data_is_supportive': is_supportive, 'is_users_opinion': is_users_opinion, 'enemy': { 'avatar': gravatar_link, 'profile': profile, 'available': profile is not None } } votecount_keys = __get_text_for_click_and_mark_count(db_user, bubble_type is BubbleTypes.USER, argument_uid, statement_uid, speech, lang) speech['votecounts_message'] = votecount_keys[speech['votecounts']] return speech
def __proposal_for_the_element(db_review, data, db_user): """ Adds proposal for the ReviewEdit :param db_review: ReviewEdit :param data: String :param db_user: User :return: None """ # sort the new edits by argument uid argument_dict, statement_dict = __prepare_dicts_for_proposals(data) logger( 'review.opinions', 'detector {}, statements {}, arguments {}'.format( db_user.uid, statement_dict, argument_dict)) # add reviews new_edits = list() for argument_uid in argument_dict: DBDiscussionSession.add( ReviewEdit(detector=db_user.uid, argument=argument_uid)) DBDiscussionSession.flush() transaction.commit() db_review_edit = DBDiscussionSession.query(ReviewEdit).filter( ReviewEdit.detector_uid == db_user.uid, ReviewEdit.argument_uid == argument_uid).order_by( ReviewEdit.uid.desc()).first() logger( 'review.opinions', 'New ReviewEdit with uid ' + str(db_review_edit.uid) + ' (argument)') for edit in argument_dict[argument_uid]: new_edits.append( ReviewEditValue(review_edit=db_review_edit.uid, statement=edit['uid'], typeof=edit['type'], content=edit['val'])) for statement_uid in statement_dict: DBDiscussionSession.add( ReviewEdit(detector=db_user.uid, statement=statement_uid)) DBDiscussionSession.flush() transaction.commit() db_review_edit = DBDiscussionSession.query(ReviewEdit).filter( ReviewEdit.detector_uid == db_user.uid, ReviewEdit.statement_uid == statement_uid).order_by( ReviewEdit.uid.desc()).first() logger( 'review.opinions', 'New ReviewEdit with uid ' + str(db_review_edit.uid) + ' (statement)') for edit in statement_dict[statement_uid]: new_edits.append( ReviewEditValue(review_edit=db_review_edit.uid, statement=statement_uid, typeof=edit['type'], content=edit['val'])) if len(new_edits) > 0: DBDiscussionSession.add_all(new_edits) # edit given, so this review is executed db_review.set_executed(True) db_review.update_timestamp() DBDiscussionSession.add(db_review) DBDiscussionSession.flush() transaction.commit()
def setUp(self): self.config = testing.setUp() self.config.include('pyramid_chameleon') self.issue_disabled: Issue = DBDiscussionSession.query(Issue).get(6) self.issue_read_only: Issue = DBDiscussionSession.query(Issue).get(7) self.issue_cat_or_dog: Issue = DBDiscussionSession.query(Issue).get(2) self.issue_town: Issue = DBDiscussionSession.query(Issue).get(1) self.position_cat_or_dog: Statement = DBDiscussionSession.query( Statement).get(2) self.position_town: Statement = DBDiscussionSession.query( Statement).get(36) self.statement_cat_or_dog: Statement = DBDiscussionSession.query( Statement).get(5) self.statement_town: Statement = DBDiscussionSession.query( Statement).get(40) self.statement_argument_town: Statement = DBDiscussionSession.query( Statement).get(39) self.argument_town: Argument = DBDiscussionSession.query(Argument).get( 34) self.argument_cat_or_dog: Argument = DBDiscussionSession.query( Argument).get(2) self.user_anonymous: User = DBDiscussionSession.query(User).get(1) self.user_tobi: User = DBDiscussionSession.query(User).get(2) self.user_christian: User = DBDiscussionSession.query(User).get(3) self.user_bjoern: User = DBDiscussionSession.query(User).get(4) DBDiscussionSession.query(Argument).get(1).set_disabled(True) transaction.commit()
def __split_premisegroup(review): """ Splits a premisegroup into the items, which are mapped with the given review :param review: ReviewSplit.uid :return: None """ db_values = DBDiscussionSession.query(ReviewSplitValues).filter_by( review_uid=review.uid).all() db_old_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=review.premisegroup_uid).all() db_issue = DBDiscussionSession.query(Issue).get( db_old_premises[0].issue_uid) db_old_statement_ids = [p.statement_uid for p in db_old_premises] db_first_old_statement = DBDiscussionSession.query(Statement).get( db_old_premises[0].uid) db_user = DBDiscussionSession.query(User).get(review.detector_uid) if db_values: logger('review.opinions', 'split given premisegroup into the mapped, new statements') db_statements = [] for value in db_values: new_statement, tmp = set_statement( value.content, db_user, db_first_old_statement.is_position, db_issue) db_statements.append(new_statement) else: logger('review.opinions', 'just split the premisegroup') db_statements = DBDiscussionSession.query(Statement).filter( Statement.uid.in_(db_old_statement_ids)).all() # new premisegroups, for each statement a new one new_premisegroup_ids = [] new_premise_ids = [] for statement in db_statements: db_new_premisegroup = PremiseGroup(author=db_user.uid) DBDiscussionSession.add(db_new_premisegroup) DBDiscussionSession.flush() new_premisegroup_ids.append(db_new_premisegroup.uid) db_new_premise = Premise(db_new_premisegroup.uid, statement.uid, False, db_user.uid, statement.issue_uid) DBDiscussionSession.add(db_new_premise) DBDiscussionSession.flush() new_premise_ids.append(db_new_premise.uid) # note new added pgroup DBDiscussionSession.add( PremiseGroupSplitted(review.uid, review.premisegroup_uid, db_new_premisegroup.uid)) # swap the premisegroup occurence in every argument and add new arguments for the new premises db_arguments = DBDiscussionSession.query(Argument).filter_by( premisegroup_uid=review.premisegroup_uid).all() for argument in db_arguments: argument.set_premisegroup(new_premisegroup_ids[0]) DBDiscussionSession.add(argument) for uid in new_premisegroup_ids[1:]: argument = Argument(uid, argument.is_supportive, argument.author_uid, argument.issue_uid, argument.conclusion_uid, argument.argument_uid, argument.is_disabled) DBDiscussionSession.add(argument) DBDiscussionSession.flush() DBDiscussionSession.add( ArgumentsAddedByPremiseGroupSplit(review.uid, argument.uid)) # swap the conclusion in every argument new_statements_uids = [s.uid for s in db_statements] for old_statement_uid in db_old_statement_ids: db_arguments = DBDiscussionSession.query(Argument).filter_by( conclusion_uid=old_statement_uid).all() for argument in db_arguments: argument.set_conclusion(new_statements_uids[0]) DBDiscussionSession.add(argument) DBDiscussionSession.add( StatementReplacementsByPremiseGroupSplit( review.uid, old_statement_uid, new_statements_uids[0])) DBDiscussionSession.flush() for statement_uid in new_statements_uids[1:]: db_argument = Argument(argument.premisegroup_uid, argument.is_supportive, argument.author_uid, argument.issue_uid, statement_uid, argument.argument_uid, argument.is_disabled) DBDiscussionSession.add(db_argument) DBDiscussionSession.add( StatementReplacementsByPremiseGroupSplit( review.uid, old_statement_uid, statement_uid)) DBDiscussionSession.flush() # finish DBDiscussionSession.flush() transaction.commit()
def update_last_action(event: NewResponse): user = DBDiscussionSession.query(User).filter_by( nickname=event.request.authenticated_userid).first() if user is not None: user.update_last_action()