github.com/aerth/userinfo@v0.0.0-20160917202326-6c837af3a47b/userinfo.go (about)

     1  /*
     2  Userinfo library for web applications to store userdata in a BoltDB.
     3  
     4  */
     5  
     6  package userinfo
     7  
     8  import (
     9  	"encoding/base64"
    10  	"encoding/json"
    11  	"log"
    12  	"math/rand"
    13  	"os"
    14  	"time"
    15  
    16  	"github.com/boltdb/bolt"
    17  )
    18  
    19  func init() {
    20  	ran = rand.New(rand.NewSource(time.Now().UnixNano())) // new random source
    21  }
    22  
    23  var users = map[string]Person{}
    24  var objectboxes = map[string]ObjectBox{}
    25  var objects = map[string]UserObject{}
    26  var db *bolt.DB
    27  var ran *rand.Rand
    28  var blankUser Person
    29  var err error
    30  var dbname = ".db"
    31  
    32  type Person struct {
    33  	ID, FirstName, LastName, NickName, Email, Data string      `json:",omitempty"`
    34  	Gender, BodyType, Age, LookingFor              uint8       `json:",string,omitempty"`
    35  	Height, ZipCode                                uint32      `json:",string,omitempty"`
    36  	More                                           interface{} `json:",string,omitempty"`
    37  }
    38  
    39  type ObjectBox struct {
    40  	OwnerID      string    // Doesn't need ObjectBox ID because each user only has one
    41  	TimeCreated  time.Time `json:",string"`
    42  	TimeModified time.Time `json:",string,omitempty"`
    43  	Bucket       string    `json:",omitempty"`        // big
    44  	Objects      []string  `json:",string,omitempty"` // big
    45  
    46  }
    47  
    48  func (ob UserObject) Base64() string {
    49  	file, err := os.Open(ob.ObjectID)
    50  	if err != nil {
    51  		log.Println(err)
    52  		return ""
    53  	}
    54  	var b = make([]byte, ob.Size)
    55  	n, err := file.Read(b)
    56  	if err != nil {
    57  		log.Println(err)
    58  		return ""
    59  	}
    60  	return string(b[:n])
    61  }
    62  
    63  func (ob UserObject) RawBytes() []byte {
    64  	file, err := os.Open(ob.ObjectID)
    65  	if err != nil {
    66  		log.Println(err)
    67  		return []byte("")
    68  	}
    69  	var b = make([]byte, ob.Size)
    70  	n, err := file.Read(b)
    71  	if err != nil {
    72  		log.Println(err)
    73  		return []byte("")
    74  	}
    75  	dst := make([]byte, 1024*1000)
    76  	i, err := base64.StdEncoding.Decode(dst, b[:n])
    77  	return dst[:i]
    78  }
    79  
    80  type UserObject struct {
    81  	OwnerID      string
    82  	ObjectID     string
    83  	Title        string
    84  	Filename     string
    85  	Extension    string
    86  	Data         string    `json:",omitempty"` // base64 encoded inside json encoded
    87  	TimeCreated  time.Time `json:",string"`
    88  	TimeModified time.Time `json:",string,omitempty"`
    89  	Size         int       `json:",string"`
    90  	IsMessage    bool      `json:",string,omitempty"`
    91  	IsMedia      bool      `json:",string,omitempty"`
    92  	IsFile       bool      `json:",string,omitempty"`
    93  	IsPublic     bool      `json:",string,omitempty"`
    94  	Permissions  []string  // List of users able to view/read the databytes
    95  	ImgSrc       string    `json:",omitempty"`
    96  	ImgBase64    string    `json:",omitempty"`
    97  	LinkHref     string    `json:",omitempty"`
    98  	LinkTitle    string    `json:",omitempty"`
    99  	Ref          string    `json:",omitempty"`
   100  	Class        string    `json:",omitempty"` // for css
   101  }
   102  
   103  //var userdatas = map[string]ObjectBox{}
   104  
   105  func Delete(bucket, key string) error {
   106  	// Delete the key in a different write transaction.
   107  	if err := db.Update(func(tx *bolt.Tx) error {
   108  		return tx.Bucket([]byte(bucket)).Delete([]byte(key))
   109  	}); err != nil {
   110  		return err
   111  	}
   112  	return nil
   113  }
   114  
   115  // Write: Insert data into a bucket.
   116  func Write(bucket, key string, value []byte) error {
   117  	if err = db.Update(func(tx *bolt.Tx) error {
   118  		b, err := tx.CreateBucketIfNotExists([]byte(bucket))
   119  		if err != nil {
   120  			return err
   121  		}
   122  
   123  		if key != "" { // blank key just creates the bucket. nil value still gets stored if key is named.
   124  			if err := b.Put([]byte(key), value); err != nil {
   125  				return err
   126  			}
   127  		}
   128  
   129  		return nil
   130  	}); err != nil {
   131  		return err
   132  	}
   133  	return nil
   134  }
   135  
   136  // Read: retrieve []byte(value) of bucket[key]
   137  func Read(bucket, key string) []byte {
   138  	if bucket == "" || key == "" {
   139  		return nil
   140  	}
   141  
   142  	var v []byte
   143  	err = db.View(func(tx *bolt.Tx) error {
   144  		if tx.Bucket([]byte(bucket)) == nil {
   145  			return nil
   146  		}
   147  		v = tx.Bucket([]byte(bucket)).Get([]byte(key))
   148  		return nil // no error
   149  	})
   150  	if err != nil {
   151  		log.Println(err)
   152  		return nil
   153  
   154  	}
   155  	return v
   156  }
   157  
   158  // Scan updates the (memory) user map. Must be called after writes to the db
   159  func Scan() map[string]Person {
   160  	var i = 0
   161  	if err = db.Update(func(tx *bolt.Tx) error {
   162  		b, err := tx.CreateBucketIfNotExists([]byte("user"))
   163  		if err != nil {
   164  			return err
   165  		}
   166  
   167  		// Iterate over items in sorted key order.
   168  		if err := b.ForEach(func(k, v []byte) error {
   169  			i++
   170  			var user Person
   171  			err = json.Unmarshal(v, &user)
   172  			if err != nil {
   173  				return err
   174  			}
   175  			// Insert into user map[id string]user
   176  			users[string(k)] = user
   177  			return nil
   178  		}); err != nil {
   179  			return err
   180  		}
   181  		return nil
   182  	}); err != nil {
   183  		log.Fatal(err)
   184  	}
   185  	return users
   186  }
   187  
   188  // Scan updates the (memory) user map. Must be called after writes to the userdata db to get the true map
   189  func ScanObjectBoxes() map[string]ObjectBox {
   190  	var i = 0
   191  	if err = db.Update(func(tx *bolt.Tx) error {
   192  		b, err := tx.CreateBucketIfNotExists([]byte("objectbox"))
   193  		if err != nil {
   194  			return err
   195  		}
   196  
   197  		// Iterate over items in sorted key order.
   198  		if err := b.ForEach(func(k, v []byte) error {
   199  			i++
   200  			var ud ObjectBox
   201  			err = json.Unmarshal(v, &ud)
   202  			if err != nil {
   203  				return err
   204  			}
   205  			// Insert into user map[id string]user
   206  			objectboxes[string(k)] = ud
   207  			return nil
   208  		}); err != nil {
   209  			return err
   210  		}
   211  		return nil
   212  	}); err != nil {
   213  		log.Fatal(err)
   214  	}
   215  	return objectboxes
   216  }
   217  
   218  // Scan updates the (memory) user map. Must be called after writes to the userdata db to get the true map
   219  func ScanObjects() map[string]UserObject {
   220  	var i = 0
   221  	if err = db.Update(func(tx *bolt.Tx) error {
   222  		b, err := tx.CreateBucketIfNotExists([]byte("object"))
   223  		if err != nil {
   224  			return err
   225  		}
   226  
   227  		// Iterate over items in sorted key order.
   228  		if err := b.ForEach(func(k, v []byte) error {
   229  			i++
   230  			var ud UserObject
   231  			err = json.Unmarshal(v, &ud)
   232  			if err != nil {
   233  				return err
   234  			}
   235  			// Insert into user map[id string]user
   236  			objects[string(k)] = ud
   237  			return nil
   238  		}); err != nil {
   239  			return err
   240  		}
   241  		return nil
   242  	}); err != nil {
   243  		log.Fatal(err)
   244  	}
   245  	return objects
   246  }
   247  
   248  // Init 1
   249  // userinfo.Init("the.db", []string{"user","userdata","objects"})
   250  func Init(location string, buckets []string) {
   251  	db, err = bolt.Open(location, 0666, nil)
   252  	if err != nil {
   253  		log.Fatal(err)
   254  	}
   255  
   256  	// go func() {
   257  	// 	log.Println("Starting stats loop")
   258  	// 	for {
   259  	// 		fmt.Println("stats:", db.Stats().TxStats.WriteTime)
   260  	// 		time.Sleep(10 * time.Second)
   261  	// 		// create buckets if they dont exist
   262  	// 	}
   263  	// }()
   264  	for _, bucket := range buckets {
   265  		err = Write(bucket, "", nil)
   266  		if err != nil {
   267  			log.Println(err)
   268  		}
   269  	}
   270  
   271  }
   272  
   273  // Close safely close BoltDB
   274  func Close() {
   275  	if err := db.Close(); err != nil {
   276  		log.Fatal(err)
   277  	}
   278  }