use crate::error::Result;
use crate::query::facet::FacetCount;
use crate::query::types::Type;
use crate::query::*;
use chrono::NaiveDate;
use std::borrow::Cow;
define_keyed_enum! {
WorkElement {
DOI => "DOI",
ISBN => "ISBN",
ISSN => "ISSN",
URL => "URL",
Abstract_ => "abstract",
Accepted => "accepted",
AlternativeId => "alternative-id",
Approved => "approved",
Archive => "archive",
ArticleNumber => "article-number",
Assertion => "assertion",
Author => "author",
Chair => "chair",
ClinicalTrialNumber => "clinical-trial-number",
ContainerTitle => "container-title",
ContentCreated => "content-created",
ContentDomain => "content-domain",
Contributor => "contributor",
Created => "created",
Degree => "degree",
Deposited => "deposited",
Editor => "editor",
Event => "event",
Funder => "funder",
GroupTitle => "group-title",
Indexed => "indexed",
IsReferencedByCount => "is-referenced-by-count",
IssnType => "issn-type",
Issue => "issue",
Issued => "issued",
License => "license",
Link => "link",
Member => "member",
OriginalTitle => "original-title",
Page => "page",
Posted => "posted",
Prefix => "prefix",
Published => "published",
PublishedOnline => "published-online",
PublishedPrint => "published-print",
Publisher => "publisher",
PublisherLocation => "publisher-location",
Reference => "reference",
ReferencesCount => "references-count",
Relation => "relation",
Resource => "resource",
Score => "score",
ShortContainerTitle => "short-container-title",
ShortTitle => "short-title",
StandardsBody => "standards-body",
Subject => "subject",
Subtitle => "subtitle",
Title => "title",
Translator => "translator",
Type => "type",
UpdatePolicy => "update-policy",
UpdateTo => "update-to",
UpdatedBy => "updated-by",
Volume => "volume",
}
}
define_filter! {
WorksFilter;
markers {
HasFunder => "has-funder",
HasFunderDoi => "has-funder-doi",
HasFunderRorId => "has-funder-ror-id",
HasAffiliation => "has-affiliation",
HasAffiliationRorId => "has-affiliation-ror-id",
HasRorId => "has-ror-id",
HasLicense => "has-license",
HasFullText => "has-full-text",
HasReferences => "has-references",
HasArchive => "has-archive",
HasOrcid => "has-orcid",
HasAuthenticatedOrcid => "has-authenticated-orcid",
HasAbstract => "has-abstract",
HasClinicalTrialNumber => "has-clinical-trial-number",
HasContentDomain => "has-content-domain",
HasDomainRestriction => "has-domain-restriction",
HasRelation => "has-relation",
HasUpdate => "has-update",
HasUpdatePolicy => "has-update-policy",
HasAssertion => "has-assertion",
HasAward => "has-award",
HasAlias => "has-alias",
HasPrimeDoi => "has-prime-doi",
HasEvent => "has-event",
IsUpdate => "is-update",
}
values {
Funder(String) => "funder",
Prefix(String) => "prefix",
Member(String) => "member",
Doi(String) => "doi",
Issn(String) => "issn",
Isbn(String) => "isbn",
Orcid(String) => "orcid",
Archive(String) => "archive",
Directory(String) => "directory",
Updates(String) => "updates",
ContainerTitle(String) => "container-title",
CategoryName(String) => "category-name",
TypeName(String) => "type-name",
Type(Type) => "type",
GroupTitle(String) => "group-title",
ContentDomain(String) => "content-domain",
ClinicalTrialNumber(String) => "clinical-trial-number",
AlternativeId(String) => "alternative-id",
ArticleNumber(String) => "article-number",
RorId(String) => "ror-id",
UpdateType(String) => "update-type",
FunderDoiAssertedBy(String) => "funder-doi-asserted-by",
Assertion(String) => "assertion",
AssertionGroup(String) => "assertion-group",
AwardNumber(String) => "award.number",
AwardFunder(String) => "award.funder",
GteAwardAmount(u64) => "gte-award-amount",
LteAwardAmount(u64) => "lte-award-amount",
LicenseUrl(String) => "license.url",
LicenseVersion(String) => "license.version",
LicenseDelay(i32) => "license.delay",
FullTextVersion(String) => "full-text.version",
FullTextType(String) => "full-text.type",
FullTextApplication(String) => "full-text.application",
RelationType(String) => "relation.type",
RelationObject(String) => "relation.object",
RelationObjectType(String) => "relation.object-type",
FromIndexDate(NaiveDate) => "from-index-date",
UntilIndexDate(NaiveDate) => "until-index-date",
FromDepositDate(NaiveDate) => "from-deposit-date",
UntilDepositDate(NaiveDate) => "until-deposit-date",
FromUpdateDate(NaiveDate) => "from-update-date",
UntilUpdateDate(NaiveDate) => "until-update-date",
FromCreatedDate(NaiveDate) => "from-created-date",
UntilCreatedDate(NaiveDate) => "until-created-date",
FromPubDate(NaiveDate) => "from-pub-date",
UntilPubDate(NaiveDate) => "until-pub-date",
FromOnlinePubDate(NaiveDate) => "from-online-pub-date",
UntilOnlinePubDate(NaiveDate) => "until-online-pub-date",
FromPrintPubDate(NaiveDate) => "from-print-pub-date",
UntilPrintPubDate(NaiveDate) => "until-print-pub-date",
FromPostedDate(NaiveDate) => "from-posted-date",
UntilPostedDate(NaiveDate) => "until-posted-date",
FromAcceptedDate(NaiveDate) => "from-accepted-date",
UntilAcceptedDate(NaiveDate) => "until-accepted-date",
FromApprovedDate(NaiveDate) => "from-approved-date",
UntilApprovedDate(NaiveDate) => "until-approved-date",
FromAwardedDate(NaiveDate) => "from-awarded-date",
UntilAwardedDate(NaiveDate) => "until-awarded-date",
FromIssuedDate(NaiveDate) => "from-issued-date",
UntilIssuedDate(NaiveDate) => "until-issued-date",
FromEventStartDate(NaiveDate) => "from-event-start-date",
UntilEventStartDate(NaiveDate) => "until-event-start-date",
FromEventEndDate(NaiveDate) => "from-event-end-date",
UntilEventEndDate(NaiveDate) => "until-event-end-date",
}
}
define_field_queries! {
Title => "title" / title,
ContainerTitle => "container-title" / container_title,
Author => "author" / author,
Editor => "editor" / editor,
Chair => "chair" / chair,
Translator => "translator" / translator,
Contributor => "contributor" / contributor,
Bibliographic => "bibliographic" / bibliographic,
Affiliation => "affiliation" / affiliation,
Degree => "degree" / degree,
Description => "description" / description,
EventAcronym => "event-acronym" / event_acronym,
EventLocation => "event-location" / event_location,
EventName => "event-name" / event_name,
EventSponsor => "event-sponsor" / event_sponsor,
EventTheme => "event-theme" / event_theme,
FunderName => "funder-name" / funder_name,
PublisherLocation => "publisher-location" / publisher_location,
PublisherName => "publisher-name" / publisher_name,
StandardsBodyAcronym => "standards-body-acronym" / standards_body_acronym,
StandardsBodyName => "standards-body-name" / standards_body_name,
}
impl CrossrefQueryParam for FieldQuery {
fn params(&self) -> Vec<(Cow<'_, str>, Cow<'_, str>)> {
vec![(
Cow::Borrowed(self.name()),
Cow::Owned(format_query(self.value())),
)]
}
}
#[derive(Debug, Clone)]
pub enum WorkResultControl {
Standard(ResultControl),
Cursor {
token: Option<String>,
rows: Option<usize>,
},
}
impl WorkResultControl {
pub fn new_cursor() -> Self {
WorkResultControl::Cursor {
token: None,
rows: None,
}
}
pub fn cursor(token: &str) -> Self {
WorkResultControl::Cursor {
token: Some(token.to_string()),
rows: None,
}
}
}
impl Default for WorkResultControl {
fn default() -> Self {
WorkResultControl::new_cursor()
}
}
impl CrossrefQueryParam for WorkResultControl {
fn params(&self) -> Vec<(Cow<'_, str>, Cow<'_, str>)> {
match self {
WorkResultControl::Standard(standard) => standard.params(),
WorkResultControl::Cursor { token, rows } => {
let mut params = vec![(
Cow::Borrowed("cursor"),
Cow::Borrowed(token.as_deref().unwrap_or("*")),
)];
if let Some(rows) = rows {
params.push((Cow::Borrowed("rows"), Cow::Owned(rows.to_string())));
}
params
}
}
}
}
#[derive(Debug, Clone)]
pub enum Works {
Identifier(String),
Query(WorksQuery),
Agency(String),
}
impl Works {
pub fn doi(doi: &str) -> Self {
Works::Identifier(doi.to_string())
}
pub fn agency_for_doi(doi: &str) -> Self {
Works::Agency(doi.to_string())
}
}
impl CrossrefRoute for Works {
fn route(&self) -> Result<String> {
match self {
Works::Identifier(s) => Ok(format!("{}/{}", Component::Works.route()?, s)),
Works::Agency(s) => Ok(format!("{}/{}/agency", Component::Works.route()?, s)),
Works::Query(query) => query.route(),
}
}
}
impl CrossrefQuery for Works {
fn resource_component(self) -> ResourceComponent {
ResourceComponent::Works(self)
}
}
#[derive(Debug, Clone)]
pub enum WorkListQuery {
Works(WorksQuery),
Combined {
primary_component: WorksComponent,
ident: WorksIdentQuery,
},
}
impl WorkListQuery {
pub fn query(&self) -> &WorksQuery {
match self {
WorkListQuery::Works(query) => query,
WorkListQuery::Combined { ident, .. } => &ident.query,
}
}
pub fn query_mut(&mut self) -> &mut WorksQuery {
match self {
WorkListQuery::Works(query) => query,
WorkListQuery::Combined { ident, .. } => &mut ident.query,
}
}
}
impl From<WorksQuery> for WorkListQuery {
fn from(val: WorksQuery) -> Self {
WorkListQuery::Works(val)
}
}
impl<T: ToString> From<T> for WorkListQuery {
fn from(term: T) -> Self {
WorkListQuery::Works(WorksQuery::new(term))
}
}
impl CrossrefRoute for WorkListQuery {
fn route(&self) -> Result<String> {
match self {
WorkListQuery::Works(query) => query.route(),
WorkListQuery::Combined {
primary_component,
ident,
} => Ok(format!(
"{}/{}{}",
primary_component.route()?,
ident.id,
ident.query.route()?
)),
}
}
}
impl CrossrefQuery for WorkListQuery {
fn resource_component(self) -> ResourceComponent {
match self {
WorkListQuery::Works(query) => ResourceComponent::Works(Works::Query(query)),
WorkListQuery::Combined {
primary_component,
ident,
} => match primary_component {
WorksComponent::Funders => ResourceComponent::Funders(Funders::Works(ident)),
WorksComponent::Journals => ResourceComponent::Journals(Journals::Works(ident)),
WorksComponent::Members => ResourceComponent::Members(Members::Works(ident)),
WorksComponent::Prefixes => ResourceComponent::Prefixes(Prefixes::Works(ident)),
WorksComponent::Types => ResourceComponent::Types(Types::Works(ident)),
},
}
}
}
#[derive(Debug, Clone)]
pub struct WorksIdentQuery {
pub id: String,
pub query: WorksQuery,
}
impl WorksIdentQuery {
pub fn new<T: Into<String>>(id: T, query: WorksQuery) -> Self {
WorksIdentQuery {
id: id.into(),
query,
}
}
}
pub trait WorksCombiner {
fn primary_component() -> WorksComponent;
fn ident_query(ident: WorksIdentQuery) -> Self;
fn combined_route(ident: &WorksIdentQuery) -> Result<String> {
Ok(format!(
"{}/{}{}",
Self::primary_component().route()?,
ident.id,
ident.query.route()?
))
}
fn work_list_query(ident: WorksIdentQuery) -> WorkListQuery {
WorkListQuery::Combined {
primary_component: Self::primary_component(),
ident,
}
}
}
macro_rules! impl_combiner {
($($name:ident,)*) => {
$(
impl WorksCombiner for $name {
fn primary_component() -> WorksComponent {
WorksComponent::$name
}
fn ident_query(ident: WorksIdentQuery) -> Self {
$name::Works(ident)
}
}
)+
};
}
impl_combiner!(Journals, Funders, Members, Prefixes, Types,);
impl WorksQuery {
pub fn empty() -> Self {
WorksQuery::default()
}
pub fn random(len: usize) -> Self {
WorksQuery::default().sample(len)
}
pub fn new<T: ToString>(query: T) -> Self {
WorksQuery::empty().query(query)
}
pub fn sample(mut self, len: impl Into<Option<usize>>) -> Self {
self.sample = len.into();
self
}
pub fn query<T: ToString>(mut self, query: T) -> Self {
self.free_form_queries.push(query.to_string());
self
}
pub fn queries<T: ToString>(mut self, queries: &[T]) -> Self {
self.free_form_queries
.extend(queries.iter().map(T::to_string));
self
}
pub fn field_query(mut self, query: FieldQuery) -> Self {
self.field_queries.push(query);
self
}
pub fn elements(mut self, element: Vec<WorkElement>) -> Self {
self.elements.extend(element);
self
}
pub fn field_queries(mut self, queries: Vec<FieldQuery>) -> Self {
self.field_queries.extend(queries);
self
}
pub fn filter(mut self, filter: WorksFilter) -> Self {
self.filter.push(filter);
self
}
pub fn sort(mut self, sort: impl Into<Option<Sort>>) -> Self {
self.sort = sort.into();
self
}
pub fn order(mut self, order: impl Into<Option<Order>>) -> Self {
self.order = order.into();
self
}
pub fn facet(mut self, facet: FacetCount) -> Self {
self.facets.push(facet);
self
}
pub fn next_cursor(mut self, cursor: &str) -> Self {
let rows = match self.result_control {
Some(WorkResultControl::Standard(ResultControl::Rows(rows))) => Some(rows),
_ => None,
};
self.result_control = Some(WorkResultControl::Cursor {
token: Some(cursor.to_string()),
rows,
});
self
}
pub fn new_cursor(mut self) -> Self {
self.result_control = Some(WorkResultControl::new_cursor());
self
}
pub fn result_control(mut self, result_control: impl Into<Option<WorkResultControl>>) -> Self {
self.result_control = result_control.into();
self
}
pub fn into_combined<W: WorksCombiner>(self, id: &str) -> W {
W::ident_query(self.into_ident(id))
}
pub fn into_ident(self, id: &str) -> WorksIdentQuery {
WorksIdentQuery::new(id, self)
}
pub fn into_combined_query<W: WorksCombiner>(self, id: &str) -> WorkListQuery {
W::work_list_query(self.into_ident(id))
}
}
#[derive(Debug, Clone, Default)]
pub struct WorksQuery {
pub free_form_queries: Vec<String>,
pub field_queries: Vec<FieldQuery>,
pub filter: Vec<WorksFilter>,
pub sort: Option<Sort>,
pub order: Option<Order>,
pub elements: Vec<WorkElement>,
pub facets: Vec<FacetCount>,
pub result_control: Option<WorkResultControl>,
pub sample: Option<usize>,
}
fn select_value(elements: &[WorkElement]) -> String {
let selected = elements.iter().map(WorkElement::name);
if elements.contains(&WorkElement::DOI) {
selected.collect::<Vec<_>>().join(",")
} else {
std::iter::once(WorkElement::DOI.name())
.chain(selected)
.collect::<Vec<_>>()
.join(",")
}
}
impl CrossrefRoute for WorksQuery {
fn route(&self) -> Result<String> {
let mut params: Vec<(Cow<'_, str>, Cow<'_, str>)> = Vec::new();
if let Some(sample) = self.sample {
params.push((Cow::Borrowed("sample"), Cow::Owned(sample.to_string())));
return Ok(format!(
"{}{}",
Component::Works.route()?,
encode::query_string(¶ms)
));
}
if !self.free_form_queries.is_empty() {
params.push((
Cow::Borrowed("query"),
Cow::Owned(format_queries(&self.free_form_queries)),
));
}
params.extend(
self.field_queries
.iter()
.flat_map(CrossrefQueryParam::params),
);
if !self.filter.is_empty() {
reject_unsendable_filters(&self.filter)?;
params.extend(self.filter.params());
}
if !self.elements.is_empty() {
params.push((
Cow::Borrowed("select"),
Cow::Owned(select_value(&self.elements)),
));
}
if !self.facets.is_empty() {
params.extend(self.facets.params());
}
if let Some(sort) = &self.sort {
params.extend(sort.params());
}
if let Some(order) = &self.order {
params.extend(order.params());
}
if let Some(rc) = &self.result_control {
params.extend(rc.params());
}
Ok(format!(
"{}{}",
Component::Works.route()?,
encode::query_string(¶ms)
))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serialize_works_ident() {
let works = Works::doi("10.1037/0003-066X.59.1.29");
assert_eq!("/works/10.1037/0003-066X.59.1.29", &works.route().unwrap())
}
#[test]
fn sample_query_keeps_the_works_route() {
let route = WorksQuery::random(10).route().unwrap();
assert_eq!("/works?sample=10", &route);
let query: WorkListQuery = WorksQuery::random(10).into();
assert_eq!(
"https://api.crossref.org/works?sample=10",
&query.to_url("https://api.crossref.org").unwrap()
);
}
#[test]
fn filter_names_have_no_stray_whitespace() {
let route = WorksQuery::empty()
.filter(WorksFilter::HasClinicalTrialNumber)
.route()
.unwrap();
assert_eq!("/works?filter=has-clinical-trial-number:true", &route);
}
#[test]
fn cursor_with_rows_renders_two_parameters() {
let query = WorksQuery::empty().result_control(WorkResultControl::Cursor {
token: Some("abc".to_string()),
rows: Some(20),
});
assert_eq!("/works?cursor=abc&rows=20", &query.route().unwrap());
}
#[test]
fn new_cursor_renders_the_wildcard_token() {
let query = WorksQuery::empty().new_cursor();
assert_eq!("/works?cursor=*", &query.route().unwrap());
}
#[test]
fn a_query_term_can_no_longer_inject_a_parameter() {
assert_eq!(
"/works?query=R%26D",
&WorksQuery::new("R&D").route().unwrap()
);
}
#[test]
fn filter_and_field_query_values_are_encoded_too() {
let route = WorksQuery::empty()
.field_query(FieldQuery::container_title("Ecology & Evolution"))
.filter(WorksFilter::ContainerTitle("Q&A".to_string()))
.route()
.unwrap();
assert_eq!(
"/works?query.container-title=Ecology%20%26%20Evolution&filter=container-title:Q%26A",
&route
);
}
#[test]
fn an_empty_query_targets_the_bare_works_route() {
assert_eq!("/works", &WorksQuery::empty().route().unwrap());
}
#[test]
fn selected_elements_render_as_one_comma_separated_parameter() {
let route = WorksQuery::empty()
.elements(vec![WorkElement::DOI, WorkElement::Title])
.route()
.unwrap();
assert_eq!("/works?select=DOI,title", &route);
}
#[test]
fn a_select_that_omits_the_doi_still_asks_for_it() {
let route = WorksQuery::empty()
.elements(vec![WorkElement::Title])
.route()
.unwrap();
assert_eq!("/works?select=DOI,title", &route);
}
#[test]
fn a_filter_value_with_a_comma_in_it_is_refused() {
let error = WorksQuery::empty()
.filter(WorksFilter::ContainerTitle("A, B".to_string()))
.route()
.expect_err("crossref cannot read this back");
let crate::Error::UnsendableFilterValue { filter, value } = error else {
panic!("expected an unsendable filter value, got {error:?}");
};
assert_eq!("container-title", filter);
assert_eq!("A, B", value);
}
#[test]
fn rows_offset_renders_two_parameters() {
let query = WorksQuery::empty().result_control(WorkResultControl::Standard(
ResultControl::RowsOffset {
rows: 10,
offset: 20,
},
));
assert_eq!("/works?rows=10&offset=20", &query.route().unwrap());
}
#[test]
fn referenced_by_count_uses_the_crossref_spelling() {
assert_eq!("is-referenced-by-count", Sort::IsReferencedByCount.as_str());
}
}