def step_impl(context, user):
woid = context.woid
app_id = context.app_id
app_secret = context.app_secret
params = {'woid': woid}
resp = Resource.use("apiserver").put({
'resource': 'user.token',
'data': params
})
if resp and resp.get('code') == 200:
apiserver_access_token = resp.get('data').get('access_token')
logging.info("apiserver_access_token : %s" % apiserver_access_token)
context.apiserver_access_token = apiserver_access_token
app = App.objects.get(woid=woid)
app.apiserver_access_token = apiserver_access_token
app.save()
params = {'appid': app_id, 'secret': app_secret}
resp = Resource.use("openapi").get({
'resource': 'auth.access_token',
'data': params
})
if resp and resp.get('code') == 200:
openapi_access_token = resp.get('data').get('access_token')
logging.info("openapi_access_token : %s" % openapi_access_token)
context.openapi_access_token = openapi_access_token
def api_put(request):
#给接口传递发货的参数
__method = request.POST.get('__method', '')
params = {
'order_id': request.POST.get('order_id', ''),
'express_company_name': request.POST.get('express_company_name',
''),
'express_number': request.POST.get('express_number', ''),
'leader_name': request.POST.get('leader_name', ''),
'operator_name': request.user.username
}
if __method == 'put':
#发货
res = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).put({
'resource': 'mall.delivery',
'data': params
})
else:
#修改物流
res = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).post({
'resource': 'mall.delivery',
'data': params
})
if res and res['data']['result'] == u'SUCCESS':
response = create_response(200)
return response.get_response()
else:
response = create_response(500)
response.errMsg = res['data']['msg']
return response.get_response()
def process(data, recv_msg=None):
corp_id = data['corp_id']
delivery_item_id = data['delivery_item_id']
data = {'corp_id': corp_id, 'delivery_item_id': delivery_item_id}
Resource.use('gaia').put({
'resource': 'delivery_item.phone_message',
'data': data
})
def step_impl(context, user, product_name):
param_data = {
'woid': context.woid,
"access_token": context.openapi_access_token
}
resp = Resource.use('openapi').get({
'resource': 'mall.products',
'data': param_data
})
data = []
product_id = None
if resp and resp['code'] == 200:
data = resp['data']['items']
for product in data:
if product['name'] == product_name:
product_id = product['id']
break
if product_id:
param_data = {
'woid': context.woid,
'product_id': product_id,
"access_token": context.openapi_access_token
}
resp = Resource.use('openapi').get({
'resource': 'mall.product',
'data': param_data
})
data = []
if resp and resp['code'] == 200:
data = resp['data']
print '=========data============', data
actual_product = {}
actual_product['name'] = data['name']
actual_product['price'] = float(
data['price_info']['display_price'])
actual_product['weight'] = float(data['models'][0]['weight'])
actual_product['image'] = data['thumbnails_url'].replace(' ', '')
actual_product['stocks'] = float(data['total_stocks'])
actual_product['detail'] = data['detail'][15:-18] if data[
'detail'].startswith("<html>") else data['detail']
actual_product['unified_postage_money'] = data[
'unified_postage_money']
actual_product['postage_type'] = data['postage_type']
actual_product['supplier_postage_config'] = data[
'supplier_postage_config']
if not hasattr(context, 'product_name2id'):
context.product_name2id = {}
context.product_name2id[data['name']] = product_id
expected = json.loads(context.text)
bdd_util.assert_dict(expected, actual_product)
else:
1 / 0
def get_shelve_on_product(weapp_product_ids=None,
product_2_weapp_product=None):
"""
获取上架的商品
"""
# 获取商品是否上线
product_shelve_on = []
if weapp_product_ids:
weapp_product_ids = '_'.join(
[str(product_id) for product_id in weapp_product_ids])
params = {'product_ids': weapp_product_ids}
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).get({
'resource':
'mall.product_status',
'data':
params
})
# 已上架商品列表
if resp and resp.get('code') == 200:
product_status = resp.get('data').get('product_status')
product_shelve_on = [
product_2_weapp_product.get(
int(product_statu.get('product_id')))
for product_statu in product_status
if product_statu.get('status') == 'on'
]
return product_shelve_on
def api_delete(request):
value_id = request.POST.get('value_id', 0)
response = create_response(500)
try:
if value_id != 0:
models.ProductModelPropertyValue.objects.filter(
id=value_id).delete()
response = create_response(200)
relation = models.ProductModelPropertyValueRelation.objects.filter(
property_value_id=value_id).first()
if relation:
params = {
'id': relation.weapp_property_value_id,
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).delete({
'resource':
'mall.model_property_value',
'data':
params
})
if not resp or not resp.get('code') == 200:
response = create_response(500)
except:
msg = unicode_full_stack()
response.innerErrMsg = msg
watchdog.error(msg)
return response.get_response()
def step_impl(context, user):
data = {}
data['woid'] = context.woid
data['access_token'] = context.openapi_access_token
data['apiserver_access_token'] = context.apiserver_access_token,
if hasattr(context, 'order_id'):
order_id = context.order_id
del context.order_id
# order_id ='001'
data['order_id'] = order_id
resp = Resource.use('openapi').get({
'resource': 'mall.order',
'data': data
})
actual_order = {}
if resp:
code = resp['code']
if code == 200:
actual_order = resp['data']['order']
expected = json.loads(context.text)
ship_address = expected['ship_address']
ship_area = expected['ship_area']
expected_order = {
'order_status': ORDER_STATUS2ID[expected['status']],
'ship_address': ship_address,
'ship_area': ship_area,
'ship_name': expected['ship_name'],
'ship_tel': expected['ship_tel'],
'postage': expected['postage'],
'final_price': expected['final_price'],
'sub_orders': []
}
if expected_order['order_status'] != 0 and actual_order['sub_orders']:
for sub_order in expected['group']:
tmp_order = {
'postage': sub_order['postage'],
'order_status': ORDER_STATUS2ID[sub_order['status']],
'products': []
}
for product in sub_order['products']:
tmp_order['products'].append({
'product_name': product['name'],
'price': product['price'],
'product_count': product['count'],
})
expected_order['sub_orders'].append(tmp_order)
else:
products = []
for product in expected['products']:
products.append({
'product_name': product['name'],
'price': product['price'],
'product_count': product['count']
})
expected_order['products'] = products
bdd_util.assert_dict(expected_order, actual_order)
def get_datas(request):
group_name = request.GET.get('group_name', '')
product_name = request.GET.get('product_name', '')
status = int(request.GET.get('status', -1))
handle_status = int(request.GET.get('handle_status', 0))
start_time = request.GET.get('start_time', '')
end_time = request.GET.get('end_time', '')
now_time = datetime.today().strftime('%Y-%m-%d %H:%M')
params = {'owner_id':request.manager.id}
datas_datas = app_models.Group.objects(**params)
for data_data in datas_datas:
data_start_time = data_data.start_time.strftime('%Y-%m-%d %H:%M')
data_end_time = data_data.end_time.strftime('%Y-%m-%d %H:%M')
handle_status = int(data_data.handle_status)#手动开启状态
if handle_status == 0:#手动关闭(默认)
pass
elif handle_status == 1:#手动开启
if data_start_time <= now_time and now_time < data_end_time:
data_data.update(set__status=app_models.STATUS_RUNNING)
if now_time >= data_end_time:
data_data.update(set__status=app_models.STATUS_STOPED)
#活动已结束，所有进行中的小团置为失败
running_group_relations = app_models.GroupRelations.objects(belong_to=data_data.id,group_status=app_models.GROUP_RUNNING)
for group_relation in running_group_relations:
group_relation.update(group_status=app_models.GROUP_FAILURE)
group_relation_id = group_relation.id
# update_order_status_by_group_status(group_relation_id,'failure')
resp = Resource.use('zeus').post({
'resource': 'mall.group_update_order',
'data': {
'group_id': group_relation_id,
'status': 'failure',
'is_test': 1 if request.GET.get('is_test', False) else 0
}
})
if resp and resp['code'] == 200:
#发送拼团失败模板消息
try:
group_details = app_models.GroupDetail.objects(relation_belong_to=str(group_relation_id))
owner_id = data_data.owner_id
product_name = data_data.product_name
miss = int(group_relation.group_type)-group_details.count()
activity_info = {
"owner_id": str(owner_id),
"record_id": str(request.POST['id']),
"group_id": str(group_relation_id),
"fid": str(group_relation.member_id),
"price": '%.2f' % group_relation.group_price,
"product_name": product_name,
"status" : 'fail',
"miss": str(miss)
}
member_info_list = [{"member_id": group_detail.grouped_member_id, "order_id": group_detail.order_id} for group_detail in group_details]
send_group_template_message(activity_info, member_info_list)
except Exception, e:
print(u'发送拼团失败模板消息失败')
print 'template----------------------------------'
print e
print 'template----------------------------------'
def sync_create_rebate_info(user_id, account_relation):
"""
同步五五分成
"""
rebates = AccountHasRebateProport.objects.filter(user_id=user_id)
for rebate in rebates:
rebate_params = {
'supplier_id': account_relation.supplier_id,
'owner_id': PRODUCT_POOL_OWNER_ID,
'divide_money': int(rebate.order_money),
'basic_rebate': int(rebate.default_rebate_proport),
'rebate': int(rebate.rebate_proport),
}
# print '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.'
# print rebate_params
# print '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.'
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).put({
'resource': 'mall.supplier_divide_rebate_info',
"data": rebate_params
})
if not resp or resp.get('code') != 200:
AccountHasRebateProport.objects.filter(user_id=user_id).delete()
raise Exception('Sync create rebate info failed!')
else:
AccountRebateProportRelation.objects.create(panda_proport_id=rebate.id,
weapp_divide_id=resp.get('data').get('info').get('id'))
def refund(args):
"""
微众卡退款，取消订单或者下单失败时使用
"""
# 交易类型（支付失败退款：0、普通退款：1）
if mall_models.Order.select().dj_where(
order_id=args['order_id']).first():
trade_type = 1
else:
trade_type = 0
data = {'trade_id': args['trade_id'], 'trade_type': trade_type}
resp = Resource.use('card_apiserver').delete({
'resource': 'card.trade',
'data': data
})
is_success = resp and resp['code'] == 200
if is_success:
try:
log = member_models.MemberCardLog.select().dj_where(
order_id=args['order_id'], reason=u'下单').first()
member_models.MemberCardLog.create(
member_card=args['member_card_id'],
trade_id=args['trade_id'],
order_id=args['order_id'],
reason=u"取消下单或下单失败",
price=log.price)
except Exception, e:
watchdog.error(
u'会员卡自动退款时获取下单时的扣除金额失败,member_card_id:%s,order_id:%s' %
(args['member_card_id'], args['order_id']))
watchdog.error(e)
def get_reserved_products_from_purchase_info(self, purchase_info):
'''
根据purchase info获取已预订商品集合
@param [in] purchase_info: PurchaseInfo对象
@return ReservedProduct对象集合
'''
webapp_owner = self.context['webapp_owner']
webapp_user = self.context['webapp_user']
product_ids = purchase_info.product_ids
promotion_ids = purchase_info.promotion_ids
product_counts = purchase_info.product_counts
product_model_names = purchase_info.product_model_names
products = []
for i in range(len(product_ids)):
product_id = int(product_ids[i])
expected_promotion_id = int(promotion_ids[i])
product_model_name = product_model_names[i]
product_count = int(product_counts[i])
product_info = {
"id": product_id,
"model_name": product_model_name,
"count": product_count,
"expected_promotion_id": expected_promotion_id
}
reversed_product = ReservedProduct.get({
"webapp_owner": webapp_owner,
"webapp_user": webapp_user,
"product_info": product_info
})
if purchase_info.group_id:
params = {'group_id': purchase_info.group_id, 'woid': self.context['webapp_owner'].id}
resp = Resource.use('marketapp_apiserver').get({
'resource': GroupBuyOPENAPI['group_buy_info'],
'data': params
})
if resp and resp['code'] == 200:
group_buy_info = resp['data']
group_buy_price = group_buy_info['group_buy_price']
reversed_product.price = group_buy_price
products.append(reversed_product)
#TODO2：目前对商品是否可使用优惠券的设置放在了reserved_product_repository中
#主要是出于目前批量处理的考虑，后续应该将判断逻辑放入到reserved_product中
forbidden_coupon_product_ids = ForbiddenCouponProductIds.get_for_webapp_owner({
'webapp_owner': webapp_owner
}).ids
for product in products:
if product.id in forbidden_coupon_product_ids:
product.can_use_coupon = False
return products
def refund_for_order(order):
"""
微众卡退款
"""
# 交易类型（支付失败退款：0、普通退款：1）
trade_id = mall_models.OrderCardInfo.select().dj_where(order_id=order.order_id).first().trade_id
data = {
'trade_id': trade_id,
'trade_type': 1 # 普通退款
}
msg = {
'uuid': 'refund_wzcard',
'order_id': order.order_id,
'weizoom_card_money': order.weizoom_card_money
}
watchdog.info(message=msg, log_type='business_log')
resp = Resource.use('card_apiserver').delete({
'resource': 'card.trade',
'data': data
})
return resp
def get_product2group(pids, woid='3'):
#例子
#pids为list,里面的每一项都是商品id的str
# pids_url = "http://{}/mall2/api/test/".format(settings.MARKETTOOLS_HOST)
if not pids:
return {}
params = {
'woid': woid,
'pids': "_".join(pids)
}
resp = Resource.use('marketapp_apiserver').get({
'resource':'group.group_buy_products',
'data':params
})
if resp and resp['code']:
data = resp['data']
product_groups = data['pid2is_in_group_buy']
product2group = {}
for product_group in product_groups:
product2group[product_group["pid"]] = product_group["is_in_group_buy"]
else:
product2group = {}
return product2group
def process(data, recv_msg=None):
corp_id = data['corp_id']
delivery_item_id = data['delivery_item_id']
data = {'corp_id': corp_id, 'delivery_item_id': delivery_item_id}
result = Resource.use('gaia').put({
'resource': 'delivery_item.notify_kuaidi',
'data': data
})
def put(args):
order_id = args['order_id']
express_company_name = args['express_company_name']
express_number = args['express_number']
data_mns = []
data = {
'order_id': order_id,
'express_company_name': express_company_name,
'express_number': express_number
}
resp = Resource.use('zeus').put({
'resource': 'mall.delivery',
'data': data
})
errcode = SYSTEM_ERROR_CODE
# 获取app_id传送到mns进行消息处理
pay_log = PayLog.from_order_id({"order_id": order_id})
if pay_log:
app_id = pay_log.appid
else:
watchdog.info(
"order paylog is not exits, delivery mns message send failed!! order_id:{}, msg:{}"
.format(order_id, unicode_full_stack()),
log_type='OPENAPI_ORDER')
errcode = DELIVERY_ORDER_HAS_NO_PAYLOG
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
topic_name = TOPIC['order']
data_mns['order_id'] = order_id
data_mns['app_id'] = app_id or ''
data_mns['express_company_name'] = express_company_name
data_mns['express_number'] = express_number
if resp:
if resp['code'] == 200:
if resp['data']['result'] == 'SUCCESS':
errcode = SUCCESS_CODE
data = {'errcode': errcode}
msgutil.send_message(topic_name, 'delivery_item_shipped',
data_mns)
return data
else:
if resp['data']['msg'] == u'不能对当前订单发货':
errcode = DELIVERY_ORDER_HAS_MULTIPLE_CHILD_ORDERS
elif resp['data']['msg'] == u'订单状态已经改变':
errcode = DELIVERY_ORDER_STATUS_ERROR
elif resp['data']['msg'] == u'订单不存在':
errcode = DELIVERY_ORDER_NOT_EXIST
watchdog.info(
"delivery failed!! errcode:{}, order_id:{}".format(
errcode, order_id),
log_type='OPENAPI_ORDER')
if errcode == SYSTEM_ERROR_CODE:
watchdog.error("delivery failed!! errcode:{}, msg:{}".format(
errcode, unicode_full_stack()),
log_type='OPENAPI_ORDER')
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
def __sync_zeus_get(params, resource):
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).get({
'resource': resource,
'data': params
})
if resp and resp.get('code') == 200:
return True, resp.get('data')
else:
return False, None
def use(args):
wzcard_info = args['wzcard_info']
webapp_owner = args['webapp_owner']
order_id = args['order_id']
webapp_user = args['webapp_user']
if webapp_user.member.is_subscribed:
if mall_models.Order.select().dj_where(
webapp_user_id=webapp_user.id).count() > 0:
customer_type = 0
else:
customer_type = 1
else:
customer_type = 2
params = {
'card_infos': json.dumps(wzcard_info),
'money': args['money'],
'valid_money': -1,
'order_id': order_id,
'shop_id': webapp_owner.id,
'shop_name': webapp_owner.user_profile.store_name,
'customer_id': args['webapp_user'].member.id,
'customer_type': customer_type
}
resp = Resource.use('card_apiserver').post({
'resource': 'card.trade',
'data': params
})
data = {}
if resp:
code = resp['code']
data = resp['data']
if code == 200:
can_use = True
msg = ''
else:
can_use = False
msg = data['reason']
else:
can_use = False
msg = u'系统繁忙'
data['type'] = 'common:wtf'
if can_use:
member_models.MemberCardLog.create(
member_card=webapp_user.member_card.id,
trade_id=data['trade_id'],
order_id=order_id,
reason=u"下单",
# price=float(args['money'])
price=float(data['paid_money']))
return can_use, msg, data
def cancel(self, corp):
"""
影响:
- 更新订单状态
- 记录状态日志
- 记录操作日志
- 取消出货单
- 返还订单资源
- 积分
- 优惠券
- 库存
- 微众卡
- 库存
- 更新商品销量（如果订单已支付
- 更新会员信息
- 发送运营邮件通知
- 发送短信通知
@return:
"""
if self.status != mall_models.ORDER_STATUS_NOT:
return False, 'Error Status'
# 关闭微信交易单
if self.pay_interface_type == mall_models.PAY_INTERFACE_WEIXIN_PAY and not settings.IS_UNDER_BDD:
resp = Resource.use("pay_misc_tools").delete({
'data': {'order_bids': json.dumps([self.bid])},
'resource': 'weixin.trade_order'
})
if resp and resp['code'] == 200 and resp['data']['result'][self.bid]:
pass
else:
return False, 'close weixin pay order fail'
action_text = u"取消订单"
from_status = self.status
to_status = mall_models.ORDER_STATUS_CANCEL
self.status = to_status
self.__record_operation_log(self.bid, corp.username, action_text)
self.__recode_status_log(self.bid, corp.username, from_status, to_status)
self.__save()
Order.__fill_delivery_items([self], None)
for delivery_item in self.delivery_items:
delivery_item.cancel(corp)
release_order_resource_service = ReleaseOrderResourceService.get(corp)
release_order_resource_service.release(self.id, from_status, to_status)
self.__send_msg_to_topic('order_cancelled', from_status, to_status)
return True, ''
def api_put(request):
self_shop_name = request.POST.get('self_shop_name', '')
weapp_user_id = request.POST.get('weapp_user_id', '')
settlement_type = int(request.POST.get('settlement_type', 1))
corp_account = int(request.POST.get('corp_account', 1))
split_atio = float(request.POST.get('split_atio', 0))
risk_money = float(request.POST.get('risk_money', 0))
is_sync = request.POST.get('is_sync', '')
remark = request.POST.get('remark', '')
if models.SelfShops.objects.filter(
weapp_user_id=weapp_user_id).count() > 0:
response = create_response(500)
response.errMsg = u'该自营平台已存在'
return response.get_response()
try:
models.SelfShops.objects.create(self_shop_name=self_shop_name,
weapp_user_id=weapp_user_id,
settlement_type=settlement_type,
split_atio=split_atio,
risk_money=risk_money,
corp_account=corp_account,
remark=remark)
product_models.SelfUsernameWeappAccount.objects.create(
self_user_name=weapp_user_id, weapp_account_id=weapp_user_id)
data = {
'user_id': weapp_user_id,
'settlement_type': settlement_type,
'divide_rebate': split_atio,
'risk_money': risk_money,
'remark': remark
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).put({
'resource': 'account.divide_info',
'data': data
})
is_sync = True if is_sync == 'is_sync' else False
if is_sync: #需要在创建时候同步
is_synced = sync_all_product_2_new_self_shop(weapp_user_id)
sync_all_product_2_weapp(weapp_user_id)
if is_synced:
models.SelfShops.objects.filter(
weapp_user_id=weapp_user_id).update(is_synced=True)
response = create_response(200)
else:
response = create_response(500)
response.errMsg = u'同步失败'
response.innerErrMsg = unicode_full_stack()
else:
response = create_response(200)
except Exception, e:
msg = unicode_full_stack()
response = create_response(500)
response.errMsg = u'添加自营平台失败'
print msg
def api_delete(request):
model_id = request.POST.get('model_id', 0)
response = create_response(500)
try:
if model_id != 0:
models.ProductModelProperty.objects.filter(id=model_id).update(
is_deleted=True)
models.ProductModelPropertyValue.objects.filter(
property_id=model_id).update(is_deleted=True)
has_properrty_values = models.ProductModelHasPropertyValue.objects.filter(
property_id=model_id, is_deleted=False)
model_ids = [
has_properrty_value.model_id
for has_properrty_value in has_properrty_values
]
product_models = models.ProductModel.objects.filter(
id__in=model_ids, is_deleted=False)
product_ids = [
product_model.product_id
for product_model in product_models
]
product_models.update(stocks=0,
price=0,
market_price=0,
weight=0,
limit_clear_price=0,
is_deleted=True)
models.Product.objects.filter(id__in=product_ids).update(
product_price=0,
clear_price=0,
product_store=0,
product_weight=0)
has_properrty_values.delete()
response = create_response(200)
# 调用zeus接口
db_model = models.ProductModelPropertyRelation.objects.filter(
model_property_id=model_id).first()
if db_model:
params = {
"id": db_model.weapp_property_id,
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).delete({
'resource':
'mall.product_model_property',
'data':
params
})
if not resp or resp.get('code') != 200:
response = create_response(500)
except:
msg = unicode_full_stack()
watchdog.error(msg)
response.innerErrMsg = msg
return response.get_response()
def sync_add_product(params, product, weapp_catalog_id=None, user_id=None):
"""
同步新增加商品
"""
if product.catalog_id:
weapp_catalog_id = catalog_models.ProductCatalogRelation.objects\
.filter(catalog_id=product.catalog_id).first().weapp_catalog_id
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).put({
'resource':
'mall.sync_product',
'data':
params
})
# 同步到商品中间关系表
if resp:
if resp.get('code') == 200 and resp.get('data').get('product'):
weapp_product_id = resp.get('data').get('product').get('id')
models.ProductHasRelationWeapp.objects.create(
product_id=product.id,
weapp_product_id=weapp_product_id,
self_user_name=user_id)
# 同步类目
if weapp_catalog_id:
catalog_params = {
'classification_id': weapp_catalog_id,
'product_id': weapp_product_id
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).put({
'resource':
'mall.classification_product',
'data':
catalog_params
})
if not resp or resp.get('code') != 200:
watchdog.error({
'errorMsg':
'Panda product: %s sync catalog failed!' % product.id
})
# 同步标签
sync_product_label(weapp_product_id=weapp_product_id,
product=product)
def handle(self, **options):
datas = []
file_name_dir = '%s' % './account/management/commands/sync_customer_phone_1.xlsx'
data = xlrd.open_workbook(file_name_dir)
table = data.sheet_by_index(0)
nrows = table.nrows #行数
print "=====" + 'loading xlsx file' + "====="
for i in range(0, nrows):
item = dict()
item['username'] = table.cell(i, 0).value
item['phone'] = str(int(table.cell(i, 1).value))
datas.append(item)
for data in datas:
try:
user_id = User.objects.get(username=data['username']).id
account_info = account_models.UserProfile.objects.filter(
user_id=user_id)
account_info.update(phone=data['phone'])
new_relation = [
re.supplier_id
for re in account_models.AccountHasSupplier.objects.filter(
user_id=user_id)
]
old_relation = [
re.supplier_id
for re in account_models.AccountHasSupplier.objects.filter(
user_id=-user_id)
]
supplier_ids = old_relation + new_relation
for supplier_id in supplier_ids:
param = {
'name': account_info.first().name,
'remark': '',
'responsible_person': u'8000FT',
'supplier_tel': data['phone'],
'supplier_address': u'中国 北京',
'supplier_id': supplier_id
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).post({
'resource':
'mall.supplier',
"data":
param
})
if resp and resp.get('code') == 200:
print '++++++++++++++++++++++++++++++++++++++++++++++='
print "===" + 'changing user:'******'username'] + "==="
except Exception, e:
print e
print "===" + 'error:user is not exsit:' + data[
'username'] + "==="
def get_supplier(self, id):
"""
获得指定的Supplier对象
"""
resp = Resource.use('wcas').get({
'resource': 'corp.supplier',
'data': {
'corp_id': 1127 # todo 多平台上线后要改
}
})
supplier_data = resp['data']
return Supplier(supplier_data)
def put(args):
woid = args['woid']
order_id = args['order_id']
access_token = args['apiserver_access_token']
timestamp = str(long(time.time() * 1000))
data = {
'order_id': order_id,
'timestamp': timestamp,
'woid': woid,
u'access_token': access_token,
'pay_interface_type': '12'
}
pay_log = PayLog.from_order_id({
'order_id': args['order_id'],
})
if pay_log:
errcode = PAY_ORDER_STATUS_ERROR
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
resp = Resource.use('apiserver').put({
'resource': 'pay.pay_result',
'data': data
})
status = 0
code = 0
errcode = SYSTEM_ERROR_CODE
# reason= ''
if resp:
code = resp["code"]
if code == 200:
if resp['data']['is_success'] == True:
status = 1
errcode = SUCCESS_CODE
PayLog.save({
'woid': args['woid'],
'order_id': order_id,
'status': status,
'appid': args['appid']
})
else:
msg = resp['data']['msg']
# reason = msg
if u'非待支付订单' in msg:
errcode = PAY_ORDER_STATUS_ERROR
else:
errcode = PAY_ORDER_ERROR
if code == 200 and status:
return {'order_id': order_id}
else:
return {'errcode': errcode, 'errmsg': code2msg[errcode]}
def step_impl(context, user):
order_id = json.loads(context.text)['order_no']
data = {
'order_id': order_id,
'access_token': context.openapi_access_token,
'woid': context.woid,
'apiserver_access_token': context.apiserver_access_token
}
resp = Resource.use('openapi').put({
'resource': 'pay.third_pay',
'data': data
})
if resp:
assert 200 == resp['code']
def fill_options(member_card, fill_options):
if fill_options:
with_price = fill_options.get("with_price", False)
#member_card.balance = 100
if with_price:
member_card.balance = 0
#访问微众卡service
wzcard_info = [{
"card_number": member_card.card_number,
"card_password": member_card.card_password
}]
params = {
'card_infos': json.dumps(wzcard_info),
}
resp = Resource.use('card_apiserver').post({
'resource': 'card.get_cards',
'data': params
})
data = {}
if resp:
code = resp['code']
data = resp['data']
if code == 200:
card_infos = resp['data']['card_infos']
if len(card_infos) == 1:
#判断微众卡状态是否可用 duhao
card_status_text = card_infos[0][
member_card.card_number]['status']
if card_status_text == CAN_USE_TEXT:
member_card.is_active = True
#剩余返现次数
remained_backcash_times = card_infos[0][
member_card.
card_number]['membership_to_recharge_times']
member_card.remained_backcash_times = remained_backcash_times
member_card.valid_time_to = card_infos[0][
member_card.card_number]['valid_time_to']
member_card.balance = card_infos[0][
member_card.card_number]['balance']
member_card.next_clear_time = card_infos[0][
member_card.card_number]['next_clear_time']
else:
watchdog.error(resp)
batch_info = get_batch_info(member_card.batch_id)
member_card.interval_days = int(
Decimal(batch_info.get('vip_back_via_day', 30)))
def _handle_keyword(self, context, from_weixin_user, is_from_simulator):
user_id = context.user_profile.user_id
username = User.objects.get(id=user_id).username
if username != 'weshop':
# request = context.request
message = context.message
response = None
response_rule = None
response_content = None
try:
webapp_owner_id = context.user_profile.user_id
keyword = message.content
openid = message.fromUserName
webapp_id = context.user_profile.webapp_id
response_content = Resource.use('marketapp_apiserver').post({
'resource':
'sign.do_auto_signment',
'data': {
'webapp_owner_id': webapp_owner_id,
'keyword': keyword,
'openid': openid,
'webapp_id': webapp_id
}
})
response_content = response_content['data']
if response_content:
response = generator.get_text_response(
message.fromUserName, message.toUserName,
response_content, message.fromUserName,
context.user_profile)
try:
self._process_recorde_message(context, response_rule,
from_weixin_user,
is_from_simulator)
except:
notify_message = u"_process_recorde_message, cause:\n{}".format(
unicode_full_stack())
message_tail = '\nanswer:%s,patterns:%s,owner_id:%d,id:%d' % (
response_rule.answer, response_rule.patterns,
response_rule.owner_id, response_rule.id)
notify_message += message_tail
watchdog_error(notify_message)
return response
except:
return None
else:
return None
def sync_delete_retail_rebate_info(account_relation):
"""
同步增加零售返点
user_id 属于哪个平台的团购扣点,-1表示基础扣点
"""
params = {
'supplier_id': account_relation.supplier_id,
}
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).delete({
'resource': 'mall.supplier_retail_rebate_info',
"data": params
})
if not resp or resp.get('code') != 200:
raise Exception('Sync create delete retail rebate info failed!')
def sync_weapp_product_store(product_id=None,
owner_id=None,
source_product=None,
new_properties=None,
old_properties=None,
relation=None):
"""
判断商品是否需要同步并同步
"""
# 如果降价（售价，结算价）库存修改自动更新。
new_product = models.Product.objects.filter(owner=owner_id,
id=product_id).first()
# relation = models.ProductHasRelationWeapp.objects.filter(product_id=product_id).first()
if new_product.has_product_model != source_product.has_product_model:
return False
# 未同步的不处理
if relation:
if new_product.has_product_model:
# 多规格,获取规格信息
model_type = 'custom'
if not charge_models_product_sync(old_properties=old_properties,
new_properties=new_properties):
return False
weapp_models_info = get_weapp_model_properties(
product=source_product)
else:
model_type = 'single'
if new_product.product_store == source_product.product_store:
return False
weapp_models_info = [{
'name': 'standard',
'product_store': new_product.product_store
}]
params = {
'model_type': model_type,
'model_info': json.dumps(weapp_models_info),
'product_id': relation.weapp_product_id
}
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).post({
'resource':
'panda.product_store',
'data':
params
})
if resp and resp.get('code') == 200:
pass
def get_card_infos(args):
"""
检查微众卡，编辑订单页接口使用
@type args: h5请求参数
"""
params = {
'card_infos': json.dumps(args['card_infos'])
}
resp = Resource.use('card_apiserver').post({
'resource': 'card.get_cards',
'data': params
})
return resp