def process_order_from_spread(args):
"""静态方法 订单完成后处理分享链接相关
@param[in] order_id 订单id
@param[in] webapp_user 当前下单用户
"""
order_id = args['order_id']
webapp_user = args['webapp_user']
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:
followed_member = member_models.Member.get(token=fmt)
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 handle(request, webapp_id):
global message_pipeline
if not message_pipeline:
from weixin.message.message_pipeline import MessagePipeline
message_pipeline = MessagePipeline()
if 'echostr' in request.GET:
if is_valid_request(request, webapp_id):
return HttpResponse(request.GET['echostr'])
else:
return HttpResponse('')
else:
#通过微信来的数据kkj
try:
content = message_pipeline.handle(request, webapp_id)
except:
notify_message = u"进行消息处理失败，webapp_id:{} cause:\n{}".format(webapp_id, unicode_full_stack())
watchdog_fatal(notify_message)
content =None
if content is None or len(content) == 0:
return HttpResponse('')
else:
return HttpResponse(content, mimetype="application/xml")
def process_payment_with_shared_info(request):
"""
购买完成后进行分享链接的相关处理
如果请求信息中没有相应的分享链接信息，那么不进行任何处理,。
否则该分享链接带来的购买量+1
"""
member_shared_url_info = get_followed_member_shared_url_info(request)
if not member_shared_url_info:
return
try:
from django.db import connection, transaction
cursor = connection.cursor()
cursor.execute('update member_shared_url_info set leadto_buy_count=leadto_buy_count+1 where id = %d' % member_shared_url_info.id)
transaction.commit_unless_managed()
#计算成功后清除请求中携带的分享链接信息
remove_shared_info(request)
except:
notify_message = u"更新分享链接带来的购买量失败，分享链接id:{}, cause:\n{}".format(
member_shared_url_info.id, unicode_full_stack()
)
watchdog_warning(notify_message)
def api_post(request):
"""
编辑分组名称
"""
if 'category_id' in request.POST and 'category_name' in request.POST:
# 只能删除本webapp下的分组
webapp_id = request.user_profile.webapp_id
category_name = request.POST['category_name']
# 检查分类名是否合法
(is_valid,
response) = FansCategory.check_category_name(category_name)
if is_valid:
try:
category_id = request.POST['category_id']
# 确保只能删除本webapp账号的分类才使用 (webapp_id, id) 查询
category = FanCategory.objects.get(webapp_id=webapp_id,
id=category_id)
category.name = category_name
category.save()
response = create_response(200).get_response()
except:
response = create_response(500)
response.errMsg = u'分类名更新失败(错误的ID?)'
response.innerErrMsg = unicode_full_stack()
response = response.get_response()
else:
response = create_response(400)
response.errMsg = u"需要指定category_id和category_name"
response = response.get_response()
return response
def send_coupon_expired_remind(request, args):
"""
提前36小时给即将到期的优惠券，发消息
"""
user_ids = []
for component in ComponentAuthedAppid.objects.all():
user_ids.append(component.user_id)
now = datetime.now()
expired_time_g = datetime.now() + timedelta(hours=36)
expired_time_l = datetime.now() + timedelta(hours=37)
coupons = promotion_models.Coupon.objects.filter(
owner_id__in=user_ids,
expired_time__gte=expired_time_g,
expired_time__lt=expired_time_l,
status=promotion_models.COUPON_STATUS_UNUSED
)
for coupon in coupons:
try:
model_data = {
"coupon_store": u'全部可用',
"coupon_rule": u'不限'
}
if coupon.coupon_rule.limit_product:
model_data["coupon_store"] = u'单个商品可用'
if coupon.coupon_rule.valid_restrictions > -1:
model_data["coupon_rule"] = "每笔订单满%s元即可使用本券" % str(coupon.coupon_rule.valid_restrictions)
template_message_api.send_weixin_template_message(coupon.owner_id, coupon.member_id, model_data, template_message_model.COUPON_EXPIRED_REMIND)
except:
alert_message = u"ship_order 发送模板消息失败, cause:\n{}".format(unicode_full_stack())
watchdog_warning(alert_message)
return u"Succeed in sending a hint message to members who have a coupon will expire!"
def build_system_exception_response():
response_dict = {}
response_dict['code'] = 995995
response_dict['msg'] = u'系统自身异常'
response_dict['detail'] = unicode_full_stack()
return AliPayErrorResponse(response_dict)
def api_delete(request):
"""
删除粉丝分组
"""
if 'category_id' in request.POST:
# 只能删除本webapp下的分组
webapp_id = request.user_profile.webapp_id
try:
category_id = int(request.POST['category_id'])
if category_id > 0:
FanCategory.objects.filter(webapp_id=webapp_id,
id=category_id).delete()
response = create_response(200).get_response()
else:
response = create_response(500)
response.errMsg = u'无法删除此分组'
response = response.get_response()
except:
response = create_response(500)
response.errMsg = u'删除分组失败'
response.innerErrMsg = unicode_full_stack()
response = response.get_response()
else:
response = create_response(400)
response.errMsg = u"请指定分组ID"
response = response.get_response()
return response
def upload_image_to_upyun(file_path, upyun_path):
if settings.MODE == 'test':
BUCKETNAME = 'testweapp'
else:
BUCKETNAME = 'weappimg'
USERNAME = '******'
PASSWORD = '******'
if settings.MODE == 'develop':
return upyun_path
up = upyun.UpYun(BUCKETNAME,
USERNAME,
PASSWORD,
timeout=300,
endpoint=upyun.ED_AUTO)
try:
with open(file_path, 'rb') as f:
try:
res = up.put(upyun_path, f)
except:
res = up.put(upyun_path, f)
return image_path % (BUCKETNAME, upyun_path)
except:
notify_message = u"upload_image_to_upyun error {}".format(
unicode_full_stack())
print notify_message
return upyun_path
return None
def pay_order(request):
order_to_pay = None
profile = request.user_profile
webapp_user = request.webapp_user
order_id = request.POST.get('order_id', None)
if order_id is None:
response = create_response(400)
response.errMsg = u'订单不存在'
return response.get_response()
try:
order_to_pay = Order.objects.get(id=order_id)
except:
response = create_response(500)
response.errMsg = u'获取订单失败'
response.innerErrMsg = full_stack()
return response.get_response()
interface_id = int(request.POST.get('interface_id', 0))
pay_interface = PayInterface.objects.get(id=interface_id)
pay_url = shihuazhiye_util.pay(pay_interface, order_to_pay, request.webapp_owner_id)
if pay_url:
response = create_response(200)
response.data.url = pay_url
else:
response = create_response(500)
response.errMsg = u'支付失败'
stack = unicode_full_stack()
response.innerErrMsg = full_stack()
return response.get_response()
def get_integral_log(request):
# 1. 解析会员信息
member_id = request.GET.get('member_id', '')
try:
if not hasattr(request, 'member') or request.member is None:
member = Member.objects.get(id=member_id)
else:
member = request.member
MemberIntegralLog.update_follower_member_token(member)
except:
notify_msg = u"webapp，积分日志, cause:\n{}".format(unicode_full_stack())
watchdog_error(notify_msg)
raise Http404('不存在该会员')
# 2. 获取与该会员对应的积分日志列表（按日期倒叙）
member_integral_logs = list(
MemberIntegralLog.objects.filter(
member=member).order_by('-created_at'))
# 3. 组织积分日志结构，将同一天好友奖励的积分日志在一条记录中显示，并且显示好友头像
organized_integral_log_list = __get_organized_integral_log_list(
member_integral_logs)
# 4. 将组织后的日志信息，渲染到integral_log.html页面中
c = RequestContext(
request, {
'is_hide_weixin_option_menu': True,
'page_title': u'积分日志',
'member_integral_logs': organized_integral_log_list,
'member': member
})
return render_to_response('%s/integral_log.html' % request.template_dir, c)
def _handle_keyword(self, context, from_weixin_user, is_from_simulator):
# request = context.request
message = context.message
user_profile = context.user_profile
response = None
#获取匹配用户输入的自动答复规则
if hasattr(message, 'content') is False:
message.content = ''
#response_rule = qa_util.find_answer_for(user_profile.webapp_id, message.content.lower())
#从缓存中获取数据 duhao 2015-03-09
response_rule = cache_util.find_answer_from_cache_for(
user_profile.webapp_id, message.content.lower())
if (response_rule is None) or (not response_rule.is_active):
response_rule, response = self._build_response_without_auto_response_rule(
user_profile, message, is_from_simulator)
else:
response = self._build_response_with_auto_response_rule(
user_profile, message, response_rule, is_from_simulator)
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())
watchdog_error(notify_message)
return response
def get_brand_value(webapp_id, date_str):
"""
获取品牌价值的接口（如果数据库中有非今日的缓存值，则取出；否则计算并存入数据库）
@retval brand_value(整型，单位元)
"""
cached, created = BrandValueHistory.objects.get_or_create(
webapp_id=webapp_id, value_date=date_str)
today = util_dateutil.date2string(util_dateutil.now())
# 如果有缓存的数据，从数据库取数据
#print("date_str: {}, count: {}".format(date_str, cached.count()))
if date_str != today and not created:
brand_value = int(cached.value)
else:
brand_value = 0
try:
brand_value = compute_brand_value(webapp_id, date_str)
#print("date_str: {}, value: {}".format(date_str, brand_value))
#BrandValueHistory.objects.create(
# webapp_id=webapp_id,
# value_date=date_str,
# value=brand_value)
cached.webapp_id = webapp_id
cached.value_date = date_str
cached.value = brand_value
cached.save()
brand_value = int(brand_value)
except:
notify_msg = u"存微品牌数据失败, cause:\n{}".format(unicode_full_stack())
watchdog_error(notify_msg)
return brand_value
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 get_social_account_by_member_id(member_id):
try:
return MemberHasSocialAccount.objects.filter(member_id=member_id)[0].account
except:
error_msg = u"get_social_account:\n{}, {}".format(member_id, unicode_full_stack())
watchdog_error(error_msg)
return None
def api_get(request):
"""
响应GET
"""
try:
cur_color = random.choice(COLOR_LIST)
captcha_image = captcha(
drawings=[
background('#FFFFFF'),
text(fonts=['ARLRDBD.TTF'],
font_sizes=[30],
drawings=[offset(dx_factor=0.1, dy_factor=0.1)],
color=cur_color,
squeeze_factor=1.2),
curve(cur_color),
noise(),
# smooth()
],
width=120,
height=45)
code_dict = init_check_code()
rand_list = code_dict['clist']
rand_str = code_dict['cstr']
image = captcha_image(rand_list)
# 将验证码转换成小写，并保存到session中
request.session['checkcode'] = rand_str.lower()
buf = StringIO.StringIO()
image.save(buf, 'png')
return HttpResponse(buf.getvalue(), 'image/png')
except:
error_msg = u"生成扫码抽奖验证码失败, cause:\n{}".format(unicode_full_stack())
watchdog_error(error_msg)
return HttpResponse('')
def send_message(self):
try:
message = self._get_message_dict()
if message is None:
return False, u"message dict错误"
mpuser_access_token = self._get_mpuser_access_token(self.user)
weixin_api = get_weixin_api(mpuser_access_token)
result = weixin_api.send_template_message(message, True)
return True, result
except:
notify_message = u"shengjing发送模板消息异常, cause:\n{}".format(
unicode_full_stack())
watchdog_warning(notify_message,
self.shengjing_params.WATCHDOG_TYPE_SHENGJING)
return False, unicode_full_stack()
def api_get(request):
"""
购买过会员分析
"""
webapp_id = request.user_profile.webapp_id
bought_fans_count = Member.objects.filter(webapp_id=webapp_id,
is_for_test=False,
pay_times__gt=0).count()
not_bought_fans_count = Member.objects.filter(webapp_id=webapp_id,
is_for_test=False,
pay_times=0).count()
tooltip = {
'trigger': 'item',
'formatter': '{b}</br>人数：{c}</br>占比：{d}%',
'backgroundColor': '#FFFFFF',
'textStyle': {
'color': '#363636'
},
'borderWidth': 1,
'borderColor': '#363636'
}
try:
return create_pie_chart_response('', {
"购买过的会员": bought_fans_count,
"未购买过的会员": not_bought_fans_count
}, tooltip)
except:
if settings.DEBUG:
raise
else:
response = create_response(500)
response.innerErrMsg = unicode_full_stack()
return response.get_response()
def supplier_name(self):
try:
# 非微众系列商家
if not self.context['webapp_owner'].user_profile.webapp_type:
return ''
# 手动添加的供货商
if self.supplier:
supplier = account_model.UserProfile.select().dj_where(
user_id=self.supplier).first()
if supplier:
return supplier.store_name
else:
supplier = mall_models.Supplier.select().dj_where(
id=self.supplier).first()
if supplier:
print 'still old supplier ........................', self.supplier
return supplier.name
# 同步的供货商
relation = mall_models.WeizoomHasMallProductRelation.select(
).dj_where(weizoom_product_id=self.id).first()
if relation:
supplier_name = account_model.UserProfile.select().dj_where(
user_id=relation.mall_id).first().store_name
else:
supplier_name = ''
return supplier_name
except:
watchdog.alert(unicode_full_stack())
return ''
def increase_father_member_integral_by_child_member_buyed(order, webapp_id):
webapp_user_id = order.webapp_user_id
integral_settings = IntegralStrategySttings.objects.filter(
webapp_id=webapp_id)
member = WebAppUser.get_member_by_webapp_user_id(webapp_user_id)
if integral_settings.count() > 0 and member:
father_member = MemberFollowRelation.get_father_member(member.id)
if father_member and integral_settings[
0].buy_via_offline_increase_count_for_author != 0:
increase_member_integral(
father_member,
integral_settings[0].buy_via_offline_increase_count_for_author,
BUY_INCREST_COUNT_FOR_FATHER)
if order.final_price > 0 and integral_settings[
0].buy_via_offline_increase_count_percentage_for_author:
try:
buy_via_offline_increase_count_percentage_for_author = float(
integral_settings[0].
buy_via_offline_increase_count_percentage_for_author)
integral_count = int(
order.final_price *
buy_via_offline_increase_count_percentage_for_author)
increase_member_integral(father_member, integral_count,
BUY_INCREST_COUNT_FOR_FATHER)
except:
notify_message = u"increase_father_member_integral_by_child_member_buyed cause:\n{}".format(
unicode_full_stack())
watchdog_error(notify_message)
def get_courses(request):
count = request.GET.get('count', 10)
page = request.GET.get('page', 1)
webapp_owner_id = request.GET.get('webapp_owner_id', 1)
try:
courses, has_next = crm_api_views.list_course(page, 10000, 60)
except:
watchdog_error(u'crm_api_views.list_course 错误！！{}'.format(unicode_full_stack()))
response = create_response(500)
response.errMsg = u'获取数据失败'
return response.get_response()
shengjing_courses = ShengjingCourseRelation.objects.filter(owner_id=webapp_owner_id)
shengjing_course_id2course = dict([(c.course_id, c) for c in shengjing_courses])
shengjing_course_id2config = dict([(course.course_id, course.config)for course in shengjing_courses])
cur_courses = []
for c in courses:
if c['id'] in shengjing_course_id2course:
c['cover_pic_url'] = shengjing_course_id2config[c['id']].course_cover_pic_url
c['introduction'] = shengjing_course_id2config[c['id']].introduction
cur_courses.append(c)
response = create_response(200)
response.data.items = cur_courses
response.data.pageinfo.has_next = has_next
return response.get_response()
def update_user_by_agent(request):
username = request.POST.get('un', None)
store_name = request.POST.get('stn', None)
key = request.POST.get('key', None)
settlement_period = request.POST.get('sp', None)
is_formal = True if request.POST.get('at', 'formal') == 'formal' else False
if KEY != key:
response = create_response(INVALID_KEY_ERROR_CODE)
response.errMsg = u'非法的key'
return response.get_response()
exist_users = User.objects.filter(username=username)
if exist_users.count() == 0:
response = create_response(400)
response.errMsg = u'该用户不存在'
return response.get_response()
to_operate_user = exist_users[0]
try:
user_profile = UserProfile.objects.get(user=to_operate_user)
user_profile.store_name = store_name
user_profile.is_formal = is_formal
if settlement_period:
user_profile.settlement_period = int(settlement_period)
user_profile.save()
response = create_response(200)
except:
response = create_response(500)
response.errMsg = u'系统繁忙，请稍后重试'
response.innerErrMsg = unicode_full_stack()
return response.get_response()
def put(args):
"""
@warning: 对外网开放的支付接口，只接受从h5支付方式列表发起的货到付款,高风险，改动需慎重
"""
webapp_user = args['webapp_user']
webapp_owner = args['webapp_owner']
order_id = args['order_id'].split('-')[0]
pay_interface_type = int(args['pay_interface_type'])
# 此接口只可使用货到付款
if pay_interface_type != mall_models.PAY_INTERFACE_COD:
watchdog.alert('货到付款接口被异常调用,woid:%s,webapp_user_id:%s',
(webapp_owner.id, webapp_user.id))
return 500, {}
order = Order.from_id({
'webapp_owner': webapp_owner,
'webapp_user': webapp_user,
'order_id': order_id
})
try:
is_success, msg = order.pay(
pay_interface_type=mall_models.PAY_INTERFACE_COD)
except:
is_success = False
msg = unicode_full_stack()
watchdog.alert(msg)
return {
'order_id': args['order_id'],
'is_success': is_success,
}
def update_member_source(request, args):
"""
更新用户来源(?)
"""
member = member_info_util.get_request_member(request)
if member is None:
return None
if member.source == -1:
followed_member_token = member_info_util.get_followed_member_token(
request)
if followed_member_token:
followed_member = member_info_util.get_member_by_member_token(
followed_member_token)
if followed_member and member and member.id != followed_member.id and followed_member.webapp_id == request.app.appid:
member_models.Member.objects.filter(id=member.id).update(
source=member_models.SOURCE_BY_URL)
try:
shared_url_digest = request.COOKIES.get(
member_settings.FOLLOWED_MEMBER_SHARED_URL_SESSION_KEY,
None)
if shared_url_digest:
integral.increase_shared_url_followers(
followed_member, shared_url_digest)
except:
notify_message = u"MemberSouceMiddleware error, cause:\n{}".format(
unicode_full_stack())
watchdog_error(notify_message)
else:
member_models.Member.objects.filter(id=member.id).update(
source=member_models.SOURCE_SELF_SUB)
else:
member_models.Member.objects.filter(id=member.id).update(
source=member_models.SOURCE_SELF_SUB)
def create_authorized_user_from_other_site(request):
username = request.GET.get('un', None)
password = request.GET.get('pw', None)
logout_redirect_to = request.GET.get('logout_redirect_to', None)
if (username is None) or (password is None):
response = create_response(400)
else:
user = auth.authenticate(username=username, password=password)
if user is not None:
try:
UserProfile.objects.filter(user=user).update(
logout_redirect_to=logout_redirect_to)
except:
error_msg = u"更新user('{}')的logout_redirect_to('{}')失败, cause:\n{}"\
.format(username, logout_redirect_to, unicode_full_stack())
watchdog_error(error_msg, user_id=user.id)
response = create_response(200)
response.token = get_token_for_logined_user(user)
else:
response = create_response(400)
return response.get_jsonp_response(request)
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 get_templates(user):
"""
从微信获取商家在公众号中配置的所有模板消息
@param owner_id:
@return:
"""
mpuser_access_token = _get_mpuser_access_token(user)
if mpuser_access_token:
weixin_api = get_weixin_api(mpuser_access_token)
try:
result = weixin_api.get_all_template_messages(True)
template_list = result['template_list']
user_update_list = []
for t in template_list:
user_update_list.append(
UserHasTemplateMessages(
owner_id=user.id,
template_id=t['template_id'],
title=t['title'],
primary_industry=t['primary_industry'],
deputy_industry=t['deputy_industry'],
content=t['content']))
UserHasTemplateMessages.objects(owner_id=user.id).delete()
UserHasTemplateMessages.objects.insert(user_update_list)
print result, 'asdfsgsf'
except Exception, e:
print e
notify_message = u"获取模板列表异常, cause:\n{}".format(
unicode_full_stack())
watchdog_warning(notify_message)
def update_binded_mpuser(request):
try:
mpuser = WeixinMpUser.objects.filter(
id=int(request.POST['mpid'])).update(
# username = request.POST['username'].strip(),
is_service=True
if request.POST['is_service'] == 'true' else False,
is_certified=True
if request.POST['is_certified'] == 'true' else False,
aeskey=request.POST.get('aeskey', '0'),
encode_aeskey=request.POST.get('encode_aeskey', ''),
)
MpuserPreviewInfo.objects.filter(
id=int(request.POST['mpprid'])).update(
image_path=request.POST['pic_url'],
name=request.POST['mpuser_nickname'].strip(),
)
response = create_response(200)
except:
response = create_response(500)
response.errMsg = u"更新公众号信息失败"
response.innerErrMsg = unicode_full_stack()
return response.get_response()
def get_orders(request):
token = request.GET.get('token', '').strip()
response = erp_util.check_invalid_serach_type(
request.GET.get('serach_type', '0'))
if response:
return response
try:
pageinfo, request_orders, count_per_page = __get_request_order_list(
request)
return_orders_jsonarray = []
# 构造返回数据
for order in request_orders:
return_orders_jsonarray.append(
__build_return_order_min_json(order))
response = create_response(200)
response.data = {'items': return_orders_jsonarray}
if count_per_page == -1:
response.data['pageinfo'] = {
'object_count': pageinfo['object_count']
}
else:
response.data['pageinfo'] = paginator.to_dict(pageinfo)
except:
response = create_response(590)
response.errMsg = u'内部异常'
error_msg = u"erp获取订单列表 token={}, cause:\n{}".format(
token, unicode_full_stack())
response.innerErrMsg = error_msg
watchdog_error(error_msg)
return response.get_response()
def _send_response(self):
"""
发送电子面单请求，返回成功与否信息
"""
# post中的param的json
headers = {'content-type': 'application/json'}
param_json_data = self._build_post_data()
DataSign = self._encrypt(json.dumps(param_json_data))
params = json.dumps({
"RequestData": json.dumps(param_json_data),
"EBusinessID": self.Business_id,
"RequestType": "1007",
"DataSign": DataSign,
"DataType": "2"
})
verified_result = ''
try:
verified_result = requests.post(KdniaoExpressConfig.eorder_url,
data=params,
headers=headers)
watchdog.watchdog_info(
u"发送快递鸟 电子面单请求 url: {},/n param_data: {}".format(
KdniaoExpressConfig.eorder_url, params), "EXPRESS")
except:
watchdog.watchdog_error(
u'发送快递鸟 电子面单请求 失败，url:{},data:{},原因:{}'.format(
KdniaoExpressConfig.eorder_url, params,
unicode_full_stack()), "EXPRESS")
return verified_result
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 resolve(self, path):
method = None
app_resource = None
func = None
try:
items = path.split('/')
method = items[-1].lower()
if items[0] == 'api':
resource = '/'.join(items[1:-1])
method = 'api_%s' % method
else:
resource = '/'.join(items[:-1])
app_resource = '%s-%s' % (self.app_name, resource)
class_info = resource_util.APPRESOURCE2CLASS.get(app_resource, None)
# print '-*-' * 20
# print 'path: ', path
# print 'method: ', method
# print 'app_resource: ', app_resource
# print '-$-' * 20
if class_info:
if not class_info['instance']:
class_info['instance'] = class_info['cls']
resource_instance = class_info['instance']
func = getattr(resource_instance, method, None)
if func:
return ResolverMatch(func, (), {}, path)
else:
self.__raise_404(path)
else:
self.__raise_404(path)
except:
context = {
'path': path,
'method': method,
'app_resource': app_resource,
'func': func,
'APPRESOURCE2CLASS': resource_util.APPRESOURCE2CLASS
}
notify_message = u"RESTful url2 route failed, context:{}\ncause:\n{}".format(str(context), unicode_full_stack())
# watchdog_fatal(notify_message, type='URL_ROUTE', noraise=True)
self.__raise_404(path)
