def get_issue_dict_for(db_issue: Issue, uid: int, lang: str) -> dict: """ Creates an dictionary for the issue :param db_issue: Issue :param uid: current selected Issue.uid :param lang: ui_locales :return: dict() """ _um = UrlManager(db_issue.slug) issue_dict = { 'uid': str(db_issue.uid), 'slug': db_issue.slug, 'title': db_issue.title, 'url': '/' + db_issue.slug, 'review_url': _um.get_review_url() if str(uid) != str(db_issue.uid) else '', 'info': db_issue.info, 'stat_count': get_number_of_statements(db_issue.uid), 'date': sql_timestamp_pretty_print(db_issue.date, lang), 'author': db_issue.author.public_nickname, 'error': '', 'author_url': '/user/{}'.format(db_issue.author.uid), 'enabled': 'disabled' if str(uid) == str(db_issue.uid) else 'enabled' } return issue_dict
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_statements_with_value(issue_uid: int, search_value: str = '') -> list: """ This method returns statements fitting the given parametes. It returns the result as a list of single dicts containing the information of each result with the data: text, statement_uid, content, score, url. :param issue_uid: uid of the issue to search in :param search_value: the position of the statement :return: statements fitting a certain text """ query = get_statements_with_value_path(issue_uid, search_value) slug = DBDiscussionSession.query(Issue).get(issue_uid).slug _um = UrlManager(slug=slug) results = [] current_results = response_as_dict(query)['result'] if current_results is not None: results = list( map( lambda res: { 'text': res['text'], 'statement_uid': res['statement_uid'], 'html': res['html'], 'score': res['score'], 'url': _um.get_url_for_statement_attitude(res[ 'statement_uid']) }, current_results)) return results
def get_all_statements_with_value(search_value: str, issue_uid: int) -> list: """ Returns all statements matching the given search_value :param issue_uid: uid of the issue to be searched in :param search_value: text to be searched for :return: statements matching the given search value in the given issue, uses levensthein. """ issues_statements_uids = [ el.statement_uid for el in DBDiscussionSession.query(StatementToIssue).filter_by( issue_uid=issue_uid).all() ] db_statements = get_enabled_statement_as_query().filter( Statement.uid.in_(issues_statements_uids)).all() return_array = [] slug = DBDiscussionSession.query(Issue).get(issue_uid).slug _um = UrlManager(slug=slug) for stat in db_statements: db_tv = DBDiscussionSession.query(TextVersion).filter_by( statement_uid=stat.uid).order_by(TextVersion.uid.asc()).first() if search_value.lower() in db_tv.content.lower(): rd = __get_fuzzy_string_dict(current_text=search_value, return_text=db_tv.content, uid=db_tv.statement_uid) rd['url'] = _um.get_url_for_statement_attitude(db_tv.statement_uid) return_array.append(rd) return_array = __sort_array(return_array) return return_array[:RESULT_LENGTH]
def url_to_statement(issue_uid, statement_uid, agree=True): """ Generate URL to given statement_uid in specific issue (by slug). Used to directly jump into the discussion. :param issue_uid: uid of current issue :type issue_uid: id :param statement_uid: Statement id to generate the link to :type statement_uid: int :param agree: Indicate (dis-)agreement with a statement :type agree: boolean :return: direct URL to jump to the provided statement :rtype: str """ if isinstance(agree, str): if agree == "true": mode = "agree" else: mode = "disagree" else: mode = "agree" if agree is True else "disagree" slug = resolve_issue_uid_to_slug(issue_uid) url_manager = UrlManager(slug=slug) return "api/" + url_manager.get_url_for_justifying_statement( statement_uid, mode)
def set_position(db_user: User, db_issue: Issue, statement_text: str) -> dict: """ Set new position for current discussion and returns collection with the next url for the discussion. :param statement_text: The text of the new position statement. :param db_issue: The issue which gets the new position :param db_user: The user who sets the new position. :rtype: dict :return: Prepared collection with statement_uids of the new positions and next url or an error """ logger('StatementsHelper', statement_text) user.update_last_action(db_user) new_statement = insert_as_statement(statement_text, db_user, db_issue, is_start=True) _um = UrlManager(db_issue.slug) url = _um.get_url_for_statement_attitude(new_statement.uid) add_rep, broke_limit = add_reputation_for(db_user, rep_reason_first_position) if not add_rep: add_rep, broke_limit = add_reputation_for(db_user, rep_reason_new_statement) # send message if the user is now able to review if broke_limit: url += '#access-review' return { 'status': 'success', 'url': 'url', 'statement_uids': [new_statement.uid], 'error': '' }
def prepare_item_dict_for_attitude(self, statement_uid): """ Prepares the dict with all items for the second step in discussion, where the user chooses her attitude. :param statement_uid: Statement.uid :return: """ logger('ItemDictHelper', 'def') _tn = Translator(self.lang) slug = DBDiscussionSession.query(Issue).get(self.db_issue.uid).slug statements_array = [] _um = UrlManager(slug, history=self.path) db_arguments = DBDiscussionSession.query(Argument).filter( Argument.conclusion_uid == statement_uid, Argument.is_supportive == True).all() uid = random.choice(db_arguments).uid if len(db_arguments) > 0 else 0 title_t = _tn.get(_.iAgreeWithInColor) + '.' title_f = _tn.get(_.iDisagreeWithInColor) + '.' title_d = _tn.get(_.iHaveNoOpinionYetInColor) + '.' url_t = _um.get_url_for_justifying_statement(statement_uid, Attitudes.AGREE.value) url_f = _um.get_url_for_justifying_statement(statement_uid, Attitudes.DISAGREE.value) url_d = _um.get_url_for_justifying_statement(uid, Attitudes.DONT_KNOW.value) d_t = self.__create_answer_dict(Attitudes.AGREE.value, [{ 'title': title_t, 'id': Attitudes.AGREE.value }], Attitudes.AGREE.value, url_t) d_f = self.__create_answer_dict(Attitudes.DISAGREE.value, [{ 'title': title_f, 'id': Attitudes.DISAGREE.value }], Attitudes.DISAGREE.value, url_f) d_d = self.__create_answer_dict(Attitudes.DONT_KNOW.value, [{ 'title': title_d, 'id': Attitudes.DONT_KNOW.value }], Attitudes.DONT_KNOW.value, url_d) statements_array.append(d_t) statements_array.append(d_f) statements_array.append(d_d) return { 'elements': statements_array, 'extras': { 'cropped_list': False } }
def set_position(db_user: User, db_issue: Issue, statement_text: str, feature_data: dict = {}) -> dict: """ Set new position for current discussion and returns collection with the next url for the discussion. :param statement_text: The text of the new position statement. :param db_issue: The issue which gets the new position :param db_user: The user who sets the new position. :param feature_data: More data which is used by additional features :rtype: dict :return: Prepared collection with statement_uids of the new positions and next url or an error """ LOG.debug("%s", statement_text) new_statement: Statement = insert_as_statement(statement_text, db_user, db_issue, is_start=True) if db_issue.decision_process: dp = db_issue.decision_process if 'decidotron_cost' not in feature_data: transaction.abort() LOG.error('Cost missing for an issue with a decision_process') return { 'status': 'fail', # best error management 'errors': 'Cost missing for an issue with a decision_process' } else: cost = int(float(feature_data['decidotron_cost'])) if dp.min_position_cost <= cost <= (dp.max_position_cost or dp.budget) and not dp.position_ended(): add_associated_cost(db_issue, new_statement, cost) else: transaction.abort() LOG.error( f'Cost has to be {dp.min_position_cost} <= cost <= {dp.max_position_cost or dp.budget}. cost is: {cost}') return { 'status': 'fail', 'errors': f'Cost has to be {dp.min_position_cost} <= cost <= {dp.max_position_cost or dp.budget}.' } _um = UrlManager(db_issue.slug) url = _um.get_url_for_statement_attitude(new_statement.uid) rep_added = add_reputation_for(db_user, get_reason_by_action(ReputationReasons.first_position)) had_access = has_access_to_review_system(db_user) if not rep_added: add_reputation_for(db_user, get_reason_by_action(ReputationReasons.new_statement)) broke_limit = has_access_to_review_system(db_user) and not had_access if broke_limit: url += '#access-review' return { 'status': 'success', 'url': url, 'statement_uids': [new_statement.uid], 'errors': '' }
def get_array_for_reaction(self, argument_uid_sys, argument_uid_user, is_supportive, attack, gender): """ Prepares the dict with all items for the argumentation window. :param argument_uid_sys: Argument.uid :param argument_uid_user: Argument.uid :param is_supportive: Boolean :param attack: String :param gender: Gender of the author of the attack :return: """ LOG.debug("Entering get_array_for_reaction") slug = self.db_issue.slug db_sys_argument = DBDiscussionSession.query(Argument).get(argument_uid_sys) db_user_argument = DBDiscussionSession.query(Argument).get(argument_uid_user) statements_array = [] if not db_sys_argument or not db_user_argument: return {'elements': statements_array, 'extras': {'cropped_list': False}} rel_dict = get_relation_text_dict_with_substitution(self.lang, True, attack_type=attack, gender=gender) mode = Attitudes.AGREE if is_supportive else Attitudes.DISAGREE _um = UrlManager(slug, history=self.path) relations = [relation for relation in Relations] for relation in relations: url = self.__get_url_based_on_relation(relation, attack, _um, mode, db_user_argument, db_sys_argument) d = {'title': rel_dict[relation.value + '_text'], 'id': relation.value} tmp = self.__create_answer_dict(relation.value, [d], relation.value, url) statements_array.append(tmp) # last item is the change attack button or step back, if we have bno other attack attacking_arg_uids = get_all_attacking_arg_uids_from_history(self.path) attacking_arg_uids.append(argument_uid_sys) arg_id_sys, new_attack = attacks.get_attack_for_argument(argument_uid_user, restrictive_arg_uids=attacking_arg_uids, history=self.path) if not new_attack: url = _um.get_last_valid_url_before_reaction() relation = 'step_back' else: relation = 'no_opinion' url = _um.get_url_for_reaction_on_argument(argument_uid_user, new_attack, arg_id_sys) statements_array.append( self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation, url)) return {'elements': statements_array, 'extras': {'cropped_list': False}}
def get_array_for_choosing(self, argument_or_statement_id, pgroup_ids, is_argument, is_supportive, nickname): """ Prepares the dict with all items for the choosing an premise, when the user inserted more than one new premise. :param argument_or_statement_id: Argument.uid or Statement.uid :param pgroup_ids: PremiseGroups.uid :param is_argument: Boolean :param is_supportive: Boolean :param nickname: :return: dict() """ LOG.debug("Entering get_array_for_choosing") statements_array = [] slug = self.db_issue.slug _um = UrlManager(slug, history=self.path) conclusion_uid = argument_or_statement_id if not is_argument else None argument_uid = argument_or_statement_id if is_argument else None db_user = DBDiscussionSession.query(User).filter_by(nickname=nickname).first() for group_id in pgroup_ids: sarray = self.__get_choose_array_for_pgroup(is_argument, is_supportive, conclusion_uid, argument_uid, db_user, group_id, _um) if not sarray: return {'elements': statements_array, 'extras': {'cropped_list': False}} statements_array.append(sarray) return {'elements': statements_array, 'extras': {'cropped_list': False}}
def __get_choose_array_for_pgroup(self, is_argument: bool, is_supportive: bool, conclusion_uid: int, argument_uid: int, db_user: User, group_id: int, _um: UrlManager): db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=group_id).all() premise_array = [] for premise in db_premises: text = premise.get_text() premise_array.append({'title': text, 'id': premise.statement_uid}) if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible add_seen_statement(premise.statement_uid, db_user) # get attack for each premise, so the urls will be unique db_argument = DBDiscussionSession.query(Argument).filter(Argument.premisegroup_uid == group_id, Argument.is_supportive == is_supportive) if conclusion_uid and not is_argument: db_argument = db_argument.filter_by(conclusion_uid=conclusion_uid).first() else: db_argument = db_argument.filter_by(argument_uid=argument_uid).first() if not db_argument: return None attacking_arg_uids = get_all_attacking_arg_uids_from_history(self.path) arg_id_sys, attack = attacks.get_attack_for_argument(db_argument.uid, restrictive_arg_uids=attacking_arg_uids) url = _um.get_url_for_reaction_on_argument(db_argument.uid, attack, arg_id_sys) if is_argument: is_author = is_author_of_argument(db_user, argument_uid) else: is_author = is_author_of_statement(db_user, conclusion_uid) return self.__create_answer_dict(str(db_argument.uid), premise_array, 'choose', url, is_markable=True, is_editable=True, is_author=is_author)
def __set_url_of_start_premises(prepared_dict: dict, db_conclusion: Statement, supportive: bool, db_issue: Issue, db_user: User, history, mailer): LOG.debug("Entering __set_url_of_start_premises") # arguments=0: empty input # arguments=1: deliver new url # arguments>1: deliver url where the user has to choose between her inputs _um = UrlManager(db_issue.slug, history) _main_um = UrlManager(db_issue.slug, history=history) new_argument_uids = prepared_dict['argument_uids'] if len(new_argument_uids) == 1: url = _um.get_url_for_new_argument(new_argument_uids) else: pgroups = [ DBDiscussionSession.query(Argument).get(arg_uid).premisegroup_uid for arg_uid in new_argument_uids ] url = _um.get_url_for_choosing_premisegroup(False, supportive, db_conclusion.uid, pgroups) # send notifications and mails email_url = _main_um.get_url_for_justifying_statement( db_conclusion.uid, Attitudes.AGREE if supportive else Attitudes.DISAGREE) nh.send_add_text_notification(email_url, db_conclusion.uid, db_user, mailer) prepared_dict['url'] = url
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 get_arguments_by_statement_uid(db_statement: Statement, db_issue: Issue) -> dict: """ Collects every argument which uses the given statement :param db_statement: Statement :param db_issue: issue :rtype: dict :return: prepared collection with several arguments """ slug = resolve_issue_uid_to_slug(db_issue.uid) _um = UrlManager(slug) return {'arguments': get_all_arguments_with_text_and_url_by_statement_id(db_statement, _um, True, is_jump=True)}
def get_array_for_dont_know_reaction(self, argument_uid, db_user, gender): """ Prepares the dict with all items for the third step, where a supportive argument will be presented. :param argument_uid: Argument.uid :param db_user: User :param gender: m, f or n :return: """ LOG.debug("Entering get_array_for_dont_know_reaction") slug = self.db_issue.slug statements_array = [] db_arguments = get_enabled_arguments_as_query() db_argument = db_arguments.filter_by(uid=argument_uid).first() if not db_argument: return {'elements': statements_array, 'extras': {'cropped_list': False}} # set real argument in history tmp_path = self.path.replace('/justify/{}/d'.format(db_argument.conclusion_uid), '/justify/{}/d'.format(argument_uid)) _um = UrlManager(slug, history=tmp_path) if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible add_seen_argument(argument_uid, db_user) rel_dict = get_relation_text_dict_with_substitution(self.lang, False, is_dont_know=True, gender=gender) relation = Relations.UNDERMINE.value url = self.__get_dont_know_item_for_undermine(db_argument, Attitudes.DISAGREE, _um) d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation, url) statements_array.append(d) relation = Relations.SUPPORT.value url = self.__get_dont_know_item_for_support(argument_uid, _um) d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation, url) statements_array.append(d) relation = Relations.UNDERCUT.value url = self.__get_dont_know_item_for_undercut(argument_uid, Attitudes.AGREE, _um) d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation, url) statements_array.append(d) relation = Relations.REBUT.value url = self.__get_dont_know_item_for_rebut(db_argument, Attitudes.DISAGREE, _um) d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation, url) statements_array.append(d) return {'elements': statements_array, 'extras': {'cropped_list': False}}
def test_mail_for_justifying_statement(self): url = UrlManager(slug='cat-or-dog') url = url.get_url_for_justifying_statement(statement_uid=123, attitude=Attitudes.AGREE) for language, for_html in list( itertools.product(['de', 'en'], [True, False])): subject = "Test Mail" body = get_text_for_message( nickname=DummyUser().firstname, lang=language, path=url, message_content=_.statementAddedMessageContent, for_html=for_html) was_send, was_send_msg, msg = send_mail( mailer=DummyMailer, subject=subject, body=body, recipient=DummyUser().email, lang=language) self.assertTrue(was_send) self.assertEqual(msg.body, body)
def test_mail_for_reaction_on_argument(self): url = UrlManager(slug='cat-or-dog') url = url.get_url_for_reaction_on_argument(argument_uid=123, relation=Relations.REBUT, confrontation_argument=35) for language, for_html in list( itertools.product(['de', 'en'], [True, False])): subject = "Test Mail" body = get_text_for_message( nickname=DummyUser().firstname, lang=language, path=url, message_content=_.argumentAddedMessageContent, for_html=for_html) was_send, was_send_msg, msg = send_mail( mailer=DummyMailer, subject=subject, body=body, recipient=DummyUser().email, lang=language) self.assertTrue(was_send) self.assertEqual(msg.body, body)
def test_get_all_arguments_with_text_and_url_by_statement_id(self): um = UrlManager(slug='slug') results = { 47: 'we should close public swimming pools because our swimming pools are very old and it would take a major investment to repair them', 48: 'Someone 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 said that schools need the swimming pools for their sports lessons.', 49: 'we should close public swimming pools does not hold, because the rate of non-swimmers is too high' } db_statement = DBDiscussionSession.query(Statement).get(38) res = lib.get_all_arguments_with_text_and_url_by_statement(db_statement, um) self.assertEqual(len(res), 3) for r in res: self.assertIn(r['uid'], results)
def set_position(db_user: User, db_issue: Issue, statement_text: str) -> dict: """ Set new position for current discussion and returns collection with the next url for the discussion. :param statement_text: The text of the new position statement. :param db_issue: The issue which gets the new position :param db_user: The user who sets the new position. :rtype: dict :return: Prepared collection with statement_uids of the new positions and next url or an error """ LOG.debug("%s", statement_text) user.update_last_action(db_user) new_statement: Statement = insert_as_statement(statement_text, db_user, db_issue, is_start=True) _um = UrlManager(db_issue.slug) url = _um.get_url_for_statement_attitude(new_statement.uid) rep_added = add_reputation_for( db_user, get_reason_by_action(ReputationReasons.first_position)) had_access = has_access_to_review_system(db_user) if not rep_added: add_reputation_for( db_user, get_reason_by_action(ReputationReasons.new_statement)) broke_limit = has_access_to_review_system(db_user) and not had_access if broke_limit: url += '#access-review' return { 'status': 'success', 'url': url, 'statement_uids': [new_statement.uid], 'error': '' }
def test_get_all_arguments_with_text_and_url_by_statement_id_with_color(self): um = UrlManager(slug='slug') results = { 47: '<span data-argumentation-type="position">we should close public swimming pools</span> because our swimming pools are very old and it would take a major investment to repair them', 48: 'Someone argued that <span data-argumentation-type="position">we should close public swimming pools</span> because our swimming pools are very old and it would take a major investment to repair them. Other participants said that schools need the swimming pools for their sports lessons.', 49: '<span data-argumentation-type="position">we should close public swimming pools</span> does not hold, because the rate of non-swimmers is too high' } db_statement = DBDiscussionSession.query(Statement).get(38) res = lib.get_all_arguments_with_text_and_url_by_statement_id(db_statement, um, color_statement=True) self.assertEqual(3, len(res)) for r in res: self.assertIn(r['uid'], results) self.assertEqual(results[r['uid']], r['text'])
def test_get_all_arguments_with_text_and_url_by_statement_id_with_color_and_jump(self): um = UrlManager(slug='slug') results = { 47: '<span data-argumentation-type="position">we should close public swimming pools</span> because our swimming pools are very old and it would take a major investment to repair them.', 48: 'our swimming pools are very old and it would take a major investment to repair them is not a good reason for <span data-argumentation-type="position">we should close public swimming pools</span>. Because schools need the swimming pools for their sports lessons.', 49: '<span data-argumentation-type="position">we should close public swimming pools</span> does not hold because the rate of non-swimmers is too high.' } db_statement = DBDiscussionSession.query(Statement).get(38) res = lib.get_all_arguments_with_text_and_url_by_statement(db_statement, um, color_statement=True, is_jump=True) self.assertEqual(len(res), 3) for r in res: self.assertIn(r['uid'], results) self.assertIn('jump', r['url']) self.assertEqual(results[r['uid']], r['text'])
def get_arguments_by_statement(statement: Statement, issue: Issue) -> dict: """ Collects every argument which uses the given statement. :param statement: Statement which is used for query :param issue: Extract information for url manager from issue :rtype: dict :return: prepared collection with several arguments """ _um = UrlManager(issue.slug) return { 'arguments': get_all_arguments_with_text_and_url_by_statement(statement, _um, True, is_jump=True) }
def get_array_for_justify_argument(self, argument_uid, attack_type, db_user, history): """ Prepares the dict with all items for a step in discussion, where the user justifies his attack she has done. :param argument_uid: Argument.uid :param attack_type: String :param db_user: :param history: :return: """ LOG.debug("Entering get_array_for_justify_argument with arg %s anf attack %s", argument_uid, attack_type) statements_array = [] _tn = Translator(self.lang) slug = self.db_issue.slug # description in docs: dbas/logic db_arguments = self.__get_arguments_based_on_attack(attack_type, argument_uid) uids = [argument.uid for argument in db_arguments if db_arguments] _um = UrlManager(slug, history=self.path) for argument in db_arguments: sarray = self.__get_statement_array_for_justify_argument(argument_uid, attack_type, db_user, history, argument, uids, _um) statements_array.append(sarray) shuffle_list_by_user(db_user, statements_array) if not self.issue_read_only: if db_user and db_user.nickname != nick_of_anonymous_user: text = _tn.get(_.newPremiseRadioButtonText) if len(statements_array) == 0: text = _tn.get(_.newPremiseRadioButtonTextAsFirstOne) a_dict = self.__create_answer_dict('justify_premise', [{'id': '0', 'title': text}], 'justify', 'add') statements_array.append(a_dict) else: # elif len(statements_array) == 1: a_dict = self.__create_answer_dict('login', [{'id': '0', 'title': _tn.get(_.onlyOneItem)}], 'justify', 'login') statements_array.append(a_dict) return {'elements': statements_array, 'extras': {'cropped_list': len(uids) < len(db_arguments)}}
def get_array_for_justify_statement(self, db_statement: Statement, db_user: User, is_supportive: bool, history): """ Prepares the dict with all items for the third step in discussion, where the user justifies his position. :param db_statement: Statement :param db_user: User :param is_supportive: Boolean :param history: history :return: """ LOG.debug("Entering get_array_for_justify_statement") statements_array = [] _tn = Translator(self.lang) slug = self.db_issue.slug db_arguments: List[Argument] = attacks.get_arguments_by_conclusion(db_statement.uid, is_supportive) uids: List[int] = [argument.uid for argument in db_arguments if db_arguments] _um = UrlManager(slug, history=self.path) for argument in db_arguments: sarray = self.__get_statement_array_for_justify_statement(db_user, history, argument, uids, _tn, _um) statements_array.append(sarray) shuffle_list_by_user(db_user, statements_array) if not self.issue_read_only: if db_user and db_user.nickname != nick_of_anonymous_user: statements_array.append(self.__create_answer_dict('start_premise', [{ 'title': _tn.get(_.newPremiseRadioButtonText), 'id': 0 }], 'justify', 'add')) else: statements_array.append(self.__create_answer_dict('login', [{'id': '0', 'title': _tn.get(_.onlyOneItem)}], 'justify', 'login')) return {'elements': statements_array, 'extras': {'cropped_list': len(uids) < len(db_arguments)}}
def get_array_for_justify_argument(self, argument_uid, attack_type, db_user, history): """ Prepares the dict with all items for a step in discussion, where the user justifies his attack she has done. :param argument_uid: Argument.uid :param attack_type: String :param db_user: :param history: :return: """ logger('ItemDictHelper', 'def: arg {}, attack {}'.format(argument_uid, attack_type)) statements_array = [] _tn = Translator(self.lang) slug = self.db_issue.slug # description in docs: dbas/logic db_arguments = self.__get_arguments_based_on_attack( attack_type, argument_uid) uids = [argument.uid for argument in db_arguments if db_arguments] _um = UrlManager(slug, history=self.path) for argument in db_arguments: if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible add_seen_argument(argument_uid, db_user) # get all premises in this group db_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=argument.premisegroup_uid).all() premises_array = [] for premise in db_premises: text = premise.get_text() premises_array.append({ 'id': premise.statement_uid, 'title': text }) # for each justifying premise, we need a new confrontation: (restriction is based on fix #38) is_undermine = Relations.UNDERMINE if attack_type == Relations.UNDERMINE else None attacking_arg_uids = get_all_attacking_arg_uids_from_history( self.path) arg_id_sys, attack = attacks.get_attack_for_argument( argument.uid, last_attack=is_undermine, restrictive_arg_uids=attacking_arg_uids, history=self.path) the_other_one = True url = '' # with a chance of 50% or at the end we will seed the new "support step" if not attack: new_arg = get_another_argument_with_same_conclusion( argument.uid, history) the_other_one = new_arg is None if new_arg: the_other_one = False url = _um.get_url_for_support_each_other( argument.uid, new_arg.uid) if the_other_one: url = _um.get_url_for_reaction_on_argument( argument.uid, attack, arg_id_sys) statements_array.append( self.__create_answer_dict( argument.uid, premises_array, 'justify', url, is_markable=True, is_editable=not is_arguments_premise_in_edit_queue( argument), is_author=is_author_of_argument(db_user, argument.uid), is_visible=argument.uid in uids, attack_url=_um.get_url_for_jump(argument.uid))) shuffle_list_by_user(db_user, statements_array) if not self.issue_read_only: if db_user and db_user.nickname != nick_of_anonymous_user: text = _tn.get(_.newPremiseRadioButtonText) if len(statements_array) == 0: text = _tn.get(_.newPremiseRadioButtonTextAsFirstOne) a_dict = self.__create_answer_dict('justify_premise', [{ 'id': '0', 'title': text }], 'justify', 'add') statements_array.append(a_dict) else: # elif len(statements_array) == 1: a_dict = self.__create_answer_dict( 'login', [{ 'id': '0', 'title': _tn.get(_.onlyOneItem) }], 'justify', 'login') statements_array.append(a_dict) return { 'elements': statements_array, 'extras': { 'cropped_list': len(uids) < len(db_arguments) } }
def get_dict_for_justify_statement(self, db_statement: Statement, slug, is_supportive, count_of_items, db_user: User): """ Prepares the discussion dict with all bubbles for the third step in discussion, where the user justifies his position. :param db_statement: Statement :param db_user: User :param slug: Issue.slug :param is_supportive: Boolean :param count_of_items: Integer :return: dict() """ LOG.debug("Entering get_dict_for_justify_statement") _tn = Translator(self.lang) bubbles_array = history_handler.create_bubbles(self.history, self.nickname, self.lang, self.slug) save_statement_url = 'set_new_start_statement' text = db_statement.get_text() if not text: return None tag_start = '<{} data-argumentation-type="position">'.format(tag_type) tag_end = '</{}>'.format(tag_type) # system bubble system_question = get_system_bubble_text_for_justify_statement( is_supportive, _tn, tag_start, text, tag_end) # user bubble nickname = db_user.nickname if db_user and db_user.nickname != nick_of_anonymous_user else None user_text, add_premise_text = get_user_bubble_text_for_justify_statement( db_statement.uid, db_user, is_supportive, _tn) question_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM, content=system_question, omit_bubble_url=True, lang=self.lang) url = UrlManager(slug).get_url_for_statement_attitude(db_statement.uid) select_bubble = create_speechbubble_dict( BubbleTypes.USER, bubble_url=url, content=user_text, omit_bubble_url=False, statement_uid=db_statement.uid, is_supportive=is_supportive, db_user=db_user, lang=self.lang) if not bubbles_already_last_in_list(bubbles_array, select_bubble): bubbles_array.append(select_bubble) self.__append_now_bubble(bubbles_array) if not bubbles_already_last_in_list(bubbles_array, question_bubble): bubbles_array.append(question_bubble) if not self.nickname and count_of_items == 1: _t = Translator(self.lang) db_user = DBDiscussionSession.query(User).filter_by( nickname=nickname).first() msg_dict = { 'm': _.voteCountTextFirstM, 'f': _.voteCountTextFirstF, 'n': _.voteCountTextFirst, } if db_user: msg = msg_dict[db_user.gender] else: msg = _.voteCountTextFirst msg = _t.get(msg) + '.' bubbles_array.append( create_speechbubble_dict(BubbleTypes.INFO, uid='now_first', content=msg + _tn.get(_.onlyOneItemWithLink), omit_bubble_url=True, lang=self.lang)) return { 'bubbles': bubbles_array, 'add_premise_text': add_premise_text, 'save_statement_url': save_statement_url, 'mode': '', 'is_supportive': is_supportive, 'broke_limit': self.broke_limit }
def get_array_for_justify_statement(self, db_statement: Statement, db_user: User, is_supportive: bool, history): """ Prepares the dict with all items for the third step in discussion, where the user justifies his position. :param db_statement: Statement :param db_user: User :param is_supportive: Boolean :param history: history :return: """ logger('ItemDictHelper', 'def') statements_array = [] _tn = Translator(self.lang) slug = self.db_issue.slug db_arguments: List[Argument] = attacks.get_arguments_by_conclusion( db_statement.uid, is_supportive) uids: List[int] = [ argument.uid for argument in db_arguments if db_arguments ] _um = UrlManager(slug, history=self.path) for argument in db_arguments: if db_user and argument.uid in uids: # add seen by if the statement is visible add_seen_argument(argument.uid, db_user) # get all premises in the premisegroup of this argument db_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=argument.premisegroup_uid).all() premise_array = [] for premise in db_premises: text = premise.get_text() premise_array.append({ 'title': text, 'id': premise.statement_uid }) # filter forbidden attacks forbidden_attacks = attacks.get_forbidden_attacks_based_on_history( self.path) # get attack for each premise, so the urls will be unique arg_id_sys, attack = attacks.get_attack_for_argument( argument.uid, history=self.path, restrictive_arg_uids=forbidden_attacks) already_used = 'reaction/' + str(argument.uid) + '/' in self.path additional_text = '(' + _tn.get(_.youUsedThisEarlier) + ')' new_arg = None url = None if not attack: new_arg = get_another_argument_with_same_conclusion( argument.uid, history) if new_arg: url = _um.get_url_for_support_each_other( argument.uid, new_arg.uid) if attack or new_arg is None or url is None: url = _um.get_url_for_reaction_on_argument( argument.uid, attack.value, arg_id_sys) statements_array.append( self.__create_answer_dict( str(argument.uid), premise_array, 'justify', url, already_used=already_used, already_used_text=additional_text, is_editable=not is_arguments_premise_in_edit_queue( argument), is_markable=True, is_author=is_author_of_argument(db_user, argument.uid), is_visible=argument.uid in uids, attack_url=_um.get_url_for_jump(argument.uid))) shuffle_list_by_user(db_user, statements_array) if not self.issue_read_only: if db_user and db_user.nickname != nick_of_anonymous_user: statements_array.append( self.__create_answer_dict( 'start_premise', [{ 'title': _tn.get(_.newPremiseRadioButtonText), 'id': 0 }], 'justify', 'add')) else: statements_array.append( self.__create_answer_dict( 'login', [{ 'id': '0', 'title': _tn.get(_.onlyOneItem) }], 'justify', 'login')) return { 'elements': statements_array, 'extras': { 'cropped_list': len(uids) < len(db_arguments) } }
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: """ logger('ItemDictHelper', 'def user: {}'.format(db_user.nickname)) db_statements = DBDiscussionSession.query(Statement) \ .filter(Statement.is_disabled == False, Statement.is_position == True, Statement.issue_uid == self.db_issue.uid).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) 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) statements_array.append( 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 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)) _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 get_array_for_choosing(self, argument_or_statement_id, pgroup_ids, is_argument, is_supportive, nickname): """ Prepares the dict with all items for the choosing an premise, when the user inserted more than one new premise. :param argument_or_statement_id: Argument.uid or Statement.uid :param pgroup_ids: PremiseGroups.uid :param is_argument: Boolean :param is_supportive: Boolean :param nickname: :return: dict() """ logger('ItemDictHelper', 'def') statements_array = [] slug = self.db_issue.slug _um = UrlManager(slug, history=self.path) conclusion_uid = argument_or_statement_id if not is_argument else None argument_uid = argument_or_statement_id if is_argument else None db_user = DBDiscussionSession.query(User).filter_by( nickname=nickname).first() for group_id in pgroup_ids: db_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=group_id).all() premise_array = [] for premise in db_premises: text = premise.get_text() premise_array.append({ 'title': text, 'id': premise.statement_uid }) if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible add_seen_statement(premise.statement_uid, db_user) # get attack for each premise, so the urls will be unique db_argument = DBDiscussionSession.query(Argument).filter( Argument.premisegroup_uid == group_id, Argument.is_supportive == is_supportive) if conclusion_uid and not is_argument: db_argument = db_argument.filter_by( conclusion_uid=conclusion_uid).first() else: db_argument = db_argument.filter_by( argument_uid=argument_uid).first() if not db_argument: print(group_id) return { 'elements': statements_array, 'extras': { 'cropped_list': False } } attacking_arg_uids = get_all_attacking_arg_uids_from_history( self.path) arg_id_sys, attack = attacks.get_attack_for_argument( db_argument.uid, restrictive_arg_uids=attacking_arg_uids) url = _um.get_url_for_reaction_on_argument(db_argument.uid, attack, arg_id_sys) if is_argument: is_author = is_author_of_argument(db_user, argument_uid) else: is_author = is_author_of_statement(db_user, conclusion_uid) statements_array.append( self.__create_answer_dict(str(db_argument.uid), premise_array, 'choose', url, is_markable=True, is_editable=True, is_author=is_author)) return { 'elements': statements_array, 'extras': { 'cropped_list': False } }
def __get_url_for_jump_array(self, slug, arg_uid): """ Returns urls for the answers to jump to an argument :param slug: String :param arg_uid: Argument.uid :return: dict() """ db_argument = DBDiscussionSession.query(Argument).get(arg_uid) _um = UrlManager(slug, history=self.path) db_premises = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=db_argument.premisegroup_uid).all() forbidden_attacks = attacks.get_forbidden_attacks_based_on_history( self.path) db_undercutted_arg = None len_undercut = 0 if db_argument.argument_uid is not None: db_undercutted_arg = DBDiscussionSession.query(Argument).get( db_argument.argument_uid) len_undercut = 1 if db_undercutted_arg.argument_uid is None else 2 arg_id_sys, sys_attack = attacks.get_attack_for_argument( db_argument.uid, redirected_from_jump=True, restrictive_arg_uids=forbidden_attacks) url0 = _um.get_url_for_reaction_on_argument(db_argument.uid, sys_attack, arg_id_sys) if len_undercut == 0: url1 = _um.get_url_for_justifying_statement( db_argument.conclusion_uid, Attitudes.AGREE) url2 = _um.get_url_for_justifying_argument(db_argument.uid, Attitudes.AGREE, Relations.UNDERCUT) url3 = _um.get_url_for_justifying_statement( db_argument.conclusion_uid, Attitudes.DISAGREE) if len(db_premises) == 1: url4 = _um.get_url_for_justifying_statement( db_premises[0].statement_uid, Attitudes.DISAGREE) else: url4 = _um.get_url_for_justifying_argument( db_argument.uid, Attitudes.DISAGREE, Relations.UNDERMINE) elif len_undercut == 1: url1 = None url2 = _um.get_url_for_justifying_argument(db_argument.uid, Attitudes.AGREE, Relations.UNDERCUT) url3 = _um.get_url_for_jump(db_undercutted_arg.uid) if len(db_premises) == 1: url4 = _um.get_url_for_justifying_statement( db_premises[0].statement_uid, Attitudes.DISAGREE) else: url4 = _um.get_url_for_justifying_argument( db_argument.uid, Attitudes.DISAGREE, Relations.UNDERMINE) else: url1 = None url2 = None url3 = _um.get_url_for_jump(db_undercutted_arg.uid) if len(db_premises) == 1: url4 = _um.get_url_for_justifying_statement( db_premises[0].statement_uid, Attitudes.DISAGREE) else: url4 = _um.get_url_for_justifying_argument( db_argument.uid, Attitudes.DISAGREE, Relations.UNDERMINE) return [url0, url1, url2, url3, url4]