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