def setPassword(username,password):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 获取token的json字段
postStr = '{"newpassword": "******"}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->setPassword->postStr:', postStr)
conn.request('POST', url + '/users/' + username + '/password', postStr, headers)
"""
response示例
{
"action" : "set user password",
"timestamp" : 1409575962124,
"duration" : 326
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->setPassword->error:',response.status)
return False,backdata
else:
return True,'设置密码成功'
except:
print('func_im.py->setPassword->except:', backdata)
return False, '设置密码异常'
def searchUser(request):
#判断用户是否登录,登录用户才具备查询权限，并返回当前登录用户
result,loginUser = LoginStatus(ltoken=get_token(request))
if not result:
#print 'not login',get_token(request),loginUser
infor = loginUser
return JsonResponse(GlobalVar.RspOffLine,infor)
if request.method == 'GET':
pKey = request.GET.get('key','')
if pKey == '':
return JsonResponse(GlobalVar.RspFail,'需要输入关键字')
try:
#temp1 = User.objects.filter(PhoneNumber=pKey)
#temp2 = User.objects.filter(UserName__contains=pKey)
lUser = User.objects.filter(PhoneNumber=pKey) | User.objects.filter(UserName__contains=pKey)
lUser = lUser.distinct().values(*GlobalVar.TableFields.Userfields)
lUser = GetCommonDlList(lUser)
#lUser = lUser.values(*fields)
return JsonResponse(lUser)
except User.DoesNotExist:
return JsonResponse(GlobalVar.RspSuccess,'查询结果为空')
except Exception,ex:
debug('views_person.py->searchUser->error',ex)
return JsonResponse(GlobalVar.RspFail,'查询过程出现异常')
def save(self,*args,**kwargs):
#用户名使用随机数字
#if '' == self.UserName:
# self.UserName = '******' + self.PhoneNumber #get_random_string(7,'0123456789') + \
#datetime.now().strftime('%Y%m%d%H%M%S')
if not isPhoneNumber(self.PhoneNumber):
debug('models.py->User->save:电话号码非法')
return False,'电话号码非法'
#当环信用户名为空时，则表明未注册，需要注册
if not self.hxActivieFlag:
self.hxActivieFlag = True
self.hxUserName = '******' + self.PhoneNumber
self.hxPassword = get_random_string(16,'abcdefghijklmnopqrstuvwxyz~!@#$%^&*()0123456789')
#UuID如果未空，则表明没有注册，注册还是在用户注册成功之后，调用环信注册函数
if self.hxActivieFlag and (self.hxUuid is None or '' == self.hxUuid):
result,info = getHxUser(self.hxUserName)
#环信用户已经存在
if result:
self.hxUuid = info
else:
result,info = register(self.hxUserName,self.hxPassword)
if result:
self.hxUuid = info
#uuid生成失败，下次修改记录场景下重新自动注册
else:
debug('models.py->User->save:uuid生成失败-',info)
#不能直接返回，继续保存其他变量
#return False,'注册IM失败'
super(User,self).save(*args,**kwargs)
return True,'保存成功'
def updateFileToCommon(self,fileFlag,colName='_FILE_HeaderFigure'):
temp = {}
#print "GetUlToken Start"
ulToken,filename = GetCommonUlToken(model=fileFlag,count=1)
debug('func_json.py -> updateFileToCommon -> _meta', JsonCode(type(self).__name__))
#print "ulToken:",ulToken,"filename",filename
#将上传凭证和服务器生成的文件名称返回给客户端，让客户端向云上传附件
if(len(ulToken)== 1 and len(filename) == 1):
temp['UlToken'] = ulToken[0]
temp['FileName'] = filename[0]
else:
return False,'上传Token获取失败'
try:
#根据列名，保留旧值，新值暂时放到末尾，待上传文件成功之后，回调再刷新
setattr(self, colName,getattr(self,colName,'') + GlobalVar.InterStr + filename[0])
self.save()
"""
for field in self._meta.fields:
if field.name == colName:
print self._meta,field.name
setattr(self, colName,getattr(self,colName,'') + GlobalVar.InterStr + filename[0])
#field += GlobalVar.InterStr + filename[0]
break;"""
return True,temp
except Exception,ex:
return False,ex
def refreshUrl(self,colname='content',pIsPublic=True):
lIsPublic = getattr(self,'IsPublic',True)
pIsPublic = lIsPublic and pIsPublic
content = getattr(self,colname,'')
if pIsPublic:
return content
content = b64decode(content)
soup = BeautifulSoup(content)
aList = soup.find_all("a")
for a in aList:
#更新url
if pIsPublic:
result,newUrl = GetCommonDlItem(a.get('tilte',''))
else:
result,newUrl = GetPrivateDlItem(a.get('tilte',''))
if result:
a.href = newUrl
#附件src更新，支持的类型才会直接更新src
for child in a.children:
if child.name == 'img':
child.src = newUrl
else:
pass
else:
pass
debug('func_json.py -> JsonMode -> refreshUrl',soup.prettify())
return b64encode(soup.prettify())
def get_access_token(refresh=False):
try:
global token_time,expires_in, access_token
#小于两小时，并且不需要强制刷新token
if (datetime.now() - token_time).seconds < expires_in \
and not refresh and not access_token == '':
#print 'get_access_token: now access_token is ',access_token
pass
#
else:
debug( 'get_access_token:Get the access_token,now it is',access_token)
url = wxHost + '/cgi-bin/token?grant_type=client_credential&appid=' \
+ appid + '&secret=' + secret
#更新token和时间戳
#{"access_token":"ACCESS_TOKEN","expires_in":7200}
errorcode,responseJson = https_get(url)
access_token = responseJson.get('access_token','')
expires_in = int(responseJson.get('expires_in','7200'))
token_time = datetime.now()
return access_token
except:
print 'get_access_token:except.'
return 'access_token:except'
def wxWebLogin(request):
if request.method == 'POST':
json_para = JsonRequest(request.body)
try:
puserTempId = json_para.get('userTempId','')
puserTempToken = json_para.get('userTempToken','')
pToken = get_token(request)
debug('wxWebLogin',puserTempId,puserTempToken)
lUser = User.objects.get(UserTempId=puserTempId)
if lUser.verifyUserTempToken(puserTempToken):
"""
resultSave,infoSave = lUser.save()
if not resultSave:
return JsonResponse(GlobalVar.RspFail,infoSave)"""
result,infor = LoginStatus(luser=lUser,ltoken=pToken)
if result:
return JsonResponse(GlobalVar.RspSuccess,'微信用户登录成功')
else:
return JsonResponse(GlobalVar.RspFail,infor)
else:
return JsonResponse(GlobalVar.RspFail,'微信用户登录失败')
except User.DoesNotExist:
return JsonResponse(GlobalVar.RspFail,'微信用户链接可能已经过期')
except:
return JsonResponse(GlobalVar.RspFail,'微信用户登录异常，请重新登录')
else:
return JsonResponse(GlobalVar.RspFail,'HTTP方法不支持')
def sendSysMsg(target_type=globalvar.target_type.users,target='["test"]',typePara="system",action="test",fromPara="admin",ext=""):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
if ext is None or ext == '':
ext = '{"reservs":"保留"}'
# 添加朋友的json字段
#users 给用户发消息, chatgroups 给群发消息, chatrooms 给聊天室发消息
#一个用户u1或者群组, 也要用数组形式 ['u1'], 给用户发送时数组元素是用户名,给群组发送时数组元素是groupid
#表示消息发送者, 无此字段Server会默认设置为"from":"admin",有from字段但值为空串("")时请求失败
#扩展属性, 由app自己定义.可以没有这个字段，但是如果有，值不能是“ext:null“这种形式，否则出错
postStr = '{' +\
'"target_type":"' + target_type + '", '+\
'"target":"'+ target +'",'+ \
'"msg":{"type":"' + typePara + '", "action":"' + action +'"},'+\
'"from":"' + fromPara + '",' +\
'"ext":' + ext + '}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->sendSysMsg->postStr:', postStr)
conn.request('POST', url + '/messages/', postStr, headers)
"""
{
"action" : "post",
"application" : "4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5",
"uri" : "https://a1.easemob.com/easemob-demo/chatdemoui",
"entities" : [ ],
"data" : {
"testb" : "success",
"testc" : "success"
},
"timestamp" : 1415167842297,
"duration" : 4,
"organization" : "easemob-demo",
"applicationName" : "chatdemoui"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->getBlocks->error:',response.status)
return False,backdata
else:
_dict = JsonRequest(backdata)
data = _dict.get('data',[])
return True,data
except:
print('func_im.py->getBlocks->except:', backdata)
return False, '获取黑名单异常'
def wxticket(request):
if request.method == 'GET':
#不支持GeT方法
return JsonResponse(GlobalVar.RspFail)
elif request.method == 'POST':
data = JsonRequest(request.body);
url = data.get('url','')
debug('wxticket',url)
ret = get_js_wx_config(url)
return JsonResponse(ret)
else:
return JsonResponse(GlobalVar.RspFail)
def rmvFriend(username,friend_username):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 删除朋友的json字段
postStr = '{}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->rmvFriend->postStr:', postStr)
conn.request('DELETE', url + '/users/' + username + '/contacts/users/' + friend_username, postStr, headers)
"""
{
"action" : "delete",
"application" : "4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5",
"params" : { },
"path" : "/users/stliu/contacts",
"uri" : "https://a1.easemob.com/easemob-demo/chatdemoui/users/stliu/contacts/users/yantao",
"entities" : [ {
"uuid" : "aa6160da-eb01-11e3-ab09-15edd986e7b7",
"type" : "user",
"created" : 1401787813725,
"modified" : 1409739134225,
"username" : "88888",
"activated" : true,
"device_token" : "67aab3a88a0b146b7883e7b0275ffe94f509a4e69e8b1db503b2fa4f9c556dd3",
"nickname" : "88888",
"notification_display_style" : 0,
"notification_no_disturbing" : false,
"notification_no_disturbing_end" : 24,
"notification_no_disturbing_start" : 0,
"notifier_name" : "chatdemoui_dev"
} ],
"timestamp" : 1409739808288,
"duration" : 1575,
"organization" : "easemob-demo",
"applicationName" : "chatdemoui"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->rmvFriend->error:',response.status)
return False,backdata
else:
return True,'添加朋友成功'
except:
print('func_im.py->rmvFriend->except:', backdata)
return False, '添加朋友异常'
def wxMyInfo(request):
#debug('wiews_weixin.py->wxMyInfor:enter the wxMyinfo')
if request.method == 'GET':
code = request.GET.get('code','')
result,url = weixin_user_url_preHandle(code,GlobalVar.OpenType.Messsage)
debug('wiews_weixin.py->wxMyInfo->result,url:',result,url)
if result:
return HttpResponseRedirect(url)
else:
return JsonResponse(GlobalVar.RspFail,url)
else:
return JsonResponse(GlobalVar.RspSuccess,'OK')
def JsonRequest(body):
try:
"""
decodeStr=''
print body
if "AppTest" in body or ',hash="' in body:
decodeStr= body
else:
decodeStr = Cipher.decrypt(body)
"""
return simplejson.loads(body)
except Exception,ex:
debug('func_json.py->JsonRequest->error:',ex)
return {}
def get_jsapi_ticket(refresh=False):
try:
global ticket_time,expires_in, jsapi_ticket
#小于两小时，并且不需要强制刷新token
if (datetime.now() - ticket_time).seconds < expires_in \
and not refresh and not jsapi_ticket == '':
debug( 'get_jsapi_ticket: now access_token is ',access_token)
pass
#
else:
#https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=ACCESS_TOKEN&type=jsapi
debug( 'get_jsapi_ticket:Get the jsapi_ticket,now it is',jsapi_ticket)
url = wxHost + '/cgi-bin/ticket/getticket?access_token=' \
+ get_access_token() + '&type=jsapi'
#更新token和时间戳
#{"access_token":"ACCESS_TOKEN","expires_in":7200}
errorcode,responseJson = https_get(url)
if errorcode == '0':
jsapi_ticket = responseJson.get('ticket','')
#expires_in = int(responseJson.get('expires_in','7200'))
ticket_time = datetime.now()
else:
debug("get_jsapi_ticket: the weixin server response is error:",errorcode)
return jsapi_ticket
except:
debug( 'get_jsapi_ticket:except.')
return 'access_token:except'
def weixin_user_url_preHandle(code='',openType=0):
if code == '':
return True,'http://x5.wuyoubar.cn/X5/'
errorcode2,response2 = get_user_refresh_token(code)
#debug( errorcode2,response2)
if errorcode2 != '0':
return False,response2
p_openid = response2.get('openid','')
p_access_token = response2.get('access_token','')
p_refresh_token = response2.get('refresh_token','')
#debug('lOpenid',lOpenid)
#OpenID在数据库中存在，已经绑定用户，直接跳转页面
#携带openType和tempUserToken
try:
lUser = User.objects.get(openid=p_openid)
#debug('lUser',lUser)
userTempId = datetime.now().strftime('%Y%m%d%H%M%S') +\
get_random_string(6,'0123456789abcdefghijklmnopqrstuvwxyz')
userTempToken = datetime.now().strftime('%Y%m%d%H%M%S') +\
get_random_string(24,'0123456789abcdefghijklmnopqrstuvwxyz')
#创建tempUserToken，需要保存到数据库中
result = lUser.generateUserTempToken(userTempId,userTempToken)
if not lUser.save():
debug('weixin_user_url_preHandle','generate temp userid and token fail!!!!!')
return False,'微信用户临时授权失败'
debug('weixin_user_url_preHandle',lUser)
#debug(result,userTempId,userTempToken)
if result:
return True,UserPageHome+'?openType='+str(openType)+'&userTempId='+userTempId +\
'&userTempToken='+userTempToken
else:
return False,'网络异常，请稍后重试'
#OpenID在数据库中不存在，跳转到绑定用户页面,code下发给终端
except User.DoesNotExist:
#把openid,access_token和refresh_token加密发送给用户
#msg消息体加密之前是access_token(xxxx)&openid(xxx)&refresh_token(xxx)
tempWXUser = TempWXUser(
openid = p_openid,
access_token = p_access_token,
refresh_token = p_refresh_token,
)
tempWXUser.save()
#msg = encrypter(msg)
debug('weixin_user_url_preHandle','msg',p_openid)
return True,UserPageHome+'?openType='+str(GlobalVar.OpenType.wxBound) +\
'&code='+p_openid+'&nextopenType='+str(openType)
except Exception,ex:
debug('func_weixin.py->weixin_user_url_preHandle->error',p_openid)
return False,'网络异常，请稍后重试'
def https_post(url,PostStr):
try:
conn = httplib.HTTPSConnection(wxHost)
conn.request('POST',url,PostStr,headers_post)
response = conn.getresponse()
backdata = response.read(5000)
errorcode,result = response_handle(backdata)
debug('https_post',url,PostStr,errorcode,result)
if errorcode == '0':
return errorcode,result
else:
return errorcode,'http post方法失败'+errorcode
except:
return 'https_post except','https post方法异常'
def wxBond(self,TokenInfor,userInfo):
try:
debug('wxBond',TokenInfor,userInfo)
#是不是已经微信绑定，如果用户已经绑定，需要先解绑定，才能继续绑定
if self.openid == '' or self.openid is None:
pass
else:
return False,'该手机用户已经绑定，请绑定其他手机用户或者进行解绑'
#TokenInfor = [openid,access_token,refresh_token]
self.openid = TokenInfor[0]
self.country = userInfo.get('country','')
self.privilege = userInfo.get('privilege','')
self.access_token = TokenInfor[1]
self.expires_in = 7200
self.refresh_token = TokenInfor[2]
#self.unionid = TokenInfor.get('unionid','')
#如果用户相关信息为空，则将微信的用户相关信息直接导入
#微信的等同于本系统的用户名
if self.UserName == '' or self.UserName is None:
self.UserName = userInfo.get('nickname','')
if self.Sex == '' or self.Sex is None:
if userInfo.get('sex','') == '1':
self.Sex = '男'
else:
self.Sex = '女'
if self.Provence == '' or self.Provence is None:
self.Provence = userInfo.get('province','')
if self.City == '' or self.City is None:
self.City = userInfo.get('city','')
if self._FILE_HeaderFigure == '' or self._FILE_HeaderFigure is None:
self._FILE_HeaderFigure = userInfo.get('headimgurl','')
if self.save():
return True,'绑定成功'
else:
return False,'绑定失败'
except:
return False,'绑定数据操作异常，请稍后重试'
def https_get(url):
try:
conn = httplib.HTTPSConnection(wxHost)
conn.request('GET',url,None,headers_get)
response = conn.getresponse()
backdata = response.read(5000)
errorcode,result = response_handle(backdata)
#{"access_token":"ACCESS_TOKEN","expires_in":7200}
debug('https_get',url,errorcode,result)
#GET方法处理成功，状态判断的主要在response_handle函数中处理
if errorcode == '0':
return errorcode,result
else:
return errorcode,'https get方法失败'+errorcode
except:
return 'https_get except','https get方法异常'
def setNickName(username,nickname):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 获取token的json字段
postStr = '{"nickname": "'+nickname+'"}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->setNickName->postStr:', postStr)
conn.request('POST', url + '/users/' + username, postStr, headers)
"""
{
"action" : "put",
"application" : "4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5",
"path" : "/users",
"uri" : "https://a1.easemob.com/easemob-demo/chatdemoui/users",
"entities" : [ {
"uuid" : "c3b56d5a-7135-11e4-92d2-edab82ae2302",
"type" : "user",
"created" : 1416543645861,
"modified" : 1416550240537,
"username" : "jianguo",
"activated" : true,
"device_token" : "61491f49f3e69cd1d62c5b390e42f4b1cd15bf1a876a487268cfaef9960188ee",
"nickname" : "张建国"
} ],
"timestamp" : 1416550240285,
"duration" : 278,
"organization" : "easemob-demo",
"applicationName" : "chatdemoui"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->setNickName->error:',response.status)
return False,backdata
else:
return True,'设置昵称成功'
except:
print('func_im.py->setNickName->except:', backdata)
return False, '设置昵称异常'
def getToken(refresh=False):
global expires_in,access_token,application,url
#判断当前是否已经超时
if (datetime.now() - token_time).seconds < expires_in \
and not refresh and not access_token == '':
return True,access_token
backdata = ''
try:
#获取token的json字段
postStr = '{"grant_type":"client_credentials",'\
+ '"client_id": "YXA6oSm0kJ2OEeW4bge9YoDNxQ","client_secret": "YXA6tGnIfyPAskipCkcUxWTbERT8xDU"}'
conn = httplib.HTTPSConnection(host)
conn.request('POST', url + '/token' , postStr, headers)
"""
response示例
{
"access_token":"YWMtWY779DgJEeS2h9OR7fw4QgAAAUmO4Qukwd9cfJSpkWHiOa7MCSk0MrkVIco",
"expires_in":5184000, #有效时间,秒为单位, 默认是七天,在有效期内是不需要重复获取的
"application":"c03b3e30-046a-11e4-8ed1-5701cdaaa0e4"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
return False,backdata
except:
debug('func_im.py->getToken->except:',backdata)
return False,'更新环信Token异常'
if 'access_token' in backdata and 'expires_in' in backdata:
_dict = JsonRequest(backdata)
access_token = _dict.get("access_token","")
expires_in = int(_dict.get('expires_in','5184000'))
application = _dict.get("application","")
if access_token != "":
#更新headers
headers['Authorization'] = 'Bearer ' + access_token
return True,access_token
else:
return False,backdata
else:
return False,backdata
def getHxUser(username):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 添加朋友的json字段
postStr = '{}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->getUser->postStr:', postStr)
conn.request('GET', url + '/users/' + username , postStr, headers)
"""
{
"action" : "get",
"application" : "4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5",
"params" : { },
"path" : "/users",
"uri" : "https://a1.easemob.com/easemob-demo/chatdemoui/users/ywuxvxuir6",
"entities" : [ {
"uuid" : "628a88ba-dfce-11e3-8cac-51d3cb69b303",
"type" : "user",
"created" : 1400556326075,
"modified" : 1400556326075,
"username" : "ywuxvxuir6",
"activated" : true
} ],
"timestamp" : 1409574716897,
"duration" : 57,
"organization" : "easemob-demo",
"applicationName" : "chatdemoui"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->getUser->error:',response.status)
return False,backdata
else:
_dict = JsonRequest(backdata)
data = _dict.get('entities',[])
if len(data) == 1:
uuid = data[0].get('uuid','')
if uuid == '':
return False,'获取到的uuid为空'
else:
return True,uuid
else:
debug('func_im.py->getFriends->get Uuid fail:', backdata)
return False,'获取Uuid失败'
except Exception,ex:
debug('func_im.py->getFriends->error:', ex)
return False, '获取用户信息异常'
def addFriend(username,friend_username):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 添加朋友的json字段
postStr = '{}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->addFriend->postStr:', postStr)
conn.request('POST', url + '/users/' + username + '/contacts/users/' + friend_username, postStr, headers)
"""
{
"action":"post","application":"4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5","params":{},
"path":"/users/aa6160da-eb01-11e3-ab09-15edd986e7b7/contacts",
"uri":"https://a1.easemob.com/easemob-demo/chatdemoui/users/jliu/contacts/yantao",
"entities":[
{
"uuid":"0086742a-dc9b-11e3-a782-1b5d581c57a9",
"type":"user",
"created":1400204403810,
"modified":1400204403810,
"username":"******",
"activated":true
}
],
"timestamp":1406086326974,"duration":242,
"organization":"easemob-demo",
"applicationName":"chatdemoui"
}
"""
response = conn.getresponse()
backdata = rsponse.read(5000)
if response.status >= 400:
debug('func_im.py->addFriend->error:',response.status)
return False,backdata
else:
return True,'添加朋友成功'
except:
print('func_im.py->addFriend->except:', backdata)
return False, '添加朋友异常'
def getFileUrl(self,colName='_FILE_HeaderFigure',pIsPublic=True):
filename = getattr(self,colName,'').split(GlobalVar.InterStr)[0]
debug('func_json.py -> JsonMode -> getFileUrl ->colValue,filename,colname:',getattr(self,colName,''),filename,colName)
if filename == '':
return ''
result,url = False,''
lIsPublic = getattr(self,'IsPublic',True)
pIsPublic = lIsPublic and pIsPublic
if pIsPublic:
result,info = GetCommonDlItem(filename)
else:
result,info = GetPrivateDlItem(filename)
if result:
return info
else:
return ''
def rmvBlocks(username,friend_username):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 删除朋友的json字段
postStr = '{}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->rmvBlocks->rmvBlocks:', postStr)
conn.request('DELETE', url + '/users/' + username + '/blocks/users/' + friend_username, postStr, headers)
"""
{
"action" : "delete",
"application" : "4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5",
"path" : "/users/72bb4f9a-fce7-11e3-98f4-adc39e9f4363/blocks",
"uri" : "https://a1.easemob.com/easemob-demo/chatdemoui/users/v3y0kf9arx/blocks",
"entities" : [ {
"uuid" : "7cc785ea-dfcc-11e3-b24a-d5b4112501a1",
"type" : "user",
"created" : 1400555511102,
"modified" : 1400555511102,
"username" : "5cxhactgdj",
"activated" : true
} ],
"timestamp" : 1412825354550,
"duration" : 164,
"organization" : "easemob-demo",
"applicationName" : "chatdemoui"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->rmvBlocks->error:',response.status)
return False,backdata
else:
return True,'从黑名单中删除成功'
except:
print('func_im.py->rmvBlocks->except:', backdata)
return False, '从黑名单中删除异常'
def getUserInfoFromHx(request):
#判断用户是否登录,登录用户才具备查询权限，并返回当前登录用户
result,loginUser = LoginStatus(ltoken=get_token(request))
if not result:
#print 'not login',get_token(request),loginUser
infor = loginUser
return JsonResponse(GlobalVar.RspOffLine,infor)
if request.method == 'GET':
phxUserName = request.GET.get('hxUserName','')
if phxUserName == '':
return JsonResponse(GlobalVar.RspFail,'环信用户名不能为空')
try:
#temp1 = User.objects.filter(PhoneNumber=pKey)
#temp2 = User.objects.filter(UserName__contains=pKey)
fields = ['id','PhoneNumber','UserName','_FILE_HeaderFigure','IsDelete','Nick','hxUserName']
lUser = User.objects.values(*GlobalVar.TableFields.Userfields).get(hxUserName=phxUserName)
#lUser = lUser
lUser = GetCommonDlList([lUser])
#lUser = lUser.values(*fields)
return JsonResponse(lUser)
except User.DoesNotExist:
return JsonResponse(GlobalVar.RspFail,'未查找到该环信用户的信息')
except:
return JsonResponse(GlobalVar.RspFail,'出现异常')
elif request.method == "POST":
_strReq = JsonRequest(request.body)
pHxUserNameList = _strReq.get('hxUserNameList',[])
debug('views_person->getUserInfoFromHx->_strReq:',_strReq)
debug('views_person->getUserInfoFromHx->pHxUserNameList:',pHxUserNameList)
try:
lUser = User.objects.values(*GlobalVar.TableFields.Userfields).filter(hxUserName__in=pHxUserNameList)
if len(lUser) == 0:
return JsonResponse(GlobalVar.RspSuccess, '查询结果为空')
lUser = GetCommonDlList(lUser)
return JsonResponse(lUser)
except:
return JsonResponse(GlobalVar.RspFail,'出现异常')
return JsonResponse(GlobalVar.RspFail,'方法不支持')
def get_js_wx_config(url=''):
#try:
debug('get_js_wx_config:starut handle the url-',url)
#timestamp需要去掉小数点，取十位整数就可以了，到秒级
timestamp = str(mktime(datetime.now().timetuple()))[0:10]
nonceStr = get_random_string(16,'0123456789abcdefghijklmnopqrstuvwxyz')
debug('get_js_wx_config:nonceStr',timestamp,'nonceStr',nonceStr)
#debug(jsapi_ticket,timestamp,url,tempStr)
"""
对所有待签名参数按照字段名的ASCII
码从小到大排序（字典序）后，使用URL键值对的格式
（即key1=value1&key2=value2…）拼接成字符串string1
对string1进行sha1签名，得到signature：
这里需要注意的是所有参数名均为小写字符
"""
ticket = get_jsapi_ticket()
tempList = sorted(["jsapi_ticket="+ticket,"noncestr="+nonceStr,"timestamp="+timestamp,"url="+url])
tempStr = tempList[0]+"&"+tempList[1]+"&"+tempList[2]+"&"+tempList[3]
#debug(jsapi_ticket,timestamp,url,tempStr)
#debug("signature",sha1(tempStr).hexdigest())
return {
#'jsapi_ticket':jsapi_ticket,
'debug':'false',
'appId':appid,
'timestamp':timestamp,
'nonceStr':nonceStr,
'signature':sha1(tempStr).hexdigest(),
'jsApiList': ['onMenuShareTimeline','onMenuShareAppMessage','onMenuShareQQ',\
'onMenuShareWeibo','onMenuShareQZone','startRecord','stopRecord',\
'onVoiceRecordEnd','playVoice','pauseVoice','stopVoice','onVoicePlayEnd',\
'uploadVoice','downloadVoice','chooseImage','previewImage','uploadImage',\
'downloadImage','translateVoice','getNetworkType','openLocation','getLocation',\
'hideOptionMenu','showOptionMenu','hideMenuItems','showMenuItems',\
'hideAllNonBaseMenuItem','showAllNonBaseMenuItem','closeWindow','scanQRCode',\
'chooseWXPay','openProductSpecificView','addCard','chooseCard','openCard']
}
"""
def getFriends(username):
#Token刷新，如果获取失败，则返回
result,info = getToken()
if not result:
return False,info
backdata = ''
try:
# 添加朋友的json字段
postStr = '{}'
conn = httplib.HTTPSConnection(host)
debug('func_im.py->getFriends->postStr:', postStr)
conn.request('GET', url + '/users/' + username + '/contacts/users', postStr, headers)
"""
{
"action" : "get",
"application" : "4d7e4ba0-dc4a-11e3-90d5-e1ffbaacdaf5",
"params" : { },
"uri" : "https://a1.easemob.com/easemob-demo/chatdemoui/users/v3y0kf9arx/contacts/users",
"entities" : [ ],
"data" : [ "88888" ],
"timestamp" : 1409737366071,
"duration" : 45,
"organization" : "easemob-demo",
"applicationName" : "chatdemoui"
}
"""
response = conn.getresponse()
backdata = response.read(5000)
if response.status >= 400:
debug('func_im.py->getFriends->error:',response.status)
return False,backdata
else:
_dict = JsonRequest(backdata)
data = _dict.get('data',[])
return True,data
except:
print('func_im.py->getFriends->except:', backdata)
return False, '获取好友列表异常'
def getVerifyCode(pPhoneNumber):
#【场景1】用户存在，生成验证码用于重置密码或者其他授权行为
try:
debug('func_user.py->getVerifyCode',1,pPhoneNumber)
lUser = User.objects.get(PhoneNumber=pPhoneNumber)
#怀疑此处异常
#debug('getVerifyCode',2,lUser.PhoneNumber)
return writeVerifyCode(lUser)
#【场景2】用户不存在，直接生成用户，并分配验证码
except User.DoesNotExist:
debug('func_user->getVerifyCode->new User by VerifyCode')
try:
lUser = User(
PhoneNumber = pPhoneNumber,
Password = "******",
Role = "注册中",
hxActivieFlag=False)
lUser.save()
return writeVerifyCode(lUser)
except Exception,ex:
debug('func_user.py->getVerifyCode->except',ex)
return False,'验证码获取异常'
def managerRefreshToken(request):
result,loginUser = LoginStatus(ltoken=get_token(request))
if not result:
infor = loginUser
return JsonResponse(GlobalVar.RspOffLine,infor)
if not (u'管理员' in loginUser.Role):
return JsonResponse(GlobalVar.RspFail,'需要管理员权限')
try:
if request.method == 'GET':
access_token = get_access_token(True)
debug('views_weixin.py->managerRefreshToken->access_token:',access_token)
if access_token is None or 'except' in access_token or access_token == '':
return JsonResponse(GlobalVar.RspFail,'Token刷新失败，请重试')
else:
return JsonResponse(GlobalVar.RspSuccess,access_token)
else:
return JsonResponse(GlobalVar.RspFail,'不支持GET以外的方法')
except:
return JsonResponse(GlobalVar.RspFail,'发生异常')
def wxRelease(request):
#【1】如果方法是Post，提交验证码和电话号码
if request.method == 'POST':
wxLogin = JsonRequest(request.body)
try:
#【1】使用验证码登录
result1,info1,lUser = loginBest(GlobalVar.LoginWeiXinRelease,wxLogin)
#身份校验，验证码比对不通过直接返回，包括用户不存在场景
if not result1:
return JsonResponse(GlobalVar.RspFail,info1)
#【2】验证登录通过之后,根据返回的用户释放微信绑定
#lUser=User.objects.get(PhoneNumber=pPhoneNumber)
rusult2,infor2 = lUser.wxRelease()
debug('wxRelease',rusult2,infor2)
#依据电话号码来查找对应的csrfToken
pPhonNumber = wxLogin.get('PhoneNumber','')
lUserToken = UserToken.objects.filter(idUser__PhoneNumber=pPhonNumber)
#解除绑定之后，还需要将csrfToken清除下线
if lUserToken.count() > 0:
lUserToken.delete()
if rusult2:
return JsonResponse(GlobalVar.RspSuccess,infor2)
else:
return JsonResponse(GlobalVar.RspFail,infor2)
#【2】其他异常
except:
return JsonResponse(GlobalVar.RspFail,'解绑异常')
#微信采用GET方法跳转
elif request.method == 'GET':
return JsonResponse(GlobalVar.RspFail,'不支持操作')
else:
return JsonResponse(GlobalVar.RspFail,'不支持操作')
def managerCreateWeixinMenu(request):
result,loginUser = LoginStatus(ltoken=get_token(request))
if not result:
infor = loginUser
return JsonResponse(GlobalVar.RspOffLine,infor)
if not (u'管理员' in loginUser.Role):
return JsonResponse(GlobalVar.RspFail,'需要管理员权限')
if request.method == 'POST':
#如果是Json格式的菜单，解析出来
_strReq = request.body
result,msg = False,''
if len(_strReq) == 0:
debug('views_weixin.py->managerCreateWeixinMenu->mod:','create without json para')
result,msg = creat_menu()
else:
debug('views_weixin.py->managerCreateWeixinMenu->mod:','create with json para')
result,msg = creat_menu(_strReq)
if result:
return JsonResponse(GlobalVar.RspSuccess,msg)
else:
return JsonResponse(GlobalVar.RspFail,msg)
elif request.method == 'GET':
type = request.GET.get('type','')
#删除所有
if type == 'delete':
result,msg = delete_menu()
if result:
return JsonResponse(GlobalVar.RspSuccess,msg)
else:
return JsonResponse(GlobalVar.RspFail,msg)
else:
return JsonResponse(GlobalVar.RspSuccess,'该方法未定义')
else:
return JsonResponse(GlobalVar.RspSuccess,'Other Method is building')
