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 }