package entity

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"

	"github.com/pingcap/errors"
)

func (j *PackageUnits) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := PackageUnits{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j PackageUnits) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *Labels) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := Labels{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j Labels) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *ExpressionLabels) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := ExpressionLabels{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j ExpressionLabels) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *PricingInfos) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := PricingInfos{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j PricingInfos) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *ClosePolicy) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := ClosePolicy{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j ClosePolicy) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *CloseActionsStatus) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := CloseActionsStatus{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j CloseActionsStatus) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *UnitFilters) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := UnitFilters{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j UnitFilters) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *RechargeCreditsPlanRule) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := RechargeCreditsPlanRule{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j RechargeCreditsPlanRule) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *DimensionValue) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := DimensionValue{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j DimensionValue) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *EditionDimensionValue) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := EditionDimensionValue{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j EditionDimensionValue) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *Unit) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := Unit{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j Unit) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *AdjustmentMeta) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := AdjustmentMeta{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j AdjustmentMeta) Value() (driver.Value, error) {
	return json.Marshal(j)
}
func (j *OrderMap) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := OrderMap{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j OrderMap) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *PaymentMeta) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := PaymentMeta{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j PaymentMeta) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *InvoiceMeta) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := InvoiceMeta{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j InvoiceMeta) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *BillingAddress) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := BillingAddress{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j BillingAddress) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *CopyUnitFilterArgs) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := CopyUnitFilterArgs{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j CopyUnitFilterArgs) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *StringSlice) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}
	result := StringSlice{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j StringSlice) Value() (driver.Value, error) {
	return json.Marshal(j)
}

func (j *TieredPriceRules) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprint("Failed to unmarshal JSON value:", value))
	}

	result := TieredPriceRules{}
	err := json.Unmarshal(bytes, &result)
	if err != nil {
		return errors.AddStack(err)
	}
	*j = result
	return nil
}

func (j TieredPriceRules) Value() (driver.Value, error) {
	return json.Marshal(j)
}