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 __get_statement_array_for_justify_argument(self, argument_uid, attack_type, db_user, history, argument, uids, _um): 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) return self.__create_answer_dict(argument.uid, premises_array, 'justify', url, is_markable=True, is_editable=not EditQueue().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))
def __get_statement_array_for_justify_statement(self, db_user, history, argument, uids, _tn, _um): 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) + ')' url = _um.get_url_for_discussion_finish( argument.uid) # finish the discussion if D-BAS can't find something to talk about if attack: # if there is an attack get the url to a reaction url = _um.get_url_for_reaction_on_argument(argument.uid, attack.value, arg_id_sys) else: # if there is no attack, search for an argument to ask the user about new_arg = get_another_argument_with_same_conclusion(argument.uid, history) if new_arg: # if one is found: get the url url = _um.get_url_for_support_each_other(argument.uid, new_arg.uid) return self.__create_answer_dict(str(argument.uid), premise_array, 'justify', url, already_used=already_used, already_used_text=additional_text, is_editable=not EditQueue().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))
def get_dict_for_argumentation(self, db_user_argument: Argument, arg_sys_id: Optional[int], attack: Optional[Relations], history: str, db_user: User) -> dict: """ Prepares the discussion dict with all bubbles for the argumentation window. :param db_user_argument: Argument :param arg_sys_id: Argument.uid / not necessary if attack=end :param attack: String (undermine, support, undercut, rebut, ...) :param history: History :param db_user: User :return: dict() """ LOG.debug("At_argumentation about %s", db_user_argument.uid) nickname = db_user.nickname if db_user.nickname == nick_of_anonymous_user: db_user = None nickname = None bubbles_array = history_handler.create_bubbles(self.history, nickname, self.lang, self.slug) add_premise_text = '' save_statement_url = 'set_new_start_statement' bubble_mid = '' splitted_history = history_handler.split(self.history) user_changed_opinion = splitted_history[-1].endswith( str(db_user_argument.uid)) statement_list = list() db_argument = DBDiscussionSession.query(Argument).get( db_user_argument.uid) gender_of_counter_arg = '' db_enemy = None if arg_sys_id is not None: db_tmp_arg = DBDiscussionSession.query(Argument).get(arg_sys_id) data = get_name_link_of_arguments_author(db_tmp_arg, nickname) db_enemy = data['user'] if not attack: prep_dict = self.__get_dict_for_argumentation_end( db_user_argument.uid, user_changed_opinion, db_user) bubble_sys = create_speechbubble_dict(BubbleTypes.SYSTEM, content=prep_dict['sys'], omit_bubble_url=True, lang=self.lang, other_author=db_enemy) bubble_mid = create_speechbubble_dict(BubbleTypes.INFO, content=prep_dict['mid'], omit_bubble_url=True, lang=self.lang) else: prep_dict = self.__get_dict_for_argumentation( db_argument, arg_sys_id, history, attack, nickname, db_user_argument.is_supportive) quid = 'question-bubble-' + str(arg_sys_id) if int( arg_sys_id) > 0 else '' is_author = is_author_of_argument(db_user, prep_dict['confrontation'].uid) bubble_sys = create_speechbubble_dict(BubbleTypes.SYSTEM, is_markable=True, is_author=is_author, uid=quid, content=prep_dict['sys'], omit_bubble_url=True, lang=self.lang, other_author=db_enemy) statement_list = self.__get_all_statement_texts_by_argument( prep_dict['confrontation']) gender_of_counter_arg = prep_dict['gender'] bubble_user = create_speechbubble_dict( BubbleTypes.USER, content=prep_dict['user'], omit_bubble_url=True, argument_uid=db_user_argument.uid, is_supportive=db_user_argument.is_supportive, db_user=db_user, lang=self.lang, other_author=db_enemy) # dirty fixes if len(bubbles_array) > 0 and bubbles_array[-1][ 'message'] == bubble_user['message']: bubbles_array.remove(bubbles_array[-1]) self.__append_now_bubble(bubbles_array) if not bubbles_already_last_in_list(bubbles_array, bubble_user): bubbles_array.append(bubble_user) if not bubbles_already_last_in_list(bubbles_array, bubble_sys): bubbles_array.append(bubble_sys) if not attack: bubbles_array.append(bubble_mid) return { 'bubbles': bubbles_array, 'add_premise_text': add_premise_text, 'save_statement_url': save_statement_url, 'mode': '', 'extras': statement_list, 'gender': gender_of_counter_arg, 'broke_limit': self.broke_limit }
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_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_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) } }