github.com/tsmith1024/pop@v4.12.2+incompatible/callbacks.go (about)

     1  package pop
     2  
     3  import (
     4  	"reflect"
     5  
     6  	"golang.org/x/sync/errgroup"
     7  )
     8  
     9  // AfterFindable callback will be called after a record, or records,
    10  // has been retrieved from the database.
    11  type AfterFindable interface {
    12  	AfterFind(*Connection) error
    13  }
    14  
    15  func (m *Model) afterFind(c *Connection) error {
    16  	if x, ok := m.Value.(AfterFindable); ok {
    17  		if err := x.AfterFind(c); err != nil {
    18  			return err
    19  		}
    20  	}
    21  
    22  	// if the "model" is a slice/array we want
    23  	// to loop through each of the elements in the collection
    24  	// and call AfterFind on them if they exist.
    25  	rv := reflect.Indirect(reflect.ValueOf(m.Value))
    26  	kind := rv.Kind()
    27  	if kind != reflect.Slice && kind != reflect.Array {
    28  		return nil
    29  	}
    30  
    31  	wg := &errgroup.Group{}
    32  	for i := 0; i < rv.Len(); i++ {
    33  		func(i int) {
    34  			wg.Go(func() error {
    35  				y := rv.Index(i)
    36  				y = y.Addr()
    37  				if x, ok := y.Interface().(AfterFindable); ok {
    38  					return x.AfterFind(c)
    39  				}
    40  				return nil
    41  			})
    42  		}(i)
    43  	}
    44  
    45  	return wg.Wait()
    46  }
    47  
    48  // BeforeSaveable callback will be called before a record is
    49  // either created or updated in the database.
    50  type BeforeSaveable interface {
    51  	BeforeSave(*Connection) error
    52  }
    53  
    54  func (m *Model) beforeSave(c *Connection) error {
    55  	if x, ok := m.Value.(BeforeSaveable); ok {
    56  		return x.BeforeSave(c)
    57  	}
    58  	return nil
    59  }
    60  
    61  // BeforeCreateable callback will be called before a record is
    62  // created in the database.
    63  type BeforeCreateable interface {
    64  	BeforeCreate(*Connection) error
    65  }
    66  
    67  func (m *Model) beforeCreate(c *Connection) error {
    68  	if x, ok := m.Value.(BeforeCreateable); ok {
    69  		return x.BeforeCreate(c)
    70  	}
    71  	return nil
    72  }
    73  
    74  // BeforeUpdateable callback will be called before a record is
    75  // updated in the database.
    76  type BeforeUpdateable interface {
    77  	BeforeUpdate(*Connection) error
    78  }
    79  
    80  func (m *Model) beforeUpdate(c *Connection) error {
    81  	if x, ok := m.Value.(BeforeUpdateable); ok {
    82  		return x.BeforeUpdate(c)
    83  	}
    84  	return nil
    85  }
    86  
    87  // BeforeDestroyable callback will be called before a record is
    88  // destroyed in the database.
    89  type BeforeDestroyable interface {
    90  	BeforeDestroy(*Connection) error
    91  }
    92  
    93  func (m *Model) beforeDestroy(c *Connection) error {
    94  	if x, ok := m.Value.(BeforeDestroyable); ok {
    95  		return x.BeforeDestroy(c)
    96  	}
    97  	return nil
    98  }
    99  
   100  // AfterDestroyable callback will be called after a record is
   101  // destroyed in the database.
   102  type AfterDestroyable interface {
   103  	AfterDestroy(*Connection) error
   104  }
   105  
   106  func (m *Model) afterDestroy(c *Connection) error {
   107  	if x, ok := m.Value.(AfterDestroyable); ok {
   108  		return x.AfterDestroy(c)
   109  	}
   110  	return nil
   111  }
   112  
   113  // AfterUpdateable callback will be called after a record is
   114  // updated in the database.
   115  type AfterUpdateable interface {
   116  	AfterUpdate(*Connection) error
   117  }
   118  
   119  func (m *Model) afterUpdate(c *Connection) error {
   120  	if x, ok := m.Value.(AfterUpdateable); ok {
   121  		return x.AfterUpdate(c)
   122  	}
   123  	return nil
   124  }
   125  
   126  // AfterCreateable callback will be called after a record is
   127  // created in the database.
   128  type AfterCreateable interface {
   129  	AfterCreate(*Connection) error
   130  }
   131  
   132  func (m *Model) afterCreate(c *Connection) error {
   133  	if x, ok := m.Value.(AfterCreateable); ok {
   134  		return x.AfterCreate(c)
   135  	}
   136  	return nil
   137  }
   138  
   139  // AfterSaveable callback will be called after a record is
   140  // either created or updated in the database.
   141  type AfterSaveable interface {
   142  	AfterSave(*Connection) error
   143  }
   144  
   145  func (m *Model) afterSave(c *Connection) error {
   146  	if x, ok := m.Value.(AfterSaveable); ok {
   147  		return x.AfterSave(c)
   148  	}
   149  	return nil
   150  }