133 lines
3.9 KiB
Rust
133 lines
3.9 KiB
Rust
use crate::cli::Issue2Work;
|
|
use crate::config::Config;
|
|
use crate::error::GeneralError;
|
|
use crate::gitlab::client::{ClientProvider, ClientProviderTrait};
|
|
use crate::gitlab::issue::IssueBundle;
|
|
use crate::openproject::client::Client;
|
|
use crate::openproject::user::{GetMe, User};
|
|
use crate::openproject::work::WorkPackageWriterAssignee;
|
|
use gitlab::api::{issues, projects, AsyncQuery};
|
|
use gitlab::{Issue, Project};
|
|
use url::Url;
|
|
|
|
#[derive(Debug)]
|
|
struct IssueInfo {
|
|
project: String,
|
|
iid: u64,
|
|
}
|
|
|
|
/// details on how to create a work package from various informations
|
|
#[derive(Debug)]
|
|
struct Issue2WorkPackageDTO {
|
|
pub issue: IssueBundle,
|
|
pub assign_to: Option<User>,
|
|
}
|
|
|
|
impl From<&Issue2WorkPackageDTO> for crate::openproject::work::WorkPackageWriter {
|
|
fn from(value: &Issue2WorkPackageDTO) -> Self {
|
|
crate::openproject::work::WorkPackageWriter {
|
|
subject: format!(
|
|
"{} ({}/{})",
|
|
value.issue.issue.title,
|
|
value.issue.project.name_with_namespace,
|
|
value.issue.issue.iid
|
|
),
|
|
work_type: "TASK".into(),
|
|
description: crate::openproject::work::DescriptionWriter {
|
|
format: "markdown".into(),
|
|
raw: format!("From gitlab: {}", value.issue.issue.web_url),
|
|
},
|
|
assignee: WorkPackageWriterAssignee {
|
|
href: match &value.assign_to {
|
|
None => None,
|
|
Some(w) => Some(w.clone().d_links.d_self.href),
|
|
},
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) async fn issue2work(config: Config, args: &Issue2Work) -> Result<(), GeneralError> {
|
|
let url = Url::parse(&*args.issue_url).expect("issue_url is not valid");
|
|
let data = extract_issue_info(&url).unwrap();
|
|
|
|
let client = ClientProvider::client_for_url(&url, &config).await?;
|
|
|
|
let endpoint = issues::ProjectIssues::builder()
|
|
.iid(data.iid)
|
|
.project(String::from(data.project))
|
|
.build()
|
|
.unwrap();
|
|
|
|
let issues: Vec<Issue> = endpoint.query_async(&client).await.unwrap();
|
|
let issue = issues.first().unwrap();
|
|
|
|
let project_endpoint = projects::Project::builder()
|
|
.project(issue.project_id.value())
|
|
.build()
|
|
.unwrap();
|
|
|
|
let project: Project = project_endpoint.query_async(&client).await.unwrap();
|
|
|
|
let issue_bundle = IssueBundle::new(&issue, &project);
|
|
|
|
let open_project_client = Client::from_config(&config.openproject);
|
|
|
|
let dto = Issue2WorkPackageDTO {
|
|
issue: issue_bundle,
|
|
assign_to: match args.assign_to_me {
|
|
true => {
|
|
let u = open_project_client.me().await?;
|
|
Some(u)
|
|
}
|
|
false => None,
|
|
},
|
|
};
|
|
|
|
let work_package = open_project_client
|
|
.create_work_package(&(&dto).into(), &args.project_id)
|
|
.await?;
|
|
|
|
println!(
|
|
"new work package created: {:?}, edit at {}/projects/{}/work_packages/{}",
|
|
work_package.subject, config.openproject.base_url, args.project_id, work_package.id
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn extract_issue_info(url: &Url) -> Option<IssueInfo> {
|
|
let parts = url
|
|
.path_segments()
|
|
.expect("Could not parse path segment of given url");
|
|
let mut project_url: Vec<String> = Vec::with_capacity(3);
|
|
let mut iid: Option<String> = None;
|
|
|
|
let mut project_found = false;
|
|
|
|
for el in parts {
|
|
if el == "-" {
|
|
project_found = true;
|
|
continue;
|
|
}
|
|
if el == "issues" {
|
|
continue;
|
|
}
|
|
if !project_found {
|
|
project_url.push(String::from(el));
|
|
} else {
|
|
// must be the id
|
|
iid = Some(String::from(el));
|
|
break;
|
|
}
|
|
}
|
|
|
|
Some(IssueInfo {
|
|
project: project_url.join("/"),
|
|
iid: iid
|
|
.expect("iid of the issue not found")
|
|
.parse()
|
|
.expect("could not transform issue id to u64"),
|
|
})
|
|
}
|