def __init__(self, classname):
self.classname = classname
if not self.blacklistAuth:
blacklistAuthHelper = ClassHelper("BlacklistAuth")
items = blacklistAuthHelper.find({})
if items:
self.blacklistAuth = items
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 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 get_specific_count(userid):
'''
:param userid:
:return:{}
followers 粉丝
followees 关注的人
uploaders 贡献的照片数量
medias 拥有的照片数量
faces 拥有的脸的数量
assigners 有多少人贡献照片
'''
l = ['followers', 'followees', 'uploaders', 'medias', 'faces', 'assigners']
result = {}
for i in l:
result[i] = 0
stat_unique_helper = ClassHelper('StatCount')
query = {
'$or': [{
'name': l[0] + '_' + userid
}, {
'name': l[1] + '_' + userid
}, {
'name': l[2] + '_' + userid
}, {
'name': l[3] + '_' + userid
}, {
'name': l[4] + '_' + userid
}, {
'name': l[5] + '_' + userid
}]
}
objs = stat_unique_helper.find(query)
# print 'objs:', objs
if objs:
for obj in objs:
for i in l:
if obj['name'] == i + '_' + userid:
result[i] = obj['count']
break
# print 'result:', result
return result
def get(self, userId, count, isuser=1):
faceHelper = ClassHelper('FaceRecommend')
isExistBackupUser = False
field_name = 'user'
if int(isuser) == 0:
field_name = 'backupUser'
isExistBackupUser = True
oid = self.get_argument('objectId', None)
if oid:
query = {field_name: userId, 'read': {'$exists': False}, 'backupUser': {'$exists': isExistBackupUser},
'_id': {'$lt': oid}}
else:
query = {field_name: userId, 'read': {'$exists': False}, 'backupUser': {'$exists': isExistBackupUser}}
sort = {'_id': -1}
fs = faceHelper.find(query, sort=sort, limit=int(count))
faces = []
for face in fs:
if face.has_key('createAt'):
del (face['createAt'])
del (face['updateAt'])
del (face['acl'])
if face.has_key('backupUser'):
face['user'] = face['backupUser']
del (face['backupUser'])
face['mosaic'] = 5
faces.append(face)
result = deepcopy(ERR_SUCCESS.message)
result['data'] = faces
result['count'] = faceHelper.query_count({'user': userId})
result['unread'] = faceHelper.query_count({'user': userId, 'read': {'$exists': False}})
print result
self.write(result)
def get(self, className, objectId=None):
# if className == "User":
# self.write(ERR_CLASS_PERMISSION.message)
# return
if objectId:
try:
ObjectId(objectId)
except Exception:
self.write(ERR_OBJECTID_MIS.message)
return
obj = MeObject(className)
if not obj.get(objectId):
self.write(ERR_OBJECTID_MIS.message)
else:
mo = obj.get(objectId)
# self.filter_field(mo)
self.write(json.dumps(mo, cls=MeEncoder))
else:
classHelper = ClassHelper(className)
query = {}
objs = None
if self.request.arguments.has_key('aggregate'):
query = eval(self.get_argument('aggregate'))
objs = classHelper.aggregate(query)
else:
if self.request.arguments.has_key('where'):
query = eval(self.get_argument('where'))
try:
if query.has_key('_id'):
ObjectId(query['_id'])
if query.has_key('$or'):
for item in query['$or']:
if "_id" in item:
item["_id"] = ObjectId(item["_id"])
except Exception:
self.write(ERR_OBJECTID_MIS.message)
return
if self.request.arguments.has_key('keys'):
keys = eval(self.get_argument('keys'))
else:
keys = None
try:
sort = json.loads(self.get_argument('sort', '{}'))
idSort = sort.get('_id', -1)
sort = sort or None
except Exception, e:
self.write(ERR_INVALID.message)
print e
return
skip = 0
limit = 20
try:
if self.request.arguments.has_key('skip'):
skip = int(self.get_argument('skip'))
if self.request.arguments.has_key('limit'):
limit = int(self.get_argument('limit'))
except Exception:
self.write(ERR_INVALID.message)
return
if limit > 100:
self.write(ERR_INVALID.message)
return
objs = classHelper.find(query, keys, sort, limit, skip)
objects = []
for obj in objs:
mo = MeObject(className, obj, False)
mo.overLoadGet = False
acl = MeACL(mo['acl'])
# if not acl.readAccess(self.user):
# continue
# self.filter_field(mo)
objects.append(mo)
self.write(json.dumps(objects, cls=MeEncoder))
def get(self, action):
if action == "albumUser": #弃用，用下面的那个
classHelper = ClassHelper("Face")
result = classHelper.find({
"$and": [{
'createAt': {
'$gt': '2017-09-20 00:00:00'
}
}, {
'createAt': {
'$lt': '2017-10-01 00:00:00'
}
}]
})
print "++++++++++++++++++++++++"
for res in result:
print 'test', res
break
elif action == "albumUserTwo":
classHelper = ClassHelper('Media')
items = classHelper.aggregate([
{
# '$match': {'uploader': "59dc3decca7143413c03a62f", 'publish': False}
'$match': {
'uploader': self.user['_id'],
'publish': False
}
},
{
'$project': {
'faces': 1
}
},
{
'$unwind': "$faces"
},
{
"$lookup": {
"from": "Face",
"localField": "faces",
"foreignField": "_sid",
"as": "faceInfo"
}
},
{
'$unwind': "$faceInfo"
},
{
"$project": {
"faces": 1,
"possible": "$faceInfo.possible",
'media': "$faceInfo.media"
}
},
{
"$unwind": "$possible"
},
{
'$group': {
"_id": {
'userId': "$possible.user",
"backupUserId": "$possible.backupUser"
},
"media": {
'$first': "$media"
},
"count": {
'$sum': 1
}
}
},
{
"$sort": {
"count": -1
}
},
{
'$lookup': {
"from": "UserInfo",
"localField": "_id.userId",
"foreignField": "user",
"as": "userInfo"
}
},
{
'$lookup': {
"from": "BackupUser",
"localField": "_id.backupUserId",
"foreignField": "_sid",
"as": "backupUserInfo"
}
}
])
userInfo = []
for obj in items:
try:
if obj['userInfo']:
userInfo.append({
'nickName':
obj['userInfo'][0].get('nickName', None),
'userId':
obj["_id"]['userId'],
'count':
obj['count']
})
else:
userInfo.append({
'nickName':
obj['backupUserInfo'][0].get('nickName', None),
'backupUserId':
obj["_id"]['backupUserId'],
'count':
obj['count']
})
except Exception, e:
log.err(
"MyHandler-->get user(backup) info err for userId:%s",
obj['_id'])
data = copy.deepcopy(ERR_SUCCESS)
data.message['data'] = userInfo
self.write(json.dumps(data.message, cls=MeEncoder))
def get(self, className, objectId=None):
admin = False
if self.get_current_user() in BaseConfig.adminUser:
admin = True
if not admin:
if className in BaseConfig.accessNoClass:
self.write(ERR_CLASS_PERMISSION.message)
return
if className not in BaseConfig.projectClass:
#不存在的class
self.write(ERR_PATH_PERMISSION.message)
return
verify = self.verify_cookie(className)
if not verify:
self.write(ERR_UNAUTHORIZED.message)
return
if objectId:
try:
ObjectId(objectId)
except Exception:
self.write(ERR_OBJECTID_MIS.message)
return
obj = MeObject(className)
if not obj.get(objectId):
self.write(ERR_OBJECTID_MIS.message)
else:
mo = obj.get(objectId)
self.filter_field(mo)
self.write(json.dumps(mo, cls=MeEncoder))
else:
classHelper = ClassHelper(className)
query = {}
objs = None
if self.request.arguments.has_key('aggregate'):
query = eval(self.get_argument('aggregate'))
objs = classHelper.aggregate(query)
else:
if self.request.arguments.has_key('where'):
query = eval(self.get_argument('where'))
try:
if query.has_key('_id'):
ObjectId(query['_id'])
if query.has_key('$or'):
for item in query['$or']:
if "_id" in item:
item["_id"] = ObjectId(item["_id"])
except Exception:
self.write(ERR_OBJECTID_MIS.message)
return
if self.request.arguments.has_key('keys'):
keys = eval(self.get_argument('keys'))
else:
keys = None
try:
sort = json.loads(self.get_argument('sort', '{}'))
idSort = sort.get('_id', -1)
sort = sort or None
except Exception, e:
self.write(ERR_INVALID.message)
print e
return
try:
if self.request.arguments.has_key('startId'):
startId = self.get_argument('startId')
if idSort == -1:
query["_id"] = {"$lt": ObjectId(startId)}
elif idSort == 1:
query["_id"] = {"$gt": ObjectId(startId)}
if self.request.arguments.has_key('limit'):
limit = int(self.get_argument('limit'))
else:
limit = 20
except Exception:
self.write(ERR_INVALID.message)
return
skip = 0
try:
if self.request.arguments.has_key('skip'):
skip = int(self.get_argument('skip'))
except Exception:
self.write(ERR_INVALID.message)
return
if limit > 100:
self.write(ERR_INVALID.message)
return
objs = classHelper.find(query, keys, sort, limit, skip)
objects = []
for obj in objs:
mo = MeObject(className, obj, False)
mo.overLoadGet = False
if self.get_current_user() and not admin:
acl = MeACL(mo['acl'])
if not acl.readAccess(self.user):
continue
self.filter_field(mo)
objects.append(mo)
self.write(json.dumps(objects, cls=MeEncoder))
