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}