def update_pwd(self):
if is_tourist():
return TOKEN_ERROR(u"未登录")
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_list(self.suser.getuser_by_uid(
request.user.id))
if not user or user[0]['USpassword'] != oldpassword:
return PASSWORD_WRONG
user_update = {}
user_update["USpassword"] = newpassword
self.suser.update_user_by_uid(request.user.id, user_update)
data = import_status("update_password_success", "OK")
return data
def get_product_category(self):
args = request.args.to_dict()
try:
PAtype = int(args.get("PAtype"))
if PAtype == 1:
product_category = (get_model_return_list(self.sgoods.get_first_product_category(str(0))))
elif PAtype == 2:
PAid = args.get("PAid")
product_category = (get_model_return_list(self.sgoods.get_first_product_category(PAid)))
else:
return NO_THIS_CATEGORY
except Exception as e:
print(e.message)
return PARAMS_MISS
response = import_status("get_product_category_success", "OK")
response["data"] = product_category
return response
def get_sowingmap(self):
if is_tourist():
return TOKEN_ERROR
mallUrls = []
personUrls = []
list = get_model_return_list(self.sgoods.get_sowingmap())
for pic in list:
if pic['SMtype'] == 1:
personUrls.append(pic)
if pic['SMtype'] == 2:
mallUrls.append(pic)
data = {}
data['mallUrls'] = mallUrls
data['personUrls'] = personUrls
response = import_status("get_sowingmap_success", "OK")
response['data'] = data
return response
def change_default(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
old_defaultid = data.get('old_defaultid')
new_defaultid = data.get('new_defaultid')
except:
return PARAMS_ERROR
change_result = self.smycenter.change_default(request.user.id,
old_defaultid,
new_defaultid)
if change_result:
response = import_status("change_address_success", "OK")
return response
else:
return CHANGE_ADDRESS_FAIL
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 add_size(self):
if not is_admin():
return TOKEN_ERROR
try:
data = request.json
sizename = data.get("sizename")
except Exception as e:
print e
return PARAMS_ERROR
is_same = self.sgoods.get_color_by_sizename(sizename.encode('utf-8'))
if is_same:
return REPERT_SIZE
time_now = datetime.strftime(datetime.now(), format_for_db)
result = self.sgoods.add_size(sizename, time_now)
if not result:
return SYSTEM_ERROR
response = import_status("add_size_success", "OK")
return response
def get_product_category_list(self):
# 获取商品分类列表
if is_tourist():
return TOKEN_ERROR
first_level = get_model_return_list(self.sgoods.get_first_product_category_status(str(0)))
options = []
for parent_category in first_level:
product_category_list = {}
parnetid = parent_category['PAid']
parentname = parent_category['PAname']
product_category_list['PAid'] = parnetid
product_category_list['PAname'] = parentname
child_category = get_model_return_list(self.sgoods.get_first_product_category(parnetid))
product_category_list['child_category'] = child_category
options.append(product_category_list)
response = import_status("get_product_category_list_success", "OK")
response['data'] = options
return response
def add_sowingmap(self):
if not is_admin():
return TOKEN_ERROR
try:
data = request.json
type = data['type']
urls = data['urls']
except:
return PARAMS_ERROR
if int(type) < 0:
return PARAMS_ERROR
result = self.sgoods.update_sowingmap_by_type(type)
if not result:
return SYSTEM_ERROR
result = self.sgoods.add_sowingmap(type, urls)
if not result:
return SYSTEM_ERROR
response = import_status("add_sowingmap_success", "OK")
return response
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 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 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 publish_commessage(self):
if not is_admin():
return AUTHORITY_ERROR
try:
json_data = request.json
type = json_data.get('type')
title = json_data.get('title')
url = json_data.get('url')
except Exception as e:
return PARAMS_ERROR
if not title or not url:
return PARAMS_MISS
# 获取当前时间
import datetime
from common.timeformat import format_for_db
time_time = datetime.datetime.now()
time_str = datetime.datetime.strftime(time_time, format_for_db)
id = str(uuid.uuid4())
self.smessage.publish_commessage(id, time_str, type, title, url)
response = import_status("publish_message_success", "OK")
return response
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
def update_useraddress(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
UAid = data.get('UAid')
USname = data.get('USname')
USphonenum = data.get('USphonenum')
details = data.get('details')
areaid = data.get('areaid')
except:
return PARAMS_ERROR
update_address = {}
update_address['UAname'] = USname
update_address['UAphonenum'] = USphonenum
update_address['UAdetails'] = details
update_address['areaid'] = areaid
update_result = self.smycenter.update_address(request.user.id, UAid, update_address)
if update_result:
response = import_status("update_address_success", "OK")
return response
else:
return UPDATE_ADDRESS_FAIL
def delete_shoppingcart_sku(self):
if not is_ordirnaryuser():
return TOKEN_ERROR
try:
data = request.json
scidlist = data.get('scidlist')
except:
return PARAMS_ERROR
update = {
"SCstatus": 0
}
session = db_session()
try:
for scid in scidlist:
self.sgoods.update_user_sku_by_scid(session, request.user.id, str(scid), update)
session.commit()
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.close()
response = import_status("delete_shoppingcart_sku_success", "OK")
return response
def delete_admin(self):
if not is_superadmin():
return AUTHORITY_ERROR
try:
data = request.json
ADnum = data.get('ADnum')
#ADname = data.get('ADname')
except:
return PARAMS_ERROR
try:
retnum = False #判断ADnum是否在admin列表中
retname = False #判断ADname是否在admin列表中
all_adnum = get_model_return_list(self.sadmin.get_all_adnum())
#all_adname = get_model_return_list(self.sadmin.get_all_adname())
for adnum_dict in all_adnum:
if ADnum == int(adnum_dict['ADnum']):
retnum = True
# if retnum == False:
# return ADMINNUM_ERROR
# for adname_dict in all_adname:
# if ADname == adname_dict['ADname']:
# retcode = True
# else:
# return ADMINNAME_ERROR
#if retnum and retname:
if retnum:
update_admin = {}
update_admin['ADisfreeze'] = True
self.sadmin.delete_admin(ADnum, update_admin)
response = import_status("delete_admin_success", "OK")
return response
else:
return ADMINNUM_ERROR
except Exception as e:
print e
return SYSTEM_ERROR
def login(self):
print "hello"
json_data = request.json
if not json_data:
return PARAMS_ERROR
usphonenum = json_data.get('usphonenum')
uspassword = json_data.get('uspassword')
if not usphonenum or not uspassword:
return PARAMS_MISS(u'请输入手机号或密码')
print type(usphonenum)
user = get_model_return_dict(
self.suser.getuser_by_phonenum(usphonenum))
# print "aaaa" + user.USphone + ":" + user.USpassword
# print(dir(user))
# print user.USphonenum
# print type(user.USphonenum)
if not user or uspassword != user['USpassword']:
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 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_all_order(self):
if not is_admin():
return AUTHORITY_ERROR
params = [
'page_size', 'page_num', 'oisn', 'starttime', 'endtime', 'status',
'username', 'userphonenum', 'productname'
]
try:
data = request.json
for param in params:
if param not in data:
response = {}
response['message'] = u"参数缺失"
response['paramname'] = param
response['status'] = 405
return response
except:
return PARAMS_ERROR
page_size = data.get('page_size')
page_num = data.get('page_num')
oisn = data.get('oisn')
starttime = str(data.get('starttime')) + '000000' if data.get(
'starttime') else None
endtime = data.get('endtime') + '000000' if data.get(
'endtime') else None
status = data.get('status')
username = data.get('username')
userphonenum = data.get('userphonenum')
productname = data.get('productname')
all_order = get_model_return_list(
self.sorder.get_all_order(oisn, starttime, endtime, status,
username, userphonenum))
return_list = []
for order in all_order:
detail = get_model_return_dict(
self.sorder.get_order_details(order['OIsn']))
from common.timeformat import get_web_time_str
order['OIcreatetime'] = get_web_time_str(order['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
order['product_list'] = product_list
if productname:
for product in product_list:
if productname in product['PRname']:
return_list.append(order)
break
else:
return_list.append(order)
mount = len(return_list)
page = mount / page_size
if page == 0 or page == 1 and mount % page_size == 0:
real_return_list = return_list[0:]
else:
if ((mount - (page_num - 1) * page_size) / page_size) >= 1 and \
(mount - (page_num * page_size)) > 0:
real_return_list = return_list[((page_num - 1) *
page_size):(page_num *
page_size)]
else:
real_return_list = return_list[((page_num - 1) * page_size):]
response = import_status("get_allorder_success", "OK")
response['data'] = real_return_list
response['mount'] = mount
return response
def create_review(self):
args = request.args.to_dict() # 捕获前端的URL参数，以字典形式呈现
# 判断url参数是否异常
if len(args) != 2 or "token" not in args.keys() or "Oid" not in args.keys():
message, status, statuscode = import_status("URL_PARAM_WRONG", "response_error", "URL_PARAM_WRONG")
return {
"message": message,
"status": status,
"statuscode": statuscode,
}
token_to_str = get_str(args, "token")
print('token'+token_to_str)
oid_to_str = get_str(args, "Oid")
oid_list_service = self.service_order.get_all_order_by_uid(token_to_str)
oid_list_control = []
print(oid_list_service)
if oid_list_service == None:
message, status, statuscode = import_status("messages_error_wrong_status_code", "response_error",
"error_wrong_status_code")
return {
"message": message,
"status": status,
"statuscode": statuscode,
}
for i in range(len(oid_list_service)):
oid = oid_list_service[i].Oid
oid_list_control.append(oid)
print(oid_to_str)
if oid_to_str not in oid_list_control:
message, status, statuscode = import_status("messages_error_wrong_status_code", "response_error",
"error_wrong_status_code")
return {
"message": message,
"status": status,
"statuscode": statuscode,
}
else:
# 查看订单状态是否正常
order_abo = self.service_order.get_order_abo_by_oid(oid_to_str)
if order_abo.Ostatus != 42:
message, status, statuscode = import_status("messages_error_wrong_status_code", "response_error",
"error_wrong_status_code")
return {
"message": message,
"status": status,
"statuscode": statuscode,
}
form = request.data # 获取前端发送的body体
form = json.loads(form)
pro_list = form["Product_list"]
print pro_list
for i in range(len(pro_list)):
review = model.Review()
Rid = uuid.uuid4()
review.Rid = str(Rid)
review.Oid = oid_to_str
review.Pid = pro_list[i].get("Pid")
review.Uid = token_to_str
review.Rscore = pro_list[i].get("Rscore")
review.Rcontent = pro_list[i].get("Rcontent")
review.Rstatus = "on"
result = self.service_review.create_review(review)
print(result)
# 更新订单状态
try:
order_status = {}
order_status["Ostatus"] = 49
self.service_order.update_status_by_oid(oid_to_str, order_status)
except Exception as e:
print(e)
from config.status import response_error
from config.status_code import SYSTEM_ERROR
from config.messages import error_system_error
return {
"message": error_system_error,
"status": response_error,
"statuscode": SYSTEM_ERROR,
}
from config.messages import create_review_success
return {
"message": create_review_success,
"status": 200,
}
def get_useraddress(self):
if is_tourist():
return TOKEN_ERROR
try:
data = request.json
isdefault = int(data.get('isdefault'))
all = int(data.get('all'))
UAid = data.get('UAid')
except:
return PARAMS_ERROR
from common.timeformat import get_web_time_str
if all == 1:
all_address = get_model_return_list(self.smycenter.get_all_address(request.user.id))
if not all_address:
response = import_status("get_address_success", "OK")
response['data'] = []
return response
address_list = []
for address in all_address:
address = get_model_return_dict(self.smycenter.get_other_address(request.user.id, address['UAid']))
if not address:
return NO_ADDRESS
area = get_model_return_dict(self.smycenter.get_area_by_areaid(address['areaid']))
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']))
data = {}
data['provincename'] = province['provincename']
data['provinceid'] = province['provinceid']
data['cityname'] = city['cityname']
data['cityid'] = city['cityid']
data['areaname'] = area['areaname']
data['areaid'] = area['areaid']
data['details'] = address['UAdetails']
data['username'] = address['UAname']
data['userphonenum'] = address['UAphonenum']
data['uaid'] = address['UAid']
data['isdefault'] = address['UAdefault']
data['createtime'] = get_web_time_str(address['UAcreatetime'])
address_list.append(data)
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']))
data = {}
data['provincename'] = province['provincename']
data['provinceid'] = province['provinceid']
data['cityname'] = city['cityname']
data['cityid'] = city['cityid']
data['details'] = address['UAdetails']
data['username'] = address['UAname']
data['userphonenum'] = address['UAphonenum']
data['uaid'] = address['UAid']
data['isdefault'] = address['UAdefault']
data['createtime'] = get_web_time_str(address['UAcreatetime'])
address_list.append(data)
response = import_status("get_address_success", "OK")
response['data'] = address_list
return response
if isdefault == 1:
address = get_model_return_dict(self.smycenter.get_default_address(request.user.id))
if not address:
response = import_status("get_address_success", "OK")
response['data'] = []
return response
area = get_model_return_dict(self.smycenter.get_area_by_areaid(address['areaid']))
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']))
data = {}
data['provincename'] = province['provincename']
data['provinceid'] = province['provinceid']
data['cityname'] = city['cityname']
data['cityid'] = city['cityid']
data['areaname'] = area['areaname']
data['areaid'] = area['areaid']
data['details'] = address['UAdetails']
data['username'] = address['UAname']
data['userphonenum'] = address['UAphonenum']
data['uaid'] = address['UAid']
data['createtime'] = get_web_time_str(address['UAcreatetime'])
response = import_status("get_address_success", "OK")
response['data'] = data
return response
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']))
data = {}
data['provincename'] = province['provincename']
data['provinceid'] = province['provinceid']
data['cityname'] = city['cityname']
data['cityid'] = city['cityid']
data['details'] = address['UAdetails']
data['username'] = address['UAname']
data['userphonenum'] = address['UAphonenum']
data['uaid'] = address['UAid']
data['createtime'] = get_web_time_str(address['UAcreatetime'])
response = import_status("get_address_success", "OK")
response['data'] = data
return response
elif isdefault == 0:
address = get_model_return_dict(self.smycenter.get_other_address(request.user.id, UAid))
if not address:
response = import_status("get_address_success", "OK")
response['data'] = []
return response
area = get_model_return_dict(self.smycenter.get_area_by_areaid(address['areaid']))
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']))
data = {}
data['provincename'] = province['provincename']
data['provinceid'] = province['provinceid']
data['cityname'] = city['cityname']
data['cityid'] = city['cityid']
data['areaname'] = area['areaname']
data['areaid'] = area['areaid']
data['details'] = address['UAdetails']
data['username'] = address['UAname']
data['userphonenum'] = address['UAphonenum']
data['uaid'] = address['UAid']
data['createtime'] = get_web_time_str(address['UAcreatetime'])
response = import_status("get_address_success", "OK")
response['data'] = data
return response
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']))
data = {}
data['provincename'] = province['provincename']
data['provinceid'] = province['provinceid']
data['cityname'] = city['cityname']
data['cityid'] = city['cityid']
data['details'] = address['UAdetails']
data['username'] = address['UAname']
data['userphonenum'] = address['UAphonenum']
data['uaid'] = address['UAid']
data['createtime'] = get_web_time_str(address['UAcreatetime'])
response = import_status("get_address_success", "OK")
response['data'] = data
return response
def deal_register_record(self):
if not is_admin():
return TOKEN_ERROR
try:
data = request.json
IRIid = data.get('IRIid')
willstatus = data.get('willstatus')
except:
return PARAMS_ERROR
info = get_model_return_dict(
self.suser.get_registerrecord_by_IRIid(IRIid))
if not info:
return NOT_FOUND_USER
if willstatus == 2:
session = db_session()
try:
user = self.smycenter.get_user_basicinfo_byphone(
info['IRIprephonenum']) # 插入销售表，有数据就更新
if not user:
raise dberror
user = get_model_return_dict(user)
monthnow = datetime.strftime(datetime.now(),
format_for_db)[0:6]
amount_data = self.saccount.get_user_date(
user['USid'], monthnow)
if amount_data:
amount_data = get_model_return_dict(amount_data)
new_data = {}
new_data['reward'] = amount_data['reward'] + float(
self.conf.get('account', 'reward'))
try:
session.query(Amount).filter(
Amount.USid == user['USid']).update(new_data)
except:
raise dberror
else:
amount = Amount()
amount.USid = user['USid']
amount.AMid = str(uuid.uuid4())
amount.USagentid = user['USagentid']
amount.USname = user['USname']
amount.reward = float(self.conf.get('account', 'reward'))
amount.AMstatus = 1
amount.USheadimg = user['USheadimg']
amount.AMcreattime = datetime.strftime(
datetime.now(), format_for_db)
amount.AMmonth = datetime.strftime(datetime.now(),
format_for_db)[0:6]
session.add(amount)
new_userid = str(uuid.uuid4()) # 插入新用户
new_user = User()
new_user.USid = new_userid
new_user.USname = info['IRIname']
new_user.USpre = user['USid']
new_user.USagentid = get_random_str(12)
new_user.USheadimg = info['IRIpic'] if info['IRIpic'] else 'https://timgsa.baidu.com/timg?image&quality=80&size=b9999_100' \
'00&sec=1540919391&di=91c' \
'1ae656341d5814e63280616ad8ade&imgtype=jpg&er=1&src=http%3A%2F%2Fimg.zcool.cn%2Fcommun' \
'ity%2F0169d55548dff50000019ae9973427.jpg%401280w_1l_2o_100sh.jpg'
new_user.USphonenum = info['IRIphonenum']
new_user.USmount = 0
new_user.USbail = 0
new_user.USwechat = info['IRIwechat']
new_user.idcardnum = info['IRIidcardnum']
new_user.UScreatetime = datetime.strftime(
datetime.now(), format_for_db)
new_user.USpassword = generate_password_hash(
info['IRIpassword'])
session.add(new_user)
reward = Reward() # 插入直推奖励表
reward.REid = str(uuid.uuid4())
reward.RElastuserid = user['USid']
reward.REnextuserid = new_userid
reward.REmonth = datetime.strftime(datetime.now(),
format_for_db)[0:6]
reward.REmount = float(self.conf.get('account', 'reward'))
reward.REcreatetime = datetime.strftime(
datetime.now(), format_for_db)
session.add(reward)
session.query(User).filter(User.USid == user['USid'])\
.update({"USmount": user['USmount'] + float(self.conf.get('account', 'reward'))})
# 写入代理消息
content = u'您推荐的代理已审核通过，直推奖励已发放至余额'
agent_result = self.smessage.create_agentmessage(
session, user['USid'],
datetime.strftime(datetime.now(), format_for_db), content,
2)
if not agent_result:
return SYSTEM_ERROR
USname = info['IRIname'] # 插入默认收货地址
USphonenum = info['IRIphonenum']
USdatails = info['IRIaddress']
areaid = info['IRIarea']
cityid = info['IRIcity']
if areaid:
all_areaid = get_model_return_list(
self.smycenter.get_all_areaid())
area_list = []
for area in all_areaid:
area_list.append(area['areaid'])
if areaid not in area_list:
return BAD_ADDRESS
time_time = datetime.now()
time_str = datetime.strftime(time_time, format_for_db)
uaid = str(uuid.uuid1())
exist_default = self.smycenter.get_default_address_by_usid(
new_userid)
uadefault = True if not exist_default else False
self.smycenter.add_address_selfsession(session, uaid, new_userid, USname, USphonenum, USdatails, \
areaid, uadefault, time_str, None)
else:
all_cityid = get_model_return_list(
self.smycenter.get_all_cityid())
cityid_list = []
for city in all_cityid:
cityid_list.append(city['cityid'])
if cityid not in cityid_list:
return BAD_ADDRESS
time_time = datetime.now()
time_str = datetime.strftime(time_time, format_for_db)
uaid = str(uuid.uuid1())
exist_default = self.smycenter.get_default_address_by_usid(
new_userid)
uadefault = True if not exist_default else False
self.smycenter.add_address_selfsession(session, uaid, new_userid, USname, USphonenum, USdatails, \
None, uadefault, time_str, cityid)
session.commit()
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.close()
update = {}
update['IRIstatus'] = int(willstatus)
result = self.suser.update_register_record(IRIid, update)
response = import_status("register_success", "OK")
return response
def register(self):
params = [
'qrid', 'preusername', 'prephonenum', 'username', 'phonenum',
'inforcode', 'password', 'idcardnum', 'wechat', 'cityid', 'areaid',
'details', 'paytype', 'payamount', 'paytime', 'headimg', 'proof',
'alipaynum', 'bankname', 'accountname', 'cardnum'
]
data = request.json
for param in data:
if param not in params:
return PARAMS_MISS
try:
qrid = data['qrid']
preusername = data['preusername']
prephonenum = data['prephonenum']
username = data['username']
phonenum = data['phonenum']
inforcode = data['inforcode'] # 验证码
password = data['password']
idcardnum = data['idcardnum']
wechat = data['wechat']
cityid = data['cityid']
areaid = data['areaid']
details = data['details']
paytype = data['paytype']
payamount = data['payamount']
paytime = data['paytime']
headimg = data['headimg']
proof = data['proof']
alipaynum = data['alipaynum']
bankname = data['bankname']
accountname = data['accountname']
cardnum = data['cardnum']
if int(paytype) == 1:
if not alipaynum or bankname or accountname or cardnum:
return PARAMS_ERROR
if int(paytype) == 2:
if alipaynum or not bankname or not accountname or not cardnum:
return PARAMS_ERROR
except:
return PARAMS_ERROR
qr = get_model_return_dict(self.suser.get_qrcode_by_qrid(
qrid)) if self.suser.get_qrcode_by_qrid(qrid) else None
if not qr:
return NOT_FOUND_QRCODE
update = {}
update['QRnumber'] = str(int(qr['QRnumber']) - 1)
result = self.suser.update_qrcode(qrid, update)
if not result:
return NOT_FOUND_QRCODE
check_phone = self.suser.getuser_by_phonenum(phonenum)
if check_phone:
return HAS_REGISTER
codeinfo = get_model_return_dict(self.smycenter.get_inforcode_by_usphonenum(phonenum)) if self.smycenter\
.get_inforcode_by_usphonenum(phonenum) else None
if not codeinfo:
return SYSTEM_ERROR
if inforcode != codeinfo['ICcode']:
return INFORCODE_WRONG
session = db_session()
try:
result = self.suser.insertInvitate(session, data)
if not result:
raise dberror
session.commit()
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.close()
response = import_status("register_success", "OK")
return response
def get_registerinfo(self):
try:
data = request.json
qrcodeid = str(data.get('qrid'))
except:
return PARAMS_ERROR
if not qrcodeid:
user_dict = {}
user_dict['alipaynum'] = self.conf.get('account', 'alipaynum')
user_dict['alipayname'] = self.conf.get('account', 'alipayname')
user_dict['bankname'] = self.conf.get('account', 'bankname')
user_dict['accountname'] = self.conf.get('account', 'accountname')
user_dict['cardnum'] = self.conf.get('account', 'cardnum')
user_dict['money'] = float(self.conf.get('account', 'money'))
user_dict['service'] = self.conf.get('account', 'service')
user_dict['drawbank'] = self.conf.get('account', 'drawbank')
response = import_status("get_registerinfo_success", "OK")
response['data'] = user_dict
return response
usid = self.suser.get_user_by_qrid(qrcodeid)
if not usid:
return NOT_FOUND_QRCODE
usid = get_model_return_dict(usid)
user = self.suser.getuserinfo_by_uid(usid['USid'])
if not user:
return NOT_FOUND_USER
user = get_model_return_dict(user)
user_dict = {}
user_dict['name'] = user['USname']
user_dict['USphonenum'] = user['USphonenum']
user_dict['alipaynum'] = self.conf.get('account', 'alipaynum')
user_dict['alipayname'] = self.conf.get('account', 'alipayname')
user_dict['bankname'] = self.conf.get('account', 'bankname')
user_dict['accountname'] = self.conf.get('account', 'accountname')
user_dict['cardnum'] = self.conf.get('account', 'cardnum')
user_dict['money'] = float(self.conf.get('account', 'money'))
user_dict['service'] = self.conf.get('account', 'service')
user_dict['drawbank'] = self.conf.get('account', 'drawbank')
address = self.smycenter.get_user_default_details(usid['USid'])
if address:
address = get_model_return_dict(address)
area = get_model_return_dict(
self.smycenter.get_area_by_areaid(address['areaid']))
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']))
provincename = province['provincename']
cityname = city['cityname']
areaname = area['areaname']
details = address['UAdetails']
real_address = provincename + cityname + areaname + details
user_dict['address'] = real_address
response = import_status("get_registerinfo_success", "OK")
response['data'] = user_dict
return response
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']))
data = {}
provincename = province['provincename']
cityname = city['cityname']
details = address['UAdetails']
real_address = provincename + cityname + details
user_dict['address'] = real_address
response = import_status("get_registerinfo_success", "OK")
response['data'] = user_dict
return response
else:
address = self.smycenter.get_user_otherdefault_details(
usid['USid'])
if address:
address = get_model_return_dict(address)
area = get_model_return_dict(
self.smycenter.get_area_by_areaid(address['areaid']))
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']))
provincename = province['provincename']
cityname = city['cityname']
areaname = area['areaname']
details = address['UAdetails']
real_address = provincename + cityname + areaname + details
response = import_status("get_registerinfo_success", "OK")
response['data'] = user_dict
return response
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']))
data = {}
provincename = province['provincename']
cityname = city['cityname']
details = address['UAdetails']
real_address = provincename + cityname + details
user_dict['address'] = real_address
response = import_status("get_registerinfo_success", "OK")
response['data'] = user_dict
return response
return SYSTEM_ERROR
def get_order_list(self):
if is_tourist():
return TOKEN_ERROR
data = request.json
if not data:
return PARAMS_MISS
try:
type = int(data.get('type'))
page = int(data.get('page'))
count = int(data.get('count'))
except:
return PARAMS_ERROR
order_return_list = []
if type == 0:
order_list = get_model_return_list(
self.sorder.get_allorder_list(request.user.id, page, count))
state0 = int(self.sorder.get_total_order_num(
request.user.id)) if self.sorder.get_total_order_num(
request.user.id) else 0
state1 = int(self.sorder.get_order_num(
request.user.id, 1)) if self.sorder.get_order_num(
request.user.id, 1) else 0
state2 = int(self.sorder.get_order_num(
request.user.id, 2)) if self.sorder.get_order_num(
request.user.id, 2) else 0
state3 = int(self.sorder.get_order_num(
request.user.id, 3)) if self.sorder.get_order_num(
request.user.id, 3) else 0
state4 = int(self.sorder.get_order_num(
request.user.id, 4)) if self.sorder.get_order_num(
request.user.id, 4) else 0
state1 = state1 + state4
for order in order_list:
product_list = get_model_return_list(
self.sorder.get_product_list(order['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
order['product_list'] = product_list
from common.timeformat import get_web_time_str
order['OIcreatetime'] = get_web_time_str(order['OIcreatetime'])
order_return_list.append(order)
response = import_status("get_orderlist_success", "OK")
response['data'] = order_return_list
response['state0_num'] = state0
response['state1_num'] = state1
response['state2_num'] = state2
response['state3_num'] = state3
return response
else:
order_list = get_model_return_list(
self.sorder.get_order_list(request.user.id, type, page, count))
if type == 1:
order_list = order_list + get_model_return_list(
self.sorder.get_order_list(request.user.id, 4, page,
count))
new_list = sorted(order_list,
key=lambda order: order['OIcreatetime'],
reverse=True)
order_list = new_list
if not order_list:
response = import_status("get_orderlist_success", "OK")
response['data'] = order_return_list
return response
for order in order_list:
product_list = get_model_return_list(
self.sorder.get_product_list(order['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
order['product_list'] = product_list
from common.timeformat import get_web_time_str
order['OIcreatetime'] = get_web_time_str(order['OIcreatetime'])
order_return_list.append(order)
response = import_status("get_orderlist_success", "OK")
response['data'] = order_return_list
return response
def upload_file(self):
try:
param = request.args.to_dict()
type = param.get("type")
except:
type = None
if is_ordirnaryuser() or is_admin():
try:
files = request.files.get("file")
except:
return PARAMS_ERROR
if not files:
return NOT_FOUND_FILE
if platform.system() == "Windows":
rootdir = "D:/task"
else:
rootdir = "/opt/beili/file/"
if not os.path.isdir(rootdir):
os.makedirs(rootdir)
lastpoint = str(files.filename).rindex(".")
filessuffix = str(files.filename)[lastpoint + 1:]
print 'filessuffix', filessuffix
if is_ordirnaryuser():
if filessuffix.lower() in ['png', 'jpg', 'jpeg', 'gif']:
image = Image.open(files)
w, h = image.size
filename = request.user.id + get_db_time_str(
) + get_random_str(6) + "." + filessuffix
filepath = os.path.join(rootdir, filename)
if type == 1:
image.resize((128, 128)).save(filepath)
else:
image.resize((w / 2, h / 2)).save(filepath)
response = import_status("upload_file_success", "OK")
url = QRCODEHOSTNAME + "/file/" + filename
response["data"] = url
return response
if is_admin():
if filessuffix.lower() in ['png', 'jpg', 'jpeg', 'gif']:
image = Image.open(files)
w, h = image.size
filename = request.user.id + get_db_time_str(
) + get_random_str(6) + "." + filessuffix
filepath = os.path.join(rootdir, filename)
# image.resize((w / 2, h / 2)).save(filepath)
if w > 1000:
image.resize((w * 2 / 3, h * 2 / 3)).save(filepath)
else:
image.save(filepath)
response = import_status("upload_file_success", "OK")
url = QRCODEHOSTNAME + "/file/" + filename
response["data"] = url
return response
filename = request.user.id + get_db_time_str() + get_random_str(
6) + "." + filessuffix
filepath = os.path.join(rootdir, filename)
print(filepath)
files.save(filepath)
response = import_status("upload_file_success", "OK")
url = QRCODEHOSTNAME + "/file/" + filename
response["data"] = url
return response
else:
id1 = str(uuid.uuid4())
token = usid_to_token(id=id1, type='Temp')
try:
files = request.files.get("file")
except:
return PARAMS_ERROR
if not files:
return NOT_FOUND_FILE
if platform.system() == "Windows":
rootdir = "D:/task"
else:
rootdir = "/opt/beili/file/"
if not os.path.isdir(rootdir):
os.makedirs(rootdir)
lastpoint = str(files.filename).rindex(".")
filessuffix = str(files.filename)[lastpoint + 1:] # 后缀名
print filessuffix
if filessuffix.lower() in ['png', 'jpg', 'jpeg', 'gif']:
image = Image.open(files)
w, h = image.size
filename = id1 + get_db_time_str() + "." + filessuffix
filepath = os.path.join(rootdir, filename)
if type == 1:
image.resize((128, 128)).save(filepath)
else:
image.resize((w / 2, h / 2)).save(filepath)
url = QRCODEHOSTNAME + "/file/" + filename
data = import_status("upload_file_success", "OK")
data['data'] = {'token': token, 'url': url}
return data
filename = id1 + get_db_time_str() + "." + filessuffix
filepath = os.path.join(rootdir, filename)
print(filepath)
files.save(filepath)
url = QRCODEHOSTNAME + "/file/" + filename
data = import_status("upload_file_success", "OK")
data['data'] = {'token': token, 'url': url}
return data
def update_order(self):
if not is_admin():
return AUTHORITY_ERROR
try:
data = request.json
oisn = data.get('oisn')
expressname = data.get('expressname')
expressnum = data.get('expressnum')
if not expressname or not expressnum:
raise dberror
except:
return PARAMS_ERROR
detail = get_model_return_dict(self.sorder.get_order_details(oisn))
if not detail:
return NOT_FOUND_ORDER
session = db_session()
try:
is_exits = get_model_return_dict(
session.query(OrderInfo.expressnum).filter(
OrderInfo.OIsn == oisn).first())
if is_exits['expressnum']:
update = {}
update['OIstatus'] = 2
update['expressname'] = expressname
update['expressnum'] = expressnum
session.query(OrderInfo).filter(
OrderInfo.OIsn == oisn).update(update)
else:
update = {}
update['OIstatus'] = 2
update['expressname'] = expressname
update['expressnum'] = expressnum
session.query(OrderInfo).filter(
OrderInfo.OIsn == oisn).update(update)
monthnow = datetime.strftime(datetime.now(),
format_for_db)[0:6]
amount_data = self.saccount.get_user_date(
detail['USid'], monthnow)
order = get_model_return_dict(
self.sorder.get_order_details(oisn))
user = self.smycenter.get_user_basicinfo(
detail['USid']) # 插入销售表，有数据就更新
if not user:
raise dberror
user = get_model_return_dict(user)
if not order:
raise dberror
if amount_data:
amount_data = get_model_return_dict(amount_data)
new_data = {}
new_data['performance'] = amount_data[
'performance'] + order['discountnum']
try:
session.query(Amount).filter(
Amount.USid == detail['USid']).filter(
Amount.AMmonth == monthnow).update(new_data)
except:
raise dberror
else:
amount = Amount()
amount.USid = detail['USid']
amount.AMid = str(uuid.uuid4())
amount.USagentid = user['USagentid']
amount.performance = order['discountnum']
amount.USname = user['USname']
amount.AMstatus = 1
amount.USheadimg = user['USheadimg']
amount.AMcreattime = datetime.strftime(
datetime.now(), format_for_db)
amount.AMmonth = monthnow
session.add(amount)
performance = Performance() # 插入业绩表
performance.USid = detail['USid']
performance.REmonth = datetime.strftime(
datetime.now(), format_for_db)[0:6]
performance.PEid = str(uuid.uuid4())
performance.PEdiscountnum = order['discountnum']
performance.PEcreatetime = datetime.strftime(
datetime.now(), format_for_db)
session.add(performance)
session.commit()
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.close()
reponse = import_status("update_order_success", "OK")
detail = get_model_return_dict(self.sorder.get_order_details(oisn))
from common.timeformat import get_web_time_str
detail['OIcreatetime'] = get_web_time_str(detail['OIcreatetime'])
product_list = get_model_return_list(
self.sorder.get_product_list(detail['OIid']))
detail['product_list'] = product_list
reponse['data'] = detail
return reponse
def create_order(self):
if is_tourist():
return TOKEN_ERROR
data = request.json
if not data:
return PARAMS_MISS
params_list = [
"UAid", "product_list", "OInote", "PRlogisticsfee", "totalprice"
]
for param in params_list:
if param not in data:
response = {}
response['message'] = u"参数缺失"
response['paramname'] = param
response['status'] = 405
return response
try:
UAid = data['UAid']
OInote = data['OInote']
product_list = data['product_list']
PRlogisticsfee = float(data['PRlogisticsfee'])
totalprice = float(data['totalprice'])
except:
return PARAMS_ERROR
real_PRlogisticsfee = 0
if len(product_list) == 1 and len(
product_list[0]['skulist']) == 1 and int(
product_list[0]['skulist'][0]['number']) == 1:
real_PRlogisticsfee = get_model_return_dict(
self.sgoods.get_product_details(
product_list[0]['PRid']))['PRlogisticsfee']
user_info = get_model_return_dict(
self.smycenter.get_user_basicinfo(request.user.id))
if not user_info:
return SYSTEM_ERROR
if user_info['USbail'] < float(self.conf.get('account', 'bail')):
return NO_BAIL
mount = 0
new_list = []
all_psid = []
discountnum = 0
product_num = 0
try:
for product in product_list:
check_product = get_model_return_dict(
self.sgoods.get_product_info(product['PRid']))
if not check_product:
return PRODUCT_OFFLINE
for sku in product['skulist']:
sku_info = get_model_return_dict(
self.sgoods.get_sku_status(sku['psid']))
if not sku_info:
return SKU_WRONG
if sku['number'] > sku_info['PSstock']:
return STOCK_NOT_ENOUGH
mount = mount + sku['number'] * check_product['PRprice']
product_num = product_num + sku['number']
discountnum = discountnum + sku['number'] * check_product[
'PAdiscountnum']
all_psid.append(sku['psid'])
product['PRprice'] = check_product['PRprice']
new_list.append(product)
if round(totalprice,
2) != round(mount + real_PRlogisticsfee,
2) or real_PRlogisticsfee != PRlogisticsfee:
response = {}
response['status'] = 200
response['success'] = False
response['data'] = new_list
response['PRlogisticsfee'] = real_PRlogisticsfee
response['totalprice'] = round(mount + real_PRlogisticsfee, 2)
return response
if user_info['USmount'] < round(mount + PRlogisticsfee, 2):
return NO_ENOUGH_MOUNT
except Exception as e:
print e
return SYSTEM_ERROR
session = db_session()
try:
OIid = str(uuid.uuid4())
OIsn = datetime.strftime(datetime.now(),
format_for_db) + get_random_int()
OIcreatetime = datetime.strftime(datetime.now(), format_for_db)
address = get_model_return_dict(
self.smycenter.get_other_address(request.user.id, 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']))
provincename = province['provincename']
cityname = city['cityname']
areaname = area['areaname']
details = address['UAdetails']
username = address['UAname']
userphonenum = address['UAphonenum']
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']))
provincename = province['provincename']
cityname = city['cityname']
areaname = None
details = address['UAdetails']
username = address['UAname']
userphonenum = address['UAphonenum']
result = self.sorder.add_order(session, OIid, OIsn,
request.user.id, OInote, mount,
UAid, OIcreatetime, PRlogisticsfee,
provincename, cityname, areaname,
details, username, userphonenum,
product_num, discountnum)
if not result:
raise dberror
# 插入订单商品详情表
for product in new_list:
OPIid = str(uuid.uuid4())
PRid = product['PRid']
PRname = product['PRname']
PRimage = get_model_return_dict(
self.sgoods.get_product(PRid))['PRpic']
PRprice = product['PRprice']
result = self.sorder.add_orderproductinfo(
session, OPIid, OIid, PRid, PRname, PRprice, PRimage)
if not result:
raise dberror
# 插入订单sku详情表
for sku in product['skulist']:
orderskuinfo = OrderSkuInfo()
orderskuinfo.OSIid = str(uuid.uuid4())
orderskuinfo.OPIid = OPIid
orderskuinfo.number = sku['number']
orderskuinfo.sizename = sku['sizename']
orderskuinfo.colorname = sku['colorname']
session.add(orderskuinfo)
sku_info = get_model_return_dict(
self.sgoods.get_sku_status(sku['psid']))
session.query(ProductSku).filter(ProductSku.PSid == sku['psid'])\
.update({"PSstock": sku_info['PSstock'] - sku['number']})
# 更改用户购物车商品状态
for psid in all_psid:
session.query(ShoppingCart).filter(ShoppingCart.USid == request.user.id).filter(ShoppingCart.PSid == psid)\
.update({"SCstatus": 0})
# 减余额并插入代理消息
user = {}
user['USmount'] = round(
user_info['USmount'] - round(mount + real_PRlogisticsfee, 2),
2)
session.query(User).filter_by(USid=request.user.id).update(user)
agentmessage = AgentMessage()
agentmessage.AMid = str(uuid.uuid4())
agentmessage.USid = request.user.id
agentmessage.AMdate = OIcreatetime
agentmessage.AMtype = 0
agentmessage.AMcontent = u'您的订单创建成功，订单号为' + ' ' + str(OIsn)
session.add(agentmessage)
moneyrecord = MoneyRecord() # 插入收支记录表
moneyrecord.MRid = str(uuid.uuid4())
moneyrecord.MRtype = 1
moneyrecord.OIid = OIsn
moneyrecord.MRamount = -(mount + real_PRlogisticsfee)
moneyrecord.MRcreatetime = datetime.strftime(
datetime.now(), format_for_db)
moneyrecord.USid = request.user.id
session.add(moneyrecord)
session.commit()
except stockerror as e:
session.rollback()
return STOCK_NOT_ENOUGH
except Exception as e2:
session.rollback()
print e2.message
return SYSTEM_ERROR
finally:
session.close()
response = import_status("create_order_success", "OK")
response['success'] = True
return response
def get_willsend_products(self):
if not is_admin():
return TOKEN_ERROR
# workbook = xlrd.open_workbook(r'/Users/fx/Desktop/项目相关/1.xls')
# print (workbook.sheet_names())
# sheet = workbook.sheet_names()[0]
# sheet_data = workbook.sheet_by_name(sheet)
# print(sheet_data)
# print (sheet_data.name, sheet_data.nrows, sheet_data.ncols)
# rows = sheet_data.row_values(0) # 获取第一行内容
# cols = sheet_data.col_values(0) # 获取第一列内容
# print (rows)
try:
data = request.json
oisnlist = data.get('oisnlist')
except:
return PARAMS_ERROR
new_oisn_list = []
for oisn in oisnlist:
order = get_model_return_dict(
self.sorder.get_order_details(str(oisn)))
if order['OIstatus'] == 1:
new_oisn_list.append(order)
style = xlwt.XFStyle()
font = xlwt.Font()
font.name = u'宋体'
font.bold = True
style.font = font
time_now = datetime.strftime(datetime.now(), format_for_db)
workbook = xlwt.Workbook(encoding='utf-8')
worksheet = workbook.add_sheet('sheet1')
# worksheet.write_merge()
worksheet.write(0, 0, label='订单号', style=style)
worksheet.write(0, 1, label='收货地址', style=style)
worksheet.write(0, 2, label='卖家备注', style=style)
worksheet.write(0, 3, label='发件人姓名', style=style)
worksheet.write(0, 4, label='发件人电话', style=style)
worksheet.write(0, 5, label='发件人地址', style=style)
worksheet.write(0, 6, label='发货商品', style=style)
font = xlwt.Font()
font.name = u'宋体'
font.bold = False
style.font = font
url = ''
session = db_session()
try:
if new_oisn_list:
for i, order in enumerate(new_oisn_list):
oisn = order['OIsn']
username = order['username']
phone = order['userphonenum']
provincename = order['provincename']
cityname = order['cityname']
areaname = order['areaname'] if order['areaname'] else ''
details = order['details']
address = username + ' ' + phone + ' ' + provincename + cityname + areaname + details
OInote = order['OInote']
product_list = get_model_return_list(
self.sorder.get_product_list(order['OIid']))
productname = self.get_product_name(product_list)
worksheet.write(i + 1, 0, label=oisn, style=style)
worksheet.write(i + 1, 1, label=address, style=style)
worksheet.write(i + 1, 2, label=OInote, style=style)
worksheet.write(i + 1,
3,
label=self.conf.get('account', 'sendname'),
style=style)
worksheet.write(i + 1,
4,
label=self.conf.get(
'account', 'sendphone'),
style=style)
worksheet.write(i + 1,
5,
label=self.conf.get(
'account', 'sendaddress'),
style=style)
session.query(OrderInfo).filter(
OrderInfo.OIsn == oisn).update({"OIstatus": 4})
worksheet.write(i + 1, 6, label=productname, style=style)
if platform.system() == "Windows":
rootdir = "D:/task"
else:
rootdir = "/opt/beili/file/"
if not os.path.isdir(rootdir):
os.makedirs(rootdir)
filename = get_db_time_str() + "." + 'xls'
filepath = os.path.join(rootdir, filename)
print(filepath)
workbook.save(filepath)
url = QRCODEHOSTNAME + "/file/" + filename
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.commit()
response = import_status("get_willsend_products_success", "OK")
response['data'] = url
return response
