server/database/productTagging.go

/**
 * file: database/productTagging.go
 * author: Theo Technicguy
 * license: Apache 2.0
 *
 * Product tagging database table connector
 */

package database

import (
	"git.licolas.net/hoffman/server/types"
)

const (
	sqlDropProductTagging   = "DROP TABLE ProductTagging;"
	sqlCreateProductTagging = `CREATE TABLE ProductTagging (
		ProductID INTEGER NOT NULL,
		TagID INTEGER NOT NULL,
		PRIMARY KEY (ProductID, TagID),
		CONSTRAINT productId FOREIGN KEY (ProductID)
			REFERENCES Product (ProductID)
			ON UPDATE CASCADE
			ON DELETE RESTRICT,
		CONSTRAINT tagId FOREIGN KEY (TagID)
			REFERENCES ProductTag (TagID)
			ON UPDATE CASCADE
			ON DELETE RESTRICT
	);`
	sqlSelectProductTaggingByPid = `SELECT pt.TagID, pt.Name, pt.Color
	FROM ProductTag pt
	JOIN ProductTagging ptg ON pt.TagID = ptg.TagID
	WHERE ptg.ProductID = ?;`
	sqlSelectProductTaggingByTid = `SELECT ProductID
	FROM ProductTagging
	WHERE TagID = ?;`
	sqlSelectProductTaggingLikeTagName = `SELECT ptg.ProductID
	FROM ProductTagging ptg
	JOIN ProductTag pt on ptg.TagID = pt.TagID
	WHERE pt.Name LIKE ?;`
	sqlInsertProductTagging        = "INSERT INTO ProductTagging (ProductID, TagID) VALUES (?, ?);"
	sqlDeleteOneProductTagging     = "DELETE FROM ProductTagging WHERE ProductID = ? AND TagID = ?"
	sqlDeleteProductProductTagging = "DELETE FROM ProductTagging WHERE ProductID = ?"
	sqlDeleteTagProductTagging     = "DELETE FROM ProductTagging WHERE TagID = ?"
)

func (r *R) DropProductTaggingTable() error {
	logger.Info().Msg("dropping product tagging table")
	_, err := r.db.Exec(sqlDropProductTagging)
	return err
}

func (r *R) CreateProductTaggingTable() error {
	logger.Info().Msg("creating product tagging table")
	_, err := r.db.Exec(sqlCreateProductTagging)
	return err
}

func (r *R) SelectProductTaggingByPid(pid uint) ([]types.Tag, error) {
	logger.
		Trace().
		Uint("product-id", pid).
		Msg("querying taggings by product and scanning tags")
	rows, err := r.db.Query(sqlSelectProductTaggingByPid, pid)

	if err != nil {
		return nil, err
	}

	var tags []types.Tag = []types.Tag{}
	for rows.Next() {
		var tag types.Tag
		if err := rows.Scan(&tag.Id, &tag.Name, &tag.Color); err != nil {
			return nil, err
		}
		logger.Trace().Any("tag", tag).Msg("adding tag")
		tags = append(tags, tag)
	}

	logger.
		Trace().
		Int("tags", len(tags)).
		Msg("done querying taggings by product and scanning tags")
	return tags, nil
}

func (r *R) SelectProductTaggingByTid(tid uint) ([]*types.Product, error) {
	logger := logger.With().Uint("tag-id", tid).Logger()
	logger.
		Trace().
		Msg("querying taggings by tag and scanning products")
	rows, err := r.db.Query(sqlSelectProductTaggingByTid, tid)

	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var products []*types.Product = []*types.Product{}
	for rows.Next() {
		var pid uint
		if err = rows.Scan(&pid); err != nil {
			return nil, err
		}

		logger.Trace().Uint("product-id", pid).Msg("selecting product")
		product, err := r.SelectProductById(pid)
		if err != nil {
			return nil, err
		}

		logger.Trace().Any("product", pid).Msg("adding found product")
		products = append(products, product)
	}

	logger.Trace().Int("products", len(products)).Msg("found products")
	return products, nil
}

func (r *R) SelectProductTaggingLikeTagName(name string) ([]*types.Product, error) {
	logger := logger.With().Str("name", name).Logger()
	logger.Trace().Msg("selecting product taggings like tag name")
	rows, err := r.db.Query(sqlSelectProductTaggingLikeTagName, name)

	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var products []*types.Product = []*types.Product{}
	for rows.Next() {
		var pid uint
		if err = rows.Scan(&pid); err != nil {
			return nil, err
		}

		logger.Trace().Uint("product-id", pid).Msg("selecting product")
		product, err := r.SelectProductById(pid)
		if err != nil {
			return nil, err
		}

		logger.Trace().Any("product", pid).Msg("adding found product")
		products = append(products, product)
	}

	logger.Trace().Int("products", len(products)).Msg("found products")
	return products, nil
}

func (r *R) InsertProductTagging(pid, tid uint) error {
	logger.Trace().Uint("product-id", pid).Uint("tag-id", tid).Msg("inserting tagging")
	_, err := r.db.Exec(sqlInsertProductTagging, pid, tid)
	return err
}

func (r *R) DeleteOneProductTagging(pid, tid uint) error {
	logger.Trace().Uint("product-id", pid).Uint("tag-id", tid).Msg("deleting tagging")
	_, err := r.db.Exec(sqlDeleteOneProductTagging, pid, tid)
	return err
}

func (r *R) DeleteProductProductTagging(pid uint) error {
	logger.Trace().Uint("product-id", pid).Msg("deleting tagging by product")
	_, err := r.db.Exec(sqlDeleteProductProductTagging, pid)
	return err
}

func (r *R) DeleteTagProductTagging(tid uint) error {
	logger.Trace().Uint("tag-id", tid).Msg("deleting tagging by tag")
	_, err := r.db.Exec(sqlDeleteTagProductTagging, tid)
	return err
}