def onCall(self, **kwargs):
print "GetBillHandler"
billId = kwargs["billId"]
bill = yield Bill.get(billId)
if bill:
self.finish(DataProtocol.getSuccessJson(bill.to_client()))
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
getUserId = kwargs["getUserId"]
location = yield Location.get_collection().find({"userId":getUserId}).sort([("timestamp", -1)]).limit(1).to_list(1)
if location:
self.write(DataProtocol.getSuccessJson(location[0], "json"))
else:
self.write(DataProtocol.getJson(DataProtocol.DB_ERROR,"找不到该用户的地理位置"))
def onCall(self, **kwargs):
billId = self.get_argument("billId", None)
toUserId = self.get_argument("toUserId", None)
user = yield self.getUser()
#通过单发送请求
print "request bill id:", billId
hBill = yield HistoryBill.objects({
"id": billId,
"state": BillState.WAIT
}).one()
if hBill:
if hBill.senderId:
sender = yield User.get(hBill.senderId)
if not sender:
self.finish(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
return
elif sender.level != UserLevel.MANAGER:
req = PendingRequest()
req.reqType = RequestType.HistoryBill
req.reqUser = user.id
req.reqUserType = self.getUserType()
req.reqBill = hBill.id
req.respUser = sender.id
req.respUserType = hBill.senderType
print "pickBill req save!"
yield req.save()
self.finish(DataProtocol.getSuccessJson())
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
billId = self.get_argument("billId", None)
toUserId = self.get_argument("toUserId", None)
user = yield self.getUser()
#通过单发送请求
print "request bill id:", billId
hBill = yield HistoryBill.objects({"id":billId, "state":BillState.WAIT}).one()
if hBill:
if hBill.senderId:
sender = yield User.get(hBill.senderId)
if not sender:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
return
elif sender.level != UserLevel.MANAGER:
req = PendingRequest()
req.reqType = RequestType.HistoryBill
req.reqUser = user.id
req.reqUserType = self.getUserType()
req.reqBill = hBill.id
req.respUser = sender.id
req.respUserType = hBill.senderType
print "pickBill req save!"
yield req.save()
self.finish(DataProtocol.getSuccessJson())
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
username, phoneNum = self.get_argument("username",
None), self.get_argument(
"phoneNum", None)
inviteNum = self.get_argument("inviteNum", None)
psw = kwargs["password"]
if username or phoneNum:
# sameUser = yield User.get_collection().find_one(qOr(username=username, phoneNum=phoneNum))
sameUser = yield User.objects({
"$or": [{
"username": username
}, {
"phoneNum": phoneNum
}]
}).one()
if sameUser:
self.finish(
DataProtocol.getJson(DataProtocol.USER_EXISTED_ERROR,
"用户已经存在"))
else:
user = User(username, phoneNum, encryptPassword(psw))
user.regtime = time.time()
yield user.save()
#注册完马上给个登录态
self.set_secure_cookie("userid", str(user.id))
self.set_secure_cookie("mark", getMark(user.id))
self.finish(
DataProtocol.getSuccessJson(user.to_client(), "json"))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
print "GetBillHandler"
billId = kwargs["billId"]
bill = yield Bill.get(billId)
if bill:
self.finish(DataProtocol.getSuccessJson(bill.to_client()))
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
fromId = self.get_argument("fromId", None)
isPrev = self.get_argument("isPrev", None)
try:
fromObjId = ObjectId(fromId) if fromId else None
isPrevBool = bool(isPrev) and bool(str(isPrev).lower() == "true")
print "get history:", fromId, "is prev:", isPrev
user = yield self.getUser()
historyBills = yield user.getHistoryBill(self.getUserType(),
fromObjId, isPrevBool)
toReturn = []
for hBill in historyBills:
#如果历史单据是正常的用户发送的，返回用户数据，否则返回一个临时用户的数据
sender = (yield User.get(
hBill.senderId,
hBill.senderType)) if hBill.senderId else None
senderData = sender.to_user_base_data() if sender else None
hBill = createReturnHistoryBill(hBill, senderData)
toReturn.append(hBill)
print "return %d history bills" % len(toReturn)
self.write(DataProtocol.getSuccessJson(toReturn))
except ValueError:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
username = self.get_argument("username", None)
phoneNum = self.get_argument("phoneNum", None)
psw = self.get_argument("password", None)
userinput = username or phoneNum
if userinput:
encryptPsw = encryptPassword(psw)
query = {"$or":[{"username": userinput, "psw": encryptPsw}, {"phoneNum": userinput, "psw": encryptPsw}]}
user = yield User.objects(query).one()
if user:
if user.nickName:
self.set_cookie("nickName", user.nickName)
elif user.username:
self.set_cookie("nickName", user.username)
elif user.phoneNum:
self.set_cookie("nickName", user.phoneNum)
self.set_secure_cookie("userid", str(user.id))
self.set_secure_cookie("mark", getMark(user.id))
userData = user.to_client()
userData["userId"] = userData.pop("id")
control = yield getClientControl()
dataToClient = {"user":userData, "control":control}
self.finish(DataProtocol.getSuccessJson(dataToClient,"json"))
else:
self.finish(DataProtocol.getJson(DataProtocol.LOGIN_FAIL,"手机号码或者密码错误，登录失败"))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
billId = self.get_argument("billId", None)
toUserId = self.get_argument("toUserId", None)
if not billId and not toUserId:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
return
user = yield self.getUser()
req = PendingRequest()
req.reqType = RequestType.Bill
req.reqUser = user.id
req.reqUserType = self.getUserType()
if billId:
#通过单发送请求
print "request bill id:", billId
bill = yield Bill.objects({"id":billId, "state":BillState.WAIT}).one()
if bill:
sender = None
if bill.sender:
sender = yield User.get(bill.sender)
if not sender:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
return
elif sender.level != UserLevel.MANAGER:
req.reqBill = bill.id
req.respUser = sender.id
req.respUserType = bill.getSenderType()
print "pickBill req save!"
yield req.save()
#####？bill没有sender 或者是管理员发送的单子的话就利用bill上面的数据来生成历史单据
if not sender or (sender and sender.level == UserLevel.MANAGER):
sender = User()
sender.nickName = bill.senderName
sender.currType = matchUserType(bill.billType)
historyBill = createHistoryBill(sender, bill)
hbid = yield historyBill.save()
user.getAttr("HistoryBills").append(hbid)
yield user.save()
yield bill.remove()
BillMatchController().removeBill(bill)
#返回不是有效的对象，告诉客户端直接存历史，不需要发请求给对方
self.finish(DataProtocol.getJson(DataProtocol.USER_INVALID, "bill from manager", createReturnHistoryBill(historyBill)))
return
else:
# 发送请求给本地司机
print "bill removed"
self.finish(DataProtocol.getJson(DataProtocol.BILL_REMOVED))
return
elif toUserId:
respUser = yield User.get(toUserId)
req.respUser = respUser.id
yield req.save()
self.finish(DataProtocol.getSuccessJson())
def onCall(self, **kwargs):
print "get bill confirm:", kwargs["billId"]
bill = yield Bill.get(kwargs["billId"])
if not bill:
self.finish(DataProtocol.getJson(DataProtocol.BILL_REMOVED))
elif bill.state == BillState.WAIT:
self.finish(DataProtocol.getSuccessJson())
else:
self.finish(DataProtocol.getJson(DataProtocol.BILL_NOT_WAIT))
def onCall(self, **kwargs):
billId = kwargs["billId"]
bill = yield Bill.get(billId)
if bill:
bill.update(**kwargs)
yield bill.save()
self.finish(DataProtocol.getSuccessJson(bill.to_client()))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR, "订单不存在"))
def onCall(self, **kwargs):
print "get bill confirm:", kwargs["billId"]
bill = yield Bill.get(kwargs["billId"])
if not bill:
self.finish(DataProtocol.getJson(DataProtocol.BILL_REMOVED))
elif bill.state == BillState.WAIT:
self.finish(DataProtocol.getSuccessJson())
else:
self.finish(DataProtocol.getJson(DataProtocol.BILL_NOT_WAIT))
def get(self):
service = self.getDbService()
item = service.mongo.trunkDb.a56135Url.find_one({"read": {'$ne': 1}})
if item:
item["read"] = 1
service.mongo.trunkDb.a56135Url.update({"_id": item["_id"]}, item)
self.write(DataProtocol.getSuccessJson(item["url"], "string"))
else:
self.write(DataProtocol.getSuccessJson("nothing", "string"))
def onCall(self, **kwargs):
print "************get confirm request id:", kwargs["reqId"]
req = yield PendingRequest.get(kwargs["reqId"])
req.state = PendingReqState.FINISHED
yield req.save()
reqBill = yield Bill.objects({
"id": req.reqBill,
"state": BillState.WAIT
}).one()
if reqBill:
requestUser = yield User.get(req.reqUser, req.reqUserType)
responseUser = yield User.get(req.respUser, req.respUserType)
if requestUser and responseUser:
config = yield Config.shared()
locateValidSec = config.locateValidSec
#根据请求的信息生成双方的历史单据
senderHistoryBill = createHistoryBill(responseUser, reqBill,
locateValidSec)
shbId = yield senderHistoryBill.save()
receiverHistoryBill = createHistoryBill(
requestUser, reqBill, locateValidSec)
rhbId = yield receiverHistoryBill.save()
#add each of the users a historybill.
if shbId and rhbId:
#双方添加历史单据
requestUser.getAttr("HistoryBills").append(shbId)
yield requestUser.save()
responseUser.getAttr("HistoryBills").append(rhbId)
yield responseUser.save()
yield responseUser.billDone(reqBill)
BillMatchController().removeBill(reqBill)
#反馈成功的信息给之前发起请求的一方
if requestUser.getAttr("JPushId"):
msg = createBillConfirmMsg(str(requestUser.id),
responseUser.nickName,
str(reqBill.id))
print "---push confirm...", requestUser.getAttr(
"JPushId"), "msg: ", msg
JPushToId(requestUser.getAttr("JPushId"), None, msg,
req.reqUserType)
self.finish(
DataProtocol.getSuccessJson(reqBill.to_client()))
else:
self.finish(DataProtocol.getJson(DataProtocol.DB_ERROR))
else:
self.finish(
DataProtocol.getJson(DataProtocol.DB_ERROR,
"can'find user"))
else:
self.finish(DataProtocol.getJson(DataProtocol.BILL_REMOVED))
yield req.remove()
def onCall(self, **kwargs):
getUserId = kwargs["getUserId"]
location = yield Location.get_collection().find({
"userId": getUserId
}).sort([("timestamp", -1)]).limit(1).to_list(1)
if location:
self.write(DataProtocol.getSuccessJson(location[0], "json"))
else:
self.write(
DataProtocol.getJson(DataProtocol.DB_ERROR, "找不到该用户的地理位置"))
def post(self):
service = self.getDbService()
id = self.get_argument("id", None)
ret = service.giveupMessage(id)
if ret:
self.write(DataProtocol.getSuccessJson())
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"args is invalid"))
def onCall(self, **kwargs):
billId = kwargs["billId"]
bill = yield Bill.get(billId)
if bill:
bill.update(**kwargs)
yield bill.save()
self.finish(DataProtocol.getSuccessJson(bill.to_client()))
else:
self.finish(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR, "订单不存在"))
def post(self):
id = self.get_argument("id", None)
if id:
service = self.getDbService()
ret = service.confirmMessage(id)
self.write(DataProtocol.getSuccessJson(ret, "string"))
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"args is invalid"))
def post(self):
service = self.getDbService()
id = self.get_argument("id", None)
if not id is None:
ret = service.modifyMessage(id)
self.write(DataProtocol.getSuccessJson())
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"args is invalid"))
def get(self):
service = self.getDbService()
userid = self.getCurrentUser()
user = service.getAdmin(userid)
mylog.getlog().info(getLogText("GetAdminHandler user", user))
if user:
self.write(DataProtocol.getSuccessJson(user, "json"))
else:
self.write(DataProtocol.getJson(DataProtocol.DB_ERROR))
def post(self):
billid = self.get_argument("billid", None)
if billid:
service = self.getDbService()
if service:
service.removeBill(billid)
self.write(DataProtocol.getSuccessJson())
self.finish()
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
self.finish()
def post(self):
billid = self.get_argument("billid", None)
if billid:
service = self.getDbService()
if service:
service.removeBill(billid)
self.write(DataProtocol.getSuccessJson())
self.finish()
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
self.finish()
def get(self):
username = self.getCurrentUsername()
if username:
service = self.getDbService()
ret = service.getRefuseMessage(username)
self.write(DataProtocol.getSuccessJson(ret, "json"))
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"args is invalid"))
def post(self):
billid = self.get_argument("billid", None)
receiver = self.get_argument("receiver", None)
if receiver and billid:
service = DbService()
service.connect()
service.connectBills(billid, receiver)
self.write(DataProtocol.getSuccessJson())
self.finish()
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
self.finish()
def post(self):
billid = self.get_argument("billid", None)
receiver = self.get_argument("receiver", None)
if receiver and billid:
service = DbService()
service.connect()
service.connectBills(billid, receiver)
self.write(DataProtocol.getSuccessJson())
self.finish()
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
self.finish()
def post(self):
inviteFrom = self.get_argument("from", None)
inviteTo = self.get_argument("to", None)
service = self.getDbService()
billFrom = service.getBillById(inviteFrom)
billTo = service.getBillById(inviteTo)
if billFrom and billTo and billFrom["billType"] != billTo["billType"] and billFrom["state"] == "wait" and \
billTo["state"] == "wait":
service.inviteBill(billFrom, billTo)
self.write(DataProtocol.getSuccessJson())
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def post(self):
id = self.get_argument("id", None)
reason = self.get_argument("reason", None)
if id:
service = self.getDbService()
print "reason", reason
ret = service.refuseMessage(id, reason)
self.write(DataProtocol.getSuccessJson(ret, "string"))
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"args is invalid"))
def post(self):
inviteFrom = self.get_argument("from", None)
inviteTo = self.get_argument("to", None)
service = self.getDbService()
billFrom = service.getBillById(inviteFrom)
billTo = service.getBillById(inviteTo)
if billFrom and billTo and billFrom["billType"] != billTo["billType"] and billFrom["state"] == "wait" and \
billTo["state"] == "wait":
service.inviteBill(billFrom, billTo)
self.write(DataProtocol.getSuccessJson())
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def post(self):
service = self.getDbService()
id = self.get_argument("id", None)
if (not id is None):
mylog.getlog().info(getLogText("id", id))
username = self.getCurrentUsername()
service.doneToAddMessage(id, username)
self.write(DataProtocol.getSuccessJson("ok", "json"))
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"id is invaill"))
def post(self):
service = self.getDbService()
data = self.get_argument("data", None)
data = data.encode("utf-8")
if data:
dataJSON = json.loads(data)
for item in dataJSON:
service.mongo.trunkDb.grab51YunliCol.update(
{"phonenum": item["phonenum"]}, item, True)
print item
self.write(DataProtocol.getSuccessJson("nothing", "string"))
else:
self.write(DataProtocol.getSuccessJson("fail", "string"))
def post(self):
realname = self.get_argument("realname", None)
bankName = self.get_argument("bankName", None)
phoneNum = self.get_argument("phoneNum", None)
bankNum = self.get_argument("bankNum", None)
service = self.getDbService()
userid = self.getCurrentUser()
if userid:
service.updateAdmin(userid, realname, phoneNum, bankName, bankNum)
self.write(DataProtocol.getSuccessJson())
else:
self.write(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
print "get bills", kwargs["billIds"]
try:
billIds = json.loads(kwargs["billIds"])
bills = []
for id in billIds:
bill = yield Bill.get(id)
if bill:
bills.append(bill.to_client())
self.finish(DataProtocol.getSuccessJson(bills))
except Exception, e:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
raise Return(None)
def onCall(self, **kwargs):
print "get bills", kwargs["billIds"]
try:
billIds = json.loads(kwargs["billIds"])
bills = []
for id in billIds:
bill = yield Bill.get(id)
if bill:
bills.append(bill.to_client())
self.finish(DataProtocol.getSuccessJson(bills))
except Exception, e:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
raise Return(None)
def post(self):
username = self.get_argument("username", None)
psw = self.get_argument("password", None)
realname = self.get_argument("realname", None)
bankName = self.get_argument("bankName", None)
phoneNum = self.get_argument("phoneNum", None)
bankNum = self.get_argument("bankNum", None)
mylog.getlog().info(
getLogText("RegisterHandler", username, psw, realname, phoneNum,
bankName, bankNum))
if username and psw:
service = self.getDbService()
# self.set_secure_cookie("mark", getmark(user))
#开放注册的flag
if False:
self.write(
DataProtocol.getJson(DataProtocol.USER_EXISTED_ERROR,
"不允许注册了，请与管理员联系"))
return
else:
if not service.hasAdmin(username):
# print "register new admin:", username
service.addAdmin(username, encryptPassword(psw), realname,
phoneNum, bankName, bankNum)
#注册后顺便登录
user = service.confirmAdmin(username, encryptPassword(psw))
if user:
self.set_secure_cookie("userid", str(user["_id"]))
self.set_secure_cookie("username",
str(user["username"]))
self.set_secure_cookie("mark", getMark(user["_id"]))
# print str(username)
# print getMark(username)
self.write(DataProtocol.getSuccessJson(user, "json"))
else:
self.write(
DataProtocol.getJson(DataProtocol.USER_EXISTED_ERROR,
"管理员已经存在"))
else:
self.write(
DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR,
"missing username or password"))
class GetRecordBillHandler(BaseHandler):
returnOnce = 5
returnLimit = 50
optionalParams = {"fromId": unicode}
@auth
@coroutineDebug
@coroutine
def onCall(self, **kwargs):
mylog.getlog().info(getLogText("get record bills"))
user = yield self.getUser()
fromId = self.get_argument("fromId", None)
fromObjId = ObjectId(fromId) if fromId else None
record = user.getAttr("BillsRecord")
record.reverse()
fromIndex = 0
try:
if fromObjId:
fromIndex = record.index(fromObjId) + 1
except Exception, e:
pass
mylog.getlog().info(getLogText("from index: ", fromIndex))
slice = record[fromIndex:fromIndex +
self.returnOnce] if fromIndex < len(record) else []
bills = [(yield Bill.get(id)) for id in slice]
billsToReturn = [bill.to_client() for bill in bills if bill]
self.finish(DataProtocol.getSuccessJson(billsToReturn))
def get(self):
service = self.getDbService()
keyword = self.get_argument("keyword", None)
username = self.getCurrentUsername()
self.write(
DataProtocol.getSuccessJson(
service.getToAddMessage(keyword, username), "json"))
def onCall(self, **kwargs):
returnData, sendedUsers = [], []
try:
billIds = json.loads(kwargs["billIds"])
except Exception, e:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
raise Return(None)
def onCall(self, **kwargs):
req = yield PendingRequest.get(kwargs["reqId"])
req.state = PendingReqState.FINISHED
yield req.save()
sender = yield User.get(req.reqUser, req.reqUserType)
receiver = yield User.get(req.respUser, req.respUserType)
if sender and sender.getAttr("JPushId"):
bill = yield HistoryBill.get(req.reqBill)
if bill:
bill.state = BillState.DONE
yield bill.save()
msg = createHistoryBillConfirmMsg(str(sender.id), receiver.nickName, str(req.reqBill))
print "---push history confirm...", sender.getAttr("JPushId"), "msg: ", msg
JPushToId(sender.getAttr("JPushId"), None, msg, sender.currType)
self.finish(DataProtocol.getSuccessJson())
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
returnData, sendedUsers = [], []
try:
billIds = json.loads(kwargs["billIds"])
except Exception, e:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
raise Return(None)
def get(self):
viewmode = self.get_argument("viewmode", "day")
fromDate = self.get_argument("from", None)
toDate = self.get_argument("to", None)
editor = self.get_argument("editor", None)
groupname = self.get_argument("groupname", None)
region = self.get_argument("region", None)
regionmode = self.get_argument("regionmode", None)
usertype = self.get_argument("usertype", None)
routemode = self.get_argument("routemode", None)
service = self.getDbService()
if regionmode is None:
data = service.getSummaryStat(viewmode, fromDate, toDate, editor,
groupname)
else:
if routemode is None:
data = service.getRegionSummaryStat(viewmode, fromDate, toDate,
region, regionmode,
usertype)
else:
data = service.getRouteSummaryStat(viewmode, fromDate, toDate,
region, regionmode,
usertype)
self.write(DataProtocol.getSuccessJson(data, "json"))
def onCall(self, **kwargs):
location = Location()
location.userId = kwargs["userId"]
location.latitude = kwargs["latitude"]
location.longitude = kwargs["longitude"]
location.prov = kwargs["prov"]
location.city = kwargs["city"]
location.district = kwargs["district"]
location.timestamp = time.time()
config = yield Config.shared()
archiveCount = yield Location.objects({"userId":location.userId, "isArchived":True}).count()
if archiveCount > 0:
latest = yield Location.objects({"userId":location.userId, "isArchived":True}).skip(archiveCount-1).to_list(1)
latestLocation = latest[0]
nextArchiveTime = latestLocation.timestamp + config.locationArchIntervalHours*60*60
lastCacheTime = location.timestamp - config.locationCacheHours*60*60
query = {"userId":location.userId, "isArchived":False, "timestamp":{"$lt":lastCacheTime, "$gt":nextArchiveTime}}
nextArchive = yield Location.objects(query).limit(1).to_list(1)
if nextArchive:
archiveLocation = nextArchive[0]
archiveLocation.isArchived = True
yield archiveLocation.save()
yield Location.objects({"userId":location.userId, "isArchived":False, "timestamp":{"$lt":lastCacheTime}}).remove()
else:
location.isArchived = True
yield location.save()
self.finish(DataProtocol.getSuccessJson())
def onCall(self, **kwargs):
bill = yield Bill.get(kwargs["billId"])
#full字段表示是传回完整的dict（包括matcher和id），如果不传full， 则传回一个bill id的list
if "full" in kwargs and kwargs["full"]:
result = BillMatchController().getMatchDict(bill)
else:
result = BillMatchController().getMatchBills(bill)
self.finish(DataProtocol.getSuccessJson(result))
def onCall(self, **kwargs):
bill = yield Bill.get(kwargs["billId"])
#full字段表示是传回完整的dict（包括matcher和id），如果不传full， 则传回一个bill id的list
if "full" in kwargs and kwargs["full"]:
result = BillMatchController().getMatchDict(bill)
else:
result = BillMatchController().getMatchBills(bill)
self.finish(DataProtocol.getSuccessJson(result))
def onCall(self, **kwargs):
userId = self.getCurrUserId()
user = yield User.get(self.getCurrUserId(), self.getUserType())
userData = user.to_client()
userData["userId"] = userData.pop("id")
control = yield getClientControl()
dataToClient = {"user": userData, "control": control}
self.finish(DataProtocol.getSuccessJson(dataToClient, "json"))
def onCall(self, **kwargs):
userId = self.getCurrUserId()
user = yield User.get(self.getCurrUserId(), self.getUserType())
userData = user.to_client()
userData["userId"] = userData.pop("id")
control = yield getClientControl()
dataToClient = {"user":userData, "control":control}
self.finish(DataProtocol.getSuccessJson(dataToClient, "json"))
def get(self):
viewmode = self.get_argument("viewmode", "day")
fromDate = self.get_argument("from", None)
toDate = self.get_argument("to", None)
editor = self.get_argument("editor", None)
service = self.getDbService()
data = service.getSummaryStat(viewmode, fromDate, toDate, editor, None)
self.write(DataProtocol.getSuccessJson(data, "json"))
def onCall(self, **kwargs):
print "remove bill", kwargs
billid = kwargs["billid"]
bill = yield Bill.get(billid)
user = yield self.getUser()
if bill:
bill.state = BillState.CANCELLED
yield bill.save()
if user and user.currType and bill.id in user.getAttr("Bills"):
user.getAttr("Bills").remove(bill.id)
user.getAttr("BillsRecord").append(bill.id)
yield user.save()
BillMatchController().removeBill(bill)
self.finish(DataProtocol.getSuccessJson())
else:
self.finish(DataProtocol.getJson(DataProtocol.BILL_NOT_OWN))
def onCall(self, **kwargs):
regular = yield Regular.get(kwargs["id"])
print kwargs["route"]
try:
route = json.loads(kwargs["route"])
except Exception, e:
print "JSON ERROR", e.message
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
return
def onCall(self, **kwargs):
user = yield self.getUser()
user.setAttr("JPushId", "")
yield user.save()
print "========USER %s LOGOUT"%self.getCurrUserId()
self.clear_cookie("mark")
self.clear_cookie("userid")
self.clear_cookie("nickName")
self.finish(DataProtocol.getSuccessJson())
def onCall(self, **kwargs):
print "************get confirm request id:", kwargs["reqId"]
req = yield PendingRequest.get(kwargs["reqId"])
req.state = PendingReqState.FINISHED
yield req.save()
reqBill = yield Bill.objects({"id":req.reqBill, "state":BillState.WAIT}).one()
if reqBill:
requestUser = yield User.get(req.reqUser, req.reqUserType)
responseUser = yield User.get(req.respUser, req.respUserType)
if requestUser and responseUser:
config = yield Config.shared()
locateValidSec = config.locateValidSec
#根据请求的信息生成双方的历史单据
senderHistoryBill = createHistoryBill(responseUser, reqBill, locateValidSec)
shbId = yield senderHistoryBill.save()
receiverHistoryBill = createHistoryBill(requestUser, reqBill, locateValidSec)
rhbId = yield receiverHistoryBill.save()
#add each of the users a historybill.
if shbId and rhbId:
#双方添加历史单据
requestUser.getAttr("HistoryBills").append(shbId)
yield requestUser.save()
responseUser.getAttr("HistoryBills").append(rhbId)
yield responseUser.save()
yield responseUser.billDone(reqBill)
BillMatchController().removeBill(reqBill)
#反馈成功的信息给之前发起请求的一方
if requestUser.getAttr("JPushId"):
msg = createBillConfirmMsg(str(requestUser.id), responseUser.nickName, str(reqBill.id))
print "---push confirm...", requestUser.getAttr("JPushId"), "msg: ", msg
JPushToId(requestUser.getAttr("JPushId"), None, msg, req.reqUserType)
self.finish(DataProtocol.getSuccessJson(reqBill.to_client()))
else:
self.finish(DataProtocol.getJson(DataProtocol.DB_ERROR))
else:
self.finish(DataProtocol.getJson(DataProtocol.DB_ERROR, "can'find user"))
else:
self.finish(DataProtocol.getJson(DataProtocol.BILL_REMOVED))
yield req.remove()
def onCall(self, **kwargs):
user = yield User.get(self.getCurrUserId(), self.getUserType())
if "push" in kwargs:
value = True if kwargs["push"] == Value.True else False
user.getAttr("Settings")["push"] = value
if "locate" in kwargs:
value = True if kwargs["locate"] == Value.True else False
user.getAttr("Settings")["locate"] = value
yield user.save()
self.finish(DataProtocol.getSuccessJson())
def get(self):
mylog.getlog().info(getLogText("find bills"))
service = self.getDbService()
userid = self.getCurrUserId()
if service:
user = service.getUserBaseData(userid)
query = {}
if user.has_key("userType"):
query["billType"] = "goods" if user["userType"] == "driver" else "trunk"
mylog.getlog().info(getLogText("find:", query["billType"]))
bills = service.findBills(query)
self.write(DataProtocol.getSuccessJson(bills))
def onCall(self, **kwargs):
user = yield self.getUser()
fromId = kwargs["fromId"]
try:
historyBills = user.getHistoryBillList()
fromIndex = historyBills.index(ObjectId(fromId))
except Exception:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
username, phoneNum = self.get_argument("username", None), self.get_argument("phoneNum", None)
inviteNum = self.get_argument("inviteNum", None)
psw = kwargs["password"]
if username or phoneNum:
# sameUser = yield User.get_collection().find_one(qOr(username=username, phoneNum=phoneNum))
sameUser = yield User.objects({"$or":[{"username":username}, {"phoneNum":phoneNum}]}).one()
if sameUser:
self.finish(DataProtocol.getJson(DataProtocol.USER_EXISTED_ERROR,"用户已经存在"))
else:
user = User(username, phoneNum, encryptPassword(psw))
user.regtime = time.time()
yield user.save()
#注册完马上给个登录态
self.set_secure_cookie("userid", str(user.id))
self.set_secure_cookie("mark", getMark(user.id))
self.finish(DataProtocol.getSuccessJson(user.to_client(), "json"))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
mylog.getlog().info(getLogText("get recomend bills"))
usertype = self.getUserType()
user = yield self.getUser()
if not user:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
raise Return(None)
self.findtype = matchBillType(oppsiteUserType(usertype))
self.config = yield Config.shared()
self.userBills = yield user.getBills()
for id in user.getAttr("BillsRecord")[0:10]:
bill = yield Bill.get(id)
self.recordBills.append(bill)
bills = yield getBillsToRecomend(user, self.config)
if "format" in kwargs and kwargs["format"] == "ids":
#slice
sortBills, returnBillIds = bills[0:self.returnBillsNum], []
returnBills = yield getRecomendBills(sortBills)
if len(bills)>self.returnBillsNum:
returnBillIds = [str(b.id) for b in bills[self.returnBillsNum:len(bills)]]
returnData = {"bills":returnBills, "ids":returnBillIds}
else:
returnData = yield getRecomendBills(bills)
# if we want to find trucks then return some local drivers.
if self.findtype == BillType.TRUNK:
gap = self.config.recommendBillsReturnOnce - len(returnData)
if gap > 0:
localBills = yield self.getLocalTruckBill(getCity(user.homeLocation), gap)
returnData.extend(localBills)
mylog.getlog().info(getLogText("recommend bills return:", len(bills)))
self.finish(DataProtocol.getSuccessJson(returnData))
def onCall(self, **kwargs):
fromId = self.get_argument("fromId", None)
isPrev = self.get_argument("isPrev", None)
try:
fromObjId = ObjectId(fromId) if fromId else None
isPrevBool = bool(isPrev) and bool(str(isPrev).lower()=="true")
print "get history:", fromId, "is prev:", isPrev
user = yield self.getUser()
historyBills = yield user.getHistoryBill(self.getUserType(), fromObjId, isPrevBool)
toReturn = []
for hBill in historyBills:
#如果历史单据是正常的用户发送的，返回用户数据，否则返回一个临时用户的数据
sender = (yield User.get(hBill.senderId, hBill.senderType)) if hBill.senderId else None
senderData = sender.to_user_base_data() if sender else None
hBill = createReturnHistoryBill(hBill, senderData)
toReturn.append(hBill)
print "return %d history bills"%len(toReturn)
self.write(DataProtocol.getSuccessJson(toReturn))
except ValueError:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
def onCall(self, **kwargs):
# userid = self.getCurrentUser()
# userType = self.getUserType()
# service = self.getDbService()
# if service:
# print "get visit bill"
# bills = service.getUserVisitedBills(userid, userType)
# data = dict([(bill["billId"], bill["visitedTimes"]) for bill in bills])
# self.write(DataProtocol.getSuccessJson(data))
# return
# else:
# self.write(DataProtocol.getJson(DataProtocol.DB_ERROR))
user = yield self.getUser()
bills = yield user.getBills()
billsToReturn = []
for bill in bills:
if bill.visitedChange:
billsToReturn.append(bill)
bill.visitedChange = False
yield bill.save()
returnDict = dict([(str(b.id), b.visitedTimes) for b in billsToReturn])
self.finish(DataProtocol.getSuccessJson(returnDict))
def onCall(self, **kwargs):
mylog.getlog().info(getLogText("--send bill, get argument: ", kwargs))
if kwargs:
bill = Bill.from_db(kwargs)
if bill:
now = time.time()
bill.sendTime, bill.addTime = bill.sendTime or now, now
bill.state = BillState.WAIT
userId = self.getCurrUserId()
print "userid"
if userId:
user = (yield self.getUser()) if not bill.sender else (yield User.get(bill.sender, matchUserType(bill.billType)))
if user and user.currType == matchUserType(bill.billType):
# saveBill = yield user.sendBill(bill)
bill.sender = bill.sender or user.id
bill.senderName = bill.senderName or user.nickName
bill.phoneNum = bill.phoneNum or user.phoneNum
saveResult = yield bill.save()
if saveResult:
user.getAttr("Bills").append(bill.id)
yield user.save()
mylog.getlog().info(getLogText("--send bill success~~~"))
#告诉matchcontroller有新单发送，更新matchmap
BillMatchController().sendBill(bill)
self.finish(DataProtocol.getSuccessJson(bill.to_client()))
else:
self.finish(DataProtocol.getJson(DataProtocol.DB_ERROR))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR, "创建订单失败"))
else:
yield bill.save()
#告诉matchcontroller有新单发送，更新matchmap
BillMatchController().sendBill(bill)
self.finish(DataProtocol.getSuccessJson(bill.to_client()))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR, "创建订单失败"))
else:
self.finish(DataProtocol.getJson(DataProtocol.ARGUMENT_ERROR))
return
def onCall(self, **kwargs):
user = yield self.getUser()
bills = yield user.getBills()
returnBills = [b.to_client() for b in bills]
print "---return ",len(returnBills)," bills"
self.write(DataProtocol.getSuccessJson(returnBills))
def onCall(self, **kwargs):
print "-------------UpdateUserHandler", kwargs
update = dict([(k, v) for k,v in kwargs.items() if k in self.optionalParams])
print update
yield User.objects({"id":self.getCurrUserId()}).update(**User.query_dict_to_db(update))
self.finish(DataProtocol.getSuccessJson())
