def agree_refund(cls, user_id, order_id):
balance = OrderService.get_balance(user_id)
refund_order = cls._get_refund_order(order_id)
if balance < refund_order.price:
return 1, "您余额不足退款给买家", {}
if not refund_order:
return 1, "没有这个退款单", {}
if refund_order.refund_state not in [OrderState.APPLY_REFUNDING]:
return 1, "正在处理中", {}
# need 统一错的情况
# 。。。
from .wechartpay import WechatRefund
wp = WechatRefund()
result_json = wp.apply_refund(refund_order.out_trade_no,
refund_order.out_refund_no,
refund_order.price)
print(result_json)
logger.info(result_json)
if result_json.get("result_code", "") == "SUCCESS":
cls.save_refund_order_scuess(result_json,
refund_order.out_refund_no)
# freeze money
OrderService.freeze(user_id, refund_order.price,
refund_order.out_refund_no)
OrderService.update_order_status(order_id, OrderState.REFUNDING)
else:
return 1, result_json.get("err_code_des", ""), {}
return 0, "scuessfull", {"order_id": order_id}
def get_customer_info_index(request, **kwargs):
"""
个人中心--首页
:param request:
:return:
"""
user_id = kwargs.get("userid")
kwargs = {
"user_id": user_id,
"other_query": ~Q(seller_id=user_id),
}
logger.info("customer index, kwargs: %s" % kwargs)
_, fans = CustomerService.get_my_fans_by_user_id(user_id)
_, follows = CustomerService.get_my_follows(**kwargs)
spreaders = JieLongSpreadUserRelation.objects.filter(
status=1, invite_sponsor_id=user_id).count()
balance = OrderService.get_balance(user_id)
_, apply_refunding = OrderService.refund_order_list(
refund_state="apply_refunding", seller_id=user_id)
result = {
"meta": {
"msg": "success",
"code": 0
},
"results": {
"follow": follows,
"fans": fans,
"spreader": spreaders,
"balance": "%s" % balance,
"apply_refunding": apply_refunding,
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def save_refund_order_fail(cls, order_id, reason):
refund_order = cls._get_refund_order(order_id)
save_dict = {
"refund_state": OrderState.REFUND_FAILED,
"fail_reason": reason
}
models.WeChatRefund.objects.update_or_create(
out_refund_no=refund_order.out_refund_no, defaults=save_dict)
OrderService.update_order_status(order_id, OrderState.REFUND_FAILED)
def get_jielong_list_by_spread_user(user_id, start, end):
'''
根据发起人id获取接龙列表
:param user_id:
:return:
'''
jielongs = JieLong.objects.filter(passport_user_id=user_id).order_by(
"-create_time", "status")
count = jielongs.count()
jielongs = jielongs[start:end]
if count > end:
has_next = True
else:
has_next = False
jielong = []
if jielongs:
for j in jielongs:
browse_num = j.browse_num
orderlist, count = OrderService.order_list(jielong_id=j.id)
total_price = OrderService.total_order_price(jielong_id=j.id)
# order_total_price = total_price["order_num"]
order_total_price = total_price
if not order_total_price:
order_total_price = "0.00"
item = {
"id":
j.id,
"title":
j.title,
"status":
get_jielong_status(j.id),
"create_time":
get_time_span(UtilDateTime.utc2local(j.create_time)),
"nick":
get_covert_user_nickname(j.id,
j.passport_user.wechatuser.nickname),
"avatar_url":
covert_avatar_url(j.passport_user.wechatuser.avatar_url),
"info":
"%s人浏览 , %s人参加，总收入%s元" % (browse_num, count, order_total_price)
}
jielong.append(item)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"has_next": has_next,
"items": jielong
}
}
return result
def get_spread_user_list(request, **kwargs):
"""
我的推广者--推广人列表
:param request:
:return:
"""
user_id = kwargs.get("userid")
pagination = Pagination(request)
start = pagination.start
end = pagination.end
try:
results, items, has_next = {}, [], False
user_relations = JieLongSpreadUserRelation.objects.filter(
invite_sponsor_id=user_id, status=1)
count = user_relations.count()
logger.info("spreader_list, user_id: %s; count: %s" % (user_id, count))
if count > 0:
user_relations = user_relations.order_by("-update_time")[start:end]
if count > end:
has_next = True
for user_relation in user_relations:
items_dict = {}
order_num_result = OrderService.total_commission_price(
seller_id=user_id,
spread_user_id=user_relation.passport_user_id)
o_list, order_count = OrderService.order_list(
page_size=20,
page_no=1,
seller_id=user_id,
spread_user_id=user_relation.passport_user_id)
items_dict["id"] = user_relation.passport_user.id
items_dict["nick"] = jielong_service.get_covert_user_nickname(
user_relation.passport_user_id,
user_relation.passport_user.wechatuser.nickname)
items_dict["avatar_url"] = jielong_service.covert_avatar_url(
user_relation.passport_user.wechatuser.avatar_url)
items_dict["status"] = user_relation.status
items_dict["commission_info"] = "共推广%s单，收入%s元" % (
order_count, order_num_result)
items.append(items_dict)
results["count"] = count
results["items"] = items
results["has_next"] = has_next
code, msg = 0, "success"
logger.info("get_spread_user_list: result:%s" % (results))
except Exception as e:
print(e)
logger.info("get_spread_user_list: error:%s" % (e))
code, msg = 90100, "服务器错误"
results = {}
result = {"meta": {"msg": msg, "code": code}, "results": results}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def save_pay_order(cls, order):
pays = models.WeChatPay.objects.get(
out_trade_no=order.get("out_trade_no"))
if not cls.check_pay(pays.order_id):
logger.info(f"{pays.order_id}已经支付")
return
save_dict = {
"transaction_id": order.get("transaction_id"),
"out_trade_no": order.get("out_trade_no"),
"time_end": order.get("time_end"),
"total_fee": order.get("total_fee"),
"trade_state": order.get("trade_state", ""),
"ctime": datetime.strptime(order.get("time_end"), "%Y%m%d%H%M%S")
}
models.WeChatPay.objects.update_or_create(
out_trade_no=order.get("out_trade_no"), defaults=save_dict)
order_info = OrderService.pay_sccuess(pays.order_id,
save_dict.get("ctime"))
# send template message
data = {
"name": order_info.get("name"),
"number": order_info.get("number"),
"money": save_dict.get("total_fee"),
"create_time":
save_dict.get("ctime").strftime("%Y-%m-%d %H:%M:%S"),
"way": "微信支付",
"order_id": pays.order_id,
}
PushOrderMessage.send_message(pays.openid, pays.prepay_id, data)
try:
order_detail = OrderService.order_detail(pays.order_id)
from passport.models import PassportUser
seller = PassportUser.objects.get(id=order_detail.get("seller_id"))
we_user = seller.wechatuser
goods_titles = [d.get("title") for d in order_detail.get("goods")]
data_tuanzhang = {
"name": order_info.get("name"),
"goods": "、".join(goods_titles),
"price": order_detail.get("order_price"),
"user_name": we_user.nickname,
"money": save_dict.get("total_fee"),
"create_time":
save_dict.get("ctime").strftime("%Y-%m-%d %H:%M:%S"),
"order_id": pays.order_id,
}
PushTuanZhangMessage.send_message(we_user.openid, pays.prepay_id,
data_tuanzhang)
except Exception as e:
import traceback
logger.exception(f'{e}')
logger.info("openid%s, pay_id:%s", pays.openid, pays.prepay_id)
def refund_sccuess(cls, order):
save_dict = {
"settlement_refund_fee":
order.get("settlement_refund_fee"),
"refund_status":
order.get("refund_status"),
"success_time":
order.get("success_time"),
"refund_recv_accout":
order.get("refund_recv_accout"),
"refund_account":
order.get("refund_account", ""),
"refund_request_source":
order.get("refund_request_source", ""),
"ctime":
datetime.strptime(order.get("success_time"), "%Y-%m-%d %H:%M:%S")
}
orders = models.WeChatRefund.objects.get(
out_refund_no=order.get("out_refund_no"))
if orders.refund_state == OrderState.REFUNDED:
logger.info(f"已经退款{ orders.order_id }")
return
if save_dict["refund_status"] == "SUCCESS":
save_dict["refund_state"] = OrderState.REFUNDED
OrderService.refund_statement(orders.order_id, orders.price)
OrderService.update_order_status(orders.order_id,
OrderState.REFUNDED)
else:
save_dict["refund_state"] = OrderState.REFUND_FAILED
save_dict["fail_reason"] = "wechart failed"
OrderService.update_order_status(orders.order_id,
OrderState.REFUND_FAILED)
OrderService.unfreeze(order.get("out_refund_no"))
models.WeChatRefund.objects.update_or_create(
out_refund_no=order.get("out_refund_no"), defaults=save_dict)
def get_jielong_order_list(request,**kwargs):
user_id = kwargs.get("userid")
jielong_id = request.GET.get("jielong_id",None)
if not jielong_id:
result = {
"meta": {
"msg": "缺少接龙活动id参数",
"code": 1
},
"results": {}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
kwargs = {
"seller_id": user_id,
"jielong_id":jielong_id
}
page_size = int(request.GET.get("page_size", 20))
page_no = int(request.GET.get("page_no", 1))
list_data, count = OrderService.order_list(page_size, page_no, **kwargs)
# list_data = OrderService.format_jielong_order(list_data)
has_next = False if len(list_data) <= page_size else True
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"has_next": has_next,
"items": list_data
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def order_cancel(request,**kwargs):
userid = kwargs.get("userid", None)
order_dict = json.loads(request.body)
order_id = order_dict.get("order_id")
OrderService.cancel_order(order_id)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"order_no": order_id
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def update_commit(request, **kwargs):
userid = kwargs.get("userid", None)
order_dict = json.loads(request.body)
order_id = order_dict.get("order_id")
order_type = order_dict.get("type", "buyer")
OrderService.update_remark(order_id, order_dict.get("content", ""), order_type)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_order_detail(request):
order_id = request.GET.get("order_id", "")
results = OrderService.order_detail(order_id)
refund_state = results["refund_state"]
refund_order = ReFundService.get_format_refund_order(order_id)
if refund_order != "":
apply_reason = refund_order["reason"]
else:
apply_reason = ""
if refund_state != "":
refund_button = False
if refund_state == "apply_refunding":
refund_button = True
results["seller_refund_info"] = {
"refund_info": results["refund_info"],
"refund_info_color": results["refund_info_color"],
"refund_button": refund_button,
"refund_apply_reason": apply_reason,
"refund_state": results["refund_state"]
}
result = {
"meta": {
"msg": "",
"code": 0
},
"results": results
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_spreaders_by_orderuser(cls, **kwargs):
# query = OrderService._parse_query_params(**kwargs)
logger.info("get_spreaders_by_orderuser, kwargs: %s")
spread_user_ids = OrderService.order_queryset(**kwargs).values("spread_user_id").distinct()
count = spread_user_ids.count()
if count > 0:
spread_user_ids = [s["spread_user_id"] for s in spread_user_ids]
return spread_user_ids, count
def _create_order_report(self, sheet, data_list, flush_bound=500):
sheet_style_normal = self.get_sheet_style()
row_index = 1
with open(OrderReport.report_abs_path_txt, mode="w",
encoding="utf-8") as f:
for item in data_list:
order_detail = OrderService.order_detail(item.trade_parent_id)
string = ""
for order in order_detail["goods"]:
sheet.row(row_index).write(0,
str(order_detail["trade_id"]),
style=sheet_style_normal)
sheet.row(row_index).write(1,
order["title"],
style=sheet_style_normal)
sheet.row(row_index).write(2,
str(order["buy_num"]),
style=sheet_style_normal)
sheet.row(row_index).write(3,
str(order["price"]),
style=sheet_style_normal)
sheet.row(row_index).write(
4,
order_detail["address"]["receiver"],
style=sheet_style_normal)
sheet.row(row_index).write(
5,
str(order_detail["address"]["tel"]),
style=sheet_style_normal)
sheet.row(row_index).write(
6,
order_detail["address"]["address"],
style=sheet_style_normal)
sheet.row(row_index).write(7,
order_detail["comment"],
style=sheet_style_normal)
sheet.row(row_index).write(8,
order_detail["seller_comment"],
style=sheet_style_normal)
# str_item = "姓名: %s。\t电话: %s。\t地址: %s。\t商品名称: %s。\t商品数量: %s\n" % (
# order_detail["address"]["receiver"], order_detail["address"]["tel"], order_detail["address"]["address"], order["title"], str(order["buy_num"])
# )
str_item = "%s。%s。%s。%s * %s\n" % (
order_detail["address"]["receiver"],
order_detail["address"]["tel"],
order_detail["address"]["address"], order["title"],
str(order["buy_num"]))
string += str_item
row_index += 1
f.write(string)
if row_index % flush_bound == 0:
sheet.flush_row_data()
# ToDo
if row_index >= 65535:
# Excel 2003格式最大行数
print("Warning: excel reach max row num.")
break
def create_refund_order(cls, order_id, pay_order, reason):
save_dict = {
"user_id": pay_order.user_id,
"out_trade_no": pay_order.out_trade_no,
"out_refund_no": pay_order.out_trade_no,
"order_id": order_id,
"transaction_id": pay_order.transaction_id,
"price": str(pay_order.price),
"refund_state": OrderState.APPLY_REFUNDING,
"reason": reason,
}
from .wechartpay import local2utc
models.WeChatRefund.objects.update_or_create(
out_refund_no=pay_order.out_trade_no, defaults=save_dict)
OrderService.update_order_status(order_id,
OrderState.APPLY_REFUNDING,
apply_refund_time=local2utc(
datetime.now()))
def order_create(request,**kwargs):
userid = kwargs.get("userid", None)
order_dict = json.loads(request.body)
# req = {
# "jielong_id": 1,
# "goods": [{
# "id": 1,
# "sku_desc": "规格",
# "product_num": 2
# },
# {
# "id": 2,
# "sku_desc": "规格",
# "product_num": 3
# },
# ]
# }
jielong_id = order_dict.get("jielong_id")
goods = order_dict.get("goods")
spread_user = order_dict.get("spread_user_id")
o = OrderService(userid)
try:
order_id = o.create_order(jielong_id, spread_user, goods)
except Exception as e:
msg = str(e)
result = {
"meta": {
"msg": msg,
"code": 1
},
"results": {
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"order_no": order_id
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_jielong_ids(user_id):
'''
获取用户创建和参与的活动id
:param user_id:
:return: c_ids,p_ids,m_ids
'''
c_jielongs = JieLong.objects.filter(passport_user_id=user_id).order_by(
"-create_time", "status")
c_ids = []
p_ids = []
m_ids = []
for c in c_jielongs:
c_id = c.id
c_ids.append(c_id)
m_ids.append(c_id)
p_jielongs = OrderService.order_queryset(user_id=user_id).values_list(
"activity_id", flat=True).distinct()
for p in p_jielongs:
p_id = int(p)
p_ids.append(p_id)
m_ids.append(p_id)
a_user = JieLongUserRelation.objects.filter(passport_user_id=user_id,
is_attention=0)
a_user_ids = []
for u in a_user:
a_user_ids.append(u.jielong.passport_user_id)
a_user_ids = list(set(a_user_ids))
a_jielongs = JieLong.objects.filter(
passport_user_id__in=a_user_ids).order_by("-create_time", "status")
a_ids = []
for a in a_jielongs:
a_ids.append(a.id)
m_ids.append(a.id)
s_user_ids = []
# s_user = JieLongSpreadUserRelation.objects.filter(passport_user_id = user_id,status = 1)
# for s in s_user:
# s_user_ids.append(s.invite_sponsor_id)
# s_jielongs = JieLong.objects.filter(passport_user_id__in=s_user_ids)
# s_ids = []
# for s in s_jielongs:
# s_ids.append(s.id)
# m_ids.append(s.id)
func = lambda x, y: x if y in x else x + [y]
m_ids = reduce(func, [
[],
] + m_ids)
logger.info("get_jielong_ids user-info a_user_ids: %s;s_user_ids:%s" %
(a_user_ids, s_user_ids))
return c_ids, p_ids, m_ids
def get_jielong_order_list(request):
jielong_id = request.GET.get("jielong_id", None)
if not jielong_id:
result = {"meta": {"msg": "API请求参数错误", "code": 90001}}
logger.info("get_jielong_order_list result jielong_id %s" %
(jielong_id))
return JsonResponse(result, encoder=DjangoJSONEncoder)
pagination = Pagination(request)
order_list, count = OrderService.order_list(page_no=pagination.page_no,
page_size=pagination.page_size,
jielong_id=jielong_id)
has_next = False if len(order_list) <= pagination.page_size else True
orders = []
if len(order_list) > 0:
index = len(order_list)
for o in order_list:
goods_info = []
goods = o["goods"]
if len(goods):
for g in goods:
g_info = "%s(%s元) x %s" % (g["title"], g["price"],
g["buy_num"])
goods_info.append(g_info)
item = {
"index":
index,
"nick":
jielong_service.get_covert_user_nickname(
o["user_id"], o["nickname"]),
"avatar_url":
jielong_service.covert_avatar_url(o["avatar_url"]),
"create_time":
get_time_span(o["order_time"].strftime("%Y-%m-%d %H:%M:%S")),
"order_info":
"已支付%s元" % (o["order_price"]),
"specifications_info":
goods_info
}
orders.append(item)
index -= 1
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"has_next": has_next,
"items": orders
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_my_follows(cls, **kwargs):
""" 我的关注 """
pagination = kwargs.get("pagination", None)
if not pagination:
pagination = cls.paginator()
follows = OrderService.order_queryset(**kwargs).values("seller_id").distinct()
count = follows.count()
follows = follows[pagination.start: pagination.end]
if follows:
follows = [f["seller_id"] for f in follows]
logger.info("my_follows, kwargs: %s, count:%s, follows: %s" % (kwargs, count, follows))
return follows, count
def get_jielong_order(self, jielong_id):
"""
根据接龙活动查订单
:param jielong_id:
:return: channel order list
"""
other_query = ~Q(
status__in=[OrderState.REFUNDING, OrderState.REFUNDED])
order_list = OrderService.order_queryset(jielong_id=jielong_id,
other_query=other_query)
count = order_list.count()
print("channel:%s order num:%s" % (jielong_id, count))
return order_list
def get_refund_order_count(request,**kwargs):
user_id = kwargs.get("userid")
refund_state = request.GET.get("state", "")
results = OrderService.refund_order_list(refund_state=refund_state, seller_id=user_id)
result = {
"meta":{
"msg":"",
"code":0
},
"results":{
"refund_order_count": results[1]
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_join_order_list(request,**kwargs):
user_id = kwargs.get("userid")
# user_id = 1
kwargs = {
"user_id": user_id
}
page_size = int(request.GET.get("page_size", 20))
page_no = int(request.GET.get("page_no", 1))
list_data, count = OrderService.order_list(page_size, page_no, **kwargs)
list_data = OrderService.format_jielong_order(list_data)
# logger.info("get_join_order_list result %s" % (list_data))
logger.info("get_join_order_list user_id %s" % (user_id))
has_next = False if len(list_data) <= page_size else True
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"has_next": has_next,
"items": list_data
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_account_balance_list(request,**kwargs):
# user_id = 1
user_id = kwargs.get("userid")
status = request.GET.get("state", 0)
items = OrderService.get_statement(user_id, status)
result = {
"meta": {
"msg": "",
"code": 0
},
"results":{
"has_next": False,
"items": items
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def apply_refund(cls, user_id, order_id, reason=""):
is_apply = cache.get(f"refund_{user_id}_{order_id}")
if is_apply:
return 1, "操作频繁", {}
if not OrderService.jielong_status(order_id):
return 1, "接龙已经结束", {}
result = 0, "scuessfull", {}
cache.set(f"refund_{user_id}_{order_id}", 1, 60)
order = cls._get_pay_order(order_id)
if not order:
result = 1, "没有这个订单", {}
refund_order_status = cls._get_refund_order_status(order_id)
if refund_order_status:
if refund_order_status not in [OrderState.APPLY_REFUNDING]:
result = 2, "正在申请中", {}
cls.create_refund_order(order_id, order, reason)
cache.delete(f"refund_{user_id}_{order_id}")
return result
def get_refund_order_list(request, **kwargs):
user_id = kwargs.get("userid")
page_size = int(request.GET.get("page_size", 20))
page_no = int(request.GET.get("page_no", 1))
refund_state = request.GET.get("state", "")
list_data, count = OrderService.refund_order_list(page_size, page_no, refund_state, seller_id=user_id)
has_next = False if len(list_data) <= page_size else True
result = {
"meta": {
"msg": "",
"code": 0,
"count": count,
},
"results": {
"has_next": has_next,
"items": list_data
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_join_jielong_order_by_user_id(user_id, page_no, page_size):
order_list, count = OrderService.order_list(page_size=page_size,
page_no=page_no,
user_id=user_id)
has_next = False if len(order_list) <= page_size else True
jielong = []
if len(order_list) > 0:
for o in order_list:
goods_info = []
jielong_id = o["activity_id"]
print(jielong_id)
create_time = o["order_time"].strftime("%Y-%m-%d %H:%M:%S")
pay_info = "已付款 : %s元" % (o["order_price"])
goods = o["goods"]
for g in goods:
g_title = g["title"]
g_sku_des = g["sku_desc"]
g_buy_num = g["buy_num"]
g_info = "%s(%s)x%s" % (g_title, g_sku_des, g_buy_num)
goods_info.append(g_info)
item = {
"title": get_jielong_info_by_id(jielong_id),
"create_time": create_time,
"pay_info": pay_info,
"goods_info": goods_info
}
jielong.append(item)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"has_next": has_next,
"items": jielong
}
}
return result
def get_my_join_jielong_detail(request):
order_id = request.GET.get("order_id", "")
results = OrderService.order_detail(order_id)
if results:
jielong_id = results["activity_id"]
jielong = JieLong.objects.get(id=jielong_id)
p_nickname = jielong.passport_user.wechatuser.nickname
p_avatar_url = jielong.passport_user.wechatuser.avatar_url
wechat_no = jielong.wechat_no
results["nickname"] = p_nickname
results["avatar_url"] = p_avatar_url
results["wechat_no"] = wechat_no
results["time_info"] = "%s发起" % (get_time_span(
UtilDateTime.utc2local(jielong.create_time)))
results["title"] = jielong.title
results["order_time"] = results["order_time"].strftime(
"%Y-%m-%d %H:%M:%S")
results["activity_status"] = jielong_service.get_jielong_status(
jielong_id)
result = {"meta": {"msg": "", "code": 0}, "results": results}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_order_copy_info(request,**kwargs):
order_id = request.GET.get("order_id",None)
if not order_id:
result = {
"meta": {
"msg": "缺少订单id参数",
"code": 1
},
"results": {}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
delivery = []
order_detail = OrderService.order_detail(order_id = order_id)
receiver = order_detail["address"]["receiver"]
tel = order_detail["address"]["tel"]
address = order_detail["address"]["address"]
goods = order_detail["goods"]
if len(goods) > 0:
for g in goods:
title = g["title"]
buy_num = g["buy_num"]
delivery_info = "%s。%s。%s。%s * %s " % (receiver,tel,address,title,buy_num)
delivery.append(delivery_info)
delivery_info = "\n".join(delivery)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
# "order_data":"姓名,电话,地址,商品名称,商品数量\n姓名,电话,地址,商品名称,商品数量"
"order_data":delivery_info
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_delivery_order_list(request,**kwargs):
user_id = kwargs.get("userid")
jielong_id = request.GET.get("jielong_id",None)
if not jielong_id:
result = {
"meta": {
"msg": "缺少接龙活动id参数",
"code": 1
},
"results": {}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
kwargs = {
"seller_id": user_id,
"jielong_id":jielong_id
}
page_size = int(request.GET.get("page_size", 500))
page_no = int(request.GET.get("page_no", 1))
list_data, count = OrderService.order_list(page_size, page_no, **kwargs)
has_next = False if len(list_data) <= page_size else True
delivery = []
if len(list_data) > 0:
for o in list_data:
order_id = o["trade_id"]
order_detail = OrderService.order_detail(order_id = order_id)
receiver = order_detail["address"]["receiver"]
tel = order_detail["address"]["tel"]
address = order_detail["address"]["address"]
goods = order_detail["goods"]
if len(goods) > 0:
for g in goods:
title = g["title"]
buy_num = g["buy_num"]
delivery_info = "%s。%s。%s。%s * %s " % (receiver,tel,address,title,buy_num)
delivery.append(delivery_info)
else:
continue
delivery_info = "\n".join(delivery)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
# "order_data":"姓名,电话,地址,商品名称,商品数量\n姓名,电话,地址,商品名称,商品数量"
"order_data":delivery_info
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
else:
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def get_jielong_list(request, **kwargs):
pagination = Pagination(request)
start = pagination.start
end = pagination.end
user_id = kwargs.get("userid", None)
##############################
c_ids, p_ids, m_ids = jielong_service.get_jielong_ids(user_id)
jielongs = JieLong.objects.filter(id__in=m_ids).order_by(
"-display_order", "-create_time")[start:end]
# count = jielongs.count()
count = len(m_ids)
##############################
# jielongs = jielongs[start:end]
if count > end:
has_next = True
else:
has_next = False
jielong = []
if jielongs:
for j in jielongs:
order_list, count = OrderService.order_list(page_no=1,
page_size=5,
jielong_id=j.id)
jielong_detail = {
"id":
j.id,
"avatar_url":
jielong_service.covert_avatar_url(
j.passport_user.wechatuser.avatar_url),
"nickname":
jielong_service.get_covert_user_nickname(
j.passport_user.id, j.passport_user.wechatuser.nickname),
"time_info":
"%s发起 , %s人看过 , %s人参与" %
(get_time_span(UtilDateTime.utc2local(
j.create_time)), j.browse_num, count),
"title":
j.title,
"thumb_images": [sm for sm in j.small_images.split(" ")]
if j.small_images else [],
"status":
jielong_service.get_jielong_status(j.id),
"details":
jielong_service.format_index_jielong_order(order_list),
"label":
jielong_service.get_jielong_label(j.id, c_ids, p_ids)
}
jielong.append(jielong_detail)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {
"has_next": has_next,
"items": jielong
}
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
def apply_withdraw_cash2(request, **kwargs):
userid = kwargs.get("userid", 5)
save_dict = json.loads(request.body)
money = save_dict.get("money")
from order.models import WithdrawCash
user_name = save_dict.get("user_name")
if not user_name:
result = {
"meta": {
"msg": u"用户实际名不能为空",
"code": 1
},
"results": [],
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
if not money:
result = {
"meta": {
"msg": u"金额不能为空",
"code": 1
},
"results": [],
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
from decimal import Decimal
money = Decimal(money)
if money < Decimal("1"):
result = {
"meta": {
"msg": u"申请金额必须大于等于1",
"code": 1
},
"results": [],
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
withdraw_cashs = WithdrawCash.objects.filter(user_id=userid).filter(status=0)
if withdraw_cashs:
result = {
"meta": {
"msg": u"您有一笔提现正在处理中，不能再次发起提现",
"code": 1
},
"results": [],
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
statements = OrderService.get_balance(userid)
if not statements:
result = {
"meta": {
"msg": u"提现失败，稍后重试或联系客服",
"code": 1
},
"results": [],
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
if statements:
balancea = statements
from passport.models import PassportUser
user = PassportUser.objects.get(id=userid)
we_user = user.wechatuser
import time
out_trade_no = str(int(time.time() * 1000))
if balancea < money:
result = {
"meta": {
"msg": u"提现失败，稍后重试或联系客服",
"code": 1
},
"results": [],
}
return JsonResponse(result, encoder=DjangoJSONEncoder)
cash_dict = {
"user_id": userid,
"user_name": user_name,
"money": money,
"open_id": we_user.openid,
"order_num": out_trade_no,
}
# is_send
# ready_send = WithdrawCash.objects.filter(user_id=userid, status=2).order_by("-update_time")[:1]
# if ready_send:
# result_model = ready_send[0]
# out_trade_no = result_model.order_num
# else:
# cash_dict["order_num"] = out_trade_no
result_model = WithdrawCash.objects.create(**cash_dict)
from payment.wechartpay import WechartWithdrawCash
wechart_cash = WechartWithdrawCash()
wechart_cash.out_trade_no = out_trade_no
result_json = wechart_cash.withdraw_cash(we_user.openid, money, user_name)
if result_json.get("result_code", "") == "SUCCESS":
result_model.payment_no = result_json.get("payment_no", "")
result_model.status = 1
result_model.save()
balance = OrderService.cash_statement(userid, money)
result = {
"meta": {
"msg": "",
"code": 0
},
"results": {"balance": balance}
}
else:
# result_model.payment_no = result_json.get("payment_no", "")
result_model.status = 2
result_model.remark = result_json.get("err_code_des", "")
result_model.save()
result = {
"meta": {
"msg": wechart_cash.check_withdraw_cash_err_des(result_json.get("err_code_des", "")),
"code": 40002
},
"results": {}
}
logger.info("apply_withdraw_cash2 result %s;wx_result_json:%s" % (result,result_json))
return JsonResponse(result, encoder=DjangoJSONEncoder)