Donn't override old value when seting same value

Author: pengwei

README.md

@@ -14,18 +14,24 @@ Use cookie as session, base on [secure cookie](https://github.com/go-http-utils/
 * Interfaces and infrastructure for custom session backends: sessions from
   different stores can be retrieved and batch-saved using a common API.
 
+##Installation
+```go
+go get github.com/go-http-utils/cookie-session
+```
 ##Examples
 ```go
 go run cookiesession/main.go
 ```
 ##Usage
 ```go
-    store := sessions.New([]string{"key"})
+    store := sessions.NewCookieStore([]string{"key"})
 	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		store.Init(w, r, false)
-		session, _ := sessions.Get(sessionkey, store)
-		session.Values["name"] = "mushroom"
-		println(session.Values["name"].(string)) //get session
+	  	session, _ := store.Get(sessionkey, w, r)
+		if val, ok := session.Values["name"]; ok {
+			println(val)
+		} else {
+			session.Values["name"] = "mushroom"
+		}
 		session.Save()
 	})
 ```

cookiesession/main.go

@@ -11,29 +11,29 @@ func main() {
 
 	sessionkey := "sessionid"
 
+	store := sessions.NewCookieStore([]string{})
+
 	req, _ := http.NewRequest("GET", "/", nil)
 
 	recorder := httptest.NewRecorder()
 	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-
-		store := sessions.NewCookieStore([]string{"key"})
-
-		session, _ := sessions.New(sessionkey, store, w, r)
-
-		session.Values["name"] = "mushroom"
-
+		session, _ := store.Get(sessionkey, w, r)
+		if val, ok := session.Values["name"]; ok {
+			println(val)
+		} else {
+			session.Values["name"] = "mushroom"
+		}
 		session.Save()
-
 	})
 	handler.ServeHTTP(recorder, req)
 
 	//======reuse=====
+	store = sessions.NewCookieStore([]string{})
 	cookies, _ := getCookie(sessionkey, recorder)
 	req.AddCookie(cookies)
 	handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		store := sessions.NewCookieStore([]string{"key"})
 
-		session, _ := sessions.New(sessionkey, store, w, r)
+		session, _ := store.Get(sessionkey, w, r)
 
 		println(session.Values["name"].(string))
 	})

cookiestore.go

@@ -1,8 +1,8 @@
 package sessions
 
 import (
-	"errors"
 	"net/http"
+	"reflect"
 
 	"github.com/go-http-utils/cookie"
 )
@@ -22,43 +22,42 @@ type Options struct {
 }
 
 // NewCookieStore an CookieStore instance
-func NewCookieStore(Keys []string, options ...*Options) (store *CookieStore) {
-	if len(Keys) == 0 {
-		panic(errors.New("invalid keys parameter"))
-	}
-	store = &CookieStore{keys: Keys}
+func NewCookieStore(keys []string, options ...*Options) (store *CookieStore) {
+	store = &CookieStore{keys: keys}
 	if len(options) > 0 {
 		store.options = options[0]
 	}
+	if len(keys) > 0 && len(keys[0]) > 0 {
+		store.signed = true
+	}
 	return
 }
 
 // CookieStore stores sessions using secure cookies.
 type CookieStore struct {
-	cookie  *cookie.Cookies
 	options *Options
 	keys    []string
-	signed  bool // optional
-}
-
-// Init an CookieStore instance
-func (c *CookieStore) Init(w http.ResponseWriter, r *http.Request, signed bool) {
-	c.cookie = cookie.New(w, r, c.keys)
-	c.signed = signed
-	return
+	signed  bool
 }
 
-// Get existed session from Request's cookies
-func (c *CookieStore) Get(name string) (data map[string]interface{}, err error) {
-	val, _ := c.cookie.Get(name, c.signed)
+// Get a session instance by name and any kind of stores
+func (c *CookieStore) Get(name string, w http.ResponseWriter, r *http.Request) (session *Session, err error) {
+	cookie := cookie.New(w, r, c.keys)
+	session = NewSession(name, c, w, r)
+	val, _ := cookie.Get(name, c.signed)
 	if val != "" {
-		Decode(val, &data)
+		Decode(val, &session.Values)
 	}
+	session.AddCache("cookie", cookie)
+	session.AddCache("lastvalue", session.Values)
 	return
 }
 
 // Save session to Response's cookie
-func (c *CookieStore) Save(name string, data map[string]interface{}) (err error) {
+func (c *CookieStore) Save(w http.ResponseWriter, r *http.Request, session *Session) (err error) {
+	if reflect.DeepEqual(session.GetCache("lastvalue"), session.Values) {
+		return
+	}
 	opts := &cookie.Options{
 		Path:     "/",
 		HTTPOnly: true,
@@ -72,9 +71,9 @@ func (c *CookieStore) Save(name string, data map[string]interface{}) (err error)
 		opts.Secure = c.options.Secure
 		opts.HTTPOnly = c.options.HTTPOnly
 	}
-	val, err := Encode(data)
+	val, err := Encode(session.Values)
 	if err == nil {
-		c.cookie.Set(name, val, opts)
+		session.GetCache("cookie").(*cookie.Cookies).Set(session.Name(), val, opts)
 	}
 	return
 }

sessions.go

@@ -8,11 +8,26 @@ import (
 
 // Session stores the values and optional configuration for a session.
 type Session struct {
-	sid    string
 	Values map[string]interface{}
+	SID    string
 	store  Store
 	name   string
-	//oldval string
+	cache  map[string]interface{}
+	w      http.ResponseWriter
+	req    *http.Request
+}
+
+// NewSession to create new session instance
+func NewSession(name string, store Store, w http.ResponseWriter, r *http.Request) (session *Session) {
+	session = &Session{
+		Values: make(map[string]interface{}),
+		store:  store,
+		name:   name,
+		w:      w,
+		req:    r,
+		cache:  make(map[string]interface{}),
+	}
+	return
 }
 
 // Name returns the name used to register the session
@@ -25,50 +40,37 @@ func (s *Session) Store() Store {
 	return s.store
 }
 
-// New a session instance by name and any kind of stores
-func New(name string, store Store, w http.ResponseWriter, r *http.Request, signed ...bool) (session *Session, err error) {
-	session = &Session{
-		store: store,
-		name:  name,
-	}
-	var issigned = false
-	if len(signed) > 0 {
-		issigned = signed[0]
-	}
-	store.Init(w, r, issigned)
-	session.Values, err = store.Get(name)
-
-	if session.Values == nil {
-		session.Values = make(map[string]interface{})
+// AddCache to add data cache for thirdparty store implement, like store the last value to check whether changed when saving
+func (s *Session) AddCache(key string, val interface{}) {
+	switch v := val.(type) {
+	case map[string]interface{}:
+		s.cache[key] = copyMap(val.(map[string]interface{}))
+	default:
+		s.cache[key] = v
 	}
-	return
 }
 
-// New a new session instance by name base on current store
-func (s *Session) New(name string) *Session {
-	session := &Session{
-		Values: make(map[string]interface{}),
-		store:  s.store,
-		name:   name,
+func copyMap(cache map[string]interface{}) (data map[string]interface{}) {
+	data = make(map[string]interface{})
+	for k, v := range cache {
+		switch val := v.(type) {
+		case map[string]interface{}:
+			data[k] = copyMap(val)
+		default:
+			data[k] = val
+		}
 	}
-	return session
+	return
 }
 
-// Get a new session instance by name base on current store
-func (s *Session) Get(name string) (session *Session, err error) {
-	session = &Session{
-
-		Values: make(map[string]interface{}),
-		store:  s.store,
-		name:   name,
-	}
-	session.Values, err = s.store.Get(session.name)
-	return
+// GetCache cache data from current Session
+func (s *Session) GetCache(name string) interface{} {
+	return s.cache[name]
 }
 
 // Save is a convenience method to save current session
 func (s *Session) Save() (err error) {
-	s.store.Save(s.name, s.Values)
+	s.store.Save(s.w, s.req, s)
 	return
 }
 
@@ -97,11 +99,9 @@ func Decode(value string, dst interface{}) (err error) {
 
 // Store is an interface for custom session stores.
 type Store interface {
-	Init(w http.ResponseWriter, r *http.Request, signed bool)
-
 	// Get should return a cached session string.
-	Get(name string) (map[string]interface{}, error)
+	Get(name string, w http.ResponseWriter, r *http.Request) (session *Session, err error)
 
 	// Save should persist session to the underlying store implementation.
-	Save(name string, data map[string]interface{}) error
+	Save(w http.ResponseWriter, r *http.Request, session *Session) error
 }