commit fc7640a08233b5cae6ff37bbeaaf256cec3ee5d0 · dunkirk.sh/tangled-cli

+35

crates/tangled-api/src/client.rs

···

       926
       926
        
               Self::uri_rkey(&res.uri).ok_or_else(|| anyhow!("missing rkey in issue state uri"))

     

       927
       927
        
           }

     

       928
       928
        
       

     

       929
       929
       +
           pub async fn list_issue_states(

     

       930
       930
       +
               &self,

     

       931
       931
       +
               author_did: &str,

     

       932
       932
       +
               bearer: Option<&str>,

     

       933
       933
       +
           ) -> Result<Vec<IssueState>> {

     

       934
       934
       +
               #[derive(Deserialize)]

     

       935
       935
       +
               struct Item {

     

       936
       936
       +
                   #[allow(dead_code)]

     

       937
       937
       +
                   uri: String,

     

       938
       938
       +
                   #[allow(dead_code)]

     

       939
       939
       +
                   cid: Option<String>,

     

       940
       940
       +
                   value: IssueState,

     

       941
       941
       +
               }

     

       942
       942
       +
               #[derive(Deserialize)]

     

       943
       943
       +
               struct ListRes {

     

       944
       944
       +
                   #[serde(default)]

     

       945
       945
       +
                   records: Vec<Item>,

     

       946
       946
       +
               }

     

       947
       947
       +
               let params = vec![

     

       948
       948
       +
                   ("repo", author_did.to_string()),

     

       949
       949
       +
                   ("collection", "sh.tangled.repo.issue.state".to_string()),

     

       950
       950
       +
                   ("limit", "100".to_string()),

     

       951
       951
       +
               ];

     

       952
       952
       +
               let res: ListRes = self

     

       953
       953
       +
                   .get_json("com.atproto.repo.listRecords", &params, bearer)

     

       954
       954
       +
                   .await?;

     

       955
       955
       +
               Ok(res.records.into_iter().map(|it| it.value).collect())

     

       956
       956
       +
           }

     

       957
       957
       +
       

     

       929
       958
        
           pub async fn get_pull_record(

     

       930
       959
        
               &self,

     

       931
       960
        
               author_did: &str,

     
···

       1363
       1392
        
           pub author_did: String,

     

       1364
       1393
        
           pub rkey: String,

     

       1365
       1394
        
           pub issue: Issue,

     

       1395
       1395
       +
       }

     

       1396
       1396
       +
       

     

       1397
       1397
       +
       #[derive(Debug, Clone, Serialize, Deserialize)]

     

       1398
       1398
       +
       pub struct IssueState {

     

       1399
       1399
       +
           pub issue: String,

     

       1400
       1400
       +
           pub state: String,

     

       1366
       1401
        
       }

     

       1367
       1402
        
       

     

       1368
       1403
        
       // Pull record value (subset)

+2 -2

crates/tangled-api/src/lib.rs

···

       2
       2
        
       

     

       3
       3
        
       pub use client::TangledClient;

     

       4
       4
        
       pub use client::{

     

       5
       5
       -
           CreateRepoOptions, DefaultBranch, Issue, IssueRecord, Language, Languages, Pull, PullRecord,

     

       6
       6
       -
           RepoRecord, Repository, Secret,

     

       5
       5
       +
           CreateRepoOptions, DefaultBranch, Issue, IssueRecord, IssueState, Language, Languages, Pull,

     

       6
       6
       +
           PullRecord, RepoRecord, Repository, Secret,

     

       7
       7
        
       };

+39 -1

crates/tangled-cli/src/commands/issue.rs

···

       34
       34
        
               None

     

       35
       35
        
           };

     

       36
       36
        
       

     

       37
       37
       -
           let items = client

     

       37
       37
       +
           let mut items = client

     

       38
       38
        
               .list_issues(

     

       39
       39
        
                   &session.did,

     

       40
       40
        
                   repo_filter_at.as_deref(),

     

       41
       41
        
                   Some(session.access_jwt.as_str()),

     

       42
       42
        
               )

     

       43
       43
        
               .await?;

     

       44
       44
       +
       

     

       45
       45
       +
           // Filter by state if requested

     

       46
       46
       +
           if let Some(state_filter) = &args.state {

     

       47
       47
       +
               let state_nsid = match state_filter.as_str() {

     

       48
       48
       +
                   "open" => "sh.tangled.repo.issue.state.open",

     

       49
       49
       +
                   "closed" => "sh.tangled.repo.issue.state.closed",

     

       50
       50
       +
                   other => {

     

       51
       51
       +
                       return Err(anyhow!(format!(

     

       52
       52
       +
                           "unknown state '{}', expected 'open' or 'closed'",

     

       53
       53
       +
                           other

     

       54
       54
       +
                       )))

     

       55
       55
       +
                   }

     

       56
       56
       +
               };

     

       57
       57
       +
       

     

       58
       58
       +
               // Fetch issue states

     

       59
       59
       +
               let states = client

     

       60
       60
       +
                   .list_issue_states(&session.did, Some(session.access_jwt.as_str()))

     

       61
       61
       +
                   .await?;

     

       62
       62
       +
       

     

       63
       63
       +
               // Build map of issue AT-URI to current state

     

       64
       64
       +
               let mut issue_states = std::collections::HashMap::new();

     

       65
       65
       +
               for state in states {

     

       66
       66
       +
                   issue_states.insert(state.issue, state.state);

     

       67
       67
       +
               }

     

       68
       68
       +
       

     

       69
       69
       +
               // Filter issues by state

     

       70
       70
       +
               items.retain(|it| {

     

       71
       71
       +
                   let issue_at = format!(

     

       72
       72
       +
                       "at://{}/sh.tangled.repo.issue/{}",

     

       73
       73
       +
                       it.author_did, it.rkey

     

       74
       74
       +
                   );

     

       75
       75
       +
                   match issue_states.get(&issue_at) {

     

       76
       76
       +
                       Some(state) => state == state_nsid,

     

       77
       77
       +
                       None => state_nsid == "sh.tangled.repo.issue.state.open", // default to open

     

       78
       78
       +
                   }

     

       79
       79
       +
               });

     

       80
       80
       +
           }

     

       81
       81
       +
       

     

       44
       82
        
           if items.is_empty() {

     

       45
       83
        
               println!("No issues found (showing only issues you created)");

     

       46
       84
        
           } else {