From 69b0a9b713e87ab371ea5c6127e2acd15c7e8242 Mon Sep 17 00:00:00 2001
From: Nash Tsai <nash.tsai@gmail.com>
Date: Sat, 30 Nov 2013 17:50:04 +0800
Subject: [PATCH 1/4] implementation of before/after processors

---
 base_test.go  | 161 +++++++++++++++++++++++++++++++
 engine.go     |  42 +++++++++
 processors.go |  39 ++++++++
 session.go    | 256 +++++++++++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 497 insertions(+), 1 deletion(-)
 create mode 100644 processors.go

diff --git a/base_test.go b/base_test.go
index 93c11d4c..4e7f20fa 100644
--- a/base_test.go
+++ b/base_test.go
@@ -1706,6 +1706,165 @@ func testPrefixTableName(engine *Engine, t *testing.T) {
 	}
 }
 
+type ProcessorsStruct struct {
+	Id int64
+	
+	B4InsertFlag bool
+	AfterInsertedFlag bool 
+	B4UpdateFlag bool
+	AfterUpdatedFlag bool
+	B4DeleteFlag bool `xorm:"-"`
+	AfterDeletedFlag bool `xorm:"-"`
+
+	B4InsertViaExt bool
+	AfterInsertedViaExt bool 
+	B4UpdateViaExt bool
+	AfterUpdatedViaExt bool
+	B4DeleteViaExt bool `xorm:"-"`
+	AfterDeletedViaExt bool `xorm:"-"`
+}
+
+func (p *ProcessorsStruct) BeforeInsert() {
+	p.B4InsertFlag = true
+}
+
+func (p *ProcessorsStruct) BeforeUpdate() {
+	p.B4UpdateFlag = true
+}
+
+func (p *ProcessorsStruct) BeforeDelete() {
+	p.B4DeleteFlag = true
+}
+
+func (p *ProcessorsStruct) AfterInsert() {
+	p.AfterInsertedFlag = true
+}
+
+func (p *ProcessorsStruct) AfterUpdate() {
+	p.AfterUpdatedFlag = true
+}
+
+func (p *ProcessorsStruct) AfterDelete() {
+	p.AfterDeletedFlag = true
+}
+
+func testProcessors(engine *Engine, t *testing.T) {
+	err := engine.Sync(&ProcessorsStruct{})
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	p := &ProcessorsStruct{}
+	b4InsertFunc := func(bean interface{}) {
+		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
+			v.B4InsertViaExt = true
+		} else {
+			t.Fail()
+		}
+	}
+
+	afterInsertFunc := func(bean interface{}) {
+		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
+			v.AfterInsertedViaExt = true
+		} else {
+			t.Fail()
+		}
+	}
+		
+	_, err = engine.BeforeInsert(b4InsertFunc).AfterInsert(afterInsertFunc).Insert(p)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	} else {
+		if !p.B4InsertFlag { t.Fail() }
+		if !p.AfterInsertedFlag { t.Fail() }
+		if !p.B4InsertViaExt { t.Fail() }
+		if !p.AfterInsertedViaExt { t.Fail() }
+	}
+		
+	p2 := &ProcessorsStruct{}
+	_, err = engine.Id(p.Id).Get(p2)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	} else {
+		if !p.B4InsertFlag { t.Fail() }
+		if p.AfterInsertedFlag { t.Fail() }
+		if !p.B4InsertViaExt { t.Fail() }
+		if p.AfterInsertedViaExt { t.Fail() }
+	}
+
+	b4UpdateFunc := func(bean interface{}) {
+		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
+			v.B4UpdateViaExt = true
+		} else {
+			t.Fail()
+		}
+	}
+
+	afterUpdateFunc := func(bean interface{}) {
+		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
+			v.AfterUpdatedViaExt = true
+		} else {
+			t.Fail()
+		}
+	}
+
+	_, err = engine.BeforeUpdate(b4UpdateFunc).AfterUpdate(afterUpdateFunc).Update(p)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	} else {
+		if !p.B4UpdateFlag { t.Fail() }
+		if !p.AfterUpdatedFlag { t.Fail() }
+		if !p.B4UpdateViaExt { t.Fail() }
+		if !p.AfterUpdatedViaExt { t.Fail() }
+	}
+		
+	_, err = engine.Id(p.Id).Get(p2)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	} else {
+		if !p.B4UpdateFlag { t.Fail() }
+		if p.AfterUpdatedFlag { t.Fail() }
+		if !p.B4UpdateViaExt { t.Fail() }
+		if p.AfterUpdatedViaExt { t.Fail() }
+	}
+
+	b4DeleteFunc := func(bean interface{}) {
+		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
+			v.B4DeleteViaExt = true
+		} else {
+			t.Fail()
+		}
+	}
+
+	afterDeleteFunc := func(bean interface{}) {
+		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
+			v.AfterDeletedViaExt = true
+		} else {
+			t.Fail()
+		}
+	}
+
+		
+	_, err = engine.BeforeDelete(b4DeleteFunc).AfterDelete(afterDeleteFunc).Delete(p)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	} else {
+		if !p.B4DeleteFlag { t.Fail() }
+		if !p.AfterDeletedFlag { t.Fail() }
+		if !p.B4DeleteViaExt { t.Fail() }
+		if !p.AfterDeletedViaExt { t.Fail() }
+	}
+
+	// !nashtsai! TODO insert many beans tests
+	
+}
+
 func testAll(engine *Engine, t *testing.T) {
 	fmt.Println("-------------- directCreateTable --------------")
 	directCreateTable(engine, t)
@@ -1802,4 +1961,6 @@ func testAll2(engine *Engine, t *testing.T) {
 	testPrefixTableName(engine, t)
 	fmt.Println("-------------- transaction --------------")
 	transaction(engine, t)
+	fmt.Println("-------------- processors --------------")
+	testProcessors(engine, t)
 }
diff --git a/engine.go b/engine.go
index 570f221d..b4ad2f8f 100644
--- a/engine.go
+++ b/engine.go
@@ -272,6 +272,48 @@ func (engine *Engine) Id(id int64) *Session {
 	return session.Id(id)
 }
 
+// Apply before insert Processor, affected bean is passed to closure arg
+func (engine *Engine) BeforeInsert(closures func(interface{})) *Session {
+	session := engine.NewSession()
+	session.IsAutoClose = true
+	return session.BeforeInsert(closures)
+} 
+
+// Apply before update Processor, affected bean is passed to closure arg
+func (engine *Engine) BeforeUpdate(closures func(interface{})) *Session {
+	session := engine.NewSession()
+	session.IsAutoClose = true
+	return session.BeforeUpdate(closures)
+} 
+
+// Apply before delete Processor, affected bean is passed to closure arg
+func (engine *Engine) BeforeDelete(closures func(interface{})) *Session {
+	session := engine.NewSession()
+	session.IsAutoClose = true
+	return session.BeforeDelete(closures)
+} 
+
+// Apply after insert Processor, affected bean is passed to closure arg
+func (engine *Engine) AfterInsert(closures func(interface{})) *Session {
+	session := engine.NewSession()
+	session.IsAutoClose = true
+	return session.AfterInsert(closures)
+} 
+
+// Apply after update Processor, affected bean is passed to closure arg
+func (engine *Engine) AfterUpdate(closures func(interface{})) *Session {
+	session := engine.NewSession()
+	session.IsAutoClose = true
+	return session.AfterUpdate(closures)
+} 
+
+// Apply after delete Processor, affected bean is passed to closure arg
+func (engine *Engine) AfterDelete(closures func(interface{})) *Session {
+	session := engine.NewSession()
+	session.IsAutoClose = true
+	return session.AfterDelete(closures)
+}
+
 // set charset when create table, only support mysql now
 func (engine *Engine) Charset(charset string) *Session {
 	session := engine.NewSession()
diff --git a/processors.go b/processors.go
new file mode 100644
index 00000000..271a1f08
--- /dev/null
+++ b/processors.go
@@ -0,0 +1,39 @@
+package xorm
+
+// Executed before an object is initially persisted to the database
+type BeforeInsertProcessor interface {
+	BeforeInsert()
+}
+
+// Executed before an object is updated
+type BeforeUpdateProcessor interface {
+	BeforeUpdate()
+}
+
+// Executed before an object is deleted
+type BeforeDeleteProcessor interface {
+	BeforeDelete()
+}
+
+// !nashtsai! TODO enable BeforeValidateProcessor when xorm start to support validations
+//// Executed before an object is validated
+//type BeforeValidateProcessor interface {
+//	BeforeValidate()
+//}
+// --
+
+// Executed after an object is persisted to the database
+type AfterInsertProcessor interface {
+	AfterInsert()
+}
+
+// Executed after an object has been updated
+type AfterUpdateProcessor interface {
+	AfterUpdate()
+}
+
+// Executed after an object has been deleted
+type AfterDeleteProcessor interface {
+	AfterDelete()
+}
+
diff --git a/session.go b/session.go
index c29844fe..4ef3b67d 100644
--- a/session.go
+++ b/session.go
@@ -22,6 +22,19 @@ type Session struct {
 	IsCommitedOrRollbacked bool
 	TransType              string
 	IsAutoClose            bool
+	
+    // !nashtsai! storing these beans due to yet committed tx
+	afterInsertBeans []interface{}
+	afterUpdateBeans []interface{}
+	afterDeleteBeans []interface{}
+	// --
+	
+	beforeInsertClosures []func(interface{})
+	beforeUpdateClosures []func(interface{})
+	beforeDeleteClosures []func(interface{})
+	afterInsertClosures []func(interface{})
+	afterUpdateClosures []func(interface{})
+	afterDeleteClosures []func(interface{})
 }
 
 // Method Init reset the session as the init status.
@@ -31,6 +44,17 @@ func (session *Session) Init() {
 	session.IsAutoCommit = true
 	session.IsCommitedOrRollbacked = false
 	session.IsAutoClose = false
+	
+	// !nashtsai! is lazy init better?
+	session.afterInsertBeans = make([]interface{}, 0)
+	session.afterUpdateBeans = make([]interface{}, 0)
+	session.afterDeleteBeans = make([]interface{}, 0)
+	session.beforeInsertClosures = make([]func(interface{}), 0)
+	session.beforeUpdateClosures = make([]func(interface{}), 0)
+	session.beforeDeleteClosures = make([]func(interface{}), 0)
+	session.afterInsertClosures = make([]func(interface{}), 0)
+	session.afterUpdateClosures = make([]func(interface{}), 0)	
+	session.afterDeleteClosures = make([]func(interface{}), 0)
 }
 
 // Method Close release the connection from pool
@@ -76,6 +100,54 @@ func (session *Session) Id(id int64) *Session {
 	return session
 }
 
+// Apply before insert Processor, affected bean is passed to closure arg
+func (session *Session) BeforeInsert(closures func(interface{})) *Session {
+	if closures != nil {
+		session.beforeInsertClosures = append(session.beforeInsertClosures, closures)
+	}
+	return session
+} 
+
+// Apply before update Processor, affected bean is passed to closure arg
+func (session *Session) BeforeUpdate(closures func(interface{})) *Session {
+	if closures != nil {
+		session.beforeUpdateClosures = append(session.beforeUpdateClosures, closures)
+	}
+	return session
+} 
+
+// Apply before delete Processor, affected bean is passed to closure arg
+func (session *Session) BeforeDelete(closures func(interface{})) *Session {
+	if closures != nil {
+		session.beforeDeleteClosures = append(session.beforeDeleteClosures, closures)
+	}
+	return session
+} 
+
+// Apply after insert Processor, affected bean is passed to closure arg
+func (session *Session) AfterInsert(closures func(interface{})) *Session {
+	if closures != nil {
+		session.afterInsertClosures = append(session.afterInsertClosures, closures)
+	}
+	return session
+} 
+
+// Apply after update Processor, affected bean is passed to closure arg
+func (session *Session) AfterUpdate(closures func(interface{})) *Session {
+	if closures != nil {
+		session.afterUpdateClosures = append(session.afterUpdateClosures, closures)
+	}
+	return session
+} 
+
+// Apply after delete Processor, affected bean is passed to closure arg
+func (session *Session) AfterDelete(closures func(interface{})) *Session {
+	if closures != nil {
+		session.afterDeleteClosures = append(session.afterDeleteClosures, closures)
+	}
+	return session
+} 
+
 // Method Table can input a string or pointer to struct for special a table to operate.
 func (session *Session) Table(tableNameOrBean interface{}) *Session {
 	session.Statement.Table(tableNameOrBean)
@@ -251,7 +323,56 @@ func (session *Session) Commit() error {
 	if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
 		session.Engine.LogSQL("COMMIT")
 		session.IsCommitedOrRollbacked = true
-		return session.Tx.Commit()
+		var err error
+		
+		
+		if err = session.Tx.Commit(); err == nil { 
+			// handle processors after tx committed
+			for _, elem := range session.afterInsertBeans {
+				for _, closure := range session.afterInsertClosures {
+					closure(elem)
+				}
+				
+				if processor, ok := interface{}(elem).(AfterInsertProcessor); ok {
+					processor.AfterInsert()
+				}
+			}
+			for _, elem := range session.afterUpdateBeans {
+				for _, closure := range session.afterUpdateClosures {
+					closure(elem)
+				}
+				if processor, ok := interface{}(elem).(AfterUpdateProcessor); ok {
+					processor.AfterUpdate()
+				}
+			}
+			for _, elem := range session.afterDeleteBeans {
+				for _, closure := range session.afterDeleteClosures {
+					closure(elem)
+				}			 
+				if processor, ok := interface{}(elem).(AfterDeleteProcessor); ok {
+					processor.AfterDelete()
+				}
+			}
+			cleanUpFunc := func(slices *[]interface{}) {
+				if len(*slices) > 0 {
+					*slices = make([]interface{}, 0)
+				}
+			}
+			cleanUpProcessorsFunc := func(slices *[]func(interface{})) {
+				if len(*slices) > 0 {
+					*slices = make([]func(interface{}), 0)
+				}
+			}
+			cleanUpFunc(&session.afterInsertBeans)
+			cleanUpFunc(&session.afterUpdateBeans)
+			cleanUpFunc(&session.afterDeleteBeans)
+
+			// !nash! shoule session based processors get cleanup?
+			cleanUpProcessorsFunc(&session.afterInsertClosures)
+			cleanUpProcessorsFunc(&session.afterUpdateClosures)
+			cleanUpProcessorsFunc(&session.afterDeleteClosures)
+		} 
+		return err
 	}
 	return nil
 }
@@ -1333,6 +1454,17 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 	for i := 0; i < size; i++ {
 		elemValue := sliceValue.Index(i).Interface()
 		colPlaces := make([]string, 0)
+		
+		// handle BeforeInsertProcessor
+		for _, closure := range session.beforeInsertClosures {
+			closure(elemValue)
+		}
+
+		if processor, ok := interface{}(elemValue).(BeforeInsertProcessor); ok {
+			processor.BeforeInsert()
+		}
+		// --
+		
 
 		if i == 0 {
 			for _, col := range table.Columns {
@@ -1409,6 +1541,28 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 	if table.Cacher != nil && session.Statement.UseCache {
 		session.cacheInsert(session.Statement.TableName())
 	}
+	
+	hasAfterInsertClosures := len(session.afterInsertClosures) > 0 
+	for i := 0; i < size; i++ {
+		elemValue := sliceValue.Index(i).Interface()
+		// handle AfterInsertProcessor
+		if session.IsAutoCommit {
+			for _, closure := range session.afterInsertClosures {
+				closure(elemValue)
+			}
+			if processor, ok := interface{}(elemValue).(AfterInsertProcessor); ok {
+				processor.AfterInsert()
+			}
+		} else {
+			if hasAfterInsertClosures {
+				session.afterInsertBeans = append(session.afterInsertBeans, elemValue)				
+			} else {
+				if _, ok := interface{}(elemValue).(AfterInsertProcessor); ok {
+					session.afterInsertBeans = append(session.afterInsertBeans, elemValue)	
+				}
+			}
+		}
+	}
 
 	return res.RowsAffected()
 }
@@ -1682,6 +1836,18 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	table := session.Engine.autoMap(bean)
 	session.Statement.RefTable = table
 
+	// handle BeforeInsertProcessor
+	for _, closure := range session.beforeInsertClosures {
+		closure(bean)
+	}
+	if processor, ok := interface{}(bean).(BeforeInsertProcessor); ok {
+		session.Engine.LogDebug(session.Statement.TableName(), " has before insert processor")
+		processor.BeforeInsert()
+	} else {
+		session.Engine.LogDebug(session.Statement.TableName(), " has no before insert processor")
+	}
+	// --		
+
 	colNames, args, err := table.genCols(session, bean, false, false)
 	if err != nil {
 		return 0, err
@@ -1699,12 +1865,36 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		session.Engine.QuoteStr(),
 		colPlaces)
 
+
+	handleAfterInsertProcessorFunc := func(bean interface{}) {
+
+		if session.IsAutoCommit {
+			for _, closure := range session.afterInsertClosures {
+				closure(bean)
+			}
+ 			if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
+		    	session.Engine.LogDebug(session.Statement.TableName(), " has after insert processor")
+				processor.AfterInsert()
+			}
+		} else {
+			if len(session.afterInsertClosures) > 0 {
+				session.afterInsertBeans = append(session.afterInsertBeans, bean)				
+			} else {
+ 				if _, ok := interface{}(bean).(AfterInsertProcessor); ok {
+					session.afterInsertBeans = append(session.afterInsertBeans, bean)				
+				}
+			}
+		}
+	}	
+
 	// for postgres, many of them didn't implement lastInsertId, so we should
 	// implemented it ourself.
 	if session.Engine.DriverName != POSTGRES || table.PrimaryKey == "" {
 		res, err := session.exec(sql, args...)
 		if err != nil {
 			return 0, err
+		} else {
+			handleAfterInsertProcessorFunc(bean)
 		}
 
 		if table.Cacher != nil && session.Statement.UseCache {
@@ -1748,6 +1938,8 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		res, err := session.query(sql, args...)
 		if err != nil {
 			return 0, err
+		} else {
+			handleAfterInsertProcessorFunc(bean)
 		}
 
 		if table.Cacher != nil && session.Statement.UseCache {
@@ -1979,6 +2171,17 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	var args []interface{}
 	var table *Table
 
+
+	// handle before update processors
+	for _, closure := range session.beforeUpdateClosures {
+		closure(bean)
+	}
+
+	if processor, ok := interface{}(bean).(BeforeUpdateProcessor); ok {
+		processor.BeforeUpdate()
+	}
+	// --
+
 	if t.Kind() == reflect.Struct {
 		table = session.Engine.autoMap(bean)
 		session.Statement.RefTable = table
@@ -2077,6 +2280,26 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		table.Cacher.ClearBeans(session.Statement.TableName())
 	}
 
+	// handle after update processors
+	if session.IsAutoCommit {
+		for _, closure := range session.afterUpdateClosures {
+			closure(bean)
+		}
+		if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
+			session.Engine.LogDebug(session.Statement.TableName(), " has after update processor")
+			processor.AfterUpdate()
+		}
+	} else {
+		if len(session.afterInsertClosures) > 0 {
+			session.afterUpdateBeans = append(session.afterUpdateBeans, bean)                               
+		} else {
+			if _, ok := interface{}(bean).(AfterUpdateProcessor); ok {
+				session.afterUpdateBeans = append(session.afterUpdateBeans, bean)                               
+			}
+		}
+ 	}
+	// --
+
 	return res.RowsAffected()
 }
 
@@ -2142,6 +2365,17 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		defer session.Close()
 	}
 
+
+	// handle before delete processors
+	for _, closure := range session.beforeDeleteClosures {
+		closure(bean)
+	}
+
+	if processor, ok := interface{}(bean).(BeforeDeleteProcessor); ok {
+		processor.BeforeDelete()
+	}
+	// --
+
 	table := session.Engine.autoMap(bean)
 	session.Statement.RefTable = table
 	colNames, args := buildConditions(session.Engine, table, bean, true,
@@ -2174,5 +2408,25 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		return 0, err
 	}
 
+	// handle after delete processors
+	if session.IsAutoCommit {
+		for _, closure := range session.afterDeleteClosures {
+			closure(bean)
+		}
+		if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
+			session.Engine.LogDebug(session.Statement.TableName(), " has after update processor")
+			processor.AfterDelete()
+		}
+	} else {
+		if len(session.afterDeleteClosures) > 0 {
+			session.afterDeleteBeans = append(session.afterDeleteBeans, bean)                               
+		} else {
+			if _, ok := interface{}(bean).(AfterDeleteProcessor); ok {
+				session.afterDeleteBeans = append(session.afterDeleteBeans, bean)                               
+			}
+		}
+ 	}
+	// --
+
 	return res.RowsAffected()
 }

From e9a5dddbef6a1d1a4f98a129613b3a409b4eb456 Mon Sep 17 00:00:00 2001
From: Nash Tsai <nash.tsai@gmail.com>
Date: Mon, 2 Dec 2013 14:23:04 +0800
Subject: [PATCH 2/4] elimited BeforeXXX and AfterXXX operations with After()
 and Before()

---
 engine.go  |  38 +++-----------------
 session.go | 102 +++++++++++++++--------------------------------------
 2 files changed, 34 insertions(+), 106 deletions(-)

diff --git a/engine.go b/engine.go
index b4ad2f8f..996ebd27 100644
--- a/engine.go
+++ b/engine.go
@@ -272,48 +272,20 @@ func (engine *Engine) Id(id int64) *Session {
 	return session.Id(id)
 }
 
-// Apply before insert Processor, affected bean is passed to closure arg
-func (engine *Engine) BeforeInsert(closures func(interface{})) *Session {
+// Apply before Processor, affected bean is passed to closure arg
+func (engine *Engine) Before(closures func(interface{})) *Session {
 	session := engine.NewSession()
 	session.IsAutoClose = true
-	return session.BeforeInsert(closures)
-} 
-
-// Apply before update Processor, affected bean is passed to closure arg
-func (engine *Engine) BeforeUpdate(closures func(interface{})) *Session {
-	session := engine.NewSession()
-	session.IsAutoClose = true
-	return session.BeforeUpdate(closures)
-} 
-
-// Apply before delete Processor, affected bean is passed to closure arg
-func (engine *Engine) BeforeDelete(closures func(interface{})) *Session {
-	session := engine.NewSession()
-	session.IsAutoClose = true
-	return session.BeforeDelete(closures)
+	return session.Before(closures)
 } 
 
 // Apply after insert Processor, affected bean is passed to closure arg
-func (engine *Engine) AfterInsert(closures func(interface{})) *Session {
+func (engine *Engine) After(closures func(interface{})) *Session {
 	session := engine.NewSession()
 	session.IsAutoClose = true
-	return session.AfterInsert(closures)
+	return session.After(closures)
 } 
 
-// Apply after update Processor, affected bean is passed to closure arg
-func (engine *Engine) AfterUpdate(closures func(interface{})) *Session {
-	session := engine.NewSession()
-	session.IsAutoClose = true
-	return session.AfterUpdate(closures)
-} 
-
-// Apply after delete Processor, affected bean is passed to closure arg
-func (engine *Engine) AfterDelete(closures func(interface{})) *Session {
-	session := engine.NewSession()
-	session.IsAutoClose = true
-	return session.AfterDelete(closures)
-}
-
 // set charset when create table, only support mysql now
 func (engine *Engine) Charset(charset string) *Session {
 	session := engine.NewSession()
diff --git a/session.go b/session.go
index 4ef3b67d..17c744a2 100644
--- a/session.go
+++ b/session.go
@@ -29,12 +29,8 @@ type Session struct {
 	afterDeleteBeans []interface{}
 	// --
 	
-	beforeInsertClosures []func(interface{})
-	beforeUpdateClosures []func(interface{})
-	beforeDeleteClosures []func(interface{})
-	afterInsertClosures []func(interface{})
-	afterUpdateClosures []func(interface{})
-	afterDeleteClosures []func(interface{})
+	beforeClosures []func(interface{})
+	afterClosures []func(interface{})
 }
 
 // Method Init reset the session as the init status.
@@ -49,12 +45,8 @@ func (session *Session) Init() {
 	session.afterInsertBeans = make([]interface{}, 0)
 	session.afterUpdateBeans = make([]interface{}, 0)
 	session.afterDeleteBeans = make([]interface{}, 0)
-	session.beforeInsertClosures = make([]func(interface{}), 0)
-	session.beforeUpdateClosures = make([]func(interface{}), 0)
-	session.beforeDeleteClosures = make([]func(interface{}), 0)
-	session.afterInsertClosures = make([]func(interface{}), 0)
-	session.afterUpdateClosures = make([]func(interface{}), 0)	
-	session.afterDeleteClosures = make([]func(interface{}), 0)
+	session.beforeClosures = make([]func(interface{}), 0)
+	session.afterClosures = make([]func(interface{}), 0)
 }
 
 // Method Close release the connection from pool
@@ -100,53 +92,21 @@ func (session *Session) Id(id int64) *Session {
 	return session
 }
 
-// Apply before insert Processor, affected bean is passed to closure arg
-func (session *Session) BeforeInsert(closures func(interface{})) *Session {
+// Apply before Processor, affected bean is passed to closure arg
+func (session *Session) Before(closures func(interface{})) *Session {
 	if closures != nil {
-		session.beforeInsertClosures = append(session.beforeInsertClosures, closures)
+		session.beforeClosures = append(session.beforeClosures, closures)
 	}
 	return session
 } 
 
-// Apply before update Processor, affected bean is passed to closure arg
-func (session *Session) BeforeUpdate(closures func(interface{})) *Session {
+// Apply after Processor, affected bean is passed to closure arg
+func (session *Session) After(closures func(interface{})) *Session {
 	if closures != nil {
-		session.beforeUpdateClosures = append(session.beforeUpdateClosures, closures)
+		session.afterClosures = append(session.afterClosures, closures)
 	}
 	return session
-} 
-
-// Apply before delete Processor, affected bean is passed to closure arg
-func (session *Session) BeforeDelete(closures func(interface{})) *Session {
-	if closures != nil {
-		session.beforeDeleteClosures = append(session.beforeDeleteClosures, closures)
-	}
-	return session
-} 
-
-// Apply after insert Processor, affected bean is passed to closure arg
-func (session *Session) AfterInsert(closures func(interface{})) *Session {
-	if closures != nil {
-		session.afterInsertClosures = append(session.afterInsertClosures, closures)
-	}
-	return session
-} 
-
-// Apply after update Processor, affected bean is passed to closure arg
-func (session *Session) AfterUpdate(closures func(interface{})) *Session {
-	if closures != nil {
-		session.afterUpdateClosures = append(session.afterUpdateClosures, closures)
-	}
-	return session
-} 
-
-// Apply after delete Processor, affected bean is passed to closure arg
-func (session *Session) AfterDelete(closures func(interface{})) *Session {
-	if closures != nil {
-		session.afterDeleteClosures = append(session.afterDeleteClosures, closures)
-	}
-	return session
-} 
+}
 
 // Method Table can input a string or pointer to struct for special a table to operate.
 func (session *Session) Table(tableNameOrBean interface{}) *Session {
@@ -324,12 +284,10 @@ func (session *Session) Commit() error {
 		session.Engine.LogSQL("COMMIT")
 		session.IsCommitedOrRollbacked = true
 		var err error
-		
-		
 		if err = session.Tx.Commit(); err == nil { 
 			// handle processors after tx committed
 			for _, elem := range session.afterInsertBeans {
-				for _, closure := range session.afterInsertClosures {
+				for _, closure := range session.afterClosures {
 					closure(elem)
 				}
 				
@@ -338,7 +296,7 @@ func (session *Session) Commit() error {
 				}
 			}
 			for _, elem := range session.afterUpdateBeans {
-				for _, closure := range session.afterUpdateClosures {
+				for _, closure := range session.afterClosures {
 					closure(elem)
 				}
 				if processor, ok := interface{}(elem).(AfterUpdateProcessor); ok {
@@ -346,7 +304,7 @@ func (session *Session) Commit() error {
 				}
 			}
 			for _, elem := range session.afterDeleteBeans {
-				for _, closure := range session.afterDeleteClosures {
+				for _, closure := range session.afterClosures {
 					closure(elem)
 				}			 
 				if processor, ok := interface{}(elem).(AfterDeleteProcessor); ok {
@@ -367,10 +325,8 @@ func (session *Session) Commit() error {
 			cleanUpFunc(&session.afterUpdateBeans)
 			cleanUpFunc(&session.afterDeleteBeans)
 
-			// !nash! shoule session based processors get cleanup?
-			cleanUpProcessorsFunc(&session.afterInsertClosures)
-			cleanUpProcessorsFunc(&session.afterUpdateClosures)
-			cleanUpProcessorsFunc(&session.afterDeleteClosures)
+			// !nash! should session based processors get cleanup?
+			cleanUpProcessorsFunc(&session.afterClosures)
 		} 
 		return err
 	}
@@ -1456,7 +1412,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		colPlaces := make([]string, 0)
 		
 		// handle BeforeInsertProcessor
-		for _, closure := range session.beforeInsertClosures {
+		for _, closure := range session.beforeClosures {
 			closure(elemValue)
 		}
 
@@ -1542,19 +1498,19 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		session.cacheInsert(session.Statement.TableName())
 	}
 	
-	hasAfterInsertClosures := len(session.afterInsertClosures) > 0 
+	hasAfterClosures := len(session.afterClosures) > 0 
 	for i := 0; i < size; i++ {
 		elemValue := sliceValue.Index(i).Interface()
 		// handle AfterInsertProcessor
 		if session.IsAutoCommit {
-			for _, closure := range session.afterInsertClosures {
+			for _, closure := range session.afterClosures {
 				closure(elemValue)
 			}
 			if processor, ok := interface{}(elemValue).(AfterInsertProcessor); ok {
 				processor.AfterInsert()
 			}
 		} else {
-			if hasAfterInsertClosures {
+			if hasAfterClosures {
 				session.afterInsertBeans = append(session.afterInsertBeans, elemValue)				
 			} else {
 				if _, ok := interface{}(elemValue).(AfterInsertProcessor); ok {
@@ -1837,7 +1793,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	session.Statement.RefTable = table
 
 	// handle BeforeInsertProcessor
-	for _, closure := range session.beforeInsertClosures {
+	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
 	if processor, ok := interface{}(bean).(BeforeInsertProcessor); ok {
@@ -1869,7 +1825,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	handleAfterInsertProcessorFunc := func(bean interface{}) {
 
 		if session.IsAutoCommit {
-			for _, closure := range session.afterInsertClosures {
+			for _, closure := range session.afterClosures {
 				closure(bean)
 			}
  			if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
@@ -1877,7 +1833,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 				processor.AfterInsert()
 			}
 		} else {
-			if len(session.afterInsertClosures) > 0 {
+			if len(session.afterClosures) > 0 {
 				session.afterInsertBeans = append(session.afterInsertBeans, bean)				
 			} else {
  				if _, ok := interface{}(bean).(AfterInsertProcessor); ok {
@@ -2173,7 +2129,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 
 
 	// handle before update processors
-	for _, closure := range session.beforeUpdateClosures {
+	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
 
@@ -2282,7 +2238,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 
 	// handle after update processors
 	if session.IsAutoCommit {
-		for _, closure := range session.afterUpdateClosures {
+		for _, closure := range session.afterClosures {
 			closure(bean)
 		}
 		if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
@@ -2290,7 +2246,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 			processor.AfterUpdate()
 		}
 	} else {
-		if len(session.afterInsertClosures) > 0 {
+		if len(session.afterClosures) > 0 {
 			session.afterUpdateBeans = append(session.afterUpdateBeans, bean)                               
 		} else {
 			if _, ok := interface{}(bean).(AfterUpdateProcessor); ok {
@@ -2367,7 +2323,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 
 
 	// handle before delete processors
-	for _, closure := range session.beforeDeleteClosures {
+	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
 
@@ -2410,7 +2366,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 
 	// handle after delete processors
 	if session.IsAutoCommit {
-		for _, closure := range session.afterDeleteClosures {
+		for _, closure := range session.afterClosures {
 			closure(bean)
 		}
 		if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
@@ -2418,7 +2374,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 			processor.AfterDelete()
 		}
 	} else {
-		if len(session.afterDeleteClosures) > 0 {
+		if len(session.afterClosures) > 0 {
 			session.afterDeleteBeans = append(session.afterDeleteBeans, bean)                               
 		} else {
 			if _, ok := interface{}(bean).(AfterDeleteProcessor); ok {

From fe91775981b61408d2017dbdfabf05358ee8dbd8 Mon Sep 17 00:00:00 2001
From: Nash Tsai <nash.tsai@gmail.com>
Date: Mon, 2 Dec 2013 14:23:53 +0800
Subject: [PATCH 3/4] add processors tests

---
 base_test.go | 182 ++++++++++++++++++++++++++++++++-------------------
 1 file changed, 114 insertions(+), 68 deletions(-)

diff --git a/base_test.go b/base_test.go
index 4e7f20fa..ec07feae 100644
--- a/base_test.go
+++ b/base_test.go
@@ -1709,160 +1709,206 @@ func testPrefixTableName(engine *Engine, t *testing.T) {
 type ProcessorsStruct struct {
 	Id int64
 	
-	B4InsertFlag bool
-	AfterInsertedFlag bool 
-	B4UpdateFlag bool
-	AfterUpdatedFlag bool
-	B4DeleteFlag bool `xorm:"-"`
-	AfterDeletedFlag bool `xorm:"-"`
+	B4InsertFlag int
+	AfterInsertedFlag int 
+	B4UpdateFlag int
+	AfterUpdatedFlag int
+	B4DeleteFlag int `xorm:"-"`
+	AfterDeletedFlag int `xorm:"-"`
 
-	B4InsertViaExt bool
-	AfterInsertedViaExt bool 
-	B4UpdateViaExt bool
-	AfterUpdatedViaExt bool
-	B4DeleteViaExt bool `xorm:"-"`
-	AfterDeletedViaExt bool `xorm:"-"`
+	B4InsertViaExt int
+	AfterInsertedViaExt int 
+	B4UpdateViaExt int
+	AfterUpdatedViaExt int
+	B4DeleteViaExt int `xorm:"-"`
+	AfterDeletedViaExt int `xorm:"-"`
 }
 
 func (p *ProcessorsStruct) BeforeInsert() {
-	p.B4InsertFlag = true
+	p.B4InsertFlag = 1
 }
 
 func (p *ProcessorsStruct) BeforeUpdate() {
-	p.B4UpdateFlag = true
+	p.B4UpdateFlag = 1
 }
 
 func (p *ProcessorsStruct) BeforeDelete() {
-	p.B4DeleteFlag = true
+	p.B4DeleteFlag = 1
 }
 
 func (p *ProcessorsStruct) AfterInsert() {
-	p.AfterInsertedFlag = true
+	p.AfterInsertedFlag = 1
 }
 
 func (p *ProcessorsStruct) AfterUpdate() {
-	p.AfterUpdatedFlag = true
+	p.AfterUpdatedFlag = 1
 }
 
 func (p *ProcessorsStruct) AfterDelete() {
-	p.AfterDeletedFlag = true
+	p.AfterDeletedFlag = 1
 }
 
 func testProcessors(engine *Engine, t *testing.T) {
-	err := engine.Sync(&ProcessorsStruct{})
+	tempEngine, err := NewEngine(engine.DriverName, engine.DataSourceName)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+	
+	tempEngine.ShowSQL = true
+	err = tempEngine.DropTables(&ProcessorsStruct{})
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	err = tempEngine.CreateTables(&ProcessorsStruct{})
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	}
 
 	p := &ProcessorsStruct{}
+
 	b4InsertFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
-			v.B4InsertViaExt = true
+		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+			v.B4InsertViaExt = 1
 		} else {
-			t.Fail()
+			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
 		}
 	}
 
 	afterInsertFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
-			v.AfterInsertedViaExt = true
+		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+			v.AfterInsertedViaExt = 1
 		} else {
-			t.Fail()
+			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
 		}
 	}
 		
-	_, err = engine.BeforeInsert(b4InsertFunc).AfterInsert(afterInsertFunc).Insert(p)
+	_, err = tempEngine.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	} else {
-		if !p.B4InsertFlag { t.Fail() }
-		if !p.AfterInsertedFlag { t.Fail() }
-		if !p.B4InsertViaExt { t.Fail() }
-		if !p.AfterInsertedViaExt { t.Fail() }
+		if p.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+		if p.AfterInsertedFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+		if p.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+		if p.AfterInsertedViaExt == 0 { t.Error(errors.New("AfterInsertedViaExt not set")) }
 	}
 		
 	p2 := &ProcessorsStruct{}
-	_, err = engine.Id(p.Id).Get(p2)
+	_, err = tempEngine.Id(p.Id).Get(p2)
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	} else {
-		if !p.B4InsertFlag { t.Fail() }
-		if p.AfterInsertedFlag { t.Fail() }
-		if !p.B4InsertViaExt { t.Fail() }
-		if p.AfterInsertedViaExt { t.Fail() }
+		if p2.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+		if p2.AfterInsertedFlag != 0 { t.Error(errors.New("AfterInsertedFlag is set")) }
+		if p2.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertViaExt not set")) }
+		if p2.AfterInsertedViaExt != 0 { t.Error(errors.New("AfterInsertedViaExt is set")) }
 	}
 
 	b4UpdateFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
-			v.B4UpdateViaExt = true
+		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+			v.B4UpdateViaExt = 1
 		} else {
-			t.Fail()
+			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
 		}
 	}
 
 	afterUpdateFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
-			v.AfterUpdatedViaExt = true
+		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+			v.AfterUpdatedViaExt = 1
 		} else {
-			t.Fail()
+			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
 		}
 	}
+	
+	p = p2 // reset
 
-	_, err = engine.BeforeUpdate(b4UpdateFunc).AfterUpdate(afterUpdateFunc).Update(p)
+	_, err = tempEngine.Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	} else {
-		if !p.B4UpdateFlag { t.Fail() }
-		if !p.AfterUpdatedFlag { t.Fail() }
-		if !p.B4UpdateViaExt { t.Fail() }
-		if !p.AfterUpdatedViaExt { t.Fail() }
+		if p.B4UpdateFlag == 0 { t.Error(errors.New("B4UpdateFlag not set")) }
+		if p.AfterUpdatedFlag == 0 { t.Error(errors.New("AfterUpdatedFlag not set")) }
+		if p.B4UpdateViaExt == 0 { t.Error(errors.New("B4UpdateViaExt not set")) }
+		if p.AfterUpdatedViaExt == 0 { t.Error(errors.New("AfterUpdatedViaExt not set")) }
 	}
-		
-	_, err = engine.Id(p.Id).Get(p2)
+	
+	p2 = &ProcessorsStruct{}	
+	_, err = tempEngine.Id(p.Id).Get(p2)
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	} else {
-		if !p.B4UpdateFlag { t.Fail() }
-		if p.AfterUpdatedFlag { t.Fail() }
-		if !p.B4UpdateViaExt { t.Fail() }
-		if p.AfterUpdatedViaExt { t.Fail() }
+		if p2.B4UpdateFlag == 0 { t.Error(errors.New("B4UpdateFlag not set")) }
+		if p2.AfterUpdatedFlag != 0 { t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag))) }
+		if p2.B4UpdateViaExt == 0 { t.Error(errors.New("B4UpdateViaExt not set")) }
+		if p2.AfterUpdatedViaExt != 0 { t.Error(errors.New("AfterUpdatedViaExt is set: " + string(p.AfterUpdatedViaExt))) }
 	}
 
 	b4DeleteFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
-			v.B4DeleteViaExt = true
+		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+			v.B4DeleteViaExt = 1
 		} else {
-			t.Fail()
+			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
 		}
 	}
 
 	afterDeleteFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(ProcessorsStruct); ok {
-			v.AfterDeletedViaExt = true
+		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+			v.AfterDeletedViaExt = 1
 		} else {
-			t.Fail()
+			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
 		}
 	}
-
-		
-	_, err = engine.BeforeDelete(b4DeleteFunc).AfterDelete(afterDeleteFunc).Delete(p)
+	
+	p = p2 // reset
+	_, err = tempEngine.Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	} else {
-		if !p.B4DeleteFlag { t.Fail() }
-		if !p.AfterDeletedFlag { t.Fail() }
-		if !p.B4DeleteViaExt { t.Fail() }
-		if !p.AfterDeletedViaExt { t.Fail() }
+		if p.B4DeleteFlag == 0 { t.Error(errors.New("B4DeleteFlag not set")) }
+		if p.AfterDeletedFlag == 0 { t.Error(errors.New("AfterDeletedFlag not set")) }
+		if p.B4DeleteViaExt == 0 { t.Error(errors.New("B4DeleteViaExt not set")) }
+		if p.AfterDeletedViaExt == 0 { t.Error(errors.New("AfterDeletedViaExt not set")) }
 	}
 
-	// !nashtsai! TODO insert many beans tests
+	// test insert multi
+	pslice := make([]*ProcessorsStruct, 0);
+	pslice = append(pslice, &ProcessorsStruct{})
+	pslice = append(pslice, &ProcessorsStruct{})
+	cnt, err := tempEngine.Before(b4InsertFunc).After(afterInsertFunc).Insert(&pslice)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	} else {
+		if cnt != 2 { t.Error(errors.New("incorrect insert count")) }
+		for _, elem := range pslice {
+			if elem.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+			if elem.AfterInsertedFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+			if elem.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+			if elem.AfterInsertedViaExt == 0 { t.Error(errors.New("AfterInsertedViaExt not set")) }
+		}
+	}
 	
+	for _, elem := range pslice {
+		p = &ProcessorsStruct{}
+		_, err = tempEngine.Id(elem.Id).Get(p)
+		if err != nil {
+			t.Error(err)
+			panic(err)
+		} else {
+			if p2.B4InsertFlag == 0 { t.Error(errors.New("B4InsertFlag not set")) }
+			if p2.AfterInsertedFlag != 0 { t.Error(errors.New("AfterInsertedFlag is set")) }
+			if p2.B4InsertViaExt == 0 { t.Error(errors.New("B4InsertViaExt not set")) }
+			if p2.AfterInsertedViaExt != 0 { t.Error(errors.New("AfterInsertedViaExt is set")) }
+		}
+	}
 }
 
 func testAll(engine *Engine, t *testing.T) {
@@ -1959,8 +2005,8 @@ func testAll2(engine *Engine, t *testing.T) {
 	testTime(engine, t)
 	fmt.Println("-------------- testPrefixTableName --------------")
 	testPrefixTableName(engine, t)
-	fmt.Println("-------------- transaction --------------")
-	transaction(engine, t)
 	fmt.Println("-------------- processors --------------")
 	testProcessors(engine, t)
+	fmt.Println("-------------- transaction --------------")
+	transaction(engine, t)
 }

From cc19af9498f81bffa7f533eac2c84e89794aa630 Mon Sep 17 00:00:00 2001
From: Nash Tsai <nash.tsai@gmail.com>
Date: Mon, 2 Dec 2013 14:53:23 +0800
Subject: [PATCH 4/4] code tidy up for processors tests

---
 base_test.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/base_test.go b/base_test.go
index ec07feae..3f0292f5 100644
--- a/base_test.go
+++ b/base_test.go
@@ -1771,7 +1771,7 @@ func testProcessors(engine *Engine, t *testing.T) {
 	p := &ProcessorsStruct{}
 
 	b4InsertFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+		if v, ok := (bean).(*ProcessorsStruct); ok {
 			v.B4InsertViaExt = 1
 		} else {
 			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
@@ -1779,7 +1779,7 @@ func testProcessors(engine *Engine, t *testing.T) {
 	}
 
 	afterInsertFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+		if v, ok := (bean).(*ProcessorsStruct); ok {
 			v.AfterInsertedViaExt = 1
 		} else {
 			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
@@ -1810,7 +1810,7 @@ func testProcessors(engine *Engine, t *testing.T) {
 	}
 
 	b4UpdateFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+		if v, ok := (bean).(*ProcessorsStruct); ok {
 			v.B4UpdateViaExt = 1
 		} else {
 			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
@@ -1818,7 +1818,7 @@ func testProcessors(engine *Engine, t *testing.T) {
 	}
 
 	afterUpdateFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+		if v, ok := (bean).(*ProcessorsStruct); ok {
 			v.AfterUpdatedViaExt = 1
 		} else {
 			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
@@ -1851,7 +1851,7 @@ func testProcessors(engine *Engine, t *testing.T) {
 	}
 
 	b4DeleteFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+		if v, ok := (bean).(*ProcessorsStruct); ok {
 			v.B4DeleteViaExt = 1
 		} else {
 			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))
@@ -1859,7 +1859,7 @@ func testProcessors(engine *Engine, t *testing.T) {
 	}
 
 	afterDeleteFunc := func(bean interface{}) {
-		if v, ok := interface{}(bean).(*ProcessorsStruct); ok {
+		if v, ok := (bean).(*ProcessorsStruct); ok {
 			v.AfterDeletedViaExt = 1
 		} else {
 			t.Error(errors.New("cast to ProcessorsStruct failed, how can this be!?"))