1#![allow(non_snake_case)]
4
5use super::*;
6
7use std::path::Path;
8
9pub fn list_agreements() -> Result<serde_json::Value, String> {
11 serde_json::to_value(crate::agreements::list_agreements()).map_err(|e| e.to_string())
12}
13
14pub fn agreements_for(did: String) -> Result<serde_json::Value, String> {
16 serde_json::to_value(crate::agreements::agreements_for(&did)).map_err(|e| e.to_string())
17}
18
19pub fn create_agreement(
22 title: String,
23 relationship_did: String,
24 parties: Vec<String>,
25) -> Result<serde_json::Value, String> {
26 let now = mail_now_unix();
27 let a = crate::agreements::Agreement {
28 id: uuid::Uuid::new_v4().to_string(),
29 title,
30 relationship_did,
31 parties: parties.clone(),
32 values_anchors: vec!["urn:qualia:values:udhr".to_string()],
33 undertakings: vec![],
34 consents: parties
35 .into_iter()
36 .map(|did| crate::agreements::PartyConsent {
37 did,
38 consent: crate::agreements::ConsentState::Pending,
39 signature_hex: None,
40 })
41 .collect(),
42 stage: crate::agreements::FormationStage::Draft,
43 jurisdiction: None,
44 intents: Vec::new(),
45 artifact_context: None,
46 created_at: now,
47 updated_at: now,
48 };
49 crate::agreements::upsert_agreement(a.clone())?;
50 serde_json::to_value(a).map_err(|e| e.to_string())
51}
52
53pub fn save_agreement(agreement_json: String) -> Result<serde_json::Value, String> {
55 let a: crate::agreements::Agreement =
56 serde_json::from_str(&agreement_json).map_err(|e| format!("bad agreement: {e}"))?;
57 crate::agreements::upsert_agreement(a)?;
58 list_agreements()
59}
60
61pub fn set_agreement_consent(
63 id: String,
64 did: String,
65 state: String,
66) -> Result<serde_json::Value, String> {
67 let mut all = crate::agreements::list_agreements();
68 let a = all
69 .iter_mut()
70 .find(|a| a.id == id)
71 .ok_or_else(|| format!("unknown agreement '{id}'"))?;
72 let cs = match state.to_lowercase().as_str() {
73 "granted" => crate::agreements::ConsentState::Granted,
74 "withdrawn" => crate::agreements::ConsentState::Withdrawn,
75 _ => crate::agreements::ConsentState::Pending,
76 };
77 crate::agreements::set_consent(a, &did, cs);
78 a.updated_at = mail_now_unix();
79 let updated = a.clone();
80 crate::agreements::upsert_agreement(updated)?;
81 list_agreements()
82}
83
84pub fn get_chat_graph(session_id: String) -> Result<serde_json::Value, String> {
86 let state = crate::state::APP_STATE.get().unwrap();
87 let storage = state.config.lock().unwrap().storage_path.clone();
88 let graph = crate::chat_graph::load_graph(Path::new(&storage), &session_id)
89 .map_err(|e| e.to_string())?;
90 let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
91 .map_err(|e| e.to_string())?;
92 let reactions =
93 crate::chat_ontology::list_reactions(Path::new(&storage), &session_id).unwrap_or_default();
94 let branch_types = crate::chat_ontology::list_branch_types(Path::new(&storage));
95 serde_json::to_value(serde_json::json!({
96 "fragments": graph.fragments,
97 "edges": graph.edges,
98 "messages": session.messages,
99 "reactions": reactions,
100 "branch_types": branch_types,
101 "wordnet": crate::chat_ontology::resolve_wordnet_q42(Path::new(&storage))
102 .map(|p| p.to_string_lossy().to_string()),
103 }))
104 .map_err(|e| e.to_string())
105}
106
107pub fn create_chat_fragment(
109 session_id: String,
110 message_lamport: u64,
111 anchor_start: u32,
112 anchor_end: u32,
113) -> Result<serde_json::Value, String> {
114 let state = crate::state::APP_STATE.get().unwrap();
115 let storage = state.config.lock().unwrap().storage_path.clone();
116 let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
117 .map_err(|e| e.to_string())?;
118 let msg = session
119 .messages
120 .iter()
121 .find(|m| m.lamport == message_lamport)
122 .ok_or_else(|| format!("message {message_lamport} not found"))?;
123 let fragment = crate::chat_graph::create_fragment_from_selection(
124 Path::new(&storage),
125 &session_id,
126 message_lamport,
127 &msg.content,
128 anchor_start,
129 anchor_end,
130 )
131 .map_err(|e| e.to_string())?;
132 serde_json::to_value(fragment).map_err(|e| e.to_string())
133}
134
135pub fn sync_chat_relay(session_id: Option<String>) -> Result<u64, String> {
137 let state = crate::state::APP_STATE.get().unwrap();
138 let storage = state.config.lock().unwrap().storage_path.clone();
139 if let Some(id) = session_id {
140 Ok(crate::chat_relay::sync_session_relay(Path::new(&storage), &id)? as u64)
141 } else {
142 Ok(crate::chat_relay::sync_all_group_sessions()? as u64)
143 }
144}
145
146pub fn start_chat_relay_poller() {
148 crate::chat_relay::start_relay_poller();
149}
150
151pub fn list_chat_branch_types() -> Result<serde_json::Value, String> {
153 let state = crate::state::APP_STATE.get().unwrap();
154 let storage = state.config.lock().unwrap().storage_path.clone();
155 let types = crate::chat_ontology::list_branch_types(Path::new(&storage));
156 serde_json::to_value(types).map_err(|e| e.to_string())
157}
158
159pub fn classify_chat_branch(
161 anchor_text: String,
162 reply_text: String,
163) -> Result<serde_json::Value, String> {
164 let state = crate::state::APP_STATE.get().unwrap();
165 let storage = state.config.lock().unwrap().storage_path.clone();
166 let c = crate::chat_ontology::classify_branch(Path::new(&storage), &anchor_text, &reply_text);
167 serde_json::to_value(c).map_err(|e| e.to_string())
168}
169
170pub fn toggle_chat_reaction(
172 session_id: String,
173 message_lamport: u64,
174 emoji: String,
175) -> Result<serde_json::Value, String> {
176 let state = crate::state::APP_STATE.get().unwrap();
177 let storage = state.config.lock().unwrap().storage_path.clone();
178 let reactions = crate::chat_ontology::toggle_reaction(
179 Path::new(&storage),
180 &session_id,
181 message_lamport,
182 &emoji,
183 )?;
184 serde_json::to_value(reactions).map_err(|e| e.to_string())
185}
186
187pub fn list_chat_reactions(session_id: String) -> Result<serde_json::Value, String> {
189 let state = crate::state::APP_STATE.get().unwrap();
190 let storage = state.config.lock().unwrap().storage_path.clone();
191 let reactions = crate::chat_ontology::list_reactions(Path::new(&storage), &session_id)?;
192 serde_json::to_value(reactions).map_err(|e| e.to_string())
193}
194
195pub fn wordnet_chat_ontology_status() -> Result<serde_json::Value, String> {
197 let state = crate::state::APP_STATE.get().unwrap();
198 let storage = state.config.lock().unwrap().storage_path.clone();
199 let path = crate::chat_ontology::resolve_wordnet_q42(Path::new(&storage));
200 Ok(serde_json::json!({
201 "available": path.is_some(),
202 "q42_path": path.as_ref().map(|p| p.to_string_lossy().to_string()),
203 "lex_path": path.as_ref().and_then(|p| crate::chat_ontology::resolve_wordnet_lex(p).map(|l| l.to_string_lossy().to_string())),
204 }))
205}
206
207pub fn default_chat_file_sharing(session_id: String) -> Result<serde_json::Value, String> {
209 let state = crate::state::APP_STATE.get().unwrap();
210 let storage = state.config.lock().unwrap().storage_path.clone();
211 let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
212 .map_err(|e| e.to_string())?;
213 let sharing = crate::chat_files::default_sharing_for_session(session.meta.session_kind);
214 serde_json::to_value(sharing).map_err(|e| e.to_string())
215}
216
217pub fn attach_chat_file(
219 session_id: String,
220 source_path: String,
221 sharing_json: serde_json::Value,
222) -> Result<serde_json::Value, String> {
223 let state = crate::state::APP_STATE.get().unwrap();
224 let storage = state.config.lock().unwrap().storage_path.clone();
225 let sharing: crate::chat_files::ChatFileSharing =
226 serde_json::from_value(sharing_json).map_err(|e| e.to_string())?;
227 let result = crate::chat_files::attach_chat_file(
228 Path::new(&storage),
229 &session_id,
230 Path::new(&source_path),
231 sharing,
232 )?;
233 serde_json::to_value(result).map_err(|e| e.to_string())
234}
235
236pub fn list_chat_files(session_id: String) -> Result<serde_json::Value, String> {
238 let state = crate::state::APP_STATE.get().unwrap();
239 let storage = state.config.lock().unwrap().storage_path.clone();
240 let files = crate::chat_files::list_chat_files(Path::new(&storage), &session_id, None)?;
241 serde_json::to_value(files).map_err(|e| e.to_string())
242}
243
244pub fn set_chat_file_sharing(
246 session_id: String,
247 file_id: String,
248 sharing_json: serde_json::Value,
249) -> Result<serde_json::Value, String> {
250 let state = crate::state::APP_STATE.get().unwrap();
251 let storage = state.config.lock().unwrap().storage_path.clone();
252 let sharing: crate::chat_files::ChatFileSharing =
253 serde_json::from_value(sharing_json).map_err(|e| e.to_string())?;
254 let updated = crate::chat_files::set_chat_file_sharing(
255 Path::new(&storage),
256 &session_id,
257 &file_id,
258 sharing,
259 )?;
260 serde_json::to_value(updated).map_err(|e| e.to_string())
261}
262
263pub fn get_chat_file_local_path(
265 session_id: String,
266 file_id: String,
267 variant: String,
268) -> Result<String, String> {
269 let state = crate::state::APP_STATE.get().unwrap();
270 let storage = state.config.lock().unwrap().storage_path.clone();
271 let path = crate::chat_files::resolve_chat_file_path(
272 Path::new(&storage),
273 &session_id,
274 &file_id,
275 &variant,
276 None,
277 )?;
278 Ok(path.to_string_lossy().to_string())
279}
280
281pub fn parse_chat_file_preview(source_path: String) -> Result<serde_json::Value, String> {
283 let path = Path::new(&source_path);
284 if !path.is_file() {
285 return Err(format!("File not found: {}", path.display()));
286 }
287 let mut bytes = Vec::new();
288 std::fs::File::open(path)
289 .and_then(|mut f| std::io::Read::read_to_end(&mut f, &mut bytes))
290 .map_err(|e| e.to_string())?;
291 let name = path.file_name().and_then(|s| s.to_str()).unwrap_or("file");
292 let parsed = crate::chat_files::parse_document_bytes(name, &bytes);
293 serde_json::to_value(parsed).map_err(|e| e.to_string())
294}