recipes2/internal/storage/postgresql/postgresql.go

169 lines
3.8 KiB
Go

package postgresql
import (
"context"
"fmt"
"recipes/internal/domain/models"
"github.com/jackc/pgx/v5/pgxpool"
)
type Storage struct {
db *pgxpool.Pool
}
func New(user, password, addr, dbname string) (*Storage, error) {
const op = "storage.postgresql.New"
pool, err := pgxpool.New(context.Background(), fmt.Sprintf("postgres://%s:%s@%s/%s?sslmode=disable", user, password, addr, dbname))
if err != nil {
return nil, fmt.Errorf("%s: %w", op, err)
}
return &Storage{db: pool}, nil
}
// AddRecipe adds recipe to db.
func (s *Storage) AddRecipe(ctx context.Context, recipe models.Recipe) error {
const op = "storage.postgresql.AddRecipe"
// open transaction
tx, err := s.db.Begin(ctx)
if err != nil {
return fmt.Errorf("%s: %w", op, err)
}
// refactor error handling
// rollback transaction on return
defer tx.Rollback(ctx)
var id uint
// insert recipe
err = s.db.QueryRow(
ctx,
"insert into recipe (title, description, image, cooking_time, servings, cal) values ($1, $2, $3, $4, $5, $6) returning id",
recipe.Title, recipe.Description, recipe.Image, recipe.CookingTime, recipe.ServingsNum, recipe.Calories,
).Scan(&id)
// insert ingredients
for _, r := range recipe.Ingredients {
var ing_id uint
err = s.db.QueryRow(
ctx,
"insert into recipe_ingredients_group (recipe_id, title) values ($1, $2) returning id",
id, r.Title,
).Scan(&ing_id)
if err != nil {
return fmt.Errorf("%s: %w", op, err)
}
for _, i := range r.Ingredients {
_, err = s.db.Exec(
ctx,
"insert into recipe_ingredients (recipe_ingredients_group_id, ingredient) values ($1, $2)",
ing_id, i,
)
if err != nil {
return fmt.Errorf("%s: %w", op, err)
}
}
}
// insert steps
for i, step := range recipe.Recipe_steps {
s.db.Exec(
ctx,
"insert into recipe_steps (recipe_id, step_num, step_text) values ($1, $2, $3)",
id, i, step,
)
}
// insert advices
for _, a := range recipe.Advices {
s.db.Exec(
ctx,
"insert into recipe_advices (recipe_id, advice) values ($1, $2)",
id, a,
)
}
// insert categories
for _, c := range recipe.Categories {
s.db.Exec(
ctx,
"insert into recipe_categories (recipe_id, category) values ($1, $2)",
id, c,
)
}
// commit transaction
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("%s: %w", op, err)
}
return nil
}
// RecipeExists returns true if recipe is exists.
func (s *Storage) RecipeExists(ctx context.Context, title string) (bool, error) {
const op = "storage.postgresql.RecipeExists"
var exists bool
err := s.db.QueryRow(
ctx,
"select exists(select id from recipe where title = $1)",
title,
).Scan(&exists)
if err != nil {
return false, fmt.Errorf("%s: %w", op, err)
}
return exists, nil
}
// func (db *PostgresqlDatabase) GetRecipes(offset, limit int) ([]structs.Recipe, error)
func (s *Storage) GetRecipes(ctx context.Context, offset, limit int) ([]models.Recipe, error) {
const op = "storage.postgresql.GetRecipes"
rows, err := s.db.Query(
ctx,
"select id, title, image, cooking_time, cal from recipe order by id desc offset $1 limit $2",
offset, limit,
)
if err != nil {
return nil, fmt.Errorf("%s: %w", op, err)
}
defer rows.Close()
var recipes []models.Recipe = make([]models.Recipe, 0, limit)
for rows.Next() {
var r models.Recipe
err = rows.Scan(
&r.ID,
&r.Title,
&r.Image,
&r.CookingTime,
&r.Calories,
)
if err != nil {
return nil, fmt.Errorf("%s: %w", op, err)
}
recipes = append(recipes, r)
}
return recipes, nil
}
// func (db *PostgresqlDatabase) GetRecipe(r_id uint) (structs.Recipe, error)
// add to recipe info about ingredients, steps, advices, categories
// func (db *PostgresqlDatabase) AddRecipeInformation(r *structs.Recipe)
// get recipes by category
// func (db *PostgresqlDatabase) GetRecipesByCategory(offset, limit int, category string) ([]structs.Recipe, error)