def getGroupUnpublished(self,
blogId,
groupId,
typeId=None,
authorId=None,
thumbSize=None,
offset=None,
limit=None,
q=None):
'''
@see: IBlogPostService.getUnpublished
'''
assert q is None or isinstance(
q, QBlogPostUnpublished), 'Invalid query %s' % q
updateLastAccessOn(self.session(), groupId)
sql = self._buildQuery(blogId, typeId, None, authorId, q)
sql = sql.filter(BlogPostMapped.PublishedOn == None)
# blog collaborator group
sql = sql.join(
BlogCollaboratorGroupMemberMapped,
BlogCollaboratorGroupMemberMapped.BlogCollaborator ==
BlogPostMapped.Creator)
sql = sql.filter(BlogCollaboratorGroupMemberMapped.Group == groupId)
sql = sql.order_by(desc_op(BlogPostMapped.Creator))
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._addImages(sql.distinct())
def reorder(self, blogId, postId, refPostId, before=True):
'''
@see: IBlogPostService.reorder
'''
sql = self.session().query(BlogPostMapped.Order)
sql = sql.filter(BlogPostMapped.Blog == blogId)
sql = sql.filter(BlogPostMapped.Id == refPostId)
order = sql.scalar()
if not order: raise InputError(Ref(_('Invalid before post')))
sql = self.session().query(BlogPostMapped.Order)
sql = sql.filter(BlogPostMapped.Blog == blogId)
sql = sql.filter(BlogPostMapped.Id != postId)
if before:
sql = sql.filter(BlogPostMapped.Order > order)
sql = sql.order_by(BlogPostMapped.Order)
else:
sql = sql.filter(BlogPostMapped.Order < order)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = sql.limit(1)
orderPrev = sql.scalar()
if orderPrev: order = (order + orderPrev) / 2
elif before: order += 1
else: order -= 1
post = self.getById(blogId, postId)
assert isinstance(post, BlogPostMapped)
post.Order = order
post.CId = self._nextCId()
self.session().merge(post)
async def get_messages(
chat_id: int,
pagination: Pagination = Depends(get_pagination),
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a list of all messages for a specific chat."""
chat = crud.get_chat(db, current_user.user_id, chat_id)
if not chat:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"The chat with id {chat_id} does not exist.",
)
messages = (db.query(
models.Message).filter(models.Message.chat_id == chat_id).order_by(
desc_op(models.Message.sent_datetime)).limit(
pagination.count).offset(pagination.page *
pagination.count).all())
if not messages:
return []
return [
MessageResponse(
message_id=message.message_id,
contact_id=message.contact_id,
sent_datetime=message.sent_datetime,
message=prepare_message(chat.chat_id, message.message_id,
message.message),
) for message in messages
]
def reorder(self, blogTypeId, postId, refPostId, before=True):
'''
@see: IBlogPostService.reorder
'''
sql = self.session().query(BlogTypePostMapped.Order)
sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId)
sql = sql.filter(BlogTypePostMapped.Id == refPostId)
order = sql.scalar()
if order is None: raise InputError(Ref(_('Invalid before post')))
sql = self.session().query(BlogTypePostMapped.Order)
sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId)
sql = sql.filter(BlogTypePostMapped.Id != postId)
if before:
sql = sql.filter(BlogTypePostMapped.Order < order)
sql = sql.order_by(desc_op(BlogTypePostMapped.Order))
else:
sql = sql.filter(BlogTypePostMapped.Order > order)
sql = sql.order_by(BlogTypePostMapped.Order)
sql = sql.limit(1)
orderPrev = sql.scalar()
if orderPrev is not None: order = (order + orderPrev) / 2
else: order = order - 1 if before else order + 1
post = self.getById(blogTypeId, postId)
assert isinstance(post, BlogTypePostMapped)
post.Order = order
self.session().merge(post)
self.session().flush((post,))
def reorder(self, blogTypeId, postId, refPostId, before=True):
'''
@see: IBlogPostService.reorder
'''
sql = self.session().query(BlogTypePostMapped.Order)
sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId)
sql = sql.filter(BlogTypePostMapped.Id == refPostId)
order = sql.scalar()
if order is None: raise InputError(Ref(_('Invalid before post')))
sql = self.session().query(BlogTypePostMapped.Order)
sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId)
sql = sql.filter(BlogTypePostMapped.Id != postId)
if before:
sql = sql.filter(BlogTypePostMapped.Order < order)
sql = sql.order_by(desc_op(BlogTypePostMapped.Order))
else:
sql = sql.filter(BlogTypePostMapped.Order > order)
sql = sql.order_by(BlogTypePostMapped.Order)
sql = sql.limit(1)
orderPrev = sql.scalar()
if orderPrev is not None: order = (order + orderPrev) / 2
else: order = order - 1 if before else order + 1
post = self.getById(blogTypeId, postId)
assert isinstance(post, BlogTypePostMapped)
post.Order = order
self.session().merge(post)
self.session().flush((post, ))
def reorder(self, blogId, postId, refPostId, before=True):
'''
@see: IBlogPostService.reorder
'''
sql = self.session().query(BlogPostMapped.Order)
sql = sql.filter(BlogPostMapped.Blog == blogId)
sql = sql.filter(BlogPostMapped.Id == refPostId)
order = sql.scalar()
if not order: raise InputError(Ref(_('Invalid before post')))
sql = self.session().query(BlogPostMapped.Order)
sql = sql.filter(BlogPostMapped.Blog == blogId)
sql = sql.filter(BlogPostMapped.Id != postId)
if before:
sql = sql.filter(BlogPostMapped.Order > order)
sql = sql.order_by(BlogPostMapped.Order)
else:
sql = sql.filter(BlogPostMapped.Order < order)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = sql.limit(1)
orderPrev = sql.scalar()
if orderPrev: order = (order + orderPrev) / 2
elif before: order += 1
else: order -= 1
post = self.getById(blogId, postId)
assert isinstance(post, BlogPostMapped)
post.Order = order
post.CId = self._nextCId()
self.session().merge(post)
def getOwned(self,
blogId,
creatorId,
typeId=None,
thumbSize=None,
offset=None,
limit=None,
q=None):
'''
@see: IBlogPostService.getOwned
'''
assert q is None or isinstance(q, QBlogPost), 'Invalid query %s' % q
sql = self._buildQuery(blogId, typeId, creatorId, None, q)
sql = sql.join(CollaboratorMapped,
CollaboratorMapped.Id == BlogPostMapped.Author)
sql = sql.join(SourceMapped,
SourceMapped.Id == CollaboratorMapped.Source)
sql = sql.filter(SourceMapped.Name == self.internal_source_type)
if q and QBlogPost.isPublished in q:
if q.isPublished.value:
sql = sql.filter(BlogPostMapped.PublishedOn != None)
else:
sql = sql.filter(BlogPostMapped.PublishedOn == None)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._addImages(sql.all(), thumbSize)
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 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 getAll(self, blogId, typeId=None, creatorId=None, authorId=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getAll
'''
assert q is None or isinstance(q, QBlogPost), 'Invalid query %s' % q
sql = self._buildQuery(blogId, typeId, creatorId, authorId, q)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._trimmDeleted(sql.all())
def getGroupUnpublished(self, blogId, groupId, typeId=None, authorId=None, thumbSize=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getUnpublished
'''
assert q is None or isinstance(q, QBlogPostUnpublished), 'Invalid query %s' % q
updateLastAccessOn(self.session(), groupId)
sql = self._buildQuery(blogId, typeId, None, authorId, q)
sql = sql.filter(BlogPostMapped.PublishedOn == None)
# blog collaborator group
sql = sql.join(BlogCollaboratorGroupMemberMapped, BlogCollaboratorGroupMemberMapped.BlogCollaborator == BlogPostMapped.Creator)
sql = sql.filter(BlogCollaboratorGroupMemberMapped.Group == groupId)
sql = sql.order_by(desc_op(BlogPostMapped.Creator))
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._addImages(sql.distinct())
def getAll(self, blogId, typeId=None, creatorId=None, authorId=None, thumbSize=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getAll
'''
assert q is None or isinstance(q, QBlogPost), 'Invalid query %s' % q
sql = self._buildQuery(blogId, typeId, creatorId, authorId, q)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._addImages(sql.all(), thumbSize)
def getAll(self, blogTypeId, typeId=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getAll
'''
assert q is None or isinstance(q, QBlogTypePost), 'Invalid query %s' % q
sql = self._buildQuery(blogTypeId, typeId, q)
sql = sql.order_by(desc_op(BlogTypePostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._trimmDeleted(sql.all())
def get_last_message(db: Session, user_id: int, chat_id: int):
model = (db.query(
models.Message).filter(models.Message.chat_id == chat_id).order_by(
desc_op(models.Message.sent_datetime)).first())
return (schemas.MessageResponse(
message_id=model.message_id,
contact_id=model.contact_id,
message=json.loads(model.message),
sent_datetime=model.sent_datetime,
) if model else None)
def getUnpublished(self, blogId, typeId=None, creatorId=None, authorId=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getUnpublished
'''
assert q is None or isinstance(q, QBlogPostUnpublished), 'Invalid query %s' % q
sql = self._buildQuery(blogId, typeId, creatorId, authorId, q)
sql = sql.filter(BlogPostMapped.PublishedOn == None)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._trimmDeleted(sql.all())
def getOwned(self, blogId, creatorId, typeId=None, thumbSize=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getOwned
'''
assert q is None or isinstance(q, QBlogPost), 'Invalid query %s' % q
sql = self._buildQuery(blogId, typeId, creatorId, None, q)
if q and QBlogPost.isPublished in q:
if q.isPublished.value: sql = sql.filter(BlogPostMapped.PublishedOn != None)
else: sql = sql.filter(BlogPostMapped.PublishedOn == None)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._addImages(sql.all(), thumbSize)
def getOwned(self, blogId, creatorId, typeId=None, offset=None, limit=None, q=None):
'''
@see: IBlogPostService.getOwned
'''
assert q is None or isinstance(q, QBlogPost), 'Invalid query %s' % q
sql = self._buildQuery(blogId, typeId, creatorId, None, q)
if q and QBlogPost.isPublished in q:
if q.isPublished.value: sql = sql.filter(BlogPostMapped.PublishedOn != None)
else: sql = sql.filter(BlogPostMapped.PublishedOn == None)
#sql = sql.filter(BlogPostMapped.Author == None)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sql = buildLimits(sql, offset, limit)
return self._trimmDeleted(sql.all())
def getPublished(self, blogId, typeId=None, creatorId=None, authorId=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._buildQuery(blogId, typeId, creatorId, authorId, q)
sql = sql.filter(BlogPostMapped.PublishedOn != None)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sqlLimit = buildLimits(sql, offset, limit)
if detailed: return IterPart(sqlLimit.all(), sql.count(), offset, limit)
return self._trimmDeleted(sqlLimit.all())
def getUnpublished(self, blogId, typeId=None, creatorId=None, authorId=None, 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._filterQuery(blogId, typeId, creatorId, authorId, q)
deleted = False
if q:
if QBlogPostUnpublished.isDeleted in q:
deleted = q.isDeleted.value
if QWithCId.cId in q and q.cId:
sql = sql.filter(BlogPostMapped.CId != None)
sql = buildQuery(sql, q, BlogPostMapped)
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:
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(), unpublished=False, published=True), thumbSize)
if detailed:
posts = IterPost(posts, sql.distinct().count(), offset, limit)
posts.lastCId = self.session().query(func.MAX(BlogPostMapped.CId)).filter(BlogPostMapped.Blog == blogId).scalar()
return posts
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
async def get_chats(
pagination: Pagination = Depends(get_pagination),
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a list of all chats the user has."""
chats_with_message = (db.query(
models.Chat,
models.Connector,
models.Message,
func.max(models.Message.sent_datetime),
).join(models.Connector).join(models.Message).group_by(
models.Message.chat_id).filter(
models.Connector.user_id == current_user.user_id).order_by(
desc_op(models.Message.sent_datetime)).limit(
pagination.count).offset(pagination.page *
pagination.count).all())
if not chats_with_message:
return []
return [
ChatResponse(
chat_id=chat_with_message[0].chat_id,
connector_id=chat_with_message[0].connector_id,
name=chat_with_message[0].name,
is_muted=chat_with_message[0].is_muted,
is_archived=chat_with_message[0].is_archived,
pin_position=chat_with_message[0].pin_position,
last_message=schemas.MessageResponse(
message_id=chat_with_message[2].message_id,
contact_id=chat_with_message[2].contact_id,
message=json.loads(chat_with_message[2].message),
sent_datetime=chat_with_message[2].sent_datetime,
) if chat_with_message[2] else None,
) for chat_with_message in chats_with_message
]
def history():
histories = Histories.query.order_by(desc_op(
Histories.created_time)).limit(20)
return render_template('history.html', nav='history', histories=histories)
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 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
postVerification = aliased(PostVerificationMapped,
name='post_verification_filter')
sinceLastCId = 0
sql = self._filterQuery(blogId, typeId, creatorId, authorId, q)
if q:
if QWithCId.cId in q and q.cId:
sql = sql.filter(BlogPostMapped.CId != None)
sinceLastCId = q.cId.since
sql = buildQuery(sql, q, BlogPostMapped)
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 q is None or QWithCId.cId not in q:
sql = sql.filter((BlogPostMapped.PublishedOn != None)
& (BlogPostMapped.DeletedOn == None))
#filter updates that were not published yet
sql = sql.filter(BlogPostMapped.WasPublished == True)
sql = sql.order_by(desc_op(BlogPostMapped.Order))
sqlLimit = buildLimits(sql, offset, limit)
posts = self._addImages(self._trimPosts(sqlLimit.distinct()),
thumbSize)
if detailed:
posts = IterPost(posts, sql.distinct().count(), offset, limit)
posts.lastCId = self.session().query(func.MAX(
BlogPostMapped.CId)).filter(
BlogPostMapped.Blog == blogId).scalar()
posts.sinceLastCId = sinceLastCId
return posts
