def __init__(self, classname):
self.classname = classname
if not self.blacklistAuth:
blacklistAuthHelper = ClassHelper("BlacklistAuth")
items = blacklistAuthHelper.find({})
if items:
self.blacklistAuth = items
def readallCheck(self, className, objid):
recommendHelper = ClassHelper(className)
item = recommendHelper.get(objid)
if item:
sid = None
isBackupUser = False
user = item['user']
if item.has_key('backupUser'):
# 感兴趣
sid = RedisDb.hget( "recommendILatestOid", user)
if not sid:
return
isBackupUser = True
else:
# 相似的
sid = RedisDb.hget( "recommendSLatestOid", user)
if not sid:
return
unreadquery = {'_sid': {"$lte": sid}, 'user': user, "read": {"$exists": False}, "backupUser": {"$exists": isBackupUser}}
unread_count = recommendHelper.query_count( unreadquery )
if unread_count and unread_count > 0:
return
import time
if isBackupUser:
RedisDb.zadd( 'recommendIReadAll', time.time(), user)
else:
RedisDb.zadd( 'recommendSReadAll', time.time(), user)
def get(self, action=None):
if action == "sharerecord": #根据分享记录返回人或face的信息
if not self.request.arguments.has_key('compareId'):
self.write(ERR_PATH_PERMISSION.message)
return
compareId = self.get_argument("compareId")
shareRecordHelper = ClassHelper("ShareRecords")
srItem = shareRecordHelper.get(compareId)
if srItem:
srItem = self.filter_field(srItem)
result = {}
if srItem['shareType'] < 2:
item = self.getUser(srItem['shareTargetId'],
srItem['shareType'])
if item:
result['nickname'] = item['nickName']
result['avatar'] = item['avatar']
if "user" in item:
result['userId'] = item['user']
else:
result['userId'] = item['_id']
else:
result = self.getFace(srItem['shareTargetId'])
result.update(srItem)
self.write(json.dumps(result, cls=MeEncoder))
else:
self.write(ERR_PATH_PERMISSION.message)
else:
self.write(ERR_PATH_PERMISSION.message)
def post(self):
try:
xml = self.request.body
log.debug('xml: %s', xml)
pub = Wxpay_server_pub()
pub.saveData(xml)
log.debug('pub.data: %s', pub.data)
if pub.data['return_code'] == 'SUCCESS' and pub.data[
'result_code'] == 'SUCCESS':
print 'wx call back result is success'
order_no = pub.data.get('out_trade_no', None)
log.debug('out_trade_no:%s', order_no)
if order_no:
flow = ClassHelper("RechargeFlow").find_one({
'orderNo': order_no,
'status': 0
})
if flow:
payUtil.orderCallback(flow['_id'], flow['user'], 1,
pub.data)
else:
order_no = pub.data.get('out_trade_no', None)
if order_no:
flow = ClassHelper("RechargeFlow").find_one({
'orderNo': order_no,
'status': 0
})
if flow:
payUtil.orderCallback(flow['_id'], flow['user'], -1,
pub.data)
except Exception, e:
log.err(e)
msg = traceback.format_exc()
log.err(msg)
def delete(self, className, objectId):
if not objectId:
self.write(ERR_PARA.message)
return
if BaseConfig.deleteClass.count(className) <= 0:
self.write(ERR_USER_PERMISSION.message)
return
try:
ObjectId(objectId)
except Exception:
self.write(ERR_OBJECTID_MIS.message)
return
classHelper = ClassHelper(className)
obj = classHelper.find_one({"_id": objectId})
if not obj:
self.write(ERR_OBJECTID_MIS.message)
return
mo = MeObject(className, obj, False)
mo.overLoadGet = False
acl = MeACL(mo['acl'])
if not acl.deleteAccess(self.user):
self.write(ERR_USER_PERMISSION.message)
return
else:
try:
classHelper.delete(objectId)
self.write(ERR_SUCCESS.message)
except Exception, e:
log.err("ClassHandler-->delete error, %s", e)
self.write(ERR_DB_OPERATION.message)
def getMosicLevel(userId, face, media, good=None, hasUser=False):
"""
获取照片马赛克等级
:param userId: 登录用户
:param face: 人脸object
:param media: 照片object
:param good: 商品object
:param hasUser: 照片中是否有用户
:return:
"""
assign = face.get('assign')
# 我贡献的0
if assign and assign.get('assigner') == userId:
return 0
# 我购买过的1
charge_helper = ClassHelper('ChargeFlow')
charge_record = charge_helper.find_one({
'user': userId,
'goods': good['_id'],
'status': 1
}) if good else None
if charge_record:
return 1
if not hasUser:
hasUser = _mediaHasUser(media, userId)
# 照片中有我5
if hasUser:
return 5
# 默认10
return 10
def getId(self, className, query):
classHelper = ClassHelper(className)
result = classHelper.find_one(query,keys={"_id":1,"acl":1})
acl = MeACL(result['acl'])
if not acl.readAccess(self.user):
return None
return result['_id']
def __init__(self, className, method, userId):
self.className = className
self.method = method
self.userId = userId
if not self.autoMessage:
autoMessageClassHelper = ClassHelper("AutoMessage")
items = autoMessageClassHelper.find({})
for item in items:
self.autoMessage[(item['classname'], item['method'])] = item
def getJson(self, className, query):
classHelper = ClassHelper(className)
result = classHelper.find_one(query)
mo = MeObject(className, result, False)
mo.overLoadGet = False
acl = MeACL(mo['acl'])
if not acl.readAccess(self.user):
return None
return mo
def get(self, oid, child=False):
from mecloud.helper.ClassHelper import ClassHelper
classHelper = ClassHelper(self.className)
obj = classHelper.get(oid)
# if obj == None:
# return False
self.copySelf(obj, child)
self.dirty.clear()
return obj
def orderCallback(oId, userId, status, order):
logger.debug('oId:%s, userId:%s, status:%d, order:%s', oId, userId, status,
order)
'''
根据支付结果更新订单的状态
:param oId:RechargeFlow Id
:param userId:用户Id
:param status: 支付是否成功，1为成功，0为失败
:param order:第三方平台返回订单信息，包括错误码
:return:
'''
item = {"$set": {"status": status, "order": order}}
###更新充值流水记录
orderHelper = ClassHelper("RechargeFlow")
rechargeFlow = orderHelper.update(oId, item)
if rechargeFlow and status == 1:
###更新钱包
walletHelper = ClassHelper("Wallet")
walletInfo = walletHelper.find_one({"user": userId})
if walletInfo:
wallet = {"$inc": {'balance': rechargeFlow['amount']}}
wallet = walletHelper.update(walletInfo['_id'], wallet)
else:
wallet = {"user": userId, 'balance': rechargeFlow['amount']}
walletHelper.create(wallet)
if wallet:
return wallet.update(rechargeFlow)
else:
return None
else:
return None
def create_face_db(face_info):
"""
创建数据库face记录
:param face_info:
:return:
"""
face_helper = ClassHelper('Face')
now = datetime.datetime.now()
face_info['createAt'] = face_info['updateAt'] = now
face_info['acl'] = {'*': {"read": True, "write": True}}
return face_helper.create(face_info)
def filterAuTH(self, userId, obj):
for auth in self.blacklistAuth:
if self.classname == auth['classname']:
classHelper = ClassHelper("Blacklist")
item = classHelper.find_one({
'user': obj[auth['foreign']],
"blacker": userId
})
if item:
log.warn("user %s black blacker %s", obj[auth['foreign']],
userId)
return None
return obj
def get(self, classname=None):
# 查看钱包余额
if classname not in ['wallet']:
self.write(ERR_PATH_PERMISSION.message)
return
query = {'user': self.user['_id']}
obj = {'user': self.user['_id'].decode(), 'balance': 0, 'income': 0}
if not self.check_field('Wallet', obj):
return
walletHelper = ClassHelper("Wallet")
objects = walletHelper.findCreate(query, obj)
self.filter_field(objects)
self.write(json.dumps(objects, cls=MeEncoder))
def addFeedRecord(userId, feedType, actionId, extraInfo=None):
"""
给用户添加feed记录
:param userId: 发出动作的用户
:param feedType: 行为,包括认领,关注.分享,购买
:param actionId: 关联的事件id,目前只有认领,actionId为faceid
:param extraInfo:
:return:
"""
faceHelper = ClassHelper('Face')
face = faceHelper.get(actionId)
if not face:
return
assign = face.get('assign')
if assign and assign.get('status') == 1:
assigner = assign.get('assigner')
else:
assigner = None
fansHelper = ClassHelper('Followee')
feedHelper = ClassHelper('InBox')
fans = fansHelper.find({'followee': userId, 'effect': {'$gt': 0}})
feedUserIds = []
for fan in fans:
feedInfo = {
'user': fan['user'],
'type': feedType,
'actionId': actionId,
'read': False
}
if extraInfo:
feedInfo['extraInfo'] = extraInfo
feedHelper.create(feedInfo)
feedUserIds.append(fan['user'])
rc = Redis.get_connection()
for user in feedUserIds:
count = Redis.incrby('user_unread_feed_count_%s' % user, 1)
message_json = {
'to_id': user,
'count': count,
't': 'feed',
'uri': 'honey://newFeed/$' + userId
}
publish_result = rc.publish(
'push_channel', json.dumps(message_json, ensure_ascii=False))
log.debug('public_result: %s', publish_result)
# 发推送
if not assigner == user:
message = {'userid': user, 'action': 'newFeed', 'otherid': userId}
requests.post(BaseConfig.pushUrl,
data=json.dumps(message),
headers={'X-MeCloud-Debug': '1'})
def login(self):
versionNo = self.request.headers.get("X-MeCloud-AppVersion", None)
platform = self.request.headers.get("X-MeCloud-Platform", None)
print 'BaseConfig.mode:', BaseConfig.mode
if BaseConfig.mode == 'online' and platform == 'iOS':
inReview_config = ClassHelper('VersionControl').find_one({
'platform':
platform,
'versionNo':
int(versionNo),
'settingName':
'inReview'
})
print 'inReview_config:', inReview_config
if inReview_config and inReview_config[
'switch'] is True and self.jsonBody[
'password'] == 'd6e6729cc66fd4656e3d6664ceaca28b':
user = ClassHelper('User').find_one({'device': '13800138000'})
del (user['password'])
self.write(json.dumps(user, cls=MeEncoder))
self.set_secure_cookie("u", user['_id'])
new_cookie = str(self._new_cookie.get('u')).split(
'=')[1].split(';')[0].replace('"', '')
print new_cookie
print user['_id']
if new_cookie is not None:
self.set_user_cookie_record(new_cookie, user['_id'])
return
user = MeUser(self.jsonBody)
print 'when login username, password:'******'username'], user[
'password']
if user['username'] == None or user['password'] == None:
self.write(ERR_PARA.message)
print 'when login username, password:'******'username'], user[
'password']
if user.login(user['username'], user['password']):
del (user['password'])
self.write(json.dumps(user, cls=MeEncoder))
self.set_secure_cookie("u", user['_id'])
# userid = self.get_secure_cookie("u")
# cookie = self.get_cookie("u")
new_cookie = str(
self._new_cookie.get('u')).split('=')[1].split(';')[0].replace(
'"', '')
# new_cookie = str(self._new_cookie.get('u')).split('"')[1]
print new_cookie
print user['_id']
if new_cookie is not None:
self.set_user_cookie_record(new_cookie, user['_id'])
else:
self.write(ERR_USERPWD_MISMATCH.message)
def getList(self, className, query):
classHelper = ClassHelper(className)
result = classHelper.find(query)
objects = []
for obj in result:
mo = MeObject(className, obj, False)
mo.overLoadGet = False
acl = MeACL(mo['acl'])
if not acl.readAccess(self.user):
continue
objects.append(mo)
if len(objects) == 0:
return None
return objects
def getCountUser(self, userId, isUser=1):
item = profile(userId, isUser)
obj = copy.deepcopy(item)
item['assignersCount'] = item.get('assigners', 0)
item['followersCount'] = item.get('followers', 0)
item['imageCount'] = item.get('medias', 0)
faceHelper = ClassHelper('Face')
toClaimCount = faceHelper.query_count({
'assign.user': userId,
'assign.status': 0
}) or 0
item['toClaimCount'] = toClaimCount
if item['assignersCount'] and item['followersCount'] and item[
'imageCount'] and item['toClaimCount']:
return item
return obj
def unfollow(user, followee, is_user=True):
if not user or not followee:
log.err("FollowHelper-->unfollow userId:%s, followeeId %s", user,
followee)
return
if is_user:
fieldname = "followee"
else:
fieldname = "backupFollowee"
followHelper = ClassHelper(FollowHelper.classame)
result = followHelper.find_one({
'user': followee,
'followee': user,
'effect': {
'$gte': 2
}
})
if result:
#双向关注,需要处理followee的双向关注effect和粉丝数量
followHelper.updateOne({
'user': followee,
fieldname: user
}, {"$set": {
'effect': 1,
'updateAt': result['updateAt']
}})
# 取消我的关注
followee_action = {
'destClass': 'StatCount',
'query': {
'name': 'followees_' + user
},
'action': {
'@inc': {
'count': -1
}
}
}
follower_action = {
'destClass': 'StatCount',
'query': {
'name': 'followers_' + followee
},
'action': {
'@inc': {
'count': -1
}
}
}
actions = [follower_action, followee_action]
followHelper.updateOne({
'user': user,
fieldname: followee
}, {"$set": {
'effect': 0
}},
transactions=actions,
upsert=True)
def check(self):
username = self.get_argument('username', None)
print '--------------------------------------------------------------check device - username', username
user = ClassHelper('User').find_one({'username': username})
if user:
r = {'errCode': 0, 'exist': True}
else:
r = {'errCode': 0, 'exist': False}
self.write(r)
def get_media_id_list_from_db():
"""
从db中获取media_id列表
:return:
"""
last_id = get_last_cal_id() or None
media_helper = ClassHelper('Media')
query = {'faces': {'$exists': False}}
if last_id:
query['_id'] = {'$gt': last_id}
medias = media_helper.find(query=query,
keys={"_id": 1},
sort=[("_id", 1)],
limit=MEDIA_COUNT_LIMIT)
media_id_list = []
for media in medias:
media_id_list.append(media['_id'])
return media_id_list
def put(self, action=None):
if action == "update":
try:
obj = json.loads(self.request.body)
except Exception, e:
log.err("JSON Error:[%d/%s] , error:%s",
len(self.request.body), self.request.body, str(e))
self.write(ERR_INVALID.message)
return
classHelper = ClassHelper("User")
# 只返回了更新时间
try:
data = classHelper.update(self.user['_id'], obj)
# 默认返回整个对象
self.write(json.dumps(data, cls=MeEncoder))
except Exception, e:
log.err("UserHandler-->update in put() error, %s", e)
self.write(e.message)
def _mediaHasUser(media, user):
"""
图片中是否有用户
:param media:
:param user:
:return:
"""
faces = media.get('faces', [])
if not faces:
return False
face_helper = ClassHelper('Face')
for faceId in faces:
face = face_helper.get(faceId)
assign = face.get('assign', None)
if not assign:
continue
if assign.get('user', None) == user and assign.get('status') == 1:
return True
return False
def orderCallback(self, oId, userId, status, order):
'''
根据支付结果更新订单的状态
:param oId:RechargeFlow Id
:param userId:用户Id
:param status: 支付是否成功，1为成功，3为等待验证
:param order:第三方平台返回订单信息，包括错误码
:return:
'''
###更新充值流水记录
orderHelper = ClassHelper("RechargeFlow")
rechargeFlow = orderHelper.get(oId)
walletHelper = ClassHelper("Wallet")
walletInfo = walletHelper.find_one({"user": userId})
if status == 1: # 充值成功,更新钱包
rechargeFlow_action = {
'destClass': 'RechargeFlow',
'query': {
"_id": oId
},
'action': {
"@set": {
"status": status,
"order": order
}
}
}
if not walletInfo: # 未找到钱包直接创建
wallet = {"user": userId, 'balance': rechargeFlow['amount']}
walletInfo = walletHelper.create(
wallet, transaction=[rechargeFlow_action])
else:
wallet = {"$inc": {'balance': rechargeFlow['amount']}}
walletInfo = walletHelper.update(
walletInfo['_id'],
wallet,
transaction=[rechargeFlow_action])
return walletInfo
else:
rechargeFlow = orderHelper.update(
oId, {"$set": {
"status": status,
"order": order
}})
return rechargeFlow
def getUser(self, userId, isUser=-1):
if isUser == 1:
userHelper = ClassHelper("UserInfo")
obj = userHelper.find_one({'user': userId}) or {}
else:
obj = ClassHelper("BackupUser").get(userId) or {}
if not obj:
userHelper = ClassHelper("UserInfo")
obj = userHelper.find_one({'user': userId}) or {}
return self.filter_field(obj)
def sentMessage(self, obj):
item = self.autoMessage.get((self.className, self.method), None)
if not item:
return
userClassHelper = ClassHelper("UserInfo")
userInfo = userClassHelper.find_one({"user": self.userId},
{'nickName': 1})
if not userInfo:
return
obj.update(userInfo)
title = item['title'].format(**obj)
template = item['template'].format(**obj)
# TODO
pushData = {"userid": obj['to'], "title": title, "text": template}
log.info("Push Data:%s", json.dumps(pushData))
try:
res = requests.post(self.pushUrl,
data=json.dumps(pushData),
headers={'X-MeCloud-Debug': '1'})
print res.text
except Exception, ex:
log.err("Push Err:%s", ex)
def put(self, className, objectId=None):
try:
if not objectId and not self.request.arguments.has_key('where'):
self.write(ERR_OBJECTID_MIS.message)
return
try:
if objectId:
try:
ObjectId(objectId)
except Exception:
self.write(ERR_OBJECTID_MIS.message)
return
obj = json.loads(self.request.body)
except Exception, e:
log.err("JSON Error:[%d/%s] , error:%s", len(self.request.body), self.request.body, str(e))
self.write(ERR_INVALID.message)
return
if self.request.arguments.has_key('where'):
classHelper = ClassHelper(className)
query = eval(self.get_argument('where'))
if "$set" in obj:
obj['$set'] = self.check_field(className, obj['$set'])
else:
obj = self.check_field(className, obj)
if not obj:
return
returnObj = classHelper.updateOneCreate(query, obj)
data = copy.deepcopy(ERR_SUCCESS)
data.message['data'] = self.filter_field(returnObj)
self.write(json.dumps(data.message, cls=MeEncoder))
elif type(obj) == list:
objectIdError = False
for index in range(len(obj) - 1):
try:
for key, value in obj[index].items():
if value.has_key('_sid'):
ObjectId(value['_sid'])
value = self.sentiveCheck(key, value)
meobj = MeObject(key, value)
meobj.save()
except bson.errors.InvalidId:
objectIdError = True
break
except Exception, e:
log.err("Error:%s , error:%s", self.request.body, str(e))
if objectIdError:
self.write(ERR_OBJECTID_MIS.message)
return
mainObj = obj[len(obj) - 1]
mainObj = self.sentiveCheck(className, mainObj)
classHelper = ClassHelper(className)
# 只返回了更新时间
try:
data = classHelper.update(objectId, mainObj)
# 默认返回整个对象
self.write(json.dumps(data, cls=MeEncoder))
except Exception, e:
log.err("ClassV2Handler-->put error, %s", e)
self.write(ERR_DB_OPERATION.message)
def save(self):
from mecloud.helper.ClassHelper import ClassHelper
classHelper = ClassHelper(self.className)
if self.objectId == None:
if self.dirty.has_key('_sid'):
self.dirty['_id'] = ObjectId(self.dirty['_sid'])
del (self.dirty['_sid'])
obj = classHelper.create(self.dirty)
if obj == None:
return False
self.objectId = obj['_id']
else:
obj = classHelper.updateWithId(self.objectId, self.dirty)
if obj == None:
return False
for k in obj:
dict.__setitem__(self, k, obj[k])
self.dirty.clear()
return True
def start_face_cal():
"""
开始计算人脸向量
:return:
"""
media_helper = ClassHelper('Media')
client = RedisDb.get_connection(dbid=1)
redis_key = _build_media_redis_key()
while client.llen(redis_key):
media_id = client.lpop(redis_key)
media = media_helper.get(media_id)
if not media:
log.err('media not found: %s' % media_id)
continue
faces = get_faces_from_media_id(media_id)
face_ids = []
for face_info in faces:
face_info['media'] = media_id
face = create_face_db(face_info)
face_ids.append(face['_id'])
# 没有获取到的话就不更新了
if face_ids:
media_helper.update(media_id, {'$set': {'faces': face_ids}})
log.info('media face calculate finish: %s' % media_id)
def getFace(self, faceId):
faceHelper = ClassHelper("Face")
obj = faceHelper.find_one(query={"_id": faceId},
keys={
"rect": 1,
"possible.score": 1,
"file": 1
}) or {}
item = {}
item['faceId'] = faceId
item['rect'] = obj['rect']
item['file'] = obj['file']
item['score'] = obj['possible'][0]['score']
# user = {}
# if obj:
# if "uploader" in obj:
# user = self.getUser(obj['uploader'],1)
# elif "backupUser" in obj:
# user = self.getUser(obj['backupUser'], 0)
# else:
# pass
# user = self.filter_field(user)
# obj = self.filter_field(obj)
return item