def getPotential(self,
blogId,
excludeSources=True,
offset=None,
limit=None,
detailed=True,
qu=None,
qs=None):
'''
@see: IBlogCollaboratorService.getPotential
'''
sqlBlog = self.session().query(BlogCollaboratorMapped.Id).filter(
BlogCollaboratorMapped.Blog == blogId)
sql = self.session().query(CollaboratorMapped)
sql = sql.join(UserMapped, CollaboratorMapped.User == UserMapped.Id)
sql = sql.join(SourceMapped,
SourceMapped.Id == CollaboratorMapped.Source)
sql = sql.filter(not_(CollaboratorMapped.Id.in_(sqlBlog)))
sql = sql.filter(UserMapped.Active == True)
sql = sql.filter(UserMapped.Type == self.default_user_type_key)
sql = sql.filter(SourceMapped.Name == self.internal_source_name)
sql = sql.order_by(CollaboratorMapped.Name)
if excludeSources: sql = sql.filter(CollaboratorMapped.User != None)
if qu: sql = buildQuery(sql, qu, UserMapped)
if qs: sql = buildQuery(sql, qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.distinct(),
sql.distinct().count(), offset, limit)
return sqlLimit.distinct()
def getPublished(self, blogId, typeId=None, creatorId=None, authorId=None, thumbSize=None, offset=None, limit=None,
detailed=False, q=None):
'''
@see: IBlogPostService.getPublished
'''
assert q is None or isinstance(q, QBlogPostPublished), 'Invalid query %s' % q
sql = self._filterQuery(blogId, typeId, creatorId, authorId)
sqlMore = None
if q:
if QWithCId.cId in q and q.cId:
sql = sql.filter(BlogPostMapped.CId != None)
# sql = sql.filter((BlogPostMapped.PublishedOn != None) | ((BlogPostMapped.CId != None) & (BlogPostMapped.DeletedOn == None)))
sqlMore = buildQuery(sql, q, BlogPostMapped, exclude=QWithCId.cId)
sql = buildQuery(sql, q, BlogPostMapped)
if not sqlMore:
sql = sql.filter((BlogPostMapped.PublishedOn != None) & (BlogPostMapped.DeletedOn == None))
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sqlLimit = buildLimits(sql, offset, limit)
posts = self._addImages(self._trimPosts(sqlLimit.all()), thumbSize)
if detailed:
posts = IterPost(posts, sql.count(), offset, limit)
posts.lastCId = self.session().query(func.MAX(BlogPostMapped.CId)).filter(BlogPostMapped.Blog == blogId).scalar()
if sqlMore: posts.offsetMore = sqlMore.count()
else: posts.offsetMore = posts.total
return posts
def getAll(self,
userId=None,
sourceId=None,
offset=None,
limit=None,
detailed=False,
qu=None,
qs=None):
'''
@see: ICollaboratorService.getAll
'''
sql = self.session().query(CollaboratorMapped)
sql = sql.outerjoin(UserMapped).filter(UserMapped.DeletedOn == None)
if userId is not None:
sql = sql.filter(CollaboratorMapped.User == userId)
if sourceId is not None:
sql = sql.filter(CollaboratorMapped.Source == sourceId)
if qu is not None:
sql = buildQuery(sql.join(UserMapped), qu, UserMapped)
if qs is not None:
sql = buildQuery(sql.join(SourceMapped), qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getPotential(self,
blogId,
excludeSources=True,
offset=None,
limit=None,
detailed=True,
qu=None,
qs=None):
'''
@see: IBlogCollaboratorService.getPotential
'''
sqlBlog = self.session().query(BlogCollaboratorMapped.Id).filter(
BlogCollaboratorMapped.Blog == blogId)
sql = self.session().query(CollaboratorMapped).join(UserMapped).join(
SourceMapped)
sql = sql.filter(not_(CollaboratorMapped.Id.in_(sqlBlog)))
sql = sql.filter(UserMapped.DeletedOn == None)
sql = sql.order_by(CollaboratorMapped.Name)
if excludeSources: sql = sql.filter(CollaboratorMapped.User != None)
if qu: sql = buildQuery(sql, qu, UserMapped)
if qs: sql = buildQuery(sql, qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sql.all()
def getPluginMessages(self, plugin, offset=None, limit=None, detailed=False, qm=None, qs=None):
'''
@see: IMessageService.getPluginMessages
'''
sql = self.session().query(Message).join(Source).filter(Source.Plugin == plugin)
if qm: sql = buildQuery(sql, qm, Message)
if qs: sql = buildQuery(sql, qs, Source)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getMetaInfos(self,
scheme,
offset=None,
limit=None,
qi=None,
qd=None,
thumbSize=None):
'''
Provides the meta data based on unified multi-plugin criteria.
'''
sql = self.session().query(MetaInfoMapped)
if qi is not None:
assert isinstance(qi, self.QMetaInfo), 'Invalid query %s' % qi
metaInfos = self.queryIndexer.metaInfos.copy()
assert isinstance(metaInfos, set)
for name in namesForQuery(qi):
if getattr(self.QMetaInfo, name) not in qi: continue
criteriaMetaInfos = self.queryIndexer.metaInfoByCriteria.get(
name)
assert criteriaMetaInfos, 'No model class available for %s' % name
metaInfos.intersection(criteriaMetaInfos)
sql = buildQuery(sql, qi, MetaInfoMapped)
for metaInfo in metaInfos:
sql = sql.join(metaInfo)
try:
sql = buildQuery(sql, qi, metaInfo)
except:
raise Exception('Cannot build query for meta info %s' %
metaInfo)
if qd is not None:
assert isinstance(qd, self.QMetaData), 'Invalid query %s' % qd
metaDatas = self.queryIndexer.metaDatas.copy()
assert isinstance(metaDatas, set)
for name in namesForQuery(qd):
if getattr(self.QMetaData, name) not in qd: continue
criteriaMetaDatas = self.queryIndexer.metaDataByCriteria.get(
name)
assert criteriaMetaDatas, 'No model class available for %s' % name
metaDatas.intersection(criteriaMetaDatas)
sql = sql.join(MetaDataMapped)
sql = buildQuery(sql, qd, MetaDataMapped)
for metaData in metaDatas:
sql = sql.join(metaData)
sql = buildQuery(sql, qd, metaData)
sql = buildLimits(sql, offset, limit)
return sql.all()
def getMessages(self, sourceId=None, offset=None, limit=None, detailed=False, qm=None, qs=None):
'''
@see: IMessageService.getMessages
'''
sql = self.session().query(Message)
if sourceId: sql = sql.filter(Message.Source == sourceId)
if qm: sql = buildQuery(sql, qm, Message)
if qs: sql = buildQuery(sql.join(Source), qs, Source)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getAll(self, personId=None, sourceId=None, offset=None, limit=None, detailed=False, qp=None, qs=None):
'''
@see: ICollaboratorService.getAll
'''
sql = self.session().query(CollaboratorMapped)
if personId: sql = sql.filter(CollaboratorMapped.Person == personId)
if sourceId: sql = sql.filter(CollaboratorMapped.Source == sourceId)
if qp: sql = buildQuery(sql.join(PersonMapped), qp, PersonMapped)
if qs: sql = buildQuery(sql.join(SourceMapped), qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getAll(self, userId=None, sourceId=None, offset=None, limit=None, detailed=False, qu=None, qs=None):
'''
@see: ICollaboratorService.getAll
'''
sql = self.session().query(CollaboratorMapped)
if userId: sql = sql.filter(CollaboratorMapped.User == userId)
sql = sql.filter(UserMapped.DeletedOn == None)
if sourceId: sql = sql.filter(CollaboratorMapped.Source == sourceId)
if qu: sql = buildQuery(sql.join(UserMapped), qu, UserMapped)
if qs: sql = buildQuery(sql.join(SourceMapped), qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getComponentMessages(self, component, offset=None, limit=None, detailed=False, qm=None, qs=None):
"""
@see: IMessageService.getComponentMessages
"""
sql = self.session().query(Message).join(Source).filter(Source.Component == component)
if qm:
sql = buildQuery(sql, qm, Message)
if qs:
sql = buildQuery(sql, qs, Source)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def buildSubquery(self, session, metaInfo, metaData, qa, qi, qd, types):
sql = session.query(MetaDataMapped)
if metaInfo == MetaInfoMapped and metaData == MetaDataMapped:
if types:
sql = sql.join(MetaTypeMapped,
MetaTypeMapped.Id == MetaDataMapped.typeId)
sql = sql.filter(MetaTypeMapped.Type.in_(types))
elif metaInfo != MetaInfoMapped:
sql = sql.join(
MetaTypeMapped,
and_(
MetaTypeMapped.Id == MetaDataMapped.typeId,
MetaTypeMapped.Type == self.queryIndexer.typesByMetaInfo[
metaInfo.__name__]))
elif metaData != MetaDataMapped:
sql = sql.join(
MetaTypeMapped,
and_(
MetaTypeMapped.Id == MetaDataMapped.typeId,
MetaTypeMapped.Type == self.queryIndexer.typesByMetaData[
metaData.__name__]))
sql = sql.join(MetaInfoMapped,
MetaDataMapped.Id == MetaInfoMapped.MetaData)
sql = sql.add_entity(MetaInfoMapped)
if qi: sql = buildQuery(sql, qi, metaInfo)
if qd: sql = buildQuery(sql, qd, metaData)
if qi and metaInfo != MetaInfoMapped:
sql = buildQuery(sql, qi, MetaInfoMapped)
if qd and metaData != MetaDataMapped:
sql = buildQuery(sql, qd, MetaDataMapped)
if qi: sql = buildExpressionQuery(sql, qi, metaInfo, qa)
if qd: sql = buildExpressionQuery(sql, qd, metaData, qa)
if qi and metaInfo != MetaInfoMapped:
sql = buildExpressionQuery(sql, qi, MetaInfoMapped, qa)
if qd and metaData != MetaDataMapped:
sql = buildExpressionQuery(sql, qd, MetaDataMapped, qa)
if qa and qa.all:
assert isinstance(qa, QMetaDataInfo), 'Invalid query %s' % qa
sql = buildAllQuery(
sql, qa.all, self.queryIndexer.queryByInfo[metaInfo.__name__],
metaInfo, self.queryIndexer.queryByData[metaData.__name__],
metaData)
return sql
def buildSql(self, dataId, languageId, qi, qd):
'''
Build the sql alchemy based on the provided data.
'''
sql = self.session().query(self.MetaInfo)
if dataId: sql = sql.filter(self.MetaInfo.MetaData == dataId)
if languageId: sql = sql.filter(self.MetaInfo.Language == languageId)
if qi:
assert isinstance(qi, self.QMetaInfo), 'Invalid meta info query %s' % qi
sql = buildQuery(sql, qi, self.MetaInfo)
if qd:
assert isinstance(qd, self.QMetaData), 'Invalid meta data query %s' % qd
sql = buildQuery(sql.join(self.MetaData), qd, self.MetaData)
return sql
def buildSql(self, dataId, languageId, qi, qd):
'''
Build the sql alchemy based on the provided data.
'''
sql = self.session().query(self.MetaInfo)
if dataId: sql = sql.filter(self.MetaInfo.MetaData == dataId)
if languageId: sql = sql.filter(self.MetaInfo.Language == languageId)
if qi:
assert isinstance(qi, self.QMetaInfo), 'Invalid meta info query %s' % qi
sql = buildQuery(sql, qi, self.MetaInfo)
if qd:
assert isinstance(qd, self.QMetaData), 'Invalid meta data query %s' % qd
sql = buildQuery(sql.join(self.MetaData), qd, self.MetaData)
return sql
def getPotential(self, blogId, excludeSources=True, offset=None, limit=None, detailed=True, qu=None, qs=None):
'''
@see: IBlogCollaboratorService.getPotential
'''
sqlBlog = self.session().query(BlogCollaboratorMapped.Id).filter(BlogCollaboratorMapped.Blog == blogId)
sql = self.session().query(CollaboratorMapped).join(UserMapped).join(SourceMapped)
sql = sql.filter(not_(CollaboratorMapped.Id.in_(sqlBlog)))
sql = sql.filter(UserMapped.DeletedOn == None)
sql = sql.order_by(CollaboratorMapped.Name)
if excludeSources: sql = sql.filter(CollaboratorMapped.User != None)
if qu: sql = buildQuery(sql, qu, UserMapped)
if qs: sql = buildQuery(sql, qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sql.all()
def _getAll(self, filter=None, query=None, offset=None, limit=None, sqlQuery=None):
"""
Provides all the entities for the provided filter, with offset and limit. Also if query is known to the
service then also a query can be provided.
@param filter: SQL alchemy filtering|None
The sql alchemy conditions to filter by.
@param query: query
The REST query object to provide filtering on.
@param offset: integer|None
The offset to fetch elements from.
@param limit: integer|None
The limit of elements to get.
@param sqlQuery: SQL alchemy|None
The sql alchemy query to use.
@return: list
The list of all filtered and limited elements.
"""
if limit == 0:
return []
sqlQuery = sqlQuery or self.session().query(self.Entity)
if filter is not None:
sqlQuery = sqlQuery.filter(filter)
if query:
assert self.QEntity, "No query provided for the entity service"
assert self.queryType.isValid(query), "Invalid query %s, expected %s" % (query, self.QEntity)
sqlQuery = buildQuery(sqlQuery, query, self.Entity)
sqlQuery = buildLimits(sqlQuery, offset, limit)
return (entity for entity in sqlQuery.all())
def _getAllWithCount(self,
filter=None,
query=None,
offset=None,
limit=None,
sql=None):
'''
Provides all the entities for the provided filter, with offset and limit and the total count. Also if query is
known to the service then also a query can be provided.
@param filter: SQL alchemy filtering|None
The sql alchemy conditions to filter by.
@param query: query
The REST query object to provide filtering on.
@param offset: integer|None
The offset to fetch elements from.
@param limit: integer|None
The limit of elements to get.
@param sql: SQL alchemy|None
The sql alchemy query to use.
@return: tuple(list, integer)
The list of all filtered and limited elements and the count of the total elements.
'''
sql = sql or self.session().query(ItemMapped)
if filter is not None: sql = sql.filter(filter)
if query:
assert self.queryType.isValid(
query), 'Invalid query %s, expected %s' % (query, QItem)
sql = buildQuery(sql, query, ItemMapped)
sqlLimit = buildLimits(sql, offset, limit)
if limit == 0: return (), sql.count()
return sqlLimit.all(), sql.count()
def getChainedPosts(self,
blogId,
sourceTypeKey,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IBlogSourceService.getChainedPosts
'''
sql = self.session().query(PostMapped)
sql = sql.join(CollaboratorMapped).join(SourceMapped).join(
SourceTypeMapped)
sql = sql.filter(SourceTypeMapped.Key == sourceTypeKey)
sql = sql.join(BlogSourceDB,
SourceMapped.Id == BlogSourceDB.source).filter(
BlogMapped.Id == blogId)
if q:
assert isinstance(q, QPostWithPublished), 'Invalid query %s' % q
sql = buildQuery(sql, q, PostMapped)
if q and QPostWithPublished.isPublished in q:
if q.isPublished.value:
sql = sql.filter(PostMapped.PublishedOn != None)
else:
sql = sql.filter(PostMapped.PublishedOn == None)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getAll(self, typeKey=None, offset=None, limit=None, detailed=False, q=None):
"""
@see: ISourceService.getAll
"""
sql = self.session().query(SourceMapped)
if typeKey:
sql = sql.join(SourceTypeMapped).filter(SourceTypeMapped.Key == typeKey)
if q:
assert isinstance(q, QSource), "Invalid source query %s" % q
sql = buildQuery(sql, q, SourceMapped)
if QSource.all in q:
filter = None
if AsLike.like in q.all:
for col in ALL_NAMES:
filter = col.like(q.all.like) if filter is None else filter | col.like(q.all.like)
elif AsLike.ilike in q.all:
for col in ALL_NAMES:
filter = col.ilike(q.all.ilike) if filter is None else filter | col.ilike(q.all.ilike)
sql = sql.filter(filter)
# TODO: Hack to be able to get the list of the chained blog sources for a blog;
# It should be removed when the new version of ally-py is used
if QSource.blogId in q:
sqlIn = self.session().query(BlogSourceDB.source).filter(BlogSourceDB.blog == q.blogId.equal)
sql = sql.filter(SourceMapped.Id.in_(sqlIn))
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getRights(self,
userId,
typeId=None,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IUserRbacService.getRights
'''
if limit == 0: entities = ()
else: entities = None
if detailed or entities is None:
rbacId = self.rbacIdFor(userId)
if not rbacId:
return IterPart((), 0, offset, limit) if detailed else ()
sql = self.rbacService.rightsForRbacSQL(rbacId)
if typeId: sql = sql.filter(RightMapped.Type == typeId)
if q:
assert isinstance(q, QRight), 'Invalid query %s' % q
sql = buildQuery(sql, q, RightMapped)
if entities is None:
entities = buildLimits(sql, offset, limit).all()
if detailed: return IterPart(entities, sql.count(), offset, limit)
return entities
def getAll(self, offset=None, limit=None, detailed=False, q=None):
'''
@see: IUserService.getAll
'''
if limit == 0: entities = ()
else: entities = None
if detailed or entities is None:
sql = self.session().query(UserMapped)
activeUsers = True
if q:
assert isinstance(q, QUser), 'Invalid query %s' % q
sql = buildQuery(sql, q, UserMapped)
if QUser.all in q:
filter = None
if AsLike.like in q.all:
for col in ALL_NAMES:
filter = col.like(q.all.like) if filter is None else filter | col.like(q.all.like)
elif AsLike.ilike in q.all:
for col in ALL_NAMES:
filter = col.ilike(q.all.ilike) if filter is None else filter | col.ilike(q.all.ilike)
sql = sql.filter(filter)
if (QUser.inactive in q) and (AsBoolean.value in q.inactive):
activeUsers = not q.inactive.value
sql = sql.filter(UserMapped.Active == activeUsers)
sql = sql.filter(UserMapped.Type == self.default_user_type_key)
if entities is None: entities = buildLimits(sql, offset, limit).all()
if detailed: return IterPart(entities, sql.count(), offset, limit)
return entities
def _buildQuery(self, languageId=None, userId=None, q=None):
'''
Builds the general query for blogs.
'''
sql = self.session().query(BlogMapped)
#Hide deleted blogs
sql = sql.filter(BlogMapped.DeletedOn == None)
if languageId: sql = sql.filter(BlogMapped.Language == languageId)
if userId:
#TODO: change it for the new version of Ally-Py, where it is a complete implementation of security
qRole = QRole()
qRole.name = self.admin_role
isAdmin = len(self.roleService.getRoles(userId, q=qRole))
if not isAdmin:
userFilter = (BlogMapped.Creator == userId) | exists().where((CollaboratorMapped.User == userId) \
& (BlogCollaboratorMapped.blogCollaboratorId == CollaboratorMapped.Id) \
& (BlogCollaboratorMapped.Blog == BlogMapped.Id))
sql = sql.filter(userFilter)
if q:
assert isinstance(q, QBlog), 'Invalid query %s' % q
sql = buildQuery(sql, q, BlogMapped)
if (QBlog.isOpen in q) and (AsBoolean.value in q.isOpen):
if q.isOpen.value:
sql = sql.filter(BlogMapped.ClosedOn == None)
else:
sql = sql.filter(BlogMapped.ClosedOn != None)
return sql
def getByBlog(self,
blogId,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see IBlogSyncService.getByBlog
'''
sql = self.session().query(BlogSyncMapped)
if q:
assert isinstance(q, QBlogSync), 'Invalid blog sync query %s' % q
sql = buildQuery(sql, q, BlogSyncMapped)
sql = sql.join(SourceMapped, SourceMapped.Id == BlogSyncMapped.Source)
sql = sql.join(BlogSourceDB, SourceMapped.Id == BlogSourceDB.source)
sql = sql.filter(BlogSourceDB.blog == blogId)
sql_prov = self.session().query(SourceMapped.URI)
sql_prov = sql_prov.join(SourceTypeMapped,
SourceTypeMapped.id == SourceMapped.typeId)
sql_prov = sql_prov.filter(
SourceTypeMapped.Key == self.blog_provider_type)
sql = sql.filter(SourceMapped.OriginURI.in_(sql_prov))
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def _getAll(self,
filter=None,
query=None,
offset=None,
limit=None,
sql=None):
'''
Provides all the entities for the provided filter, with offset and limit. Also if query is known to the
service then also a query can be provided.
@param filter: SQL alchemy filtering|None
The sql alchemy conditions to filter by.
@param query: query
The REST query object to provide filtering on.
@param offset: integer|None
The offset to fetch elements from.
@param limit: integer|None
The limit of elements to get.
@param sql: SQL alchemy|None
The sql alchemy query to use.
@return: list
The list of all filtered and limited elements.
'''
if limit == 0: return []
sql = sql or self.session().query(self.Entity)
if filter is not None: sql = sql.filter(filter)
if query:
assert self.QEntity, 'No query provided for the entity service'
assert self.queryType.isValid(
query), 'Invalid query %s, expected %s' % (query, self.QEntity)
sql = buildQuery(sql, query, self.Entity)
sql = buildLimits(sql, offset, limit)
return sql.all()
def _buildQuery(self, languageId=None, userId=None, q=None):
'''
Builds the general query for blogs.
'''
sql = self.session().query(BlogMapped)
#Hide deleted blogs
sql = sql.filter(BlogMapped.DeletedOn == None)
if languageId: sql = sql.filter(BlogMapped.Language == languageId)
if userId:
#TODO: change it for the new version of Ally-Py, where it is a complete implementation of security
qRole = QRole()
qRole.name = self.admin_role
isAdmin = len(self.roleService.getRoles(userId, q=qRole))
if not isAdmin:
userFilter = (BlogMapped.Creator == userId) | exists().where((CollaboratorMapped.User == userId) \
& (BlogCollaboratorMapped.blogCollaboratorId == CollaboratorMapped.Id) \
& (BlogCollaboratorMapped.Blog == BlogMapped.Id))
sql = sql.filter(userFilter)
if q:
assert isinstance(q, QBlog), 'Invalid query %s' % q
sql = buildQuery(sql, q, BlogMapped)
if (QBlog.isOpen in q) and (AsBoolean.value in q.isOpen):
if q.isOpen.value:
sql = sql.filter(BlogMapped.ClosedOn == None)
else:
sql = sql.filter(BlogMapped.ClosedOn != None)
return sql
def getAll(self, offset=None, limit=None, detailed=False, q=None):
'''
@see: IUserService.getAll
'''
if limit == 0: entities = ()
else: entities = None
if detailed or entities is None:
sql = self.session().query(UserMapped)
sql = sql.filter(UserMapped.DeletedOn == None)
if q:
assert isinstance(q, QUser), 'Invalid query %s' % q
sql = buildQuery(sql, q, UserMapped)
if QUser.all in q:
filter = None
if AsLike.like in q.all:
for col in ALL_NAMES:
filter = col.like(
q.all.like
) if filter is None else filter | col.like(
q.all.like)
elif AsLike.ilike in q.all:
for col in ALL_NAMES:
filter = col.ilike(
q.all.ilike
) if filter is None else filter | col.ilike(
q.all.ilike)
sql = sql.filter(filter)
if entities is None:
entities = buildLimits(sql, offset, limit).all()
if detailed: return IterPart(entities, sql.count(), offset, limit)
return entities
def getAll(self, adminId, offset=None, limit=None, detailed=False, q=None):
"""
@see: IUserService.getAll
"""
if limit == 0:
entities = ()
else:
entities = None
if detailed or entities is None:
sql = self.session().query(UserMapped)
sql = sql.filter(UserMapped.DeletedOn == None)
if q:
assert isinstance(q, QUser), "Invalid query %s" % q
sql = buildQuery(sql, q, UserMapped)
if QUser.all in q:
filter = None
if AsLike.like in q.all:
for col in ALL_NAMES:
filter = col.like(q.all.like) if filter is None else filter | col.like(q.all.like)
elif AsLike.ilike in q.all:
for col in ALL_NAMES:
filter = col.ilike(q.all.ilike) if filter is None else filter | col.ilike(q.all.ilike)
sql = sql.filter(filter)
if entities is None:
entities = buildLimits(sql, offset, limit).all()
if detailed:
return IterPart(entities, sql.count(), offset, limit)
return entities
def _getAllWithCount(self, filter=None, query=None, offset=None, limit=None, sql=None):
'''
Provides all the entities for the provided filter, with offset and limit and the total count. Also if query is
known to the service then also a query can be provided.
@param filter: SQL alchemy filtering|None
The sql alchemy conditions to filter by.
@param query: query
The REST query object to provide filtering on.
@param offset: integer|None
The offset to fetch elements from.
@param limit: integer|None
The limit of elements to get.
@param sql: SQL alchemy|None
The sql alchemy query to use.
@return: tuple(list, integer)
The list of all filtered and limited elements and the count of the total elements.
'''
sql = sql or self.session().query(self.Entity)
if filter is not None: sql = sql.filter(filter)
if query:
assert self.QEntity, 'No query provided for the entity service'
assert self.queryType.isValid(query), 'Invalid query %s, expected %s' % (query, self.QEntity)
sql = buildQuery(sql, query, self.Entity)
sqlLimit = buildLimits(sql, offset, limit)
if limit == 0: return (), sql.count()
return sqlLimit.all(), sql.count()
def getAll(self,
typeKey=None,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: ISourceService.getAll
'''
sql = self.session().query(SourceMapped)
if typeKey:
sql = sql.join(SourceTypeMapped).filter(
SourceTypeMapped.Key == typeKey)
if q:
assert isinstance(q, QSource), 'Invalid source query %s' % q
sql = buildQuery(sql, q, SourceMapped)
if QSource.all in q:
filter = None
if AsLike.like in q.all:
for col in ALL_NAMES:
filter = col.like(
q.all.like
) if filter is None else filter | col.like(q.all.like)
elif AsLike.ilike in q.all:
for col in ALL_NAMES:
filter = col.ilike(
q.all.ilike
) if filter is None else filter | col.ilike(
q.all.ilike)
sql = sql.filter(filter)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def buildQuery(self, session, offset=None, limit=1000, q=None):
'''
@see: IArticleSearchProvider.buildQuery()
'''
sql = session.query(ArticleMapped)
if q:
sql = buildQuery(sql, q, ArticleMapped)
sql = sql.join(PersonMapped,
ArticleMapped.Author == PersonMapped.Id)
sql = sql.join(UserMapped, ArticleMapped.Creator == UserMapped.Id)
if QArticle.search in q:
all = processLike(
q.search.ilike
) if q.search.ilike is not None else processLike(q.search.like)
sql = sql.filter(
or_(PersonMapped.FullName.like(all),
UserMapped.FullName.like(all),
ArticleMapped.Content.like(all)))
count = sql.count()
sql = buildLimits(sql, offset, limit)
return (sql, count)
def _getAll(self, filter=None, query=None, offset=None, limit=None, sql=None):
'''
Provides all the entities for the provided filter, with offset and limit. Also if query is known to the
service then also a query can be provided.
@param filter: SQL alchemy filtering|None
The sql alchemy conditions to filter by.
@param query: query
The REST query object to provide filtering on.
@param offset: integer|None
The offset to fetch elements from.
@param limit: integer|None
The limit of elements to get.
@param sql: SQL alchemy|None
The sql alchemy query to use.
@return: list
The list of all filtered and limited elements.
'''
if limit == 0: return []
sql = sql or self.session().query(ItemMapped)
if filter is not None: sql = sql.filter(filter)
if query:
assert self.queryType.isValid(query), 'Invalid query %s, expected %s' % (query, QItem)
sql = buildQuery(sql, query, ItemMapped)
sql = buildLimits(sql, offset, limit)
return sql.all()
def getMetaInfos(self, scheme, offset=None, limit=None, qi=None, qd=None, thumbSize=None):
'''
Provides the meta data based on unified multi-plugin criteria.
'''
sql = self.session().query(MetaInfoMapped)
if qi is not None:
assert isinstance(qi, self.QMetaInfo), 'Invalid query %s' % qi
metaInfos = self.queryIndexer.metaInfos.copy()
assert isinstance(metaInfos, set)
for name in namesForQuery(qi):
if getattr(self.QMetaInfo, name) not in qi: continue
criteriaMetaInfos = self.queryIndexer.metaInfoByCriteria.get(name)
assert criteriaMetaInfos, 'No model class available for %s' % name
metaInfos.intersection(criteriaMetaInfos)
sql = buildQuery(sql, qi, MetaInfoMapped)
for metaInfo in metaInfos:
sql = sql.join(metaInfo)
try:
sql = buildQuery(sql, qi, metaInfo)
except :
raise Exception('Cannot build query for meta info %s' % metaInfo)
if qd is not None:
assert isinstance(qd, self.QMetaData), 'Invalid query %s' % qd
metaDatas = self.queryIndexer.metaDatas.copy()
assert isinstance(metaDatas, set)
for name in namesForQuery(qd):
if getattr(self.QMetaData, name) not in qd: continue
criteriaMetaDatas = self.queryIndexer.metaDataByCriteria.get(name)
assert criteriaMetaDatas, 'No model class available for %s' % name
metaDatas.intersection(criteriaMetaDatas)
sql = sql.join(MetaDataMapped)
sql = buildQuery(sql, qd, MetaDataMapped)
for metaData in metaDatas:
sql = sql.join(metaData)
sql = buildQuery(sql, qd, metaData)
sql = buildLimits(sql, offset, limit)
return sql.all()
def getPluginMessages(self,
plugin,
offset=None,
limit=None,
detailed=False,
qm=None,
qs=None):
'''
@see: IMessageService.getPluginMessages
'''
sql = self.session().query(Message).join(Source).filter(
Source.Plugin == plugin)
if qm: sql = buildQuery(sql, qm, Message)
if qs: sql = buildQuery(sql, qs, Source)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getUnpublishedBySource(self, sourceId, thumbSize=None, offset=None, limit=None, detailed=False, q=None):
'''
@see: IBlogPostService.getUnpublished
'''
assert q is None or isinstance(q, QBlogPostUnpublished), 'Invalid query %s' % q
postVerification = aliased(PostVerificationMapped, name='post_verification_filter')
sql = self.session().query(BlogPostMapped)
sql = sql.filter(BlogPostMapped.Feed == sourceId)
deleted = False
if q:
if QBlogPostUnpublished.isDeleted in q:
deleted = q.isDeleted.value
sql = buildQuery(sql, q, BlogPostMapped)
if q:
if QWithCId.search in q:
all = self._processLike(q.search.ilike) if q.search.ilike is not None else self._processLike(q.search.like)
sql = sql.filter(or_(BlogPostMapped.Meta.ilike(all), BlogPostMapped.CreatedOn.ilike(all), \
BlogPostMapped.Content.ilike(all), BlogPostMapped.ContentPlain.ilike(all), \
))
if QWithCId.status in q or QWithCId.checker in q:
sql = sql.join(postVerification, postVerification.Id == BlogPostMapped.Id)
sql = sql.join(VerificationStatusMapped, VerificationStatusMapped.id == postVerification.statusId)
if QWithCId.status in q:
sql = sql.filter(VerificationStatusMapped.Key == q.status.equal)
if QWithCId.checker in q:
sql = sql.filter(postVerification.Checker == q.checker.equal)
if (QWithCId.cId not in q) or (QWithCId.cId in q and QWithCId.cId.start not in q \
and QWithCId.cId.end not in q and QWithCId.cId.since not in q and QWithCId.cId.until not in q):
sql = sql.filter(BlogPostMapped.PublishedOn == None)
if deleted: sql = sql.filter(BlogPostMapped.DeletedOn != None)
else: sql = sql.filter(BlogPostMapped.DeletedOn == None)
else: sql = sql.filter((BlogPostMapped.PublishedOn == None) & (BlogPostMapped.DeletedOn == None))
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sqlLimit = buildLimits(sql, offset, limit)
posts = self._addImages(self._trimPosts(sqlLimit.distinct(), deleted= not deleted, unpublished=False, published=True), thumbSize)
if detailed:
posts = IterPost(posts, sql.distinct().count(), offset, limit)
lastCidSql = self.session().query(func.MAX(BlogPostMapped.CId))
lastCidSql = lastCidSql.join(CollaboratorMapped, BlogPostMapped.Creator == CollaboratorMapped.User)
lastCidSql = lastCidSql.filter(CollaboratorMapped.Source == sourceId)
posts.lastCId = lastCidSql.scalar()
return posts
def getMessages(self,
sourceId=None,
offset=None,
limit=None,
detailed=False,
qm=None,
qs=None):
'''
@see: IMessageService.getMessages
'''
sql = self.session().query(Message)
if sourceId: sql = sql.filter(Message.Source == sourceId)
if qm: sql = buildQuery(sql, qm, Message)
if qs: sql = buildQuery(sql.join(Source), qs, Source)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getPublished(self,
blogId,
typeId=None,
creatorId=None,
authorId=None,
thumbSize=None,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IBlogPostService.getPublished
'''
assert q is None or isinstance(
q, QBlogPostPublished), 'Invalid query %s' % q
sql = self._filterQuery(blogId, typeId, creatorId, authorId, q)
sqlMore = None
if q:
if QWithCId.cId in q and q.cId:
sql = sql.filter(BlogPostMapped.CId != None)
# sql = sql.filter((BlogPostMapped.PublishedOn != None) | ((BlogPostMapped.CId != None) & (BlogPostMapped.DeletedOn == None)))
sqlMore = buildQuery(sql,
q,
BlogPostMapped,
exclude=QWithCId.cId)
sql = buildQuery(sql, q, BlogPostMapped)
if not sqlMore:
sql = sql.filter((BlogPostMapped.PublishedOn != None)
& (BlogPostMapped.DeletedOn == None))
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sqlLimit = buildLimits(sql, offset, limit)
posts = self._addImages(self._trimPosts(sqlLimit.all()), thumbSize)
if detailed:
posts = IterPost(posts, sql.count(), offset, limit)
posts.lastCId = self.session().query(func.MAX(
BlogPostMapped.CId)).filter(
BlogPostMapped.Blog == blogId).scalar()
if sqlMore: posts.offsetMore = sqlMore.count()
else: posts.offsetMore = posts.total
return posts
def getPotential(self, blogId, excludeSources=True, offset=None, limit=None, detailed=True, qu=None, qs=None):
'''
@see: IBlogCollaboratorService.getPotential
'''
sqlBlog = self.session().query(BlogCollaboratorMapped.Id).filter(BlogCollaboratorMapped.Blog == blogId)
sql = self.session().query(CollaboratorMapped)
sql = sql.join(UserMapped, CollaboratorMapped.User == UserMapped.Id)
sql = sql.join(SourceMapped, SourceMapped.Id == CollaboratorMapped.Source)
sql = sql.filter(not_(CollaboratorMapped.Id.in_(sqlBlog)))
sql = sql.filter(UserMapped.Active == True)
sql = sql.filter(UserMapped.Type == self.default_user_type_key)
sql = sql.filter(SourceMapped.Name == self.internal_source_name)
sql = sql.order_by(CollaboratorMapped.Name)
if excludeSources: sql = sql.filter(CollaboratorMapped.User != None)
if qu: sql = buildQuery(sql, qu, UserMapped)
if qs: sql = buildQuery(sql, qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.distinct(), sql.distinct().count(), offset, limit)
return sqlLimit.distinct()
def buildSql(self, typeId, q):
'''
Build the sql alchemy based on the provided data.
'''
sql = self.session().query(self.MetaData)
if typeId: sql = sql.filter(self.MetaData.typeId == typeId)
if q:
assert isinstance(q, self.QMetaData)
sql = buildQuery(sql, q, self.MetaData)
return sql
def buildSql(self, typeId, q):
'''
Build the sql alchemy based on the provided data.
'''
sql = self.session().query(self.MetaData)
if typeId: sql = sql.filter(self.MetaData.typeId == typeId)
if q:
assert isinstance(q, self.QMetaData)
sql = buildQuery(sql, q, self.MetaData)
return sql
def _buildQuery(self, blogTypeId, typeId=None, q=None):
'''
Builds the general query for posts.
'''
sql = self.session().query(BlogTypePostMapped)
sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId)
if typeId: sql = sql.join(PostTypeMapped).filter(PostTypeMapped.Key == typeId)
if q:
sql = buildQuery(sql, q, BlogTypePostMapped)
return sql
def _buildQuery(self, blogId, typeId=None, creatorId=None, authorId=None, q=None):
'''
Builds the general query for posts.CollaboratorMapped
'''
sql = self._filterQuery(blogId, typeId, creatorId, authorId, q)
if q:
sql = buildQuery(sql, q, BlogPostMapped)
if QPostUnpublished.deletedOn not in q and QWithCId.cId not in q:
sql = sql.filter(BlogPostMapped.DeletedOn == None)
return sql
def getAll(self, typeKey=None, offset=None, limit=None, detailed=False, q=None):
'''
@see: ISourceService.getAll
'''
sql = self.session().query(SourceMapped)
if typeKey:
sql = sql.join(SourceTypeMapped).filter(SourceTypeMapped.Key == typeKey)
if q: sql = buildQuery(sql, q, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getAll(self,
personId=None,
sourceId=None,
offset=None,
limit=None,
detailed=False,
qp=None,
qs=None):
'''
@see: ICollaboratorService.getAll
'''
sql = self.session().query(CollaboratorMapped)
if personId: sql = sql.filter(CollaboratorMapped.Person == personId)
if sourceId: sql = sql.filter(CollaboratorMapped.Source == sourceId)
if qp: sql = buildQuery(sql.join(PersonMapped), qp, PersonMapped)
if qs: sql = buildQuery(sql.join(SourceMapped), qs, SourceMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def _buildQuery(self, blogTypeId, typeId=None, q=None):
'''
Builds the general query for posts.
'''
sql = self.session().query(BlogTypePostMapped)
sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId)
if typeId:
sql = sql.join(PostTypeMapped).filter(PostTypeMapped.Key == typeId)
if q:
sql = buildQuery(sql, q, BlogTypePostMapped)
return sql
def _buildQuery(self, creatorId=None, authorId=None, q=None):
'''
Builds the general query for posts.
'''
sql = self.session().query(PostMapped)
if creatorId: sql = sql.filter(PostMapped.Creator == creatorId)
if authorId: sql = sql.filter(PostMapped.Author == authorId)
addDeleted = False
if q:
sql = buildQuery(sql, q, PostMapped)
addDeleted = QPostUnpublished.deletedOn in q
if not addDeleted: sql = sql.filter(PostMapped.DeletedOn == None)
return sql
def buildQuery(self, session, scheme, offset=None, limit=1000, q=None):
'''
@see: IArticleSearchProvider.buildQuery()
Creates the solr query, executes the query against Solr server. Then build a SQL query that will return
the Solr founded data.
'''
sql = session.query(Article)
if q:
sql = buildQuery(sql, q, self.Entity)
sql = buildLimits(sql, offset, limit)
def _buildQuery(self, creatorId=None, authorId=None, q=None):
'''
Builds the general query for posts.
'''
sql = self.session().query(PostMapped)
if creatorId: sql = sql.filter(PostMapped.Creator == creatorId)
if authorId: sql = sql.filter(PostMapped.Author == authorId)
addDeleted = False
if q:
sql = buildQuery(sql, q, PostMapped)
addDeleted = QPostUnpublished.deletedOn in q
if not addDeleted: sql = sql.filter(PostMapped.DeletedOn == None)
return sql
def buildQuery(self, session, scheme, offset=None, limit=1000, q=None):
'''
@see: IArticleSearchProvider.buildQuery()
Creates the solr query, executes the query against Solr server. Then build a SQL query that will return
the Solr founded data.
'''
sql = session.query(Article)
if q:
sql = buildQuery(sql, q, self.Entity)
sql = buildLimits(sql, offset, limit)
def _buildQueryWithCId(self, q, sql):
if q:
if QWithCId.cId in q and q.cId:
if AsRange.start in q.cId:
sql = sql.filter(PostMapped.Id >= q.cId.start)
if AsRange.since in q.cId:
sql = sql.filter(PostMapped.Id > q.cId.since)
if AsRange.end in q.cId:
sql = sql.filter(PostMapped.Id <= q.cId.end)
if AsRange.until in q.cId:
sql = sql.filter(PostMapped.Id < q.cId.until)
sql = buildQuery(sql, q, PostMapped)
return sql
def _buildQueryWithCId(self, q, sql):
if q:
if QWithCId.cId in q and q.cId:
if AsRange.start in q.cId:
sql = sql.filter(PostMapped.Id >= q.cId.start)
if AsRange.since in q.cId:
sql = sql.filter(PostMapped.Id > q.cId.since)
if AsRange.end in q.cId:
sql = sql.filter(PostMapped.Id <= q.cId.end)
if AsRange.until in q.cId:
sql = sql.filter(PostMapped.Id < q.cId.until)
sql = buildQuery(sql, q, PostMapped)
return sql
def buildSubquery(self, session, metaInfo, metaData, qa, qi, qd, types):
sql = session.query(MetaDataMapped)
if metaInfo == MetaInfoMapped and metaData == MetaDataMapped:
if types:
sql = sql.join(MetaTypeMapped, MetaTypeMapped.Id == MetaDataMapped.typeId)
sql = sql.filter(MetaTypeMapped.Type.in_(types))
elif metaInfo != MetaInfoMapped:
sql = sql.join(MetaTypeMapped, and_(MetaTypeMapped.Id == MetaDataMapped.typeId, MetaTypeMapped.Type == self.queryIndexer.typesByMetaInfo[metaInfo.__name__]))
elif metaData != MetaDataMapped:
sql = sql.join(MetaTypeMapped, and_(MetaTypeMapped.Id == MetaDataMapped.typeId, MetaTypeMapped.Type == self.queryIndexer.typesByMetaData[metaData.__name__]))
sql = sql.join(MetaInfoMapped, MetaDataMapped.Id == MetaInfoMapped.MetaData)
sql = sql.add_entity(MetaInfoMapped)
if qi: sql = buildQuery(sql, qi, metaInfo)
if qd: sql = buildQuery(sql, qd, metaData)
if qi and metaInfo != MetaInfoMapped:
sql = buildQuery(sql, qi, MetaInfoMapped)
if qd and metaData != MetaDataMapped:
sql = buildQuery(sql, qd, MetaDataMapped)
if qi: sql = buildExpressionQuery(sql, qi, metaInfo, qa)
if qd: sql = buildExpressionQuery(sql, qd, metaData, qa)
if qi and metaInfo != MetaInfoMapped:
sql = buildExpressionQuery(sql, qi, MetaInfoMapped, qa)
if qd and metaData != MetaDataMapped:
sql = buildExpressionQuery(sql, qd, MetaDataMapped, qa)
if qa and qa.all:
assert isinstance(qa, QMetaDataInfo), 'Invalid query %s' % qa
sql = buildAllQuery(sql, qa.all, self.queryIndexer.queryByInfo[metaInfo.__name__], metaInfo,
self.queryIndexer.queryByData[metaData.__name__], metaData)
return sql
def getAll(self, parentId, offset=None, limit=None, detailed=False, q=None):
'''
@see: IConfigurationService.getAll
'''
sql = self.session().query(self.ConfigurationMapped)
sql = sql.filter(self.ConfigurationMapped.parent == parentId)
if q:
assert isinstance(q, QConfiguration), 'Invalid query'
sql = buildQuery(sql, q, self.ConfigurationMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getRights(self, roleId, offset=None, limit=None, detailed=False, q=None):
'''
@see: IRoleService.getRights
'''
if limit == 0: entities = ()
else: entities = None
if detailed or entities is None:
sql = self.rbacService.rightsForRbacSQL(roleId)
if q:
assert isinstance(q, QRight), 'Invalid query %s' % q
sql = buildQuery(sql, q, RightMapped)
if entities is None: entities = buildLimits(sql, offset, limit).all()
if detailed: return IterPart(entities, sql.count(), offset, limit)
return entities
def getComments(self, blogId, offset=None, limit=None, detailed=False, q=None):
'''
@see: IBlogCommentService.getComments
'''
sql = self.session().query(BlogPostMapped).filter(BlogPostMapped.Blog == blogId)
sql = sql.join(CollaboratorMapped).join(SourceMapped).join(SourceTypeMapped)
sql = sql.filter(SourceTypeMapped.Key == self.source_type_key)
if q:
assert isinstance(q, QBlogPost), 'Invalid query %s' % q
sql = buildQuery(sql, q, BlogPostMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def _buildQuery(self, languageId=None, adminId=None, q=None):
"""
Builds the general query for blogs.
"""
sql = self.session().query(BlogMapped)
if languageId:
sql = sql.filter(BlogMapped.Language == languageId)
if adminId:
sql = sql.filter(
(BlogMapped.Creator == adminId)
| exists().where((AdminEntry.adminId == adminId) & (AdminEntry.Blog == BlogMapped.Id))
)
if q:
assert isinstance(q, QBlog), "Invalid query %s" % q
sql = buildQuery(sql, q, BlogMapped)
return sql
def _buildQuery(self, languageId=None, userId=None, q=None):
'''
Builds the general query for blogs.
'''
sql = self.session().query(BlogMapped)
if languageId: sql = sql.filter(BlogMapped.Language == languageId)
if userId:
userFilter = (BlogMapped.Creator == userId) | exists().where((CollaboratorMapped.User == userId) \
& (BlogCollaboratorMapped.blogCollaboratorId == CollaboratorMapped.Id) \
& (BlogCollaboratorMapped.Blog == BlogMapped.Id))
sql = sql.filter(userFilter)
if q:
assert isinstance(q, QBlog), 'Invalid query %s' % q
sql = buildQuery(sql, q, BlogMapped)
return sql
def _buildQuery(self,
blogId,
typeId=None,
creatorId=None,
authorId=None,
q=None):
'''
Builds the general query for posts.CollaboratorMapped
'''
sql = self._filterQuery(blogId, typeId, creatorId, authorId, q)
if q:
sql = buildQuery(sql, q, BlogPostMapped)
if QPostUnpublished.deletedOn not in q and QWithCId.cId not in q:
sql = sql.filter(BlogPostMapped.DeletedOn == None)
return sql
def getAll(self,
typeKey=None,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: ISourceService.getAll
'''
sql = self.session().query(SourceMapped)
if typeKey:
sql = sql.join(SourceTypeMapped).filter(
SourceTypeMapped.Key == typeKey)
if q:
assert isinstance(q, QSource), 'Invalid source query %s' % q
sql = buildQuery(sql, q, SourceMapped)
if QSource.all in q:
filter = None
if AsLike.like in q.all:
for col in ALL_NAMES:
filter = col.like(
q.all.like
) if filter is None else filter | col.like(q.all.like)
elif AsLike.ilike in q.all:
for col in ALL_NAMES:
filter = col.ilike(
q.all.ilike
) if filter is None else filter | col.ilike(
q.all.ilike)
sql = sql.filter(filter)
#TODO: Hack to be able to get the list of the chained blog sources for a blog;
#It should be removed when the new version of ally-py is used
if QSource.blogId in q:
sqlIn = self.session().query(BlogSourceDB.source).filter(
BlogSourceDB.blog == q.blogId.equal)
sql = sql.filter(SourceMapped.Id.in_(sqlIn))
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getAll(self,
parentId,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IConfigurationService.getAll
'''
sql = self.session().query(self.ConfigurationMapped)
sql = sql.filter(self.ConfigurationMapped.parent == parentId)
if q:
assert isinstance(q, QConfiguration), 'Invalid query'
sql = buildQuery(sql, q, self.ConfigurationMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getRights(self,
roleId,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IRoleService.getRights
'''
if limit == 0: entities = ()
else: entities = None
if detailed or entities is None:
sql = self.rbacService.rightsForRbacSQL(roleId)
if q:
assert isinstance(q, QRight), 'Invalid query %s' % q
sql = buildQuery(sql, q, RightMapped)
if entities is None:
entities = buildLimits(sql, offset, limit).all()
if detailed: return IterPart(entities, sql.count(), offset, limit)
return entities
