Filters & Dashboards

def filter(self, id: str) -> Filter:
    """
    Get a filter by ID.
    
    Parameters:
    - id: Filter ID
    
    Returns:
    Filter object
    """

def favourite_filters(self) -> list[Filter]:
    """
    Get list of current user's favorite filters.
    
    Returns:
    List of Filter objects marked as favorites
    """

def create_filter(
    self,
    name: str = None,
    description: str = None,
    jql: str = None,
    favourite: bool = None
) -> Filter:
    """
    Create a new filter.
    
    Parameters:
    - name: Filter name
    - description: Filter description
    - jql: JQL query string
    - favourite: Whether to mark as favorite
    
    Returns:
    Created Filter object
    """

def update_filter(
    self,
    filter_id: str,
    name: str = None,
    description: str = None,
    jql: str = None,
    favourite: bool = None
) -> Filter:
    """
    Update an existing filter.
    
    Parameters:
    - filter_id: ID of filter to update
    - name: New filter name
    - description: New filter description
    - jql: New JQL query string
    - favourite: Whether to mark as favorite
    
    Returns:
    Updated Filter object
    """

# Get a specific filter
filter_obj = jira.filter('12345')
print(f"Filter: {filter_obj.name}")
print(f"JQL: {filter_obj.jql}")
print(f"Owner: {filter_obj.owner.displayName}")

# Get user's favorite filters
favorites = jira.favourite_filters()
for filter_obj in favorites:
    print(f"Favorite: {filter_obj.name} - {filter_obj.jql}")

# Create a new filter
new_filter = jira.create_filter(
    name="My High Priority Issues",
    description="All high priority issues assigned to me",
    jql="assignee = currentUser() AND priority = High",
    favourite=True
)
print(f"Created filter: {new_filter.id}")

# Update an existing filter
updated_filter = jira.update_filter(
    filter_id=new_filter.id,
    name="My Critical Issues",
    jql="assignee = currentUser() AND priority in (High, Highest)"
)

def dashboards(
    self,
    filter: str = None,
    startAt: int = 0,
    maxResults: int = 20
) -> list[Dashboard]:
    """
    Get dashboards visible to current user.
    
    Parameters:
    - filter: Dashboard name filter
    - startAt: Starting index for pagination
    - maxResults: Maximum number of results
    
    Returns:
    List of Dashboard objects
    """

def dashboard(self, id: str) -> Dashboard:
    """
    Get a specific dashboard by ID.
    
    Parameters:
    - id: Dashboard ID
    
    Returns:
    Dashboard object
    """

# Get all dashboards
dashboards = jira.dashboards()
for dashboard in dashboards:
    print(f"Dashboard: {dashboard.name}")
    print(f"URL: {dashboard.view_url}")

# Search for specific dashboards
project_dashboards = jira.dashboards(filter="Project")
for dashboard in project_dashboards:
    print(f"Project dashboard: {dashboard.name}")

# Get specific dashboard details
dashboard = jira.dashboard('12345')
print(f"Dashboard: {dashboard.name}")
print(f"Owner: {dashboard.owner.displayName}")
print(f"Favorite: {dashboard.favourite}")

filter_obj = jira.filter('12345')

# Basic properties
print(f"ID: {filter_obj.id}")
print(f"Name: {filter_obj.name}")
print(f"Description: {filter_obj.description}")
print(f"JQL: {filter_obj.jql}")
print(f"Favorite: {filter_obj.favourite}")

# Owner information
print(f"Owner: {filter_obj.owner.displayName}")
print(f"Owner Key: {filter_obj.owner.key}")

# URLs
print(f"View URL: {filter_obj.viewUrl}")
print(f"Search URL: {filter_obj.searchUrl}")

# Sharing and permissions
print(f"Share Permissions: {filter_obj.sharePermissions}")
print(f"Editable: {filter_obj.editable}")

# Subscription information (if available)
if hasattr(filter_obj, 'subscriptions'):
    print(f"Subscriptions: {len(filter_obj.subscriptions)}")

dashboard = jira.dashboard('12345')

# Basic properties
print(f"ID: {dashboard.id}")
print(f"Name: {dashboard.name}")
print(f"Favorite: {dashboard.favourite}")

# Owner information
print(f"Owner: {dashboard.owner.displayName}")

# URLs
print(f"View URL: {dashboard.view_url}")

# Share permissions
print(f"Share Permissions: {dashboard.sharePermissions}")
print(f"Editable: {dashboard.editable}")

# Create filter for team's work
team_filter = jira.create_filter(
    name="Team Sprint Work",
    description="Current sprint issues for development team",
    jql='''
    project = PROJ AND
    sprint in openSprints() AND
    assignee in (john.doe, jane.smith, bob.jones) AND
    status != Done
    ORDER BY priority DESC, created ASC
    ''',
    favourite=True
)

# Use filter to get issues
issues = jira.search_issues(team_filter.jql)
print(f"Found {len(issues)} issues in current sprint")

# Update filter to add more conditions
jira.update_filter(
    filter_id=team_filter.id,
    jql=team_filter.jql + " AND labels not in (blocked, on-hold)"
)

# Share filter with team (requires additional permissions)
# This would typically be done through the JIRA UI or additional API calls

# Get user's dashboards
my_dashboards = jira.dashboards()
for dashboard in my_dashboards:
    print(f"Dashboard: {dashboard.name}")
    
    # Note: Gadget configuration and data would require
    # additional API calls to the gadget endpoints
    if dashboard.favourite:
        print(f"  ⭐ Favorite dashboard")

# Find dashboards containing specific filters
filter_name = "My Team Issues"
for dashboard in my_dashboards:
    # In practice, you'd need to examine dashboard gadgets
    # to find which filters they use
    print(f"Checking dashboard: {dashboard.name}")

# Always check if filter exists before creating
def get_or_create_filter(jira_client, name, jql):
    """Get existing filter or create new one."""
    favorites = jira_client.favourite_filters()
    for filter_obj in favorites:
        if filter_obj.name == name:
            return filter_obj
    
    # Create new filter if not found
    return jira_client.create_filter(
        name=name,
        jql=jql,
        favourite=True
    )

# Use descriptive names and JQL
team_filter = get_or_create_filter(
    jira,
    "Backend Team - Current Sprint",
    '''
    project = BACKEND AND
    sprint in openSprints() AND
    component in ("API", "Database", "Services")
    ORDER BY priority DESC
    '''
)

# Validate JQL before creating filters
try:
    test_results = jira.search_issues(jql_query, maxResults=1)
    filter_obj = jira.create_filter(name="Test Filter", jql=jql_query)
except Exception as e:
    print(f"Invalid JQL: {e}")