def take_coverages():
setup_urls()
use_liveblog_configuration(mongo_dbs.get_db().db)
from citizendesk.outgest.liveblog.process import get_coverage_list
logger = get_logger()
client_ip = get_client_ip()
try:
res = get_coverage_list(mongo_dbs.get_db().db)
if (not res) or (not res[0]):
logger.info(str(res[1]))
return (
res[1],
404,
)
return (json.dumps(res[1]), 200, {
'Content-Type': 'application/json',
'Access-Control-Allow-Origin': '*'
})
except Exception as exc:
logger.warning('problem on liveblog-oriented coverages listing')
return (
'problem on liveblog-oriented coverages listing',
404,
)
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 feed_sms_citizen_alias_get_list():
from citizendesk.feeds.sms.citizen_alias 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 = {'name_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, 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_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 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 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_workingon_reports():
from citizendesk.outgest.workingon 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)
try:
res = process.get_workingon_reports_list(mongo_dbs.get_db().db, params['offset'], params['limit'], params['sort'])
if not res[0]:
ret_data = {'_meta': {'message': res[1]}}
return (json.dumps(ret_data, default=json_util.default, sort_keys=True), 404, {'Content-Type': 'application/json'})
ret_data = {'_meta': {}, '_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'})
except Exception as exc:
logger.warning('problem on workingon-oriented reports listing')
return ('problem on workingon-oriented reports listing', 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_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_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_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 get_collection(self, for_type):
self.db = mongo_dbs.get_db().db
coll_names = {'aliases':COLL_ALIASES, 'citizens':COLL_CITIZENS}
if for_type in coll_names:
use_coll_name = coll_names[for_type]
return self.db[use_coll_name]
return None
def get_collection(self, for_type):
self.db = mongo_dbs.get_db().db
coll_names = {'reports': COLL_REPORTS, 'citizens': COLL_CITIZENS}
if for_type in coll_names:
use_coll_name = coll_names[for_type]
return self.db[use_coll_name]
return None
def get_collection(self, for_type):
self.db = mongo_dbs.get_db().db
coll_names = {'aliases': COLL_ALIASES, 'citizens': COLL_CITIZENS}
if for_type in coll_names:
use_coll_name = coll_names[for_type]
return self.db[use_coll_name]
return None
def get_collection(self, for_type):
self.db = mongo_dbs.get_db().db
coll_names = {'reports':COLL_REPORTS, 'citizens':COLL_CITIZENS}
if for_type in coll_names:
use_coll_name = coll_names[for_type]
return self.db[use_coll_name]
return None
def feed_twt_send_one_post(report_id):
from citizendesk.feeds.twt.send 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:
authorized_id = data['authorized_id']
user_id = data['user_id']
endpoint_id = data['endpoint_id']
tweet_spec = data['tweet_spec']
except:
return (json.dumps(
'provided data should contain "authorized_id", "user_id", "endpoint_id", "tweet_spec" parts'
), 404, {
'Content-Type': 'application/json'
})
sender_url = get_config('newstwister_url')
res = process.do_post_send(mongo_dbs.get_db().db, sender_url,
authorized_id, user_id, endpoint_id, tweet_spec,
report_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_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_sms_citizen_alias_get_one(alias_type, alias_value):
from citizendesk.feeds.sms.citizen_alias import process
logger = get_logger()
client_ip = get_client_ip()
res = process.do_get_one(mongo_dbs.get_db().db, alias_type, alias_value)
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 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_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 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_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_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 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_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_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_twt_authorized_finalize_one(doc_id):
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_finalize_one(mongo_dbs.get_db().db, auther_url, doc_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_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_authorized_delete_one(doc_id):
from citizendesk.feeds.twt.authorized import process
logger = get_logger()
client_ip = get_client_ip()
res = process.do_delete_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 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 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_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_post_one(stream_id):
from citizendesk.feeds.twt.stream 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_post_one(mongo_dbs.get_db().db, stream_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 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 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 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_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'
})
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,)
