mirror of
https://github.com/go-gitea/gitea
synced 2024-12-05 04:28:12 +01:00
204 lines
5.2 KiB
Go
204 lines
5.2 KiB
Go
|
// Copyright 2015 go-swagger maintainers
|
||
|
//
|
||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
// you may not use this file except in compliance with the License.
|
||
|
// You may obtain a copy of the License at
|
||
|
//
|
||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||
|
//
|
||
|
// Unless required by applicable law or agreed to in writing, software
|
||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
// See the License for the specific language governing permissions and
|
||
|
// limitations under the License.
|
||
|
|
||
|
package strfmt
|
||
|
|
||
|
import (
|
||
|
"database/sql/driver"
|
||
|
"encoding/json"
|
||
|
"errors"
|
||
|
"fmt"
|
||
|
"regexp"
|
||
|
"strings"
|
||
|
"time"
|
||
|
|
||
|
"go.mongodb.org/mongo-driver/bson"
|
||
|
)
|
||
|
|
||
|
func init() {
|
||
|
dt := DateTime{}
|
||
|
Default.Add("datetime", &dt, IsDateTime)
|
||
|
}
|
||
|
|
||
|
// IsDateTime returns true when the string is a valid date-time
|
||
|
func IsDateTime(str string) bool {
|
||
|
if len(str) < 4 {
|
||
|
return false
|
||
|
}
|
||
|
s := strings.Split(strings.ToLower(str), "t")
|
||
|
if len(s) < 2 || !IsDate(s[0]) {
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
matches := rxDateTime.FindAllStringSubmatch(s[1], -1)
|
||
|
if len(matches) == 0 || len(matches[0]) == 0 {
|
||
|
return false
|
||
|
}
|
||
|
m := matches[0]
|
||
|
res := m[1] <= "23" && m[2] <= "59" && m[3] <= "59"
|
||
|
return res
|
||
|
}
|
||
|
|
||
|
const (
|
||
|
// RFC3339Millis represents a ISO8601 format to millis instead of to nanos
|
||
|
RFC3339Millis = "2006-01-02T15:04:05.000Z07:00"
|
||
|
// RFC3339Micro represents a ISO8601 format to micro instead of to nano
|
||
|
RFC3339Micro = "2006-01-02T15:04:05.000000Z07:00"
|
||
|
// ISO8601LocalTime represents a ISO8601 format to ISO8601 in local time (no timezone)
|
||
|
ISO8601LocalTime = "2006-01-02T15:04:05"
|
||
|
// DateTimePattern pattern to match for the date-time format from http://tools.ietf.org/html/rfc3339#section-5.6
|
||
|
DateTimePattern = `^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$`
|
||
|
)
|
||
|
|
||
|
var (
|
||
|
dateTimeFormats = []string{RFC3339Micro, RFC3339Millis, time.RFC3339, time.RFC3339Nano, ISO8601LocalTime}
|
||
|
rxDateTime = regexp.MustCompile(DateTimePattern)
|
||
|
// MarshalFormat sets the time resolution format used for marshaling time (set to milliseconds)
|
||
|
MarshalFormat = RFC3339Millis
|
||
|
)
|
||
|
|
||
|
// ParseDateTime parses a string that represents an ISO8601 time or a unix epoch
|
||
|
func ParseDateTime(data string) (DateTime, error) {
|
||
|
if data == "" {
|
||
|
return NewDateTime(), nil
|
||
|
}
|
||
|
var lastError error
|
||
|
for _, layout := range dateTimeFormats {
|
||
|
dd, err := time.Parse(layout, data)
|
||
|
if err != nil {
|
||
|
lastError = err
|
||
|
continue
|
||
|
}
|
||
|
return DateTime(dd), nil
|
||
|
}
|
||
|
return DateTime{}, lastError
|
||
|
}
|
||
|
|
||
|
// DateTime is a time but it serializes to ISO8601 format with millis
|
||
|
// It knows how to read 3 different variations of a RFC3339 date time.
|
||
|
// Most APIs we encounter want either millisecond or second precision times.
|
||
|
// This just tries to make it worry-free.
|
||
|
//
|
||
|
// swagger:strfmt date-time
|
||
|
type DateTime time.Time
|
||
|
|
||
|
// NewDateTime is a representation of zero value for DateTime type
|
||
|
func NewDateTime() DateTime {
|
||
|
return DateTime(time.Unix(0, 0).UTC())
|
||
|
}
|
||
|
|
||
|
// String converts this time to a string
|
||
|
func (t DateTime) String() string {
|
||
|
return time.Time(t).Format(MarshalFormat)
|
||
|
}
|
||
|
|
||
|
// MarshalText implements the text marshaller interface
|
||
|
func (t DateTime) MarshalText() ([]byte, error) {
|
||
|
return []byte(t.String()), nil
|
||
|
}
|
||
|
|
||
|
// UnmarshalText implements the text unmarshaller interface
|
||
|
func (t *DateTime) UnmarshalText(text []byte) error {
|
||
|
tt, err := ParseDateTime(string(text))
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*t = tt
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// Scan scans a DateTime value from database driver type.
|
||
|
func (t *DateTime) Scan(raw interface{}) error {
|
||
|
// TODO: case int64: and case float64: ?
|
||
|
switch v := raw.(type) {
|
||
|
case []byte:
|
||
|
return t.UnmarshalText(v)
|
||
|
case string:
|
||
|
return t.UnmarshalText([]byte(v))
|
||
|
case time.Time:
|
||
|
*t = DateTime(v)
|
||
|
case nil:
|
||
|
*t = DateTime{}
|
||
|
default:
|
||
|
return fmt.Errorf("cannot sql.Scan() strfmt.DateTime from: %#v", v)
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// Value converts DateTime to a primitive value ready to written to a database.
|
||
|
func (t DateTime) Value() (driver.Value, error) {
|
||
|
return driver.Value(t.String()), nil
|
||
|
}
|
||
|
|
||
|
// MarshalJSON returns the DateTime as JSON
|
||
|
func (t DateTime) MarshalJSON() ([]byte, error) {
|
||
|
return json.Marshal(time.Time(t).Format(MarshalFormat))
|
||
|
}
|
||
|
|
||
|
// UnmarshalJSON sets the DateTime from JSON
|
||
|
func (t *DateTime) UnmarshalJSON(data []byte) error {
|
||
|
if string(data) == jsonNull {
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
var tstr string
|
||
|
if err := json.Unmarshal(data, &tstr); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
tt, err := ParseDateTime(tstr)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*t = tt
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (t DateTime) MarshalBSON() ([]byte, error) {
|
||
|
return bson.Marshal(bson.M{"data": t.String()})
|
||
|
}
|
||
|
|
||
|
func (t *DateTime) UnmarshalBSON(data []byte) error {
|
||
|
var m bson.M
|
||
|
if err := bson.Unmarshal(data, &m); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
|
||
|
if data, ok := m["data"].(string); ok {
|
||
|
rd, err := ParseDateTime(data)
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*t = rd
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
return errors.New("couldn't unmarshal bson bytes value as Date")
|
||
|
}
|
||
|
|
||
|
// DeepCopyInto copies the receiver and writes its value into out.
|
||
|
func (t *DateTime) DeepCopyInto(out *DateTime) {
|
||
|
*out = *t
|
||
|
}
|
||
|
|
||
|
// DeepCopy copies the receiver into a new DateTime.
|
||
|
func (t *DateTime) DeepCopy() *DateTime {
|
||
|
if t == nil {
|
||
|
return nil
|
||
|
}
|
||
|
out := new(DateTime)
|
||
|
t.DeepCopyInto(out)
|
||
|
return out
|
||
|
}
|