logos-messaging/libchat
1
0
Fork 0
mirror of https://github.com/logos-messaging/libchat.git synced 2026-04-03 01:53:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: further clean for review comments

Browse Source
This commit is contained in:
kaichaosun 2026-03-31 11:40:38 +08:00
parent e5e10c6cb0
commit 961697e2c5
No known key found for this signature in database
GPG Key ID: 223E0F992F4F03BF
2 changed files with 36 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/conversations/src/api.rs
View File

@ -135,7 +135,7 @@ pub fn create_new_private_convo(
// Create conversation // Create conversation
let (convo_id, payloads) = match ctx.0.create_private_convo(&intro, &content) { let (convo_id, payloads) = match ctx.0.create_private_convo(&intro, &content) {
Ok((id, payloads)) => (id, payloads), Ok(v) => v,
Err(_) => { Err(_) => {
*out = NewConvoResult { *out = NewConvoResult {
error_code: ErrorCode::UnknownError as i32, error_code: ErrorCode::UnknownError as i32,

65
core/conversations/src/context.rs
View File

@ -108,16 +108,20 @@ impl<T: ChatStore> Context<T> {
convo_id: ConversationId, convo_id: ConversationId,
content: &[u8], content: &[u8],
) -> Result<Vec<AddressedEnvelope>, ChatError> { ) -> Result<Vec<AddressedEnvelope>, ChatError> {
let mut convo = self.load_convo(convo_id)?; let convo = self.load_convo(convo_id)?;
let payloads = convo.send_message(content)?; match convo {
let remote_id = convo.remote_id(); Conversation::Private(mut convo) => {
convo.save_ratchet_state(&mut self.store)?; let payloads = convo.send_message(content)?;
let remote_id = convo.remote_id();
convo.save_ratchet_state(&mut self.store)?;
Ok(payloads Ok(payloads
.into_iter() .into_iter()
.map(|p| p.into_envelope(remote_id.clone())) .map(|p| p.into_envelope(remote_id.clone()))
.collect()) .collect())
}
}
} }
// Decode bytes and send to protocol for processing. // Decode bytes and send to protocol for processing.
@ -162,12 +166,15 @@ impl<T: ChatStore> Context<T> {
convo_id: ConversationId, convo_id: ConversationId,
enc_payload: EncryptedPayload, enc_payload: EncryptedPayload,
) -> Result<Option<ContentData>, ChatError> { ) -> Result<Option<ContentData>, ChatError> {
let mut convo = self.load_convo(convo_id)?; let convo = self.load_convo(convo_id)?;
let result = convo.handle_frame(enc_payload)?; match convo {
convo.save_ratchet_state(&mut self.store)?; Conversation::Private(mut convo) => {
let result = convo.handle_frame(enc_payload)?;
Ok(result) convo.save_ratchet_state(&mut self.store)?;
Ok(result)
}
}
} }
pub fn create_intro_bundle(&mut self) -> Result<Vec<u8>, ChatError> { pub fn create_intro_bundle(&mut self) -> Result<Vec<u8>, ChatError> {
@ -178,31 +185,29 @@ impl<T: ChatStore> Context<T> {
} }
/// Loads a conversation from DB by constructing it from metadata + ratchet state. /// Loads a conversation from DB by constructing it from metadata + ratchet state.
fn load_convo(&self, convo_id: ConversationId) -> Result<PrivateV1Convo, ChatError> { fn load_convo(&self, convo_id: ConversationId) -> Result<Conversation, ChatError> {
let record = self let record = self
.store .store
.load_conversation(convo_id)? .load_conversation(convo_id)?
.ok_or_else(|| ChatError::NoConvo(convo_id.into()))?; .ok_or_else(|| ChatError::NoConvo(convo_id.into()))?;
match record.kind { match record.kind {
ConversationKind::PrivateV1 => {} ConversationKind::PrivateV1 => {
ConversationKind::Unknown(_) => { let dr_record = self.store.load_ratchet_state(&record.local_convo_id)?;
return Err(ChatError::BadBundleValue(format!( let skipped_keys = self.store.load_skipped_keys(&record.local_convo_id)?;
"unsupported conversation type: {}", let dr_state: RatchetState = restore_ratchet_state(dr_record, skipped_keys);
record.kind.as_str()
))); Ok(Conversation::Private(PrivateV1Convo::new(
record.local_convo_id,
record.remote_convo_id,
dr_state,
)))
} }
ConversationKind::Unknown(_) => Err(ChatError::BadBundleValue(format!(
"unsupported conversation type: {}",
record.kind.as_str()
))),
} }
let dr_record = self.store.load_ratchet_state(&record.local_convo_id)?;
let skipped_keys = self.store.load_skipped_keys(&record.local_convo_id)?;
let dr_state: RatchetState = restore_ratchet_state(dr_record, skipped_keys);
Ok(PrivateV1Convo::new(
record.local_convo_id,
record.remote_convo_id,
dr_state,
))
} }
/// Persists a conversation's metadata and ratchet state to DB. /// Persists a conversation's metadata and ratchet state to DB.