def POST(self):
imgdata=json.loads(web.data())
with dbconfig.Session() as session:
user=session.query(datamodel.user.User).filter(datamodel.user.User.uid==imgdata['uid']).first()
if user is None:
return DefJsonEncoder.encode({"errno":1,"error":"user lost"})
fileurl=dbconfig.qiniuDownLoadLinkHead+imgdata['hash']
user.background_image=fileurl
session.merge(user)
session.commit()
return DefJsonEncoder.encode({"errno":0,"error":"Success","url":fileurl})
def POST(self):
imgdata=json.loads(web.data())
with dbconfig.Session() as session:
cdef=session.query(CircleDef).filter(CircleDef.cid==imgdata['cid']).first()
if cdef is None:
return DefJsonEncoder.encode({"errno":1,"error":"cid lost"})
fileurl=dbconfig.qiniuDownLoadLinkHead+imgdata['hash']
cdef.icon_url=fileurl
session.merge(cdef)
session.commit()
return DefJsonEncoder.encode({"errno":0,"error":"Success","url":fileurl})
def run(mid,people_count,hardwareid,recommend_uid=None):
with dbconfig.Session() as session:
sm=session.query(StoreMerchandise).filter(StoreMerchandise.mid==mid).first()
if sm is None:
return Res(errno=2,error="not exist")
usr=session.query(User).filter(User.uid==BackEndEnvData.uid).first()
if usr is None:
return Res(errno=2,error="this bug can not happen")
price=get_price(sm,people_count=people_count)
transtime=int(time.time())
od=u"%d-%d"%(transtime,random.randint(100, 999))
paystate=StorePayState()
paystate.orderid=od
paystate.paystate=0
paystate.mid=mid
paystate.uid=BackEndEnvData.uid
paystate.ex_people=people_count
paystate.remain=price
if recommend_uid is not None:
paystate.recommend_uid=recommend_uid
session.merge(paystate)
session.commit()
msg_content=u"%s(%s) 正在预订 %s (%s)"%(usr.phone,usr.nick,sm.productdesc,
time.strftime("%m-%d %H:%M",time.localtime()))
to_sendsms=session.query(StoreSmsNotify).filter(or_(StoreSmsNotify.mid==0,StoreSmsNotify.mid==None,StoreSmsNotify.mid==mid)).all()
for ssn in to_sendsms:
BackEndEnvData.queue_producer.publish(DefJsonEncoder.encode({'content':msg_content,'phone':ssn.phone}),routing_key='sms.ad',exchange='sys.sms')
to_notifys=session.query(StoreWeixinNotify).filter(or_(StoreWeixinNotify.mid==0,StoreWeixinNotify.mid==None,StoreWeixinNotify.mid==mid)).all()
to_weixin_user=set()
for noti_one in to_notifys:
to_weixin_user.add(noti_one.openid)
if to_weixin_user:
json_msg=DefJsonEncoder.encode({
'weixin_users':list(to_weixin_user),
'content':msg_content
})
BackEndEnvData.queue_producer.publish(body=json_msg,delivery_mode=2,
routing_key='sys.sendweixin',
compression='gzip')
gourl=None
if price>0:
mer=MerchantAPI()
gourl=mer.wap_credit(od,transtime,156,price,str(sm.productcatalog),
"Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)",
sm.productname,sm.productdesc,BackEndEnvData.client_ip,
usr.phone,4,"IMEI:"+hardwareid,"http://%s/payresult/Paybackend"%website_config.hostname,
"http://%s/payresult/Paybackend"%website_config.hostname,"1|2")
return Res({'gourl':gourl,'orderid':od})
def Check(self):
params=web.input()
data=params['data']
encryptkey=params['encryptkey']
mer=MerchantAPI()
result=mer.result_decrypt({'data':data,
'encryptkey':encryptkey})
with dbconfig.Session() as session:
paystate=session.query(StorePayState).filter(StorePayState.orderid==result['orderid']).first()
if paystate.paystate==1:
return True
paystate.paystate=1 if result['status']==1 else -1
paystate.paytime=datetime.datetime.now()
paystate.yborderid=result['yborderid']
paystate.remain=result['amount']
session.merge(paystate)
sm=session.query(StoreMerchandise).filter(StoreMerchandise.mid==paystate.mid).first()
log=StorePayLog(sm,paystate)
log=session.merge(log)
session.commit()
try:
json_post=DefJsonEncoder.encode(log.toJson())
pusher.rawPush(exchange="system",routing_key='sys.paylog',headers={},body=json_post)
return True
except Exception,e:
return False
def Check(self):
all=web.input()
tp=paylib.tenpaylib.tenpay()
if tp.VerifySign(all):
ps=datamodel.tenpaylog.TenpayState.objects(orderid=all['sp_billno']).first()
new_pay_state=1 if int(all['pay_result'])==0 else -1
if ps.paystate==new_pay_state:
return True
ps.paystate=new_pay_state
ps.paytime=datetime.datetime.now()
ps.transaction_id=all['transaction_id']
ps.remain=all['total_fee']
ps.save()
pl=datamodel.tenpaylog.TenpayLog()
pl.set_paystate(ps)
pl.pay_info=all.get('pay_info')
pl.bank_type=all.get('bank_type')
pl.bank_billno=all.get('bank_billno')
pl.time_end=all.get('time_end')
pl.purchase_alias=all.get('purchase_alias')
pl.save()
try:
json_post=DefJsonEncoder.encode(pl.toJson())
pusher.rawPush(exchange="system",routing_key='sys.paylog',headers={},body=json_post)
except Exception,e:
print e
return True
def GET(self):
params = web.input(usepage="0")
sessionid = params.get("sessionid", None)
uid = int(params.get("uid", 0))
recommend_uid = int(params.get("recommend_uid", 0))
if sessionid is None:
return "No Session id"
data = dbconfig.redisdb.get(str("session:%s" % sessionid))
if data is None:
return {"errno": 1, "error": "session not found", "result": {}}
data = json.loads(data)
if data["uid"] != uid and data["uid"] != recommend_uid:
return "user is error()"
with dbconfig.Session() as session:
ru = (
session.query(RecommendUser)
.filter(and_(RecommendUser.uid == uid, RecommendUser.recommend_uid == recommend_uid))
.first()
)
if ru is None:
return "RecommendUser not exists"
uptoken = media_token(uid, recommend_uid)
if int(params["usepage"]) == 0:
web.header("Content-type", "application/json")
return DefJsonEncoder.encode({"token": uptoken})
tpl = WebSiteBasePage.jinja2_env.get_template("upload/PostEx.html")
return tpl.render(token=uptoken)
def POST(self):
imgdata = json.loads(web.data())
with dbconfig.Session() as session:
rm = RecommendMedia()
rm.uid = imgdata["uid"]
rm.recommend_uid = imgdata["recommend_uid"]
fileurl = dbconfig.qiniuDownLoadLinkHead + imgdata["hash"]
filetype = int(imgdata["filetype"])
if filetype == 1:
rm.picture = fileurl
rm.width = imgdata["width"]
rm.height = imgdata["height"]
elif filetype == 2:
rm.voice = fileurl
rm.length = imgdata["length"]
elif filetype == 3:
rm.video = fileurl
rm.length = imgdata["length"]
rm = session.merge(rm)
session.query(RecommendUser).filter(
and_(RecommendUser.uid == imgdata["uid"], RecommendUser.recommend_uid == imgdata["recommend_uid"])
).update({RecommendUser.media_count: RecommendUser.media_count + 1})
session.commit()
return DefJsonEncoder.encode({"errno": 0, "error": "Success", "result": {"url": fileurl, "did": rm.did}})
def open(self):
self.usezlib=int(self.get_argument('usezlib',0))
sessionid=self.get_argument('sessionid',None)
cdata=self.get_argument('cdata',None)
self.userdata=None
if sessionid:
self.userdata=DecodeCryptSession(sessionid)
if self.userdata:
self.userdata['uid']=str(self.userdata['uid'])
if sessionid and self.userdata is None:
self.close()
return
self.connid=uuid.uuid4().get_hex()
print self.connid+' connected'
connection_list[self.connid]=self
self.last_act_time=time.time()
self.cip=self.request.remote_ip
if self.userdata:
msgbody=DefJsonEncoder.encode(
{
"func":"session.start2",
"parm":{
"sessionid":None,
},
"cdata":cdata
}
)
msg=Message(body=msgbody,delivery_mode=2,reply_to=mqserver.back_queue)
msg.headers={"connid":self.connid,'cip':self.cip,"uid":self.userdata['uid'],
'stime':time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(self.userdata.get('time'))),'suuid':self.userdata.get('uuid').hex}
mqserver.publish(msg)
def GET(self):
params=web.input(usepage='0')
uptoken =dbconfig.qiniuAuth.upload_token(dbconfig.qiniuSpace,policy={"returnBody":'{"errno":0,"error":"Success","url":"http://$(bucket).qiniudn.com/$(key)"}'})
if int(params['usepage'])==0:
web.header("Content-type","application/json")
return DefJsonEncoder.encode({'token':uptoken})
tpl=WebSiteBasePage.jinja2_env.get_template('upload/UploadImage.html')
return tpl.render(token=uptoken)
def GET(self):
params=web.input(usepage='0')
uptoken =dbconfig.qiniuAuth.upload_token(dbconfig.qiniuSpace,policy={"callbackUrl":'http://%s/operational_background/CircleIconDone'%website_config.hostname,
"callbackBody":'{"name":"$(fname)","hash":"$(etag)","width":$(imageInfo.width),"height":$(imageInfo.height),"cid":$(x:cid)}'})
if int(params['usepage'])==0:
web.header("Content-type","application/json")
return DefJsonEncoder.encode({'token':uptoken})
tpl=WebSiteBasePage.jinja2_env.get_template('operational/circleicon.html')
return tpl.render(token=uptoken)
def GET(self):
try:
params=web.input()
payid=int(params.get("payid"))
paylog=TenpayLog.objects(payid=payid).first()
json_post=DefJsonEncoder.encode(paylog.toJson())
pusher.rawPush(exchange="system",routing_key='sys.paylog',headers={},body=json_post)
return "ok"
except Exception,e:
return traceback.format_exc()
def POST(self):
backdata=json.loads(web.data())
verCode=int(backdata['verCode'])
verName=urllib.unquote_plus(backdata['verName'].encode('ascii')).decode('utf-8')
Info=urllib.unquote_plus(backdata['Info'].encode('ascii')).decode('utf-8')
file=backdata['name']
fout= codecs.open('static/android/version.js','w','utf-8')
json.dump({'verCode':verCode,'verName':verName,'Info':Info,'url':file},fout,ensure_ascii=False)
fout.close()
return DefJsonEncoder.encode({"url":'http://%s/static/android/version.js'%website_config.hostname})
def GET(self):
try:
params=web.input()
payid=params.get("payid")
with dbconfig.Session() as session:
paylog=session.query(StorePayLog).filter(StorePayLog.payid==payid).first()
json_post=DefJsonEncoder.encode(paylog.toJson())
pusher.rawPush(exchange="system",routing_key='sys.paylog',headers={},body=json_post)
return "ok"
except Exception,e:
return False
def GET(self):
param=web.input()
session=database.Session()
with AutoClose(session) as ac:
all=session.query(VideoComment,User).join(User,VideoComment.uid==User.id).filter(VideoComment.youku_id==param.video_id).order_by(VideoComment.id.desc()).all()
ret_data={}
comlist=[]
ret_data["comments"]=comlist
for com,usr in all:
data={
"user":usr.toJSON(),
"text":com.text,
"time":com.time
}
comlist.append(data)
return DefJsonEncoder.encode(ret_data)
def POST(self):
param=web.input()
session=database.Session()
with AutoClose(session) as ac:
vc=VideoComment()
vc.uid=tools.data.session.uid
vc.text=param.text
vc.youku_id=param.video_id
usr=session.query(User).filter(User.id==tools.data.session.uid).one()
vc=session.merge(vc)
session.commit()
data={
"user":usr.toJSON(),
"text":vc.text,
"time":vc.time
}
return DefJsonEncoder.encode(data)
def GET(self):
params=web.input(usepage='0')
sessionid=params.get('sessionid',None)
if sessionid is None:
return "No Session id"
data=tools.crypt_session.DecodeCryptSession(sessionid)
if data is None:
data=dbconfig.redisdb.get(str('session:%s'%sessionid))
if data:
data=json.loads(data)
if data is None:
return {"errno":1,"error":"session not found","result":{}}
uptoken = backgroundimg_token(data['uid'])
if int(params['usepage'])==0:
web.header("Content-type","application/json")
return DefJsonEncoder.encode({'token':uptoken})
tpl=WebSiteBasePage.jinja2_env.get_template('upload/HeadImg.html')
return tpl.render(token=uptoken)
def SetMenu(token,menu_json):
url = 'https://api.weixin.qq.com/cgi-bin/menu/create?access_token=%s'%token
crl = pycurl.Curl()
crl.setopt(pycurl.FOLLOWLOCATION, 1)
crl.setopt(pycurl.MAXREDIRS, 5)
crl.setopt(pycurl.AUTOREFERER,1)
crl.setopt(pycurl.SSL_VERIFYHOST,0)
crl.setopt(pycurl.SSL_VERIFYPEER,0)
crl.setopt(pycurl.CONNECTTIMEOUT, 60)
crl.setopt(pycurl.TIMEOUT, 300)
#crl.setopt(pycurl.PROXY,proxy)
crl.setopt(pycurl.HTTPPROXYTUNNEL,1)
crl.fp = StringIO()
crl.setopt(crl.POSTFIELDS, DefJsonEncoder.encode(menu_json).encode('utf-8'))
crl.setopt(pycurl.URL, url.encode('utf-8'))
crl.setopt(crl.WRITEFUNCTION, crl.fp.write)
crl.perform()
return json.loads(crl.fp.getvalue())
def SendMessage(token,json_message):
"""
http://mp.weixin.qq.com/wiki/index.php?title=%E5%8F%91%E9%80%81%E5%AE%A2%E6%9C%8D%E6%B6%88%E6%81%AF
"""
crl = pycurl.Curl()
crl.setopt(pycurl.FOLLOWLOCATION, 0)
crl.setopt(pycurl.MAXREDIRS, 5)
crl.setopt(pycurl.ENCODING,"gzip,deflate")
crl.setopt(pycurl.POST, 1)
crl.setopt(pycurl.POSTFIELDS, DefJsonEncoder.encode(json_message).encode('utf-8'))
crl.setopt(pycurl.CONNECTTIMEOUT, 6)
crl.setopt(pycurl.TIMEOUT, 15)
crl.setopt(pycurl.SSL_VERIFYPEER,False)
crl.fp = StringIO()
crl.setopt(pycurl.URL, ("https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=%s"%token).encode('utf-8'))
crl.setopt(crl.WRITEFUNCTION, crl.fp.write)
crl.perform()
res_code=crl.getinfo(pycurl.HTTP_CODE)
res_body=json.loads(crl.fp.getvalue())
crl.close()
return res_body
def POST(self):
imgdata=json.loads(web.data())
with dbconfig.Session() as session:
exmedia=datamodel.user.UserExMedia()
exmedia.uid=imgdata['uid']
exmedia.text=urllib.unquote_plus(imgdata['text'].encode('ascii')).decode('utf-8')
fileurl=dbconfig.qiniuDownLoadLinkHead+imgdata['hash']
filetype=int(imgdata['filetype'])
if filetype==1:
exmedia.picture=fileurl
exmedia.width=imgdata['width']
exmedia.height=imgdata['height']
elif filetype==2:
exmedia.voice=fileurl
exmedia.length=imgdata['length']
elif filetype==3:
exmedia.video=fileurl
exmedia.length=imgdata['length']
exmedia=session.merge(exmedia)
session.commit()
return DefJsonEncoder.encode({"errno":0,"error":"Success","result":{"url":fileurl,'did':exmedia.did}})
def open(self):
self.ccode=GenSession(20)
self.write_message(DefJsonEncoder.encode({"ccode":self.ccode}))
return
replyheader, replybody = res
except Exception, e:
replybody = traceback.format_exc()
replyheader = {"error": str(e)}
if "reply_to" in properties:
if replyheader.get("zip"):
producer.publish(
body=replybody,
delivery_mode=2,
headers=replyheader,
routing_key=properties["reply_to"],
correlation_id=properties.get("correlation_id"),
content_type="application/data",
content_encoding="binary",
exchange=back_exchange,
)
else:
producer.publish(
body=replybody,
delivery_mode=2,
headers=replyheader,
routing_key=properties["reply_to"],
correlation_id=properties.get("correlation_id"),
compression="gzip",
exchange=back_exchange,
)
else:
print DefJsonEncoder.encode(replyheader), replybody
message.ack()
def CreateQRCode(token,scene_id,expire_seconds=None):
if expire_seconds:
postdata={"expire_seconds": expire_seconds, "action_name": "QR_SCENE", "action_info": {"scene": {"scene_id": scene_id}}}
else:
postdata={"action_name": "QR_LIMIT_SCENE", "action_info": {"scene": {"scene_id": scene_id}}}
request = urllib2.Request("https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=%s"%(token),DefJsonEncoder.encode(postdata))
data=json.loads(urllib2.urlopen(request).read())
ticket=data['ticket']
return "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=%s"%ticket
def on_message(self, message):
message=DefJsonEncoder.encode(msgpack.unpackb(message))
msg=Message(body=message,delivery_mode=2,reply_to=mqserver.back_queue)
msg.headers={"connid":self.connid,'cip':self.cip}
mqserver.publish(msg)
self.last_act_time=time.time()
StorePayState.create_time > time_min,
)
)
.all()
)
# all_pay=session.query(StorePayState).filter(StorePayState.paystate==0).all()
for pay in all_pay:
payinfo = mer.QueryPay(pay.orderid, "")
print(payinfo)
if "error_code" in payinfo:
pay.paystate = -1
session.merge(pay)
else:
pay.paystate = 1
pay.paytime = datetime.datetime.now()
pay.yborderid = payinfo["yborderid"]
pay.remain = payinfo["amount"]
session.merge(pay)
sm = session.query(StoreMerchandise).filter(StoreMerchandise.mid == pay.mid).first()
log = StorePayLog(sm, pay)
log = session.merge(log)
session.commit()
try:
json_post = DefJsonEncoder.encode(log.toJson())
pusher.rawPush(exchange="system", routing_key="sys.paylog", headers={}, body=json_post)
except Exception, e:
pass
session.commit()
time.sleep(30)
