1use chrono::{DateTime, Utc};
2use minco_interaction::{
3 AttachmentKind, AttachmentMetadata, SupportResourceReference, TransitionRule,
4 transition_allowed,
5};
6use serde::{Deserialize, Serialize};
7use std::{collections::BTreeSet, fmt, str::FromStr};
8use uuid::Uuid;
9
10macro_rules! ticket_id {
11 ($name:ident) => {
12 #[derive(
13 Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
14 )]
15 #[serde(transparent)]
16 pub struct $name(pub Uuid);
17
18 impl $name {
19 #[must_use]
20 pub fn new() -> Self {
21 Self(Uuid::now_v7())
22 }
23 }
24
25 impl Default for $name {
26 fn default() -> Self {
27 Self::new()
28 }
29 }
30
31 impl fmt::Display for $name {
32 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
33 self.0.fmt(formatter)
34 }
35 }
36
37 impl FromStr for $name {
38 type Err = uuid::Error;
39
40 fn from_str(value: &str) -> Result<Self, Self::Err> {
41 value.parse().map(Self)
42 }
43 }
44 };
45}
46
47ticket_id!(TicketId);
48ticket_id!(TicketMessageId);
49ticket_id!(TicketAttachmentId);
50
51#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
52#[serde(rename_all = "snake_case")]
53pub enum TicketPriority {
54 Low,
55 #[default]
56 Normal,
57 High,
58 Urgent,
59}
60
61#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
62#[serde(rename_all = "snake_case")]
63pub enum TicketChannel {
64 Portal,
65 Email,
66 Api,
67 Voice,
68 Internal,
69 Other,
70}
71
72#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
73#[serde(rename_all = "snake_case")]
74pub enum TicketStatus {
75 New,
76 Open,
77 PendingRequester,
78 PendingInternal,
79 OnHold,
80 Resolved,
81 Closed,
82}
83
84#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
85#[serde(rename_all = "snake_case")]
86pub enum TicketClockState {
87 Open,
88 Paused,
89 Stopped,
90}
91
92impl TicketStatus {
93 #[must_use]
94 pub const fn clock_state(self) -> TicketClockState {
95 match self {
96 Self::New | Self::Open | Self::PendingInternal => TicketClockState::Open,
97 Self::PendingRequester | Self::OnHold => TicketClockState::Paused,
98 Self::Resolved | Self::Closed => TicketClockState::Stopped,
99 }
100 }
101
102 #[must_use]
103 pub fn can_transition_to(self, target: Self) -> bool {
104 use TicketStatus::{
105 Closed, New, OnHold, Open, PendingInternal, PendingRequester, Resolved,
106 };
107 const RULES: &[TransitionRule<TicketStatus>] = &[
108 TransitionRule::new(New, Open),
109 TransitionRule::new(New, PendingRequester),
110 TransitionRule::new(New, PendingInternal),
111 TransitionRule::new(New, OnHold),
112 TransitionRule::new(New, Resolved),
113 TransitionRule::new(Open, PendingRequester),
114 TransitionRule::new(Open, PendingInternal),
115 TransitionRule::new(Open, OnHold),
116 TransitionRule::new(Open, Resolved),
117 TransitionRule::new(PendingRequester, Open),
118 TransitionRule::new(PendingRequester, PendingInternal),
119 TransitionRule::new(PendingRequester, OnHold),
120 TransitionRule::new(PendingRequester, Resolved),
121 TransitionRule::new(PendingInternal, Open),
122 TransitionRule::new(PendingInternal, PendingRequester),
123 TransitionRule::new(PendingInternal, OnHold),
124 TransitionRule::new(PendingInternal, Resolved),
125 TransitionRule::new(OnHold, Open),
126 TransitionRule::new(OnHold, PendingRequester),
127 TransitionRule::new(OnHold, PendingInternal),
128 TransitionRule::new(OnHold, Resolved),
129 TransitionRule::new(Resolved, Open),
130 TransitionRule::new(Resolved, Closed),
131 TransitionRule::new(Closed, Open),
132 ];
133 transition_allowed(&self, &target, RULES)
134 }
135}
136
137#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
138#[serde(rename_all = "snake_case")]
139pub enum TicketMessageKind {
140 PublicReply,
141 InternalNote,
142 SystemEvent,
143 VoiceTranscript,
144}
145
146#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
147#[serde(rename_all = "snake_case")]
148pub enum TicketMessageDirection {
149 Inbound,
150 Outbound,
151 Internal,
152 System,
153}
154
155#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
156#[serde(deny_unknown_fields)]
157pub struct TicketRequester {
158 pub subject: String,
159 #[serde(default, skip_serializing_if = "Option::is_none")]
160 pub display_name: Option<String>,
161 #[serde(default, skip_serializing_if = "Option::is_none")]
162 pub email: Option<String>,
163}
164
165#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
166#[serde(deny_unknown_fields)]
167pub struct TicketSourceReference {
168 pub provider: String,
169 pub scope: String,
170 pub external_id: String,
171}
172
173#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
174pub struct TicketMessage {
175 pub id: TicketMessageId,
176 pub kind: TicketMessageKind,
177 pub direction: TicketMessageDirection,
178 #[serde(default, skip_serializing_if = "Option::is_none")]
179 pub author_subject: Option<String>,
180 pub body: String,
181 pub created_at: DateTime<Utc>,
182}
183
184#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
185pub struct TicketAttachment {
186 pub id: TicketAttachmentId,
187 pub kind: AttachmentKind,
188 pub object_key: String,
189 pub file_name: String,
190 pub content_type: String,
191 pub size_bytes: u64,
192 pub sha256: String,
193 pub created_at: DateTime<Utc>,
194}
195
196impl From<AttachmentMetadata> for TicketAttachment {
197 fn from(value: AttachmentMetadata) -> Self {
198 Self {
199 id: TicketAttachmentId(value.id),
200 kind: value.kind,
201 object_key: value.object_key.as_str().to_owned(),
202 file_name: value.file_name,
203 content_type: value.content_type,
204 size_bytes: value.size_bytes,
205 sha256: value.sha256,
206 created_at: value.created_at,
207 }
208 }
209}
210
211#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
212pub struct Ticket {
213 pub id: TicketId,
214 pub project_id: String,
215 pub display_reference: String,
216 pub subject: String,
217 pub description: String,
218 pub requester: TicketRequester,
219 pub channel: TicketChannel,
220 pub priority: TicketPriority,
221 pub status: TicketStatus,
222 pub clock_state: TicketClockState,
223 #[serde(default, skip_serializing_if = "Option::is_none")]
224 pub queue_id: Option<String>,
225 #[serde(default, skip_serializing_if = "Option::is_none")]
226 pub assignee_subject: Option<String>,
227 #[serde(default)]
228 pub followers: BTreeSet<String>,
229 #[serde(default, skip_serializing_if = "Option::is_none")]
230 pub category: Option<String>,
231 #[serde(default)]
232 pub tags: BTreeSet<String>,
233 #[serde(default)]
234 pub source_references: Vec<TicketSourceReference>,
235 #[serde(default)]
236 pub resource_references: Vec<SupportResourceReference>,
237 #[serde(default)]
238 pub messages: Vec<TicketMessage>,
239 #[serde(default)]
240 pub attachments: Vec<TicketAttachment>,
241 pub created_at: DateTime<Utc>,
242 pub updated_at: DateTime<Utc>,
243 #[serde(default, skip_serializing_if = "Option::is_none")]
244 pub first_public_response_at: Option<DateTime<Utc>>,
245 #[serde(default, skip_serializing_if = "Option::is_none")]
246 pub waiting_since: Option<DateTime<Utc>>,
247 #[serde(default, skip_serializing_if = "Option::is_none")]
248 pub resolved_at: Option<DateTime<Utc>>,
249 #[serde(default, skip_serializing_if = "Option::is_none")]
250 pub closed_at: Option<DateTime<Utc>>,
251 #[serde(default, skip_serializing_if = "Option::is_none")]
252 pub resolution: Option<String>,
253 #[serde(default, skip_serializing_if = "Option::is_none")]
254 pub close_reason: Option<String>,
255 pub revision: u64,
256}
257
258#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
259pub struct CreateTicketInput {
260 pub project_id: String,
261 pub subject: String,
262 pub description: String,
263 pub requester: TicketRequester,
264 pub channel: TicketChannel,
265 #[serde(default)]
266 pub priority: TicketPriority,
267 #[serde(default)]
268 pub resource_references: Vec<SupportResourceReference>,
269}
270
271impl Ticket {
272 pub fn create(
273 input: CreateTicketInput,
274 display_reference: impl Into<String>,
275 now: DateTime<Utc>,
276 ) -> Result<Self, TicketValidationError> {
277 validate_text("project_id", &input.project_id, 100)?;
278 validate_text("subject", &input.subject, 300)?;
279 validate_text("description", &input.description, 20_000)?;
280 validate_text("requester.subject", &input.requester.subject, 300)?;
281 validate_optional_text(
282 "requester.display_name",
283 input.requester.display_name.as_deref(),
284 300,
285 )?;
286 validate_optional_text("requester.email", input.requester.email.as_deref(), 320)?;
287 let display_reference = display_reference.into();
288 validate_text("display_reference", &display_reference, 100)?;
289 if input.resource_references.len() > 32 {
290 return Err(TicketValidationError::InvalidField {
291 field: "resource_references",
292 detail: "must not contain more than 32 values".into(),
293 });
294 }
295 let id = TicketId::new();
296 let mut ticket = Self {
297 id,
298 project_id: input.project_id,
299 display_reference,
300 subject: input.subject,
301 description: input.description.clone(),
302 requester: input.requester,
303 channel: input.channel,
304 priority: input.priority,
305 status: TicketStatus::New,
306 clock_state: TicketClockState::Open,
307 queue_id: None,
308 assignee_subject: None,
309 followers: BTreeSet::new(),
310 category: None,
311 tags: BTreeSet::new(),
312 source_references: Vec::new(),
313 resource_references: input.resource_references,
314 messages: Vec::new(),
315 attachments: Vec::new(),
316 created_at: now,
317 updated_at: now,
318 first_public_response_at: None,
319 waiting_since: None,
320 resolved_at: None,
321 closed_at: None,
322 resolution: None,
323 close_reason: None,
324 revision: 0,
325 };
326 ticket.messages.push(TicketMessage {
327 id: TicketMessageId::new(),
328 kind: TicketMessageKind::PublicReply,
329 direction: TicketMessageDirection::Inbound,
330 author_subject: Some(ticket.requester.subject.clone()),
331 body: input.description,
332 created_at: now,
333 });
334 Ok(ticket)
335 }
336
337 pub fn reply_as_requester(
338 &mut self,
339 body: impl Into<String>,
340 now: DateTime<Utc>,
341 ) -> Result<(), TicketValidationError> {
342 let body = body.into();
343 validate_text("body", &body, 20_000)?;
344 if matches!(
345 self.status,
346 TicketStatus::PendingRequester | TicketStatus::Resolved | TicketStatus::Closed
347 ) {
348 self.apply_status(TicketStatus::Open, None, None, now)?;
349 }
350 self.messages.push(TicketMessage {
351 id: TicketMessageId::new(),
352 kind: TicketMessageKind::PublicReply,
353 direction: TicketMessageDirection::Inbound,
354 author_subject: Some(self.requester.subject.clone()),
355 body,
356 created_at: now,
357 });
358 self.touch(now);
359 Ok(())
360 }
361
362 pub fn reply_as_agent(
363 &mut self,
364 actor_subject: impl Into<String>,
365 body: impl Into<String>,
366 now: DateTime<Utc>,
367 ) -> Result<(), TicketValidationError> {
368 let actor_subject = actor_subject.into();
369 let body = body.into();
370 validate_text("actor_subject", &actor_subject, 300)?;
371 validate_text("body", &body, 20_000)?;
372 self.first_public_response_at.get_or_insert(now);
373 if self.status == TicketStatus::New {
374 self.apply_status(TicketStatus::Open, None, None, now)?;
375 }
376 self.messages.push(TicketMessage {
377 id: TicketMessageId::new(),
378 kind: TicketMessageKind::PublicReply,
379 direction: TicketMessageDirection::Outbound,
380 author_subject: Some(actor_subject),
381 body,
382 created_at: now,
383 });
384 self.touch(now);
385 Ok(())
386 }
387
388 pub fn add_internal_note(
389 &mut self,
390 actor_subject: impl Into<String>,
391 body: impl Into<String>,
392 now: DateTime<Utc>,
393 ) -> Result<(), TicketValidationError> {
394 let actor_subject = actor_subject.into();
395 let body = body.into();
396 validate_text("actor_subject", &actor_subject, 300)?;
397 validate_text("body", &body, 20_000)?;
398 self.messages.push(TicketMessage {
399 id: TicketMessageId::new(),
400 kind: TicketMessageKind::InternalNote,
401 direction: TicketMessageDirection::Internal,
402 author_subject: Some(actor_subject),
403 body,
404 created_at: now,
405 });
406 self.touch(now);
407 Ok(())
408 }
409
410 pub fn change_status(
411 &mut self,
412 target: TicketStatus,
413 resolution: Option<String>,
414 close_reason: Option<String>,
415 now: DateTime<Utc>,
416 ) -> Result<(), TicketValidationError> {
417 self.apply_status(target, resolution, close_reason, now)?;
418 self.messages.push(TicketMessage {
419 id: TicketMessageId::new(),
420 kind: TicketMessageKind::SystemEvent,
421 direction: TicketMessageDirection::System,
422 author_subject: None,
423 body: format!("status changed to {target:?}").to_ascii_lowercase(),
424 created_at: now,
425 });
426 self.touch(now);
427 Ok(())
428 }
429
430 fn apply_status(
431 &mut self,
432 target: TicketStatus,
433 resolution: Option<String>,
434 close_reason: Option<String>,
435 now: DateTime<Utc>,
436 ) -> Result<(), TicketValidationError> {
437 if !self.status.can_transition_to(target) {
438 return Err(TicketValidationError::InvalidTransition {
439 current: self.status,
440 target,
441 });
442 }
443 if let Some(value) = resolution.as_deref() {
444 validate_text("resolution", value, 20_000)?;
445 }
446 if let Some(value) = close_reason.as_deref() {
447 validate_text("close_reason", value, 500)?;
448 }
449 if target == TicketStatus::Resolved
450 && resolution.as_ref().or(self.resolution.as_ref()).is_none()
451 {
452 return Err(TicketValidationError::ResolutionRequired);
453 }
454 if target == TicketStatus::Closed {
455 if resolution.as_ref().or(self.resolution.as_ref()).is_none() {
456 return Err(TicketValidationError::ResolutionRequired);
457 }
458 if close_reason.is_none() {
459 return Err(TicketValidationError::CloseReasonRequired);
460 }
461 }
462 self.status = target;
463 self.clock_state = target.clock_state();
464 self.waiting_since = matches!(
465 target,
466 TicketStatus::PendingRequester | TicketStatus::OnHold
467 )
468 .then_some(now);
469 if target == TicketStatus::Resolved {
470 self.resolved_at = Some(now);
471 self.resolution = resolution.clone().or_else(|| self.resolution.clone());
472 } else if !matches!(target, TicketStatus::Closed) {
473 self.resolved_at = None;
474 if target == TicketStatus::Open {
475 self.closed_at = None;
476 self.close_reason = None;
477 }
478 }
479 if target == TicketStatus::Closed {
480 self.closed_at = Some(now);
481 self.resolution = resolution.or_else(|| self.resolution.clone());
482 self.close_reason = close_reason;
483 }
484 Ok(())
485 }
486
487 pub fn assign(
488 &mut self,
489 subject: Option<String>,
490 now: DateTime<Utc>,
491 ) -> Result<(), TicketValidationError> {
492 validate_optional_text("assignee_subject", subject.as_deref(), 300)?;
493 self.assignee_subject = subject;
494 self.touch(now);
495 Ok(())
496 }
497
498 pub fn transfer_queue(
499 &mut self,
500 queue_id: String,
501 now: DateTime<Utc>,
502 ) -> Result<(), TicketValidationError> {
503 validate_text("queue_id", &queue_id, 200)?;
504 self.queue_id = Some(queue_id);
505 self.touch(now);
506 Ok(())
507 }
508
509 pub const fn change_priority(&mut self, priority: TicketPriority, now: DateTime<Utc>) {
510 self.priority = priority;
511 self.touch(now);
512 }
513
514 pub fn add_attachment(&mut self, attachment: TicketAttachment, now: DateTime<Utc>) {
515 self.attachments.push(attachment);
516 self.touch(now);
517 }
518
519 const fn touch(&mut self, now: DateTime<Utc>) {
520 self.updated_at = now;
521 self.revision = self.revision.saturating_add(1);
522 }
523
524 #[must_use]
525 pub fn requester_projection(&self) -> RequesterTicket {
526 RequesterTicket {
527 id: self.id,
528 project_id: self.project_id.clone(),
529 display_reference: self.display_reference.clone(),
530 subject: self.subject.clone(),
531 description: self.description.clone(),
532 requester: self.requester.clone(),
533 channel: self.channel.clone(),
534 priority: self.priority,
535 status: self.status,
536 messages: self
537 .messages
538 .iter()
539 .filter(|message| message.kind != TicketMessageKind::InternalNote)
540 .cloned()
541 .collect(),
542 attachments: self
543 .attachments
544 .iter()
545 .map(RequesterTicketAttachment::from)
546 .collect(),
547 created_at: self.created_at,
548 updated_at: self.updated_at,
549 revision: self.revision,
550 }
551 }
552
553 #[must_use]
554 pub fn export_ai_context(&self) -> TicketAiContext {
555 TicketAiContext {
556 schema_version: 1,
557 project_id: self.project_id.clone(),
558 ticket_id: self.id,
559 display_reference: self.display_reference.clone(),
560 subject: self.subject.clone(),
561 description: self.description.clone(),
562 status: self.status,
563 priority: self.priority,
564 resource_references: self.resource_references.clone(),
565 messages: self.messages.clone(),
566 }
567 }
568}
569
570#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
571pub struct RequesterTicketAttachment {
572 pub id: TicketAttachmentId,
573 pub kind: AttachmentKind,
574 pub file_name: String,
575 pub content_type: String,
576 pub size_bytes: u64,
577 pub created_at: DateTime<Utc>,
578}
579
580impl From<&TicketAttachment> for RequesterTicketAttachment {
581 fn from(value: &TicketAttachment) -> Self {
582 Self {
583 id: value.id,
584 kind: value.kind,
585 file_name: value.file_name.clone(),
586 content_type: value.content_type.clone(),
587 size_bytes: value.size_bytes,
588 created_at: value.created_at,
589 }
590 }
591}
592
593#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
594pub struct RequesterTicket {
595 pub id: TicketId,
596 pub project_id: String,
597 pub display_reference: String,
598 pub subject: String,
599 pub description: String,
600 pub requester: TicketRequester,
601 pub channel: TicketChannel,
602 pub priority: TicketPriority,
603 pub status: TicketStatus,
604 pub messages: Vec<TicketMessage>,
605 pub attachments: Vec<RequesterTicketAttachment>,
606 pub created_at: DateTime<Utc>,
607 pub updated_at: DateTime<Utc>,
608 pub revision: u64,
609}
610
611#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
612pub struct TicketAiContext {
613 pub schema_version: u32,
614 pub project_id: String,
615 pub ticket_id: TicketId,
616 pub display_reference: String,
617 pub subject: String,
618 pub description: String,
619 pub status: TicketStatus,
620 pub priority: TicketPriority,
621 pub resource_references: Vec<SupportResourceReference>,
622 pub messages: Vec<TicketMessage>,
623}
624
625#[derive(Debug, Clone, PartialEq, Eq)]
626pub struct TicketFromHandoffInput {
627 pub subject: String,
628 pub description: String,
629 pub channel: TicketChannel,
630 pub priority: TicketPriority,
631}
632
633#[derive(Debug, thiserror::Error, PartialEq, Eq)]
634pub enum TicketValidationError {
635 #[error("invalid {field}: {detail}")]
636 InvalidField { field: &'static str, detail: String },
637 #[error("ticket cannot transition from {current:?} to {target:?}")]
638 InvalidTransition {
639 current: TicketStatus,
640 target: TicketStatus,
641 },
642 #[error("a resolution is required")]
643 ResolutionRequired,
644 #[error("a close reason is required")]
645 CloseReasonRequired,
646}
647
648fn validate_text(
649 field: &'static str,
650 value: &str,
651 maximum: usize,
652) -> Result<(), TicketValidationError> {
653 if value.trim().is_empty()
654 || value.chars().count() > maximum
655 || value.chars().any(char::is_control)
656 {
657 Err(TicketValidationError::InvalidField {
658 field,
659 detail: format!("must contain 1-{maximum} visible characters"),
660 })
661 } else {
662 Ok(())
663 }
664}
665
666fn validate_optional_text(
667 field: &'static str,
668 value: Option<&str>,
669 maximum: usize,
670) -> Result<(), TicketValidationError> {
671 value.map_or(Ok(()), |value| validate_text(field, value, maximum))
672}
673
674#[cfg(test)]
675mod tests {
676 use super::*;
677 use chrono::TimeDelta;
678
679 fn ticket() -> Ticket {
680 Ticket::create(
681 CreateTicketInput {
682 project_id: "project-a".into(),
683 subject: "Need help".into(),
684 description: "It broke".into(),
685 requester: TicketRequester {
686 subject: "user-1".into(),
687 display_name: None,
688 email: None,
689 },
690 channel: TicketChannel::Portal,
691 priority: TicketPriority::Normal,
692 resource_references: Vec::new(),
693 },
694 "SUP-1",
695 Utc::now(),
696 )
697 .unwrap()
698 }
699
700 #[test]
701 fn clock_mapping_keeps_pending_internal_open() {
702 assert_eq!(
703 TicketStatus::PendingInternal.clock_state(),
704 TicketClockState::Open
705 );
706 assert_eq!(
707 TicketStatus::PendingRequester.clock_state(),
708 TicketClockState::Paused
709 );
710 assert_eq!(
711 TicketStatus::Closed.clock_state(),
712 TicketClockState::Stopped
713 );
714 }
715
716 #[test]
717 fn requester_reply_reopens_and_internal_note_stays_private() {
718 let mut ticket = ticket();
719 let now = ticket.created_at + TimeDelta::minutes(1);
720 ticket
721 .change_status(TicketStatus::PendingRequester, None, None, now)
722 .unwrap();
723 ticket.add_internal_note("agent", "private", now).unwrap();
724 assert_eq!(ticket.status, TicketStatus::PendingRequester);
725 ticket.reply_as_requester("more detail", now).unwrap();
726 assert_eq!(ticket.status, TicketStatus::Open);
727 assert!(
728 !serde_json::to_string(&ticket.requester_projection())
729 .unwrap()
730 .contains("private")
731 );
732 }
733
734 #[test]
735 fn first_response_and_resolution_timestamps_are_stable() {
736 let mut ticket = ticket();
737 let first = ticket.created_at + TimeDelta::minutes(1);
738 ticket.reply_as_agent("agent", "hello", first).unwrap();
739 ticket
740 .reply_as_agent("agent", "again", first + TimeDelta::minutes(1))
741 .unwrap();
742 assert_eq!(ticket.first_public_response_at, Some(first));
743 let resolved = first + TimeDelta::minutes(2);
744 ticket
745 .change_status(TicketStatus::Resolved, Some("fixed".into()), None, resolved)
746 .unwrap();
747 assert_eq!(ticket.resolved_at, Some(resolved));
748 assert_eq!(
749 ticket.change_status(TicketStatus::Closed, None, None, resolved),
750 Err(TicketValidationError::CloseReasonRequired)
751 );
752 ticket
753 .change_status(
754 TicketStatus::Closed,
755 None,
756 Some("confirmed".into()),
757 resolved,
758 )
759 .unwrap();
760 ticket.reply_as_requester("regressed", resolved).unwrap();
761 assert_eq!(ticket.status, TicketStatus::Open);
762 assert!(ticket.closed_at.is_none());
763 }
764}