kanbars 0.2.1

Lightning-fast terminal kanban board for JIRA
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::config::Config;
use crate::model::{Ticket, TicketType};
use base64::{Engine as _, engine::general_purpose};
use reqwest::blocking::Client;
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize)]
struct JiraResponse {
    issues: Vec<JiraIssue>,
}

#[derive(Debug, Deserialize)]
struct JiraIssue {
    key: String,
    fields: JiraFields,
}

#[derive(Debug, Deserialize)]
struct JiraFields {
    summary: String,
    status: JiraStatus,
    issuetype: JiraIssueType,
    assignee: Option<JiraUser>,
}

#[derive(Debug, Deserialize)]
struct JiraStatus {
    name: String,
}

#[derive(Debug, Deserialize)]
struct JiraIssueType {
    name: String,
}

#[derive(Debug, Deserialize)]
struct JiraUser {
    #[serde(rename = "displayName")]
    display_name: Option<String>,
    #[serde(rename = "emailAddress")]
    email_address: Option<String>,
}

pub fn fetch_tickets_api(config: &Config) -> Result<Vec<Ticket>, Box<dyn Error>> {
    let url = config.jira.url.as_ref()
        .ok_or("JIRA URL not configured. Set JIRA_URL or JIRA_SITE environment variable")?;
    let email = config.jira.email.as_ref()
        .ok_or("JIRA email not configured. Set JIRA_USER or JIRA_EMAIL environment variable")?;
    let token = config.jira.api_token.as_ref()
        .ok_or("JIRA API token not configured. Set JIRA_API_TOKEN environment variable")?;
    
    let client = Client::new();
    
    // Create basic auth header
    let auth = format!("{}:{}", email, token);
    let encoded = general_purpose::STANDARD.encode(auth.as_bytes());
    
    // Use the new v3 JQL search endpoint
    let api_url = format!("{}/rest/api/3/search/jql", url.trim_end_matches('/'));
    
    let response = client
        .get(&api_url)
        .header("Authorization", format!("Basic {}", encoded))
        .header("Accept", "application/json")
        .query(&[
            ("jql", config.query.jql.as_str()),
            ("maxResults", "100"),
            ("fields", "key,summary,status,issuetype,assignee"),
        ])
        .send()?;
    
    if !response.status().is_success() {
        let status = response.status();
        let body = response.text().unwrap_or_else(|_| "Could not read response body".to_string());
        return Err(format!(
            "JIRA API request failed with status: {}\nResponse: {}",
            status,
            body
        ).into());
    }
    
    let jira_response: JiraResponse = response.json()?;
    
    let tickets: Vec<Ticket> = jira_response.issues
        .into_iter()
        .map(|issue| {
            let assignee = issue.fields.assignee
                .and_then(|u| u.display_name.or(u.email_address))
                .unwrap_or_else(|| "unassigned".to_string());
            
            Ticket {
                key: issue.key,
                ticket_type: TicketType::from_str(&issue.fields.issuetype.name),
                summary: issue.fields.summary,
                status: issue.fields.status.name,
                assignee,
            }
        })
        .collect();
    
    Ok(tickets)
}