Struct ProfessionalJudgment 

pub struct ProfessionalJudgment {

    pub judgment_id: Uuid,
    pub judgment_ref: String,
    pub engagement_id: Uuid,
    pub judgment_type: JudgmentType,
    pub subject: String,
    pub applicable_standards: Vec<String>,
    pub issue_description: String,
    pub information_considered: Vec<InformationItem>,
    pub alternatives_evaluated: Vec<AlternativeEvaluation>,
    pub skepticism_applied: SkepticismDocumentation,
    pub conclusion: String,
    pub rationale: String,
    pub residual_risk: String,
    pub impact_on_audit: Option<String>,
    pub consultation_required: bool,
    pub consultation: Option<ConsultationRecord>,
    pub preparer_id: String,
    pub preparer_name: String,
    pub preparer_date: NaiveDate,
    pub reviewer_id: Option<String>,
    pub reviewer_name: Option<String>,
    pub reviewer_date: Option<NaiveDate>,
    pub partner_concurrence_required: bool,
    pub partner_concurrence_id: Option<String>,
    pub partner_concurrence_date: Option<NaiveDate>,
    pub workpaper_refs: Vec<Uuid>,
    pub evidence_refs: Vec<Uuid>,
    pub status: JudgmentStatus,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

Professional judgment documentation.

Fields

judgment_id: Uuid

Unique judgment ID

judgment_ref: String

External reference

engagement_id: Uuid

Engagement ID

judgment_type: JudgmentType

Type of judgment

subject: String

Subject matter of the judgment

applicable_standards: Vec<String>

Applicable auditing standards

issue_description: String

Issue or matter requiring judgment

information_considered: Vec<InformationItem>

Information and factors considered

alternatives_evaluated: Vec<AlternativeEvaluation>

Alternatives evaluated

skepticism_applied: SkepticismDocumentation

Professional skepticism applied

conclusion: String

Conclusion reached

rationale: String

Rationale for conclusion

residual_risk: String

Residual risk or uncertainty

impact_on_audit: Option<String>

Impact on audit approach

consultation_required: bool

Was consultation required?

consultation: Option<ConsultationRecord>

Consultation details

preparer_id: String

Preparer user ID

preparer_name: String

Preparer name

preparer_date: NaiveDate

Date prepared

reviewer_id: Option<String>

Reviewer ID

reviewer_name: Option<String>

Reviewer name

reviewer_date: Option<NaiveDate>

Review date

partner_concurrence_required: bool

Partner concurrence required?

partner_concurrence_id: Option<String>

Partner concurrence ID

partner_concurrence_date: Option<NaiveDate>

Partner concurrence date

workpaper_refs: Vec<Uuid>

Related workpaper IDs

evidence_refs: Vec<Uuid>

Related evidence IDs

status: JudgmentStatus

created_at: DateTime<Utc>

updated_at: DateTime<Utc>

Implementations

impl ProfessionalJudgment

pub fn new( engagement_id: Uuid, judgment_type: JudgmentType, subject: &str, ) -> Self

Create a new professional judgment document.

pub fn with_issue(self, issue: &str) -> Self

Set the issue description.

pub fn add_information(&mut self, item: InformationItem)

Add information considered.

pub fn add_alternative(&mut self, alternative: AlternativeEvaluation)

Add an alternative evaluation.

pub fn with_skepticism(self, skepticism: SkepticismDocumentation) -> Self

Set skepticism documentation.

pub fn with_conclusion( self, conclusion: &str, rationale: &str, residual_risk: &str, ) -> Self

Set conclusion.

pub fn with_preparer(self, id: &str, name: &str, date: NaiveDate) -> Self

Set preparer.

pub fn add_review(&mut self, id: &str, name: &str, date: NaiveDate)

Add reviewer sign-off.

pub fn add_partner_concurrence(&mut self, id: &str, date: NaiveDate)

Add partner concurrence.

pub fn add_consultation(&mut self, consultation: ConsultationRecord)

Add consultation record.

pub fn is_approved(&self) -> bool

Check if judgment is fully approved.

Trait Implementations

impl Clone for ProfessionalJudgment

fn clone(&self) -> ProfessionalJudgment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProfessionalJudgment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProfessionalJudgment

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ProfessionalJudgment

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

where __S: Serializer,

Serialize this value into the given Serde serializer.