145 lines
3.3 KiB
Rust
145 lines
3.3 KiB
Rust
use serde::{Deserialize, Deserializer, Serialize};
|
|
use std::collections::HashMap;
|
|
|
|
// Hermes types
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct HermesIntent {
|
|
input: String,
|
|
#[serde(rename = "rawInput")]
|
|
input_raw: String,
|
|
intent: HermesIntentClassification,
|
|
#[serde(rename = "sessionId")]
|
|
session_id: String,
|
|
#[serde(rename = "siteId")]
|
|
site_id: String,
|
|
slots: Vec<HermesSlot>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct HermesIntentClassification {
|
|
#[serde(rename = "confidenceScore")]
|
|
confidence: f32,
|
|
#[serde(rename = "intentName")]
|
|
name: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct HermesSlot {
|
|
confidence: f32,
|
|
entity: String,
|
|
#[serde(rename = "slotName")]
|
|
name: String,
|
|
value: HermesSlotValue,
|
|
#[serde(rename = "rawValue")]
|
|
value_raw: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct HermesSlotValue {
|
|
value: String,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
struct HermesResponse {
|
|
#[serde(rename = "sessionId")]
|
|
session_id: String,
|
|
text: Option<String>,
|
|
}
|
|
|
|
// Native types
|
|
|
|
#[derive(Debug)]
|
|
pub struct Intent {
|
|
pub name: String,
|
|
pub input: String,
|
|
pub input_raw: String,
|
|
pub confidence: f32,
|
|
pub session_id: String,
|
|
pub site_id: String,
|
|
pub slots: HashMap<String, Slot>,
|
|
}
|
|
|
|
impl From<HermesIntent> for Intent {
|
|
fn from(hermes_intent: HermesIntent) -> Self {
|
|
let slots = hermes_intent
|
|
.slots
|
|
.into_iter()
|
|
.map(|hermes_slot| (hermes_slot.name.clone(), Slot::from(hermes_slot)))
|
|
.collect();
|
|
|
|
Self {
|
|
name: hermes_intent.intent.name,
|
|
input: hermes_intent.input,
|
|
input_raw: hermes_intent.input_raw,
|
|
confidence: hermes_intent.intent.confidence,
|
|
session_id: hermes_intent.session_id,
|
|
site_id: hermes_intent.site_id,
|
|
slots,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Slot {
|
|
pub confidence: f32,
|
|
pub entity: String,
|
|
pub value: String,
|
|
pub value_raw: String,
|
|
}
|
|
|
|
impl From<HermesSlot> for Slot {
|
|
fn from(slot_data: HermesSlot) -> Self {
|
|
Self {
|
|
confidence: slot_data.confidence,
|
|
entity: slot_data.entity,
|
|
value: slot_data.value.value,
|
|
value_raw: slot_data.value_raw,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Intent {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
let intent_data = HermesIntent::deserialize(deserializer)?;
|
|
Ok(Intent::from(intent_data))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Response {
|
|
pub session_id: String,
|
|
pub text: Option<String>,
|
|
}
|
|
|
|
impl Response {
|
|
pub fn new(session_id: String) -> Self {
|
|
let text = None;
|
|
Self { session_id, text }
|
|
}
|
|
|
|
pub fn with_text(mut self, text: impl Into<String>) -> Self {
|
|
self.text = Some(text.into());
|
|
self
|
|
}
|
|
}
|
|
|
|
impl From<Response> for Vec<u8> {
|
|
fn from(response: Response) -> Vec<u8> {
|
|
let hermes_response = HermesResponse::from(response);
|
|
serde_json::to_vec(&hermes_response).unwrap()
|
|
}
|
|
}
|
|
|
|
impl From<Response> for HermesResponse {
|
|
fn from(response: Response) -> Self {
|
|
HermesResponse {
|
|
session_id: response.session_id,
|
|
text: response.text,
|
|
}
|
|
}
|
|
}
|