def get_coupons(id_brand,
id_shop=None,
id_sale=None,
product_brand=None,
promotion_group=None):
query = [('id_brand', id_brand)]
if id_shop:
if not isinstance(id_shop, list):
id_shop = [id_shop]
for _id in id_shop:
query.append(('id_shop', _id))
if id_sale:
query.append(('id_item', id_sale))
if product_brand:
query.append(('item_brand', product_brand))
if promotion_group:
query.append(('promotion_group', promotion_group))
try:
url = "{}?{}".format(settings.COUPON_LIST_URL, urllib.urlencode(query))
rst = get_from_remote(
url,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
headers={'Content-Type': 'x-www-form-urlencoded'})
coupons_data = xmltodict.parse(rst)
return ActorCoupons(coupons_data)
except Exception, e:
logging.error("Failed to get coupon %s" % query, exc_info=True)
def handle(self, *args, **options):
p = {'from': options['from'], 'to': options['to']}
p = urllib.urlencode(p)
url = settings.STATS_INCOME + '?' + p
try:
data = get_from_remote(
url, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
data = xmltodict.parse(data)
data = data['incomes']
incomes = data.get('income', [])
if not isinstance(incomes, list):
incomes = [incomes]
handled_orders = set()
for income in incomes:
Incomes.objects.create(sale_id=income['id_sale'],
shop_id=income['id_shop'],
users_id=income['@id_user'],
variant_id=income['id_variant'],
price=income['price'],
quantity=income['quantity'],
up_time=income['@up_time'])
handled_orders.add(income['@id_order'])
self.send_feedback(handled_orders)
except Exception, e:
logging.error('stats_visitors_handle_err: %s', e, exc_info=True)
def handle(self, *args, **options):
p = {'from': options['from'], 'to': options['to']}
p = urllib.urlencode(p)
url = settings.STATS_VISITORS + '?' + p
try:
data = get_from_remote(
url, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
data = xmltodict.parse(data)
data = data['visitors']
users = data.get('user', [])
if not isinstance(users, list):
users = [users]
for user in users:
try:
v = Visitors.objects.get(sid=user['@sid'])
v.sid = user['@sid']
v.visit_time = user['visit_time']
v.users_id = user['users_id']
v.save()
except Visitors.DoesNotExist:
Visitors.objects.create(sid=user['@sid'],
users_id=user['users_id'],
visit_time=user['visit_time'])
self.send_feedback(users)
except Exception, e:
logging.error('stats_visitors_handle_err: %s', e, exc_info=True)
def send_cache_invalidation(method, item_name, item_id):
try:
invalidation = '%s/%s/%s' % (method, item_name, item_id)
logging.info("Sending cache invalidation %s" % invalidation)
data = gen_encrypt_json_context(
invalidation, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
get_from_remote(settings.CACHE_INVALIDATION_URL,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
except Exception, e:
logging.error("Failed to send cache invalidation %s" % invalidation,
exc_info=True)
def remote_payment_form(cookie, id_processor, id_trans, **kwargs):
uri = "webservice/1.0/private/payment/form"
query = {
'cookie': cookie,
'processor': id_processor,
}
param = {'id_trans': id_trans}
id_processor = int(id_processor)
if id_processor == PAYMENT_TYPES.PAYPAL:
query.update({
'url_notify': settings.PAYMENT_PAYPAL_GATEWAY % param,
'url_return': settings.PAYMENT_PAYPAL_RETURN % param,
'url_cancel': settings.PAYMENT_PAYPAL_CANCEL % param,
})
elif id_processor == PAYMENT_TYPES.PAYBOX:
query.update({
'url_success': settings.PAYMENT_PAYBOX_SUCCESS % param,
'url_failure': settings.PAYMENT_PAYBOX_FAILURE % param,
'url_cancel': settings.PAYMENT_PAYBOX_CANCEL % param,
'url_waiting': settings.PAYMENT_PAYBOX_WAITING % param,
'url_return': settings.PAYMENT_PAYBOX_GATEWAY % param,
'user_email': kwargs.get('user_email', ''),
})
elif id_processor == PAYMENT_TYPES.STRIPE:
query.update({
'user_email': kwargs.get('user_email', ''),
'url_process': settings.PAYMENT_STRIPE_PROCESS % param,
'url_success': kwargs.get('url_success', ''),
'url_failure': kwargs.get('url_failure', ''),
})
try:
query = ujson.dumps(query)
en_query = gen_encrypt_json_context(
query, settings.SERVER_APIKEY_URI_MAP[SERVICES.FIN],
settings.PRIVATE_KEY_PATH)
resp = get_from_remote(os.path.join(settings.FIN_ROOT_URI, uri),
settings.SERVER_APIKEY_URI_MAP[SERVICES.FIN],
settings.PRIVATE_KEY_PATH,
data=en_query,
headers={'Content-Type': 'application/json'})
return resp
except Exception, e:
logging.error('Failed to get payment form %s,'
'error: %s',
query,
e,
exc_info=True)
raise ServerError('remote_payment_form_err: %s' % str(e))
def _send_feedback(self, url, data):
data = gen_encrypt_json_context(
ujson.dumps(data),
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
resp = get_from_remote(
url,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
return xmltodict.parse(resp)
def _remote_visitors_online(self):
try:
url = settings.STATS_VISITORS_ONLINE
data = get_from_remote(
url,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
visitors_online = ujson.loads(data)['count']
return visitors_online
except Exception, e:
logging.error('remote_visitors_online_err:%s', e)
return '-'
def send_new_shipment(id_order,
id_shop,
id_brand,
shipping_fee,
handling_fee,
content,
shipping_carrier,
packing_status,
tracking_name,
shipping_service=None,
shipping_date=None,
tracking_num=None):
if isinstance(content, list):
content = ujson.dumps(content)
try:
data = {
'action': 'create',
'order': id_order,
'shop': id_shop,
'brand': id_brand,
'handling_fee': handling_fee,
'shipping_fee': shipping_fee,
'content': content,
'shipping_carrier': shipping_carrier,
'packing_status': packing_status,
'tracking_name': tracking_name,
'shipping_service': shipping_service,
'shipping_date': shipping_date,
'tracking_num': tracking_num
}
data = ujson.dumps(data)
data = gen_encrypt_json_context(
data, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
rst = get_from_remote(settings.ORDER_SHIPMENT,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
return rst
except Exception, e:
logging.error('Failed to create shipment %s,'
'error: %s', {
'id_order': id_order,
'id_shop': id_shop,
'content': content
},
e,
exc_info=True)
raise UsersServerError
def handle(self, *args, **options):
url = settings.STATS_VISITORS_ONLINE
try:
data = get_from_remote(
url, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
count = ujson.loads(data)['count']
cli = redis_cli(settings.SALES_SIM_REDIS)
cli.set(VISITORS_ONLINE, count)
except Exception, e:
logging.error('stats_visitors_online: %s', e, exc_info=True)
def get_order_packing_list(order_id):
try:
url = '%s?id_order=%s' % (settings.ORDER_SHIPPING_LIST, order_id)
data = get_from_remote(url,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
return data
except Exception, e:
logging.error(
'Failed to get order(id=%s) shipping list from '
'usr servers: %s',
order_id,
e,
exc_info=True)
raise UsersServerError
def get_order_detail(order_id, brand_id, shops_id):
try:
url = '%s?id=%s&brand_id=%s' % (settings.ORDER_DETAIL_URL, order_id,
brand_id)
if shops_id:
url += "&shops_id=%s" % ujson.dumps(shops_id)
data = get_from_remote(url,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
headers={'Content-Type': 'application/json'})
return ujson.loads(data)
except Exception, e:
logging.error('Failed to get order(id=%s) detail from usr servers',
order_id,
exc_info=True)
raise UsersServerError
def remote_payment_init(data):
uri = "webservice/1.0/private/payment/init"
remote_uri = os.path.join(settings.FIN_SERVER, uri)
try:
data = gen_encrypt_json_context(
data, settings.SERVER_APIKEY_URI_MAP[SERVICES.FIN],
settings.PRIVATE_KEY_PATH)
resp = get_from_remote(remote_uri,
settings.SERVER_APIKEY_URI_MAP[SERVICES.FIN],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
return resp
except Exception, e:
logging.error("Failed to init payment %s" % data, exc_info=True)
raise
def upload(asset_name, content):
remote_uri = os.path.join(
settings.AST_SERVER,
"webservice/1.0/private/upload?name=%s" % urllib2.quote(asset_name))
try:
data = gen_encrypt_json_context(
content.read(), settings.SERVER_APIKEY_URI_MAP[SERVICES.AST],
settings.PRIVATE_KEY_PATH)
resp = get_from_remote(remote_uri,
settings.SERVER_APIKEY_URI_MAP[SERVICES.AST],
settings.PRIVATE_KEY_PATH,
data=data)
return ujson.loads(resp)
except Exception, e:
logging.error("Failed to upload %s" % asset_name, exc_info=True)
raise
def get_from_sale_server(uri, **query):
if not uri.startswith(settings.SALES_SERVER_API_URL):
remote_uri = settings.SALES_SERVER_API_URL % {'api': uri}
else:
remote_uri = uri
if query:
query_str = urllib.urlencode(query)
else:
query_str = ''
try:
content = get_from_remote('?'.join([remote_uri, query_str]),
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
except Exception, e:
logging.error('get_from_sale_server_error: %s', e, exc_info=True)
raise
def remote_send_invoices(id_order, id_brand, id_shops):
try:
if isinstance(id_shops, list):
id_shops = ujson.dumps(id_shops)
query = {'order': id_order, 'brand': id_brand, 'shops': id_shops}
data = get_from_remote(settings.ORDER_SEND_INVOICES,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=ujson.dumps(query),
headers={'Content-Type': 'application/json'})
return data
except Exception, e:
logging.error('Failed to send order(id=%s) invoices for: %s',
id_order,
e,
exc_info=True)
raise UsersServerError
def get_order_list(brand_id, shops_id=None, limit=None):
try:
order_url = '%s?brand_id=%s' % (settings.ORDER_LIST_URL, brand_id)
if shops_id:
order_url += "&shops_id=%s" % ujson.dumps(shops_id)
if limit:
order_url += "&limit=%s" % limit
data = get_from_remote(order_url,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
headers={'Content-Type': 'application/json'})
orders = ujson.loads(data)
for order in orders:
_populate_order_info(order)
return orders
except Exception, e:
logging.error('Failed to get order list from usr servers',
exc_info=True)
raise UsersServerError
def post_coupon(id_brand, id_bo_user, **kwargs):
try:
data = {
'action': 'create',
'id_issuer': id_brand,
'author': id_bo_user,
}
data.update(kwargs)
rst = get_from_remote(
settings.COUPON_CREATE_URL,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=urllib.urlencode(data),
headers={'Content-Type': 'x-www-form-urlencoded'})
coupons_data = xmltodict.parse(rst)
return coupons_data['coupons']['coupon']['@id']
except Exception, e:
logging.error("Failed to create coupon %s" % data, exc_info=True)
def remote_invoices(id_order, id_brand, id_shops):
try:
if isinstance(id_shops, list):
id_shops = ujson.dumps(id_shops)
uri = "%s?order=%s&brand=%s&shops=%s" % (settings.ORDER_INVOICES,
id_order, id_brand, id_shops)
data = get_from_remote(uri,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
return data
except Exception, e:
logging.error(
'Failed to get order(id=%s) invoices from '
'usr servers: %s',
id_order,
e,
exc_info=True)
raise UsersServerError
def get_from_vessel_server(method, path, **query):
remote_uri = os.path.join(settings.VSL_ROOT_URI, path)
if query:
query_str = urllib.urlencode(query)
if method == 'GET':
remote_uri = '?'.join([remote_uri, query_str])
data = None
else:
data = gen_encrypt_json_context(
query_str, settings.SERVER_APIKEY_URI_MAP['VSL'],
settings.PRIVATE_KEY_PATH)
try:
content = get_from_remote(remote_uri,
settings.SERVER_APIKEY_URI_MAP['VSL'],
settings.PRIVATE_KEY_PATH,
data=data)
except Exception, e:
logging.error('get_from_vessel_server: %s', e, exc_info=True)
raise
def remote_payment_init(id_order, id_user, amount, currency, iv_id, iv_numbers,
iv_data):
uri = 'private/payment/init'
remote_uri = settings.SALES_SERVER_API_URL % {'api': uri}
if isinstance(iv_id, list):
iv_id = ujson.dumps(iv_id)
if isinstance(iv_numbers, list):
iv_numbers = ujson.dumps(iv_numbers)
query = {
"order": id_order,
"user": id_user,
"amount": amount,
"currency": currency,
"invoices": iv_id,
"invoices_num": iv_numbers,
"invoicesData": iv_data
}
logging.info("remote_payment_init_query: %s", query)
try:
query = ujson.dumps(query)
en_query = gen_encrypt_json_context(
query, settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
resp = get_from_remote(remote_uri,
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH,
data=en_query,
headers={'Content-Type': 'application/json'})
logging.info("payment_init_response: %s", resp)
return resp
except Exception, e:
logging.error('Failed to get payment init %s,'
'error: %s',
query,
e,
exc_info=True)
raise ServerError('remote_payment_init_err: %s' % str(e))
def remote_delete_order(id_order, id_brand, id_shops):
try:
if isinstance(id_shops, list):
id_shops = ujson.dumps(id_shops)
data = {'order': id_order, 'brand': id_brand, 'shops': id_shops}
data = gen_encrypt_json_context(
ujson.dumps(data), settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
rst = get_from_remote(settings.ORDER_DELETE,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
return rst
except Exception, e:
logging.error('Failed to delete order %s,'
'error: %s', {'id_order': id_order},
e,
exc_info=True)
raise UsersServerError
def send_shipping_fee(id_shipment, id_postage, shipping_fee):
try:
data = {
'id_shipment': id_shipment,
'id_postage': id_postage,
'shipping_fee': shipping_fee
}
data = ujson.dumps(data)
logging.info("Send shipping fee %s" % data)
data = gen_encrypt_json_context(
data, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
rst = get_from_remote(settings.SHIPPING_FEE_URL,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
except Exception, e:
logging.error("Failed to send shipping fee %s" % data, exc_info=True)
def handle(self, *args, **options):
p = {'from': options['from'], 'to': options['to']}
p = urllib.urlencode(p)
url = settings.STATS_ORDER + '?' + p
try:
data = get_from_remote(
url, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
data = xmltodict.parse(data)
data = data['orders']
logs = data.get('log', [])
if not isinstance(logs, list):
logs = [logs]
completed_logs = set()
for log in logs:
shop_id = int(log['id_shop'])
if shop_id == 0:
shop_id = None
obj, _ = Orders.objects.get_or_create(users_id=log['users_id'],
order_id=log['id_order'],
brand_id=log['id_brand'],
shop_id=shop_id)
obj.pending_date = log['pending_date']
obj.waiting_payment_date = log['waiting_payment_date']
obj.waiting_shipping_date = log['waiting_shipping_date']
obj.completed_date = log['completed_date']
obj.save()
if log['completed_date']:
completed_logs.add(log['@id'])
self.send_feedback(completed_logs)
except Exception, e:
logging.error('stats_visitors_handle_err: %s', e, exc_info=True)
def handle(self, *args, **options):
url = settings.STATS_BOUGHT_HISTORY
try:
data = get_from_remote(
url, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
data = xmltodict.parse(data)
data = data['histories']
histories = data.get('item', [])
if not isinstance(histories, list):
histories = [histories]
handled_histories = []
for history in histories:
ht_id = history['@id']
id_sale = history['id_sale']
users_id = history['users_id']
history = BoughtHistory.objects.filter(sale_id=id_sale)
if history.exists():
history = history[0]
cur_users = set(ujson.loads(history.users))
cur_users.add(users_id)
history.users = ujson.dumps(cur_users)
history.save()
else:
BoughtHistory.objects.create(sale_id=id_sale,
users=ujson.dumps(
set([users_id])))
handled_histories.append(ht_id)
self.send_feedback(handled_histories)
except Exception, e:
logging.error('stats_visitors_handle_err: %s', e, exc_info=True)
def send_delete_shipment(id_shipment, id_shop, id_brand):
try:
data = {
'action': 'delete',
'shipment': id_shipment,
'shop': id_shop,
'brand': id_brand
}
data = ujson.dumps(data)
data = gen_encrypt_json_context(
data, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
rst = get_from_remote(settings.ORDER_SHIPMENT,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
return rst
except Exception, e:
logging.error('Failed to delete shipment %s,'
'error: %s', {'id_shipment': id_shipment},
e,
exc_info=True)
raise UsersServerError
def send_update_shipment(id_shipment,
id_shop,
id_brand,
shipping_fee=None,
handling_fee=None,
status=None,
tracking_num=None,
content=None,
shipping_date=None,
tracking_name=None,
shipping_carrier=None):
if isinstance(content, list):
content = ujson.dumps(content)
try:
data = {}
if shipping_fee:
data['shipping_fee'] = shipping_fee
if handling_fee:
data['handling_fee'] = handling_fee
if status:
data['status'] = status
if tracking_num:
data['tracking'] = tracking_num
if content:
data['content'] = content
if shipping_date:
data['shipping_date'] = shipping_date
if tracking_name:
data['tracking_name'] = tracking_name
if shipping_carrier:
data['shipping_carrier'] = shipping_carrier
if not data:
return
data['shipment'] = id_shipment
data['shop'] = id_shop
data['brand'] = id_brand
data['action'] = 'modify'
data = ujson.dumps(data)
data = gen_encrypt_json_context(
data, settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
rst = get_from_remote(settings.ORDER_SHIPMENT,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH,
data=data,
headers={'Content-Type': 'application/json'})
return rst
except Exception, e:
logging.error(
'Failed to update shipment %s,'
'error: %s', {
'id_shipment': id_shipment,
'shipping_fee': shipping_fee,
'handling_fee': handling_fee,
'status': status,
'tracking_num': tracking_num,
'content': content
},
e,
exc_info=True)
raise UsersServerError
