def coupons(uid):
current_time = current_timestamp()
q = Coupon.query.\
filter(Coupon.uid == uid).\
filter(Coupon.is_valid == 1).\
filter(Coupon.begin_time <= current_time).\
filter(Coupon.end_time >= current_time)
valid_count = get_count(q)
valid_coupons = q.order_by(Coupon.coupon_id.desc()).all()
q = Coupon.query.\
filter(Coupon.uid == uid).\
filter(or_(and_(Coupon.is_valid == 0, Coupon.order_id == 0), Coupon.end_time < current_time))
invalid_count = get_count(q)
invalid_coupons = q.order_by(Coupon.coupon_id.desc()).all()
q = Coupon.query.\
filter(Coupon.uid == uid).\
filter(Coupon.order_id > 0)
used_count = get_count(q)
used_coupons = q.order_by(Coupon.coupon_id.desc()).all()
data = {
'valid_coupons': valid_coupons,
'invalid_coupons': invalid_coupons,
'used_coupons': used_coupons,
'valid_count': valid_count,
'invalid_count': invalid_count,
'used_count': used_count
}
return data
def index():
"""pc站 - 个人中心"""
if not check_login():
session['weixin_login_url'] = request.url
return redirect(url_for('api.weixin.login_qrcode'))
uid = get_uid()
data = MeStaticMethodsService.detail(uid)
#用户信息
user = User.query.get(uid)
# 收藏商品
q = db.session.query(Like.like_id).\
filter(Like.uid == uid).\
filter(Like.like_type == 2).\
filter(Like.ttype == 1)
collect_count = get_count(q)
wtf_form = ProfileForm()
data['user'] = user
data['collect_count'] = collect_count
data['wtf_form'] = wtf_form
return render_template('pc/me/index.html.j2', **data)
def get_rating_count(self, rating):
"""获取评价总数
:param int rating 1:差评 2:中评 3:好评
"""
if rating in (1, 2, 3):
q = self.cs.query.filter(Comment.rating == rating)
return get_count(q)
return 0
def order_comments(uid, params, is_pagination=False):
""" 订单评价中心 """
p = toint(params.get('p', '1'))
ps = toint(params.get('ps', '10'))
is_pending = toint(params.get('is_pending', '0'))
completed = db.session.query(Order.order_id).\
filter(Order.uid == uid).\
filter(Order.is_remove == 0).\
filter(Order.order_status == 2).\
filter(Order.pay_status == 2).\
filter(Order.deliver_status == 2).all()
completed = [order.order_id for order in completed]
q = db.session.query(
OrderGoods.og_id, OrderGoods.goods_id, OrderGoods.goods_name,
OrderGoods.goods_img, OrderGoods.goods_desc,
OrderGoods.goods_price, OrderGoods.comment_id).\
filter(OrderGoods.order_id.in_(completed))
pending_count = get_count(q.filter(OrderGoods.comment_id == 0))
unpending_count = get_count(q.filter(OrderGoods.comment_id > 0))
if is_pending == 1:
q = q.filter(OrderGoods.comment_id == 0)
else:
q = q.filter(OrderGoods.comment_id > 0)
comments = None
pagination = None
if is_pagination:
comments = q.order_by(OrderGoods.og_id.desc()).offset(
(p-1)*ps).limit(ps).all()
pagination = Pagination(None, p, ps, q.count(), None)
else:
comments = q.order_by(OrderGoods.og_id.desc()).all()
data = {'is_pending': is_pending, 'pending_count': pending_count,
'unpending_count': unpending_count, 'comments': comments,
'pagination': pagination}
return data
def check(self):
"""检查"""
# 检查 - 支付订单ID列表数据
self.order_id_list = [toint(order_id)
for order_id in self.order_id_list]
if len(self.order_id_list) <= 0:
self.msg = _(u'支付订单ID列表不能为空')
return False
# 格式化支付订单ID列表数据
self.order_id_list.sort()
self.order_id_json = json.dumps(self.order_id_list)
# 支付订单列表
q = db.session.query(Order.order_id,
Order.order_sn,
Order.pay_amount,
Order.order_type,
Order.uid).\
filter(Order.uid == self.uid).\
filter(Order.pay_status == 1).\
filter(Order.order_id.in_(self.order_id_list))
# 检查 - 支付订单列表是否有非法的订单
if len(self.order_id_list) != get_count(q):
self.msg = _(u'创建支付失败')
return False
# 支付订单列表
self.pay_order_list = q.all()
# 支付订单列表对应的交易
self.tran = OrderTran.query.filter(OrderTran.uid == self.uid).\
filter(OrderTran.order_id_list == self.order_id_json).first()
if self.tran:
# 检查交易是否已经支付
if self.tran.pay_status == 2:
self.msg = _(u'该订单已经支付过了')
return False
# 检查 - 支付订单列表
if not self.check_order_list():
return False
return True
# 检查 - 支付订单列表
if not self.check_order_list():
return False
return True
def get_image_rating_count(self):
"""获取有图评价总数"""
q = self.cs.query.filter(Comment.img_data != '[]')
return get_count(q)
def pagination(self):
"""分页对象"""
q = self._query()
return Pagination(None, self.page, self.page_size, get_count(q), None)
def dashboard():
"""dashboard页"""
g.page_title = _(u'首页')
admin_uid = session.get('admin_uid', None)
if not admin_uid:
return_url = request.args.get('return_url', '/admin/dashboard')
return redirect(url_for('admin.auth.login', return_url=return_url))
# 今天0点0时0分时间戳
today_time_stamp = some_day_timestamp(current_timestamp(), 0)
# 用户数
q = db.session.query(User.uid)
sum_user = get_count(q)
q = db.session.query(User.uid).\
filter(User.add_time >= today_time_stamp)
day_user = get_count(q)
# 订单数
q = db.session.query(Order.order_id).\
filter(Order.order_type == 1)
sum_order = get_count(q)
q = q.filter(Order.add_time >= today_time_stamp)
day_order = get_count(q)
# 订单交易总额
_sum_order_amount = db.session.query(
func.sum(Order.order_amount).label('sum_order_amount')).\
filter(Order.order_type == 1).\
filter(Order.pay_status == 2).first()
sum_order_amount = _sum_order_amount.sum_order_amount if _sum_order_amount else Decimal(
'0.00')
_day_order_amount = db.session.query(
func.sum(Order.order_amount).label('day_order_amount')).\
filter(Order.order_type == 1).\
filter(Order.pay_status == 2).\
filter(Order.add_time >= today_time_stamp).first()
day_order_amount = _day_order_amount.day_order_amount if _day_order_amount else Decimal(
'0.00')
# 售后数
q = db.session.query(Aftersales.order_id)
sum_aftersales = get_count(q)
q = db.session.query(Aftersales.aftersales_id).\
filter(Aftersales.add_time >= today_time_stamp)
day_aftersales = get_count(q)
# 会员充值(连表查，3条数据)
funds_orders = []
# funds_orders = db.session.query(Order.order_id, Order.order_amount, Order.add_time,
# User.nickname, User.avatar).\
# filter(Order.uid == User.uid).\
# filter(Order.order_type == 2).\
# filter(Order.pay_status == 2).\
# order_by(Order.order_id.desc()).limit(4).all()
fund_orders_amount = 0
# for funds_order in funds_orders:
# fund_orders_amount += funds_order.order_amount
# 最近订单
goods_orders = db.session.query(
Order.order_id, Order.order_sn,
Order.order_amount, Order.order_status,
Order.pay_status, Order.shipping_status,
Order.deliver_status, Order.aftersale_status,
Order.add_time, User.nickname,
Order.pay_method, User.avatar).\
filter(Order.uid == User.uid).\
filter(Order.order_type == 1).\
filter(Order.pay_status == 2).\
order_by(Order.order_id.desc()).limit(10).all()
orders = []
goods_orders_amount = 0
for order in goods_orders:
goods_orders_amount += order.order_amount
status_text, action_code = OrderStaticMethodsService.\
order_status_text_and_action_code(order)
order = kt_to_dict(order)
order['status_text'] = status_text
orders.append(order)
# 最近评论
comments = db.session.query(
Comment.nickname, Comment.avatar,
Comment.add_time, Comment.rating,
Comment.content, Comment.img_data).\
order_by(Comment.comment_id.desc()).limit(3).all()
# 今天限制时间
start = some_day_timestamp(current_timestamp(), 0)
end = some_day_timestamp(current_timestamp(), 1)
today_date_rang = timestamp2str(
start, 'YYYY-MM-DD') + ' - ' + timestamp2str(end, 'YYYY-MM-DD')
data = {
'sum_user': sum_user,
'day_user': day_user,
'sum_order': sum_order,
'day_order': day_order,
'sum_order_amount': sum_order_amount,
'day_order_amount': day_order_amount,
'sum_aftersales': sum_aftersales,
'day_aftersales': day_aftersales,
'fund_orders_amount': fund_orders_amount,
'funds_orders': funds_orders,
'orders': orders,
'orders_amount': goods_orders_amount,
'comments': comments,
'today_date_rang': today_date_rang
}
return render_template('admin/dashboard/index.html.j2', **data)
def detail(uid):
nickname = get_nickname()
avatar = get_avatar()
current_time = current_timestamp()
# 优惠券
q = Coupon.query.\
filter(Coupon.uid == uid).\
filter(Coupon.is_valid == 1).\
filter(Coupon.begin_time <= current_time).\
filter(Coupon.end_time >= current_time)
coupon_count = get_count(q)
# 未付款订单
q = db.session.query(Order.order_id).\
filter(Order.uid == uid).\
filter(Order.order_type == 1).\
filter(Order.is_remove == 0).\
filter(Order.order_status == 1).\
filter(Order.pay_status == 1)
unpaid_count = get_count(q)
# 待收货订单
q = db.session.query(Order.order_id).\
filter(Order.uid == uid).\
filter(Order.order_type == 1).\
filter(Order.is_remove == 0).\
filter(Order.order_status == 1).\
filter(Order.pay_status == 2).\
filter(Order.deliver_status.in_([0,1]))
undeliver_count = get_count(q)
completed = db.session.query(Order.order_id).\
filter(Order.uid == uid).\
filter(Order.order_type == 1).\
filter(Order.is_remove == 0).\
filter(Order.order_status == 2).\
filter(Order.pay_status == 2).\
filter(Order.deliver_status == 2).all()
completed = [order.order_id for order in completed]
# 待评价
q = db.session.query(OrderGoods.og_id).\
filter(OrderGoods.order_id.in_(completed)).\
filter(OrderGoods.comment_id == 0)
uncomment_count = get_count(q)
# 退款售后
q = db.session.query(Aftersales.aftersales_id).\
filter(Aftersales.status.in_([1,2])).\
filter(Aftersales.uid == uid)
aftersales_count = get_count(q)
funds = Funds.query.filter(Funds.uid == uid).first()
data = {
'uid': uid,
'nickname': nickname,
'avatar': avatar,
'coupon_count': coupon_count,
'unpaid_count': unpaid_count,
'undeliver_count': undeliver_count,
'uncomment_count': uncomment_count,
'aftersales_count': aftersales_count,
'funds': funds
}
return data
def before_request():
endpoint = request.endpoint
if endpoint is None:
return
# 管理后台权限判断
if (endpoint.find('admin.') == 0 and
(endpoint not in ('admin.index.root', 'admin.auth.login'))):
admin_uid = session.get('admin_uid', 0)
if admin_uid <= 0:
return abort(403)
# 移动设备 Android|iPhone|iPod|iPad
is_mobile = is_mobile_device(request.headers.get('User-Agent', ''))
if is_mobile and endpoint.find('pc.') == 0:
return redirect(u'/mobile' + request.full_path)
elif not is_mobile and endpoint.find('mobile.') == 0:
full_path = request.full_path
full_path = full_path.replace('/mobile', '')
return redirect(full_path)
# pc
if endpoint.find('pc.') == 0:
from app.models.item import GoodsCategories
# nav推荐分类列表
categories = db.session.query(GoodsCategories.cat_id, GoodsCategories.cat_name).\
filter(GoodsCategories.is_recommend == 1).\
order_by(GoodsCategories.sorting.desc()).\
order_by(GoodsCategories.cat_id.desc()).all()
g.pc_nav_categories = categories
if (endpoint.find('pc.') == 0) or (endpoint.find('mobile.') == 0):
from app.services.api.user import UserStaticMethodsService
uid = session.get('uid', 0)
g.unread_count = 0
if uid:
# 未读消息数
g.unread_count = UserStaticMethodsService.unread_count(uid)
# PC待评价数
if (endpoint.find('pc.order')
== 0) or (endpoint.find('pc.aftersales')
== 0) or (endpoint.find('pc.me')
== 0) or (endpoint.find('pc.wallet') == 0):
from app.models.order import (Order, OrderGoods)
from app.helpers import get_count
uid = session.get('uid', 0)
g.uncomment_count = 0
if uid:
completed = db.session.query(Order.order_id).\
filter(Order.uid == uid).\
filter(Order.is_remove == 0).\
filter(Order.order_status == 2).\
filter(Order.pay_status == 2).\
filter(Order.deliver_status == 2).all()
completed = [order.order_id for order in completed]
q = db.session.query(OrderGoods.og_id).\
filter(OrderGoods.order_id.in_(completed)).\
filter(OrderGoods.comment_id == 0)
g.uncomment_count = get_count(q)