use super::follow::{Delegation, Following, follow};
use crate::channels::{
MarkArchive, MarkCreateRequest as CreateRequest, MarkDelete, MarkDeleteError, MarkRequested,
MarkSubmit, MarkUnarchive, MarkUpdateEntityTypes,
};
use crate::client::Links;
use crate::errors::SemiontError;
use crate::transport::Envelope;
use crate::types::{AnnotationId, ResourceId};
use crate::types::{
AnnotationSelector, CreateAnnotationRequest, MarkArchiveCommand, MarkCreateOkResponse,
MarkCreateRequest, MarkDeleteCommand, MarkJobCompleteCommand, MarkJobCreateCommand,
MarkJobParams, MarkRequestedEvent, MarkSubmitEvent, MarkUnarchiveCommand,
MarkUpdateEntityTypesCommand, Motivation, ResourceErrorEvent,
};
pub struct MarkNamespace {
links: Links,
}
impl MarkNamespace {
pub(crate) fn new(links: Links) -> MarkNamespace {
MarkNamespace { links }
}
pub async fn annotation(
&self,
input: CreateAnnotationRequest,
) -> Result<MarkCreateOkResponse, SemiontError> {
let created = self
.links
.request::<CreateRequest>(&MarkCreateRequest {
resource_id: input.target.source.clone(),
request: input,
})
.await?;
Ok(created.response)
}
pub async fn delete(
&self,
resource_id: &ResourceId,
annotation_id: &AnnotationId,
) -> Result<(), SemiontError> {
self.links
.request::<MarkDelete>(&MarkDeleteCommand {
_user_id: None,
annotation_id: annotation_id.clone(),
resource_id: Some(resource_id.clone()),
})
.await?;
Ok(())
}
pub async fn archive(&self, resource_id: &ResourceId) -> Result<(), SemiontError> {
self.links
.request::<MarkArchive>(&MarkArchiveCommand {
_user_id: None,
resource_id: resource_id.clone(),
storage_uri: None,
keep_file: None,
})
.await?;
Ok(())
}
pub async fn unarchive(&self, resource_id: &ResourceId) -> Result<(), SemiontError> {
self.links
.request::<MarkUnarchive>(&MarkUnarchiveCommand {
_user_id: None,
resource_id: resource_id.clone(),
storage_uri: None,
})
.await?;
Ok(())
}
pub async fn update_entity_types(
&self,
resource_id: &ResourceId,
current: Vec<String>,
updated: Vec<String>,
) -> Result<(), SemiontError> {
self.links
.request::<MarkUpdateEntityTypes>(&MarkUpdateEntityTypesCommand {
resource_id: resource_id.clone(),
_user_id: None,
current_entity_types: current,
updated_entity_types: updated,
})
.await?;
Ok(())
}
pub fn delegate(
&self,
resource_id: &ResourceId,
params: impl Into<MarkJobParams>,
) -> Delegation<MarkJobCompleteCommand> {
follow(
self.links.clone(),
Following {
create: MarkJobCreateCommand::new(resource_id.clone(), params.into()).into(),
resource_id: resource_id.clone(),
stall: None,
},
)
}
pub fn request(
&self,
source: &ResourceId,
selector: AnnotationSelector,
motivation: Motivation,
) {
self.links.signal::<MarkRequested>(
&MarkRequestedEvent {
source: source.clone(),
selector,
motivation,
},
Envelope::default(),
);
}
pub fn submit(&self, input: MarkSubmitEvent) {
self.links.signal::<MarkSubmit>(&input, Envelope::default());
}
pub fn report_delete_error(&self, input: ResourceErrorEvent) {
self.links
.signal::<MarkDeleteError>(&input, Envelope::default());
}
}