update repository for better semantic

internal/domains/sensors/repository.go

@@ -1,6 +1,7 @@
 package sensors
 
 import (
+	"context"
 	"log/slog"
 	"sync"
 	"time"
@@ -9,41 +10,70 @@ import (
 )
 
 type Repository interface {
-	RegisterSensor(s Sensor) error
-	UpdateSensorConfig(s Sensor) error
-	ReadSensor(id int) (Sensor, error)
-	ReadSensorValues(id int, from, to time.Time) ([]SensorData, error)
+	CreateSensor(s Sensor) error
+	UpdateSensor(s Sensor) error
+	ReadSensor(sensorID string) (Sensor, error)
+	ReadSensorValues(sensorID string, from, to time.Time) ([]SensorData, error)
 	ReadAllSensors() ([]Sensor, error)
 }
 
 type pgxRepo struct {
-	pool *pgxpool.Pool
+	*pgxpool.Pool
 }
 
 func newPGXRepo(pool *pgxpool.Pool) Repository {
 	return &pgxRepo{
-		pool: pool,
+		pool,
 	}
 }
 
-func (p *pgxRepo) ReadSensor(id int) (Sensor, error) {
+const createSensorQuery = `insert into sensors (sensor_id, sensor_type, sampling_interval, threshold_above, threshold_below) values ($1, $2, $3, $4, $5)`
+
+func (p *pgxRepo) CreateSensor(s Sensor) error {
+	_, err := p.Exec(context.Background(), createSensorQuery, s.SensorID, string(s.SensorType), s.SamplingInterval, s.ThresholdAbove, s.ThresholdBelow)
+	return err
+}
+
+func (p *pgxRepo) UpdateSensor(s Sensor) error {
 	panic("unimplemented")
 }
 
-func (p *pgxRepo) UpdateSensorConfig(s Sensor) error {
+func (p *pgxRepo) ReadSensor(sensorID string) (Sensor, error) {
 	panic("unimplemented")
 }
 
-func (p *pgxRepo) RegisterSensor(s Sensor) error {
+func (p *pgxRepo) ReadSensorValues(sensorID string, from time.Time, to time.Time) ([]SensorData, error) {
 	panic("unimplemented")
 }
 
-func (p *pgxRepo) ReadSensorValues(id int, from time.Time, to time.Time) ([]SensorData, error) {
-	panic("unimplemented")
-}
+const readAllSensorsQuery = `select sensor_id, sensor_type, sampling_interval, threshold_above, threshold_below from sensors order by created_at desc`
 
 func (p *pgxRepo) ReadAllSensors() ([]Sensor, error) {
-	panic("unimplemented")
+	rows, err := p.Query(context.Background(), readAllSensorsQuery)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	sensors := []Sensor{}
+	for rows.Next() {
+		var s Sensor
+		if err := rows.Scan(
+			&s.SensorID,
+			&s.SensorType,
+			&s.SamplingInterval,
+			&s.ThresholdAbove,
+			&s.ThresholdBelow,
+		); err != nil {
+			return nil, err
+		}
+		sensors = append(sensors, s)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return sensors, nil
 }
 
 type inMemory struct {
@@ -54,22 +84,32 @@ type inMemory struct {
 func newInMemoryRepo() Repository {
 	return &inMemory{
 		sensors: make(map[string]*Sensor),
+		mu:      &sync.Mutex{},
 	}
 }
 
-func (i *inMemory) RegisterSensor(s Sensor) error {
+func (i *inMemory) CreateSensor(s Sensor) error {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	if _, exists := i.sensors[s.SensorID]; exists {
+		return ErrSensorAlreadyExists
+	}
+
+	sensorCopy := s
+	i.sensors[s.SensorID] = &sensorCopy
+	return nil
+}
+
+func (i *inMemory) UpdateSensor(s Sensor) error {
 	panic("unimplemented")
 }
 
-func (i *inMemory) UpdateSensorConfig(s Sensor) error {
+func (i *inMemory) ReadSensor(sensorID string) (Sensor, error) {
 	panic("unimplemented")
 }
 
-func (i *inMemory) ReadSensor(id int) (Sensor, error) {
-	panic("unimplemented")
-}
-
-func (i *inMemory) ReadSensorValues(id int, from time.Time, to time.Time) ([]SensorData, error) {
+func (i *inMemory) ReadSensorValues(sensorID string, from time.Time, to time.Time) ([]SensorData, error) {
 	// holds only last 100 values for every sensor
 
 	panic("unimplemented")
@@ -95,7 +135,7 @@ func NewDecoratorRepo(pool *pgxpool.Pool) Repository {
 	}
 
 	for _, s := range sensors {
-		_ = memory.RegisterSensor(s)
+		_ = memory.CreateSensor(s)
 	}
 
 	return &DecoratorRepo{
@@ -104,40 +144,40 @@ func NewDecoratorRepo(pool *pgxpool.Pool) Repository {
 	}
 }
 
-func (d *DecoratorRepo) RegisterSensor(s Sensor) error {
-	if err := d.db.RegisterSensor(s); err != nil {
+func (d *DecoratorRepo) CreateSensor(s Sensor) error {
+	if err := d.db.CreateSensor(s); err != nil {
 		return err
 	}
 
-	_ = d.memory.RegisterSensor(s)
+	_ = d.memory.CreateSensor(s)
 	return nil
 }
 
-func (d *DecoratorRepo) UpdateSensorConfig(s Sensor) error {
-	if err := d.db.UpdateSensorConfig(s); err != nil {
+func (d *DecoratorRepo) UpdateSensor(s Sensor) error {
+	if err := d.db.UpdateSensor(s); err != nil {
 		return err
 	}
 
-	_ = d.memory.UpdateSensorConfig(s)
+	_ = d.memory.UpdateSensor(s)
 	return nil
 }
 
-func (d *DecoratorRepo) ReadSensor(id int) (Sensor, error) {
-	sensor, err := d.memory.ReadSensor(id)
+func (d *DecoratorRepo) ReadSensor(sensorID string) (Sensor, error) {
+	sensor, err := d.memory.ReadSensor(sensorID)
 	if err == nil {
 		return sensor, nil
 	}
 
-	return d.db.ReadSensor(id)
+	return d.db.ReadSensor(sensorID)
 }
 
-func (d *DecoratorRepo) ReadSensorValues(id int, from, to time.Time) ([]SensorData, error) {
-	values, err := d.memory.ReadSensorValues(id, from, to)
+func (d *DecoratorRepo) ReadSensorValues(sensorID string, from, to time.Time) ([]SensorData, error) {
+	values, err := d.memory.ReadSensorValues(sensorID, from, to)
 	if err == nil && len(values) > 0 {
 		return values, nil
 	}
 
-	return d.db.ReadSensorValues(id, from, to)
+	return d.db.ReadSensorValues(sensorID, from, to)
 }
 
 func (d *DecoratorRepo) ReadAllSensors() ([]Sensor, error) {