155 lines
7.3 KiB
Go
155 lines
7.3 KiB
Go
package postgres
|
|
|
|
import (
|
|
"database/sql"
|
|
|
|
"gardomatic.kleiax.de/internal/storage"
|
|
)
|
|
|
|
// SpeciesModel stores global and garden-specific species data in PostgreSQL.
|
|
// SpeciesModel implements storage.SpeciesModelInterface for global and
|
|
// garden-owned species records.
|
|
type SpeciesModel struct{ DB *sql.DB }
|
|
|
|
const speciesColumns = `s.id, s.garden_id, s.common_name, s.cultivar, s.botanical_name,
|
|
s.category_id, COALESCE(c.name, ''), s.sun_exposure, s.soil_condition, s.soil_reaction,
|
|
s.winter_protection, s.spacing_cm, s.height_cm_from, s.height_cm_to,
|
|
s.width_cm_from, s.width_cm_to,
|
|
s.sow_month_from, s.sow_day_from, s.sow_month_to, s.sow_day_to,
|
|
s.planting_month_from, s.planting_day_from, s.planting_month_to, s.planting_day_to,
|
|
s.harvest_month_from, s.harvest_day_from, s.harvest_month_to, s.harvest_day_to,
|
|
s.notes, s.attributes, COALESCE('data:'||i.media_type||';base64,'||replace(encode(i.data,'base64'), E'\n', ''), ''), s.image_id, s.created_at, s.updated_at, s.version,
|
|
COALESCE(s.created_by, 0), COALESCE(s.updated_by, 0)`
|
|
|
|
func scanSpecies(s scanner) (storage.Species, error) {
|
|
var species storage.Species
|
|
err := s.Scan(
|
|
&species.ID, &species.GardenID, &species.CommonName, &species.Cultivar,
|
|
&species.BotanicalName, &species.CategoryID, &species.Category, &species.SunExposure, &species.SoilCondition,
|
|
&species.SoilReaction, &species.WinterProtection, &species.SpacingCM,
|
|
&species.HeightCMFrom, &species.HeightCMTo, &species.WidthCMFrom, &species.WidthCMTo,
|
|
&species.SowMonthFrom, &species.SowDayFrom, &species.SowMonthTo,
|
|
&species.SowDayTo, &species.PlantingMonthFrom, &species.PlantingDayFrom, &species.PlantingMonthTo, &species.PlantingDayTo, &species.HarvestMonthFrom, &species.HarvestDayFrom,
|
|
&species.HarvestMonthTo, &species.HarvestDayTo, &species.Notes, &species.Attributes, &species.ImageData, &species.ImageID,
|
|
&species.CreatedAt, &species.UpdatedAt, &species.Version, &species.CreatedBy, &species.UpdatedBy,
|
|
)
|
|
species.HeightCM = species.HeightCMTo
|
|
return species, err
|
|
}
|
|
|
|
func speciesArgs(species storage.Species) []any {
|
|
heightTo := species.HeightCMTo
|
|
if heightTo == nil {
|
|
heightTo = species.HeightCM
|
|
}
|
|
return []any{
|
|
species.GardenID, species.CommonName, species.Cultivar, species.BotanicalName,
|
|
species.CategoryID, species.SunExposure, species.SoilCondition, species.SoilReaction,
|
|
species.WinterProtection, species.SpacingCM, species.HeightCMFrom, heightTo,
|
|
species.WidthCMFrom, species.WidthCMTo,
|
|
species.SowMonthFrom, species.SowDayFrom, species.SowMonthTo, species.SowDayTo,
|
|
species.PlantingMonthFrom, species.PlantingDayFrom, species.PlantingMonthTo, species.PlantingDayTo,
|
|
species.HarvestMonthFrom, species.HarvestDayFrom, species.HarvestMonthTo,
|
|
species.HarvestDayTo, species.Notes, jsonValue(species.Attributes), species.ImageID, nullableUserID(species.CreatedBy), nullableUserID(species.UpdatedBy),
|
|
}
|
|
}
|
|
|
|
// Insert creates a global or garden-owned species record.
|
|
func (m SpeciesModel) Insert(species storage.Species) (storage.Species, error) {
|
|
ctx, cancel := contextWithTimeout()
|
|
defer cancel()
|
|
query := `
|
|
INSERT INTO species (
|
|
garden_id, common_name, cultivar, botanical_name, category_id, sun_exposure,
|
|
soil_condition, soil_reaction, winter_protection, spacing_cm,
|
|
height_cm_from, height_cm_to, width_cm_from, width_cm_to,
|
|
sow_month_from, sow_day_from, sow_month_to, sow_day_to,
|
|
planting_month_from, planting_day_from, planting_month_to, planting_day_to,
|
|
harvest_month_from, harvest_day_from, harvest_month_to, harvest_day_to,
|
|
notes, attributes, image_data, image_id, created_by, updated_by)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12,
|
|
$13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24,
|
|
$25, $26, $27, $28, '', $29, $30, $31)
|
|
RETURNING id, created_at, updated_at, version`
|
|
err := m.DB.QueryRowContext(ctx, query, speciesArgs(species)...).Scan(
|
|
&species.ID, &species.CreatedAt, &species.UpdatedAt, &species.Version,
|
|
)
|
|
if err != nil {
|
|
return storage.Species{}, recordError(err)
|
|
}
|
|
species.HeightCM = species.HeightCMTo
|
|
return species, nil
|
|
}
|
|
|
|
// Get returns a global or garden-owned species visible in gardenID.
|
|
func (m SpeciesModel) Get(gardenID, id int) (storage.Species, error) {
|
|
ctx, cancel := contextWithTimeout()
|
|
defer cancel()
|
|
species, err := scanSpecies(m.DB.QueryRowContext(ctx, `SELECT `+speciesColumns+` FROM species s LEFT JOIN species_categories c ON c.id = s.category_id LEFT JOIN images i ON i.id=s.image_id WHERE s.id = $1 AND (s.garden_id IS NULL OR s.garden_id = $2)`, id, gardenID))
|
|
if err != nil {
|
|
return storage.Species{}, recordError(err)
|
|
}
|
|
species.HeightCM = species.HeightCMTo
|
|
return species, nil
|
|
}
|
|
|
|
// GetAllForGarden lists global species and species owned by a garden.
|
|
func (m SpeciesModel) GetAllForGarden(gardenID int) ([]storage.Species, error) {
|
|
ctx, cancel := contextWithTimeout()
|
|
defer cancel()
|
|
rows, err := m.DB.QueryContext(ctx, `SELECT `+speciesColumns+`
|
|
FROM species s LEFT JOIN species_categories c ON c.id = s.category_id LEFT JOIN images i ON i.id=s.image_id
|
|
WHERE s.garden_id IS NULL OR s.garden_id = $1
|
|
ORDER BY s.common_name, s.cultivar, s.id`, gardenID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
allSpecies := []storage.Species{}
|
|
for rows.Next() {
|
|
species, err := scanSpecies(rows)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
allSpecies = append(allSpecies, species)
|
|
}
|
|
return allSpecies, rows.Err()
|
|
}
|
|
|
|
// Update changes a visible species using optimistic locking.
|
|
func (m SpeciesModel) Update(gardenID int, species storage.Species) (storage.Species, error) {
|
|
ctx, cancel := contextWithTimeout()
|
|
defer cancel()
|
|
args := speciesArgs(species)
|
|
// created_by is immutable and is intentionally not part of the UPDATE.
|
|
// Remove it from the shared insert argument list so PostgreSQL does not
|
|
// receive an unused, untyped parameter between image_id and updated_by.
|
|
args = append(args[:29], args[30])
|
|
args = append(args, gardenID, species.ID, species.Version)
|
|
err := m.DB.QueryRowContext(ctx, `
|
|
UPDATE species SET garden_id = $1, common_name = $2, cultivar = $3,
|
|
botanical_name = $4, category_id = $5, sun_exposure = $6, soil_condition = $7,
|
|
soil_reaction = $8, winter_protection = $9, spacing_cm = $10,
|
|
height_cm_from = $11, height_cm_to = $12, width_cm_from = $13, width_cm_to = $14,
|
|
sow_month_from = $15, sow_day_from = $16, sow_month_to = $17, sow_day_to = $18,
|
|
planting_month_from=$19, planting_day_from=$20, planting_month_to=$21, planting_day_to=$22,
|
|
harvest_month_from = $23, harvest_day_from = $24, harvest_month_to = $25, harvest_day_to = $26,
|
|
notes = $27, attributes = $28, image_data = '', image_id = $29, updated_by = $30, updated_at = CURRENT_TIMESTAMP, version = version + 1
|
|
WHERE garden_id IS NOT DISTINCT FROM NULLIF($31, 0) AND id = $32 AND version = $33
|
|
RETURNING updated_at, version`, args...,
|
|
).Scan(&species.UpdatedAt, &species.Version)
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return storage.Species{}, storage.ErrEditConflict
|
|
}
|
|
return storage.Species{}, recordError(err)
|
|
}
|
|
return species, nil
|
|
}
|
|
|
|
// Delete removes a species owned by the supplied garden.
|
|
func (m SpeciesModel) Delete(gardenID, id int) error {
|
|
return deleteByGardenID(m.DB, `DELETE FROM species WHERE garden_id IS NOT DISTINCT FROM NULLIF($1, 0) AND id = $2`, gardenID, id)
|
|
}
|