beenull/photoprism
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Read taken date from file name #304

Browse source 
Signed-off-by: Michael Mayer <michael@liquidbytes.net>
This commit is contained in:
Michael Mayer 2020-05-20 15:10:24 +02:00
parent a77d74e6eb
commit 1297a8cc1f
7 changed files with 442 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
assets/resources/examples/telegram_2020-01-30_09-57-18.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 132 KiB

1
internal/entity/const.go
View file

@ -6,6 +6,7 @@ const (
// data sources
SrcAuto = ""
SrcManual = "manual"
SrcName = "name"
SrcMeta = "meta"
SrcXmp = "xmp"
SrcYaml = "yaml"

3
internal/photoprism/index_mediafile.go
View file

@ -252,7 +252,8 @@ func (ind *Index) MediaFile(m *MediaFile, o IndexOptions, originalName string) (
}
if photo.TakenAt.IsZero() || photo.TakenAtLocal.IsZero() {
photo.SetTakenAt(m.DateCreated(), m.DateCreated(), "", entity.SrcAuto)
takenUtc, takenSrc := m.TakenAt()
photo.SetTakenAt(takenUtc, takenUtc, "", takenSrc)
}
if fileChanged || o.Rescan || photo.NoTitle() {

55
internal/photoprism/mediafile.go
View file

@ -28,7 +28,8 @@ type MediaFile struct {
fileName string
fileType fs.FileType
mimeType string
dateCreated time.Time
takenAt time.Time
takenAtSrc string
hash string
checksum string
width int
@ -64,41 +65,61 @@ func (m *MediaFile) Stat() (size int64, mod time.Time) {
return s.Size(), s.ModTime().Round(time.Second)
}
// DateCreated returns the date on which the media file was created in UTC.
// DateCreated returns only the date on which the media file was probably taken in UTC.
func (m *MediaFile) DateCreated() time.Time {
if !m.dateCreated.IsZero() {
return m.dateCreated
takenAt, _ := m.TakenAt()
return takenAt
}
// TakenAt returns the date on which the media file was taken in UTC and the source of this information.
func (m *MediaFile) TakenAt() (time.Time, string) {
if !m.takenAt.IsZero() {
return m.takenAt, m.takenAtSrc
}
m.dateCreated = time.Now().UTC()
m.takenAt = time.Now().UTC()
info, err := m.MetaData()
if err == nil && !info.TakenAt.IsZero() && info.TakenAt.Year() > 1000 {
m.dateCreated = info.TakenAt.UTC()
m.takenAt = info.TakenAt.UTC()
m.takenAtSrc = entity.SrcMeta
log.Infof("mediafile: taken at %s (meta)", m.dateCreated.String())
log.Infof("mediafile: %s was taken at %s (%s)", filepath.Base(m.fileName), m.takenAt.String(), m.takenAtSrc)
return m.dateCreated
return m.takenAt, m.takenAtSrc
}
t, err := times.Stat(m.FileName())
if nameTime := txt.Time(m.fileName); !nameTime.IsZero() {
m.takenAt = nameTime
m.takenAtSrc = entity.SrcName
log.Infof("mediafile: %s was taken at %s (%s)", filepath.Base(m.fileName), m.takenAt.String(), m.takenAtSrc)
return m.takenAt, m.takenAtSrc
}
m.takenAtSrc = entity.SrcAuto
fileInfo, err := times.Stat(m.FileName())
if err != nil {
log.Debug(err.Error())
log.Warnf("mediafile: %s (file stat)", err.Error())
log.Infof("mediafile: %s was taken at %s (now)", filepath.Base(m.fileName), m.takenAt.String())
return m.dateCreated
return m.takenAt, m.takenAtSrc
}
if t.HasBirthTime() {
m.dateCreated = t.BirthTime().UTC()
if fileInfo.HasBirthTime() {
m.takenAt = fileInfo.BirthTime().UTC()
log.Infof("mediafile: %s was taken at %s (file birth time)", filepath.Base(m.fileName), m.takenAt.String())
} else {
m.dateCreated = t.ModTime().UTC()
m.takenAt = fileInfo.ModTime().UTC()
log.Infof("mediafile: %s was taken at %s (file mod time)", filepath.Base(m.fileName), m.takenAt.String())
}
log.Infof("mediafile: taken at %s (file)", m.dateCreated.String())
return m.dateCreated
return m.takenAt, m.takenAtSrc
}
func (m *MediaFile) HasTimeAndPlace() bool {

105
internal/photoprism/mediafile_test.go
View file

@ -5,43 +5,128 @@ import (
"path/filepath"
"testing"
"github.com/photoprism/photoprism/internal/config"
"github.com/photoprism/photoprism/internal/entity"
"github.com/photoprism/photoprism/internal/thumb"
"github.com/photoprism/photoprism/pkg/fs"
"github.com/photoprism/photoprism/internal/config"
"github.com/stretchr/testify/assert"
)
func TestMediaFile_DateCreated(t *testing.T) {
conf := config.TestConfig()
t.Run("telegram_2020-01-30_09-57-18.jpg", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/telegram_2020-01-30_09-57-18.jpg")
if err != nil {
t.Fatal(err)
}
date := mediaFile.DateCreated().UTC()
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", date.String())
})
t.Run("Screenshot 2019-05-21 at 10.45.52.png", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/Screenshot 2019-05-21 at 10.45.52.png")
if err != nil {
t.Fatal(err)
}
date := mediaFile.DateCreated().UTC()
assert.Equal(t, "2019-05-21 10:45:52 +0000 UTC", date.String())
})
t.Run("iphone_7.heic", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/iphone_7.heic")
assert.Nil(t, err)
if err != nil {
t.Fatal(err)
}
date := mediaFile.DateCreated().UTC()
assert.Equal(t, "2018-09-10 03:16:13 +0000 UTC", date.String())
assert.Empty(t, err)
})
t.Run("canon_eos_6d.dng", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/canon_eos_6d.dng")
assert.Nil(t, err)
if err != nil {
t.Fatal(err)
}
date := mediaFile.DateCreated().UTC()
assert.Equal(t, "2019-06-06 07:29:51 +0000 UTC", date.String())
assert.Empty(t, err)
})
t.Run("elephants.jpg", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/elephants.jpg")
assert.Nil(t, err)
if err != nil {
t.Fatal(err)
}
date := mediaFile.DateCreated().UTC()
assert.Equal(t, "2013-11-26 13:53:55 +0000 UTC", date.String())
assert.Empty(t, err)
})
t.Run("dog_created_1919.jpg", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/dog_created_1919.jpg")
assert.Nil(t, err)
if err != nil {
t.Fatal(err)
}
date := mediaFile.DateCreated().UTC()
assert.Equal(t, "1919-05-04 05:59:26 +0000 UTC", date.String())
assert.Empty(t, err)
})
}
func TestMediaFile_TakenAt(t *testing.T) {
conf := config.TestConfig()
t.Run("telegram_2020-01-30_09-57-18.jpg", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/telegram_2020-01-30_09-57-18.jpg")
if err != nil {
t.Fatal(err)
}
date, src := mediaFile.TakenAt()
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", date.String())
assert.Equal(t, entity.SrcName, src)
})
t.Run("Screenshot 2019-05-21 at 10.45.52.png", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/Screenshot 2019-05-21 at 10.45.52.png")
if err != nil {
t.Fatal(err)
}
date, src := mediaFile.TakenAt()
assert.Equal(t, "2019-05-21 10:45:52 +0000 UTC", date.String())
assert.Equal(t, entity.SrcName, src)
})
t.Run("iphone_7.heic", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/iphone_7.heic")
if err != nil {
t.Fatal(err)
}
date, src := mediaFile.TakenAt()
assert.Equal(t, "2018-09-10 03:16:13 +0000 UTC", date.String())
assert.Equal(t, entity.SrcMeta, src)
})
t.Run("canon_eos_6d.dng", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/canon_eos_6d.dng")
if err != nil {
t.Fatal(err)
}
date, src := mediaFile.TakenAt()
assert.Equal(t, "2019-06-06 07:29:51 +0000 UTC", date.String())
assert.Equal(t, entity.SrcMeta, src)
})
t.Run("elephants.jpg", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/elephants.jpg")
if err != nil {
t.Fatal(err)
}
date, src := mediaFile.TakenAt()
assert.Equal(t, "2013-11-26 13:53:55 +0000 UTC", date.String())
assert.Equal(t, entity.SrcMeta, src)
})
t.Run("dog_created_1919.jpg", func(t *testing.T) {
mediaFile, err := NewMediaFile(conf.ExamplesPath() + "/dog_created_1919.jpg")
if err != nil {
t.Fatal(err)
}
date, src := mediaFile.TakenAt()
assert.Equal(t, "1919-05-04 05:59:26 +0000 UTC", date.String())
assert.Equal(t, entity.SrcMeta, src)
})
}

156
pkg/txt/convert.go Normal file
View file

@ -0,0 +1,156 @@
package txt
import (
"regexp"
"strconv"
"time"
)
var DateRegexp = regexp.MustCompile("\\d{4}[\\-_]\\d{2}[\\-_]\\d{2}")
var DateCanonicalRegexp = regexp.MustCompile("\\d{8}_\\d{6}_\\w{8}\\.")
var DatePathRegexp = regexp.MustCompile("\\d{4}\\/\\d{1,2}\\/?\\d{0,2}")
var DateTimeRegexp = regexp.MustCompile("\\d{4}[\\-_]\\d{2}[\\-_]\\d{2}.{1,4}\\d{2}\\D\\d{2}\\D\\d{2}")
var DateIntRegexp = regexp.MustCompile("\\d{1,4}")
var (
YearMin = 1000
YearMax = time.Now().Year() + 3
)
const (
MonthMin = 1
MonthMax = 12
DayMin = 1
DayMax = 31
HourMin = 0
HourMax = 24
MinMin = 0
MinMax = 59
SecMin = 0
SecMax = 59
)
// Time returns a string as time or the zero time instant in case it can not be converted.
func Time(s string) (result time.Time) {
defer func() {
if err := recover(); err != nil {
result = time.Time{}
}
}()
b := []byte(s)
if found := DateCanonicalRegexp.Find(b); len(found) == 25 { // Is it a canonical name like "20120727_093920_97425909.jpg"?
if date, err := time.Parse("20060102_150405", string(found[0:15])); err == nil {
result = date.Round(time.Second).UTC()
}
} else if found := DateTimeRegexp.Find(b); len(found) > 0 { // Is it a date with time like "2020-01-30_09-57-18"?
n := DateIntRegexp.FindAll(found, -1)
if len(n) != 6 {
return result
}
year := Int(string(n[0]))
month := Int(string(n[1]))
day := Int(string(n[2]))
hour := Int(string(n[3]))
min := Int(string(n[4]))
sec := Int(string(n[5]))
if year < YearMin || year > YearMax || month < MonthMin || month > MonthMax || day < DayMin || day > DayMax {
return result
}
if hour < HourMin || hour > HourMax || min < MinMin || min > MinMax || sec < SecMin || sec > SecMax {
return result
}
result = time.Date(
year,
time.Month(month),
day,
hour,
min,
sec,
0,
time.UTC)
} else if found := DateRegexp.Find(b); len(found) > 0 { // Is it a date only like "2020-01-30"?
n := DateIntRegexp.FindAll(found, -1)
if len(n) != 3 {
return result
}
year := Int(string(n[0]))
month := Int(string(n[1]))
day := Int(string(n[2]))
if year < YearMin || year > YearMax || month < MonthMin || month > MonthMax || day < DayMin || day > DayMax {
return result
}
result = time.Date(
year,
time.Month(month),
day,
0,
0,
0,
0,
time.UTC)
} else if found := DatePathRegexp.Find(b); len(found) > 0 { // Is it a date path like "2020/01/03"?
n := DateIntRegexp.FindAll(found, -1)
if len(n) < 2 || len(n) > 3 {
return result
}
year := Int(string(n[0]))
month := Int(string(n[1]))
if year < YearMin || year > YearMax || month < MonthMin || month > MonthMax {
return result
}
if len(n) == 2 {
result = time.Date(
year,
time.Month(month),
1,
0,
0,
0,
0,
time.UTC)
} else if day := Int(string(n[2])); day >= DayMin && day <= DayMax {
result = time.Date(
year,
time.Month(month),
day,
0,
0,
0,
0,
time.UTC)
}
}
return result.UTC()
}
// Int returns a string as int or 0 if it can not be converted.
func Int(s string) int {
if s == "" {
return 0
}
result, err := strconv.ParseInt(s, 10, 64)
if err != nil {
return 0
}
return int(result)
}

150
pkg/txt/convert_test.go Normal file
View file

@ -0,0 +1,150 @@
package txt
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestTime(t *testing.T) {
t.Run("/2020_01_30/1212/20130518_142022_3D657EBD.jpg", func(t *testing.T) {
result := Time("/2020_01_30/1212/20130518_142022_3D657EBD.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2013-05-18 14:20:22 +0000 UTC", result.String())
})
t.Run("telegram_2020_01_30_09_57_18.jpg", func(t *testing.T) {
result := Time("telegram_2020_01_30_09_57_18.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", result.String())
})
t.Run("Screenshot 2019_05_21 at 10.45.52.png", func(t *testing.T) {
result := Time("Screenshot 2019_05_21 at 10.45.52.png")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 10:45:52 +0000 UTC", result.String())
})
t.Run("telegram_2020-01-30_09-57-18.jpg", func(t *testing.T) {
result := Time("telegram_2020-01-30_09-57-18.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", result.String())
})
t.Run("Screenshot 2019-05-21 at 10.45.52.png", func(t *testing.T) {
result := Time("Screenshot 2019-05-21 at 10.45.52.png")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 10:45:52 +0000 UTC", result.String())
})
t.Run("telegram_2020-01-30_09-18.jpg", func(t *testing.T) {
result := Time("telegram_2020-01-30_09-18.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2020-01-30 00:00:00 +0000 UTC", result.String())
})
t.Run("Screenshot 2019-05-21 at 10545.52.png", func(t *testing.T) {
result := Time("Screenshot 2019-05-21 at 10545.52.png")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("2019-05-21", func(t *testing.T) {
result := Time("2019-05-21")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("2019.05.21", func(t *testing.T) {
result := Time("2019.05.21")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("05.21.2019", func(t *testing.T) {
result := Time("05.21.2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("21.05.2019", func(t *testing.T) {
result := Time("21.05.2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("05/21/2019", func(t *testing.T) {
result := Time("05/21/2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("21/05/2019", func(t *testing.T) {
result := Time("21/05/2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2019/05/21", func(t *testing.T) {
result := Time("2019/05/21")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("2019/21/05", func(t *testing.T) {
result := Time("2019/21/05")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/05/21/foo.jpg", func(t *testing.T) {
result := Time("/2019/05/21/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/21/05/foo.jpg", func(t *testing.T) {
result := Time("/2019/21/05/foo.jpg")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/5/foo.jpg", func(t *testing.T) {
result := Time("/2019/5/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/1/3/foo.jpg", func(t *testing.T) {
result := Time("/2019/1/3/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-01-03 00:00:00 +0000 UTC", result.String())
})
}
func TestInt(t *testing.T) {
t.Run("empty", func(t *testing.T) {
result := Int("")
assert.Equal(t, 0, result)
})
t.Run("non-numeric", func(t *testing.T) {
result := Int("Screenshot")
assert.Equal(t, 0, result)
})
t.Run("zero", func(t *testing.T) {
result := Int("0")
assert.Equal(t, 0, result)
})
t.Run("int", func(t *testing.T) {
result := Int("123")
assert.Equal(t, 123, result)
})
t.Run("negative int", func(t *testing.T) {
result := Int("-123")
assert.Equal(t, -123, result)
})
}