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]
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) } }