Example #1
0
func main() {
	// To access a RethinkDB database, you connect to it with the Connect function
	session, err := r.Connect("localhost:28015", "company_info")
	if err != nil {
		fmt.Println("error connecting:", err)
		return
	}

	var response []Employee
	// Using .All(), we can read the entire response into a slice, without iteration
	err = r.Table("employees").Run(session).All(&response)
	if err != nil {
		fmt.Println("err:", err)
	} else {
		fmt.Println("response:", response)
	}

	// If we want to iterate over each result individually, we can use the rows
	// object as an iterator
	rows := r.Table("employees").Run(session)
	for rows.Next() {
		var row Employee
		if err = rows.Scan(&row); err != nil {
			fmt.Println("err:", err)
			break
		}
		fmt.Println("row:", row)
	}
	if err = rows.Err(); err != nil {
		fmt.Println("err:", err)
	}
}
Example #2
0
func RegisterUser(user, password string, context *ServerContext) (err error) {
	request := r.Table("login").Filter(r.Row.Attr("Username").Eq(user))
	var result []LoginDBEntry
	if err = context.DB.MakeRequest(request).All(&result); err != nil {
		return
	}
	if len(result) == 1 {
		err = errors.New("Duplicate user")
		return
	}

	pepper := []byte(pepperStr)
	pass := []byte(password)

	crypt := hmaccrypt.New(sha512.New, pepper)

	var digest []byte
	if digest, err = crypt.Bcrypt(pass, 10); err != nil {
		return
	}

	digestStr := string(digest)

	row := LoginDBEntry{user, digestStr}
	request = r.Table("login").Insert(row)
	err = context.DB.MakeRequest(request).Err()

	return
}
func todoCreateHandler(w http.ResponseWriter, r *http.Request) {
	var todo Todo
	var response rethink.WriteResponse

	todoBody, err := ioutil.ReadAll(r.Body)
	if err != nil {
		fmt.Println("Error reading request body:", err)
	}

	err = json.Unmarshal(todoBody, &todo)
	if err != nil {
		fmt.Println("Error unmarshalling request body:", err)
	}

	err = rethink.Table(TODO_TABLE).Insert(todo).Run(session).One(&response)
	if err != nil {
		fmt.Println("Error inserting record:", err)
	}

	responseBody := map[string]string{}
	responseBody["id"] = response.GeneratedKeys[0]
	responseBodyText, err := json.Marshal(responseBody)
	if err != nil {
		fmt.Println("Unable to marshal response:", err)
	}
	fmt.Fprintf(w, "%s", responseBodyText)
}
Example #4
0
// This will convert a URL into a short url
func ShortenHandler(w http.ResponseWriter, request *http.Request, session *r.Session) {
	body, err := ioutil.ReadAll(request.Body)
	if err != nil {
		http.Error(w, fmt.Sprintf("Could not parse POST body: %v", err), http.StatusInternalServerError)
	}

	var postRequest POSTRequest
	err = json.Unmarshal(body, &postRequest)
	if err != nil {
		http.Error(w, fmt.Sprintf("Could not decode JSON: %v", err), http.StatusPreconditionFailed)
	}

	url := postRequest.URL

	var response r.WriteResponse
	row := r.Map{"url": url}
	err = r.Table("url_mapping").Insert(row).Run(session).One(&response)
	if err != nil {
		log.Print(err)
		http.Error(w, "Could not save URL", http.StatusInternalServerError)
	}

	id := response.GeneratedKeys[0]

	fmt.Fprintf(w, "http://%s/%s", request.Host, id)
}
Example #5
0
func (c AccountsController) CreateAccount(account models.Account, render render.Render, session *rethinkgo.Session) {
	log.Println("account", account)
	err := rethinkgo.Table("accounts").Insert(account).Run(session).Err()
	if err != nil {
		panic(err)
	}
	c.GetAccounts(render, session)
}
Example #6
0
func (c AccountsController) GetAccount(params martini.Params, render render.Render, session *rethinkgo.Session) {
	var account *models.Account
	err := rethinkgo.Table("accounts").Get(params["id"]).Run(session).One(&account)
	if err != nil {
		panic(err)
	}
	render.JSON(200, account)
}
Example #7
0
func (c AccountsController) GetAccounts(render render.Render, session *rethinkgo.Session) {
	var accounts []*models.Account
	err := rethinkgo.Table("accounts").Run(session).All(&accounts)
	if err != nil {
		panic(err)
	}
	render.JSON(200, accounts)
}
Example #8
0
func handleIndex(res http.ResponseWriter, req *http.Request) {
	session := sessionArray[0]
	var response []Bookmark

	err := r.Table("bookmarks").Run(session).All(&response)
	if err != nil {
		log.Fatal(err)
	}

	data, _ := json.Marshal(response)

	res.Header().Set("Content-Type", "application/json")
	res.Write(data)
}
Example #9
0
func (self User) All() []User {
	log.Println("User.All")
	session := database.getSession()

	var users []User
	err := rethinkgo.Table("users").Run(session).All(&users)

	if err != nil {
		log.Println("[ERROR] User.All: ", err)
		panic(err)
	}

	return users
}
Example #10
0
func (self User) FindById(id string) User {
	log.Println("User.FindById")
	session := database.getSession()

	var user User
	err := rethinkgo.Table("users").Get(id).Run(session).One(&user)

	if err != nil {
		log.Println("[ERROR] User.All: ", err)
		panic(err)
	}

	return user
}
Example #11
0
func insertBookmark(res http.ResponseWriter, req *http.Request) {
	session := sessionArray[0]

	b := new(Bookmark)
	json.NewDecoder(req.Body).Decode(b)

	var response r.WriteResponse

	err := r.Table("bookmarks").Insert(b).Run(session).One(&response)
	if err != nil {
		log.Fatal(err)
		return
	}
	data, _ := json.Marshal("{'bookmark':'saved'}")
	res.Header().Set("Content-Type", "application/json; charset=utf-8")
	res.Write(data)
}
Example #12
0
// This will convert a short URL into the full website
func EmbiggenHandler(w http.ResponseWriter, request *http.Request, session *r.Session) {
	vars := mux.Vars(request)
	key := vars["key"]

	//id := utils.Decode(key)

	var result map[string]interface{}
	err := r.Table("url_mapping").Get(key, "id").Run(session).One(&result)
	if err != nil || len(result) == 0 {
		log.Print(err)
		http.NotFound(w, request)
	}

	url := result["url"]

	fmt.Fprintf(w, "%s", url)
}
Example #13
0
func VerifyPassword(user, password string, context *ServerContext) (valid bool, err error) {
	request := r.Table("login").Filter(r.Row.Attr("Username").Eq(user))
	var result []LoginDBEntry
	err = context.DB.MakeRequest(request).All(&result)

	digestStr := result[0].Password
	digest := []byte(digestStr)
	pass := []byte(password)
	pepper := []byte(pepperStr)

	crypt := hmaccrypt.New(sha512.New, pepper)

	if err = crypt.BcryptCompare(digest, pass); err == nil {
		valid = true
	} else {
		valid = false
	}

	return
}
Example #14
0
func (self User) Create(params map[string]string) User {
	// Setup session
	session := database.getSession()

	// Setup table
	table := rethinkgo.Table("users")

	errors := make(map[string]string)
	user := User{Username: params["username"],
		FirstName: params["first_name"],
		LastName:  params["last_name"],
		Email:     params["email"],
		Handle:    params["handle"]}

	if params["password"] != params["password_confirmation"] {
		errors["password"] = "******"

		user.Errors = errors
	} else {
		userMap := rethinkgo.Map{
			"username":      params["username"],
			"password_hash": passwordHash(params["password"]),
			"first_name":    params["first_name"],
			"last_name":     params["last_name"],
			"email":         params["email"],
			"handle":        params["handle"],
			"created_at":    time.Now()}

		// insert the reading
		var response rethinkgo.WriteResponse
		err := table.Insert(userMap).Run(session).One(&response)

		if err != nil {
			log.Println("[ERROR] User.Create: ", err)
			errors["unknown"] = err.Error()
			user.Errors = errors
		}
	}

	return user
}
func (todo *Todo) Delete() (rethink.WriteResponse, error) {
	var response rethink.WriteResponse
	err := rethink.Table(TODO_TABLE).Get(todo.Id).Delete().Run(session).One(&response)
	return response, err
}
func (todo *Todo) Update() (response rethink.WriteResponse, err error) {
	err = rethink.Table(TODO_TABLE).Get(todo.Id).Update(todo).Run(session).One(&response)
	return
}
func getTodo(id string) (todo Todo, err error) {
	err = rethink.Table(TODO_TABLE).Get(id).Run(session).One(&todo)
	return
}
func getTodos() (todos []Todo, err error) {
	err = rethink.Table(TODO_TABLE).Run(session).All(&todos)
	return
}