1188 lines
35 KiB
Go
1188 lines
35 KiB
Go
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
|
|
}
|