1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::x509::private::validity::Time;
#[cfg(feature = "chrono_conversion")]
use chrono::{DateTime, Utc};
use picky_asn1::date::{Date, GeneralizedTime, UTCTime, UTCTimeRepr};
use std::fmt;

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct UTCDate(GeneralizedTime);

impl UTCDate {
    #[inline]
    pub fn new(year: u16, month: u8, day: u8, hour: u8, minute: u8, second: u8) -> Option<Self> {
        Some(Self(GeneralizedTime::new(year, month, day, hour, minute, second)?))
    }

    #[inline]
    pub fn ymd(year: u16, month: u8, day: u8) -> Option<Self> {
        Some(Self(GeneralizedTime::new(year, month, day, 0, 0, 0)?))
    }

    #[cfg(feature = "chrono_conversion")]
    #[inline]
    pub fn now() -> Self {
        Self(chrono::offset::Utc::now().into())
    }

    #[inline]
    pub fn year(&self) -> u16 {
        self.0.year()
    }

    #[inline]
    pub fn month(&self) -> u8 {
        self.0.month()
    }

    #[inline]
    pub fn day(&self) -> u8 {
        self.0.day()
    }

    #[inline]
    pub fn hour(&self) -> u8 {
        self.0.hour()
    }

    #[inline]
    pub fn minute(&self) -> u8 {
        self.0.minute()
    }

    #[inline]
    pub fn second(&self) -> u8 {
        self.0.second()
    }
}

impl Into<UTCTime> for UTCDate {
    fn into(self) -> UTCTime {
        unsafe {
            UTCTime::new_unchecked(
                self.0.year(),
                self.0.month(),
                self.0.day(),
                self.0.hour(),
                self.0.minute(),
                self.0.second(),
            )
        }
    }
}

impl From<UTCTime> for UTCDate {
    fn from(date: Date<UTCTimeRepr>) -> Self {
        Self(unsafe {
            GeneralizedTime::new_unchecked(
                date.year(),
                date.month(),
                date.day(),
                date.hour(),
                date.minute(),
                date.second(),
            )
        })
    }
}

impl Into<GeneralizedTime> for UTCDate {
    fn into(self) -> GeneralizedTime {
        self.0
    }
}

impl From<GeneralizedTime> for UTCDate {
    fn from(date: GeneralizedTime) -> Self {
        Self(date)
    }
}

impl From<UTCDate> for Time {
    fn from(date: UTCDate) -> Self {
        Self::Generalized(date.0.into())
    }
}

impl From<Time> for UTCDate {
    fn from(time: Time) -> Self {
        match time {
            Time::UTC(utc) => utc.0.into(),
            Time::Generalized(gen_time) => gen_time.0.into(),
        }
    }
}

#[cfg(feature = "chrono_conversion")]
impl From<DateTime<Utc>> for UTCDate {
    fn from(dt: DateTime<Utc>) -> Self {
        Self(dt.into())
    }
}

impl fmt::Display for UTCDate {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{:04}-{:02}-{:02} {:02}:{:02}:{:02}",
            self.year(),
            self.month(),
            self.day(),
            self.hour(),
            self.minute(),
            self.second()
        )
    }
}