Esempio n. 1
0
// GET render specified store from specified DB
func Store(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	msgk, msgv := c.GetFlash()
	if !rpc.HasStore(c.GetPathVar("store")) {
		c.SetFlash("alertError", "Invalid store")
		http.Redirect(w, r, fmt.Sprintf("/%s", c.GetPathVar("db")), 303)
		return
	}
	ts.Render(w, "store.tmpl", tmpl.Model{
		msgk:          msgv,
		"savedSearch": GetSavedSearches(c.Get("db").(string), c.GetPathVar("store")),
		"db":          c.Get("db"),
		"stores":      rpc.GetAllStoreStats(),
		"store":       rpc.GetAll(c.GetPathVar("store")),
		"storeName":   c.GetPathVar("store"),
		"query":       GetSavedSearch(c.Get("db").(string), c.GetPathVar("store"), r.FormValue("query")),
	})
	return
}
Esempio n. 2
0
// GET render specified record from specified store in connected DB
func Record(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	msgk, msgv := c.GetFlash()
	record := rpc.Get(c.GetPathVar("store"), GetId(c.GetPathVar("record")))
	if record == nil {
		c.SetFlash("alertError", "Invalid Record")
		http.Redirect(w, r, fmt.Sprintf("/%s/%s", c.GetPathVar("db"), c.GetPathVar("store")), 303)
		return
	}
	ts.Render(w, "record.tmpl", tmpl.Model{
		msgk:        msgv,
		"db":        c.Get("db"),
		"stores":    rpc.GetAllStoreStats(),
		"storeName": c.GetPathVar("store"),
		"record":    record,
	})
	return
}
Esempio n. 3
0
// POST save search made on store
func SaveSearch(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	var savedSearch map[string]map[string]string

	config.GetAs("search", c.Get("db").(string), &savedSearch)
	if savedSearch == nil {
		savedSearch = make(map[string]map[string]string)
	}
	if savedSearch[c.GetPathVar("store")] == nil {
		savedSearch[c.GetPathVar("store")] = make(map[string]string)
	}
	savedSearch[c.GetPathVar("store")][r.FormValue("name")] = r.FormValue("search")
	config.Set("search", c.Get("db").(string), savedSearch)
	c.SetFlash("alertSuccess", "Successfully saved search")
	http.Redirect(w, r, fmt.Sprintf("/%s", c.GetPathVar("store")), 303)
	return
}
Esempio n. 4
0
func reloadTemplates(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if r.FormValue("user") == "admin" && r.FormValue("pass") == "admin" {
		ts.Load()
		c.SetFlash("alertSuccess", "Successfully reloaded templates")
	}
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 5
0
// POST add new db connection
func AddConnection(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	var connection map[string]string
	config.GetAs("connections", r.FormValue("name"), &connection)
	if connection == nil {
		println(3)
		connection = make(map[string]string)
	}
	connection["address"] = r.FormValue("address")
	connection["token"] = r.FormValue("token")
	config.Set("connections", r.FormValue("name"), connection)
	c.SetFlash("alertSuccess", "Successfully added connection")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 6
0
func EraseDB(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	rpc.ClearAll()
	c.SetFlash("alertSuccess", "Successfully erased database")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 7
0
// POST delete record from specified store in connected DB
func DelRecord(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	rpc.Del(c.GetPathVar("store"), GetId(c.GetPathVar("record")))
	c.SetFlash("alertSuccess", "Successfully deleted record")
	http.Redirect(w, r, fmt.Sprintf("/%s", c.GetPathVar("store")), 303)
	return
}
Esempio n. 8
0
// GET connect to DB
func Connect(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	var connection map[string]string
	if config.GetAs("connections", c.GetPathVar("db"), &connection) {
		if address, ok := connection["address"]; ok && address != "" {
			if rpc.Connect(address, connection["token"]) {
				c.SetFlash("alertSuccess", "Successfully connected to database")
				c.Set("db", c.GetPathVar("db"))
				http.Redirect(w, r, "/", 303)
				return
			}
		}
	}
	c.SetFlash("alertError", "Error connecting to the database")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 9
0
// POST upload .json file of records to add to store
func UploadRecords(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	r.ParseMultipartForm(32 << 20) // 32 MB
	file, handler, err := r.FormFile("data")
	if err != nil || len(handler.Header["Content-Type"]) < 1 {
		fmt.Println(err)
		c.SetFlash("alertError", "Error uploading file")
		http.Redirect(w, r, "/"+c.GetPathVar("store")+"/import", 303)
		return
	}
	defer file.Close()
	var m []map[string]interface{}
	switch handler.Header["Content-Type"][0] {
	case "application/json":
		dec := json.NewDecoder(file)
		err = dec.Decode(&m)
	case "text/csv":
		m, err = DecodeCSV(file)
	default:
		c.SetFlash("alertError", "Error uploading file")
		http.Redirect(w, r, "/"+c.GetPathVar("store")+"/import", 303)
		return
	}

	if err != nil {
		fmt.Println(err)
		c.SetFlash("alertError", "Error uploading file")
		http.Redirect(w, r, "/"+c.GetPathVar("store")+"/import", 303)
		return
	}

	for _, doc := range m {
		SanitizeMap(&doc)
		rpc.Add(c.GetPathVar("store"), doc)
	}
	c.SetFlash("alertSuccess", "Successfully imported data")
	http.Redirect(w, r, "/"+c.GetPathVar("store"), 303)
	return
}
Esempio n. 10
0
// POST add record to specified store in connected DB
func AddRecord(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	record := r.FormValue("record")
	var rec map[string]interface{}
	json.Unmarshal([]byte(record), &rec)
	rpc.Add(c.GetPathVar("store"), rec)
	c.SetFlash("alertSuccess", "Successfully added record")

	http.Redirect(w, r, fmt.Sprintf("/%s", c.GetPathVar("store")), 303)
	return
}
Esempio n. 11
0
// GET render empty record for specified store from connected DB
func NewRecord(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	msgk, msgv := c.GetFlash()
	ts.Render(w, "record.tmpl", tmpl.Model{
		msgk:        msgv,
		"db":        c.Get("db"),
		"stores":    rpc.GetAllStoreStats(),
		"storeName": c.GetPathVar("store"),
		"record":    "",
	})
	return
}
Esempio n. 12
0
// POST update existing DB connection
func SaveConnection(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	var connection map[string]string
	ok := config.GetAs("connections", r.FormValue("name"), &connection)
	if r.FormValue("name") != r.FormValue("oldName") {
		if ok {
			c.SetFlash("alertError", "Error connection name already exists")
			http.Redirect(w, r, "/", 303)
			return
		}
		config.Del("connections", r.FormValue("oldName"))
	}
	if connection == nil {
		connection = make(map[string]string)
	}
	connection["address"] = r.FormValue("address")
	connection["token"] = r.FormValue("token")
	config.Set("connections", r.FormValue("name"), connection)
	c.SetFlash("alertSuccess", "Successfully updated connection")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 13
0
// POST delete store from connected DB
func DelStore(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	if !rpc.DelStore(c.GetPathVar("store")) {
		c.SetFlash("alertError", "Error deleteing store")
	} else {
		c.SetFlash("alertSuccess", "Successfully deleted store")
	}
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 14
0
// POST add store to connected DB
func SaveStore(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}
	name := r.FormValue("name")
	if ok := rpc.AddStore(name); ok {
		c.SetFlash("alertSuccess", "Successfully saved store")
	} else {
		c.SetFlash("alertError", "Error saving store")
	}
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 15
0
func multiLogin(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	slug := c.GetPathVar("slug")
	c.Login("driver")
	c.SetFlash("success", "You are now logged into "+slug+". Enjoy")
	http.Redirect(w, r, "/"+slug, 303)
}
Esempio n. 16
0
func adminLogin(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	c.Login("admin")
	c.SetFlash("success", "You are now logged into. Enjoy")
	http.Redirect(w, r, "/admin", 303)
}
Esempio n. 17
0
// POST delete saved DB connection
func DelConnection(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	config.Del("connections", c.GetPathVar("db"))
	c.SetFlash("alertSuccess", "Successfully deleted connection")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 18
0
// GET disconnect from DB
func Disconnect(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	rpc.Disconnect()
	c.SetFlash("alertSuccess", "Disconnected")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 19
0
// POST upload .tar file of .json files to add stores and records to connected DB
func ImportDB(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	if !rpc.Alive() {
		http.Redirect(w, r, "/", 303)
		c.SetFlash("alertError", "Error no connection to a database")
		return
	}
	if c.Get("db") == nil || c.Get("db").(string) == "" {
		http.Redirect(w, r, "/disconnect", 303)
		return
	}

	r.ParseMultipartForm(32 << 20) // 32 MB
	tarFile, handler, err := r.FormFile("import")
	if err != nil || len(handler.Header["Content-Type"]) < 1 {
		fmt.Printf("dbdbClient >> ImportDB() >> lenfile header: %v", err)
		c.SetFlash("alertError", "Error uploading file")
		http.Redirect(w, r, "/"+c.GetPathVar("store")+"/import", 303)
		return
	}
	defer tarFile.Close()

	if handler.Header["Content-Type"][0] != "application/z-tar" {
		c.SetFlash("alertError", "Incorrect file type")
		http.Redirect(w, r, "/", 303)
	}

	tarReader := tar.NewReader(tarFile)
	tarData := make(map[string][]map[string]interface{})
	for {
		hdr, err := tarReader.Next()
		if err == io.EOF {
			// end of tar archive
			break
		}
		if err != nil {
			fmt.Printf("dbdbClient >> ImportDB() >> tarReader.Next(): %v", err)
			c.SetFlash("alertError", "Error uploading file")
			http.Redirect(w, r, "/", 303)
			return
		}

		buf := new(bytes.Buffer)
		io.Copy(buf, tarReader)
		b := buf.Bytes()
		var st []map[string]interface{}
		json.Unmarshal(b, &st)
		tarData[strings.Split(hdr.Name, ".")[0]] = st
	}

	b, err := json.Marshal(tarData)
	if err != nil {
		c.SetFlash("alertError", "Error reading file")
		http.Redirect(w, r, "/", 303)
	}
	rpc.Import(b)

	/*for store, data := range tarData {
		rpc.AddStore(store)
		for _, doc := range data {
			rpc.Add(store, doc)
		}
	}*/

	c.SetFlash("alertSuccess", "Successfully imported database")
	http.Redirect(w, r, "/", 303)
	return
}
Esempio n. 20
0
func logout(w http.ResponseWriter, r *http.Request, c *webc.Context) {
	slug := c.GetPathVar("slug")
	c.Logout()
	c.SetFlash("success", "You are now logged out. Thanks for visiting")
	http.Redirect(w, r, "/"+slug, 303)
}