demo_service.pb.gorm.go

package example

import (
	context "context"
	json "encoding/json"
	fmt "fmt"
	gateway "github.com/infobloxopen/atlas-app-toolkit/gateway"
	gorm1 "github.com/infobloxopen/atlas-app-toolkit/gorm"
	query "github.com/infobloxopen/atlas-app-toolkit/query"
	errors "github.com/MichaelSkuratovichNS/protoc-gen-gorm/errors"
	trace "go.opencensus.io/trace"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	gorm "gorm.io/gorm"
)

type IntPointORM struct {
	Id uint32
	X  int32
	Y  int32
}

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

// 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 *IntPoint) ToORM(ctx context.Context) (IntPointORM, error) {
	to := IntPointORM{}
	var err error
	if prehook, ok := interface{}(m).(IntPointWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.X = m.X
	to.Y = m.Y
	if posthook, ok := interface{}(m).(IntPointWithAfterToORM); 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 *IntPointORM) ToPB(ctx context.Context) (IntPoint, error) {
	to := IntPoint{}
	var err error
	if prehook, ok := interface{}(m).(IntPointWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.X = m.X
	to.Y = m.Y
	if posthook, ok := interface{}(m).(IntPointWithAfterToPB); 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 IntPoint the arg will be the target, the caller the one being converted from

// IntPointBeforeToORM called before default ToORM code
type IntPointWithBeforeToORM interface {
	BeforeToORM(context.Context, *IntPointORM) error
}

// IntPointAfterToORM called after default ToORM code
type IntPointWithAfterToORM interface {
	AfterToORM(context.Context, *IntPointORM) error
}

// IntPointBeforeToPB called before default ToPB code
type IntPointWithBeforeToPB interface {
	BeforeToPB(context.Context, *IntPoint) error
}

// IntPointAfterToPB called after default ToPB code
type IntPointWithAfterToPB interface {
	AfterToPB(context.Context, *IntPoint) error
}

type SomethingORM struct {
	Field string
}

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

// 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 *Something) ToORM(ctx context.Context) (SomethingORM, error) {
	to := SomethingORM{}
	var err error
	if prehook, ok := interface{}(m).(SomethingWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Field = m.Field
	if posthook, ok := interface{}(m).(SomethingWithAfterToORM); 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 *SomethingORM) ToPB(ctx context.Context) (Something, error) {
	to := Something{}
	var err error
	if prehook, ok := interface{}(m).(SomethingWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Field = m.Field
	if posthook, ok := interface{}(m).(SomethingWithAfterToPB); 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 Something the arg will be the target, the caller the one being converted from

// SomethingBeforeToORM called before default ToORM code
type SomethingWithBeforeToORM interface {
	BeforeToORM(context.Context, *SomethingORM) error
}

// SomethingAfterToORM called after default ToORM code
type SomethingWithAfterToORM interface {
	AfterToORM(context.Context, *SomethingORM) error
}

// SomethingBeforeToPB called before default ToPB code
type SomethingWithBeforeToPB interface {
	BeforeToPB(context.Context, *Something) error
}

// SomethingAfterToPB called after default ToPB code
type SomethingWithAfterToPB interface {
	AfterToPB(context.Context, *Something) error
}

type CircleORM struct {
	R uint32
}

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

// 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 *Circle) ToORM(ctx context.Context) (CircleORM, error) {
	to := CircleORM{}
	var err error
	if prehook, ok := interface{}(m).(CircleWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.R = m.R
	if posthook, ok := interface{}(m).(CircleWithAfterToORM); 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 *CircleORM) ToPB(ctx context.Context) (Circle, error) {
	to := Circle{}
	var err error
	if prehook, ok := interface{}(m).(CircleWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.R = m.R
	if posthook, ok := interface{}(m).(CircleWithAfterToPB); 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 Circle the arg will be the target, the caller the one being converted from

// CircleBeforeToORM called before default ToORM code
type CircleWithBeforeToORM interface {
	BeforeToORM(context.Context, *CircleORM) error
}

// CircleAfterToORM called after default ToORM code
type CircleWithAfterToORM interface {
	AfterToORM(context.Context, *CircleORM) error
}

// CircleBeforeToPB called before default ToPB code
type CircleWithBeforeToPB interface {
	BeforeToPB(context.Context, *Circle) error
}

// CircleAfterToPB called after default ToPB code
type CircleWithAfterToPB interface {
	AfterToPB(context.Context, *Circle) error
}

// DefaultCreateIntPoint executes a basic gorm create call
func DefaultCreateIntPoint(ctx context.Context, in *IntPoint, db *gorm.DB) (*IntPoint, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeCreate_); 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).(IntPointORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

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

func DefaultReadIntPoint(ctx context.Context, in *IntPoint, db *gorm.DB, fs *query.FieldSelection) (*IntPoint, 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).(IntPointORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db, fs); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, fs, &IntPointORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db, fs); err != nil {
			return nil, err
		}
	}
	ormResponse := IntPointORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(IntPointORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db, fs); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type IntPointORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB, *query.FieldSelection) (*gorm.DB, error)
}
type IntPointORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB, *query.FieldSelection) (*gorm.DB, error)
}
type IntPointORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB, *query.FieldSelection) error
}

func DefaultDeleteIntPoint(ctx context.Context, in *IntPoint, 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).(IntPointORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&IntPointORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

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

func DefaultDeleteIntPointSet(ctx context.Context, in []*IntPoint, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []uint32{}
	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{}(&IntPointORM{})).(IntPointORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&IntPointORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&IntPointORM{})).(IntPointORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type IntPointORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*IntPoint, *gorm.DB) (*gorm.DB, error)
}
type IntPointORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*IntPoint, *gorm.DB) error
}

// DefaultStrictUpdateIntPoint clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateIntPoint(ctx context.Context, in *IntPoint, db *gorm.DB) (*IntPoint, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateIntPoint")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &IntPointORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeStrictUpdateSave); 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).(IntPointORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type IntPointORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type IntPointORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type IntPointORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchIntPoint executes a basic gorm update call with patch behavior
func DefaultPatchIntPoint(ctx context.Context, in *IntPoint, updateMask *field_mask.FieldMask, db *gorm.DB) (*IntPoint, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj IntPoint
	var err error
	if hook, ok := interface{}(&pbObj).(IntPointWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadIntPoint(ctx, &IntPoint{Id: in.GetId()}, db, nil)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(IntPointWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskIntPoint(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(IntPointWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateIntPoint(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(IntPointWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type IntPointWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *IntPoint, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type IntPointWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *IntPoint, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type IntPointWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *IntPoint, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type IntPointWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *IntPoint, *field_mask.FieldMask, *gorm.DB) error
}

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

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

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskIntPoint patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskIntPoint(ctx context.Context, patchee *IntPoint, patcher *IntPoint, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*IntPoint, 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+"X" {
			patchee.X = patcher.X
			continue
		}
		if f == prefix+"Y" {
			patchee.Y = patcher.Y
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListIntPoint executes a gorm list call
func DefaultListIntPoint(ctx context.Context, db *gorm.DB, f *query.Filtering, s *query.Sorting, p *query.Pagination, fs *query.FieldSelection) ([]*IntPoint, error) {
	in := IntPoint{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db, f, s, p, fs); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &IntPointORM{}, &IntPoint{}, f, s, p, fs)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db, f, s, p, fs); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []IntPointORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(IntPointORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse, f, s, p, fs); err != nil {
			return nil, err
		}
	}
	pbResponse := []*IntPoint{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type IntPointORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB, *query.Filtering, *query.Sorting, *query.Pagination, *query.FieldSelection) (*gorm.DB, error)
}
type IntPointORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB, *query.Filtering, *query.Sorting, *query.Pagination, *query.FieldSelection) (*gorm.DB, error)
}
type IntPointORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]IntPointORM, *query.Filtering, *query.Sorting, *query.Pagination, *query.FieldSelection) error
}

// DefaultCreateSomething executes a basic gorm create call
func DefaultCreateSomething(ctx context.Context, in *Something, db *gorm.DB) (*Something, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(SomethingORMWithBeforeCreate_); 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).(SomethingORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

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

// DefaultApplyFieldMaskSomething patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskSomething(ctx context.Context, patchee *Something, patcher *Something, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*Something, 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+"Field" {
			patchee.Field = patcher.Field
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListSomething executes a gorm list call
func DefaultListSomething(ctx context.Context, db *gorm.DB) ([]*Something, error) {
	in := Something{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(SomethingORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &SomethingORM{}, &Something{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(SomethingORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	ormResponse := []SomethingORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(SomethingORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*Something{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type SomethingORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type SomethingORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type SomethingORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]SomethingORM) error
}

// DefaultCreateCircle executes a basic gorm create call
func DefaultCreateCircle(ctx context.Context, in *Circle, db *gorm.DB) (*Circle, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(CircleORMWithBeforeCreate_); 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).(CircleORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

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

// DefaultApplyFieldMaskCircle patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskCircle(ctx context.Context, patchee *Circle, patcher *Circle, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*Circle, 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+"R" {
			patchee.R = patcher.R
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListCircle executes a gorm list call
func DefaultListCircle(ctx context.Context, db *gorm.DB) ([]*Circle, error) {
	in := Circle{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(CircleORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &CircleORM{}, &Circle{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(CircleORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	ormResponse := []CircleORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(CircleORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*Circle{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type CircleORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type CircleORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type CircleORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]CircleORM) error
}
type IntPointServiceDefaultServer struct {
	DB *gorm.DB
}

// Create ...
func (m *IntPointServiceDefaultServer) Create(ctx context.Context, in *CreateIntPointRequest) (*CreateIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithBeforeCreate); ok {
		var err error
		if db, err = custom.BeforeCreate(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultCreateIntPoint(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &CreateIntPointResponse{Result: res}
	err = gateway.SetCreated(ctx, "")
	if err != nil {
		return nil, err
	}
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithAfterCreate); ok {
		var err error
		if err = custom.AfterCreate(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// IntPointServiceIntPointWithBeforeCreate called before DefaultCreateIntPoint in the default Create handler
type IntPointServiceIntPointWithBeforeCreate interface {
	BeforeCreate(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceIntPointWithAfterCreate called before DefaultCreateIntPoint in the default Create handler
type IntPointServiceIntPointWithAfterCreate interface {
	AfterCreate(context.Context, *CreateIntPointResponse, *gorm.DB) error
}

// Read ...
func (m *IntPointServiceDefaultServer) Read(ctx context.Context, in *ReadIntPointRequest) (*ReadIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithBeforeRead); ok {
		var err error
		if db, err = custom.BeforeRead(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultReadIntPoint(ctx, &IntPoint{Id: in.GetId()}, db, in.Fields)
	if err != nil {
		return nil, err
	}
	out := &ReadIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithAfterRead); ok {
		var err error
		if err = custom.AfterRead(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// IntPointServiceIntPointWithBeforeRead called before DefaultReadIntPoint in the default Read handler
type IntPointServiceIntPointWithBeforeRead interface {
	BeforeRead(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceIntPointWithAfterRead called before DefaultReadIntPoint in the default Read handler
type IntPointServiceIntPointWithAfterRead interface {
	AfterRead(context.Context, *ReadIntPointResponse, *gorm.DB) error
}

// Update ...
func (m *IntPointServiceDefaultServer) Update(ctx context.Context, in *UpdateIntPointRequest) (*UpdateIntPointResponse, error) {
	var err error
	var res *IntPoint
	db := m.DB
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithBeforeUpdate); ok {
		var err error
		if db, err = custom.BeforeUpdate(ctx, db); err != nil {
			return nil, err
		}
	}
	if in.GetGerogeriGegege() == nil {
		res, err = DefaultStrictUpdateIntPoint(ctx, in.GetPayload(), db)
	} else {
		res, err = DefaultPatchIntPoint(ctx, in.GetPayload(), in.GetGerogeriGegege(), db)
	}
	if err != nil {
		return nil, err
	}
	out := &UpdateIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithAfterUpdate); ok {
		var err error
		if err = custom.AfterUpdate(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// IntPointServiceIntPointWithBeforeUpdate called before DefaultUpdateIntPoint in the default Update handler
type IntPointServiceIntPointWithBeforeUpdate interface {
	BeforeUpdate(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceIntPointWithAfterUpdate called before DefaultUpdateIntPoint in the default Update handler
type IntPointServiceIntPointWithAfterUpdate interface {
	AfterUpdate(context.Context, *UpdateIntPointResponse, *gorm.DB) error
}

// UpdateSet ...
func (m *IntPointServiceDefaultServer) UpdateSet(ctx context.Context, in *UpdateSetIntPointRequest) (*UpdateSetIntPointResponse, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}

	db := m.DB

	if custom, ok := interface{}(in).(IntPointServiceIntPointWithBeforeUpdateSet); ok {
		var err error
		if db, err = custom.BeforeUpdateSet(ctx, db); err != nil {
			return nil, err
		}
	}

	res, err := DefaultPatchSetIntPoint(ctx, in.GetObjects(), in.GetMasks(), db)
	if err != nil {
		return nil, err
	}

	out := &UpdateSetIntPointResponse{Results: res}

	if custom, ok := interface{}(in).(IntPointServiceIntPointWithAfterUpdateSet); ok {
		var err error
		if err = custom.AfterUpdateSet(ctx, out, db); err != nil {
			return nil, err
		}
	}

	return out, nil
}

// IntPointServiceIntPointWithBeforeUpdateSet called before DefaultUpdateSetIntPoint in the default UpdateSet handler
type IntPointServiceIntPointWithBeforeUpdateSet interface {
	BeforeUpdateSet(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceIntPointWithAfterUpdateSet called before DefaultUpdateSetIntPoint in the default UpdateSet handler
type IntPointServiceIntPointWithAfterUpdateSet interface {
	AfterUpdateSet(context.Context, *UpdateSetIntPointResponse, *gorm.DB) error
}

// List ...
func (m *IntPointServiceDefaultServer) List(ctx context.Context, in *ListIntPointRequest) (*ListIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithBeforeList); ok {
		var err error
		if db, err = custom.BeforeList(ctx, db); err != nil {
			return nil, err
		}
	}
	pagedRequest := false
	if in.GetPaging().GetLimit() >= 1 {
		in.Paging.Limit++
		pagedRequest = true
	}
	res, err := DefaultListIntPoint(ctx, db, in.Filter, in.OrderBy, in.Paging, in.Fields)
	if err != nil {
		return nil, err
	}
	var resPaging *query.PageInfo
	if pagedRequest {
		var offset int32
		var size int32 = int32(len(res))
		if size == in.GetPaging().GetLimit() {
			size--
			res = res[:size]
			offset = in.GetPaging().GetOffset() + size
		}
		resPaging = &query.PageInfo{Offset: offset}
	}
	out := &ListIntPointResponse{Results: res, PageInfo: resPaging}
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithAfterList); ok {
		var err error
		if err = custom.AfterList(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// IntPointServiceIntPointWithBeforeList called before DefaultListIntPoint in the default List handler
type IntPointServiceIntPointWithBeforeList interface {
	BeforeList(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceIntPointWithAfterList called before DefaultListIntPoint in the default List handler
type IntPointServiceIntPointWithAfterList interface {
	AfterList(context.Context, *ListIntPointResponse, *gorm.DB) error
}

// ListSomething ...
func (m *IntPointServiceDefaultServer) ListSomething(ctx context.Context, in *emptypb.Empty) (*ListSomethingResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(IntPointServiceSomethingWithBeforeListSomething); ok {
		var err error
		if db, err = custom.BeforeListSomething(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultListSomething(ctx, db)
	if err != nil {
		return nil, err
	}
	out := &ListSomethingResponse{Results: res}
	if custom, ok := interface{}(in).(IntPointServiceSomethingWithAfterListSomething); ok {
		var err error
		if err = custom.AfterListSomething(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// IntPointServiceSomethingWithBeforeListSomething called before DefaultListSomethingSomething in the default ListSomething handler
type IntPointServiceSomethingWithBeforeListSomething interface {
	BeforeListSomething(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceSomethingWithAfterListSomething called before DefaultListSomethingSomething in the default ListSomething handler
type IntPointServiceSomethingWithAfterListSomething interface {
	AfterListSomething(context.Context, *ListSomethingResponse, *gorm.DB) error
}

// Delete ...
func (m *IntPointServiceDefaultServer) Delete(ctx context.Context, in *DeleteIntPointRequest) (*DeleteIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithBeforeDelete); ok {
		var err error
		if db, err = custom.BeforeDelete(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteIntPoint(ctx, &IntPoint{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(IntPointServiceIntPointWithAfterDelete); ok {
		var err error
		if err = custom.AfterDelete(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// IntPointServiceIntPointWithBeforeDelete called before DefaultDeleteIntPoint in the default Delete handler
type IntPointServiceIntPointWithBeforeDelete interface {
	BeforeDelete(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointServiceIntPointWithAfterDelete called before DefaultDeleteIntPoint in the default Delete handler
type IntPointServiceIntPointWithAfterDelete interface {
	AfterDelete(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}

// CustomMethod ...
func (m *IntPointServiceDefaultServer) CustomMethod(ctx context.Context, in *emptypb.Empty) (*emptypb.Empty, error) {
	out := &emptypb.Empty{}
	return out, nil
}

// CreateSomething ...
func (m *IntPointServiceDefaultServer) CreateSomething(ctx context.Context, in *Something) (*Something, error) {
	out := &Something{}
	return out, nil
}

type IntPointTxnDefaultServer struct {
}

func (m *IntPointTxnDefaultServer) spanCreate(ctx context.Context, in interface{}, methodName string) (*trace.Span, error) {
	_, span := trace.StartSpan(ctx, fmt.Sprint("IntPointTxnDefaultServer.", methodName))
	raw, err := json.Marshal(in)
	if err != nil {
		return nil, err
	}
	span.Annotate([]trace.Attribute{trace.StringAttribute("in", string(raw))}, "in parameter")
	return span, nil
}

// spanError ...
func (m *IntPointTxnDefaultServer) spanError(span *trace.Span, err error) error {
	span.SetStatus(trace.Status{
		Code:    trace.StatusCodeUnknown,
		Message: err.Error(),
	})
	return err
}

// spanResult ...
func (m *IntPointTxnDefaultServer) spanResult(span *trace.Span, out interface{}) error {
	raw, err := json.Marshal(out)
	if err != nil {
		return err
	}
	span.Annotate([]trace.Attribute{trace.StringAttribute("out", string(raw))}, "out parameter")
	return nil
}

// Create ...
func (m *IntPointTxnDefaultServer) Create(ctx context.Context, in *CreateIntPointRequest) (*CreateIntPointResponse, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "Create")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	txn, ok := gorm1.FromContext(ctx)
	if !ok {
		return nil, errors.NoTransactionError
	}
	db := txn.Begin()
	if db.Error != nil {
		return nil, db.Error
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithBeforeCreate); ok {
		var err error
		if db, err = custom.BeforeCreate(ctx, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	res, err := DefaultCreateIntPoint(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, m.spanError(span, err)
	}
	out := &CreateIntPointResponse{Result: res}
	err = gateway.SetCreated(ctx, "")
	if err != nil {
		return nil, m.spanError(span, err)
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithAfterCreate); ok {
		var err error
		if err = custom.AfterCreate(ctx, out, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// IntPointTxnIntPointWithBeforeCreate called before DefaultCreateIntPoint in the default Create handler
type IntPointTxnIntPointWithBeforeCreate interface {
	BeforeCreate(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointTxnIntPointWithAfterCreate called before DefaultCreateIntPoint in the default Create handler
type IntPointTxnIntPointWithAfterCreate interface {
	AfterCreate(context.Context, *CreateIntPointResponse, *gorm.DB) error
}

// Read ...
func (m *IntPointTxnDefaultServer) Read(ctx context.Context, in *ReadIntPointRequest) (*ReadIntPointResponse, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "Read")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	txn, ok := gorm1.FromContext(ctx)
	if !ok {
		return nil, errors.NoTransactionError
	}
	db := txn.Begin()
	if db.Error != nil {
		return nil, db.Error
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithBeforeRead); ok {
		var err error
		if db, err = custom.BeforeRead(ctx, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	res, err := DefaultReadIntPoint(ctx, &IntPoint{Id: in.GetId()}, db, in.Fields)
	if err != nil {
		return nil, m.spanError(span, err)
	}
	out := &ReadIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithAfterRead); ok {
		var err error
		if err = custom.AfterRead(ctx, out, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// IntPointTxnIntPointWithBeforeRead called before DefaultReadIntPoint in the default Read handler
type IntPointTxnIntPointWithBeforeRead interface {
	BeforeRead(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointTxnIntPointWithAfterRead called before DefaultReadIntPoint in the default Read handler
type IntPointTxnIntPointWithAfterRead interface {
	AfterRead(context.Context, *ReadIntPointResponse, *gorm.DB) error
}

// Update ...
func (m *IntPointTxnDefaultServer) Update(ctx context.Context, in *UpdateIntPointRequest) (*UpdateIntPointResponse, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "Update")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	var err error
	var res *IntPoint
	txn, ok := gorm1.FromContext(ctx)
	if !ok {
		return nil, errors.NoTransactionError
	}
	db := txn.Begin()
	if db.Error != nil {
		return nil, db.Error
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithBeforeUpdate); ok {
		var err error
		if db, err = custom.BeforeUpdate(ctx, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	if in.GetGerogeriGegege() == nil {
		res, err = DefaultStrictUpdateIntPoint(ctx, in.GetPayload(), db)
	} else {
		res, err = DefaultPatchIntPoint(ctx, in.GetPayload(), in.GetGerogeriGegege(), db)
	}
	if err != nil {
		return nil, m.spanError(span, err)
	}
	out := &UpdateIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithAfterUpdate); ok {
		var err error
		if err = custom.AfterUpdate(ctx, out, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// IntPointTxnIntPointWithBeforeUpdate called before DefaultUpdateIntPoint in the default Update handler
type IntPointTxnIntPointWithBeforeUpdate interface {
	BeforeUpdate(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointTxnIntPointWithAfterUpdate called before DefaultUpdateIntPoint in the default Update handler
type IntPointTxnIntPointWithAfterUpdate interface {
	AfterUpdate(context.Context, *UpdateIntPointResponse, *gorm.DB) error
}

// List ...
func (m *IntPointTxnDefaultServer) List(ctx context.Context, in *ListIntPointRequest) (*ListIntPointResponse, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "List")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	txn, ok := gorm1.FromContext(ctx)
	if !ok {
		return nil, errors.NoTransactionError
	}
	db := txn.Begin()
	if db.Error != nil {
		return nil, db.Error
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithBeforeList); ok {
		var err error
		if db, err = custom.BeforeList(ctx, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	pagedRequest := false
	if in.GetPaging().GetLimit() >= 1 {
		in.Paging.Limit++
		pagedRequest = true
	}
	res, err := DefaultListIntPoint(ctx, db, in.Filter, in.OrderBy, in.Paging, in.Fields)
	if err != nil {
		return nil, m.spanError(span, err)
	}
	var resPaging *query.PageInfo
	if pagedRequest {
		var offset int32
		var size int32 = int32(len(res))
		if size == in.GetPaging().GetLimit() {
			size--
			res = res[:size]
			offset = in.GetPaging().GetOffset() + size
		}
		resPaging = &query.PageInfo{Offset: offset}
	}
	out := &ListIntPointResponse{Results: res, PageInfo: resPaging}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithAfterList); ok {
		var err error
		if err = custom.AfterList(ctx, out, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// IntPointTxnIntPointWithBeforeList called before DefaultListIntPoint in the default List handler
type IntPointTxnIntPointWithBeforeList interface {
	BeforeList(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointTxnIntPointWithAfterList called before DefaultListIntPoint in the default List handler
type IntPointTxnIntPointWithAfterList interface {
	AfterList(context.Context, *ListIntPointResponse, *gorm.DB) error
}

// Delete ...
func (m *IntPointTxnDefaultServer) Delete(ctx context.Context, in *DeleteIntPointRequest) (*DeleteIntPointResponse, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "Delete")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	txn, ok := gorm1.FromContext(ctx)
	if !ok {
		return nil, errors.NoTransactionError
	}
	db := txn.Begin()
	if db.Error != nil {
		return nil, db.Error
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithBeforeDelete); ok {
		var err error
		if db, err = custom.BeforeDelete(ctx, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	err := DefaultDeleteIntPoint(ctx, &IntPoint{Id: in.GetId()}, db)
	if err != nil {
		return nil, m.spanError(span, err)
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithAfterDelete); ok {
		var err error
		if err = custom.AfterDelete(ctx, out, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// IntPointTxnIntPointWithBeforeDelete called before DefaultDeleteIntPoint in the default Delete handler
type IntPointTxnIntPointWithBeforeDelete interface {
	BeforeDelete(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointTxnIntPointWithAfterDelete called before DefaultDeleteIntPoint in the default Delete handler
type IntPointTxnIntPointWithAfterDelete interface {
	AfterDelete(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}

// DeleteSet ...
func (m *IntPointTxnDefaultServer) DeleteSet(ctx context.Context, in *DeleteIntPointsRequest) (*DeleteIntPointResponse, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "DeleteSet")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	txn, ok := gorm1.FromContext(ctx)
	if !ok {
		return nil, errors.NoTransactionError
	}
	db := txn.Begin()
	if db.Error != nil {
		return nil, db.Error
	}
	objs := []*IntPoint{}
	for _, id := range in.Ids {
		objs = append(objs, &IntPoint{Id: id})
	}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithBeforeDeleteSet); ok {
		var err error
		if db, err = custom.BeforeDeleteSet(ctx, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	err := DefaultDeleteIntPointSet(ctx, objs, db)
	if err != nil {
		return nil, m.spanError(span, err)
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(IntPointTxnIntPointWithAfterDeleteSet); ok {
		var err error
		if err = custom.AfterDeleteSet(ctx, out, db); err != nil {
			return nil, m.spanError(span, err)
		}
	}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// IntPointTxnIntPointWithBeforeDeleteSet called before DefaultDeleteSetIntPoint in the default DeleteSet handler
type IntPointTxnIntPointWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, *gorm.DB) (*gorm.DB, error)
}

// IntPointTxnIntPointWithAfterDeleteSet called before DefaultDeleteSetIntPoint in the default DeleteSet handler
type IntPointTxnIntPointWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}

// CustomMethod ...
func (m *IntPointTxnDefaultServer) CustomMethod(ctx context.Context, in *emptypb.Empty) (*emptypb.Empty, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "CustomMethod")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	out := &emptypb.Empty{}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

// CreateSomething ...
func (m *IntPointTxnDefaultServer) CreateSomething(ctx context.Context, in *Something) (*Something, error) {
	span, errSpanCreate := m.spanCreate(ctx, in, "CreateSomething")
	if errSpanCreate != nil {
		return nil, errSpanCreate
	}
	defer span.End()
	out := &Something{}
	errSpanResult := m.spanResult(span, out)
	if errSpanResult != nil {
		return nil, m.spanError(span, errSpanResult)
	}
	return out, nil
}

type CircleServiceDefaultServer struct {
	DB *gorm.DB
}

// List ...
func (m *CircleServiceDefaultServer) List(ctx context.Context, in *ListCircleRequest) (*ListCircleResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(CircleServiceCircleWithBeforeList); ok {
		var err error
		if db, err = custom.BeforeList(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultListCircle(ctx, db)
	if err != nil {
		return nil, err
	}
	out := &ListCircleResponse{Results: res}
	if custom, ok := interface{}(in).(CircleServiceCircleWithAfterList); ok {
		var err error
		if err = custom.AfterList(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// CircleServiceCircleWithBeforeList called before DefaultListCircle in the default List handler
type CircleServiceCircleWithBeforeList interface {
	BeforeList(context.Context, *gorm.DB) (*gorm.DB, error)
}

// CircleServiceCircleWithAfterList called before DefaultListCircle in the default List handler
type CircleServiceCircleWithAfterList interface {
	AfterList(context.Context, *ListCircleResponse, *gorm.DB) error
}
type MultipleMethodsAutoGenDefaultServer struct {
	DB *gorm.DB
}

// CreateA ...
func (m *MultipleMethodsAutoGenDefaultServer) CreateA(ctx context.Context, in *CreateIntPointRequest) (*CreateIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeCreateA); ok {
		var err error
		if db, err = custom.BeforeCreateA(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultCreateIntPoint(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &CreateIntPointResponse{Result: res}
	err = gateway.SetCreated(ctx, "")
	if err != nil {
		return nil, err
	}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterCreateA); ok {
		var err error
		if err = custom.AfterCreateA(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeCreateA called before DefaultCreateAIntPoint in the default CreateA handler
type MultipleMethodsAutoGenIntPointWithBeforeCreateA interface {
	BeforeCreateA(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterCreateA called before DefaultCreateAIntPoint in the default CreateA handler
type MultipleMethodsAutoGenIntPointWithAfterCreateA interface {
	AfterCreateA(context.Context, *CreateIntPointResponse, *gorm.DB) error
}

// CreateB ...
func (m *MultipleMethodsAutoGenDefaultServer) CreateB(ctx context.Context, in *CreateIntPointRequest) (*CreateIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeCreateB); ok {
		var err error
		if db, err = custom.BeforeCreateB(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultCreateIntPoint(ctx, in.GetPayload(), db)
	if err != nil {
		return nil, err
	}
	out := &CreateIntPointResponse{Result: res}
	err = gateway.SetCreated(ctx, "")
	if err != nil {
		return nil, err
	}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterCreateB); ok {
		var err error
		if err = custom.AfterCreateB(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeCreateB called before DefaultCreateBIntPoint in the default CreateB handler
type MultipleMethodsAutoGenIntPointWithBeforeCreateB interface {
	BeforeCreateB(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterCreateB called before DefaultCreateBIntPoint in the default CreateB handler
type MultipleMethodsAutoGenIntPointWithAfterCreateB interface {
	AfterCreateB(context.Context, *CreateIntPointResponse, *gorm.DB) error
}

// ReadA ...
func (m *MultipleMethodsAutoGenDefaultServer) ReadA(ctx context.Context, in *ReadIntPointRequest) (*ReadIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeReadA); ok {
		var err error
		if db, err = custom.BeforeReadA(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultReadIntPoint(ctx, &IntPoint{Id: in.GetId()}, db, in.Fields)
	if err != nil {
		return nil, err
	}
	out := &ReadIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterReadA); ok {
		var err error
		if err = custom.AfterReadA(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeReadA called before DefaultReadAIntPoint in the default ReadA handler
type MultipleMethodsAutoGenIntPointWithBeforeReadA interface {
	BeforeReadA(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterReadA called before DefaultReadAIntPoint in the default ReadA handler
type MultipleMethodsAutoGenIntPointWithAfterReadA interface {
	AfterReadA(context.Context, *ReadIntPointResponse, *gorm.DB) error
}

// ReadB ...
func (m *MultipleMethodsAutoGenDefaultServer) ReadB(ctx context.Context, in *ReadIntPointRequest) (*ReadIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeReadB); ok {
		var err error
		if db, err = custom.BeforeReadB(ctx, db); err != nil {
			return nil, err
		}
	}
	res, err := DefaultReadIntPoint(ctx, &IntPoint{Id: in.GetId()}, db, in.Fields)
	if err != nil {
		return nil, err
	}
	out := &ReadIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterReadB); ok {
		var err error
		if err = custom.AfterReadB(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeReadB called before DefaultReadBIntPoint in the default ReadB handler
type MultipleMethodsAutoGenIntPointWithBeforeReadB interface {
	BeforeReadB(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterReadB called before DefaultReadBIntPoint in the default ReadB handler
type MultipleMethodsAutoGenIntPointWithAfterReadB interface {
	AfterReadB(context.Context, *ReadIntPointResponse, *gorm.DB) error
}

// UpdateA ...
func (m *MultipleMethodsAutoGenDefaultServer) UpdateA(ctx context.Context, in *UpdateIntPointRequest) (*UpdateIntPointResponse, error) {
	var err error
	var res *IntPoint
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeUpdateA); ok {
		var err error
		if db, err = custom.BeforeUpdateA(ctx, db); err != nil {
			return nil, err
		}
	}
	if in.GetGerogeriGegege() == nil {
		res, err = DefaultStrictUpdateIntPoint(ctx, in.GetPayload(), db)
	} else {
		res, err = DefaultPatchIntPoint(ctx, in.GetPayload(), in.GetGerogeriGegege(), db)
	}
	if err != nil {
		return nil, err
	}
	out := &UpdateIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterUpdateA); ok {
		var err error
		if err = custom.AfterUpdateA(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeUpdateA called before DefaultUpdateAIntPoint in the default UpdateA handler
type MultipleMethodsAutoGenIntPointWithBeforeUpdateA interface {
	BeforeUpdateA(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterUpdateA called before DefaultUpdateAIntPoint in the default UpdateA handler
type MultipleMethodsAutoGenIntPointWithAfterUpdateA interface {
	AfterUpdateA(context.Context, *UpdateIntPointResponse, *gorm.DB) error
}

// UpdateB ...
func (m *MultipleMethodsAutoGenDefaultServer) UpdateB(ctx context.Context, in *UpdateIntPointRequest) (*UpdateIntPointResponse, error) {
	var err error
	var res *IntPoint
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeUpdateB); ok {
		var err error
		if db, err = custom.BeforeUpdateB(ctx, db); err != nil {
			return nil, err
		}
	}
	if in.GetGerogeriGegege() == nil {
		res, err = DefaultStrictUpdateIntPoint(ctx, in.GetPayload(), db)
	} else {
		res, err = DefaultPatchIntPoint(ctx, in.GetPayload(), in.GetGerogeriGegege(), db)
	}
	if err != nil {
		return nil, err
	}
	out := &UpdateIntPointResponse{Result: res}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterUpdateB); ok {
		var err error
		if err = custom.AfterUpdateB(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeUpdateB called before DefaultUpdateBIntPoint in the default UpdateB handler
type MultipleMethodsAutoGenIntPointWithBeforeUpdateB interface {
	BeforeUpdateB(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterUpdateB called before DefaultUpdateBIntPoint in the default UpdateB handler
type MultipleMethodsAutoGenIntPointWithAfterUpdateB interface {
	AfterUpdateB(context.Context, *UpdateIntPointResponse, *gorm.DB) error
}

// ListA ...
func (m *MultipleMethodsAutoGenDefaultServer) ListA(ctx context.Context, in *ListIntPointRequest) (*ListIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeListA); ok {
		var err error
		if db, err = custom.BeforeListA(ctx, db); err != nil {
			return nil, err
		}
	}
	pagedRequest := false
	if in.GetPaging().GetLimit() >= 1 {
		in.Paging.Limit++
		pagedRequest = true
	}
	res, err := DefaultListIntPoint(ctx, db, in.Filter, in.OrderBy, in.Paging, in.Fields)
	if err != nil {
		return nil, err
	}
	var resPaging *query.PageInfo
	if pagedRequest {
		var offset int32
		var size int32 = int32(len(res))
		if size == in.GetPaging().GetLimit() {
			size--
			res = res[:size]
			offset = in.GetPaging().GetOffset() + size
		}
		resPaging = &query.PageInfo{Offset: offset}
	}
	out := &ListIntPointResponse{Results: res, PageInfo: resPaging}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterListA); ok {
		var err error
		if err = custom.AfterListA(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeListA called before DefaultListAIntPoint in the default ListA handler
type MultipleMethodsAutoGenIntPointWithBeforeListA interface {
	BeforeListA(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterListA called before DefaultListAIntPoint in the default ListA handler
type MultipleMethodsAutoGenIntPointWithAfterListA interface {
	AfterListA(context.Context, *ListIntPointResponse, *gorm.DB) error
}

// ListB ...
func (m *MultipleMethodsAutoGenDefaultServer) ListB(ctx context.Context, in *ListIntPointRequest) (*ListIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeListB); ok {
		var err error
		if db, err = custom.BeforeListB(ctx, db); err != nil {
			return nil, err
		}
	}
	pagedRequest := false
	if in.GetPaging().GetLimit() >= 1 {
		in.Paging.Limit++
		pagedRequest = true
	}
	res, err := DefaultListIntPoint(ctx, db, in.Filter, in.OrderBy, in.Paging, in.Fields)
	if err != nil {
		return nil, err
	}
	var resPaging *query.PageInfo
	if pagedRequest {
		var offset int32
		var size int32 = int32(len(res))
		if size == in.GetPaging().GetLimit() {
			size--
			res = res[:size]
			offset = in.GetPaging().GetOffset() + size
		}
		resPaging = &query.PageInfo{Offset: offset}
	}
	out := &ListIntPointResponse{Results: res, PageInfo: resPaging}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterListB); ok {
		var err error
		if err = custom.AfterListB(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeListB called before DefaultListBIntPoint in the default ListB handler
type MultipleMethodsAutoGenIntPointWithBeforeListB interface {
	BeforeListB(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterListB called before DefaultListBIntPoint in the default ListB handler
type MultipleMethodsAutoGenIntPointWithAfterListB interface {
	AfterListB(context.Context, *ListIntPointResponse, *gorm.DB) error
}

// DeleteA ...
func (m *MultipleMethodsAutoGenDefaultServer) DeleteA(ctx context.Context, in *DeleteIntPointRequest) (*DeleteIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeDeleteA); ok {
		var err error
		if db, err = custom.BeforeDeleteA(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteIntPoint(ctx, &IntPoint{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterDeleteA); ok {
		var err error
		if err = custom.AfterDeleteA(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeDeleteA called before DefaultDeleteAIntPoint in the default DeleteA handler
type MultipleMethodsAutoGenIntPointWithBeforeDeleteA interface {
	BeforeDeleteA(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterDeleteA called before DefaultDeleteAIntPoint in the default DeleteA handler
type MultipleMethodsAutoGenIntPointWithAfterDeleteA interface {
	AfterDeleteA(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}

// DeleteB ...
func (m *MultipleMethodsAutoGenDefaultServer) DeleteB(ctx context.Context, in *DeleteIntPointRequest) (*DeleteIntPointResponse, error) {
	db := m.DB
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeDeleteB); ok {
		var err error
		if db, err = custom.BeforeDeleteB(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteIntPoint(ctx, &IntPoint{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterDeleteB); ok {
		var err error
		if err = custom.AfterDeleteB(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeDeleteB called before DefaultDeleteBIntPoint in the default DeleteB handler
type MultipleMethodsAutoGenIntPointWithBeforeDeleteB interface {
	BeforeDeleteB(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterDeleteB called before DefaultDeleteBIntPoint in the default DeleteB handler
type MultipleMethodsAutoGenIntPointWithAfterDeleteB interface {
	AfterDeleteB(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}

// DeleteSetA ...
func (m *MultipleMethodsAutoGenDefaultServer) DeleteSetA(ctx context.Context, in *DeleteIntPointsRequest) (*DeleteIntPointResponse, error) {
	db := m.DB
	objs := []*IntPoint{}
	for _, id := range in.Ids {
		objs = append(objs, &IntPoint{Id: id})
	}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeDeleteSetA); ok {
		var err error
		if db, err = custom.BeforeDeleteSetA(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteIntPointSet(ctx, objs, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterDeleteSetA); ok {
		var err error
		if err = custom.AfterDeleteSetA(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeDeleteSetA called before DefaultDeleteSetAIntPoint in the default DeleteSetA handler
type MultipleMethodsAutoGenIntPointWithBeforeDeleteSetA interface {
	BeforeDeleteSetA(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterDeleteSetA called before DefaultDeleteSetAIntPoint in the default DeleteSetA handler
type MultipleMethodsAutoGenIntPointWithAfterDeleteSetA interface {
	AfterDeleteSetA(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}

// DeleteSetB ...
func (m *MultipleMethodsAutoGenDefaultServer) DeleteSetB(ctx context.Context, in *DeleteIntPointsRequest) (*DeleteIntPointResponse, error) {
	db := m.DB
	objs := []*IntPoint{}
	for _, id := range in.Ids {
		objs = append(objs, &IntPoint{Id: id})
	}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithBeforeDeleteSetB); ok {
		var err error
		if db, err = custom.BeforeDeleteSetB(ctx, db); err != nil {
			return nil, err
		}
	}
	err := DefaultDeleteIntPointSet(ctx, objs, db)
	if err != nil {
		return nil, err
	}
	out := &DeleteIntPointResponse{}
	if custom, ok := interface{}(in).(MultipleMethodsAutoGenIntPointWithAfterDeleteSetB); ok {
		var err error
		if err = custom.AfterDeleteSetB(ctx, out, db); err != nil {
			return nil, err
		}
	}
	return out, nil
}

// MultipleMethodsAutoGenIntPointWithBeforeDeleteSetB called before DefaultDeleteSetBIntPoint in the default DeleteSetB handler
type MultipleMethodsAutoGenIntPointWithBeforeDeleteSetB interface {
	BeforeDeleteSetB(context.Context, *gorm.DB) (*gorm.DB, error)
}

// MultipleMethodsAutoGenIntPointWithAfterDeleteSetB called before DefaultDeleteSetBIntPoint in the default DeleteSetB handler
type MultipleMethodsAutoGenIntPointWithAfterDeleteSetB interface {
	AfterDeleteSetB(context.Context, *DeleteIntPointResponse, *gorm.DB) error
}