def post(self):
'''
注册
'''
try:
args = json.loads(self.request.body.decode())
code = args.get('code')
phone = args.get('phone')
passwd = args.get('passwd')
name = args.get('name')
address = args.get('address')
st = args.get('st')
ed = args.get('ed')
manager = args.get('manager', '')
assert (code and phone)
assert (utils.is_valid_time(st))
assert (utils.is_valid_time(ed))
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
store = ctrl.store.get_store_ctl(phone)
if store:
raise utils.APIError(errcode=50001, errmsg='请勿重复注册')
try:
data = {
'ktype': 20,
'name': name,
'address': address,
'tel': phone,
'is_test': 0,
'is_own': 0,
'manager': manager
}
ktv = utils.common_post_api('/kinfo', data)
store_id = ktv['store_id']
store = ctrl.store.add_store_ctl({
'store_id':
store_id,
'st':
st,
'ed':
ed,
'name':
name,
'phone':
phone,
'passwd':
hashlib.md5(passwd.encode()).hexdigest()
})
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=50001, errmsg='注册失败, 稍后再试')
FILTER = ('store_id', 'phone', 'update_time', 'st', 'ed', 'name')
store = utils.dict_filter(store, FILTER)
self.send_json(store)
def get(self):
'''
登录
'''
try:
phone = self.get_argument('phone')
passwd = self.get_argument('passwd')
assert (phone and passwd)
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
try:
store = ctrl.store.get_store_ctl(phone)
assert (store)
assert (store['passwd'] == hashlib.md5(
passwd.encode()).hexdigest())
token = self._login(store)
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=50001, errmsg='登录失败，请检查您的账号或密码')
data = {}
FILTER = ('store_id', 'phone', 'update_time', 'st', 'ed', 'name')
data['store'] = utils.dict_filter(store, FILTER)
data['token'] = token
self.send_json(data)
def get_query_pack_sales(self,
store_id,
start_day,
end_day,
order_by,
page=1,
page_size=10):
try:
start_day = arrow.get(start_day, 'YYYY-MM-DD')
end_day = arrow.get(end_day, 'YYYY-MM-DD')
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001, errmsg='日期格式不合法')
if start_day > end_day:
raise utils.APIError(errcode=10001, errmsg='起始日期不能大于结束日期')
store = ctrl.store.get_store_ctl(self.current_user['phone'])
start_time, end_time = utils.get_range_start_end_time(
start_day, end_day, store['st'], store['ed'])
sales, count = ctrl.trade.get_day_pack_sales_ctl(
store_id, start_time, end_time, order_by, page, page_size)
total_page = (count + page_size - 1) // page_size
self.send_json({
'list': sales,
'page': page,
'total_page': total_page,
'total_count': count
})
def post(self):
'''
重置密码
'''
try:
args = json.loads(self.request.body.decode())
phone = args['phone']
passwd = args['passwd']
code = args['code']
assert (phone and passwd and code)
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
store = ctrl.store.get_store_ctl(phone)
if not store:
raise utils.APIError(errcode=50001, errmsg='该门店不存在')
is_valid = ctrl.store.check_verify_code_ctl(phone, code)
if not is_valid:
raise utils.APIError(errcode=50001, errmsg='验证码无效')
ctrl.store.update_store_ctl(
phone, dict(passwd=hashlib.md5(passwd.encode()).hexdigest()))
self.send_json()
def by_pack(self, store_id, rt_id, st, pack_id):
pack = self.ctrl.pack.get_pack_ctl(pack_id)
if not pack:
raise utils.APIError(errcode=50001, errmsg='该套餐不存在')
if not utils.is_valid_pack(pack):
raise utils.APIError(errcode=50001, errmsg='该套餐已下架')
pack_st = pack['st']
pack_ed = pack['ed']
price = pack['price']
hour = pack['hour']
name = pack['name']
pack_id = pack['id']
if not utils.is_hour_in_range(st[-5:], pack_st, pack_ed):
raise utils.APIError(errcode=50001, errmsg='开台时间需在套餐的有效时间之内')
minute = hour * 60
if len(st) > 6:
ed = utils.future_time_by_hour(st, hour, 'YYYY.MM.DD HH:mm')
else:
ed = utils.future_time_by_hour(st, hour)
bill = {
'pack_id': pack_id,
'name': name,
'st': st,
'ed': ed,
'minute': minute,
'price': price
}
return bill
async def export(self, ktv_id):
try:
channel = self.get_argument('channel', 'all')
tp = self.get_argument('tp', 'normal')
type = self.get_argument('type', '')
start_time = self.get_argument('start_time', '')
end_time = self.get_argument('end_time', '')
income_id = self.get_argument('income_id', '0')
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
channel = None if channel == 'all' else ORDER_CHANNEL[channel]
tp = None if tp == 'all' else ORDER_TP[tp]
income_id = int(income_id) if income_id else 0
data = []
if not type: # time
if not start_time and not end_time:# 今日营收
ktv = await ctrl.pay.get_ktv_ctl(ktv_id)
t_time = ctrl.mch.get_today_income_time_ctl(ktv)
start_time = t_time['start_time']
end_time = t_time['end_time']
orders = ctrl.mch.get_orders_ctl(ktv_id=ktv_id, channel=channel, tp=tp, start_time=start_time, end_time=end_time)
else: # income
if income_id == -1:# 昨日营收
orders = ctrl.mch.get_orders_ctl(ktv_id=ktv_id, channel=channel, tp=tp, income_id=income_id)
else:
orders = ctrl.mch.get_orders_ctl(ktv_id=ktv_id, channel=channel, tp=tp, income_id=income_id)
if not orders:
raise utils.APIError(errcode=1001, errmsg='无数据')
if channel == ORDER_CHANNEL['wx']:
name = '微信'
elif channel == ORDER_CHANNEL['ali']:
name = '支付宝'
elif channel == ORDER_CHANNEL['pos']:
name = 'pos'
else:
name = '全部'
sheet_dict = {
'sheetname': '%s进出账流水' % name,
'titles': ['商户订单号', '订单费用(元)', '手续费用(元)', '订单创建时间', '支付类型', '卡号', '终端号']
}
for order in orders:
sheet_dict.setdefault('data', []).append([order['order_id'], self._money_format(order['fee']),
self._money_format(order['rate']), order['finish_time'],
order['channel'], order['card_no'], order['term_id']])
data.append(sheet_dict)
if start_time and end_time:
filename = 'static/data/进出账流水_%s~%s.xlsx' % (start_time, end_time)
else:
filename = 'static/data/进出账流水_%s.xlsx' % (str(income_id))
filename_with_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), filename)
utils.export_xlsx(data=data, export_filename=filename_with_path)
self.set_header('Access-Control-Allow-Origin', '*')
self.send_json(data={'url': '/' + filename})
def wrap(*args, **kw):
self = args[0]
login = int(self.current_user['login'])
if not login:
raise utils.APIError(errcode=40001)
if roles and self.current_user['role_code'] not in roles:
raise utils.APIError(errcode=40003)
return func(*args, **kw)
def check_room_valid(self, store_id, rt_id, room_id):
room = self.ctrl.room.get_room_ctl(room_id)
if not room:
raise utils.APIError(errcode=50001, errmsg='包房不存在')
if room['room_type'] not in [ROOM_TYPE['free']]:
raise utils.APIError(errcode=50001, errmsg='包房被占用')
return room
def check_room_valid(self, store_id, rt_id, room_id):
room = self.ctrl.room.get_room_ctl(room_id)
if not room:
raise utils.APIError(errcode=50001, errmsg='包房无效')
if room['room_type'] not in [ROOM_TYPE['using'], ROOM_TYPE['timeout']]:
raise utils.APIError(errcode=50001, errmsg='未开台')
return room
def cancel_bill(self, store_id, order_no, bill_id):
bill = self.get_bill(store_id, bill_id)
if not bill:
raise utils.APIError(errcode=50001, errmsg='账单不存在')
if bill['pay_state'] == BILL_PAY_STATE['finish']:
raise utils.APIError(errcode=50001, errmsg='账单已支付,不能取消')
self.dummy_update_bill_ctl(store_id, order_no, bill_id,
{'pay_state': BILL_PAY_STATE['cancel']})
def check_pack(self, pack_id):
pack = self.ctrl.pack.get_pack_ctl(pack_id)
if not pack:
raise utils.APIError(errcode=50001, errmsg='该套餐不存在')
if not utils.is_valid_pack(pack):
raise utils.APIError(errcode=50001, errmsg='该套餐已下架')
return pack
async def get(self, timestamp, sign):
if not utils.check_sign_ex(timestamp, sign):
raise utils.APIError(errcode=10001, errmsg='验签错误')
is_guest = '1' if timestamp == '1111' else '0'
self.set_secure_cookie('is_guest', is_guest)
order_id = self.get_argument('order_id', None)
if not order_id:
raise utils.APIError(errcode=10001, errmsg='订单号不得为空')
res = ctrl.mch.get_order_ex_ctl(order_id)
self.send_json(res)
def get(self):
try:
username = self.get_argument('username')
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=100)
try:
orders = ctrl.web.get_user_orders_ctl(username)
self.send_json(dict(orders=orders))
except Exception as e:
logging.error(e)
raise utils.APIError(500)
def put(self):
try:
username = self.get_argument('username')
password = self.get_argument('password')
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=100)
user = ctrl.web.get_user_info_ctl(username)
if not user:
raise utils.APIError(errcode=404)
ctrl.web.update_user_ctl(username, ts=0, email='', password=password)
user = ctrl.web.get_user_info_ctl(username)
self.send_json(user)
def post(self):
try:
username = self.get_argument('username')
password = self.get_argument('password')
except Exception as e:
logging.error(e)
raise utils.APIError(100)
user = ctrl.web.get_user_info_ctl(username)
if password != user.get('password', ''):
raise utils.APIError(errcode=401)
is_payed_user = self._is_payed_user(username)
user.update({'is_payed_user': is_payed_user})
self.send_json(user)
def post(self):
try:
username = int(self.get_argument('username'))
password = self.get_argument('password')
except Exception as e:
raise utils.APIError(errcode=10001)
user = ctrl.pay.get_ktv_fin_account(username)
msg = dict(type=0)
if not user:
pass
elif password == user['password_org'] and not user['password']:
self._login(username)
self.set_secure_cookie('is_login',
str(user['ktv_id']),
expires_days=1)
msg.update({'type': 1})
elif password == user['password']:
self._login(username)
self.set_secure_cookie('is_login',
str(user['ktv_id']),
expires_days=1)
msg.update({'type': 2, 'user': user})
self.send_json(msg)
async def post(self):
is_login = self.get_secure_cookie('is_login')
if not is_login:
return
try:
bank_account = self.get_argument('bank_account')
bank_name = self.get_argument('bank_name')
bank_branch = self.get_argument('bank_branch')
account_name = self.get_argument('account_name')
bank_phone = self.get_argument('bank_phone')
is_extra = int(self.get_argument('is_extra', 0))
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
ktv_id = int(is_login.decode())
response = await ctrl.erp.update_bank_info_ctl(
ktv_id, {
'bank_account': bank_account,
'bank_name': bank_name,
'bank_branch': bank_branch,
'account_name': account_name,
'bank_phone': bank_phone,
'is_extra': is_extra
})
self.send_json(data=response)
async def render_flow(self, ktv_id):
try:
page = int(self.get_argument('page', 1))
except:
raise utils.APIError(errcode=10001)
page_size = 20
start_date = '2016-01-01'
end_date = '2020-01-01'
order_info = await ctrl.erp.get_pay_orders_ctl(ktv_id,
pay_type='deposit',
start_date=start_date,
end_date=end_date,
page=page,
page_size=page_size)
orders = order_info['list']
total = order_info['total']
page_total = (total + page_size - 1) // page_size
self.render('flow.tpl',
top_cate='withdraw',
action='flow',
ktv_id=ktv_id,
orders=orders,
page=page,
page_size=page_size,
page_total=page_total)
def checkout_order(self, store_id, order_no, money, real_money, pay_md,
describe):
order = self.check_order_ctl(store_id, order_no)
room_id = order['room_id']
order_id = order['id']
if order['pay_type'] == PAY_TYPE['current']:
raise utils.APIError(errcode=50001, errmsg='落单后结才需要结账')
# self.ctrl.open.update_room_ctl(store_id, room_id, ROOM_TYPE['clean'])
self.update_order_ctl(
store_id,
order_no,
{
'describe': describe,
'money': money + order.get('prepay'),
'real_money': money + order.get('prepay'), # real_money
'finish_time': when.now().strftime('%Y-%m-%d %H:%M:%S')
})
# 去掉另一个包房的订单的key
using_order_key = self.get_using_order_key_ctl(store_id, room_id)
self.ctrl.rs.delete(using_order_key)
# 现金的直接支付成功
if pay_md in (PAY_MD['cash'], PAY_MD['pos']):
self.after_checkout_order_ctl(store_id, order_no, pay_md)
async def pay_query(self, order_id, loop=1):
logging.info("\n\nloop=%s, order_id=%s"%(loop, order_id))
order = ctrl.web.get_by_order(order_id)
if not order:
raise utils.APIError(errcode=10001)
try:
params = {
"op": "query",
"ktvid": order['ktv_id'], # 专用于分享订单的打赏
"paytype": 'WX', # ALI or WX
"data": json.dumps({
"paraOutTradeNo": order['wx_pay_id'],
}),
}
url = 'http://pay.ktvsky.com/wx'
http_client = utils.get_async_client()
request = httpclient.HTTPRequest(url_concat(url, params), method='POST', body='',
headers={'Connection': 'keep-alive'}, connect_timeout=10, request_timeout=10)
res = await utils.fetch(http_client, request)
res = json.loads(bytes(res.body).decode())
logging.info(res)
if utils.is_success_pay('wx', res):
ctrl.web.update_namegame_order(data=dict(order_id=order_id, state=2, wx_pay_id=res['transaction_id']))
res['is_pay'] = 1
return res
def post(self):
'''
添加包房类型
'''
try:
args = json.loads(self.request.body.decode())
names = args['names']
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
data = {'list': []}
if not names:
return self.send_json(data)
room_types = ctrl.room.add_room_types_ctl(
self.current_user['store_id'], names)
if not room_types:
return self.send_json(data)
FILTER = ({'id': 'rt_id'}, 'store_id', 'name', 'update_time')
data['list'] = [
utils.dict_filter(room_type, FILTER) for room_type in room_types
]
self.send_json(data)
def post(self):
'''
添加计费设置
'''
try:
rt_id = int(self.get_argument('rt_id'))
args = json.loads(self.request.body.decode())
for arg in args:
assert (arg.get('day') or arg.get('holiday'))
for item in arg['list']:
assert (utils.is_valid_time(item['st']))
assert (utils.is_valid_time(item['ed']))
assert (int(item['fee']) > 0)
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
room_fees = ctrl.room.add_room_fees_ctl(self.current_user['store_id'],
rt_id, args)
data = {'list': []}
if not room_fees:
return self.send_json(data)
FILTER = ({
'id': 'fee_id'
}, 'store_id', 'rt_id', 'st', 'ed', 'fee', 'day_or_holiday',
'update_time')
data['list'] = [utils.dict_filter(fee, FILTER) for fee in room_fees]
self.send_json(data)
def post(self):
'''
往某个包房类型下添加包房
'''
try:
args = json.loads(self.request.body.decode())
rooms = {}
for arg in args:
rt_id = arg['rt_id']
rooms[rt_id] = []
for ip_name in arg['list']:
assert (ip_name['name'])
rooms[rt_id].append(ip_name)
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
data = {'list': []}
rooms = ctrl.room.add_rooms_ctl(self.current_user['store_id'], rooms)
if not rooms:
return self.send_json(data)
FILTER = ({
'id': 'room_id'
}, 'store_id', 'rt_id', 'name', 'mac', 'ip', 'room_type', 'describe',
'update_time')
data['list'] = [utils.dict_filter(room, FILTER) for room in rooms]
self.send_json(data)
def get(self):
'''
获取分类下的酒水列表
'''
try:
cate_id = int(self.get_argument('cate_id'))
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
FILTER = ({
'id': 'product_id'
}, 'store_id', 'cate_id', 'name', 'pic', 'price', 'unit', 'spec',
'stock', 'discount', 'state', 'order', 'update_time')
data = {'list': []}
products = ctrl.cate.get_cate_products_ctl(
self.current_user['store_id'], cate_id)
if not products:
return self.send_json(data)
data['list'] = [
utils.dict_filter(product, FILTER) for product in products
]
self.send_json(data)
def put(self):
'''
修改某个包房类型
'''
try:
args = json.loads(self.request.body.decode())
rt_id = int(args['rt_id'])
name = args.get('name', '')
pic = args.get('pic', '')
min_man = int(args.get('min_man', 0))
max_man = int(args.get('max_man', 0))
assert (name or pic or min_man or max_man)
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
data = {'name': name, 'pic': pic}
if 'min_man' in args:
data.update({'min_man': min_man})
if 'max_man' in args:
data.update({'max_man': max_man})
ctrl.room.update_room_type_ctl(self.current_user['store_id'], rt_id,
data)
self.send_json()
def get(self):
'''
获取某房型下的所有的酒水套餐
'''
try:
rt_id = int(self.get_argument('rt_id'))
is_valid = int(self.get_argument('is_valid', 0))
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
data = {'list': []}
FILTER = ({
'id': 'pack_id'
}, 'store_id', 'name', 'start_date', 'end_date', 'st', 'ed', 'price',
'day', 'hour', 'state', 'update_time')
packs = ctrl.room.get_room_packs_ctl(self.current_user['store_id'],
rt_id)
if not packs:
return self.send_json(data)
if is_valid:
_packs = [pack for pack in packs if utils.is_valid_pack(pack)]
packs = _packs
packs = [utils.dict_filter(pack, FILTER) for pack in packs]
data['list'] = packs
self.send_json(data)
def by_time(self, store_id, phone, rt_id, room_id, st, ed):
store = self.ctrl.store.get_store_ctl(phone)
store_st = store['st']
store_ed = store['ed']
# 兼容续时跨天
day = datetime.datetime.now().date()
order = self.ctrl.order.get_using_order_ctl(store_id, room_id)
if order:
order_ed = order['ed']
day = datetime.datetime.strptime(order_ed[:-6], '%Y.%m.%d')
if order_ed[-5:] < store_st:
day = day - datetime.timedelta(days=1)
day = day.date()
holiday_fees = self.ctrl.room.get_holiday_room_fees_ctl(store_id,
rt_id,
day=day)
if holiday_fees:
fees = holiday_fees
else:
fees = self.ctrl.room.get_week_room_fees_ctl(store_id,
rt_id,
day=day)
sorted_fees = sorted(fees, key=lambda f: f['st'])
if not utils.is_valid_fees(sorted_fees, store_st, store_ed):
raise utils.APIError(errcode=50001, errmsg='计费方式设置和营业时间不匹配')
bills = utils.get_time_bills(sorted_fees, st, ed)
return bills
def check_order(self, store_id, order_no):
order = self.get_order_ctl(store_id, order_no)
if not order or order['state'] not in [ORDER_STATE['using']]:
raise utils.APIError(errcode=50001, errmsg='未开台')
return order
def put(self):
'''
修改某条计费设置
'''
try:
args = json.loads(self.request.body.decode())
fee_id = int(args['fee_id'])
st = args.get('st', '')
ed = args.get('ed', '')
fee = int(args.get('fee', 0))
assert (utils.is_valid_time(st))
assert (utils.is_valid_time(ed))
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
data = {'st': st, 'ed': ed}
if 'fee' in args:
data.update({'fee': fee})
ctrl.room.update_room_fee_ctl(fee_id, self.current_user['store_id'],
data)
self.send_json()
def get(self):
'''
获取某房型下周几/假期内的所有计费设置
'''
try:
rt_id = int(self.get_argument('rt_id'))
md = self.get_argument('md', 'day')
day_or_holiday = self.get_argument('day_or_holiday', '')
assert (md in ('day', 'holiday'))
except Exception as e:
logging.error(e)
raise utils.APIError(errcode=10001)
data = {'list': []}
room_fees = ctrl.room.get_room_fees_ctl(self.current_user['store_id'],
rt_id, day_or_holiday, md)
if not room_fees:
return self.send_json(data)
FILTER = ({
'id': 'fee_id'
}, 'store_id', 'rt_id', 'st', 'ed', 'fee', 'day_or_holiday',
'update_time')
room_fees = [utils.dict_filter(fee, FILTER) for fee in room_fees]
data['list'] = room_fees
self.send_json(data)
