use super::browse::ResourceFilters;
use crate::cache::Cache;
use crate::cached::{Cached, Keyed};
use crate::channels::{MatchResourcesRequested, MatchSearchRequested};
use crate::client::Links;
use crate::running::Running;
use crate::state_unit::StateUnit;
use crate::transport::Envelope;
use crate::types::{
MatchResourcesRequest, MatchResourcesResponse, MatchSearchRequest, MatchSearchResult,
};
const LIMIT: u16 = 10;
pub(super) type ResourceSearch = (String, ResourceFilters);
pub struct MatchNamespace {
links: Links,
pub(super) searches: Cache<ResourceSearch, MatchResourcesResponse>,
}
impl MatchNamespace {
pub(crate) fn new(links: Links) -> MatchNamespace {
let searches = Cache::new({
let links = links.clone();
move |(search, filters): ResourceSearch| {
let links = links.clone();
async move {
let request = MatchResourcesRequest {
search,
limit: Some(u16::try_from(filters.limit()).unwrap_or(u16::MAX)),
offset: Some(filters.offset()),
archived: filters.archived,
entity_type: filters.entity_type,
};
let answer = links.request::<MatchResourcesRequested>(&request).await?;
Ok(answer.response)
}
}
});
MatchNamespace { links, searches }
}
pub(crate) fn dispose(&self) {
self.searches.dispose();
}
pub fn resources(
&self,
search: &str,
filters: ResourceFilters,
) -> Cached<MatchResourcesResponse> {
Cached::of(Keyed {
cache: self.searches.clone(),
key: (search.to_owned(), filters),
view: |value| value,
scope: None,
})
}
pub fn search(&self, mut request: MatchSearchRequest) -> Running<MatchSearchResult> {
let links = self.links.clone();
request.limit.get_or_insert(LIMIT);
request.use_semantic_scoring.get_or_insert(true);
Running::new(|_| async move { links.request::<MatchSearchRequested>(&request).await })
}
pub fn request_search(&self, input: MatchSearchRequest, correlation_id: &str) {
self.links.signal::<MatchSearchRequested>(
&input,
Envelope {
correlation_id: Some(correlation_id.to_owned()),
scope: None,
},
);
}
}
impl Drop for MatchNamespace {
fn drop(&mut self) {
self.dispose();
}
}