def remote_call(usr_root_uri, api_name, pri_key_path, usr_pub_key_uri, req,
resp, **kwargs):
if api_name not in USR_API_SETTINGS:
raise Exception('wrong api calling: %s' % api_name)
try:
url = usr_root_uri + USR_API_SETTINGS[api_name]['url']
method = USR_API_SETTINGS[api_name]['method']
encrypt = USR_API_SETTINGS[api_name].get('encrypt')
if encrypt is None:
encrypt = re.search('/(private|protected)/', url)
headers = generate_remote_req_headers(req, resp)
remote_resp = _request_remote_server(url, method, kwargs, headers,
encrypt, pri_key_path,
usr_pub_key_uri)
if resp and 'set-cookie' in remote_resp.headers:
set_resp_cookie_header(resp, remote_resp.headers['set-cookie'])
if encrypt:
content = decrypt_json_resp(remote_resp, usr_pub_key_uri,
pri_key_path)
else:
content = remote_resp.read()
try:
return ujson.loads(content)
except:
return content
except Exception, e:
logging.error("Failed to get %s from Users Server %s",
url,
e,
exc_info=True)
return {'res': RESP_RESULT.F, 'err': 'SERVER_ERR'}
def _on_post(self, req, resp, conn, **kwargs):
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
logging.info("payment_init_request: %s", data)
data = ujson.loads(data)
id_trans = create_trans(conn,
data['order'],
data['user'],
data['invoices'],
data['invoices_num'],
data['amount'],
data['currency'],
data['invoicesData'])
pm_cookie = {"id_user": long(data['user']),
"id_order": long(data['order']),
"amount_due": data['amount'],
"id_invoices": data['invoices'],
"internal_trans": id_trans}
pm_cookie = ujson.dumps(pm_cookie)
update_trans(conn,
{'cookie': pm_cookie},
where={'id': id_trans})
pm_init = self.procession_options(conn)
return {'pm_init': pm_init,
'cookie': pm_cookie}
def _get_from_server(self, obj_id=None, **kw):
if obj_id is None:
query = self._get_query_str(**kw)
api = self.list_api % query
else:
api = self.obj_api % obj_id
logging.info('fetch from sales server : %s', api)
req = urllib2.Request(
settings.SALES_SERVER_API_URL % {'api': api})
resp = urllib2.urlopen(req)
if self.need_decrypt:
xmltext = decrypt_json_resp(resp,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
else:
xmltext = resp.read()
is_entire_result = (obj_id is None and query == '')
valid = self.validate_xml(xmltext, obj_id is None)
if not valid:
logging.debug("invalidate xml response: %s", xmltext, exc_info=True)
raise ServerError("invalidate %s" % api)
return self.parse_xml(xmltext, is_entire_result, **kw)
def valid_check(self, conn, req, **kwargs):
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[self.service],
settings.PRIVATE_KEY_PATH)
logging.info("payment_ajax_request: %s", data)
data = ujson.loads(data)
try:
cookie = ujson.loads(data['cookie'])
trans = get_trans_by_id(conn, cookie['internal_trans'])
assert len(trans) == 1, "No trans for cookie %s" % cookie
trans = trans[0]
assert data['cookie'] == trans['cookie'], (
"invalid cookie: %s expected: %s"
% (cookie, trans['cookie']))
id_card = CCAddResource().add_card(conn, {
'id_user': trans['id_user'],
'pan': data.get('pan'),
'cvc': data.get('cvc'),
'expiration_date': data.get('expiration_date'),
'repeat': data.get('repeat'),
})
card = db_utils.select(conn, 'credit_card',
where={'id': id_card, 'valid': True})[0]
return trans, card
except AssertionError, e:
logging.error("pm_ajax_invalid_request, param : %s "
"error: %s", data, e, exc_info=True)
raise UserError(ErrorCode.PMA_INVALID_REQ[0],
ErrorCode.PMA_INVALID_REQ[1])
def post_to_sale_server(uri, data=None):
if not uri.startswith(settings.SALES_SERVER_API_URL):
remote_uri = settings.SALES_SERVER_API_URL % {'api': uri}
else:
remote_uri = uri
try:
encrypt = re.search('/(private|protected)/', remote_uri)
if encrypt and data:
data = gen_encrypt_json_context(
data, settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
req = urllib2.Request(remote_uri, data=data)
remote_resp = urllib2.urlopen(req)
if encrypt:
content = decrypt_json_resp(
remote_resp, settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
else:
content = remote_resp.read()
return content
except Exception, e:
logging.error('post_to_sale_server_error: %s', e, exc_info=True)
raise
def _on_post(self, req, resp, conn, **kwargs):
try:
data = decrypt_json_resp(
req.stream, settings.SERVER_APIKEY_URI_MAP[self.service],
settings.PRIVATE_KEY_PATH)
data = ujson.loads(data)
id_card = self.add_card(conn, data)
except ThirdPartyError, e:
return {"res": RESP_RESULT.F, "err": e.desc}
def _on_post(self, req, resp, conn, **kwargs):
try:
data = decrypt_json_resp(
req.stream, settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
params = ujson.loads(data)
req._params.update(params)
except Exception, e:
logging.error("sensor_requeset_err: %s", str(e), exc_info=True)
raise
def on_post(self, req, resp, **kwargs):
try:
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
logging.info("Received cache invalidation %s" % data)
method, obj_name, obj_id = data.split('/')
except Exception, e:
logging.error("Got exceptions when decrypting invalidation data",
exc_info=True)
self.gen_resp(resp, {'res': RESP_RESULT.F})
def _on_post(self, req, resp, conn, **kwargs):
try:
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
logging.info("payment_form_request: %s", data)
query = ujson.loads(data)
trans = self.valid_check(conn, query)
return self.payment_form(query, trans)
except Exception, e:
logging.error('payment_form_err: %s', e, exc_info=True)
raise
def _on_post(self, req, resp, conn, **kwargs):
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
data = ujson.loads(data)
order_id = data.get('order')
brand_id = data.get('brand')
shops_id = data.get('shops')
shops_id = [int(id_shop) for id_shop in ujson.loads(shops_id)]
success = delete_order(conn, order_id, brand_id, shops_id)
return {'res': RESP_RESULT.S if success else RESP_RESULT.F}
def on_post(self, req, resp, **kwargs):
try:
logging.info('Shipping_fee_request: %s' % req.stream)
data = decrypt_json_resp(
req.stream, settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
logging.info("Received shipping fee %s" % data)
data = ujson.loads(data)
except Exception, e:
logging.error("Got exceptions when decrypting shipping fee %s" % e,
exc_info=True)
self.gen_resp(resp, {'res': RESP_RESULT.F})
def _on_post(self, req, resp, conn, **kwargs):
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
data = ujson.loads(data)
req._params.update(data)
action = req.get_param('action')
if action is None or action not in self.post_action_func_map:
logging.error('%s: action %s', E_C.ERR_EREQ[1], action)
return {'res': FAILURE, 'err': E_C.ERR_EREQ[1]}
func = getattr(self, self.post_action_func_map[action], None)
assert hasattr(func, '__call__')
return func(req, resp, conn)
def _on_post(self, req, resp, conn, **kwargs):
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
data = ujson.loads(data)
action = data.get('action')
if action is None or action not in self.post_action_func_map:
return {'res': RESP_RESULT.F, 'err': E_C.ERR_EREQ[1]}
func = getattr(self, self.post_action_func_map[action], None)
assert hasattr(func, '__call__')
try:
func(req, resp, conn, data.get('id_order'), data.get('id_brand'))
except Exception, e:
logging.error("Failed to change order status: %s" % e,
exc_info=True)
return {'res': RESP_RESULT.F, 'err': str(e)}
def _on_post(self, req, resp, **kwargs):
rel_path = req.get_param('name', required=True)
storage_path = os.path.join(settings.STATIC_FILES_PATH, rel_path)
storage_path = self.get_available_name(storage_path)
dir_name, file_name = os.path.split(storage_path)
if not os.path.exists(dir_name):
os.makedirs(dir_name)
content = decrypt_json_resp(
req.stream, settings.SERVER_APIKEY_URI_MAP[self.service],
settings.PRIVATE_KEY_PATH)
with open(storage_path, 'wb') as _f:
_f.write(content)
resp.status = falcon.HTTP_201
new_rel_path = "%s/%s" % (os.path.dirname(rel_path), file_name)
return {'res': RESP_RESULT.S, 'location': new_rel_path}
def _on_post(self, req, resp, conn, **kwargs):
f = StringIO(req.query_string)
data = decrypt_json_resp(f,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
f.close()
form_params = cgi.parse_qs(data)
for p in form_params:
form_params[p] = form_params[p][0]
action = form_params.get('action')
id_user = form_params.get('id_user')
email = form_params.get('email')
imo = form_params.get('imo')
mmsi = form_params.get('mmsi')
if action not in ('add', 'delete'):
raise ValidationError('INVALID_REQUEST')
if not id_user or not email or not imo or not mmsi:
raise ValidationError('INVALID_REQUEST')
values = {
'id_user': id_user,
'email': email,
'imo': imo,
'mmsi': mmsi,
'done': False,
}
if action == 'add':
records = db_utils.select(conn,
"vessel_arrival_notif",
columns=("imo", "mmsi"),
where=values)
if len(records) == 0:
db_utils.insert(conn, "vessel_arrival_notif", values=values)
elif action == 'delete':
db_utils.delete(conn, "vessel_arrival_notif", where=values)
return {'res': RESP_RESULT.S}
def _on_post(self, req, resp, conn, **kwargs):
data = decrypt_json_resp(req.stream,
settings.SERVER_APIKEY_URI_MAP[self.service],
settings.PRIVATE_KEY_PATH)
data = ujson.loads(data)
id_card = data.get('id_card')
if not id_card:
raise ValidationError('Missing post param id_card')
results = db_utils.select(conn, 'credit_card', where={'id': id_card})
if not results:
raise ValidationError('Invalid param id_card')
try:
cli = Paybox()
cli.delete_card(id_card,
results[0]['id_user'],
results[0]['paybox_token'],
results[0]['expiration_date'],
repeat=results[0]['repeat'])
except ThirdPartyError, e:
return {"res": RESP_RESULT.F, "err": e.desc}
