def project_group_get_all(marker=None, limit=None, offset=None,
subscriber_id=None, sort_field=None, sort_dir=None,
**kwargs):
# Sanity checks, in case someone accidentally explicitly passes in 'None'
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
query = api_base.model_query(models.ProjectGroup)
query = api_base.apply_query_filters(query=query,
model=models.ProjectGroup,
**kwargs)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='project_group',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.ProjectGroup.id)
query = api_base.paginate_query(query=query,
model=models.ProjectGroup,
limit=limit,
sort_key=sort_field,
marker=marker,
offset=offset,
sort_dir=sort_dir)
# Execute the query
return query.all()
def project_group_get_all(marker=None, limit=None, offset=None,
subscriber_id=None, sort_field=None, sort_dir=None,
**kwargs):
# Sanity checks, in case someone accidentally explicitly passes in 'None'
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
query = api_base.model_query(models.ProjectGroup)
query = api_base.apply_query_filters(query=query,
model=models.ProjectGroup,
**kwargs)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='project_group',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.ProjectGroup.id)
query = api_base.paginate_query(query=query,
model=models.ProjectGroup,
limit=limit,
sort_key=sort_field,
marker=marker,
offset=offset,
sort_dir=sort_dir)
# Execute the query
return query.all()
def stories_query(self,
q,
status=None,
assignee_id=None,
creator_id=None,
project_group_id=None,
project_id=None,
subscriber_id=None,
tags=None,
updated_since=None,
marker=None,
offset=None,
limit=None,
tags_filter_type="all",
sort_field='id',
sort_dir='asc',
current_user=None):
session = api_base.get_session()
subquery = stories_api._story_build_query(
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
tags=tags,
updated_since=updated_since,
tags_filter_type=tags_filter_type,
current_user=current_user,
session=session)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
subquery = subquery.join(subs, subs.c.target_id == models.Story.id)
# Make a query that isn't full of aliases so that fulltext works
query = api_base.model_query(models.Story)
query = api_base.apply_query_filters(
query=query,
model=models.Story,
id=[story.id for story in subquery.all()])
try:
return self._story_fulltext_query(query, q, status, marker, offset,
limit, FullTextMode.BOOLEAN,
sort_field, sort_dir)
except DBError:
return self._story_fulltext_query(query, q, status, marker, offset,
limit, FullTextMode.NATURAL,
sort_field, sort_dir)
def project_get_all(marker=None, offset=None, limit=None, sort_field=None,
sort_dir=None, project_group_id=None, subscriber_id=None,
**kwargs):
# Sanity checks, in case someone accidentally explicitly passes in 'None'
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
# Construct the query
query = project_build_query(project_group_id=project_group_id,
**kwargs)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
user_id=subscriber_id)
# Filter by exact match, to avoid matching "project_group"
subs = subs.filter(models.Subscription.target_type == 'project')
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.Project.id)
query = api_base.paginate_query(query=query,
model=models.Project,
limit=limit,
sort_key=sort_field,
marker=marker,
offset=offset,
sort_dir=sort_dir)
# Execute the query
return query.all()
def task_build_query(project_group_id, current_user=None, **kwargs):
# Construct the query
query = api_base.model_query(models.Task)
if project_group_id:
query = query.join(models.Project,
models.project_group_mapping,
models.ProjectGroup) \
.filter(models.ProjectGroup.id == project_group_id)
# Sanity check on input parameters
query = api_base.apply_query_filters(query=query,
model=models.Task,
**kwargs)
# Filter out tasks or stories that the current user can't see
query = query.outerjoin(models.Story,
models.story_permissions,
models.Permission,
models.user_permissions,
models.User)
if current_user is not None:
query = query.filter(
or_(
and_(
models.User.id == current_user,
models.Story.private == true()
),
models.Story.private == false()
)
)
else:
query = query.filter(models.Story.private == false())
return query
def story_get_count(title=None, description=None, status=None,
assignee_id=None, creator_id=None, project_group_id=None,
project_id=None, subscriber_id=None, tags=None,
tags_filter_type="all"):
query = _story_build_query(title=title,
description=description,
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
tags=tags,
tags_filter_type=tags_filter_type)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.Story.id)
# If we're also asking for status, we have to attach storysummary here,
# since story status is derived.
if status:
query = query.subquery()
summary_query = api_base.model_query(models.StorySummary)
summary_query = summary_query \
.join(query, models.StorySummary.id == query.c.id)
query = summary_query.filter(models.StorySummary.status.in_(status))
return query.count()
def tasks_query(self,
q,
story_id=None,
assignee_id=None,
project_id=None,
project_group_id=None,
branch_id=None,
milestone_id=None,
status=None,
offset=None,
limit=None,
current_user=None,
sort_field='id',
sort_dir='asc'):
session = api_base.get_session()
subquery = tasks_api.task_build_query(
project_group_id=project_group_id,
story_id=story_id,
assignee_id=assignee_id,
project_id=project_id,
branch_id=branch_id,
milestone_id=milestone_id,
status=status,
current_user=current_user,
session=session)
# Make a query that isn't full of aliases so that fulltext works
clean_query = api_base.model_query(models.Task)
clean_query = api_base.apply_query_filters(
query=clean_query,
model=models.Task,
id=[task.id for task in subquery.all()])
try:
query = self._build_fulltext_search(models.Task, clean_query, q)
query = self._apply_pagination(models.Task,
query,
offset=offset,
limit=limit,
sort_field=sort_field,
sort_dir=sort_dir)
return query.all()
except DBError:
query = self._build_fulltext_search(models.Task,
clean_query,
q,
mode=FullTextMode.NATURAL)
query = self._apply_pagination(models.Task,
query,
offset=offset,
limit=limit,
sort_field=sort_field,
sort_dir=sort_dir)
return query.all()
def user_token_get_count(**kwargs):
query = api_base.model_query(models.AccessToken)
query = api_base.apply_query_filters(query=query,
model=models.AccessToken,
**kwargs)
return query.count()
def user_token_get_count(**kwargs):
query = api_base.model_query(models.AccessToken)
query = api_base.apply_query_filters(query=query,
model=models.AccessToken,
**kwargs)
return query.count()
def story_get_all(title=None, description=None, status=None, assignee_id=None,
creator_id=None, project_group_id=None, project_id=None,
subscriber_id=None, tags=None, marker=None, offset=None,
limit=None, tags_filter_type="all", sort_field='id',
sort_dir='asc', current_user=None):
# Sanity checks, in case someone accidentally explicitly passes in 'None'
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
if not isinstance(status, list) and status is not None:
status = [status]
# Build the query.
subquery = _story_build_query(title=title,
description=description,
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
tags=tags,
tags_filter_type=tags_filter_type,
current_user=current_user)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
subquery = subquery.join(subs, subs.c.target_id == models.Story.id)
# Turn the whole shebang into a subquery.
subquery = subquery.subquery('filtered_stories')
# Return the story summary.
query = api_base.model_query(models.StorySummary)\
.options(subqueryload(models.StorySummary.tags))
query = query.join(subquery,
models.StorySummary.id == subquery.c.id)
if status:
query = query.filter(models.StorySummary.status.in_(status))
# paginate the query
query = api_base.paginate_query(query=query,
model=models.StorySummary,
limit=limit,
sort_key=sort_field,
marker=marker,
offset=offset,
sort_dir=sort_dir)
raw_stories = query.all()
return raw_stories
def project_group_get_count(subscriber_id=None, **kwargs):
# Construct the query
query = api_base.model_query(models.ProjectGroup)
query = api_base.apply_query_filters(query=query,
model=models.ProjectGroup,
**kwargs)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='project_group',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.ProjectGroup.id)
return query.count()
def project_group_get_count(subscriber_id=None, **kwargs):
# Construct the query
query = api_base.model_query(models.ProjectGroup)
query = api_base.apply_query_filters(query=query,
model=models.ProjectGroup,
**kwargs)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='project_group',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.ProjectGroup.id)
return query.count()
def stories_query(self, q, status=None, assignee_id=None,
creator_id=None, project_group_id=None, project_id=None,
subscriber_id=None, tags=None, updated_since=None,
marker=None, offset=None,
limit=None, tags_filter_type="all", sort_field='id',
sort_dir='asc', current_user=None):
session = api_base.get_session()
subquery = stories_api._story_build_query(
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
tags=tags,
updated_since=updated_since,
tags_filter_type=tags_filter_type,
current_user=current_user,
session=session)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
subquery = subquery.join(subs, subs.c.target_id == models.Story.id)
# Make a query that isn't full of aliases so that fulltext works
query = api_base.model_query(models.Story)
query = api_base.apply_query_filters(
query=query,
model=models.Story,
id=[story.id for story in subquery.all()])
try:
return self._story_fulltext_query(
query, q, status, marker, offset, limit, FullTextMode.BOOLEAN,
sort_field, sort_dir)
except DBError:
return self._story_fulltext_query(
query, q, status, marker, offset, limit, FullTextMode.NATURAL,
sort_field, sort_dir)
def access_token_build_query(**kwargs):
# Construct the query
query = api_base.model_query(models.AccessToken)
# Apply the filters
query = api_base.apply_query_filters(query=query,
model=models.AccessToken,
**kwargs)
return query
def refresh_token_build_query(**kwargs):
# Construct the query
query = api_base.model_query(models.RefreshToken)
# Apply the filters
query = api_base.apply_query_filters(query=query,
model=models.RefreshToken,
**kwargs)
return query
def branch_build_query(project_group_id, **kwargs):
query = api_base.model_query(models.Branch)
if project_group_id:
query = query.join(models.Project.project_groups) \
.filter(models.ProjectGroup.id == project_group_id)
query = api_base.apply_query_filters(query=query, model=models.Branch,
**kwargs)
return query
def project_build_query(project_group_id, **kwargs):
# Construct the query
query = api_base.model_query(models.Project)
if project_group_id:
query = query.join(models.Project.project_groups) \
.filter(models.ProjectGroup.id == project_group_id)
# Sanity check on input parameters
query = api_base.apply_query_filters(query=query, model=models.Project,
**kwargs)
return query
def project_build_query(project_group_id, **kwargs):
# Construct the query
query = api_base.model_query(models.Project)
if project_group_id:
query = query.join(models.Project.project_groups) \
.filter(models.ProjectGroup.id == project_group_id)
# Sanity check on input parameters
query = api_base.apply_query_filters(query=query, model=models.Project,
**kwargs)
return query
def _build_user_query(full_name=None, email=None, openid=None):
query = api_base.model_query(models.User)
query = api_base.apply_query_filters(query=query,
model=models.User,
full_name=full_name)
if email:
query = query.filter(models.User.email == email)
if openid:
query = query.filter(models.User.openid == openid)
return query
def _build_user_query(full_name=None, email=None, openid=None):
query = api_base.model_query(models.User)
query = api_base.apply_query_filters(query=query,
model=models.User,
full_name=full_name)
if email:
query = query.filter(models.User.email == email)
if openid:
query = query.filter(models.User.openid == openid)
return query
def tasks_query(self, q, story_id=None, assignee_id=None, project_id=None,
project_group_id=None, branch_id=None, milestone_id=None,
status=None, offset=None, limit=None, current_user=None,
sort_field='id', sort_dir='asc'):
session = api_base.get_session()
subquery = tasks_api.task_build_query(
project_group_id=project_group_id,
story_id=story_id,
assignee_id=assignee_id,
project_id=project_id,
branch_id=branch_id,
milestone_id=milestone_id,
status=status,
current_user=current_user,
session=session)
# Make a query that isn't full of aliases so that fulltext works
clean_query = api_base.model_query(models.Task)
clean_query = api_base.apply_query_filters(
query=clean_query,
model=models.Task,
id=[task.id for task in subquery.all()])
try:
query = self._build_fulltext_search(models.Task, clean_query, q)
query = self._apply_pagination(
models.Task,
query,
offset=offset,
limit=limit,
sort_field=sort_field,
sort_dir=sort_dir)
return query.all()
except DBError:
query = self._build_fulltext_search(models.Task, clean_query, q,
mode=FullTextMode.NATURAL)
query = self._apply_pagination(
models.Task,
query,
offset=offset,
limit=limit,
sort_field=sort_field,
sort_dir=sort_dir)
return query.all()
def task_build_query(project_group_id=None,
board_id=None,
worklist_id=None,
current_user=None,
session=None,
**kwargs):
# Construct the query
query = api_base.model_query(models.Task, session=session)
if project_group_id:
query = query.join(models.Project,
models.project_group_mapping,
models.ProjectGroup) \
.filter(models.ProjectGroup.id == project_group_id)
# Sanity check on input parameters
query = api_base.apply_query_filters(query=query,
model=models.Task,
**kwargs)
# Filter out tasks or stories that the current user can't see
query = query.outerjoin(models.Story)
query = api_base.filter_private_stories(query, current_user)
if worklist_id or board_id:
query = query.outerjoin(
(models.WorklistItem,
models.WorklistItem.item_id == models.Task.id))
query = query.filter(models.WorklistItem.item_type == "task")
query = query.outerjoin(models.Worklist)
# Filter by worklist
if worklist_id:
query = query.filter(models.Worklist.id == worklist_id)
query = api_base.filter_private_worklists(query,
current_user,
hide_lanes=False)
# Filter by board
if board_id:
query = query.outerjoin(models.BoardWorklist, models.Board)
query = api_base.filter_private_boards(query, current_user)
query = query.filter(models.Board.id == board_id)
query = api_base.filter_private_worklists(query,
current_user,
hide_lanes=False)
return query
def _due_date_build_query(name=None, date=None, board_id=None,
worklist_id=None, user=None, owner=None):
query = api_base.model_query(models.DueDate)
query = api_base.apply_query_filters(query=query,
model=models.DueDate,
name=name,
date=date)
if board_id:
query = query.join(models.board_due_dates,
models.Board)
query = query.filter(models.Board.id == board_id)
if worklist_id:
query = query.join(models.worklist_due_dates,
models.Worklist)
query = query.filter(models.Worklist.id == worklist_id)
if user and not owner:
query = query.join(models.due_date_permissions,
models.Permission,
models.user_permissions,
models.User)
query = query.filter(models.User.id == user)
if owner and not user:
query = query.join(models.due_date_permissions,
models.Permission,
models.user_permissions,
models.User)
query = query.filter(models.Permission.codename == 'edit_date',
models.User.id == owner)
if owner and user:
query = query.join(models.due_date_permissions,
models.Permission,
models.user_permissions,
models.User)
user_dates = query.filter(models.User.id == user)
owner_dates = query.filter(models.Permission.codename == 'edit_date',
models.User.id == owner)
query = user_dates.union(owner_dates)
query = query.group_by(models.DueDate.id)
query = query.having(func.count(models.DueDate.id) >= 2)
return query
def _due_date_build_query(name=None, date=None, board_id=None,
worklist_id=None, user=None, owner=None):
query = api_base.model_query(models.DueDate)
query = api_base.apply_query_filters(query=query,
model=models.DueDate,
name=name,
date=date)
if board_id:
query = query.join(models.board_due_dates,
models.Board)
query = query.filter(models.Board.id == board_id)
if worklist_id:
query = query.join(models.worklist_due_dates,
models.Worklist)
query = query.filter(models.Worklist.id == worklist_id)
if user and not owner:
query = query.join(models.due_date_permissions,
models.Permission,
models.user_permissions,
models.User)
query = query.filter(models.User.id == user)
if owner and not user:
query = query.join(models.due_date_permissions,
models.Permission,
models.user_permissions,
models.User)
query = query.filter(models.Permission.codename == 'edit_date',
models.User.id == owner)
if owner and user:
query = query.join(models.due_date_permissions,
models.Permission,
models.user_permissions,
models.User)
user_dates = query.filter(models.User.id == user)
owner_dates = query.filter(models.Permission.codename == 'edit_date',
models.User.id == owner)
query = user_dates.union(owner_dates)
query = query.group_by(models.DueDate.id)
query = query.having(func.count(models.DueDate.id) >= 2)
return query
def story_get_count(title=None,
description=None,
status=None,
assignee_id=None,
creator_id=None,
project_group_id=None,
project_id=None,
subscriber_id=None,
tags=None,
updated_since=None,
tags_filter_type="all",
current_user=None):
query = _story_build_query(title=title,
description=description,
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
updated_since=updated_since,
tags=tags,
tags_filter_type=tags_filter_type,
current_user=current_user)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.Story.id)
# Turn the whole shebang into a subquery.
subquery = query.subquery('filtered_stories')
# Return the story summary.
query = api_base.model_query(models.StorySummary)\
.options(subqueryload(models.StorySummary.tags))
id_col = tuple(subquery.c)[0]
query = query.join(subquery, models.StorySummary.id == id_col)
if status:
query = query.filter(models.StorySummary.status.in_(status))
return query.count()
def _build_worklist_query(title=None, creator_id=None, project_id=None,
user_id=None, session=None):
query = api_base.model_query(models.Worklist, session=session)
query = api_base.apply_query_filters(query=query,
model=models.Worklist,
title=title,
creator_id=creator_id,
project_id=project_id)
if user_id:
query = query.join(models.worklist_permissions,
models.Permission,
models.user_permissions,
models.User)
query = query.filter(models.User.id == user_id)
return query
def _story_build_query(title=None, description=None, assignee_id=None,
creator_id=None, project_group_id=None, project_id=None,
tags=None, tags_filter_type='all'):
# First build a standard story query.
query = api_base.model_query(models.Story.id).distinct()
# Apply basic filters
query = api_base.apply_query_filters(query=query,
model=models.Story,
title=title,
description=description,
creator_id=creator_id)
# Filtering by tags
if tags:
if tags_filter_type == 'all':
for tag in tags:
query = query.filter(models.Story.tags.any(name=tag))
elif tags_filter_type == 'any':
query = query.filter(models.Story.tags.any
(models.StoryTag.name.in_(tags)))
else:
raise exc.NotFound("Tags filter not found.")
# Are we filtering by project group?
if project_group_id:
query = query.join(models.Task,
models.Project,
models.project_group_mapping,
models.ProjectGroup)
query = query.filter(models.ProjectGroup.id == project_group_id)
# Are we filtering by task?
if assignee_id or project_id:
if not project_group_id: # We may already have joined this table
query = query.join(models.Task)
if assignee_id:
query = query.filter(models.Task.assignee_id == assignee_id)
if project_id:
query = query.filter(models.Task.project_id == project_id)
return query
def task_build_query(project_group_id=None, board_id=None, worklist_id=None,
current_user=None, session=None, **kwargs):
# Construct the query
query = api_base.model_query(models.Task, session=session)
if project_group_id:
query = query.join(models.Project,
models.project_group_mapping,
models.ProjectGroup) \
.filter(models.ProjectGroup.id == project_group_id)
# Sanity check on input parameters
query = api_base.apply_query_filters(query=query,
model=models.Task,
**kwargs)
# Filter out tasks or stories that the current user can't see
query = query.outerjoin(models.Story)
query = api_base.filter_private_stories(query, current_user)
if worklist_id or board_id:
query = query.outerjoin(
(models.WorklistItem,
models.WorklistItem.item_id == models.Task.id))
query = query.filter(models.WorklistItem.item_type == "task")
query = query.outerjoin(models.Worklist)
# Filter by worklist
if worklist_id:
query = query.filter(models.Worklist.id == worklist_id)
query = api_base.filter_private_worklists(
query, current_user, hide_lanes=False)
# Filter by board
if board_id:
query = query.outerjoin(models.BoardWorklist, models.Board)
query = api_base.filter_private_boards(query, current_user)
query = query.filter(models.Board.id == board_id)
query = api_base.filter_private_worklists(
query, current_user, hide_lanes=False)
return query
def story_get_count(title=None,
description=None,
status=None,
assignee_id=None,
creator_id=None,
project_group_id=None,
project_id=None,
subscriber_id=None,
tags=None,
tags_filter_type="all",
current_user=None):
query = _story_build_query(title=title,
description=description,
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
tags=tags,
tags_filter_type=tags_filter_type,
current_user=current_user)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.Story.id)
# If we're also asking for status, we have to attach storysummary here,
# since story status is derived.
if status:
query = query.subquery()
summary_query = api_base.model_query(models.StorySummary)
summary_query = summary_query \
.join(query, models.StorySummary.id == query.c.id)
query = summary_query.filter(models.StorySummary.status.in_(status))
return query.count()
def user_token_get_all(marker=None, limit=None, sort_field=None,
sort_dir=None, **kwargs):
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
query = api_base.model_query(models.AccessToken)
query = api_base.apply_query_filters(query=query,
model=models.AccessToken,
**kwargs)
query = api_base.paginate_query(query=query,
model=models.AccessToken,
limit=limit,
sort_key=sort_field,
marker=marker,
sort_dir=sort_dir)
return query.all()
def story_get_count(title=None, description=None, status=None,
assignee_id=None, creator_id=None,
project_group_id=None, project_id=None,
subscriber_id=None, tags=None, updated_since=None,
tags_filter_type="all", current_user=None):
query = _story_build_query(title=title,
description=description,
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
updated_since=updated_since,
tags=tags,
tags_filter_type=tags_filter_type,
current_user=current_user)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.Story.id)
# Turn the whole shebang into a subquery.
subquery = query.subquery('filtered_stories')
# Return the story summary.
query = api_base.model_query(models.StorySummary)\
.options(subqueryload(models.StorySummary.tags))
id_col = tuple(subquery.c)[0]
query = query.join(subquery,
models.StorySummary.id == id_col)
if status:
query = query.filter(models.StorySummary.status.in_(status))
return query.count()
def _events_build_query(current_user=None, **kwargs):
query = api_base.model_query(models.TimeLineEvent).distinct()
query = api_base.apply_query_filters(query=query,
model=models.TimeLineEvent,
**kwargs)
query = query.outerjoin(models.Story)
query = api_base.filter_private_stories(query, current_user)
query = query.outerjoin((
models.Worklist,
models.Worklist.id == models.TimeLineEvent.worklist_id))
query = api_base.filter_private_worklists(
query, current_user, hide_lanes=False)
query = query.outerjoin((
models.Board,
models.Board.id == models.TimeLineEvent.board_id))
query = api_base.filter_private_boards(query, current_user)
return query
def _events_build_query(current_user=None, **kwargs):
query = api_base.model_query(models.TimeLineEvent).distinct()
query = api_base.apply_query_filters(query=query,
model=models.TimeLineEvent,
**kwargs)
query = query.outerjoin(models.Story)
query = api_base.filter_private_stories(query, current_user)
query = query.outerjoin(
(models.Worklist,
models.Worklist.id == models.TimeLineEvent.worklist_id))
query = api_base.filter_private_worklists(query,
current_user,
hide_lanes=False)
query = query.outerjoin(
(models.Board, models.Board.id == models.TimeLineEvent.board_id))
query = api_base.filter_private_boards(query, current_user)
return query
def user_token_get_all(marker=None,
limit=None,
sort_field=None,
sort_dir=None,
**kwargs):
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
query = api_base.model_query(models.AccessToken)
query = api_base.apply_query_filters(query=query,
model=models.AccessToken,
**kwargs)
query = api_base.paginate_query(query=query,
model=models.AccessToken,
limit=limit,
sort_key=sort_field,
marker=marker,
sort_dir=sort_dir)
return query.all()
def _story_build_query(title=None,
description=None,
assignee_id=None,
creator_id=None,
project_group_id=None,
project_id=None,
tags=None,
tags_filter_type='all',
current_user=None):
# First build a standard story query.
query = api_base.model_query(models.Story.id).distinct()
# Apply basic filters
query = api_base.apply_query_filters(query=query,
model=models.Story,
title=title,
description=description,
creator_id=creator_id)
# Filter out stories that the current user can't see
query = query.outerjoin(models.story_permissions, models.Permission,
models.user_permissions, models.User)
if current_user:
query = query.filter(
or_(
and_(models.User.id == current_user,
models.Story.private == true()),
models.Story.private == false()))
else:
query = query.filter(models.Story.private == false())
# Filtering by tags
if tags:
if tags_filter_type == 'all':
for tag in tags:
query = query.filter(models.Story.tags.any(name=tag))
elif tags_filter_type == 'any':
query = query.filter(
models.Story.tags.any(models.StoryTag.name.in_(tags)))
else:
raise exc.NotFound("Tags filter not found.")
# Are we filtering by project group?
if project_group_id:
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
query = query.join(models.Project, models.project_group_mapping,
models.ProjectGroup)
query = query.filter(models.ProjectGroup.id == project_group_id)
# Are we filtering by task?
if assignee_id or project_id:
if not project_group_id: # We may already have joined this table
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
if assignee_id:
query = query.filter(models.Task.assignee_id == assignee_id)
if project_id:
query = query.filter(models.Task.project_id == project_id)
return query
def _build_worklist_query(title=None,
creator_id=None,
project_id=None,
archived=False,
user_id=None,
session=None,
current_user=None,
hide_lanes=True,
item_type=None,
story_id=None,
task_id=None):
query = api_base.model_query(models.Worklist, session=session).distinct()
query = api_base.apply_query_filters(query=query,
model=models.Worklist,
title=title,
creator_id=creator_id,
project_id=project_id)
# Filter out lists that the current user can't see.
# This gets complicated because worklists permissions must be
# inherited from the board which contains the list (if any). To
# handle this we split the query into the lists which are in
# boards (`lanes`) and those which aren't (`lists`). We then
# either hide the lanes entirely or unify the two queries.
lanes = query.join(models.BoardWorklist, models.Board,
models.board_permissions)
lanes = lanes.join(models.Permission, models.user_permissions, models.User)
lists = query.outerjoin(models.BoardWorklist)
lists = lists.filter(models.BoardWorklist.board_id.is_(None))
lists = lists.join(models.worklist_permissions, models.Permission,
models.user_permissions, models.User)
if current_user:
if not hide_lanes:
lanes = lanes.filter(
or_(
and_(models.User.id == current_user,
models.Board.private == true()),
models.Board.private == false()))
lists = lists.filter(
or_(
and_(models.User.id == current_user,
models.Worklist.private == true()),
models.Worklist.private == false()))
else:
if not hide_lanes:
lanes = lanes.filter(models.Board.private == false())
lists = lists.filter(models.Worklist.private == false())
if hide_lanes:
query = lists
else:
query = lists.union(lists)
# Filter by lists that a given user has permissions to use
if user_id:
worklist_permissions = aliased(models.worklist_permissions)
permissions = aliased(models.Permission)
user_permissions = aliased(models.user_permissions)
users = aliased(models.User)
query = query.join(
(worklist_permissions,
models.Worklist.id == worklist_permissions.c.worklist_id))
query = query.join(
(permissions,
worklist_permissions.c.permission_id == permissions.id))
query = query.join(
(user_permissions,
permissions.id == user_permissions.c.permission_id))
query = query.join((users, user_permissions.c.user_id == users.id))
query = query.filter(users.id == user_id)
# Filter by whether or not we want archived lists
query = query.filter(models.Worklist.archived == archived)
# Filter by story id
if story_id:
query = query.join(models.WorklistItem)
stories = query.filter(models.WorklistItem.item_type == 'story')
tasks = query.filter(models.WorklistItem.item_type == 'task')
if item_type == 'story':
query = stories.filter(models.WorklistItem.item_id == story_id)
elif item_type == 'task':
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
query = tasks.filter(models.Task.story_id == story_id)
else:
stories = stories.filter(models.WorklistItem.item_id == story_id)
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
tasks = tasks.filter(models.Task.story_id == story_id)
query = stories.union(tasks)
# Filter by task id
if task_id:
items = aliased(models.WorklistItem)
query = query.join((items, models.Worklist.id == items.list_id))
query = query.filter(items.item_type == 'task')
query = query.filter(items.item_id == task_id)
return query
def _build_worklist_query(title=None, creator_id=None, project_id=None,
archived=False, user_id=None, session=None,
current_user=None, hide_lanes=True, item_type=None,
story_id=None, task_id=None):
query = api_base.model_query(models.Worklist, session=session).distinct()
query = api_base.apply_query_filters(query=query,
model=models.Worklist,
title=title,
creator_id=creator_id,
project_id=project_id)
# Filter out lists that the current user can't see.
# This gets complicated because worklists permissions must be
# inherited from the board which contains the list (if any). To
# handle this we split the query into the lists which are in
# boards (`lanes`) and those which aren't (`lists`). We then
# either hide the lanes entirely or unify the two queries.
lanes = query.join(models.BoardWorklist,
models.Board,
models.board_permissions)
lanes = lanes.join(models.Permission,
models.user_permissions,
models.User)
lists = query.outerjoin(models.BoardWorklist)
lists = lists.filter(models.BoardWorklist.board_id.is_(None))
lists = lists.join(models.worklist_permissions,
models.Permission,
models.user_permissions,
models.User)
if current_user:
if not hide_lanes:
lanes = lanes.filter(
or_(
and_(
models.User.id == current_user,
models.Board.private == true()
),
models.Board.private == false()
)
)
lists = lists.filter(
or_(
and_(
models.User.id == current_user,
models.Worklist.private == true()
),
models.Worklist.private == false()
)
)
else:
if not hide_lanes:
lanes = lanes.filter(models.Board.private == false())
lists = lists.filter(models.Worklist.private == false())
if hide_lanes:
query = lists
else:
query = lists.union(lists)
# Filter by lists that a given user has permissions to use
if user_id:
worklist_permissions = aliased(models.worklist_permissions)
permissions = aliased(models.Permission)
user_permissions = aliased(models.user_permissions)
users = aliased(models.User)
query = query.join(
(worklist_permissions,
models.Worklist.id == worklist_permissions.c.worklist_id)
)
query = query.join(
(permissions,
worklist_permissions.c.permission_id == permissions.id)
)
query = query.join(
(user_permissions,
permissions.id == user_permissions.c.permission_id)
)
query = query.join((users, user_permissions.c.user_id == users.id))
query = query.filter(users.id == user_id)
# Filter by whether or not we want archived lists
query = query.filter(models.Worklist.archived == archived)
# Filter by story id
if story_id:
query = query.join(models.WorklistItem)
stories = query.filter(models.WorklistItem.item_type == 'story')
tasks = query.filter(models.WorklistItem.item_type == 'task')
if item_type == 'story':
query = stories.filter(models.WorklistItem.item_id == story_id)
elif item_type == 'task':
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
query = tasks.filter(models.Task.story_id == story_id)
else:
stories = stories.filter(models.WorklistItem.item_id == story_id)
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
tasks = tasks.filter(models.Task.story_id == story_id)
query = stories.union(tasks)
# Filter by task id
if task_id:
items = aliased(models.WorklistItem)
query = query.join((items, models.Worklist.id == items.list_id))
query = query.filter(items.item_type == 'task')
query = query.filter(items.item_id == task_id)
return query
def _build_worklist_query(title=None, creator_id=None, project_id=None,
archived=False, user_id=None, session=None,
current_user=None, hide_lanes=True, item_type=None,
story_id=None, task_id=None, subscriber_id=None):
query = api_base.model_query(models.Worklist, session=session).distinct()
query = api_base.apply_query_filters(query=query,
model=models.Worklist,
title=title,
creator_id=creator_id,
project_id=project_id)
query = api_base.filter_private_worklists(query, current_user)
# Filter by lists that a given user has permissions to use
if user_id:
worklist_permissions = aliased(models.worklist_permissions)
permissions = aliased(models.Permission)
user_permissions = aliased(models.user_permissions)
users = aliased(models.User)
query = query.join(
(worklist_permissions,
models.Worklist.id == worklist_permissions.c.worklist_id)
)
query = query.join(
(permissions,
worklist_permissions.c.permission_id == permissions.id)
)
query = query.join(
(user_permissions,
permissions.id == user_permissions.c.permission_id)
)
query = query.join((users, user_permissions.c.user_id == users.id))
query = query.filter(users.id == user_id)
# Filter by whether or not we want archived lists
query = query.filter(models.Worklist.archived == archived)
# Filter by story id
if story_id:
query = query.join(models.WorklistItem)
stories = query.filter(models.WorklistItem.item_type == 'story')
tasks = query.filter(models.WorklistItem.item_type == 'task')
if item_type == 'story':
query = stories.filter(models.WorklistItem.item_id == story_id)
elif item_type == 'task':
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
query = tasks.filter(models.Task.story_id == story_id)
else:
stories = stories.filter(models.WorklistItem.item_id == story_id)
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
tasks = tasks.filter(models.Task.story_id == story_id)
query = stories.union(tasks)
# Filter by task id
if task_id:
items = aliased(models.WorklistItem)
query = query.join((items, models.Worklist.id == items.list_id))
query = query.filter(items.item_type == 'task')
query = query.filter(items.item_id == task_id)
# Filter by subscriber id
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='worklist',
user_id=subscriber_id)
subs = subs.subquery()
query = query.join(subs, subs.c.target_id == models.Worklist.id)
return query
def _story_build_query(title=None, description=None, assignee_id=None,
creator_id=None, project_group_id=None,
project_id=None, updated_since=None, tags=None,
board_id=None, worklist_id=None, tags_filter_type='all',
current_user=None, session=None):
# First build a standard story query.
query = api_base.model_query(models.Story.id, session=session).distinct()
# Apply basic filters
query = api_base.apply_query_filters(query=query,
model=models.Story,
title=title,
description=description,
creator_id=creator_id)
if updated_since:
query = query.filter(models.Story.updated_at > updated_since)
# Filter out stories that the current user can't see
query = api_base.filter_private_stories(query, current_user)
# Filtering by tags
if tags:
if tags_filter_type == 'all':
for tag in tags:
query = query.filter(models.Story.tags.any(name=tag))
elif tags_filter_type == 'any':
query = query.filter(models.Story.tags.any
(models.StoryTag.name.in_(tags)))
else:
raise exc.NotFound("Tags filter not found.")
# Are we filtering by project group?
if project_group_id:
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
query = query.join(models.Project,
models.project_group_mapping,
models.ProjectGroup)
query = query.filter(models.ProjectGroup.id == project_group_id)
# Are we filtering by task?
if assignee_id or project_id:
if not project_group_id: # We may already have joined this table
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
if assignee_id:
query = query.filter(models.Task.assignee_id == assignee_id)
if project_id:
query = query.filter(models.Task.project_id == project_id)
if worklist_id or board_id:
query = query.outerjoin(
(models.WorklistItem,
models.WorklistItem.item_id == models.Story.id))
query = query.filter(models.WorklistItem.item_type == "story")
query = query.outerjoin(models.Worklist)
# Filter by worklist
if worklist_id:
query = query.filter(models.Worklist.id == worklist_id)
query = api_base.filter_private_worklists(
query, current_user, hide_lanes=False)
# Filter by board
if board_id:
query = query.outerjoin(models.BoardWorklist, models.Board)
query = api_base.filter_private_boards(query, current_user)
query = query.filter(models.Board.id == board_id)
query = api_base.filter_private_worklists(
query, current_user, hide_lanes=False)
return query.distinct()
def _build_board_query(title=None, creator_id=None, user_id=None,
project_id=None, archived=False, current_user=None,
session=None, item_type=None, story_id=None,
task_id=None):
query = api_base.model_query(models.Board, session=session).distinct()
query = api_base.apply_query_filters(query=query,
model=models.Board,
title=title,
creator_id=creator_id,
project_id=project_id)
# Filter out boards that the current user can't see
query = api_base.filter_private_boards(query, current_user)
# Filter by boards that a given user has permissions to use
if user_id:
board_permissions = aliased(models.board_permissions)
permissions = aliased(models.Permission)
user_permissions = aliased(models.user_permissions)
users = aliased(models.User)
query = query.join(
(board_permissions,
models.Board.id == board_permissions.c.board_id)
)
query = query.join(
(permissions,
board_permissions.c.permission_id == permissions.id)
)
query = query.join(
(user_permissions,
permissions.id == user_permissions.c.permission_id)
)
query = query.join((users, user_permissions.c.user_id == users.id))
query = query.filter(users.id == user_id)
# Filter by whether or not we want archived boards
query = query.filter(models.Board.archived == archived)
if story_id or task_id:
query = query.join(models.BoardWorklist,
models.Worklist)
# Filter by story id
if story_id:
query = query.join(models.WorklistItem)
stories = query.filter(models.WorklistItem.item_type == 'story')
tasks = query.filter(models.WorklistItem.item_type == 'task')
if item_type == 'story':
query = stories.filter(models.WorklistItem.item_id == story_id)
elif item_type == 'task':
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
query = tasks.filter(models.Task.story_id == story_id)
else:
stories = stories.filter(models.WorklistItem.item_id == story_id)
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
tasks = tasks.filter(models.Task.story_id == story_id)
query = stories.union(tasks)
# Filter by task id
if task_id:
items = aliased(models.WorklistItem)
query = query.join((items, models.Worklist.id == items.list_id))
query = query.filter(items.item_type == 'task')
query = query.filter(items.item_id == task_id)
return query
def _build_board_query(title=None, creator_id=None, user_id=None,
project_id=None, archived=False, current_user=None,
session=None, item_type=None, story_id=None,
task_id=None):
query = api_base.model_query(models.Board, session=session).distinct()
query = api_base.apply_query_filters(query=query,
model=models.Worklist,
title=title,
creator_id=creator_id,
project_id=project_id)
# Filter out boards that the current user can't see
query = query.join(models.board_permissions,
models.Permission,
models.user_permissions,
models.User)
if current_user:
query = query.filter(
or_(
and_(
models.User.id == current_user,
models.Board.private == true()
),
models.Board.private == false()
)
)
else:
query = query.filter(models.Board.private == false())
# Filter by boards that a given user has permissions to use
if user_id:
board_permissions = aliased(models.board_permissions)
permissions = aliased(models.Permission)
user_permissions = aliased(models.user_permissions)
users = aliased(models.User)
query = query.join(
(board_permissions,
models.Board.id == board_permissions.c.board_id)
)
query = query.join(
(permissions,
board_permissions.c.permission_id == permissions.id)
)
query = query.join(
(user_permissions,
permissions.id == user_permissions.c.permission_id)
)
query = query.join((users, user_permissions.c.user_id == users.id))
query = query.filter(users.id == user_id)
# Filter by whether or not we want archived boards
query = query.filter(models.Board.archived == archived)
if story_id or task_id:
query = query.join(models.BoardWorklist,
models.Worklist)
# Filter by story id
if story_id:
query = query.join(models.WorklistItem)
stories = query.filter(models.WorklistItem.item_type == 'story')
tasks = query.filter(models.WorklistItem.item_type == 'task')
if item_type == 'story':
query = stories.filter(models.WorklistItem.item_id == story_id)
elif item_type == 'task':
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
query = tasks.filter(models.Task.story_id == story_id)
else:
stories = stories.filter(models.WorklistItem.item_id == story_id)
tasks = tasks.join(
(models.Task, models.WorklistItem.item_id == models.Task.id))
tasks = tasks.filter(models.Task.story_id == story_id)
query = stories.union(tasks)
# Filter by task id
if task_id:
items = aliased(models.WorklistItem)
query = query.join((items, models.Worklist.id == items.list_id))
query = query.filter(items.item_type == 'task')
query = query.filter(items.item_id == task_id)
return query
def _story_build_query(title=None,
description=None,
assignee_id=None,
creator_id=None,
project_group_id=None,
project_id=None,
updated_since=None,
tags=None,
board_id=None,
worklist_id=None,
tags_filter_type='all',
current_user=None,
session=None):
# First build a standard story query.
query = api_base.model_query(models.Story.id, session=session).distinct()
# Apply basic filters
query = api_base.apply_query_filters(query=query,
model=models.Story,
title=title,
description=description,
creator_id=creator_id)
if updated_since:
query = query.filter(models.Story.updated_at > updated_since)
# Filter out stories that the current user can't see
query = api_base.filter_private_stories(query, current_user)
# Filtering by tags
if tags:
if tags_filter_type == 'all':
for tag in tags:
query = query.filter(models.Story.tags.any(name=tag))
elif tags_filter_type == 'any':
query = query.filter(
models.Story.tags.any(models.StoryTag.name.in_(tags)))
else:
raise exc.NotFound("Tags filter not found.")
# Are we filtering by project group?
if project_group_id:
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
query = query.join(models.Project, models.project_group_mapping,
models.ProjectGroup)
query = query.filter(models.ProjectGroup.id == project_group_id)
# Are we filtering by task?
if assignee_id or project_id:
if not project_group_id: # We may already have joined this table
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
if assignee_id:
query = query.filter(models.Task.assignee_id == assignee_id)
if project_id:
query = query.filter(models.Task.project_id == project_id)
if worklist_id or board_id:
query = query.outerjoin(
(models.WorklistItem,
models.WorklistItem.item_id == models.Story.id))
query = query.filter(models.WorklistItem.item_type == "story")
query = query.outerjoin(models.Worklist)
# Filter by worklist
if worklist_id:
query = query.filter(models.Worklist.id == worklist_id)
query = api_base.filter_private_worklists(query,
current_user,
hide_lanes=False)
# Filter by board
if board_id:
query = query.outerjoin(models.BoardWorklist, models.Board)
query = api_base.filter_private_boards(query, current_user)
query = query.filter(models.Board.id == board_id)
query = api_base.filter_private_worklists(query,
current_user,
hide_lanes=False)
return query.distinct()
def story_get_all(title=None,
description=None,
status=None,
assignee_id=None,
creator_id=None,
project_group_id=None,
project_id=None,
subscriber_id=None,
tags=None,
updated_since=None,
board_id=None,
worklist_id=None,
marker=None,
offset=None,
limit=None,
tags_filter_type="all",
sort_field='id',
sort_dir='asc',
current_user=None):
# Sanity checks, in case someone accidentally explicitly passes in 'None'
if not sort_field:
sort_field = 'id'
if not sort_dir:
sort_dir = 'asc'
if not isinstance(status, list) and status is not None:
status = [status]
# Build the query.
subquery = _story_build_query(title=title,
description=description,
assignee_id=assignee_id,
creator_id=creator_id,
project_group_id=project_group_id,
project_id=project_id,
tags=tags,
updated_since=updated_since,
board_id=board_id,
worklist_id=worklist_id,
current_user=current_user,
tags_filter_type=tags_filter_type)
# Filter by subscriber ID
if subscriber_id is not None:
subs = api_base.model_query(models.Subscription)
subs = api_base.apply_query_filters(query=subs,
model=models.Subscription,
target_type='story',
user_id=subscriber_id)
subs = subs.subquery()
subquery = subquery.join(subs, subs.c.target_id == models.Story.id)
# Turn the whole shebang into a subquery.
subquery = subquery.subquery('filtered_stories')
# Return the story summary.
query = api_base.model_query(models.StorySummary)\
.options(subqueryload(models.StorySummary.tags))
id_col = tuple(subquery.c)[0]
query = query.join(subquery, models.StorySummary.id == id_col)
if status:
query = query.filter(models.StorySummary.status.in_(status))
# paginate the query
query = api_base.paginate_query(query=query,
model=models.StorySummary,
limit=limit,
sort_key=sort_field,
marker=marker,
offset=offset,
sort_dir=sort_dir)
raw_stories = query.all()
return raw_stories
def _story_build_query(title=None, description=None, assignee_id=None,
creator_id=None, project_group_id=None, project_id=None,
tags=None, tags_filter_type='all', current_user=None):
# First build a standard story query.
query = api_base.model_query(models.Story.id).distinct()
# Apply basic filters
query = api_base.apply_query_filters(query=query,
model=models.Story,
title=title,
description=description,
creator_id=creator_id)
# Filter out stories that the current user can't see
query = query.outerjoin(models.story_permissions,
models.Permission,
models.user_permissions,
models.User)
if current_user:
query = query.filter(
or_(
and_(
models.User.id == current_user,
models.Story.private == true()
),
models.Story.private == false()
)
)
else:
query = query.filter(models.Story.private == false())
# Filtering by tags
if tags:
if tags_filter_type == 'all':
for tag in tags:
query = query.filter(models.Story.tags.any(name=tag))
elif tags_filter_type == 'any':
query = query.filter(models.Story.tags.any
(models.StoryTag.name.in_(tags)))
else:
raise exc.NotFound("Tags filter not found.")
# Are we filtering by project group?
if project_group_id:
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
query = query.join(models.Project,
models.project_group_mapping,
models.ProjectGroup)
query = query.filter(models.ProjectGroup.id == project_group_id)
# Are we filtering by task?
if assignee_id or project_id:
if not project_group_id: # We may already have joined this table
query = query.join(
(models.Task, models.Task.story_id == models.Story.id))
if assignee_id:
query = query.filter(models.Task.assignee_id == assignee_id)
if project_id:
query = query.filter(models.Task.project_id == project_id)
return query
