def on_post(self, request, response, rider_id=None):
if not rider_id:
raise falcon.HTTPPreconditionFailed("Rider id not provided")
rider = helpers.get_rider(rider_id)
if not rider:
raise falcon.HTTPPreconditionFailed("Rider with id: {} not found".format(rider_id))
if rider.riding:
raise falcon.HTTPUnprocessableEntity("Rider is already riding")
body = json.load(request.stream)
pickup_location = body.get("pickup_location")
drop_location = body.get("drop_location")
if not pickup_location or not drop_location:
raise falcon.HTTPPreconditionFailed("Pickup or Drop location not specified")
try:
ride = Ride(Location(**pickup_location), Location(**drop_location), rider)
except Exception as e:
raise falcon.HTTPUnprocessableEntity(e)
taxi_category = body.get("category")
taxi = helpers.get_nearest_available_taxi(Location(**pickup_location), taxi_category)
if not taxi:
ride.set_taxi_unavailable()
raise falcon.HTTPUnprocessableEntity("Taxi is unavailable")
ride.start(taxi)
RIDES.append(ride)
response.body = json.dumps({"message": "Ride registered.", "data": ride.to_dict()})
response.status = falcon.HTTP_201
def __init__(self, max_calls, time_period=1.0):
"""
Initialization method for RateLimiterManager.
Args:
max_calls (int): Maximum number of calls for the server.
time_period (float): Time limit for the API. This time is set to 1.0.
Returns:
None
Status:
Expiremental
Raises:
falcon.HTTPPreconditionFailed
"""
if time_period <= 0:
raise falcon.HTTPPreconditionFailed(
title="Server HTTP Pre-Condition Failed",
description="Time period cannot be less than 0.",
)
if max_calls <= 0:
raise falcon.HTTPPreconditionFailed(
title="Server HTTP Pre-Condition Failed",
description="Maximum number of calls should be more than 0.",
)
self.calls = collections.deque()
self.max_calls = max_calls
self.time_period = time_period
self._timespan = 0
def parse_schedule_at(self, val):
"""
Tries to parse the schedule_at parameter and get the datetime value for scheduling
:param val: schedule_at rest parameter
:return: countdown in seconds or raising HTTPPreconditionFailed if parsing errored
"""
if val is None:
return 0
else:
# Do we have a ISO Date format ?
try:
schedule_at = datetime.strptime(val, '%Y-%m-%d %H:%M:%S')
if schedule_at < datetime.now():
raise falcon.HTTPPreconditionFailed(
'Cannot schedule batch in past date',
"Invalid past date given: %s" % schedule_at)
except ValueError:
# Do we have Seconds format ?
m = re.match("^(\d+)s$", val)
if not m:
raise falcon.HTTPPreconditionFailed(
'Cannot parse scheduled_at value',
("Got unknown format: %s, correct formats are "
"'YYYY-MM-DD mm:hh:ss' or number of seconds, "
"c.f. http://docs.jasminsms.com/en/latest/apis/rest")
% val)
return int(m.group(1))
else:
return (schedule_at - datetime.now()).total_seconds()
def on_post(self, req, resp):
doc = req.context['doc']
try:
obj = PatternPhraseManager()
results = {"message": ""}
if not obj.add_phrase(doc):
results[
'message'] = "A record with the same name exists in the database"
resp.status = falcon.HTTP_BAD_REQUEST
else:
results['message'] = "Added successfully"
resp.status = falcon.HTTP_200
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
def on_post(self, req, resp):
doc = req.context['doc']
language = get(doc, "language", "EN")
results = {}
try:
obj = PatternPhraseManager()
if language is not None:
patterns = self.format_result(
obj.fetch_all_patterns_by_language(language))
phrases = self.format_result(
obj.fetch_all_phrases_by_language(language))
results['patterns'] = patterns
results['phrases'] = phrases
else:
raise Exception("Model Language not specified...")
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def test_http_precondition_failed_no_title_and_desc_and_challenges(self):
try:
raise falcon.HTTPPreconditionFailed()
except falcon.HTTPPreconditionFailed as e:
self.assertEqual(status.HTTP_412, e.title,
'The title should be ' + status.HTTP_412 + ', but it is: ' + e.title)
self.assertEqual(None, e.description, 'The description should be None')
def on_post(req, resp):
logger.info(req.context)
doc = req.context['doc'] or {}
data_dict = {}
organisation_name = req.get_header('organisation-name', True)
try:
count = 0
for item in doc.values():
if validate_project_organisation(item, organisation_name):
data_dict["import" + str(count)] = [{
"datasource":
get_datasource(item)[0]
}]
count += 1
else:
data_dict["import" + str(count)] = [{
"datasource":
"given Project Id is not "
"mapped to organisation_id"
}]
count += 1
except AssertionError as ae:
logger.exception(ae.message, exc_info=True)
logger.info(type(traceback.format_exc()))
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex.message)
raise falcon.HTTPServiceUnavailable('Service Outage', str(ex), 30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
resp.data = {"data": data_dict}
def test_http_precondition_faild_with_title_and_desc_and_challenges(self):
try:
raise falcon.HTTPPreconditionFailed(title='Test', description='Testdescription')
except falcon.HTTPPreconditionFailed as e:
self.assertEqual('Test', e.title, 'Title should be "Test"')
self.assertEqual('Testdescription', e.description,
'Description should be "Testdescription"')
def on_get(self, req, resp, name):
t1 = time()
names = name.split("&")
prototxt = os.path.join(cfg.ROOT_DIR, 'models/CaffeNet/test.prototxt')
caffemodel = os.path.join(
cfg.ROOT_DIR, 'data/fast_rcnn_models/'
'caffenet_fast_rcnn_iter_40000.caffemodel')
if not os.path.isfile(caffemodel):
raise falcon.HTTPPreconditionFailed("Error",
"Caffe model not found")
caffe.set_mode_cpu()
net = caffe.Net(prototxt, caffemodel, caffe.TEST)
classes = read_synset(self.storage_path)
ext = os.path.splitext(names[0])[1][1:]
image_path = os.path.join(self.storage_path, names[0])
im = cv2.imread(image_path)
rects = []
dlib.find_candidate_object_locations(im,
rects,
min_size=np.size(im, 1))
obj_proposals = np.empty((len(rects), 4), dtype=int)
for k, d in enumerate(rects):
obj_proposals[k] = [d.left(), d.top(), d.right(), d.bottom()]
scores, boxes = im_detect(net, im, obj_proposals)
CONF_THRESH = 0.9
NMS_THRESH = 0.3
for cls in classes:
if str(cls).startswith('__background__'):
continue
cls_ind = CLASSES.index(cls)
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
keep = np.where(cls_scores >= CONF_THRESH)[0]
cls_boxes = cls_boxes[keep, :]
cls_scores = cls_scores[keep]
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(dets, NMS_THRESH)
dets = dets[keep, :]
vis_detections(im, cls, dets, thresh=CONF_THRESH)
result_image_path = os.path.join(self.storage_path,
"{0}.{1}".format(_generate_id(), ext))
if 'image/jpeg' == mimetypes.guess_type(image_path, strict=False):
cv2.imwrite(result_image_path, im,
[int(cv2.IMWRITE_JPEG_QUALITY), 100])
else:
cv2.imwrite(result_image_path, im)
t2 = time() - t1
data_size = os.path.getsize(image_path)
data_size += os.path.getsize(result_image_path)
data_size /= 1024.0 * 1024.0
cost = estimate_cost.estimateCost(data_size, t2, data_size)
resp.status = falcon.HTTP_200 # OK
resp.body = os.path.split(result_image_path)[1] + '&' + str(
os.path.getsize(result_image_path) / 1024) + '&' + str(
t2 * 1000.0) + '&' + "{:2.5f}".format(cost)
def on_post(self, req, resp):
log_flag = False
if app_config['BOTANALYTICS_LOG_FLAG'].upper() == "ON":
log_flag, req_id, botanalytics, start_time = True, str(
uuid.uuid4()), BotAnalyticsAPI(), datetime.datetime.now()
doc = req.context['doc']
validate_prediction_request(doc)
config = validate_service_id_and_cache(doc)
try:
if log_flag:
results = predict_impl(doc, config, req_id)
botanalytics.log(
requesttype="nerpredictdetails",
serviceid=doc['serviceid'],
req_id=req_id,
predict_entities=[i['tag'] for i in results['entities']],
predict_intent=get(results, 'intent.top_intent'),
ner_req_timestamp=start_time.replace(
microsecond=0).isoformat())
else:
results = predict_impl(doc, config)
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
if not ex:
description = 'Internal Server Error, Please try again later'
else:
description = ex
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
finally:
update_last_access_to_predict_api(get(doc, 'serviceid'))
if log_flag:
end_time = datetime.datetime.now()
total_time = relativedelta(end_time, start_time)
botanalytics.log(
requesttype="nerrequests",
serviceid=doc['serviceid'],
req_id=req_id,
action="PREDICT",
ner_req_timestamp=start_time.replace(
microsecond=0).isoformat(),
ner_req_end_timestamp=end_time.replace(
microsecond=0).isoformat(),
total_action_time=(total_time.hours * 60 * 60 * 1000 +
total_time.minutes * 60 * 1000 +
total_time.seconds * 1000) +
(total_time.microseconds / 1000))
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
log_flag = False
if app_config['BOTANALYTICS_LOG_FLAG'].upper() == "ON":
log_flag, req_id, botanalytics, start_time = True, str(
uuid.uuid4()), BotAnalyticsAPI(), datetime.datetime.now()
doc = req.context['doc']
try:
results = tag(doc)
resp.data = results
### BotAnalytics tag api results logging
if log_flag:
botanalytics.log(
requesttype="nertagdetails",
serviceid=doc['serviceid'],
req_id=req_id,
tag_custom_tags=[i['tag'] for i in results['custom_tags']],
tag_default_tags=[
i['tag'] for i in results['default_tags']
])
except AssertionError as ex:
logger.exception(ex, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Assertion Error, Please contact admin for assistance',
traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
logger.error(traceback.format_exc())
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
finally:
### BotAnalytics tag api call logging
if log_flag:
end_time = datetime.datetime.now()
total_time = relativedelta(end_time, start_time)
botanalytics.log(
requesttype="nerrequests",
serviceid=doc['serviceid'],
req_id=req_id,
action="TAG",
ner_req_timestamp=start_time.replace(
microsecond=0).isoformat(),
ner_req_end_timestamp=end_time.replace(
microsecond=0).isoformat(),
total_action_time=(total_time.hours * 60 * 60 * 1000 +
total_time.minutes * 60 * 1000 +
total_time.seconds * 1000) +
(total_time.microseconds / 1000))
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
doc = req.context['doc'] or {}
try:
home_dir = os.path.expanduser('~')
model_store_path = os.path.join(home_dir + os.sep +
'.verbis/store')
model_store = get_model_store()
manager = ProjectManager()
serviceid = doc['serviceid']
query = {'serviceid': serviceid}
data = manager.find_model(query)
engine = get(data, "engine", "ICE")
model_name = get_model_name(serviceid, MODEL_TYPE_NER, engine)
model_lists = model_store.get_active_models()
logger.info("model lists - %s" % model_lists)
if model_name in model_lists:
model_store.unpublish(serviceid, MODEL_TYPE_NER, engine)
model_name = get_model_name(serviceid, MODEL_TYPE_IR, engine=None)
logger.info(model_name)
if model_name in model_lists:
model_store.unpublish(serviceid, MODEL_TYPE_IR, engine=None)
logger.info("path is %s" %
os.path.join(model_store_path + os.sep + serviceid))
# delete model file from local
if os.path.exists(
os.path.join(model_store_path + os.sep + serviceid)):
# print "path exists, so do rm."
shutil.rmtree(
os.path.join(model_store_path + os.sep + serviceid))
# delete model file from minio
VerbisStore().remove_models_from_remote(serviceid)
logger.info("files removed successfully")
# update DB
document = {"$set": {"ner.status": 'new', "ir.status": 'new'}}
manager.update_config(query, document)
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
logger.error(traceback.format_exc())
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal Verbis')
resp.status = falcon.HTTP_200
def decode_request_data(self, request):
"""Decode the request stream and return a valid json"""
try:
request_data = request.stream.read()
params = json.loads(request_data)
except Exception as e:
raise falcon.HTTPPreconditionFailed('Cannot parse JSON data',
'Got unparseable json data: %s' % request_data)
else:
return params
def __init__(self, black_ip_address):
if black_ip_address is None:
raise falcon.HTTPPreconditionFailed(
title="Server precondition failed",
description="list of black listed IPs cannot be empty.",
)
if isinstance(black_ip_address, list) is not True:
raise falcon.HTTPBadRequest(
title="Bad Request",
description="Black listed IP must be passed as a list.",
)
else:
self.black_ip = black_ip_address
def on_patch(self, request, response, rider_id=None):
if not rider_id:
raise falcon.HTTPPreconditionFailed("Rider id not provided")
rider = helpers.get_rider(rider_id)
if not rider:
raise falcon.HTTPPreconditionFailed("Rider with id: {} not found".format(rider_id))
if not rider.riding:
raise falcon.HTTPUnprocessableEntity("Rider is currently not riding")
body = json.load(request.stream)
end_ride = body.get("end_ride", False)
if not end_ride:
raise falcon.HTTPBadRequest
rider_current_ride = helpers.get_rider_current_ride(rider_id)
if not rider_current_ride:
raise falcon.HTTPUnprocessableEntity("Current ride of Rider: {} not found".format(rider))
rider_current_ride.stop()
response.body = json.dumps({"message": "Ride has ended", "data": rider_current_ride.to_dict()})
response.status = falcon.HTTP_200
def on_post(self, req, resp):
doc = req.context['doc'] or {}
try:
serviceid = doc["serviceid"]
# delete model file
uncache_project_if_exists(serviceid)
resp.data = {'status': 'project deletion successful.'}
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.info(type(traceback.format_exc()))
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex)
raise falcon.HTTPServiceUnavailable('Service Outage', str(ex), 30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_patch(self, req, resp):
"""
patch a file.
:param req: falcon.Request
:param resp: falcon.Response
:return: None
"""
start = time.time()
path = req.path
try:
offset = int(req.get_param('offset'))
except TypeError:
offset = 0
content_length = int(req.get_header('Content-Length'))
try:
write_file_chunk(self.get_local_path(path),
stream=req.stream,
offset=offset,
chunk_size=content_length,
checksum=req.get_header('x-checksum'),
checksum_type=req.get_header('x-checksum-type'))
except InvalidChecksumException:
self._error_to_response(
resp,
falcon.HTTPPreconditionFailed('CHECKSUM_FAIL',
'Checksum mismatch.'))
resp.text = 'OK'
resp.append_header('x-start', "%.6f" % start)
resp.append_header('x-end', "%.6f" % time.time())
path = req.path
headers = self._extract_headers(req)
data = self._data(
path=path,
parts=['%d-%d' % (offset, offset + content_length - 1)],
headers=headers)
self._add_metadata_to_resp(resp, data)
def on_post(self, req, resp):
doc = req.context['doc']
try:
obj = PatternPhraseManager()
obj.remove_phrase(doc)
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
category = req.get_param(name='category', required=True)
name = req.get_param(name='name', required=True)
desc = req.get_param(name='desc', required=True)
utterance_file = req.get_param(name='file', required=True)
try:
df = pd.read_excel(io=utterance_file.file, header=None)
df.dropna(inplace=True)
utterances = list(df.iloc[:, 0])
doc = {}
doc['categoryName'] = category
doc['intentName'] = name
doc['intentDesc'] = desc
utterances_updated = utterance_recase(utterances)
doc['utterances'] = utterances_updated
obj = PredefinedIntentManager()
results = {"message": ""}
if not obj.add_intent(doc):
results[
'message'] = "A record with the same intent name exists under the %s category" % doc[
'categoryName']
resp.status = falcon.HTTP_BAD_REQUEST
else:
results['message'] = "Added successfully"
resp.status = falcon.HTTP_200
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp = json.dumps({"msg": "Successfully Added"})
resp.set_header('X-Powered-By', 'USTGlobal ICE')
def on_post(self, req, resp):
category = req.get_param(name='category', required=True)
data = req.get_param(name='file', required=True)
try:
df = pd.read_excel(io=data.file, header=None)
df.dropna(inplace=True)
utterances = list(df.iloc[:, 0])
utterances_updated = utterance_recase(utterances)
names = list(df.iloc[:, 1])
logger.info(df.columns)
if 2 not in df.columns:
desc = [""] * len(utterances_updated)
else:
desc = list(df.iloc[:, 2])
data = {}
for i in range(len(names)):
if names[i] in list(data.keys()):
data[names[i]][0].append(utterances_updated[i])
else:
data[names[i]] = [[utterances_updated[i]], desc[i]]
obj = PredefinedIntentManager()
obj.add_intent_by_category(data, category)
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
try:
doc = req.context['doc']
language = "EN"
if dict_contains(doc, 'language'):
language = doc['language']
ice_entity_config = IceEntitiesModelManager().get_ice_entities(
language)
predefined_entity_mappings = PreTrainedEntityModelManager(
).get_entity_models(language)
predefined_entity_models = group_entities(
ice_entity_config, predefined_entity_mappings)
results = {
"predefined_entity_models":
predefined_entity_models,
"custom_entity_models":
CustomEntityModelManager().get_entity_models(language),
"default_predefined_modelClass":
default_predefined_modelClass_dic[language],
"default_custom_modelClass":
default_custom_modelClass_dic[language]
}
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
append = req.get_param(name="append", required=True)
category = req.get_param(name='category', required=True)
name = req.get_param(name='name', required=True)
desc = req.get_param(name='desc', required=True)
utterance_file = req.get_param(name='file', required=True)
try:
df = pd.read_excel(io=utterance_file.file, header=None)
df.dropna(inplace=True)
utterances = list(df.iloc[:, 0])
doc = {}
doc['categoryName'] = category
doc['intentName'] = name
doc['intentDesc'] = desc
utterances_updated = utterance_recase(utterances)
doc['utterances'] = utterances_updated
obj = PredefinedIntentManager()
if append.lower() == "true":
obj.update_intent(doc)
else:
obj.replace_intent(doc)
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def on_get(self, req, resp):
category = req.get_param(name="category", default=None)
try:
obj = PredefinedIntentManager()
if category is None:
results = obj.get_all_intent()
else:
results = obj.get_intent_by_category(category)
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def process_request(self, req, resp):
freePaths = [
"/login-POST",
]
pathWithMethod = (req.path + "-" + req.method)
if pathWithMethod not in freePaths:
if req.auth == '':
raise falcon.HTTPPreconditionFailed(
"Token Validation", "A token valid is required")
else:
result = db.first(
"""select id,role from gambler
where token like %s and is_disabled = false""",
(req.auth, ))
if result == None:
raise falcon.HTTPUnauthorized('Token Validation',
'This token has expired')
else:
req.context["userid"] = result["id"]
req.context["role"] = result["role"]
def on_post(self, req, resp):
name = req.get_param(name="name", required=True)
language = req.get_param(name="language", default="EN")
try:
obj = PreTrainedEntityModelManager()
query = {"name": name, "language": language.upper()}
results = obj.get_entity(query)
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def handle(ex, req, resp, params):
raise falcon.HTTPPreconditionFailed(
"X and Y are not fitting with the first image.")
def on_post(self, request, response):
"""
POST /secure/sendbatch request processing
Note: Calls Jasmin http api /send resource
"""
# Authentify user before proceeding
status, _ = self.call_jasmin('balance',
params={
'username':
request.context['username'],
'password':
request.context['password']
})
if status != 200:
raise falcon.HTTPPreconditionFailed(
'Authentication failed', "Authentication failed for user: %s" %
request.context['username'])
batch_id = uuid.uuid4()
params = self.decode_request_data(request)
syslog.syslog(syslog.LOG_INFO, "Printing Request" + str(params))
syslog.syslog(syslog.LOG_INFO, "Request type" + str(type(params)))
config = {
'throughput': http_throughput_per_worker,
'smart_qos': smart_qos
}
# Batch scheduling
countdown = self.parse_schedule_at(params[0].get(
'batch_config', {}).get('schedule_at', None))
message_count = 0
for _message_params in params[0].get('messages', {}):
# Construct message params
message_params = {
'username': request.context['username'],
'password': request.context['password']
}
message_params.update(params[0].get('globals', {}))
message_params.update(_message_params)
# Convert _ to -
# Added for compliance with json encoding/decoding constraints on dev env like .Net
for k, v in message_params.iteritems():
del (message_params[k])
message_params[re.sub('_', '-', k)] = v
# Ignore message if these args are not found
if 'to' not in message_params or ('content' not in message_params
and 'hex-content'
not in message_params):
continue
# Do we have multiple destinations for this message ?
if isinstance(message_params.get('to', ''), list):
to_list = message_params.get('to')
for _to in to_list:
message_params['to'] = _to
if countdown == 0:
httpapi_send.delay(batch_id,
params[0].get('batch_config', {}),
message_params, config)
else:
httpapi_send.apply_async(args=[
batch_id, params[0].get('batch_config', {}),
message_params, config
],
countdown=countdown)
message_count += 1
else:
if countdown == 0:
httpapi_send.delay(batch_id,
params[0].get('batch_config', {}),
message_params, config)
else:
httpapi_send.apply_async(args=[
batch_id, params[0].get('batch_config', {}),
message_params, config
],
countdown=countdown)
message_count += 1
response.body = {
'data': {
"batchId": '%s' % batch_id,
"messageCount": message_count
}
}
if countdown > 0:
response.body['data']['scheduled'] = '%ss' % countdown