425 lines
15 KiB
Go
425 lines
15 KiB
Go
package repositories
|
|
|
|
import (
|
|
"database/sql"
|
|
"simplycpq/models"
|
|
)
|
|
|
|
type ValueRepository struct {
|
|
db *sql.DB
|
|
}
|
|
|
|
func NewValueRepository(db *sql.DB) *ValueRepository {
|
|
return &ValueRepository{
|
|
db: db,
|
|
}
|
|
}
|
|
|
|
func (vr *ValueRepository) CreatePropertyTypeGroup(propertyTypeGroup *models.PropertyTypeGroup) (*models.PropertyTypeGroup, error) {
|
|
// Implement the logic to insert the propertyTypeGroup into the database
|
|
query := `INSERT INTO propertytypegroups(label, description, parentGroupId) VALUES($1,$2,$3) RETURNING id`
|
|
rows, err := vr.db.Query(query, propertyTypeGroup.Label, propertyTypeGroup.Description, propertyTypeGroup.ParentGroupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var id int
|
|
if rows.Next() {
|
|
err := rows.Scan(&id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
propertyTypeGroup.ID = id
|
|
return propertyTypeGroup, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) UpdatePropertyTypeGroup(propertyTypeGroup *models.PropertyTypeGroup) error {
|
|
// Implement the logic to update the propertyTypeGroup in the database
|
|
query := `UPDATE propertytypegroups SET label=$1, description=$2, parentGroupId=$3 WHERE id=$4`
|
|
_, err := vr.db.Exec(query, propertyTypeGroup.Label, propertyTypeGroup.Description, propertyTypeGroup.ParentGroupID, propertyTypeGroup.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) DeletePropertyTypeGroup(id int) error {
|
|
// Implement the logic to delete the propertyTypeGroup from the database
|
|
query := `DELETE FROM propertytypegroups WHERE id=$1`
|
|
_, err := vr.db.Exec(query, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetPropertyTypeGroup(id int) (*models.PropertyTypeGroup, error) {
|
|
// Implement the logic to retrieve the propertyTypeGroup from the database
|
|
query := `SELECT id, label, description, parentGroupId FROM propertytypegroups WHERE id=$1`
|
|
row := vr.db.QueryRow(query, id)
|
|
var propertyTypeGroup models.PropertyTypeGroup
|
|
err := row.Scan(&propertyTypeGroup.ID, &propertyTypeGroup.Label, &propertyTypeGroup.Description, &propertyTypeGroup.ParentGroupID)
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return &propertyTypeGroup, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetPropertyTypeGroupsByParentId(parentId int) ([]*models.PropertyTypeGroup, error) {
|
|
// Implement the logic to retrieve the propertyTypeGroups by parentId from the database
|
|
query := `SELECT id, label, description, parentGroupId FROM propertytypegroups WHERE parentGroupId=$1`
|
|
rows, err := vr.db.Query(query, parentId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var propertyTypeGroups []*models.PropertyTypeGroup
|
|
for rows.Next() {
|
|
var propertyTypeGroup models.PropertyTypeGroup
|
|
err := rows.Scan(&propertyTypeGroup.ID, &propertyTypeGroup.Label, &propertyTypeGroup.Description, &propertyTypeGroup.ParentGroupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
propertyTypeGroups = append(propertyTypeGroups, &propertyTypeGroup)
|
|
}
|
|
return propertyTypeGroups, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) DeletePropertyTypeFromPropertyTypeGroupId(propertyTypeGroupId int) error {
|
|
// Implement the logic to delete the propertyType from the propertyTypeGroup in the database
|
|
query := `DELETE FROM propertytypes WHERE propertytypegroupid=$1`
|
|
_, err := vr.db.Exec(query, propertyTypeGroupId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) CreatePropertyType(propertyType *models.PropertyType) (*models.PropertyType, error) {
|
|
// Implement the logic to insert the propertyType into the database
|
|
query := `INSERT INTO propertytypes(label, description, propertytypegroupid) VALUES($1,$2,$3) RETURNING id`
|
|
err := vr.db.QueryRow(query, propertyType.Label, propertyType.Description, propertyType.PropertyTypeGroupID).Scan(&propertyType.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return propertyType, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) UpdatePropertyType(propertyType *models.PropertyType) error {
|
|
// Implement the logic to update the propertyType in the database
|
|
query := `UPDATE propertytypes SET label=$1, description=$2, propertytypegroupid=$3 WHERE id=$4`
|
|
_, err := vr.db.Exec(query, propertyType.Label, propertyType.Description, propertyType.PropertyTypeGroupID, propertyType.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) DeletePropertyType(id int) error {
|
|
// Implement the logic to delete the propertyType from the database
|
|
query := `DELETE FROM propertytypes WHERE id=$1`
|
|
_, err := vr.db.Exec(query, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetPropertyType(id int) (*models.PropertyType, error) {
|
|
// Implement the logic to retrieve the propertyType from the database
|
|
query := `SELECT id, label, description, propertytypegroupid FROM propertytypes WHERE id=$1`
|
|
row := vr.db.QueryRow(query, id)
|
|
var propertyType models.PropertyType
|
|
err := row.Scan(&propertyType.ID, &propertyType.Label, &propertyType.Description, &propertyType.PropertyTypeGroupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &propertyType, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetPropertyTypeIDByLabel(label string) (int, error) {
|
|
// Implement the logic to retrieve the propertyType ID from the database by label
|
|
query := `SELECT id FROM propertytypes WHERE label=$1`
|
|
row := vr.db.QueryRow(query, label)
|
|
var id int
|
|
err := row.Scan(&id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetPropertyTypesByGroupId(groupId int) ([]*models.PropertyType, error) {
|
|
// Implement the logic to retrieve the propertyTypes by groupId from the database
|
|
query := `SELECT id, label, description, propertytypegroupid FROM propertytypes WHERE propertytypegroupid=$1`
|
|
rows, err := vr.db.Query(query, groupId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var propertyTypes []*models.PropertyType
|
|
for rows.Next() {
|
|
var propertyType models.PropertyType
|
|
err := rows.Scan(&propertyType.ID, &propertyType.Label, &propertyType.Description, &propertyType.PropertyTypeGroupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
propertyTypes = append(propertyTypes, &propertyType)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return propertyTypes, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) CreateValueForPropertyTypeId(propertyTypeId int, value *models.Value) (*models.Value, error) {
|
|
// Implement the logic to insert the value into the database for the given propertyTypeId
|
|
query := `INSERT INTO values(propertyid, label, description) VALUES($1,$2,$3) RETURNING id`
|
|
err := vr.db.QueryRow(query, propertyTypeId, value.Label, value.Description).Scan(&value.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) DeleteValueFromPropertyTypeId(propertyTypeId int) error {
|
|
// Implement the logic to delete the value from the database for the given propertyTypeId
|
|
query := `DELETE FROM values WHERE propertid=$1`
|
|
_, err := vr.db.Exec(query, propertyTypeId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetValuesFromPropertyTypeId(propertyTypeId int) ([]*models.Value, error) {
|
|
// Implement the logic to retrieve the values from the database for the given propertyTypeId
|
|
query := `SELECT id, label, description FROM values WHERE propertyid=$1`
|
|
rows, err := vr.db.Query(query, propertyTypeId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var values []*models.Value
|
|
for rows.Next() {
|
|
var value models.Value
|
|
err := rows.Scan(&value.ID, &value.Label, &value.Description)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
values = append(values, &value)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) CreatePropertyFromPropertyTypeId(propertyTypeId int, productGroupId int, productId int) (models.Property, error) {
|
|
// Implement the logic to create a property from the given propertyTypeId
|
|
query := `INSERT INTO properties(label, description, propertytypeid) SELECT label, description, id FROM propertytypes WHERE id=$1 RETURNING id, label, description`
|
|
var property models.Property
|
|
err := vr.db.QueryRow(query, propertyTypeId).Scan(&property.ID, &property.Label, &property.Description)
|
|
if err != nil {
|
|
return models.Property{}, err
|
|
}
|
|
property.PropertyTypeID = propertyTypeId
|
|
property.ProductGroupID = productGroupId
|
|
property.ProductID = productId
|
|
err = vr.db.QueryRow(`UPDATE properties SET productgroupid=$1, productid=$2 WHERE id=$3 RETURNING id`, productGroupId, productId, property.ID).Scan(&property.ID)
|
|
if err != nil {
|
|
return models.Property{}, err
|
|
}
|
|
|
|
err = vr.copyValuesFromPropertyTypeToProperty(propertyTypeId, property.ID)
|
|
if err != nil {
|
|
return models.Property{}, err
|
|
}
|
|
|
|
return property, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetValuesFromPropertyId(propertyId int) ([]*models.Value, error) {
|
|
// Implement the logic to retrieve the values from the database for the given propertyId
|
|
query := `SELECT id, label, description, propertyId FROM values WHERE propertyId=$1`
|
|
rows, err := vr.db.Query(query, propertyId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var values []*models.Value
|
|
for rows.Next() {
|
|
var value models.Value
|
|
err := rows.Scan(&value.ID, &value.Label, &value.Description, &value.PropertyID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
values = append(values, &value)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) CreateValueForPropertyId(propertyId int, value *models.Value) (*models.Value, error) {
|
|
// Implement the logic to create a value for the given propertyId
|
|
query := `INSERT INTO values (propertyId, label, description) VALUES ($1, $2, $3) RETURNING id`
|
|
err := vr.db.QueryRow(query, propertyId, value.Label, value.Description).Scan(&value.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) DeleteValueFromPropertyId(valueId int, propertyId int) error {
|
|
// Implement the logic to delete the value from the database for the given valueId and propertyId
|
|
query := `DELETE FROM values WHERE id=$1 AND propertyId=$2`
|
|
_, err := vr.db.Exec(query, valueId, propertyId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) GetValue(id int) (*models.Value, error) {
|
|
// Implement the logic to retrieve the value from the database for the given id
|
|
query := `SELECT id, label, description FROM values WHERE id=$1`
|
|
row := vr.db.QueryRow(query, id)
|
|
var value models.Value
|
|
err := row.Scan(&value.ID, &value.Label, &value.Description)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &value, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) createPropertyFromPropertyType(productGroupId int, productId int, propertyType *models.PropertyType) (*models.Property, error) {
|
|
query := `INSERT INTO properties (label, description, propertytypeid, productid, productgroupid) VALUES ($1, $2, $3, $4, $5) RETURNING id`
|
|
var property models.Property
|
|
err := vr.db.QueryRow(query, propertyType.Label, propertyType.Description, propertyType.ID, productId, productGroupId).Scan(&property.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
property.Label = propertyType.Label
|
|
property.Description = propertyType.Description
|
|
property.PropertyTypeID = propertyType.ID
|
|
property.ProductID = productId
|
|
property.ProductGroupID = productGroupId
|
|
|
|
// Copy values from property type to property
|
|
err = vr.copyValuesFromPropertyTypeToProperty(propertyType.ID, property.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &property, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) createPropertyFromProperty(productGroupId int, productId int, property *models.Property) (*models.Property, error) {
|
|
query := `INSERT INTO properties (label, description, propertytypeid, productid, productgroupid) VALUES ($1, $2, $3, $4, $5) RETURNING id`
|
|
var newProperty models.Property
|
|
err := vr.db.QueryRow(query, property.Label, property.Description, property.PropertyTypeID, productId, productGroupId).Scan(&newProperty.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
newProperty.Label = property.Label
|
|
newProperty.Description = property.Description
|
|
newProperty.PropertyTypeID = property.PropertyTypeID
|
|
newProperty.ProductID = productId
|
|
newProperty.ProductGroupID = productGroupId
|
|
|
|
// Copy values from property type to property
|
|
err = vr.copyValuesFromPropertyToProperty(property.ID, newProperty.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &newProperty, nil
|
|
}
|
|
|
|
func (vr *ValueRepository) copyValuesFromPropertyTypeToProperty(propertyTypeId int, propertyId int) error {
|
|
// Implement the logic to copy values from a property type to a property
|
|
query := `INSERT INTO values (propertyId, label, description) SELECT $1, label, description FROM values WHERE propertyid=$2`
|
|
_, err := vr.db.Exec(query, propertyId, propertyTypeId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) copyValuesFromPropertyToProperty(propertyIdFrom int, propertyIdTo int) error {
|
|
// Implement the logic to copy values from one property to another
|
|
query := `INSERT INTO values (propertyId, label, description) SELECT $1, label, description FROM values WHERE propertyId=$2`
|
|
_, err := vr.db.Exec(query, propertyIdTo, propertyIdFrom)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) CreateTerminalPropertyForProductGroupId(productGroupId int, propertyTypeId int, value string) error {
|
|
// Create a new property for the given productGroupId and propertyTypeId
|
|
propertyType, err := vr.GetPropertyType(propertyTypeId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
query := `INSERT INTO properties(label, description, propertytypeid, productgroupid, value) VALUES($1, $2, $3, $4) RETURNING id`
|
|
var property models.Property
|
|
err = vr.db.QueryRow(query, propertyType.Label, propertyType.Description, propertyTypeId, productGroupId).Scan(&property.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = vr.db.QueryRow(`INSERT INTO values(propertyid, label, description) VALUES($1, $2, $3) RETURNING id`, property.ID, value, "").Scan(&property.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (vr *ValueRepository) CreateTerminalPropertyForProductId(productId int, propertyTypeId int, value string) error {
|
|
// Create a new property for the given productGroupId and propertyTypeId
|
|
propertyType, err := vr.GetPropertyType(propertyTypeId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
query := `INSERT INTO properties(label, description, propertytypeid, productid, value) VALUES($1, $2, $3, $4, $5) RETURNING id`
|
|
var property models.Property
|
|
err = vr.db.QueryRow(query, propertyType.Label, propertyType.Description, propertyTypeId, productId, value).Scan(&property.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = vr.db.QueryRow(`INSERT INTO values(propertyid, label, description) VALUES($1, $2, $3) RETURNING id`, property.ID, value, "").Scan(&property.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
}
|
|
|
|
func (vr *ValueRepository) SetTerminalValueForProperty(propertyId int, value string) error {
|
|
// Implement the logic to set a terminal value for a property
|
|
// remove all values from the property
|
|
_, err := vr.db.Exec(`DELETE FROM values WHERE propertyid=$1`, propertyId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// add the new value to the property
|
|
_, err = vr.db.Exec(`INSERT INTO values(propertyid, label, description) VALUES($1, $2, $3)`, propertyId, value, "")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|