use serde_json::{Value, json};
use crate::options::{RequestOption, query};
use crate::{Client, Response, Result};
fn search_body(fields: &[(&str, Option<Value>)]) -> Value {
let map: serde_json::Map<String, Value> = fields
.iter()
.filter_map(|(k, v)| v.clone().map(|v| ((*k).to_string(), v)))
.collect();
Value::Object(map)
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghBeaconQuery<'a> {
pub alternate_bases: Option<&'a str>,
pub assembly_id: Option<&'a str>,
pub end: Option<i64>,
pub reference_bases: Option<&'a str>,
pub reference_name: Option<&'a str>,
pub start: Option<i64>,
pub variant_type: Option<&'a str>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghFeaturesQuery<'a> {
pub end: Option<i64>,
pub reference_name: Option<&'a str>,
pub start: Option<i64>,
pub feature_set_id: Option<&'a str>,
pub parent_id: Option<&'a str>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghCallsetQuery<'a> {
pub variant_set_id: Option<&'a str>,
pub name: Option<&'a str>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghFeaturesetsQuery<'a> {
pub dataset_id: Option<&'a str>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghVariantAnnotationsQuery<'a> {
pub variant_annotation_set_id: Option<&'a str>,
pub effects: Option<&'a Value>,
pub end: Option<i64>,
pub page_size: Option<i64>,
pub page_token: Option<&'a Value>,
pub reference_id: Option<&'a str>,
pub reference_name: Option<&'a str>,
pub start: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghVariantsQuery<'a> {
pub variant_set_id: Option<&'a str>,
pub call_set_ids: Option<&'a [&'a str]>,
pub reference_name: Option<&'a str>,
pub start: Option<i64>,
pub end: Option<i64>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghVariantsetsQuery<'a> {
pub dataset_id: Option<&'a str>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghReferencesQuery<'a> {
pub reference_set_id: Option<&'a str>,
pub md5checksum: Option<&'a str>,
pub accession: Option<&'a str>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghReferencesetsQuery<'a> {
pub accession: Option<&'a str>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub struct Ga4ghVariantAnnotationsetsQuery<'a> {
pub variant_set_id: Option<&'a str>,
pub page_token: Option<&'a Value>,
pub page_size: Option<i64>,
}
impl Client {
pub fn get_ga4gh_beacon(&self, opts: &[RequestOption<'_>]) -> Result<Response> {
self.call("getGA4GHBeacon", &[], None, opts)
}
#[allow(clippy::too_many_arguments)]
pub fn get_ga4gh_beacon_query(
&self,
alternate_bases: &str,
assembly_id: &str,
reference_bases: &str,
reference_name: &str,
start: i64,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let start = start.to_string();
let mut all_opts = vec![
query("alternateBases", alternate_bases),
query("assemblyId", assembly_id),
query("referenceBases", reference_bases),
query("referenceName", reference_name),
query("start", &start),
];
all_opts.extend_from_slice(opts);
self.call("getGA4GHBeaconQuery", &[], None, &all_opts)
}
pub fn post_ga4gh_beacon_query(
&self,
query: &Ga4ghBeaconQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("alternateBases", query.alternate_bases.map(|v| json!(v))),
("assemblyId", query.assembly_id.map(|v| json!(v))),
("end", query.end.map(|v| json!(v))),
("referenceBases", query.reference_bases.map(|v| json!(v))),
("referenceName", query.reference_name.map(|v| json!(v))),
("start", query.start.map(|v| json!(v))),
("variantType", query.variant_type.map(|v| json!(v))),
]);
self.call("postGA4GHBeaconQuery", &[], Some(&body), opts)
}
pub fn get_ga4gh_features_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHFeaturesById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_features(
&self,
query: &Ga4ghFeaturesQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("end", query.end.map(|v| json!(v))),
("referenceName", query.reference_name.map(|v| json!(v))),
("start", query.start.map(|v| json!(v))),
("featureSetId", query.feature_set_id.map(|v| json!(v))),
("parentId", query.parent_id.map(|v| json!(v))),
]);
self.call("searchGA4GHFeatures", &[], Some(&body), opts)
}
pub fn search_ga4gh_callset(
&self,
query: &Ga4ghCallsetQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("variantSetId", query.variant_set_id.map(|v| json!(v))),
("name", query.name.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHCallset", &[], Some(&body), opts)
}
pub fn get_ga4gh_callset_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHCallsetById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_datasets(
&self,
page_token: Option<&Value>,
page_size: Option<i64>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("pageToken", page_token.cloned()),
("pageSize", page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHDatasets", &[], Some(&body), opts)
}
pub fn get_ga4gh_datasets_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHDatasetsById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_featuresets(
&self,
query: &Ga4ghFeaturesetsQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("datasetId", query.dataset_id.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHFeaturesets", &[], Some(&body), opts)
}
pub fn get_ga4gh_featuresets_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHFeaturesetsById", &[("id", id)], None, opts)
}
pub fn get_ga4gh_variants_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHVariantsById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_variant_annotations(
&self,
query: &Ga4ghVariantAnnotationsQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
(
"variantAnnotationSetId",
query.variant_annotation_set_id.map(|v| json!(v)),
),
("effects", query.effects.cloned()),
("end", query.end.map(|v| json!(v))),
("pageSize", query.page_size.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("referenceId", query.reference_id.map(|v| json!(v))),
("referenceName", query.reference_name.map(|v| json!(v))),
("start", query.start.map(|v| json!(v))),
]);
self.call("searchGA4GHVariantAnnotations", &[], Some(&body), opts)
}
pub fn search_ga4gh_variants(
&self,
query: &Ga4ghVariantsQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("variantSetId", query.variant_set_id.map(|v| json!(v))),
("callSetIds", query.call_set_ids.map(|v| json!(v))),
("referenceName", query.reference_name.map(|v| json!(v))),
("start", query.start.map(|v| json!(v))),
("end", query.end.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHVariants", &[], Some(&body), opts)
}
pub fn search_ga4gh_variantsets(
&self,
query: &Ga4ghVariantsetsQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("datasetId", query.dataset_id.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHVariantsets", &[], Some(&body), opts)
}
pub fn get_ga4gh_variantsets_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHVariantsetsById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_references(
&self,
query: &Ga4ghReferencesQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("referenceSetId", query.reference_set_id.map(|v| json!(v))),
("md5checksum", query.md5checksum.map(|v| json!(v))),
("accession", query.accession.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHReferences", &[], Some(&body), opts)
}
pub fn get_ga4gh_references_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHReferencesById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_referencesets(
&self,
query: &Ga4ghReferencesetsQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("accession", query.accession.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHReferencesets", &[], Some(&body), opts)
}
pub fn get_ga4gh_referencesets_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call("getGA4GHReferencesetsById", &[("id", id)], None, opts)
}
pub fn search_ga4gh_variant_annotationsets(
&self,
query: &Ga4ghVariantAnnotationsetsQuery<'_>,
opts: &[RequestOption<'_>],
) -> Result<Response> {
let body = search_body(&[
("variantSetId", query.variant_set_id.map(|v| json!(v))),
("pageToken", query.page_token.cloned()),
("pageSize", query.page_size.map(|v| json!(v))),
]);
self.call("searchGA4GHVariantAnnotationsets", &[], Some(&body), opts)
}
pub fn get_ga4gh_variant_annotationsets_by_id(
&self,
id: &str,
opts: &[RequestOption<'_>],
) -> Result<Response> {
self.call(
"getGA4GHVariantAnnotationsetsById",
&[("id", id)],
None,
opts,
)
}
}