def feed_twt_authorized_get_list(): from citizendesk.feeds.twt.authorized import process logger = get_logger() client_ip = get_client_ip() is_local = not is_remote_ip(client_ip) params = {'offset': None, 'limit': None} for key in params: if key in request.args: try: params[key] = int(request.args.get(key)) except: params[key] = None res = process.do_get_list(mongo_dbs.get_db().db, is_local, params['offset'], params['limit']) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} if 2 < len(res): ret_data['_meta']['list'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_twt_authorized_post_one(): from citizendesk.feeds.twt.authorized import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) auther_url = get_config('newstwister_url') res = process.do_post_one(mongo_dbs.get_db().db, auther_url, data) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_twt_report_patch_one(report_id): from citizendesk.feeds.twt.report import process logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) res = process.do_patch_one(mongo_dbs.get_db().db, report_id, data) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_sms_report_get_list(value_type, value_id): from citizendesk.feeds.sms.report import process logger = get_logger() client_ip = get_client_ip() params = {'offset': None, 'limit': None} for key in params: if key in request.args: try: params[key] = int(request.args.get(key)) except: params[key] = None for key in ['sort']: params[key] = None if key in request.args: params[key] = request.args.get(key) other = {'text_only': None} for key in other: if key in request.args: other[key] = request.args.get(key) res = process.do_get_list(mongo_dbs.get_db().db, value_type, value_id, params['offset'], params['limit'], params['sort'], other) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} if 3 >= len(res): ret_data['_meta']['list'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def take_twt(tweet_id): from citizendesk.ingest.twt.process import do_post logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if allowed_ips and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: '+ str(client_ip)) return ('Client not allowed\n\n', 403,) logger.info('allowed client from: '+ str(client_ip)) try: json_data = request.get_json(True, False, False) if type(json_data) is not dict: json_data = None except: json_data = None if json_data is None: try: json_data = request.json if type(json_data) is not dict: json_data = None except: json_data = None if not json_data: logger.info('data not provided in the request') return ('Data not provided', 404,) for part in ['filter', 'tweet', 'endpoint', 'type']: if (part not in json_data) or (not json_data[part]): logger.info('No ' + str(part) + ' provided') return ('No ' + str(part) + ' provided', 404,) tweet = json_data['tweet'] feed_filter = json_data['filter'] endpoint = json_data['endpoint'] channel_type = json_data['type'] request_id = None if ('request' in json_data) and json_data['request']: request_id = json_data['request'] try: res = do_post(holder, tweet_id, tweet, channel_type, endpoint, request_id, feed_filter, client_ip) if (not res) or (not res[0]): logger.info(str(res[1])) return (res[1], 404,) return ('tweet received\n\n', 200,) except Exception as exc: logger.warning('problem on tweet processing or saving') return ('problem on tweet processing or saving', 404,)
def feed_any_coverage_activate_one(coverage_id, set_active): from citizendesk.feeds.any.coverage import process logger = get_logger() client_ip = get_client_ip() res = process.do_set_active_one(mongo_dbs.get_db().db, coverage_id, set_active) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_sms_report_get_one(doc_id): from citizendesk.feeds.sms.report import process logger = get_logger() client_ip = get_client_ip() res = process.do_get_one(mongo_dbs.get_db().db, doc_id) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def check_client(): from citizendesk.common.utils import get_logger, get_client_ip, get_allowed_ips logger = get_logger() client_ip = get_client_ip() message = '' + str(request.method) + ' request on ' + str(request.url) + ', by ' + str(get_client_ip()) allowed_ips = get_allowed_ips() if (allowed_ips is not None) and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed ' + message) return make_response('Client not allowed\n\n', 403,) logger.info('allowed ' + message)
def feed_twt_oauth_get_one(oauth_id): from citizendesk.feeds.twt.oauth import process logger = get_logger() client_ip = get_client_ip() is_local = not is_remote_ip(client_ip) res = process.do_get_one(mongo_dbs.get_db().db, oauth_id, is_local) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def take_twt_user(user_id): from citizendesk.ingest.twt.process_user import do_post as do_post_user logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if allowed_ips and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: '+ str(client_ip)) return ('Client not allowed\n\n', 403,) logger.info('allowed client from: '+ str(client_ip)) try: json_data = request.get_json(True, False, False) if type(json_data) is not dict: json_data = None except: json_data = None if json_data is None: try: json_data = request.json if type(json_data) is not dict: json_data = None except: json_data = None if not json_data: logger.info('data not provided in the request') return ('Data not provided', 404,) for part in ['user']: if (part not in json_data) or (not json_data[part]): logger.info('No ' + str(part) + ' provided') return ('No ' + str(part) + ' provided', 404,) user_info = json_data['user'] try: res = do_post_user(citizen_holder, user_id, user_info, client_ip) if (not res) or (not res[0]): logger.info(str(res[1])) return (res[1], 404,) message = 'user info received' if len(res) > 1: message = res[1] return (json.dumps(message) + '\r\n', 200,) except Exception as exc: logger.warning('problem on user info processing or saving') return ('problem on user info processing or saving', 404,)
def feed_any_coverage_insert_one(): from citizendesk.feeds.any.coverage import process logger = get_logger() client_ip = get_client_ip() coverage_data = {} try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) try: coverage_data['title'] = data['title'] coverage_data['description'] = data['description'] coverage_data['user_id'] = data['user_id'] except: return (json.dumps('provided data should contain "title", "description", "user_id" parts'), 404, {'Content-Type': 'application/json'}) if 'active' in data: coverage_data['active'] = _get_boolean(data['active']) try: if ('uuid' in data) and data['uuid']: coverage_data['uuid'] = str(data['uuid']) except: pass res = process.do_insert_one(mongo_dbs.get_db().db, coverage_data) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_twt_citizen_alias_get_one(alias_type, alias_value): from citizendesk.feeds.twt.citizen_alias import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() other = {'force': None} for key in other: if key in request.args: other[key] = request.args.get(key) force = False if other and ('force' in other): force = _get_boolean(other['force']) res = process.do_get_one(mongo_dbs.get_db().db, alias_type, alias_value) err_reason = None err_msg = None if not res[0]: err_msg = res[1] if (not res[0]) and force: err_msg = res[1] searcher_url = get_config('newstwister_url') res_aux = process.do_request_one(mongo_dbs.get_db().db, searcher_url, alias_type, alias_value) if not res_aux[0]: err_msg = res_aux[1] if 2 < len(res_aux): err_reason = res_aux[2] else: res = process.do_get_one(mongo_dbs.get_db().db, alias_type, alias_value) if not res[0]: err_msg = res_aux[1] err_reason = None if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': err_msg}} if err_reason: ret_data['_meta']['reason'] = err_reason return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def take_sms(feed_name): from citizendesk.common.dbc import mongo_dbs db = mongo_dbs.get_db().db from citizendesk.ingest.sms.process import do_post logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if allowed_ips and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: '+ str(client_ip)) return ('Client not allowed\n\n', 403,) logger.info('allowed client from: '+ str(client_ip)) params = {'feed': feed_name} for part in ['feed', 'phone', 'time', 'text']: if part not in params: params[part] = None if part in request.form: try: params[part] = str(request.form[part].encode('utf8')) except: pass timepoint = datetime.datetime.now() if not params['time']: params['time'] = timepoint for part in ['phone', 'text']: if not params[part]: return ('No ' + str(part) + ' provided', 404) try: res = do_post(db, holder, params, client_ip) if (not res) or (not res[0]): logger.info(str(res[1])) return (res[1], 404,) return ('SMS received\n\n', 200,) except Exception as exc: logger.warning('problem on tweet processing or saving') return ('problem on tweet processing or saving', 404,)
def feed_twt_citizen_alias_request_one(alias_type, alias_value): from citizendesk.feeds.twt.citizen_alias import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() searcher_url = get_config('newstwister_url') res = process.do_request_one(mongo_dbs.get_db().db, searcher_url, alias_type, alias_value) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} if 2 < len(res): ret_data['_meta']['reason'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_twt_search_one_post(): from citizendesk.feeds.twt.search import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) try: user_id = data['user_id'] request_id = data['request_id'] search_spec = data['search_spec'] except: return (json.dumps('provided data should contain "user_id", "request_id", "search_spec" parts'), 404, {'Content-Type': 'application/json'}) searcher_url = get_config('newstwister_url') if ('searcher_url' in data) and data['searcher_url']: searcher_url = data['searcher_url'] res = process.do_post_search(mongo_dbs.get_db().db, searcher_url, user_id, request_id, search_spec) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_sms_citizen_alias_post_one(alias_id): from citizendesk.feeds.sms.citizen_alias import process logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) try: alias_spec = data['spec'] user_id = data['user_id'] except: return (json.dumps('provided data should contain "spec", "user_id" parts'), 404, {'Content-Type': 'application/json'}) if not alias_id: if ('_id' in data) and (data['_id']): alias_id = data['_id'] res = process.do_post_one(mongo_dbs.get_db().db, alias_id, alias_spec, user_id) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} if 2 < len(res): ret_data['_meta']['reason'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_any_coverage_unpublish_one(coverage_id): from citizendesk.feeds.any.coverage import process logger = get_logger() client_ip = get_client_ip() res = process.do_unpublish_one(mongo_dbs.get_db().db, coverage_id) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })
def feed_twt_filter_delete_one(filter_id): from citizendesk.feeds.twt.filter import process logger = get_logger() client_ip = get_client_ip() res = process.do_delete_one(mongo_dbs.get_db().db, filter_id) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })
def feed_twt_authorized_post_one(): from citizendesk.feeds.twt.authorized import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, { 'Content-Type': 'application/json' }) auther_url = get_config('newstwister_url') res = process.do_post_one(mongo_dbs.get_db().db, auther_url, data) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })
def feed_sms_report_get_list(value_type, value_id): from citizendesk.feeds.sms.report import process logger = get_logger() client_ip = get_client_ip() params = {'offset': None, 'limit': None} for key in params: if key in request.args: try: params[key] = int(request.args.get(key)) except: params[key] = None for key in ['sort']: params[key] = None if key in request.args: params[key] = request.args.get(key) other = {'text_only': None} for key in other: if key in request.args: other[key] = request.args.get(key) res = process.do_get_list(mongo_dbs.get_db().db, value_type, value_id, params['offset'], params['limit'], params['sort'], other) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} if 2 < len(res): ret_data['_meta']['list'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })
def feed_twt_authorized_get_one(doc_id): from citizendesk.feeds.twt.authorized import process logger = get_logger() client_ip = get_client_ip() is_local = not is_remote_ip(client_ip) res = process.do_get_one(mongo_dbs.get_db().db, doc_id, is_local) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })
def feed_err_ingest_insert_one(notice_timestamp): from citizendesk.feeds.err.ingest import process logger = get_logger() client_ip = get_client_ip() notice_data = {} try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) try: notice_data['feed_type'] = data['feed_type'] notice_data['channel'] = data['channel'] notice_data['message'] = data['message'] except: return (json.dumps('provided data should contain "feed_type", "channel", "message" parts'), 404, {'Content-Type': 'application/json'}) res = process.do_insert_one(mongo_dbs.get_db().db, notice_timestamp, notice_data) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_twt_stream_patch_one(stream_id): from citizendesk.feeds.twt.stream import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) if ('streamer_url' not in data) or (not data['streamer_url']): data['streamer_url'] = get_config('newstwister_url') params = {'force': None} for key in params: if key in request.args: params[key] = request.args.get(key) res = process.do_patch_one(mongo_dbs.get_db().db, stream_id, data, params['force']) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def feed_twt_report_patch_one(report_id): from citizendesk.feeds.twt.report import process logger = get_logger() client_ip = get_client_ip() try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, { 'Content-Type': 'application/json' }) res = process.do_patch_one(mongo_dbs.get_db().db, report_id, data) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })
def feed_twt_stream_patch_one_emulate(stream_id, switch_on): from citizendesk.feeds.twt.stream import process from citizendesk.feeds.config import get_config logger = get_logger() client_ip = get_client_ip() data = { 'control': { 'streamer_url': get_config('newstwister_url'), 'switch_on': switch_on }, } params = {'force': True} res = process.do_patch_one(mongo_dbs.get_db().db, stream_id, data, params['force']) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def take_twt(tweet_id): from citizendesk.ingest.twt.process import do_post logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if allowed_ips and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: ' + str(client_ip)) return ( 'Client not allowed\n\n', 403, ) logger.info('allowed client from: ' + str(client_ip)) try: json_data = request.get_json(True, False, False) if type(json_data) is not dict: json_data = None except: json_data = None if json_data is None: try: json_data = request.json if type(json_data) is not dict: json_data = None except: json_data = None if not json_data: logger.info('data not provided in the request') return ( 'Data not provided', 404, ) for part in ['filter', 'tweet', 'endpoint', 'type']: if (part not in json_data) or (not json_data[part]): logger.info('No ' + str(part) + ' provided') return ( 'No ' + str(part) + ' provided', 404, ) tweet = json_data['tweet'] feed_filter = json_data['filter'] endpoint = json_data['endpoint'] channel_type = json_data['type'] request_id = None if ('request' in json_data) and json_data['request']: request_id = json_data['request'] try: res = do_post(holder, tweet_id, tweet, channel_type, endpoint, request_id, feed_filter, client_ip) if (not res) or (not res[0]): logger.info(str(res[1])) return ( res[1], 404, ) return ( 'tweet received\n\n', 200, ) except Exception as exc: logger.warning('problem on tweet processing or saving') return ( 'problem on tweet processing or saving', 404, )
def ingest_sms_feed_take_one(feed_name): from citizendesk.common.dbc import mongo_dbs db = mongo_dbs.get_db().db from citizendesk.ingest.sms.process import do_post logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if (allowed_ips is not None) and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: ' + str(client_ip)) return ('Client not allowed\n\n', 403,) logger.info('allowed client from: '+ str(client_ip)) store_keys = { 'phone': 'phone_param', 'text': 'text_param', 'feed': 'feed_param', 'time': 'time_param', 'pass': '******', } param_keys = {} for key in store_keys: param_keys[store_keys[key]] = key main_config = get_sms_configuration(db) sms_password_key = main_config['sms_password_key'] for key in param_keys: take_key = 'sms_' + key if take_key in main_config: param_keys[key] = main_config[take_key] params = {'feed': feed_name} for store_key in store_keys: part_key = store_keys[store_key] part_param = param_keys[part_key] if store_key not in params: params[store_key] = None if part_param in request.args: try: params[store_key] = str(request.args[part_param].encode('utf8')) except: pass if part_param in request.form: try: params[store_key] = str(request.form[part_param].encode('utf8')) except: pass timepoint = datetime.datetime.now() if params['time']: try: dt_format = '%Y-%m-%dT%H:%M:%S' if '.' in params['time']: dt_format = '%Y-%m-%dT%H:%M:%S.%f' params['time'] = datetime.datetime.strptime(params['time'], dt_format) except: params['time'] = None if not params['time']: params['time'] = timepoint for part in ['phone', 'text']: if not params[part]: return ('No ' + str(part) + ' provided', 404) if sms_password_key: if sms_password_key != params['pass']: logger.info('request with wrong pass-phrase from: ' + str(client_ip)) return ('wrong pass-phrase\n\n', 403,) try: res = do_post(db, params, main_config, client_ip) if not res[0]: logger.info(str(res[1])) return (res[1], 404,) return ('SMS received\n\n', 200,) except Exception as exc: logger.warning('problem on sms processing or saving') return ('problem on sms processing or saving', 404,)
def feed_sms_reply_one_post(): from citizendesk.feeds.sms.reply import process from citizendesk.feeds.config import get_config as get_main_config sms_allowed_ips = get_main_config('sms_allowed_ips') sms_gateway_url = get_main_config('sms_gateway_url') sms_gateway_key = get_main_config('sms_gateway_key') try: sms_gateway_api = get_main_config('sms_gateway_api') except: sms_gateway_api = 'frontlinesms' logger = get_logger() client_ip = get_client_ip() if (sms_allowed_ips is not None) and ('*' not in sms_allowed_ips): if not client_ip in sms_allowed_ips: logger.info('unallowed sms-reply request from: ' + str(client_ip)) return (json.dumps('client not allowed'), 403, {'Content-Type': 'application/json'}) try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) try: message = data['message'] report_id = data['report_id'] user_id = data['user_id'] except: return (json.dumps('provided data should contain "message", "report_id", "user_id" parts'), 404, {'Content-Type': 'application/json'}) language = None sensitive = None if 'language' in data: language = data['language'] if 'sensitive' in data: sensitive = data['sensitive'] if ('control' in data) and (type(data['control']) is dict): control = data['control'] if ('sms_gateway_url' in control) and control['sms_gateway_url']: sms_gateway_url = control['sms_gateway_url'] if ('sms_gateway_key' in control) and control['sms_gateway_key']: sms_gateway_key = control['sms_gateway_key'] res = process.do_post_reply(mongo_dbs.get_db().db, sms_gateway_api, sms_gateway_url, sms_gateway_key, message, report_id, user_id, language, sensitive, client_ip) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} if 2 < len(res): ret_data['_meta']['reason'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'}) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'})
def page_not_found(error): from citizendesk.common.utils import get_client_ip from citizendesk.common.utils import get_logger logger = get_logger() logger.info('page not found: ' + str(request.method) + ' on ' + str(request.url) + ', by ' + str(get_client_ip())) return 'page not found', 404
def take_twt_user(user_id): from citizendesk.ingest.twt.process_user import do_post as do_post_user logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if allowed_ips and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: ' + str(client_ip)) return ( 'Client not allowed\n\n', 403, ) logger.info('allowed client from: ' + str(client_ip)) try: json_data = request.get_json(True, False, False) if type(json_data) is not dict: json_data = None except: json_data = None if json_data is None: try: json_data = request.json if type(json_data) is not dict: json_data = None except: json_data = None if not json_data: logger.info('data not provided in the request') return ( 'Data not provided', 404, ) for part in ['user']: if (part not in json_data) or (not json_data[part]): logger.info('No ' + str(part) + ' provided') return ( 'No ' + str(part) + ' provided', 404, ) user_info = json_data['user'] try: res = do_post_user(citizen_holder, user_id, user_info, client_ip) if (not res) or (not res[0]): logger.info(str(res[1])) return ( res[1], 404, ) message = 'user info received' if len(res) > 1: message = res[1] return ( json.dumps(message) + '\r\n', 200, ) except Exception as exc: logger.warning('problem on user info processing or saving') return ( 'problem on user info processing or saving', 404, )
def ingest_sms_feed_take_one(feed_name): from citizendesk.common.dbc import mongo_dbs db = mongo_dbs.get_db().db from citizendesk.ingest.sms.process import do_post logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if (allowed_ips is not None) and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: ' + str(client_ip)) return ( 'Client not allowed\n\n', 403, ) logger.info('allowed client from: ' + str(client_ip)) store_keys = { 'phone': 'phone_param', 'text': 'text_param', 'feed': 'feed_param', 'time': 'time_param', 'pass': '******', } param_keys = {} for key in store_keys: param_keys[store_keys[key]] = key main_config = get_sms_configuration(db) sms_password_key = main_config['sms_password_key'] for key in param_keys: take_key = 'sms_' + key if take_key in main_config: param_keys[key] = main_config[take_key] params = {'feed': feed_name} for store_key in store_keys: part_key = store_keys[store_key] part_param = param_keys[part_key] if store_key not in params: params[store_key] = None if part_param in request.args: try: params[store_key] = str( request.args[part_param].encode('utf8')) except: pass if part_param in request.form: try: params[store_key] = str( request.form[part_param].encode('utf8')) except: pass timepoint = datetime.datetime.utcnow() if params['time']: try: dt_format = '%Y-%m-%dT%H:%M:%S' if '.' in params['time']: dt_format = '%Y-%m-%dT%H:%M:%S.%f' params['time'] = datetime.datetime.strptime( params['time'], dt_format) except: params['time'] = None if not params['time']: params['time'] = timepoint for part in ['phone', 'text']: if not params[part]: return ('No ' + str(part) + ' provided', 404) if sms_password_key: if sms_password_key != params['pass']: logger.info('request with wrong pass-phrase from: ' + str(client_ip)) return ( 'wrong pass-phrase\n\n', 403, ) try: res = do_post(db, params, main_config, client_ip) if not res[0]: logger.info(str(res[1])) return ( res[1], 404, ) return ( 'SMS received\n\n', 200, ) except Exception as exc: logger.warning('problem on sms processing or saving') return ( 'problem on sms processing or saving', 404, )
def ingest_url_feed_take_one(feed_name): from citizendesk.common.dbc import mongo_dbs db = mongo_dbs.get_db().db from citizendesk.ingest.url.process import do_post logger = get_logger() client_ip = get_client_ip() allowed_ips = get_allowed_ips() if (allowed_ips is not None) and ('*' not in allowed_ips): if not client_ip in allowed_ips: logger.info('unallowed client from: ' + str(client_ip)) return ('Client not allowed\n\n', 403,) logger.info('allowed client from: '+ str(client_ip)) param_keys = [ 'feed_name', 'url_link', 'request_id', ] params = {'feed_name': feed_name} try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, {'Content-Type': 'application/json'}) for one_param in param_keys: if one_param in data: try: params[one_param] = str(data[one_param].encode('utf8')) except: pass for one_param in param_keys: if (not one_param in params) or (not params[one_param]): return ('No ' + str(one_param) + ' provided', 404) try: res = do_post(db, params['url_link'], params['feed_name'], params['request_id'], client_ip) if not res[0]: logger.info(str(res[1])) return (res[1], 404,) ret_data = res[1] return json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, {'Content-Type': 'application/json'} except Exception as exc: logger.warning('problem on url processing or saving: ' + str(exc)) return ('problem on url processing or saving: ' + str(exc), 404,)
def feed_sms_send_one_post(): from citizendesk.feeds.sms.send import process from citizendesk.feeds.config import get_config as get_main_config sms_allowed_ips = get_main_config('sms_allowed_ips') sms_gateway_url = get_main_config('sms_gateway_url') sms_gateway_key = get_main_config('sms_gateway_key') try: sms_gateway_api = get_main_config('sms_gateway_api') except: sms_gateway_api = 'frontlinesms' logger = get_logger() client_ip = get_client_ip() if (sms_allowed_ips is not None) and ('*' not in sms_allowed_ips): if not client_ip in sms_allowed_ips: logger.info('unallowed sms-send request from: ' + str(client_ip)) return (json.dumps('client not allowed'), 403, { 'Content-Type': 'application/json' }) try: data = request.get_json(True, False, False) if type(data) is not dict: data = None except: data = None if data is None: try: data = request.json if type(data) is not dict: data = None except: data = None if data is None: return (json.dumps('provided data are not valid json'), 404, { 'Content-Type': 'application/json' }) try: message = data['message'] targets = data['targets'] user_id = data['user_id'] except: return (json.dumps( 'provided data should contain "message", "targets", "user_id" parts' ), 404, { 'Content-Type': 'application/json' }) language = None sensitive = None if 'language' in data: language = data['language'] if 'sensitive' in data: sensitive = data['sensitive'] if ('control' in data) and (type(data['control']) is dict): control = data['control'] if ('sms_gateway_url' in control) and control['sms_gateway_url']: sms_gateway_url = control['sms_gateway_url'] if ('sms_gateway_key' in control) and control['sms_gateway_key']: sms_gateway_key = control['sms_gateway_key'] res = process.do_post_send(mongo_dbs.get_db().db, sms_gateway_api, sms_gateway_url, sms_gateway_key, message, targets, user_id, language, sensitive, client_ip) if not res[0]: ret_data = {'_meta': {'schema': process.schema, 'message': res[1]}} if 2 < len(res): ret_data['_meta']['reason'] = res[2] return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, { 'Content-Type': 'application/json' }) ret_data = {'_meta': {'schema': process.schema}, '_data': res[1]} return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 200, { 'Content-Type': 'application/json' })