def delete_useraddress(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
UAid = data.get('UAid')
except:
return PARAMS_ERROR
this_address = get_model_return_dict(self.smycenter.get_other_address(request.user.id, UAid))
if not this_address:
return NOT_FOUND_ADDRESS
updatde_address = {}
updatde_address['UAstatus'] = False
result = self.smycenter.delete_useraddress(request.user.id, UAid, updatde_address)
if result:
if this_address['UAdefault']:
try:
one_address = get_model_return_dict(self.smycenter.get_one_address())
if one_address:
updatde_address = {}
updatde_address['UAdefault'] = True
self.smycenter.set_default(one_address['UAid'], updatde_address)
except:
return SYSTEM_ERROR
response = import_status("delete_address_success", "OK")
return response
else:
return NOT_FOUND_ADDRESS
def add_shoppingcart(self):
if is_tourist():
return TOKEN_ERROR
params = ['prid', 'psid', 'colorid', 'colorname', 'sizeid', 'sizename', 'number']
data = request.json
for param in params:
if param not in data:
response = {}
response['message'] = u"参数缺失"
response['paramname'] = param
response['status'] = 405
return response
prid = data.get('prid')
psid = data.get('psid')
sku_stock = get_model_return_dict(self.sgoods.get_sku_stock(psid))['PSstock']
is_exist = get_model_return_dict(self.sgoods.check_is_exist_sku(request.user.id, prid, psid))
if is_exist:
new_number = is_exist['number'] + int(data.get('number'))
if sku_stock < new_number:
return STOCK_NOT_ENOUGH
update = {
"number": new_number
}
result = self.sgoods.update_user_sku(request.user.id, psid, update)
if not result:
return SYSTEM_ERROR
else:
if int(data.get('number')) > sku_stock:
return STOCK_NOT_ENOUGH
result = self.sgoods.add_shoppingcart(request.user.id, data)
if not result:
return SYSTEM_ERROR
response = import_status("add_shoppingcart_success", "OK")
return response
def check_qrcode(self):
try:
data = request.json
id = str(data.get('qrid'))
except:
return PARAMS_ERROR
result = get_model_return_dict(self.suser.get_arcode_details(
id)) if self.suser.get_arcode_details(id) else None
if not result:
return NOT_FOUND_QRCODE
user_info = get_model_return_dict(self.smycenter.get_user_basicinfo(result['USid'])) if self.smycenter \
.get_user_basicinfo(result['USid']) else None
if not user_info:
return NOT_FOUND_USER
if user_info['USbail'] < float(self.conf.get('account', 'bail')):
return NO_BAIL
else:
response = {}
date = result['QRovertime']
number = result['QRnumber']
timenow = datetime.strftime(datetime.now(), format_for_db)
if date < timenow:
response['message'] = u"二维码已过期"
response['success'] = False
return response
if number < 1:
response['message'] = u"二维码次数已用完"
response['success'] = False
return response
from common.timeformat import get_web_time_str
result['QRovertime'] = get_web_time_str(result['QRovertime'])
response['status'] = 200
response['data'] = result
response['success'] = True
return response
def get_shoppingcart(self):
if not is_ordirnaryuser():
return TOKEN_ERROR
product_list = get_model_return_list(self.sgoods.get_shoppingcart_product(request.user.id))
for product in product_list:
product_info = get_model_return_dict(self.sgoods.get_product_details(product['PRid']))
product['PRpic'] = product_info['PRpic']
product['PRlogisticsfee'] = product_info['PRlogisticsfee']
product['PRprice'] = product_info['PRprice']
product['PRname'] = product_info['PRname']
product_status = self.sgoods.get_product_info(product['PRid'])
sku_list = get_model_return_list(self.sgoods.get_shoppingcart_sku(request.user.id, product['PRid']))
for sku in sku_list:
sku_stok = get_model_return_dict(self.sgoods.get_sku_stock(sku['PSid']))
if int(sku['number']) > int(sku_stok['PSstock']):
sku['SCstatus'] = 2
sku_status = self.sgoods.get_sku_status(sku['PSid'])
if not sku_status:
sku['SCstatus'] = 3
if not product_status:
sku['SCstatus'] = 4
product['skulist'] = sku_list
if len(product_list) != 0:
return_list = sorted(product_list, key=lambda product: product['skulist'][0]['SCcreatetime'], reverse=True)
else:
return_list = []
response = import_status("get_shoppingcart_success", "OK")
response['data'] = return_list
return response
def get_register_record(self):
if not is_admin():
return TOKEN_ERROR
try:
data = request.json
status = int(data.get('status'))
page_size = data.get('page_size')
page_num = data.get('page_num')
except:
return PARAMS_ERROR
list = get_model_return_list(self.suser.get_register_record(status))
if not list:
response = import_status("get_registerinfo_success", "OK")
response['data'] = []
return response
from common.timeformat import get_web_time_str
for record in list:
record['IRIcreatetime'] = get_web_time_str(record['IRIcreatetime'])
record['IRIpaytime'] = get_web_time_str(record['IRIpaytime'])
record['IRIproof'] = record['IRIproof'].split(',')
if record['IRIarea']:
area = get_model_return_dict(
self.smycenter.get_area_by_areaid(record['IRIarea']))
city = get_model_return_dict(
self.smycenter.get_city_by_cityid(area['cityid']))
province = get_model_return_dict(
self.smycenter.get_province_by_provinceid(
city['provinceid']))
record['address'] = province['provincename'] + city[
'cityname'] + area['areaname']
else:
city = get_model_return_dict(
self.smycenter.get_city_by_cityid(record['IRIcity']))
province = get_model_return_dict(
self.smycenter.get_province_by_provinceid(
city['provinceid']))
record['address'] = province['provincename'] + city['cityname']
mount = len(list)
page = mount / page_size
if page == 0 or page == 1 and mount % page_size == 0:
real_return_list = list[0:]
else:
if ((mount - (page_num - 1) * page_size) / page_size) >= 1 and \
(mount - (page_num * page_size)) > 0:
real_return_list = list[((page_num - 1) *
page_size):(page_num * page_size)]
else:
real_return_list = list[((page_num - 1) * page_size):]
response = import_status("get_registerinfo_success", "OK")
response['data'] = real_return_list
response['mount'] = mount
return response
def get_product_list(self):
args = request.args.to_dict()
try:
page_num = int(args.get("page_num"))
page_size = int(args.get("page_size"))
PRstatus = int(args.get("PRstatus"))
PRname = args.get("PRname")
PAid = str(args.get("PAid"))
PAtype = int(args.get("PAtype"))
print args
except:
return PARAMS_MISS
product_list = []
if PAid == '':
return PARAMS_ERROR
if PAid == str(0):
print 'PAid == str(0)'
product_list = get_model_return_list(self.sgoods.admin_get_product(PRstatus, PRname))
elif int(PAtype) == 1:
print 'int(PAtype) == 1'
paid_list = get_model_return_list(self.sgoods.get_childid(str(PAid)))
for paid in paid_list:
product_list = product_list + get_model_return_list(
self.sgoods.admin_get_product(PRstatus, PRname, paid['PAid']))
elif int(PAtype) == 2:
print 'int(PAtype) == 2'
product_list = product_list + get_model_return_list(
self.sgoods.admin_get_product(PRstatus, PRname, PAid))
print product_list
for product in product_list:
print 'for product in product_list'
print product['PAid']
category = get_model_return_dict(self.sgoods.get_category_byid(product['PAid']))
print category
product['firstpaid'] = category['Parentid']
parent_category = get_model_return_dict(self.sgoods.get_category_byid(category['Parentid']))
product['firstpaname'] = parent_category['PAname']
product['categoryname'] = category['PAname']
product['PRcreatetime'] = get_web_time_str(product['PRcreatetime'])
mount = len(product_list)
page = mount / page_size
if page == 0 or page == 1 and mount % page_size == 0:
return_list = product_list[0:]
else:
if ((mount - (page_num - 1) * page_size) / page_size) >= 1 and \
(mount - (page_num * page_size)) > 0:
return_list = product_list[((page_num - 1) * page_size):(page_num * page_size)]
else:
return_list = product_list[((page_num - 1) * page_size):]
response = import_status("get_product_list_success", "OK")
response["data"] = return_list
response['mount'] = mount
return response
def delete_category(self):
#删除商品分类
#self.json_param_miss("post")
if not is_admin():
return AUTHORITY_ERROR
try:
data = request.json
PAid = data.get('PAid')
except:
return PARAMS_ERROR
try:
get_PAstatus = get_model_return_dict(self.sgoods.get_product_category(PAid))
if not get_PAstatus:
return PRODUCE_CATEGORY_NOT_EXIST
# elif get_Parentid == 0:
# self.sgoods.add_product_category(PAid, PAname, PAtype)
if get_PAstatus['PAtype'] == 1:
categorylist = get_model_return_list(self.sgoods.get_first_product_category_status(PAid))
if categorylist:
return HAS_SECOND_CATEGORY
if get_PAstatus['PAtype'] == 2:
product_list = get_model_return_list(self.sgoods.get_product_by_paid(paid=PAid))
if product_list:
return PRODUCE_CATEGORY_HAS_PRODUCT
delete_category = {}
delete_category['PAstatus'] = False
self.sgoods.delete_category(PAid, delete_category)
except Exception as e:
print e.message
return PARAMS_MISS
response = import_status("delete_product_category_success", "OK")
return response
def update_category(self):
#更新商品分类
#self.json_param_miss("post")
if not is_admin():
return AUTHORITY_ERROR
try:
data = request.json
PAid = data.get('PAid')
PAname = data.get('PAname')
PAtype = data.get('PAtype')
Parentid = data.get('Parentid')
except:
return PARAMS_ERROR
try:
get_PAstatus = get_model_return_dict(self.sgoods.get_product_category(PAid))
if not get_PAstatus:
return PRODUCE_CATEGORY_NOT_EXIST
if PAtype != get_PAstatus['PAtype']:
return CAN_NOT_CHANGE_LEVEL
update_category = {}
update_category['PAname'] = PAname
update_category['PAtype'] = PAtype
update_category['Parentid'] = Parentid
print Parentid
self.sgoods.update_product_category(PAid, update_category)
except Exception as e :
print Exception
return PARAMS_MISS
response = import_status("update_product_category_success", "OK")
return response
def add_product_category(self):
#添加商品分类
#self.json_param_miss("post")
if not is_admin():
return AUTHORITY_ERROR
try:
data = request.json
print data, type(data)
PAid = data.get('PAid')
PAname = data.get('PAname')
PAtype = data.get('PAtype')
Parentid = data.get('Parentid')
except Exception as e:
print e.message
return PARAMS_ERROR
try:
get_PAstatus = get_model_return_dict(self.sgoods.get_product_category(PAid))
if get_PAstatus:
update_category = {}
update_category['PAname'] = PAname
update_category['Parentid'] = Parentid if Parentid else '0'
print Parentid
self.sgoods.update_product_category(PAid, update_category)
else:
PAid = str(uuid.uuid1())
Parentid = Parentid if Parentid else '0'
self.sgoods.add_product_category(PAid, PAname, PAtype, Parentid)
except Exception as e:
print e.message
return PARAMS_MISS
response = import_status("add_product_category_success", "OK")
#response["data"] = product_category
return response
def get_order_details(self):
if is_tourist():
return TOKEN_ERROR
data = request.json
if not data:
return PARAMS_MISS
try:
OIsn = int(data.get('OIsn'))
except:
return PARAMS_ERROR
detail = get_model_return_dict(self.sorder.get_order_details(OIsn))
from common.timeformat import get_web_time_str
detail['createtime'] = get_web_time_str(detail['OIcreatetime'])
product_list = get_model_return_list(
self.sorder.get_product_list(detail['OIid']))
for product in product_list:
product['PRnum'] = 0
sku_list = get_model_return_list(
self.sorder.get_sku_list_by_opiid(product['OPIid']))
for sku in sku_list:
product['PRnum'] = product['PRnum'] + sku['number']
product['skulist'] = sku_list
detail['product_list'] = product_list
response = import_status("get_orderdetails_success", "OK")
response['data'] = detail
return response
def add_comments(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
CMcontent = data['CMcontent']
except:
return PARAMS_ERROR
try:
import datetime
from common.timeformat import format_for_db
time_time = datetime.datetime.now()
CMcreatetime = datetime.datetime.strftime(time_time, format_for_db)
usid = request.user.id
user = get_model_return_dict(
self.smycenter.get_user_basicinfo(usid))
if not user:
return NOT_FOUND_USER
result = self.smycenter.add_comment(usid, user['USname'],
user['USphonenum'], CMcontent,
CMcreatetime)
if not result:
return SYSTEM_ERROR
response = import_status("add_comment_success", "OK")
return response
except Exception as e:
print e
return SYSTEM_ERROR
def get_commessage_details(self):
if is_tourist():
return TOKEN_ERROR
try:
args = request.args.to_dict()
messageid = args.get('messageid')
except Exception as e:
return PARAMS_ERROR
message = get_model_return_dict(
self.smessage.get_commessage_details(messageid))
from common.timeformat import get_web_time_str
message['CMdate'] = get_web_time_str(message['CMdate'])
data = import_status('get_commessage_details_success', 'OK')
data['data'] = message
if is_admin():
return data
else:
try:
note = self.smessage.get_isread(messageid, request.user.id)
if note:
return data
else:
self.smessage.insert_alreadyread(str(uuid.uuid4()),
messageid,
request.user.id)
return data
except Exception as e:
print 'repeat'
def check_openid(self):
if is_tourist():
return TOKEN_ERROR
state = request.args.to_dict().get('state')
usid = request.user.id
openid = get_model_return_dict(self.saccount.check_openid(usid))
if not openid['openid']:
response = {}
response['message'] = u'执行跳转'
response['status'] = 302
data = {}
update = {}
state2 = get_random_str(10)
update['state'] = state2
result = self.suser.update_user_by_uid(usid, update)
if not result:
return SYSTEM_ERROR
login = WeixinLogin(APP_ID, APP_SECRET)
state = state2 + "$$$" + state
data['url'] = login.authorize(SERVER + "/user/get_code",
'snsapi_base',
state=state)
response['data'] = data
return response
response = import_status("has_opid", "OK")
return response
def login(self):
print "hello"
json_data = request.json
if not json_data:
return PARAMS_ERROR
usphonenum = json_data.get('usphonenum')
uspassword = str(json_data.get('uspassword'))
if not usphonenum or not uspassword:
return PARAMS_MISS
print type(usphonenum)
user = get_model_return_dict(
self.suser.getuser_by_phonenum(usphonenum))
if user:
if not check_password_hash(user['USpassword'], uspassword):
return PHONE_OR_PASSWORD_WRONG
# 从注册申请表里查询信息
else:
info = get_model_return_dict(
self.suser.get_registerrecord_by_phonenum(usphonenum))
if info:
if int(info['IRIstatus']) == 1:
returnbody = {
"status": 405,
"status_code": 405006,
"message": u"您的账户正在审核中，请稍后再试!"
}
return returnbody
if int(info['IRIstatus']) == 3:
returnbody = {
"status":
405,
"status_code":
405006,
"message":
u"您的账户未审核通过，请联系客服微信:" +
self.conf.get('account', 'service')
}
return returnbody
return PHONE_OR_PASSWORD_WRONG
token = usid_to_token(user['USid'])
data = import_status('generic_token_success', "OK")
data['data'] = {
'token': token,
}
return data
def get_user_totalinfo(self):
if is_tourist():
return TOKEN_ERROR
result = get_model_return_dict(self.smycenter.get_user_totalinfo(request.user.id))
if result:
res = import_status("get_user_basicinfo_success", "OK")
res['data'] = result
return res
else:
return SYSTEM_ERROR
def get_inforcode(self):
print "get_inforcode"
try:
args = request.args.to_dict()
print args
phonenum = args.get('usphonenum')
except Exception as e:
return PARAMS_ERROR
if not phonenum:
return PARAMS_ERROR
code = ""
while len(code) < 6:
import random
item = random.randint(1, 9)
code = code + str(item)
# 获取当前时间，与上一次获取的时间进行比较，小于60秒的获取直接报错
import datetime
from common.timeformat import format_for_db
time_time = datetime.datetime.now()
time_str = datetime.datetime.strftime(time_time, format_for_db)
# 根据电话号码获取时间
time_up = get_model_return_dict(
self.smycenter.get_uptime_by_usphonenum(phonenum))
if time_up:
time_up_time = datetime.datetime.strptime(time_up['ICtime'],
format_for_db)
delta = time_time - time_up_time
if delta.seconds < 60:
return import_status("ERROR_MESSAGE_GET_CODE_FAST",
"BEILI_ERROR", "ERROR_CODE_GET_CODE_FAST")
new_inforcode = self.smycenter.add_inforcode(phonenum, code, time_str)
if not new_inforcode:
return SYSTEM_ERROR
from config.Inforcode import SignName, TemplateCode
from common.Inforsend import send_sms
params = '{\"code\":\"' + code + '\",\"product\":\"etech\"}'
__business_id = uuid.uuid1()
response_send_message = send_sms(__business_id, phonenum, SignName,
TemplateCode, params)
response_send_message = json.loads(response_send_message)
if response_send_message["Code"] == "OK":
status = 200
else:
status = 405
response_ok = {"usphone": phonenum}
response_ok["status"] = status
response_ok["messages"] = response_send_message["Message"]
return response_ok
def cancel_order(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
oisn = data.get('oisn')
except:
return PARAMS_ERROR
order = get_model_return_dict(self.sorder.get_order_details(oisn))
if not order:
print order
return SYSTEM_ERROR
if int(order['OIstatus']) != 1:
return CANNOT_CANCEL
session = db_session()
try:
session.query(OrderInfo).filter(OrderInfo.OIsn == oisn).update(
{"OIstatus": 5})
user = self.smycenter.get_user_basicinfo(request.user.id)
if not user:
raise dberror
user = get_model_return_dict(user)
session.query(User).filter(User.USid == request.user.id).update(
{"USmount": user['USmount'] + order['OImount']})
moneyrecord = MoneyRecord() # 插入收支记录表
moneyrecord.MRid = str(uuid.uuid4())
moneyrecord.MRtype = 8
moneyrecord.OIid = oisn
moneyrecord.MRamount = order['OImount']
moneyrecord.MRcreatetime = datetime.strftime(
datetime.now(), format_for_db)
moneyrecord.USid = request.user.id
session.add(moneyrecord)
session.commit()
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.close()
response = import_status("cancel_order_success", "OK")
return response
def get_authorization(self):
if is_tourist():
return TOKEN_ERROR
result = get_model_return_dict(self.suser.get_authorization(request.user.id)) if\
self.suser.get_authorization(request.user.id) else None
if result['authorization']:
response = import_status("get_authorization_success", "OK")
response['data'] = {"url": result['authorization']}
return response
else:
from common.make_pic import make_pic
user = get_model_return_dict(
self.smycenter.get_user_basicinfo(request.user.id))
if not user:
return SYSTEM_ERROR
url = make_pic(user['USname'], user['USwechat'], user['USagentid'],
user['idcardnum'])
update = {'authorization': url}
self.suser.update_user_by_uid(request.user.id, update)
response = import_status("get_authorization_success", "OK")
response['data'] = {"url": url}
return response
def get_product(self):
self.json_param_miss("get")
args = request.args.to_dict()
try:
PRid = args.get("PRid")
product = get_model_return_dict(self.sgoods.get_product(PRid))
from common.timeformat import get_web_time_str
product['PRcreatetime'] = get_web_time_str(product['PRcreatetime'])
except Exception as e:
print(e.message)
return PARAMS_MISS
response = import_status("get_product_success", "OK")
response["data"] = product
return response
def get_user_totalinfo(self):
if is_tourist():
return TOKEN_ERROR
result = get_model_return_dict(
self.smycenter.get_user_totalinfo(request.user.id))
if result:
result['USmount'] = round(result['USmount'], 2)
result['UScreatetime'] = get_web_time_str(result['UScreatetime'])
res = import_status("get_user_totalinfo_success", "OK")
res['data'] = result
return res
else:
return SYSTEM_ERROR
def findback_pwd(self):
try:
data = request.json
phonenum = data.get('usphonenum')
iccode = data.get('iccode')
newpassword = data.get('newpassword')
except Exception as e:
return PARAMS_ERROR
if not phonenum or not iccode or not newpassword:
return PARAMS_ERROR
codeinfo = get_model_return_dict(
self.smycenter.get_inforcode_by_usphonenum(phonenum))
if not codeinfo:
return SYSTEM_ERROR
if iccode != codeinfo['ICcode']:
return INFORCODE_WRONG
user = get_model_return_dict(self.suser.getuser_by_phonenum(phonenum))
if not user:
return NOT_FOUND_USER
user_update = {}
user_update["USpassword"] = generate_password_hash(newpassword)
self.suser.update_user_by_uid(user['USid'], user_update)
data = import_status("update_password_success", "OK")
return data
def get_order_details(self):
if is_tourist():
return TOKEN_ERROR
data = request.json
if not data:
return PARAMS_MISS
try:
OIsn = int(data.get('OIsn'))
except:
return PARAMS_ERROR
detail = get_model_return_dict(self.sorder.get_order_details(OIsn))
if not detail:
response = import_status("get_orderdetails_success", "OK")
response['data'] = []
return response
address = get_model_return_dict(
self.smycenter.get_other_address(request.user.id, detail['UAid']))
if not address:
return NO_ADDRESS
area = get_model_return_dict(
self.smycenter.get_area_by_areaid(address['areaid']))
from common.timeformat import get_web_time_str
if area:
city = get_model_return_dict(
self.smycenter.get_city_by_cityid(area['cityid']))
province = get_model_return_dict(
self.smycenter.get_province_by_provinceid(city['provinceid']))
detail['provincename'] = province['provincename']
detail['cityname'] = city['cityname']
detail['areaname'] = area['areaname']
detail['details'] = address['UAdetails']
detail['username'] = address['UAname']
detail['userphonenum'] = address['UAphonenum']
detail['createtime'] = get_web_time_str(address['UAcreatetime'])
else:
city = get_model_return_dict(
self.smycenter.get_city_by_cityid(address['cityid']))
province = get_model_return_dict(
self.smycenter.get_province_by_provinceid(city['provinceid']))
detail['provincename'] = province['provincename']
detail['cityname'] = city['cityname']
detail['details'] = address['UAdetails']
detail['username'] = address['UAname']
detail['userphonenum'] = address['UAphonenum']
detail['createtime'] = get_web_time_str(address['UAcreatetime'])
product_list = get_model_return_list(
self.sorder.get_product_list(detail['OIid']))
detail['product_list'] = product_list
response = import_status("get_orderdetails_success", "OK")
response['data'] = detail
return response
def get_product_details(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
prid = data.get('prid')
except:
return PARAMS_ERROR
details = get_model_return_dict(self.sgoods.get_product_details(prid))
details['sowingmap'] = details['sowingmap'].split(",") if details['sowingmap'] else None
details['detailpics'] = details['detailpics'].split(",") if details['detailpics'] else None
sku_list = get_model_return_list(self.sgoods.get_sku_by_prid(prid))
response = import_status("get_product_detail_success", "OK")
response['data'] = details
response['data']['skulist'] = sku_list
return response
def check_stock(self, product_list):
for product in product_list:
PRid = product['PRid']
PRstock = product['PRnum']
real_num = get_model_return_dict(
self.session.query(
Product.PRstock).filter_by(PRid=PRid).first())
if real_num['PRstock'] < PRstock:
raise stockerror('库存不足')
update_stock = {}
update_stock['PRstock'] = real_num['PRstock'] - PRstock
result = self.session.query(Product).filter_by(
PRid=PRid).update(update_stock)
if not result:
raise dberror
return True
def modify(self):
all_order = get_model_return_list(self.sorder.get_all_order(None, None, None, 1, None, None))\
+ get_model_return_list(self.sorder.get_all_order(None, None, None, 2, None, None))\
+ get_model_return_list(self.sorder.get_all_order(None, None, None, 4, None, None)) \
+ get_model_return_list(self.sorder.get_all_order(None, None, None, 5, None, None))
session = db_session()
try:
for order in all_order:
product_list = get_model_return_list(
self.sorder.get_product_list(order['OIid']))
real_discount = 0
for product in product_list:
check_product = get_model_return_dict(
self.sgoods.get_product_info(product['PRid']))
sku_list = get_model_return_list(
self.sorder.get_sku_list_by_opiid(product['OPIid']))
for sku in sku_list:
real_discount = real_discount + sku[
'number'] * check_product['PAdiscountnum']
session.query(OrderInfo).filter(
OrderInfo.OIid == order['OIid']).update(
{'discountnum': real_discount})
session.commit()
except:
session.rollback()
finally:
session.close()
session = db_session()
try:
amount_list = get_model_return_list(
session.query(Amount.AMmonth, Amount.USid).all())
for amount in amount_list:
real_amount = 0
order_list = get_model_return_list(
session.query(OrderInfo.discountnum).filter(
OrderInfo.USid == amount['USid']).filter(
OrderInfo.OIstatus == 2).all())
for order in order_list:
real_amount = real_amount + order['discountnum']
session.query(Amount).filter(
Amount.USid == amount['USid']).update(
{'performance': real_amount})
session.commit()
except:
session.rollback()
finally:
session.close()
def login(self):
try:
json_data = request.json
adnum = int(json_data.get('adnum'))
adpassword = int(json_data.get('adpassword'))
except:
return PARAMS_MISS
if not adnum or not adpassword:
return NO_PHONENUM_OR_PASSWORD
admin = get_model_return_dict(self.sadmin.getadmin_by_adnum(adnum))
if not admin or adpassword != int(admin['ADpassword']):
return PHONE_OR_PASSWORD_WRONG
token = usid_to_token(admin['ADid'], type='SuperUser')
data = import_status('generic_token_success', "OK")
data['data'] = {
'token': token,
}
return data
def check_inforcode(self):
data = request.json
try:
phonenum = data.get('usphonenum')
iccode = data.get('iccode')
except Exception as e:
return PARAMS_ERROR
if not phonenum or not iccode:
return PARAMS_ERROR
codeinfo = get_model_return_dict(self.smycenter.get_inforcode_by_usphonenum(phonenum))
if not codeinfo:
return SYSTEM_ERROR
checkstatus = True if iccode == codeinfo['ICcode'] else False
checkmessage = u"验证码正确" if checkstatus is True else u"验证码错误"
response = import_status("check_inforcode_access", "OK")
response["data"] = {"checkstatus": checkstatus,
"checkmessage": checkmessage
}
return response
def update_shoppingcart_number(self):
if not is_ordirnaryuser():
return TOKEN_ERROR
try:
data = request.json
psid = data.get('psid')
number = data.get('number')
except:
return PARAMS_ERROR
sku_stock = get_model_return_dict(self.sgoods.get_sku_stock(psid))
if sku_stock['PSstatus'] != 1:
return PRODUCT_STATUS_WRONG
if int(number) > sku_stock['PSstock']:
return STOCK_NOT_ENOUGH
if int(number) < 0:
return PARAMS_MISS
result = self.sgoods.update_user_sku(request.user.id, psid, {"number": number})
if not result:
return SYSTEM_ERROR
response = import_status("change_shoppingcart_number_success", "OK")
return response
def update_pwd(self):
if not is_admin():
return AUTHORITY_ERROR
json_data = request.json
if not json_data:
return PARAMS_MISS
oldpassword = json_data.get('oldpassword')
newpassword = json_data.get('newpassword')
user = get_model_return_dict(
self.sadmin.getadmin_by_adminid(request.user.id))
if not user or not check_password_hash(user['ADpassword'],
oldpassword):
return PASSWORD_WRONG
admin_update = {}
admin_update["ADpassword"] = generate_password_hash(newpassword)
result = self.sadmin.update_amdin_by_adminid(user['ADid'],
admin_update)
if not result:
return SYSTEM_ERROR
data = import_status("update_password_success", "OK")
return data
def add_qrcode(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
date = str(data.get('overtime'))
number = int(data.get('number'))
except:
return PARAMS_ERROR
user_info = get_model_return_dict(self.smycenter.get_user_basicinfo(request.user.id)) if self.smycenter\
.get_user_basicinfo(request.user.id) else None
if not user_info:
return NOT_FOUND_USER
if user_info['USbail'] < float(self.conf.get('account', 'bail')):
return NO_BAIL
result = self.suser.add_qrcode(str(uuid.uuid4()), request.user.id,
date, number)
if result:
response = import_status("add_qrcode_success", "OK")
return response
else:
return SYSTEM_ERROR
