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 }