def vipCallback(request):
void = request.GET.get("void", None)
if not void:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
void = int(void)
viporder = VIPOrder.objects.filter(void=void)
if not viporder:
return Jsonify({"status":False, "error":"1502", "error_message":u"订单不存在。"})
else:
viporder = viporder[0]
month = viporder.month
_user = User.objects.filter(uid=viporder.user.uid)
if not _user:
return Jsonify({"status":False, "error":"1502", "error_message":u"该订单不属于任何用户。"})
else:
_user = _user[0]
if not _user.vip:
_vip = VIP()
_vip.save()
_user.vip=_vip
_user.save()
viporder.state=1
viporder.save()
newPackage = VIPPackage(level = viporder.level, days = viporder.month*31)
_vip.addNewPackage(newPackage)
return Jsonify({"status":True, "vip":_vip.toDict()})
def complain(request):
_user = request.user
user = User.objects.filter(uid=user["uid"])
user = user[0]
oid = request.POST.get("oid", None)
notes = request.POST.get("notes", None)
if not oid or not notes:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
_order = Order.objects.filter(oid=oid)
if not _order:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
else:
_order = _order[0]
if _order.state!=5:
return Jsonify({"status":False, "error":"1303", "error_message":u"用户无权进行此操作。"})
else:
comp = Complaint(order_id=oid, user_id=_user["uid"], notes=notes, state=0)
comp.save()
_order.state = 9
itemList = _order.itemList
thingList = getThingList(itemList)
address = Address.objects.filter(adid=_order.addr_id)
if address:
address = address[0]
address = address.toDict()
else:
address=""
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "thinglist":thingList, "address":address, "detail":u"同仓存取快递费: 6元。"})
def getOrder(request):
oid = request.GET.get("oid", None)
checkPayment = request.GET.get("checkpayment", 0)
checkPayment = int(checkPayment)
_user = request.user
if not oid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
_order = Order.objects.filter(oid=oid)
if _order:
_order = _order[0]
if checkPayment==1 and int(_order.state)==0:
result = checkWechatOrder(_order.toDict(), 0)
payState = 0
root = ET.fromstring(result)
if root.find("return_code").text == "SUCCESS" and root.find("trade_state").text == "SUCCESS":
payState = 1
if payState == 1:
_order.state =1
_order.save()
else:
_order.state = 2
_order.save()
itemList = _order.itemList
thingList = getThingList(itemList)
address = Address.objects.filter(adid=_order.addr_id)
if address:
address = address[0]
address = address.toDict()
else:
address=""
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "address":address, "thinglist":thingList, "detail":u"同仓存取快递费: 6元。"})
else:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
def versionInfo(request):
typeid = 0
machine = request.GET.get("machine", "others")
#machine = unicode(machine)
if machine.upper() == "ANDROID":
typeid = 1
elif machine.upper() == "WEB":
typeid = 2
elif machine.upper() == "IOS":
typeid = 0
else:
typeid = 3
version = Version.objects.filter(typeid=typeid).filter(
state__gt=0).order_by('-vrid')
if version:
version = version[0]
keylist = {}
if version.compulsorylist:
for item in version.compulsorylist.strip(" ").split(","):
keylist[item] = "F"
if version.selectlist:
for item in version.selectlist.strip(" ").split(","):
keylist[item] = "S"
_version = model_to_dict(version)
del _version["compulsorylist"]
del _version["selectlist"]
_version["versionlist"] = keylist
return Jsonify({"status": True, "error": "", "version": _version})
else:
return Jsonify({
"status": False,
"error": 1602,
"error_message": "当前系统无可用版本。"
})
def changePassword(request):
# _user = request.user
password = request.POST.get("password", None)
phone = request.POST.get("phone", None)
code = request.POST.get("code", None)
if not password or not phone or not code:
return Jsonify({
"status": False,
"error": "1101",
"error_message": "信息不足, 请重新输入。"
})
_user = User.objects.filter(phone=phone)
if _user:
_user = _user[0]
user = model_to_dict(_user)
mobsms = MobSMS('148f6c0a15c12')
status = mobsms.verify_sms_code(86, phone, code)
logger.debug(status)
logger.debug(type(status))
if status == 200:
salt = Salt()
timestamp = str(int(math.floor(time.time())))
_hash = salt.hash(
salt.md5(password) + "|" + user['username'] + "|" + timestamp)
password = salt.md5(_hash + salt.md5(password))
_user.password = password
_user.salt = _hash
_user.save()
return Jsonify({"status": True, "error": "", "error_message": ""})
else:
return Jsonify({
"status": False,
"error": "1119",
"error_message": "验证码验证失败。"
})
else:
return Jsonify({
"status": False,
"error": "1113",
"error_message": "用户不存在。"
})
# if password == _user.password:
# return Jsonify({"status":False, "error":"1112", "error_message":"密码未改变， 请重新输入。"})
#重新生成password和salt存入数据库， 并将新的session发给客户端。
# salt = Salt()
# timestamp = str(int(math.floor(time.time())))
# _hash = salt.hash(salt.md5(user['password']) + "|" + user['username'] + "|" + timestamp)
# password = salt.md5(_hash+salt.md5(user['password']))
# _user.password = password
# _user.salt = _hash
# _user.save()
# user = model_to_dict(_user)
# user["session"] = updateSession(user)
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"user": dictPolish(user)
})
def vipOrder(request):
_user = request.user
ipaddr = request.POST.get("ipaddr", "127.0.0.1")
typeid = request.POST.get("typeid", None)
fee = request.POST.get("fee", None)
body = request.POST.get("body", "Unknown")
detail = request.POST.get("detail", "Unknown")
month = request.POST.get("month", None)
if not month or not typeid or not fee:
return Jsonify({
"status": False,
"error": "1101",
"error_message": u"输入信息不足。"
})
fee = float(fee)
month = int(month)
typeid = int(typeid)
server_fee = getVIPfee(month, typeid, typeid)
if fee != server_fee:
return Jsonify({
"status": False,
"error": "1510",
"error_message": u"费用有误，您的订单费用为" + str(server_fee) + u"元。",
"fee": server_fee
})
##Generate wechat preorder
_order = VIPOrder(month=month,
fee=fee,
user_id=_user['uid'],
level=typeid,
state=0)
_order.save()
result = unifyOrder(model_to_dict(_order), body, detail, ipaddr, 1)
prepayid = ""
try:
root = ET.fromstring(result)
if root.find("return_code").text == "SUCCESS":
prepayid = root.find("prepay_id").text
else:
return Jsonify({
"status": False,
"error": "1310",
"error_message": u"微信预支付失败，响应失败"
})
except Exception, e:
logger.error(e)
logger.error("1311 wechat order failed")
return Jsonify({
"status": False,
"error": "1311",
"error_message": u"微信预支付失败, 未知错误。"
})
def orderCallback(request):
oid = request.POST.get("oid", None)
_order = Order.objects.filter(oid=oid)
if not oid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
if not _order:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
_order = _order[0]
current_state = _order.state
if current_state == 0 or current_state == 2:
_order.state = 1
_order.paid_time = datetime.now()
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "detail":u"同仓存取快递费: 6元。"})
else:
return Jsonify({"status":False, "error":"1110", "order":_order.toDict(),"detail":u"同仓存取快递费: 6元。", "error_message":u"用户无权进行此操作。"})
def getOrderList(request):
typeid = request.GET.get("typeid", None)
stateid = request.GET.get("stateid", None)
page = request.GET.get("page", 0)
page = int(page)
_user = request.user
resultList = []
itemList = Order.objects.filter(user_id=_user['uid']).exclude(state=12).exclude(state=13).order_by('-oid')[PAGECOUNT*page:PAGECOUNT*(page+1)]
if typeid:
typeid=int(typeid)
itemList = itemList.filter(typeid)
if stateid:
stateid=int(stateid)
itemList = itemList.filter(stateid)
for item in itemList:
current_item = item.toDict()
current_address = Address.objects.filter(adid=item.addr_id)
if current_address:
current_address = current_address[0]
current_item["address"]=current_address.toDict()
else:
current_item["address"] = ""
resultList.append(current_item)
print resultList
return Jsonify({"status":True, "error":"", "error_message":"", "orderlist":resultList})
def communityList(request):
result = {}
for item in Community.objects.filter(state=1):
district = item.district_belong
city = district.city_belong
if city.name in result.keys():
if district.name in result[city.name][1].keys():
result[city.name][1][district.name][1].append(
model_to_dict(item))
else:
meta_district = model_to_dict(district)
result[city.name][1][district.name] = [
meta_district, [
model_to_dict(item),
]
]
else:
meta_city = model_to_dict(city)
meta_district = model_to_dict(district)
result[city.name] = [
meta_city, {
district.name: [meta_district, [
model_to_dict(item),
]],
}
]
return Jsonify({"status": True, "error": "", "data": result})
def activityList(request):
activities = Activity.objects.filter(state=1).order_by(
'-priority', '-acid')
resultList = []
for activity in activities:
resultList.append(model_to_dict(activity))
return Jsonify({"status": True, "error": "", "activittlist": resultList})
def modifyOrder(request):
oid = request.POST.get("oid", None)
addrid = request.POST.get("addrid", None)
if not oid or not addrid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
addrid = int(addrid)
_order = Order.objects.filter(oid=oid)
if not _order:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
else:
_order = _order[0]
_order.addr_id = addrid
_order.fee=6
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "detail":u"同仓存取快递费: 6元。"})
def update(request):
"""
Crucial interface.
need user group check. @1: User @0:Engineer
include PATH I：1(已支付)/2（支付处理中）->3(取/送件中)[->4（处理中)]->5(已送达)->6(已完成)
include PATH II: 9(已申诉)->6(已完成)
"""
#工程师， 一般用户， 管理员
STATE_ALLOWED = [[1, 3, 4, 5, 9], [5,9], [1, 3, 4]]
_user = request.user
oid = request.POST.get("oid", None)
origin = request.POST.get("origin", None)
if not oid or not origin:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
origin = int(origin)
_order = Order.objects.filter(oid=oid)
if not _order:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
_order = _order[0]
thingList = getThingList(_order.itemList)
address = Address.objects.filter(adid=_order.addr_id)
if address:
address = address[0]
address = address.toDict()
else:
address=""
current_state=_order.state
if origin!=current_state:
return Jsonify({"status":False, "error":"1305", "error_message":u"订单状态不一致, 已重新刷新该订单。", "order":_order.toDict(), "thinglist":thingList, "address":address})
gid = _user['gid']
if origin not in STATE_ALLOWED[gid]:
return Jsonify({"status":False, "error":"1110", "error_message":u"用户无权进行此操作。"})
state = 11
if current_state == 1:
_order.state = 3
if current_state == 3:
_order.state = 4
if current_state == 4:
_order.state = 5
if current_state == 5 or current_state == 9:
_order.state = 6
_order.finish_time = datetime.now()
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "thinglist":thingList, "address":address, "detail":u"同仓存取快递费: 6元。"})
def feedback(request):
_user = request.user
notes = request.POST.get("notes", None)
if not notes:
return Jsonify({
"status": False,
"error": 1101,
"error_message": "信息不足, 请重新输入。"
})
fdback = Feedback(notes=notes, user_id=_user['uid'], state=0)
fdback.save()
return Jsonify({
"status": True,
"feedback": model_to_dict(fdback),
"error": "",
"error_message": ""
})
def checkDiscount(request):
_user = request.user
discount = request.GET.get("discount", None)
discount = discount.upper()
disc = Discount.objects.filter(showcode=discount).filter(state=1)
if not disc:
return Jsonify({
"status": False,
"error": 1601,
"error_message": "优惠码不存在或优惠已过期, 请关注其它活动。"
})
disc = disc[0]
return Jsonify({
"status": True,
"error": "",
"error_message": disc.message
})
def getFeeList(request):
origin, current, discount = feeList()
return Jsonify({
"status": True,
"error": "",
"origin": origin,
"current": current,
"discount": discount
})
def delete(request):
FINISH_STATE = [0, 6, 7, 8, 10, 11, 12]
oid=request.POST.get("oid", None)
_user = request.user
if not oid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
_order = Order.objects.filter(oid=oid).filter(user_id=_user['uid'])
if not _order:
return Jsonify({"status":False, "error":"1110", "error_message":u"订单不存在或用户无权对此订单操作。"})
_order = _order[0]
if _order.state in FINISH_STATE:
_order.state=13
_order.save()
return Jsonify({"status":True, "error":"", "error_message":""})
else:
return Jsonify({"status":False, "error":"1306", "error_message":u"订单正在处理中, 暂不能删除。 如遇特殊情况, 请直接联系客服。"})
def loginByPhone(request):
"""
login by phone, return dynamic session.
"""
phone = request.POST.get('phone', None)
user_password = request.POST.get('password', None)
if not (phone and user_password):
return Jsonify({
"status": False,
"error": "1101",
"error_message": "信息不足, 请输入手机号和密码"
})
user = User.objects.filter(phone=phone)
salt = Salt()
if not user:
return Jsonify({
"status": False,
"error": "1107",
"error_message": "手机号未注册, 请首先注册。"
})
user = model_to_dict(user[0])
if user['password'] == salt.md5(user['salt'] + salt.md5(user_password)):
user['session'] = updateSession(user)
#some info is not allowed to be known by clients
del user['salt']
del user['password']
del user['register']
del user['loginIp']
del user['lastLogin']
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"user": dictPolish(user)
})
else:
return Jsonify({
"status": False,
"error": "1106",
"error_message": "密码有误, 请重新输入"
})
def getItemList(request):
#can only get one type of item
typeid = request.GET.get("typeid", None)
page = request.GET.get("page", 0)
page = int(page)
user = request.user
if typeid:
typeid = int(typeid)
itemList = Thing.objects.filter(user_belong_to_id=user['uid']).filter(
state=1).filter(typeid=typeid).order_by('-tid')[PAGECOUNT *
page:PAGECOUNT *
(page + 1)]
else:
itemList = Thing.objects.filter(user_belong_to_id=user['uid']).filter(
state=1).order_by('-tid')[PAGECOUNT * page:PAGECOUNT * (page + 1)]
resultList = []
if itemList or page > 0 or typeid:
logger.debug("GET HERE HOTTTTTT")
for item in itemList:
resultList.append(item.toDict())
else:
itemList = addPresent(user['uid'], 1, typeid)
for item in itemList:
resultList.append(item.toDict())
try:
return Jsonify({
"status": True,
"itemlist": resultList,
"error": "",
"error_message": ""
})
except Exception, e:
logger.error("!!!+2")
logger.error(e)
return Jsonify({
"status": True,
"itemlist": resultList,
"error": "",
"error_message": ""
})
def vip(request):
_user = request.user
unfinishedOrder = VIPOrder.objects.filter(user_id=_user['uid']).filter(
state=2)
if unfinishedOrder:
orderstate = 1
else:
orderstate = 0
if not _user["vip"]:
return Jsonify({
"status": False,
"state": False,
"error": "1501",
"error_message": "用户还不是会员, 请先加入会员。",
"processing": orderstate
})
_vip = VIP.objects.filter(vid=_user["vip"])
if _vip:
_vip = _vip[0]
_vip.flush()
return Jsonify({
"status": True,
"state": True,
"error": "",
"error_message": "",
"processing": orderstate,
"vip": _vip.toDict(),
"user": _user
})
else:
return Jsonify({
"status": False,
"state": False,
"error": "1501",
"error_message": "用户还不是会员, 请先加入会员。",
"processing": orderstate
})
def modifyNotes(request):
_notes = request.POST.get("notes", "")
tid = request.POST.get("tid", None)
_user = request.user
if not tid:
return Jsonify({
"status": False,
"error": 1101,
"error_message": "信息不足, 请输入备注。"
})
else:
thing = Thing.objects.filter(user_belong_to_id=_user['uid']).filter(
tid=tid)
if thing:
thing = thing[0]
thing.notes = _notes
thing.save()
else:
return Jsonify({
"status": False,
"error": 1201,
"error_message": "商品不存在。"
})
return Jsonify({"status": True, "error": "", "error_message": ""})
def confirmOrder(request):
oid = request.POST.get("oid", None)
fee = request.POST.get("fee", None)
notes = request.POST.get("notes", "")
ipaddr = request.POST.get("ipaddr", "127.0.0.1")
body = request.POST.get("body", "Unknown")
detail = request.POST.get("detail", "Unknown")
prepayid = request.POST.get("prepayid", None)
if not fee or not oid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
fee = float(fee)
_order = Order.objects.filter(oid=oid)
if not _order:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
else:
_order = _order[0]
_sign = ""
for i in range(8):
_sign = _sign + ALPHABET[random.randint(0, 62)]
_order.signature = _sign
if notes:
_order.notes = notes
if fee != _order.fee:
return Jsonify({"status":False, "error":"1303", "fee":fee, "order":_order.toDict(), "error_message":u"订单价格有误， 请重新下单。"})
##wechat order
if fee==0:
_order.paid_time=datetime.now()
_order.state=1
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "detail":u"会员免运费: 0元。"})
else:
_order.state=0
result = unifyOrder(_order.toDict(), body, detail, ipaddr, 0)
if not prepayid:
try:
root = ET.fromstring(result)
if root.find("return_code").text == "SUCCESS":
prepayid = root.find("prepay_id").text
else:
return Jsonify({"status":False, "error":"1310", "error_message":u"微信预支付失败，响应失败"})
_order.prepayid = prepayid
_order.save()
except Exception, e:
logger.error(e)
logger.error("1311 微信预支付失败， 未知错误")
return Jsonify({"status":False, "error":"1311", "error_message":u"微信预支付失败, 未知错误。"})
#为iOS准备调起支付所需的参数
data = iosOrder(prepayid)
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "data":data, "detail":u"同仓存取快递费: 6元。"})
def addressList(request):
_user = request.user
addressList = Address.objects.filter(user_id=_user['uid']).filter(state=1)
resultList = []
for address in addressList:
address = address.toDict()
address["addrid"] = address["adid"]
del (address["user"])
del (address["adid"])
resultList.append(address)
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"addresslist": resultList
})
def cancel(request):
oid = request.POST.get("oid", None)
if not oid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
oid = int(oid)
_order = Order.objects.filter(oid=oid)
if not _order:
return Jsonify({"status":False, "error":"1302", "error_message":u"订单不存在。"})
else:
_order = _order[0]
state = _order.state
if state <= 2:
_order.state = 7
itemList = _order.itemList
thingList = getThingList(itemList)
address = Address.objects.filter(adid=_order.addr_id)
if address:
address = address[0]
address = address.toDict()
else:
address=""
if _order.fee != 0:
#微信退款
#refundstate = Wechat.refund()
refundstate=True
if refundstate:
_order.state=8
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "thinglist":thingList, "address":address, "detail":u"同仓存取快递费: 6元。"})
else:
_order.save()
return Jsonify({"status":False, "error":"1304", "error_message":u"微信退款失败，请联系客服。"})
else:
_order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":_order.toDict(), "thinglist":thingList, "address":address, "detail":u"同仓存取快递费: 6元。"})
else:
return Jsonify({"status":False, "error":"1303", "error_message":u"用户无权进行此操作。"})
def register(request):
"""
Interface that allows user to register using phone number.
Parameters:
@request: Http Request.
Returns:
@result: Http Response in JSON.
"""
user = {"gid": 1, "version": "1.0 User"}
invite = request.POST.get("invite", None)
user['phone'] = request.POST.get("phone", None)
randCount = random.randint(1000, 10000)
user['nickname'] = request.POST.get("nickname", u"邻仓客" + str(randCount))
while True:
randCount = random.randint(1000, 10000)
user['nickname'] = u"邻仓客" + str(randCount)
userList = User.objects.filter(nickname=user['nickname'])
if not userList:
break
user['password'] = request.POST.get("password", None)
gid = request.POST.get("gid", None)
code = request.POST.get("code", None)
if gid:
user['gid'] = gid
if not (user['password'] and user['phone'] and invite and code):
return Jsonify({
"status": False,
"error": "1101",
"error_message": "信息不足, 请重新输入。"
})
code = int(code)
invite = invite.upper()
inviteObject = InviteCode.objects.filter(code=invite).filter(state=0)
if not inviteObject:
return Jsonify({
"status": False,
"error": "1116",
"error_message": "邀请码不存在。"
})
_user = User.objects.filter(phone=user['phone'])
if _user:
return Jsonify({
"status": False,
"error": "1105",
"error_message": "手机号已注册, 请直接登录"
})
else:
mobsms = MobSMS('148f6c0a15c12')
status = mobsms.verify_sms_code(86, user['phone'], code)
if not status == 200:
return Jsonify({
"status": False,
"error": "1113",
"error_message": "验证码验证失败。"
})
user['loginIp'] = get_client_ip(request)
user['registerTime'] = datetime.now()
user['birthday'] = request.POST.get("birthday", "")
gender = request.POST.get("gender", 2)
user['gender'] = int(gender)
avatar = request.FILES.get("avatar", None)
if avatar:
user['avatar'] = 1
#Upload the avatar here.
else:
user['avatar'] = 0
salt = Salt()
#username在注册时确定， 此后不再改变。
user['username'] = "******" + salt.generateSalt(10) + "@sharecloud.com"
timestamp = str(int(math.floor(time.time())))
_hash = salt.hash(
salt.md5(user['password']) + "|" + user['username'] + "|" + timestamp)
password = salt.md5(_hash + salt.md5(user['password']))
currentUser = User(gid=user["gid"],
phone=user['phone'],
nickname=user['nickname'],
gender=user['gender'],
birthday=user['birthday'],
register=user['registerTime'],
lastLogin=user['registerTime'],
loginIp=user['loginIp'],
avatar=user['avatar'],
salt=_hash,
password=password,
username=user['username'])
currentUser.save()
user['uid'] = currentUser.uid
user['session'] = createSession(user)
if avatar:
currentPath = AVATARPATH + str(user['uid']) + ".png"
data = ""
for chunk in avatar.chunks():
data += chunk
try:
state = Picture().uploadPicture(currentPath, data)
if state:
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"user": user
})
else:
logger.error("1109 UPYUN UPLOAD FAILED")
try:
_user = User.objects.get(uid=user['uid'])
_user.avatar = False
_user.save()
except Exception, e:
logger.error(e)
logger.error("1109 User Acquirement Fail")
return Jsonify({
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。",
"user": user
})
except Exception, e:
logger.error("upload error")
logger.error(e)
return Jsonify({
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。"
})
def address(request):
_user = request.user
if request.method == 'POST':
addr = request.POST.get("addr", None)
name = request.POST.get("name", None)
gender = request.POST.get("gender", None)
phone = request.POST.get("phone", None)
tag = request.POST.get("tag", None)
is_default = request.POST.get("isdefault", 0)
addrid = request.POST.get("addrid", None)
cmid = request.POST.get("cmid", None)
def_address = Address.objects.filter(user_id=_user['uid']).filter(
is_default=1)
if def_address:
def_address = def_address[0]
else:
def_address = None
if not addrid:
#生成新的地址信息
if not addr or not name or not gender or not cmid or not phone:
return Jsonify({
"status": False,
"error": "1101",
"error_message": "信息不足。"
})
if not def_address:
is_default = 1
if is_default == u"1" and def_address:
def_address.is_default = 0
def_address.save()
address = Address(phone=phone,
addr=addr,
name=name,
gender=gender,
is_default=is_default,
user_id=_user['uid'],
state=1,
community_belong_id=cmid)
if tag:
address.tagid = tag
address.save()
else:
#修改id为addrid的地址的部分信息
address = Address.objects.filter(adid=addrid).filter(state=1)
if not address:
return Jsonify({
"status": False,
"error": "1111",
"error_message": "地址不存在。"
})
else:
address = address[0]
if phone:
address.phone = phone
if name:
address.name = name
if gender:
address.gender = gender
if tag:
address.tagid = tag
if addr:
address.addr = addr
if cmid:
address.community_belong_id = cmid
if is_default == "1":
if def_address:
def_address.is_default = 0
def_address.save()
address.is_default = 1
address.save()
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"address": address.toDict()
})
if request.method == 'GET':
addrid = request.GET.get("addrid")
if not addrid:
return Jsonify({
"status": False,
"error": "1101",
"error_message": "信息不足。"
})
else:
addrid = int(addrid)
address = Address.objects.filter(adid=addrid)
if not address:
return Jsonify({
"status": False,
"error": "1111",
"error_message": "地址不存在。"
})
else:
address = address[0]
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"address": address.toDict()
})
"user": user
})
except Exception, e:
logger.error("upload error")
logger.error(e)
return Jsonify({
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。"
})
del (user['registerTime'])
del (user['loginIp'])
del (user['password'])
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"user": dictPolish(user)
})
def sendCode(request):
"""
Generate and save code, send by message to user.
This code can never be sent or saved by client.
"""
phone = request.GET.get("phone", None)
code = request.GET.get("code", None)
if not phone or not code:
return Jsonify({
"status": False,
"error": "1101",
def vipConfirm(request):
_user = request.user
_vip = VIP.objects.filter(vid=_user["vip"])
if _vip:
_vip = _vip[0]
_vip.flush()
vip_info = _vip.toDict()
else:
_vip = None
vip_info = {}
has_processing_order = False
unfinishedOrder = VIPOrder.objects.filter(user_id=_user['uid']).filter(
state=2)
if unfinishedOrder:
has_processing_order = True
void = request.GET.get("void", None)
if not void:
return Jsonify({
"status": False,
"error": "1101",
"error_message": u"输入信息不足。",
"processing": has_processing_order,
"vip": vip_info,
"state": bool(vip_info)
})
_order = VIPOrder.objects.filter(void=void)
if not _order:
return Jsonify({
"status": False,
"error": "1502",
"error_message": u"订单不存在。",
"processing": has_processing_order,
"vip": vip_info,
"state": bool(vip_info)
})
_order = _order[0]
if _order.state == 1:
return Jsonify({
"status": True,
"error": "",
"error_message": u"",
"processing": 0,
"vip": vip_info,
"state": bool(vip_info)
})
else:
result = checkWechatOrder(model_to_dict(_order), 1)
try:
root = ET.fromstring(result)
if root.find("return_code").text == "SUCCESS" and root.find(
"trade_state").text == "SUCCESS":
_order.state = 1
_order.save()
newPackage = VIPPackage(level=_order.level,
days=_order.month * 31)
if not _vip:
_vip = VIP()
_vip.save()
user = User.objects.filter(uid=_user["uid"])[0]
user.vip = _vip
user.save()
_vip.addNewPackage(newPackage)
vip_info = _vip.toDict()
return Jsonify({
"status": True,
"error": "",
"error_message": u"",
"state": bool(vip_info),
"vip": vip_info,
"processing": 0
})
else:
_order.state = 2
_order.save()
return Jsonify({
"status": True,
"error": "",
"error_message": u"",
"state": bool(vip_info),
"vip": vip_info,
"processing": 1
})
except Exception, e:
logger.error(e)
return Jsonify({
"status": False,
"error": "1512",
"error_message": u"微信查询失败。",
"processing": 1,
"vip": vip_info,
"state": bool(vip_info)
})
except Exception, e:
logger.error(e)
logger.error("1311 wechat order failed")
return Jsonify({
"status": False,
"error": "1311",
"error_message": u"微信预支付失败, 未知错误。"
})
_order.prepayid = prepayid
_order.save()
#为iOS准备调起支付所需的参数
data = iosOrder(prepayid)
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"order": model_to_dict(_order),
"data": data
})
@UserAuthorization
def vipConfirm(request):
_user = request.user
_vip = VIP.objects.filter(vid=_user["vip"])
if _vip:
_vip = _vip[0]
_vip.flush()
vip_info = _vip.toDict()
else:
_vip = None
def addNewItem(request):
character = request.POST.get("character", u'未知')
timeAdd = datetime.now()
typeid = request.POST.get("typeid", 7)
typeid = int(typeid)
gender = request.POST.get("gender", 2)
gender = int(gender)
avatar = request.FILES.get("avatar", None)
if avatar:
_hasAvatar = 1
else:
_hasAvatar = 0
subtype_name = request.POST.get("subname", u"未知")
user_belong_to_id = request.POST.get("uid", None)
wh_in_id = request.POST.get("whid", None)
_name = TYPECONSTANT[typeid] + "-" + subtype_name + "-" + character
if not user_belong_to_id or not wh_in_id:
return Jsonify({
"status": False,
"error": 1101,
"error_message": "信息不足, 请输入用户id以及仓库id。"
})
thing = Thing(avatar=_hasAvatar,
name=_name,
time_saved=timeAdd,
typeid=typeid,
gender=gender,
subtype_name=subtype_name,
user_belong_to_id=user_belong_to_id,
wh_in_id=wh_in_id,
state=1)
thing.save()
_tid = thing.tid
thing = model_to_dict(thing)
del (thing['time_saved'])
del (thing['state'])
del (thing['user_belong_to'])
if False:
currentPath = AVATARPATH + str(_tid) + ".png"
data = ""
for chunk in avatar.chunks():
data += chunk
try:
state = Picture().uploadPicture(currentPath, data)
if state:
return Jsonify({
"status": True,
"error": "",
"error_message": "",
"tid": _tid
})
else:
logger.error("1109 UPYUN UPLOAD FAILED")
try:
_user = User.objects.get(uid=user['uid'])
_user.avatar = False
_user.save()
except Exception, e:
logger.error(e)
logger.error("1109 User Acquirement Fail")
return Jsonify({
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。",
"thing": thing
})
except Exception, e:
logger.error("upload error")
logger.error(e)
return Jsonify({
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。"
})
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。",
"thing": thing
})
except Exception, e:
logger.error("upload error")
logger.error(e)
return Jsonify({
"status": False,
"error": "1109",
"error_message": "图片上传失败, 使用默认图片。"
})
return Jsonify({
"status": True,
"thing": thing,
"error": "",
"error_message": ""
})
@UserAuthorization
def modifyNotes(request):
_notes = request.POST.get("notes", "")
tid = request.POST.get("tid", None)
_user = request.user
if not tid:
return Jsonify({
"status": False,
"error": 1101,
"error_message": "信息不足, 请输入备注。"
})
