def set_correction_of_statement(elements, db_user, translator) -> dict: """ Adds a proposal for a statements correction and returns info if the proposal could be set :param elements: List of dicts with text and uids for proposals of edits for new statements :param db_user: User :param translator: Translator :rtype: dict :return: Dictionary with info and/or error """ review_count = len(elements) added_reviews = [EditQueue().add_edit_reviews(db_user, el['uid'], el['text']) for el in elements] if added_reviews.count(Code.SUCCESS) == 0: # no edits set if added_reviews.count(Code.DOESNT_EXISTS) > 0: LOG.debug("Internal Key Error") return { 'info': translator.get(_.internalKeyError), 'error': True } if added_reviews.count(Code.DUPLICATE) > 0: LOG.debug("Already edit proposals") return { 'info': translator.get(_.alreadyEditProposals), 'error': True } LOG.debug("No corrections given") return { 'info': translator.get(_.noCorrections), 'error': True } DBDiscussionSession.flush() transaction.commit() added_values = [EditQueue().add_edit_values_review(db_user, el['uid'], el['text']) for el in elements] if Code.SUCCESS not in added_values: return { 'info': translator.get(_.alreadyEditProposals), 'error': True } DBDiscussionSession.flush() transaction.commit() msg = '' if review_count > added_values.count(Code.SUCCESS) \ or added_reviews.count(Code.SUCCESS) != added_values.count(Code.SUCCESS): msg = translator.get(_.alreadyEditProposals) return { 'error': False, 'info': msg }
def test_is_arguments_premise_in_edit_queue(self): db_reviews = DBDiscussionSession.query(ReviewEdit).filter_by( is_executed=False, is_revoked=False).all() for db_review in db_reviews: db_premise = DBDiscussionSession.query(Premise).filter_by( statement_uid=db_review.statement_uid).first() if not db_premise: # skip this cause we just have random data continue db_arg = DBDiscussionSession.query(Argument).filter_by( premisegroup_uid=db_premise.premisegroup_uid).first() self.assertTrue( EditQueue().is_arguments_premise_in_edit_queue(db_arg))
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 review_edit_argument(request): """ Values for the review for an argument, which should be edited :param request: current request of the server :return: json-dict() """ LOG.debug("Review request to edit argument: %s - %s", request.json_body, request.authenticated_userid) ui_locales = get_discussion_language(request.matchdict, request.params, request.session) db_review = request.validated['db_review'] db_user = request.validated['user'] is_edit_okay = request.validated['is_edit_okay'] main_page = request.application_url _t = Translator(ui_locales) QueueAdapter(EditQueue(), db_user, main_page, _t).add_vote(db_review, is_edit_okay) send_request_for_recent_reviewer_socketio(db_user.nickname, main_page, key_edit) return True
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 test_is_statement_in_edit_queue(self): db_review_edits = DBDiscussionSession.query(ReviewEdit).all() for review in db_review_edits: self.assertTrue(EditQueue().is_statement_in_edit_queue( review.statement_uid, review.is_executed)) self.assertFalse(EditQueue().is_statement_in_edit_queue(50))
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)}}