Struct MessageModel 

pub struct MessageModel {
    pub sequence: i64,
    pub id: String,
    pub enqueued_at: OffsetDateTime,
    pub delivery_count: usize,
    pub state: MessageState,
    pub body: BodyData,
}

Unified message model representing Azure Service Bus messages.

This struct provides a clean, consistent representation of Service Bus messages that is optimized for terminal UI display and manipulation. It handles the complexities of Azure’s message format while providing type safety and serialization support.

Fields

• sequence - Unique sequence number assigned by Azure Service Bus
• id - Message identifier (typically a GUID)
• enqueued_at - Timestamp when the message was enqueued
• delivery_count - Number of delivery attempts for this message
• state - Current state of the message in the queue
• body - Message content (JSON or raw text)

Examples

Creating a New Message Model

use quetty_server::model::{MessageModel, MessageState, BodyData};
use azure_core::time::OffsetDateTime;

let message = MessageModel::new(
    12345,
    "550e8400-e29b-41d4-a716-446655440000".to_string(),
    OffsetDateTime::now_utc(),
    0,
    MessageState::Active,
    BodyData::RawString("Hello, Service Bus!".to_string())
);

assert_eq!(message.sequence, 12345);
assert_eq!(message.delivery_count, 0);
assert_eq!(message.state, MessageState::Active);

Converting from Azure Messages

use quetty_server::model::MessageModel;
use azservicebus::prelude::ServiceBusPeekedMessage;
use std::convert::TryFrom;

// Convert single message with error handling
let azure_message: ServiceBusPeekedMessage = get_azure_message();
match MessageModel::try_from(azure_message) {
    Ok(message) => {
        println!("Converted message: {} (sequence: {})",
                 message.id, message.sequence);
    }
    Err(e) => eprintln!("Conversion failed: {:?}", e),
}

Batch Conversion

use quetty_server::model::MessageModel;
use azservicebus::prelude::ServiceBusPeekedMessage;

let azure_messages: Vec<ServiceBusPeekedMessage> = get_azure_messages();
let valid_messages = MessageModel::try_convert_messages_collect(azure_messages);

println!("Successfully converted {} messages", valid_messages.len());
for message in valid_messages {
    println!("  - {} ({})", message.id, message.state);
}

JSON Serialization

use quetty_server::model::{MessageModel, MessageState, BodyData};
use serde_json::json;

let message = MessageModel {
    sequence: 12345,
    id: "test-message".to_string(),
    enqueued_at: OffsetDateTime::now_utc(),
    delivery_count: 0,
    state: MessageState::Active,
    body: BodyData::ValidJson(json!({"type": "test", "data": "value"})),
};

// Serialize to JSON for export or API responses
let json_string = serde_json::to_string_pretty(&message)?;
println!("Exported message:\n{}", json_string);

Thread Safety

MessageModel implements Clone, Send, and Sync, making it safe to share across threads and async tasks. This is essential for the concurrent nature of the terminal UI application.

Performance Notes

• Cloning is relatively inexpensive due to reference counting for large data
• Serialization is optimized for both human-readable and compact formats
• Memory usage is minimized through efficient string storage

Fields

sequence: i64

Unique sequence number assigned by Azure Service Bus for message ordering

id: String

Message identifier, typically a GUID string

enqueued_at: OffsetDateTime

UTC timestamp when the message was originally enqueued

delivery_count: usize

Number of times delivery has been attempted for this message

state: MessageState

Current state of the message within the Service Bus queue

body: BodyData

Message content, either parsed JSON or raw text

Implementations

impl MessageModel

pub fn new( sequence: i64, id: String, enqueued_at: OffsetDateTime, delivery_count: usize, state: MessageState, body: BodyData, ) -> Self

pub fn try_convert_messages_collect( messages: Vec<ServiceBusPeekedMessage>, ) -> Vec<MessageModel>

Trait Implementations

impl Clone for MessageModel

fn clone(&self) -> MessageModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MessageModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for MessageModel

fn eq(&self, other: &MessageModel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MessageModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<ServiceBusPeekedMessage> for MessageModel

type Error = MessageModelError

The type returned in the event of a conversion error.

fn try_from(msg: ServiceBusPeekedMessage) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for MessageModel