def __get_flag_status(argument_uid, statement_uid, pgroup_uid, user_uid):
"""
Gets the status for a flag in of given argument/statement
:param argument_uid: The uid of the argument to check.
:param statement_uid: The uid of the statement to check
:param statement_uid: The uid of the premisegroup to check
:param user_uid: The uid of the user which may have flagged the argument/statement
:return: 'user' if the user flagged the argument/statement, 'other' if someone else did, None if unflagged.
"""
if any(
(__is_argument_flagged_for_delete_by_user(argument_uid, statement_uid,
user_uid),
__is_argument_flagged_for_optimization_by_user(
argument_uid, statement_uid, user_uid),
__is_argument_flagged_for_duplication_by_user(statement_uid,
user_uid),
__is_argument_flagged_for_merge_by_user(pgroup_uid, user_uid),
__is_argument_flagged_for_split_by_user(pgroup_uid, user_uid))):
logger('FlagingHelper', 'Already flagged by the user')
return 'user'
if any((__is_argument_flagged_for_delete(argument_uid, statement_uid),
__is_argument_flagged_for_optimization(argument_uid,
statement_uid),
__is_argument_flagged_for_duplication(statement_uid),
__is_argument_flagged_for_merge(pgroup_uid),
__is_argument_flagged_for_split(pgroup_uid))):
logger('FlagingHelper', 'Already flagged by others')
return 'other'
return None
def __preparation_for_dont_know_statement(db_issue: Issue, db_user: User,
db_stmt_or_arg: Statement,
supportive: bool, history,
path) -> Tuple[dict, dict]:
"""
Prepares some parameter for the "don't know" step
:param db_issue: Current issue
:param db_user: User
:param db_stmt_or_arg: Statement
:param supportive: Boolean
:param history:
:param path: request.path
:return: dict(), dict(), dict()
"""
logger('ViewHelper', 'main')
nickname = db_user.nickname
slug = db_issue.slug
disc_ui_locales = db_issue.lang
_ddh = DiscussionDictHelper(disc_ui_locales, nickname, history, slug=slug)
_idh = ItemDictHelper(disc_ui_locales,
db_issue,
path=path,
history=history)
discussion_dict = _ddh.get_dict_for_dont_know_reaction(
db_stmt_or_arg.uid, nickname)
item_dict = _idh.get_array_for_dont_know_reaction(
db_stmt_or_arg.uid, supportive, db_user, discussion_dict['gender'])
return item_dict, discussion_dict
def handle_justification_argument(db_issue: Issue, db_user: User,
db_argument: Argument, attitude: str,
relation: str, history,
path) -> Tuple[dict, dict]:
"""
:param db_issue:
:param db_user:
:param db_argument:
:param attitude:
:param relation:
:param history:
:param path:
:return:
"""
logger('ViewHelper', 'justify argument')
ui_locales = db_issue.lang
nickname = db_user.nickname
supportive = attitude in [Attitudes.AGREE, Attitudes.DONT_KNOW]
item_dict, discussion_dict = preparation_for_justify_argument(
db_issue, db_user, db_argument, relation, supportive, history, path)
add_rep, broke_limit = add_reputation_for(nickname,
rep_reason_first_confrontation)
if broke_limit:
_t = Translator(ui_locales)
send_request_for_info_popup_to_socketio(
nickname, _t.get(_.youAreAbleToReviewNow), '/review')
return item_dict, discussion_dict
def __is_uid_valid(uid, queue):
"""
Check for the specific review in the fiven queue
:param queue: Table of review
:param uid: Review.uid
:return: Boolean
:rtype: Boolean
"""
mapping = {
'deletes': ReviewDelete,
'optimizations': ReviewOptimization,
'edits': ReviewEdit,
'duplicates': ReviewDuplicate,
'merges': ReviewMerge,
'splits': ReviewSplit,
}
if queue in mapping:
logger('review_history_helper', 'query table {} with uid {}'.format(mapping[queue], uid))
return DBDiscussionSession.query(mapping[queue]).get(uid) is not None
logger('review_history_helper', 'no table found for {}'.format(queue), error=True)
return False
def start_flow(redirect_uri):
"""
:param redirect_uri:
:return:
"""
client_id = os.environ.get('OAUTH_GOOGLE_CLIENTID', None)
client_secret = os.environ.get('OAUTH_GOOGLE_CLIENTKEY', None)
if 'service=google' not in redirect_uri:
bind = '#' if '?' in redirect_uri else '?'
redirect_uri = '{}{}{}'.format(redirect_uri, bind, 'service=google')
logger(
'Google OAuth',
'Read OAuth id/secret: none? {}/{}'.format(client_id is None,
client_secret is None))
# OAuth endpoints given in the Google API documentation
google = OAuth2Session(client_id, redirect_uri=redirect_uri, scope=scope)
authorization_url, state = google.authorization_url(
authorization_base_url, access_type='offline', prompt='select_account')
logger('Google OAuth',
'Please go to {} and authorize access'.format(authorization_url))
return {'authorization_url': authorization_url, 'error': ''}
def get_random_subdict_out_of_ordered_dict(ordered_dict, count):
"""
Creates a random subdictionary with given count out of the given ordered_dict.
With a count of <2 the dictionary itself will be returned.
:param ordered_dict: dictionary for the function
:param count: count of entries for the new dictionary
:return: dictionary
"""
return_dict = dict()
logger('DictionaryHelper', 'count: ' + str(count))
items = list(ordered_dict.items())
if count < 0:
return ordered_dict
elif count == 1:
if len(items) > 1:
rnd = random.randint(0, len(items) - 1)
return_dict[items[rnd][0]] = items[rnd][1]
else:
return ordered_dict
else:
for i in range(0, count):
rnd = random.randint(0, len(items) - 1)
return_dict[items[rnd][0]] = items[rnd][1]
items.pop(rnd)
return return_dict
def revoke_old_decision(queue, db_review, db_user):
"""
Trys to revoke an old decision
:param queue: Type of review
:param db_review: Review
:param db_user: User
:return:
"""
logger('review_history_helper', 'queue {} with uid {}'.format(queue, db_review.uid))
review_canceled = None
if queue == 'deletes':
review_canceled = __revoke_old_deletes_decision(db_review, db_user)
elif queue == 'optimizations':
review_canceled = __revoke_old_optimizations_decision(db_review, db_user)
elif queue == 'edits':
review_canceled = __revoke_old_edits_decision(db_review, db_user)
elif queue == 'duplicates':
review_canceled = __revoke_old_duplicates_decision(db_review, db_user)
elif queue == 'merges':
review_canceled = __revoke_old_merges_decision(db_review, db_user)
elif queue == 'splits':
review_canceled = __revoke_old_splits_decision(db_review, db_user)
DBDiscussionSession.add(review_canceled)
DBDiscussionSession.flush()
transaction.commit()
return True
def support(db_issue: Issue, db_user: User, db_arg_user: Argument, db_arg_sys: Argument, history: str,
path: str) -> dict:
"""
Initialize the support step for the end of a branch in a discussion. Creates helper and returns a dictionary
containing the first elements needed for the discussion.
:param db_issue:
:param db_user:
:param db_arg_user:
:param db_arg_sys:
:param history:
:param path:
:return:
"""
logger('Core', 'Entering discussion.support')
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
disc_ui_locales = issue_dict['lang']
_ddh = DiscussionDictHelper(disc_ui_locales, db_user.nickname, history, slug=db_issue.slug)
_idh = ItemDictHelper(disc_ui_locales, db_issue, path=path, history=history)
discussion_dict = _ddh.get_dict_for_supporting_each_other(db_arg_sys.uid, db_arg_user.uid, db_user.nickname)
item_dict = _idh.get_array_for_support(db_arg_sys.uid, db_issue.slug)
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
def choose(db_issue: Issue, db_user: User, is_argument: bool, is_supportive: bool, pgroup: PremiseGroup,
pgroup_ids: list, history: str, path: str) -> dict:
"""
Initialize the choose step for more than one premise in a discussion. Creates helper and returns a dictionary
containing several feedback options regarding this argument.
:param db_issue:
:param db_user:
:param is_argument:
:param is_supportive:
:param uid:
:param pgroup:
:param history:
:param path:
:return:
"""
logger('Core', 'Entering discussion.choose')
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
disc_ui_locales = issue_dict['lang']
_ddh = DiscussionDictHelper(disc_ui_locales, db_user.nickname, history, slug=db_issue.slug)
_idh = ItemDictHelper(disc_ui_locales, db_issue, path=path, history=history)
discussion_dict = _ddh.get_dict_for_choosing(pgroup.uid, is_argument, is_supportive)
item_dict = _idh.get_array_for_choosing(pgroup.uid, pgroup_ids, is_argument, is_supportive, db_user.nickname)
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
def init(db_issue: Issue, db_user: User) -> dict:
"""
Initialize the discussion. Creates helper and returns a dictionary containing the first elements needed for the
discussion.
:param db_issue: Issue
:param db_user: User
:return: prepared collection with first elements for the discussion
"""
logger('Core', 'main')
slug = db_issue.slug
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
disc_ui_locales = issue_dict['lang']
_ddh = DiscussionDictHelper(disc_ui_locales, nickname=db_user.nickname, slug=slug)
item_dict = ItemDictHelper(disc_ui_locales, db_issue).get_array_for_start(db_user)
discussion_dict = _ddh.get_dict_for_start(position_count=(len(item_dict['elements'])))
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
def reaction(db_issue: Issue, db_user: User, db_arg_user: Argument, db_arg_sys: Argument, relation: Relations, history,
path) -> dict:
"""
Initialize the reaction step for a position in a discussion. Creates helper and returns a dictionary containing
different feedback options for the confrontation with an argument in a discussion.
:param db_issue:
:param db_user:
:param db_arg_user:
:param db_arg_sys:
:param relation:
:param history:
:param path:
:return:
"""
logger('Core', 'Entering discussion.reaction')
# set votes and reputation
add_rep, broke_limit = add_reputation_for(db_user, reason=rep_reason_first_argument_click)
add_click_for_argument(db_arg_user, db_user)
_ddh = DiscussionDictHelper(db_issue.lang, db_user.nickname, history, slug=db_issue.slug, broke_limit=broke_limit)
_idh = ItemDictHelper(db_issue.lang, db_issue, path=path, history=history)
discussion_dict = _ddh.get_dict_for_argumentation(db_arg_user, db_arg_sys.uid, relation, history, db_user)
item_dict = _idh.get_array_for_reaction(db_arg_sys.uid, db_arg_user.uid, db_arg_user.is_supportive, relation,
discussion_dict['gender'])
return {
'issues': issue_helper.prepare_json_of_issue(db_issue, db_user),
'discussion': discussion_dict,
'items': item_dict,
'title': db_issue.title
}
def justify_argument(db_issue: Issue, db_user: User, db_argument: Argument, attitude: str, relation: str, history: str,
path: str) -> dict:
"""
Initialize the justification step for a statement or an argument in a discussion. Creates helper and
returns a dictionary containing the necessary elements needed for the discussion.
:param db_issue:
:param db_user:
:param db_argument:
:param attitude:
:param relation:
:param history:
:param path:
:return:
"""
logger('Justify argument discussion', 'main')
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
item_dict, discussion_dict = handle_justification_argument(db_issue, db_user, db_argument, attitude, relation,
history, path)
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
def flag_statement_for_merge_or_split(key: str, pgroup: PremiseGroup,
text_values: list(), db_user: User,
tn: Translator) -> dict():
"""
Flags a statement for a merge or split event
:param key: either 'split' or 'merge'
:param pgroup_uid: ID of the selected PremiseGroup
:param text_values: text values
:param nickname: Users nickname
:return: success, info, error
"""
logger(
'FlagingHelper',
'Flag statements in pgroup {} for a {} with values {}'.format(
pgroup.uid, key, text_values))
# was this already flagged?
flag_status = __get_flag_status(None, None, pgroup.uid, db_user.uid)
if flag_status:
logger('FlagingHelper', 'already flagged')
return {
'success':
'',
'info':
tn.get(_.alreadyFlaggedByYou if flag_status ==
'user' else _.alreadyFlaggedByOthers)
}
if key is 'merge':
__add_merge_review(pgroup.uid, db_user.uid, text_values)
elif key is 'split':
__add_split_review(pgroup.uid, db_user.uid, text_values)
return {'success': tn.get(_.thxForFlagText), 'info': ''}
def __add_merge_review(pgroup_uid, user_uid, text_values):
"""
Adds a row in the ReviewMerge table as well as the values, if not none
:param pgroup_uid: ID of the selected PremiseGroup
:param user_uid: ID of the user
:param text_values: text values or None, if you want to merge the premisegroup itself
:return: None
"""
logger(
'FlagingHelper',
'Flag pgroup {} by user {} for merging with additional values: {}'.
format(pgroup_uid, user_uid, text_values))
review_merge = ReviewMerge(detector=user_uid, premisegroup=pgroup_uid)
DBDiscussionSession.add(review_merge)
DBDiscussionSession.flush()
if text_values:
DBDiscussionSession.add_all([
ReviewMergeValues(review=review_merge.uid, content=value)
for value in text_values
])
DBDiscussionSession.flush()
transaction.commit()
def get_latest_news(ui_locales):
"""
Returns the latest news for the carousel
:param ui_locales:
:return: dict()
:return:
"""
logger('NewsHelper', 'main')
db_news = DBDiscussionSession.query(News).order_by(News.date.desc()).all()
ret_news = []
for index, news in enumerate(db_news[:5]):
news_dict = {
'indicatorclass': '',
'blockclass': 'carousel-item',
'title': news.title,
'author': news.author,
'date': sql_timestamp_pretty_print(news.date, ui_locales, False),
'news': news.news,
'id': index
}
ret_news.append(news_dict)
ret_news[0]['indicatorclass'] = 'active'
ret_news[0]['blockclass'] += ' active'
return ret_news
def jump(db_issue: Issue, db_user: User, db_argument: Argument, history: str, path: str) -> dict:
"""
Initialize the jump step for an argument in a discussion. Creates helper and returns a dictionary containing
several feedback options regarding this argument.
:param request_dict: dict out of pyramid's request object including issue, slug and history and more
:rtype: dict
:return: prepared collection matchdict for the discussion
"""
logger('Core', 'Entering discussion.jzmp')
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
disc_ui_locales = issue_dict['lang']
_ddh = DiscussionDictHelper(disc_ui_locales, db_user.nickname, history, slug=db_issue.slug)
_idh = ItemDictHelper(disc_ui_locales, db_issue, path=path, history=history)
discussion_dict = _ddh.get_dict_for_jump(db_argument.uid)
item_dict = _idh.get_array_for_jump(db_argument.uid, db_issue.slug)
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
def __get_all_statements_for_args(graph_arg_list):
"""
:param graph_arg_list:
:return:
"""
logger('PartialGraph', str([arg.uid for arg in graph_arg_list]))
nodes = []
for arg in graph_arg_list:
# save all premises
db_premises = DBDiscussionSession.query(Premise).filter(
Premise.premisegroup_uid == arg.premisegroup_uid,
Premise.is_disabled == False).all()
# save premises
nodes += [premise.statement_uid for premise in db_premises]
# save conclusion
while arg.conclusion_uid is None:
arg = DBDiscussionSession.query(Argument).get(arg.argument_uid)
nodes.append(arg.conclusion_uid)
nodes = list(set(nodes))
logger('PartialGraph', 'return nodes ({}): {}'.format(len(nodes), nodes))
return nodes
def attitude(db_issue: Issue, db_user: User, db_statement: Statement, history: str, path: str) -> dict:
"""
Initialize the attitude step for a position in a discussion. Creates helper and returns a dictionary containing
the first elements needed for the discussion.
:param db_issue: Issue
:param db_user: User
:param db_statement: Statement with is_position == True
:param history: Current history
:param path:
:return: prepared collection dict for the discussion
:rtype: dict
"""
logger('Core', 'attitude')
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
disc_ui_locales = db_issue.lang
_ddh = DiscussionDictHelper(disc_ui_locales, db_user.nickname, slug=db_issue.slug)
discussion_dict = _ddh.get_dict_for_attitude(db_statement)
_idh = ItemDictHelper(disc_ui_locales, db_issue, path=path, history=history)
item_dict = _idh.prepare_item_dict_for_attitude(db_statement.uid)
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
def debug_function(request):
"""
Minimal debug interface for the websocket
:param request: current webservers reqquest
:return: dict()
"""
logger('Websocket', 'main')
ui_locales = get_language_from_cookie(request)
extras_dict = DictionaryHelper(
ui_locales).prepare_extras_dict_for_normal_page(
request.registry, request.application_url, request.path,
request.validated['user'])
return {
'language': str(ui_locales),
'title': 'Debug Socket.IO Connection',
'project': project_name,
'extras': extras_dict,
'is_admin': request.validated['user'].is_admin(),
'discussion': {
'broke_limit': False
}
}
def justify_statement(db_issue: Issue, db_user: User, db_statement: Statement, attitude: str, history, path) -> dict:
"""
Initialize the justification step for a statement or an argument in a discussion. Creates helper and
returns a dictionary containing the necessary elements needed for the discussion.
:param db_issue:
:param db_user:
:param db_statement:
:param attitude:
:param history:
:param path:
:return:
"""
logger('Justify statement discussion', 'main')
issue_dict = issue_helper.prepare_json_of_issue(db_issue, db_user)
if attitude in [Attitudes.AGREE, Attitudes.DISAGREE]:
item_dict, discussion_dict = handle_justification_statement(db_issue, db_user, db_statement, attitude,
history, path)
return {
'issues': issue_dict,
'discussion': discussion_dict,
'items': item_dict,
'title': issue_dict['title']
}
else:
return dont_know_argument(db_issue, db_user, db_statement, attitude, history, path)
def cancel_ongoing_decision(queue, db_review, db_user):
"""
Cancel an ongoing review
:param queue: Table name of review
:param db_review: Review
:param db_user: User
:return: Success, Error
"""
logger('review_history_helper', 'queue {} uid {}'.format(queue, db_review.uid))
review_canceled = None
if queue == 'deletes':
review_canceled = __cancel_ongoing_deletes_decision(db_review, db_user)
elif queue == 'optimizations':
review_canceled = __cancel_ongoing_optimizations_decision(db_review, db_user)
elif queue == 'edits':
review_canceled = __cancel_ongoing_edits_decision(db_review, db_user)
elif queue == 'duplicates':
review_canceled = __cancel_ongoing_duplicates_decision(db_review, db_user)
elif queue == 'merges':
review_canceled = __cancel_ongoing_merges_decision(db_review, db_user)
elif queue == 'splits':
review_canceled = __cancel_ongoing_splits_decision(db_review, db_user)
DBDiscussionSession.add(review_canceled)
DBDiscussionSession.flush()
transaction.commit()
return True
def __set_able_of_reviews_argument(review, is_disabled):
"""
En- or -disable a specific review, this affects all the arguments
:param review: Review
:param is_disabled: boolean
:return: None
"""
logger('review_main_helper', str(review.uid) + ' ' + str(is_disabled))
db_argument = DBDiscussionSession.query(Argument).get(review.argument_uid)
db_argument.set_disabled(is_disabled)
DBDiscussionSession.add(db_argument)
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
for premise in db_premises:
db_statement = DBDiscussionSession.query(Statement).get(
premise.statement_uid)
db_statement.set_disabled(is_disabled)
premise.set_disabled(is_disabled)
DBDiscussionSession.add(premise)
if db_argument.conclusion_uid is not None:
db_statement = DBDiscussionSession.query(Statement).get(
db_argument.conclusion_uid)
db_statement.set_disabled(is_disabled)
DBDiscussionSession.add(db_statement)
DBDiscussionSession.flush()
transaction.commit()
def get_attack_for_argument(argument_uid: int, restrictive_attacks: List[Relations] = None,
restrictive_arg_uids: List[int] = None, last_attack: Relations = None,
history: str = '', redirected_from_jump: bool = False) -> Tuple[Optional[int],
Optional[str]]:
"""
Selects an attack out of the web of reasons.
:param argument_uid: Argument.uid
:param restrictive_attacks: Array of Relations or None
:param restrictive_arg_uids: Argument.uid
:param last_attack: String
:param history: History
:param redirected_from_jump: Boolean
:return: Retrusn a tuple with an attacking Argument.uid as well as the type of attack as str
"""
restrictive_arg_uids = list(set(restrictive_arg_uids)) if restrictive_arg_uids else []
history, redirected_from_jump = __setup_history(history, redirected_from_jump)
restrictive_attacks = __setup_restrictive_attack_keys(argument_uid, restrictive_attacks, redirected_from_jump)
logger('AttackHandler', 'arg: {}, restricts: {}, {}, from_jump: {}'.format(argument_uid, restrictive_attacks,
restrictive_arg_uids,
redirected_from_jump))
attack_uids, attack_key, no_new_attacks = __get_attack_for_argument_by_random_in_range(argument_uid,
restrictive_attacks,
restrictive_arg_uids,
last_attack, history)
if len(attack_uids) == 0 or attack_key not in Relations:
return None, None
attack_uid = random.choice(attack_uids)['id']
logger('AttackHandler', 'return {} by {}'.format(attack_key, attack_uid))
return attack_uid, attack_key
def get_user_with_same_opinion_for_statements(statement_uids, is_supportive,
db_user, lang, main_page):
"""
Returns nested dictionary with all kinds of information about the votes of the statements.
:param statement_uid: Statement.uid
:param is_supportive: Boolean
:param db_user: User
:param lang: language
:param main_page: url
:return: {'users':[{nickname1.avatar_url, nickname1.vote_timestamp}*]}
"""
logger('OpinionHandler',
'Statement {} ({})'.format(statement_uids, is_supportive))
opinions = []
_t = Translator(lang)
title = _t.get(_.relativePopularityOfStatements)
for statement_uid in statement_uids:
statement_dict = __get_opinions_for_uid(statement_uid, is_supportive,
db_user, lang, _t, main_page)
opinions.append(statement_dict)
return {'opinions': opinions, 'title': title[0:1].upper() + title[1:]}
def preparation_for_justify_statement(history, db_user: User, path,
db_issue: Issue, db_statement: Statement,
supportive: bool):
"""
Prepares some parameter for the justification step for an statement.
:param history: history
:param db_user: User
:param path:
:param db_statement: Statement
:param db_issue: Issue
:param supportive: Boolean
:return: dict(), dict(), dict()
"""
logger('ViewHelper', 'main')
nickname = db_user.nickname
slug = db_issue.slug
disc_ui_locales = db_issue.lang
_ddh = DiscussionDictHelper(disc_ui_locales, nickname, history, slug=slug)
_idh = ItemDictHelper(disc_ui_locales,
db_issue,
path=path,
history=history)
voting_helper.add_click_for_statement(db_statement, db_user, supportive)
item_dict = _idh.get_array_for_justify_statement(db_statement, db_user,
supportive, history)
discussion_dict = _ddh.get_dict_for_justify_statement(
db_statement, slug, supportive, len(item_dict['elements']), db_user)
return item_dict, discussion_dict
def get_user_with_same_opinion_for_premisegroups_of_args(
argument_uids, db_user, lang, main_page):
"""
Returns nested dictionary with all kinds of information about the votes of the premisegroups.
:param argument_uids: [Argument.uid]
:param db_user: User
:param lang: language
:param main_page: url
:return: {'users':[{nickname1.avatar_url, nickname1.vote_timestamp}*]}
"""
logger('OpinionHandler', 'Arguments ' + str(argument_uids))
opinions = []
_t = Translator(lang)
title = _t.get(_.relativePopularityOfStatements)
for arg_uid in argument_uids:
db_argument = DBDiscussionSession.query(Argument).get(arg_uid)
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
if db_premises:
opinions.append(
get_user_with_same_opinion_for_premisegroups_of_arg(
db_argument, db_premises, db_user, lang, main_page))
return {'opinions': opinions, 'title': title[0:1].upper() + title[1:]}
def preparation_for_justify_argument(db_issue: Issue, db_user: User,
db_argument: Argument, relation: str,
supportive: bool, history, path):
"""
Prepares some parameter for the justification step for an argument
:param db_issue:
:param db_user:
:param db_stmt_or_arg:
:param relation:
:param supportive:
:param history:
:param path:
:return:
"""
logger('ViewHelper', 'main')
nickname = db_user.nickname
slug = db_issue.slug
disc_ui_locales = db_issue.lang
_ddh = DiscussionDictHelper(disc_ui_locales, nickname, history, slug=slug)
_idh = ItemDictHelper(disc_ui_locales,
db_issue,
path=path,
history=history)
# justifying argument
item_dict = _idh.get_array_for_justify_argument(db_argument.uid, relation,
db_user, history)
discussion_dict = _ddh.get_dict_for_justify_argument(
db_argument.uid, supportive, relation)
return item_dict, discussion_dict
def set_news(title: str, text: str, db_user: User, lang: str,
main_page: str) -> dict():
"""
Sets a new news into the news table
:param title: of the news
:param text: of the news
:param db_user: author of the news
:param lang: ui_locales
:param main_page: url
:return:
"""
logger('NewsHelper', 'def')
author = db_user.firstname
if db_user.firstname != 'admin':
author += ' {}'.format(db_user.surname)
date = arrow.now()
DBDiscussionSession.add(
News(title=title, author=author, date=arrow.now(), news=text))
DBDiscussionSession.flush()
transaction.commit()
return_dict = {
'status': 'success',
'title': title,
'date': sql_timestamp_pretty_print(date, lang, False),
'author': author,
'news': text
}
create_news_rss(main_page, lang)
return return_dict
def start_flow(redirect_uri):
"""
:param redirect_uri:
:return:
"""
client_id = os.environ.get('OAUTH_FACEBOOK_CLIENTID', None)
client_secret = os.environ.get('OAUTH_FACEBOOK_CLIENTKEY', None)
logger(
'Facebook OAuth',
'Read OAuth id/secret: none? {}/{}'.format(client_id is None,
client_secret is None))
if 'service=facebook' not in redirect_uri:
bind = '#' if '?' in redirect_uri else '?'
redirect_uri = '{}{}{}'.format(redirect_uri, bind, 'service=facebook')
authorization_base_url = 'https://www.facebook.com/dialog/oauth'
facebook = OAuth2Session(client_id, redirect_uri=redirect_uri)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(
authorization_base_url)
logger('Facebook OAuth',
'Please go to {} and authorize access'.format(authorization_url))
return {'authorization_url': authorization_url, 'error': ''}
def add_review_opinion_for_optimization(db_user, main_page, db_review,
should_optimized, new_data, _t):
"""
Adds row the optimization review
:param request: Pyramids request object
:param should_optimized: Boolean
:param review_uid: ReviewOptimization
:param data: String
:param _t: Translator
:return: String
"""
logger(
'review.opinions',
'main ' + str(db_review.uid) + ', optimize ' + str(should_optimized))
# add new review
db_new_review = LastReviewerOptimization(db_user.uid, db_review.uid,
not should_optimized)
DBDiscussionSession.add(db_new_review)
DBDiscussionSession.flush()
transaction.commit()
if not should_optimized:
__keep_the_element_of_optimization_review(db_review, main_page, _t)
else:
__proposal_for_the_element(db_review, new_data, db_user)
DBDiscussionSession.add(db_review)
DBDiscussionSession.flush()
transaction.commit()
return True
