def _is_poll_by_order(self):
try:
pushs = ExpressHasOrderPushStatus.select().dj_where(
# order_id = self.order_id,
express_company_name=self.delivery_item.
express_company_name_value,
express_number=self.delivery_item.express_number)
if pushs.count() > 0:
push = pushs[0]
# 不需要重新发送订阅请求的状态
if push.status in EXPRESS_NOT_PULL_STATUSES:
return True
# 超过4次发送就不再发送次快递
if push.send_count >= 4:
return True
# 关闭，重发订阅,由于某种原因订阅失败
if push.abort_receive_message and len(
push.abort_receive_message) > 0:
return False
# 第一次发送订阅
if push.status == EXPRESS_PULL_SUCCESS_STATUS and push.send_count > 0:
return True
return False
except:
watchdog.error(
u'快递鸟tool_express_has_order_push_status表异常，获取订单信息，express_company_name:{}，express_number:{}'
.format(self.delivery_item.express_company_name,
self.delivery_item.express_number))
return False
def api_delete(request):
post = request.POST
template_id = post.get('id')
try:
# 判断是否有正在使用的
use_products = product_models.Product.objects.filter(limit_zone=template_id)\
.exclude(limit_zone_type=product_models.NO_LIMIT)
# print '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.'
# print use_products.count()
# print '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.'
if use_products.count() > 0:
# data = {
# 'msg': '还有正在使用该模板的商品，请先处理！'
# }
response = create_response(500)
response.errMsg = '还有正在使用该模板的商品，请先处理！'
return response.get_response()
models.ProductLimitZoneTemplate.objects.filter(id=template_id).update(is_deleted=True)
# 同步到weapp
relation = models.ProductLimitZoneTemplateRelation.objects.filter(template_id=template_id).first()
if relation:
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'template_id': relation.weapp_template_id
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_limit_zone_template',
method='delete')
response = create_response(200)
except:
msg = unicode_full_stack()
watchdog.error('product_limit_zone.template_DELETE{}'.format(msg))
response = create_response(500)
return response.get_response()
def api_post(request):
label_id = request.POST.get('label_id', -1)
name = request.POST.get('name', '')
try:
models.LabelGroup.objects.filter(id=int(label_id)).update(
name= name
)
response = create_response(200)
relation = models.LabelGroupRelation.objects.filter(label_group_id=label_id).first()
if relation:
weapp_label_group_id = relation.weapp_label_group_id
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'name': name,
'product_label_group_id': weapp_label_group_id
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_label_group', method='post')
if not resp:
response = create_response(500)
except:
response = create_response(500)
msg = unicode_full_stack()
watchdog.error(msg)
return response.get_response()
def test_local_handle():
# 测试本地情况的handle
from core.handlers.event_handler_util import handle
args = {
'GET': {
'get1': 'value1',
'get2': 'value2'
},
'COOKIES': '<cookie>',
'method': 'GET',
'POST': {
'post1': 'value1',
'post2': 'value2'
},
'data': {
'app_id': '123',
'user_id': user_id,
'webppuser_id': webapp_user.id,
'user_profile_id': user_profile_id,
'social_account_id': social_account.id,
'member_id': member.id,
'is_user_from_mobile_phone': False,
'is_user_from_weixin': False,
},
'visit_data': '<visit_data>'
}
result = handle(args, 'example')
watchdog.alert('result: {}'.format(result))
watchdog.error('result: {}'.format(result))
watchdog.info('result: {}'.format(result))
print('result: {}'.format(result))
def process_order_from_spread(args):
"""静态方法 订单完成后处理分享链接相关
@param[in] order_id 订单id
@param[in] webapp_user 当前下单用户
"""
order_id = args['order_id']
mall_order_from_shared = mall_models.MallOrderFromSharedRecord.select(
).dj_where(order_id=order_id).first()
if mall_order_from_shared:
shared_url = mall_order_from_shared.url
fmt = mall_order_from_shared.fmt
if shared_url and fmt:
try:
member_models.MemberSharedUrlInfo.update(
leadto_buy_count=member_models.MemberSharedUrlInfo.
leadto_buy_count + 1).dj_where(
shared_url=shared_url, ).execute()
mall_order_from_shared.is_updated = True
mall_order_from_shared.save()
except:
notify_message = u"process_order_from_spread cause:\n{}, fmt:{}".format(
unicode_full_stack(), fmt)
watchdog.error(notify_message)
print notify_message
def save_base64_img_file_local_for_webapp(owner_id, ajax_file):
date = time.strftime('%Y%m%d')
dir_path_suffix = 'webapp/%d_%s' % (owner_id, date)
dir_path = os.path.join(settings.UPLOAD_DIR, dir_path_suffix)
if not os.path.exists(dir_path):
os.makedirs(dir_path)
#获取文件的扩展名
file_name = '%s.%s' % (datetime.now().strftime("%Y_%m_%d_%H_%M_%S_%f"),
'png')
ajax_path = '%s/%s' % (dir_path, file_name)
ajax_file = ajax_file.split(',')
image_content = base64.b64decode(ajax_file[1])
image_file = open(ajax_path, 'wb')
image_file.write(image_content)
image_file.close()
if __validate_image(ajax_path):
try:
image_path = upyun_util.upload_image_to_upyun(
ajax_path, '/upload/%s/%s' % (dir_path_suffix, file_name))
return image_path
except:
notify_msg = u"上传图片到又拍云时失败, cause:\n{}".format(
unicode_full_stack())
watchdog.error(notify_msg)
return None
#return '/static/upload/%s/%s' % (dir_path_suffix, file_name)
#return '/static/upload/%s/%s' % (dir_path_suffix, file_name)
else:
return None
def assert_api_call_success(response):
if 200 != response.body['code']:
buf = []
buf.append('>>>>>>>>>>>>>>> response <<<<<<<<<<<<<<<')
buf.append(str(response))
watchdog.error("API calling failure: %s" % '\n'.join(buf))
assert 200 == response.body['code'], "code != 200, call api FAILED!!!!"
def record_member_pv(self, member_id, url, page_title=''):
"""
记录会员访问轨迹
"""
try:
member_model.MemberBrowseRecord.create(
title=page_title,
url=url,
member=member_id
)
#访问商品详情单独写到一张表里，方便统计商品的访问记录 duhao 20161221
if 'module=mall' in url and 'model=product' in url and 'model=products' not in url:
result = urlparse.urlparse(url)
params = urlparse.parse_qs(result.query, True)
owner_id = params['woid'][0]
product_id = params['rid'][0]
referer = ''
member_model.MemberBrowseProductRecord.create(
title = page_title,
url = url,
member=member_id,
owner_id=owner_id,
product_id=product_id,
referer=referer
)
except:
notify_message = u"record_member_pv,member_id:{} cause:\n{}".format(member_id, unicode_full_stack())
watchdog.error(notify_message)
raise self.retry()
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 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 api_put(request):
post = request.POST
name = post.get('name')
db_model = None
try:
db_model = models.ProductLimitZoneTemplate.objects.create(name=name,
owner_id=request.user.id)
params = {
'name': name,
'owner_id': PRODUCT_POOL_OWNER_ID
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_limit_zone_template',
method='put')
if resp and resp_data:
# 创建中间关系
models.ProductLimitZoneTemplateRelation.objects.create(
template_id=db_model.id,
weapp_template_id=resp_data.get('template').get('id')
)
response = create_response(200)
else:
models.ProductLimitZoneTemplate.objects.filter(id=db_model).delete()
response = create_response(500)
except:
msg = unicode_full_stack()
watchdog.error('product_limit_zone.template_PUT{}'.format(msg))
if db_model:
models.ProductLimitZoneTemplate.objects.filter(id=db_model.id).delete()
response = create_response(500)
return response.get_response()
def send_task(queue_name, args):
try:
result = celery.send_task(queue_name, args=[args], queue=queue_name)
except:
notify_message = u"queue_name:{}, args:{}, cause:\n{}".format(
queue_name, args, unicode_full_stack())
watchdog.error(notify_message)
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 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 watchdog_fatal(message,
type='WEB',
user_id='0',
noraise=False,
db_name='default'):
result = None
# logging.error(message_json(user_id, message, type))
watchdog.error(message=message,
log_type=type,
user_id=user_id,
server_name='weapp')
def api_post(request):
post = request.POST
name = post.get('name')
template_id = post.get('id')
flag = post.get('flag', 'name')
try:
models.ProductLimitZoneTemplate.objects.filter(id=template_id).update(name=name)
# 同步到weapp的参数
weapp_cities = []
weapp_provinces = []
if flag != 'name':
selected_data = json.loads(post.get('selected_data', ''))
provinces = selected_data.get('provinces')
# 先删除
models.LimitTemplateHasZone.objects.filter(template_id=template_id).delete()
# 创建模板的数据
bulk_create = []
for province in provinces:
# 前段传递的数据如果是全选了省，那么cities是空的
cities = province.get('cities')
weapp_provinces.append(str(province.get('provinceId')))
if not cities:
bulk_create.append(models.LimitTemplateHasZone(template_id=template_id,
province=province.get('provinceId'),
))
else:
bulk_create += [models.LimitTemplateHasZone(template_id=template_id,
province=province.get('provinceId'),
city=city.get('cityId')) for city in cities]
weapp_cities += [str(city.get('cityId')) for city in cities]
models.LimitTemplateHasZone.objects.bulk_create(bulk_create)
# 同步更新到weapp
relation = models.ProductLimitZoneTemplateRelation.objects.filter(template_id=template_id).first()
if relation:
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'name': name,
'cities': ','.join(weapp_cities),
'template_id': relation.weapp_template_id,
'provinces': ','.join(weapp_provinces),
'flag': flag
}
sync_util.sync_zeus(params=params, resource='mall.product_limit_zone_template',
method='post')
response = create_response(200)
except:
msg = unicode_full_stack()
watchdog.error('product_limit_zone.template_POST{}'.format(msg))
response = create_response(500)
return response.get_response()
def __call__(self, environ):
url = u'%s?%s' % (environ['PATH_INFO'], environ['QUERY_STRING'])
self.response = FakeResponse(url)
print environ
response_text = ''.join(self.app(environ, self.start_response))
try:
self.response.body = json.loads(response_text)
except:
watchdog.error('>>>>>>>>>>>>>>>> invalid api response <<<<<<<<<<<<<<<<\n%s' % response_text)
#print response_text
return self.response
def api_post(request):
product_id = request.POST.get('product_id', 0)
# print product_id.split(','),"======="
response = create_response(200)
data = {}
try:
product_ids = product_id.split(',')
products = models.Product.objects.filter(id__in=product_ids)
limit_zone_infos = get_products_limit_info(products=products)
for product in products:
# 供货商中间关系
account_has_supplier = account_models.AccountHasSupplier.objects.filter(
user_id=product.owner_id).first()
if not account_has_supplier:
data['code'] = 500
response.data = data
return response.get_response()
images = get_product_images(product=product)
# 获取是单品还是多规格
model_type = 'single' if not product.has_product_model else 'custom'
weapp_models_info = []
if product.has_product_model:
# 多规格,获取规格信息
weapp_models_info = get_weapp_model_properties(
product=product)
params = organize_params(
product=product,
supplier_id=account_has_supplier.supplier_id,
images=images,
model_type=model_type,
weapp_models_info=weapp_models_info,
limit_zone_infos=limit_zone_infos)
relation = models.ProductHasRelationWeapp.objects.filter(
product_id=product.id).first()
if not relation:
sync_add_product(params, product, user_id=request.user.id)
else:
params.update({'product_id': relation.weapp_product_id})
sync_update_product(params, product)
models.Product.objects.filter(id=product.id).update(
is_update=False)
data['code'] = 200
data['count'] = len(product_ids)
except:
msg = unicode_full_stack()
watchdog.error('{}'.format(msg))
data['code'] = 500
response.data = data
return response.get_response()
def api_post(request):
#运营查看商品列表，入库驳回
product_ids = request.POST.get('product_id', -1)
reasons = request.POST.get('reasons', '')
data = {}
product_ids = product_ids.split(',')
try:
for product_id in product_ids:
product_id = int(product_id)
cur_product = models.Product.objects.filter(id=product_id)
cur_product.update(is_refused=True)
models.ProductRejectLogs.objects.create(product_id=product_id,
reject_reasons=reasons)
try:
send_product_message.send_reject_product_change(
product_id=product_id)
send_product_message.send_reject_product_ding_message(
product_id=product_id, reasons=reasons)
except:
msg = unicode_full_stack()
watchdog.error(
"product_reject.send_reject_product_change: {}".format(
msg))
print msg
try:
# 给客户系统发送日志消息
owner_id = cur_product[0].owner_id
customer_id = UserProfile.objects.get(
user_id=owner_id).corpid
customer_name = UserProfile.objects.get(
user_id=owner_id).company_name
add_customer_news.send_reject_product_message(
product_name=cur_product[0].product_name,
reject_reason=reasons,
customer_id=customer_id,
customer_name=customer_name)
except:
msg = unicode_full_stack()
watchdog.error(
"product_reject.send_reject_product_message: {}".
format(msg))
print msg
data['code'] = 200
response = create_response(200)
except:
data['code'] = 500
response = create_response(500)
response.errMsg = u'驳回失败'
response.data = data
return response.get_response()
def _poll_response(self):
"""
发送快递100 订阅请求，返回成功与否信息
"""
# post中的param的json
param_json_data = {
self.express_params.COMPANY: self.express_company_name,
self.express_params.NUMBER: self.express_number,
self.express_params.TO: self.area,
self.express_params.KEY: self.express_config.app_key,
self.express_params.PARAMETERS: {
self.express_params.CALLBACK_URL: self._get_api()
}
}
# 将PARAMETERS的json转换为字符串
param_str = json.dumps(param_json_data)
json_data = {
self.express_params.SCHEMA: self.express_config.schema,
self.express_params.PARAM: param_str
}
# print param_str
verified_result = ''
try:
param_data = urllib.urlencode(json_data)
# print '-------------------------------------------'
# print param_data
# if settings.IS_UNDER_BDD:
# from test.bdd_util import WeappClient
# bdd_client = WeappClient()
# response = bdd_client.post('/tools/api/express/test_kuaidi_poll/?code=1', param_json_data)
# verified_result = response.content
# else:
request = urllib2.Request(self.express_config.get_api_url(),
param_data)
response = urllib2.urlopen(request)
verified_result = response.read()
watchdog.info(
u"发送快递100 订阅请求 url: {},/n param_data: {}, /n response: {}".
format(self.express_config.get_api_url(), param_str,
verified_result.decode('utf-8')))
except:
watchdog.error(u'发送快递100 订阅请求 失败，url:{},data:{},原因:{}'.format(
self.express_config.get_api_url(), param_str,
unicode_full_stack()))
return verified_result
def put_access_token(self):
"""
put_access_token
"""
if self.access_token:
return self.access_token
try:
#db_model = account_models.AccessToken.get(woid=self.woid, openid=self.openid, access_token__ne='')
db_model = account_models.AccessToken.get(woid=self.woid, openid=self.openid)
except:
db_model = None
if db_model:
if db_model.access_token == "":
access_token = auth_util.encrypt_access_token(self.woid, self.openid)
db_model.access_token = access_token
db_model.save()
# self.access_token = access_token
self.access_token = db_model.access_token
return self.access_token
else:
access_token = auth_util.encrypt_access_token(self.woid, self.openid)
self.access_token = access_token
try:
db_model = account_models.AccessToken(
woid=self.woid,
openid=self.openid,
times=str(int(time.time())),
access_token=access_token,
expires_in='100000000000'
).save()
return access_token
except:
try:
db_model = account_models.AccessToken(
woid=self.woid,
openid=self.openid,
times=str(int(time.time())),
access_token=access_token,
expires_in='1000000000000'
).save()
return access_token
except:
notify_message = u"AccessToken get_access_token cause:\n{}".format(unicode_full_stack())
logging.error(notify_message)
watchdog.error(notify_message)
return None
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 __call__(self, environ):
method = environ.get('_REAL_REQUEST_METHOD',
environ.get('REQUEST_METHOD', 'UNKNOWN'))
url = u'%s?%s' % (environ['PATH_INFO'], environ['QUERY_STRING'])
self.response = FakeResponse(method, url)
response_text = ''.join(self.app(environ, self.start_response))
try:
self.response.body = json.loads(response_text)
except:
watchdog.error(
'>>>>>>>>>>>>>>>> invalid api response <<<<<<<<<<<<<<<<\n%s' %
response_text)
#print response_text
return self.response
def _parse_result(self, result):
data = dict()
if result is None or len(result) == 0:
return data
try:
data = json.loads(result)
watchdog.info(u'从快递100获取订单信息，data{}'.format(result),
self.express_config.watchdog_type)
except:
notify_message = u'解析快递100获取订单信息失败，url:{}, data:{}, 原因:{}'.format(
result, data, unicode_full_stack())
watchdog.error(notify_message, self.express_config.watchdog_type)
return data
def api_delete(request):
label_id = request.POST.get('label_id', 0)
response = create_response(500)
try:
if label_id != 0:
models.LabelGroup.objects.filter(id=label_id).update(is_deleted=True)
label_group_values = models.LabelGroupValue.objects.filter(property_id=label_id)
label_group_values.update(is_deleted=True)
product_models.ProductHasLabel.objects.filter(property_id=label_id).delete()
catalog_models.ProductCatalogHasLabel.objects.filter(property_id=label_id).delete()
response = create_response(200)
relation = models.LabelGroupRelation.objects.filter(label_group_id=label_id).first()
if relation:
weapp_label_group_id = relation.weapp_label_group_id
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'product_label_group_id': weapp_label_group_id
}
# 先删除weapp的标签分组
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_label_group',
method='delete')
if not resp:
watchdog.error('sync_delete_label_group: %s failed' % label_id)
# 同步删除标签
for label_group_value in label_group_values:
value_relation = models.LabelGroupValueRelation.objects.filter(label_value_id=label_group_value.id).first()
if not value_relation:
continue
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'product_label_id': value_relation.weapp_label_value_id
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.product_label',
method='delete')
if not resp:
watchdog.error('sync_delete_label_: %s failed' % label_group_value.id)
# 将有这个标签的商品的标签去掉
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'label_id': value_relation.weapp_label_value_id
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.disable_product_label',
method='delete')
if not resp:
watchdog.error('sync_disable_product_label: %s failed' % label_group_value.id)
# 将有这个标签的类目的标签删掉
params = {
'owner_id': PRODUCT_POOL_OWNER_ID,
'label_id': value_relation.weapp_label_value_id
}
resp, resp_data = sync_util.sync_zeus(params=params, resource='mall.classification_has_label',
method='delete')
except:
msg = unicode_full_stack()
watchdog.error(msg)
response.innerErrMsg = msg
return response.get_response()
def sync_all_product_2_weapp(self_user_name):
relation = product_models.SelfUsernameWeappAccount.objects.\
filter(weapp_account_id=self_user_name).order_by('-id').first()
weapp_account_id = relation.weapp_account_id
params = {'new_proprietary_id': weapp_account_id}
resp = Resource.use(ZEUS_SERVICE_NAME, EAGLET_CLIENT_ZEUS_HOST).put({
'resource':
'panda.sync_product_new_proprietary',
'data':
params
})
if not resp or not resp.get('code') == 200:
watchdog.error(
'sync_all_product_2_weapp:{} failed!'.format(self_user_name))
def api_put(request):
model_id = request.POST.get('model_id', 0)
model_value = request.POST.get('model_value', '')
path = request.POST.get('path', '')
response = create_response(500)
try:
if model_id != 0:
db_model = models.ProductModelPropertyValue.objects.create(
property_id=model_id, name=model_value, pic_url=path)
relation = models.ProductModelPropertyRelation.objects.filter(
model_property_id=model_id).first()
if relation:
# 获取规格是图片还是文字
# model_property = models.ProductModelProperty.objects.get(id=model_id)
if path and not path.startswith('http'):
path = 'http://chaozhi.weizoom.com' + path
params = {
'id': relation.weapp_property_id,
'name': model_value,
'pic_url': path
}
resp = Resource.use(ZEUS_SERVICE_NAME,
EAGLET_CLIENT_ZEUS_HOST).put({
'resource':
'mall.model_property_value',
'data':
params
})
if not resp or not resp.get('code') == 200 and resp.get(
'data').get('product_model_value'):
response = create_response(500)
else:
weapp_data = resp.get('data').get(
'product_model_value')
models.ProductModelPropertyValueRelation.objects.create(
property_value_id=db_model.id,
weapp_property_value_id=weapp_data.get('id'))
response = create_response(200)
except:
msg = unicode_full_stack()
response.innerErrMsg = msg
watchdog.error(msg)
return response.get_response()
def increase_member_integral(args):
#TODO-bert 调整统一参数
member = args['member']
event_type = args['event_type']
integral_increase_count = args.get('integral_increase_count', 0)
follower_member = args.get('follower_member', None)
reason = args.get('reason', '')
manager = args.get('manager', '')
webapp_user = args.get('webapp_user', None)
integral_increase_count = int(integral_increase_count)
if integral_increase_count == 0:
return None
if webapp_user:
webapp_user_id = webapp_user.id
else:
webapp_user_id = 0
member = member_models.Member.get(id=member.id)
current_integral = member.integral + integral_increase_count
try:
#TODO-bert 并发下是否会出现积分日志无法对应上
member_models.Member.update(
integral=member_models.Member.integral +
integral_increase_count).dj_where(id=member.id).execute()
integral_log = member_models.MemberIntegralLog.create(
member=member.id,
follower_member_token=follower_member.token
if follower_member else '',
integral_count=integral_increase_count,
event_type=event_type,
webapp_user_id=webapp_user_id,
reason=reason,
current_integral=current_integral,
manager=manager)
if webapp_user:
webapp_user.cleanup_cache()
return True, integral_log.id
except:
notify_message = u"update_member_integral member_id:{}, cause:\n{}".format(
member.id, unicode_full_stack())
watchdog.error(notify_message)
return False, None
def handle(request, event):
"""
“调用”services的统一接口
@param request 如果是Request对象，需要包括event_data；也可以是dict()对象，直接作为event_data。
"""
if hasattr(request, 'event_data'):
event_data = request.event_data
else:
event_data = request
result = None
if settings.EVENT_DISPATCHER == 'dummy':
print("found sepecial event '{}'".format(event))
return result
if celeryconfig.CELERY_ALWAYS_EAGER and REGISTERED_EVENTS.has_key(event):
# 如果event是测试的service，以Celery方式处理
task_name = REGISTERED_EVENTS[event]
print("found sepecial event '{}'".format(event))
result = send_task(task_name, args=[None, event_data])
print("called service: name:'{}', result:{}".format(task_name, result))
else:
from services import service_manager
if hasattr(request, 'event_data'):
if settings.EVENT_DISPATCHER == 'local':
# 本地模式：直接调用service函数
service_manager.call_service(event, request.event_data)
elif settings.EVENT_DISPATCHER == 'redis':
is_processed = False
# 如果没有处理，则用老的方式处理event
if not is_processed:
redis_cli = ensure_redis()
if redis_cli:
# 将request.event_data数据存入redis
if event in EVENT_FILTER:
redis_event = '%s_%s' % (event, str(int(time.time() * 1000)))
send_message_to_redis(redis_event, request.event_data)
else:
redis_cli.rpush(event, request.event_data)
else:
notify_msg = u"redis服务不能访问, %s:%s:%s" % (settings.REDIS_HOST, settings.REDIS_PORT, settings.REDIS_SERVICE_DB)
watchdog.error(notify_msg)
service_manager.call_service(event, request.event_data)
return result
def get(args):
"""
通过 个人中心-VIP会员 入口进入会员页面。通常情况下，只有绑定了手机号并且已经开通了的会员会进入到这个页面，
但为了防止非会员通过别人直接分享链接或者其他方式直接打开这个页面，这里面再次对is_binded和is_vip进行了判断，
如果is_binded为False，前端应该跳转到绑定手机号页面，
如果is_vip为True，前端应该跳转到会员卡详情页面
@param 无
@return member_card dict
"""
webapp_user = args['webapp_user']
webapp_owner = args['webapp_owner']
is_binded = webapp_user.is_binded
# if not is_binded: #如果没绑定手机则直接返回
# return {'is_binded': False}
member_card = webapp_user.member_card
if member_card: #如果已经是会员了则直接返回
return {'is_binded': True, 'is_vip': True}
phone_number = webapp_user.phone_number
member_name = webapp_user.username_for_html
user_icon = webapp_user.user_icon
data = {
'is_binded': True,
'is_vip': False,
'phone_number': phone_number,
'member_name': member_name,
'user_icon': user_icon
}
resp = Resource.use('card_apiserver').get({
'resource': 'card.membership_batches',
'data': {
'woid': webapp_owner.id
}
})
if resp:
code = resp['code']
r_data = resp['data']
if code == 200:
card_infos = r_data['card_infos']
data['card_infos'] = card_infos
else:
watchdog.error(resp)
return data
