package pb

import (
	context "context"
	fmt "fmt"
	errors "github.com/infobloxopen/protoc-gen-gorm/errors"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
	gorm "gorm.io/gorm"
)

type UserORM struct {
	Bio      string
	Id       uint64
	Username string
}

// TableName overrides the default tablename generated by GORM
func (UserORM) TableName() string {
	return "users"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *User) ToORM(ctx context.Context) (UserORM, error) {
	to := UserORM{}
	var err error
	if prehook, ok := interface{}(m).(UserWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.Username = m.Username
	to.Bio = m.Bio
	if posthook, ok := interface{}(m).(UserWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *UserORM) ToPB(ctx context.Context) (User, error) {
	to := User{}
	var err error
	if prehook, ok := interface{}(m).(UserWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.Username = m.Username
	to.Bio = m.Bio
	if posthook, ok := interface{}(m).(UserWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type User the arg will be the target, the caller the one being converted from

// UserBeforeToORM called before default ToORM code
type UserWithBeforeToORM interface {
	BeforeToORM(context.Context, *UserORM) error
}

// UserAfterToORM called after default ToORM code
type UserWithAfterToORM interface {
	AfterToORM(context.Context, *UserORM) error
}

// UserBeforeToPB called before default ToPB code
type UserWithBeforeToPB interface {
	BeforeToPB(context.Context, *User) error
}

// UserAfterToPB called after default ToPB code
type UserWithAfterToPB interface {
	AfterToPB(context.Context, *User) error
}

type ProductORM struct {
	Description string
	Id          uint64
	Name        string
	Price       float32
}

// TableName overrides the default tablename generated by GORM
func (ProductORM) TableName() string {
	return "products"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *Product) ToORM(ctx context.Context) (ProductORM, error) {
	to := ProductORM{}
	var err error
	if prehook, ok := interface{}(m).(ProductWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.Name = m.Name
	to.Description = m.Description
	to.Price = m.Price
	if posthook, ok := interface{}(m).(ProductWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *ProductORM) ToPB(ctx context.Context) (Product, error) {
	to := Product{}
	var err error
	if prehook, ok := interface{}(m).(ProductWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.Name = m.Name
	to.Description = m.Description
	to.Price = m.Price
	if posthook, ok := interface{}(m).(ProductWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type Product the arg will be the target, the caller the one being converted from

// ProductBeforeToORM called before default ToORM code
type ProductWithBeforeToORM interface {
	BeforeToORM(context.Context, *ProductORM) error
}

// ProductAfterToORM called after default ToORM code
type ProductWithAfterToORM interface {
	AfterToORM(context.Context, *ProductORM) error
}

// ProductBeforeToPB called before default ToPB code
type ProductWithBeforeToPB interface {
	BeforeToPB(context.Context, *Product) error
}

// ProductAfterToPB called after default ToPB code
type ProductWithAfterToPB interface {
	AfterToPB(context.Context, *Product) error
}

// DefaultCreateUser executes a basic gorm create call
func DefaultCreateUser(ctx context.Context, in *User, db *gorm.DB) (*User, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type UserORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadUser(ctx context.Context, in *User, db *gorm.DB) (*User, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == 0 {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := UserORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(UserORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type UserORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteUser(ctx context.Context, in *User, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == 0 {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&UserORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type UserORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteUserSet(ctx context.Context, in []*User, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []uint64{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == 0 {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&UserORM{})).(UserORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&UserORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&UserORM{})).(UserORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type UserORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*User, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*User, *gorm.DB) error
}

// DefaultStrictUpdateUser clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateUser(ctx context.Context, in *User, db *gorm.DB) (*User, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateUser")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	lockedRow := &UserORM{}
	db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow)
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	return &pbResponse, err
}

type UserORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchUser executes a basic gorm update call with patch behavior
func DefaultPatchUser(ctx context.Context, in *User, updateMask *field_mask.FieldMask, db *gorm.DB) (*User, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj User
	var err error
	if hook, ok := interface{}(&pbObj).(UserWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadUser(ctx, &User{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(UserWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskUser(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(UserWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateUser(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(UserWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type UserWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *User, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type UserWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *User, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type UserWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *User, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type UserWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *User, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetUser executes a bulk gorm update call with patch behavior
func DefaultPatchSetUser(ctx context.Context, objects []*User, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*User, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*User, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchUser(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskUser patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskUser(ctx context.Context, patchee *User, patcher *User, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*User, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"Username" {
			patchee.Username = patcher.Username
			continue
		}
		if f == prefix+"Bio" {
			patchee.Bio = patcher.Bio
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListUser executes a gorm list call
func DefaultListUser(ctx context.Context, db *gorm.DB) ([]*User, error) {
	in := User{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []UserORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(UserORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*User{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type UserORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type UserORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]UserORM) error
}

// DefaultCreateProduct executes a basic gorm create call
func DefaultCreateProduct(ctx context.Context, in *Product, db *gorm.DB) (*Product, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type ProductORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadProduct(ctx context.Context, in *Product, db *gorm.DB) (*Product, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == 0 {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := ProductORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(ProductORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type ProductORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteProduct(ctx context.Context, in *Product, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == 0 {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&ProductORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type ProductORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteProductSet(ctx context.Context, in []*Product, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []uint64{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == 0 {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&ProductORM{})).(ProductORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&ProductORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&ProductORM{})).(ProductORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type ProductORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Product, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Product, *gorm.DB) error
}

// DefaultStrictUpdateProduct clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateProduct(ctx context.Context, in *Product, db *gorm.DB) (*Product, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateProduct")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	lockedRow := &ProductORM{}
	db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow)
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	return &pbResponse, err
}

type ProductORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchProduct executes a basic gorm update call with patch behavior
func DefaultPatchProduct(ctx context.Context, in *Product, updateMask *field_mask.FieldMask, db *gorm.DB) (*Product, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj Product
	var err error
	if hook, ok := interface{}(&pbObj).(ProductWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadProduct(ctx, &Product{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(ProductWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskProduct(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(ProductWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateProduct(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(ProductWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type ProductWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Product, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type ProductWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Product, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type ProductWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Product, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type ProductWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Product, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetProduct executes a bulk gorm update call with patch behavior
func DefaultPatchSetProduct(ctx context.Context, objects []*Product, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*Product, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*Product, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchProduct(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskProduct patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskProduct(ctx context.Context, patchee *Product, patcher *Product, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*Product, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"Name" {
			patchee.Name = patcher.Name
			continue
		}
		if f == prefix+"Description" {
			patchee.Description = patcher.Description
			continue
		}
		if f == prefix+"Price" {
			patchee.Price = patcher.Price
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListProduct executes a gorm list call
func DefaultListProduct(ctx context.Context, db *gorm.DB) ([]*Product, error) {
	in := Product{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []ProductORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(ProductORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*Product{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type ProductORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type ProductORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]ProductORM) error
}
type PeachDefaultServer struct {
	DB *gorm.DB
}

// CreateUser ...
func (m *PeachDefaultServer) CreateUser(ctx context.Context, in *CreateUserRequest) (*CreateUserResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachUserWithBeforeCreateUser); ok {
		var err error
		if db, err = custom.BeforeCreateUser(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultCreateUser(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &CreateUserResponse{Result: res}
	if custom, ok := interface{}(in).(PeachUserWithAfterCreateUser); ok {
		var err error
		if err = custom.AfterCreateUser(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachUserWithBeforeCreateUser called before DefaultCreateUserUser in the default CreateUser handler
type PeachUserWithBeforeCreateUser interface {
	BeforeCreateUser(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachUserWithAfterCreateUser called before DefaultCreateUserUser in the default CreateUser handler
type PeachUserWithAfterCreateUser interface {
	AfterCreateUser(context.Context, *CreateUserResponse, *gorm.DB) error
}

// ReadUser ...
func (m *PeachDefaultServer) ReadUser(ctx context.Context, in *ReadUserRequest) (*ReadUserResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachUserWithBeforeReadUser); ok {
		var err error
		if db, err = custom.BeforeReadUser(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultReadUser(ctx, &User{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &ReadUserResponse{Result: res}
	if custom, ok := interface{}(in).(PeachUserWithAfterReadUser); ok {
		var err error
		if err = custom.AfterReadUser(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachUserWithBeforeReadUser called before DefaultReadUserUser in the default ReadUser handler
type PeachUserWithBeforeReadUser interface {
	BeforeReadUser(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachUserWithAfterReadUser called before DefaultReadUserUser in the default ReadUser handler
type PeachUserWithAfterReadUser interface {
	AfterReadUser(context.Context, *ReadUserResponse, *gorm.DB) error
}

// ListUsers ...
func (m *PeachDefaultServer) ListUsers(ctx context.Context, in *ListUsersRequest) (*ListUsersResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachUserWithBeforeListUsers); ok {
		var err error
		if db, err = custom.BeforeListUsers(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultListUser(ctx, db)
	if err != nil {
		return nil, err
	}
	out := &ListUsersResponse{Results: res}
	if custom, ok := interface{}(in).(PeachUserWithAfterListUsers); ok {
		var err error
		if err = custom.AfterListUsers(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachUserWithBeforeListUsers called before DefaultListUsersUser in the default ListUsers handler
type PeachUserWithBeforeListUsers interface {
	BeforeListUsers(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachUserWithAfterListUsers called before DefaultListUsersUser in the default ListUsers handler
type PeachUserWithAfterListUsers interface {
	AfterListUsers(context.Context, *ListUsersResponse, *gorm.DB) error
}

// UpdateUser ...
func (m *PeachDefaultServer) UpdateUser(ctx context.Context, in *UpdateUserRequest) (*UpdateUserResponse, error) {
	var err error
	var res *User
	db := m.DB
	if custom, ok := interface{}(in).(PeachUserWithBeforeUpdateUser); ok {
		var err error
		if db, err = custom.BeforeUpdateUser(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err = DefaultStrictUpdateUser(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &UpdateUserResponse{Result: res}
	if custom, ok := interface{}(in).(PeachUserWithAfterUpdateUser); ok {
		var err error
		if err = custom.AfterUpdateUser(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachUserWithBeforeUpdateUser called before DefaultUpdateUserUser in the default UpdateUser handler
type PeachUserWithBeforeUpdateUser interface {
	BeforeUpdateUser(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachUserWithAfterUpdateUser called before DefaultUpdateUserUser in the default UpdateUser handler
type PeachUserWithAfterUpdateUser interface {
	AfterUpdateUser(context.Context, *UpdateUserResponse, *gorm.DB) error
}

// DeleteUser ...
func (m *PeachDefaultServer) DeleteUser(ctx context.Context, in *DeleteUserRequest) (*DeleteUserResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachUserWithBeforeDeleteUser); ok {
		var err error
		if db, err = custom.BeforeDeleteUser(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteUser(ctx, &User{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteUserResponse{}
	if custom, ok := interface{}(in).(PeachUserWithAfterDeleteUser); ok {
		var err error
		if err = custom.AfterDeleteUser(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachUserWithBeforeDeleteUser called before DefaultDeleteUserUser in the default DeleteUser handler
type PeachUserWithBeforeDeleteUser interface {
	BeforeDeleteUser(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachUserWithAfterDeleteUser called before DefaultDeleteUserUser in the default DeleteUser handler
type PeachUserWithAfterDeleteUser interface {
	AfterDeleteUser(context.Context, *DeleteUserResponse, *gorm.DB) error
}

// CreateProduct ...
func (m *PeachDefaultServer) CreateProduct(ctx context.Context, in *CreateProductRequest) (*CreateProductResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachProductWithBeforeCreateProduct); ok {
		var err error
		if db, err = custom.BeforeCreateProduct(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultCreateProduct(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &CreateProductResponse{Result: res}
	if custom, ok := interface{}(in).(PeachProductWithAfterCreateProduct); ok {
		var err error
		if err = custom.AfterCreateProduct(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachProductWithBeforeCreateProduct called before DefaultCreateProductProduct in the default CreateProduct handler
type PeachProductWithBeforeCreateProduct interface {
	BeforeCreateProduct(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachProductWithAfterCreateProduct called before DefaultCreateProductProduct in the default CreateProduct handler
type PeachProductWithAfterCreateProduct interface {
	AfterCreateProduct(context.Context, *CreateProductResponse, *gorm.DB) error
}

// ReadProduct ...
func (m *PeachDefaultServer) ReadProduct(ctx context.Context, in *ReadProductRequest) (*ReadProductResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachProductWithBeforeReadProduct); ok {
		var err error
		if db, err = custom.BeforeReadProduct(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultReadProduct(ctx, &Product{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &ReadProductResponse{Result: res}
	if custom, ok := interface{}(in).(PeachProductWithAfterReadProduct); ok {
		var err error
		if err = custom.AfterReadProduct(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachProductWithBeforeReadProduct called before DefaultReadProductProduct in the default ReadProduct handler
type PeachProductWithBeforeReadProduct interface {
	BeforeReadProduct(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachProductWithAfterReadProduct called before DefaultReadProductProduct in the default ReadProduct handler
type PeachProductWithAfterReadProduct interface {
	AfterReadProduct(context.Context, *ReadProductResponse, *gorm.DB) error
}

// ListProducts ...
func (m *PeachDefaultServer) ListProducts(ctx context.Context, in *ListProductsRequest) (*ListProductsResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachProductWithBeforeListProducts); ok {
		var err error
		if db, err = custom.BeforeListProducts(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultListProduct(ctx, db)
	if err != nil {
		return nil, err
	}
	out := &ListProductsResponse{Results: res}
	if custom, ok := interface{}(in).(PeachProductWithAfterListProducts); ok {
		var err error
		if err = custom.AfterListProducts(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachProductWithBeforeListProducts called before DefaultListProductsProduct in the default ListProducts handler
type PeachProductWithBeforeListProducts interface {
	BeforeListProducts(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachProductWithAfterListProducts called before DefaultListProductsProduct in the default ListProducts handler
type PeachProductWithAfterListProducts interface {
	AfterListProducts(context.Context, *ListProductsResponse, *gorm.DB) error
}

// UpdateProduct ...
func (m *PeachDefaultServer) UpdateProduct(ctx context.Context, in *UpdateProductRequest) (*UpdateProductResponse, error) {
	var err error
	var res *Product
	db := m.DB
	if custom, ok := interface{}(in).(PeachProductWithBeforeUpdateProduct); ok {
		var err error
		if db, err = custom.BeforeUpdateProduct(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err = DefaultStrictUpdateProduct(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &UpdateProductResponse{Result: res}
	if custom, ok := interface{}(in).(PeachProductWithAfterUpdateProduct); ok {
		var err error
		if err = custom.AfterUpdateProduct(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachProductWithBeforeUpdateProduct called before DefaultUpdateProductProduct in the default UpdateProduct handler
type PeachProductWithBeforeUpdateProduct interface {
	BeforeUpdateProduct(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachProductWithAfterUpdateProduct called before DefaultUpdateProductProduct in the default UpdateProduct handler
type PeachProductWithAfterUpdateProduct interface {
	AfterUpdateProduct(context.Context, *UpdateProductResponse, *gorm.DB) error
}

// DeleteProduct ...
func (m *PeachDefaultServer) DeleteProduct(ctx context.Context, in *DeleteProductRequest) (*DeleteProductResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(PeachProductWithBeforeDeleteProduct); ok {
		var err error
		if db, err = custom.BeforeDeleteProduct(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteProduct(ctx, &Product{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteProductResponse{}
	if custom, ok := interface{}(in).(PeachProductWithAfterDeleteProduct); ok {
		var err error
		if err = custom.AfterDeleteProduct(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// PeachProductWithBeforeDeleteProduct called before DefaultDeleteProductProduct in the default DeleteProduct handler
type PeachProductWithBeforeDeleteProduct interface {
	BeforeDeleteProduct(context.Context, *gorm.DB) (*gorm.DB, error)
}

// PeachProductWithAfterDeleteProduct called before DefaultDeleteProductProduct in the default DeleteProduct handler
type PeachProductWithAfterDeleteProduct interface {
	AfterDeleteProduct(context.Context, *DeleteProductResponse, *gorm.DB) error
}