update repository for better semantic

internal/domains/sensors/mock/querier.go

@@ -41,6 +41,20 @@ func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
 	return m.recorder
 }
 
+// CreateSensor mocks base method.
+func (m *MockRepository) CreateSensor(s sensors.Sensor) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSensor", s)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateSensor indicates an expected call of CreateSensor.
+func (mr *MockRepositoryMockRecorder) CreateSensor(s any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSensor", reflect.TypeOf((*MockRepository)(nil).CreateSensor), s)
+}
+
 // ReadAllSensors mocks base method.
 func (m *MockRepository) ReadAllSensors() ([]sensors.Sensor, error) {
 	m.ctrl.T.Helper()
@@ -57,59 +71,45 @@ func (mr *MockRepositoryMockRecorder) ReadAllSensors() *gomock.Call {
 }
 
 // ReadSensor mocks base method.
-func (m *MockRepository) ReadSensor(id int) (sensors.Sensor, error) {
+func (m *MockRepository) ReadSensor(sensorID string) (sensors.Sensor, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReadSensor", id)
+	ret := m.ctrl.Call(m, "ReadSensor", sensorID)
 	ret0, _ := ret[0].(sensors.Sensor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ReadSensor indicates an expected call of ReadSensor.
-func (mr *MockRepositoryMockRecorder) ReadSensor(id any) *gomock.Call {
+func (mr *MockRepositoryMockRecorder) ReadSensor(sensorID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSensor", reflect.TypeOf((*MockRepository)(nil).ReadSensor), id)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSensor", reflect.TypeOf((*MockRepository)(nil).ReadSensor), sensorID)
 }
 
 // ReadSensorValues mocks base method.
-func (m *MockRepository) ReadSensorValues(id int, from, to time.Time) ([]sensors.SensorData, error) {
+func (m *MockRepository) ReadSensorValues(sensorID string, from, to time.Time) ([]sensors.SensorData, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReadSensorValues", id, from, to)
+	ret := m.ctrl.Call(m, "ReadSensorValues", sensorID, from, to)
 	ret0, _ := ret[0].([]sensors.SensorData)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ReadSensorValues indicates an expected call of ReadSensorValues.
-func (mr *MockRepositoryMockRecorder) ReadSensorValues(id, from, to any) *gomock.Call {
+func (mr *MockRepositoryMockRecorder) ReadSensorValues(sensorID, from, to any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSensorValues", reflect.TypeOf((*MockRepository)(nil).ReadSensorValues), id, from, to)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSensorValues", reflect.TypeOf((*MockRepository)(nil).ReadSensorValues), sensorID, from, to)
 }
 
-// RegisterSensor mocks base method.
+// UpdateSensor mocks base method.
-func (m *MockRepository) RegisterSensor(s sensors.Sensor) error {
+func (m *MockRepository) UpdateSensor(s sensors.Sensor) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterSensor", s)
+	ret := m.ctrl.Call(m, "UpdateSensor", s)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// RegisterSensor indicates an expected call of RegisterSensor.
+// UpdateSensor indicates an expected call of UpdateSensor.
-func (mr *MockRepositoryMockRecorder) RegisterSensor(s any) *gomock.Call {
+func (mr *MockRepositoryMockRecorder) UpdateSensor(s any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterSensor", reflect.TypeOf((*MockRepository)(nil).RegisterSensor), s)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSensor", reflect.TypeOf((*MockRepository)(nil).UpdateSensor), s)
-}
-
-// UpdateSensorConfig mocks base method.
-func (m *MockRepository) UpdateSensorConfig(s sensors.Sensor) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateSensorConfig", s)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// UpdateSensorConfig indicates an expected call of UpdateSensorConfig.
-func (mr *MockRepositoryMockRecorder) UpdateSensorConfig(s any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSensorConfig", reflect.TypeOf((*MockRepository)(nil).UpdateSensorConfig), s)
 }

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
+	CreateSensor(s Sensor) error
-	UpdateSensorConfig(s Sensor) error
+	UpdateSensor(s Sensor) error
-	ReadSensor(id int) (Sensor, error)
+	ReadSensor(sensorID string) (Sensor, error)
-	ReadSensorValues(id int, from, to time.Time) ([]SensorData, 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) {
+const readAllSensorsQuery = `select sensor_id, sensor_type, sampling_interval, threshold_above, threshold_below from sensors order by created_at desc`
-	panic("unimplemented")
-}
 
 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) {
+func (i *inMemory) ReadSensorValues(sensorID string, from time.Time, to time.Time) ([]SensorData, error) {
-	panic("unimplemented")
-}
-
-func (i *inMemory) ReadSensorValues(id int, 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 {
+func (d *DecoratorRepo) CreateSensor(s Sensor) error {
-	if err := d.db.RegisterSensor(s); err != nil {
+	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 {
+func (d *DecoratorRepo) UpdateSensor(s Sensor) error {
-	if err := d.db.UpdateSensorConfig(s); err != nil {
+	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) {
+func (d *DecoratorRepo) ReadSensor(sensorID string) (Sensor, error) {
-	sensor, err := d.memory.ReadSensor(id)
+	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) {
+func (d *DecoratorRepo) ReadSensorValues(sensorID string, from, to time.Time) ([]SensorData, error) {
-	values, err := d.memory.ReadSensorValues(id, from, to)
+	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) {