def getPublishedBySource(self,
sourceId,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IPostService.getPublishedBySource
'''
assert q is None or isinstance(q,
QPostPublished), 'Invalid query %s' % q
sql = self._buildQueryBySource(sourceId)
sql = sql.filter(PostMapped.PublishedOn != None)
sql = self._buildQueryWithCId(q, sql)
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
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,
blogId,
typeKey=None,
offset=None,
limit=None,
detailed=False):
'''
@see: IBlogMediaService.getAll
'''
sql = self.session().query(BlogMediaMapped)
sql = sql.filter(BlogMediaMapped.Blog == blogId)
if typeKey:
sql = sql.join(BlogMediaTypeMapped).filter(
BlogMediaMapped.Type == typeKey)
sql = sql.order_by(BlogMediaMapped.Id)
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 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 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 getAll(self,
blogId=None,
themeId=None,
offset=None,
limit=None,
detailed=False,
q=None):
'''
@see: IBlogSeo.getAll
'''
sql = self.session().query(BlogSeoMapped)
if blogId: sql = sql.filter(BlogSeoMapped.Blog == blogId)
if themeId: sql = sql.filter(BlogSeoMapped.BlogTheme == themeId)
if q:
assert isinstance(q, QBlogSeo), 'Invalid query %s' % q
sql = buildQuery(sql, q, BlogSeoMapped)
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
def getBlogSync(self, blog, offset, limit, detailed, q):
'''
@see IBlogSyncService.getBlogSync
'''
sql = self.session().query(BlogSyncMapped).filter(
BlogSyncMapped.Blog == blog)
if q: sql = buildQuery(sql, q, BlogSyncMapped)
sql = sql.join(SourceMapped, SourceMapped.Id == BlogSyncMapped.Source)
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(
or_(SourceMapped.OriginURI == None,
SourceMapped.OriginURI.in_(sql_prov)))
sqlLimit = buildLimits(sql, offset, limit)
if detailed:
return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return sqlLimit.all()
