143 lines
3.3 KiB
Go
143 lines
3.3 KiB
Go
package logfile
|
|
|
|
import (
|
|
"encoding/csv"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/volker-raschek/flucky/pkg/internal/format"
|
|
"github.com/volker-raschek/flucky/pkg/types"
|
|
)
|
|
|
|
type csvLogfile struct {
|
|
logfile string
|
|
}
|
|
|
|
func (cl *csvLogfile) Read() ([]*types.MeasuredValue, error) {
|
|
|
|
if _, err := os.Stat(cl.logfile); os.IsNotExist(err) {
|
|
if _, err := os.Stat(filepath.Dir(cl.logfile)); os.IsNotExist(err) {
|
|
if err := os.MkdirAll(filepath.Dir(cl.logfile), 0755); err != nil {
|
|
return nil, fmt.Errorf("%v: %v", errorDirectoryCreate, filepath.Dir(cl.logfile))
|
|
}
|
|
}
|
|
|
|
f, err := os.Create(cl.logfile)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v: %v", errorLogfileCreate, cl.logfile)
|
|
}
|
|
f.Close()
|
|
}
|
|
|
|
f, err := os.Open(cl.logfile)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v: %v", errorLogfileOpen, cl.logfile)
|
|
}
|
|
defer f.Close()
|
|
|
|
r := csv.NewReader(f)
|
|
records, err := r.ReadAll()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v %v: %v", errorLogfileDecode, cl.logfile, err)
|
|
}
|
|
|
|
measuredValues := make([]*types.MeasuredValue, 0)
|
|
|
|
for _, record := range records {
|
|
|
|
// ValueType
|
|
valueType, err := types.SelectMeasuredValueType(record[1])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v %v: %v", errorParseFloat, record[1], err)
|
|
}
|
|
|
|
// Value
|
|
value, err := strconv.ParseFloat(record[2], 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v %v: %v", errorParseFloat, record[2], err)
|
|
}
|
|
|
|
// Times
|
|
times := make([]time.Time, 0)
|
|
for _, i := range []int{3, 4} {
|
|
time, err := time.Parse(format.TimeFormat, record[i])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v %v: %v", errorParseTime, record[i], err)
|
|
}
|
|
times = append(times, time)
|
|
}
|
|
|
|
measuredValue := &types.MeasuredValue{
|
|
ID: record[0],
|
|
ValueType: *valueType,
|
|
Value: value,
|
|
FromDate: times[0],
|
|
TillDate: times[1],
|
|
SensorID: record[5],
|
|
}
|
|
|
|
// Creation date
|
|
if record[6] != "null" {
|
|
creationDate, err := time.Parse(format.TimeFormat, record[6])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v %v: %v", errorParseTime, record[6], err)
|
|
}
|
|
measuredValue.CreationDate = &creationDate
|
|
}
|
|
|
|
// Update date
|
|
if record[7] != "null" {
|
|
updateDate, err := time.Parse(format.TimeFormat, record[7])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%v %v: %v", errorParseTime, record[7], err)
|
|
}
|
|
measuredValue.UpdateDate = &updateDate
|
|
}
|
|
|
|
measuredValues = append(measuredValues, measuredValue)
|
|
|
|
}
|
|
|
|
return measuredValues, nil
|
|
|
|
}
|
|
|
|
func (cl *csvLogfile) Write(measuredValues []*types.MeasuredValue) error {
|
|
f, err := os.Create(cl.logfile)
|
|
if err != nil {
|
|
return fmt.Errorf("%v: %v", errorLogfileCreate, cl.logfile)
|
|
}
|
|
defer f.Close()
|
|
|
|
w := csv.NewWriter(f)
|
|
|
|
for _, measuredValue := range measuredValues {
|
|
|
|
record := []string{
|
|
measuredValue.ID,
|
|
fmt.Sprintf("%v", measuredValue.ValueType),
|
|
fmt.Sprintf("%v", measuredValue.Value),
|
|
measuredValue.FromDate.Format(format.TimeFormat),
|
|
measuredValue.TillDate.Format(format.TimeFormat),
|
|
measuredValue.SensorID,
|
|
}
|
|
|
|
record = append(record, measuredValue.CreationDate.Format(format.TimeFormat))
|
|
|
|
if measuredValue.UpdateDate != nil {
|
|
record = append(record, measuredValue.UpdateDate.Format(format.TimeFormat))
|
|
} else {
|
|
record = append(record, "null")
|
|
}
|
|
|
|
w.Write(record)
|
|
}
|
|
|
|
w.Flush()
|
|
|
|
return nil
|
|
}
|