func VersionHandler(w http.ResponseWriter, r *http.Request) {
rp := VersionResponse{
Hash: conf.Hash,
}
httpres.Json(w, http.StatusOK, rp)
}
func ListUsersHandler(w http.ResponseWriter, r *http.Request) {
fields := ListUsersForm{}
cef, err := form.Parse(&fields, w, r)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
if cef.HasError() {
cef.Error.Send(http.StatusBadRequest)
return
}
users := []model.User{}
s := conf.M.Copy()
defer s.Close()
m := bson.M{}
if fields.Name != "" {
//todo: do full text search instead
m["name"] = bson.RegEx{fields.Name, "i"}
}
q := s.DB("").C("users").Find(m)
totalCount, err := q.Count()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
p := paging.Paging{
Page: fields.Page,
Limit: fields.Limit,
Count: totalCount,
}.Calc()
if err = q.
Limit(p.Limit).
Skip(p.Offset).
Sort("-created_at").
All(&users); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
rp := UsersResponse{
Users: users,
CurrentPage: p.Page,
TotalPagesCount: p.TotalPages,
}
httpres.Json(w, http.StatusOK, rp)
}
func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
fields := createUserForm{}
// parse & validate your form and response errors with a pretty json error message
// if not all fields are valid
// e.g.
//
// HTTP 400
// {
// "message": "Invalid Data",
// "fields": {
// "email": "must be a valid email address",
// "password": "******"
// }
// }
if formutils.ParseSend(w, r, &fields) {
// oh! some fields are not valid, exit your handler
return
}
// OR use formutils.Parse(r, &fields) instead if you don't want to response
// with an error message automatically.
// Handle your invalids manually
// invalids, err := formutils.Parse(r, &fields)
// everything is OK, fields should be filled with their values
fmt.Println(fields)
httpres.Json(w, http.StatusCreated, fields)
}
func VersionHandler(w http.ResponseWriter, r *http.Request) {
rp := VersionResponse{
Hash: githash,
Time: buildstamp,
}
httpres.Json(w, http.StatusOK, rp)
}
func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
fields := CreateUserForm{}
cef, err := form.Parse(&fields, w, r)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
if cef.HasError() {
cef.Error.Send(http.StatusBadRequest)
return
}
hash, err := cryptoutils.Hash(fields.Password, conf.PasswordLevel)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
user := model.User{
ID: bson.NewObjectId(),
Name: fields.Name,
Email: strings.TrimSpace(fields.Email),
Hash: hash,
CreatedAt: time.Now(),
}
s := conf.M.Copy()
defer s.Close()
if err := s.DB("").C("users").Insert(&user); err != nil {
if mgo.IsDup(err) {
cef.Error.SendMessage("this email address already exists", http.StatusBadRequest)
return
}
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
token := model.NewToken(user.ID)
if err := s.DB("").C("tokens").Insert(&token); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
user.AccessToken = token.Token
httpres.Json(w, http.StatusCreated, UserResponse{user})
}
func ListUsersHandler(w http.ResponseWriter, r *http.Request) {
fields := listUsersForm{}
if formutils.ParseSend(w, r, &fields) {
return
}
m := bson.M{}
if fields.Name != "" {
//todo: do full text search instead
m["name"] = bson.RegEx{fields.Name, "i"}
}
q := ctx.M(r).DB("").C("users").Find(m)
totalCount, err := q.Count()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
p := paging.Paging{
Page: fields.Page,
Limit: fields.Limit,
Count: totalCount,
}.Calc()
users := []model.User{}
if err = q.
Limit(p.Limit).
Skip(p.Offset).
Sort("-created_at").
All(&users); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
rp := usersResponse{
Users: users,
CurrentPage: p.Page,
TotalPagesCount: p.TotalPages,
}
httpres.Json(w, http.StatusOK, rp)
}
func CreateEventHandler(w http.ResponseWriter, r *http.Request) {
event := model.Event{}
if formutils.ParseSend(w, r, &event) {
return
}
if err := ctx.M(r).DB("").C("events").Insert(&event); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
httpres.Json(w, http.StatusCreated, eventResponse{Event: event})
}
func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
fields := createUserForm{}
if formutils.ParseSend(w, r, &fields) {
return
}
hash, err := cryptoutils.Hash(fields.Password, conf.PasswordLevel)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
user := model.User{
ID: bson.NewObjectId(),
Name: fields.Name,
Email: strings.TrimSpace(fields.Email),
PasswordHash: hash,
CreatedAt: time.Now(),
}
if err := ctx.M(r).DB("").C("users").Insert(&user); err != nil {
if mgo.IsDup(err) {
eres.New(w).AddField("email", "already exists").Send()
return
}
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
token := model.NewToken(user.ID, false)
if err := ctx.M(r).DB("").C("tokens").Insert(&token); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
rp := userResponse{
User: user,
AccessToken: token.Token,
}
httpres.Json(w, http.StatusCreated, rp)
}
func CreateTokenHandler(w http.ResponseWriter, r *http.Request) {
fields := CreateTokenForm{}
cef, err := form.Parse(&fields, w, r)
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
if cef.HasError() {
cef.Error.Send(http.StatusBadRequest)
return
}
var user model.User
s := conf.M.Copy()
defer s.Close()
if err := s.DB("").C("users").Find(bson.M{
"email": strings.TrimSpace(fields.Email),
}).One(&user); err != nil {
if err == mgo.ErrNotFound {
cef.Error.SendMessage("bad credentials", http.StatusBadRequest)
return
}
log.Println(err)
w.WriteHeader(http.StatusBadRequest)
return
}
if err := bcrypt.CompareHashAndPassword([]byte(user.Hash), []byte(fields.Password)); err != nil {
cef.Error.SendMessage("bad credentials", http.StatusBadRequest)
return
}
token := model.NewToken(user.ID)
if err := s.DB("").C("tokens").Insert(&token); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
httpres.Json(w, http.StatusCreated, TokenResponse{token.Token})
}
func ListEventsHandler(w http.ResponseWriter, r *http.Request) {
fields := listEventsForm{}
if formutils.ParseSend(w, r, &fields) {
return
}
q := ctx.M(r).DB("").C("events")
totalCount, err := q.Count()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
p := paging.Paging{
Page: fields.Page,
Limit: fields.Limit,
Count: totalCount,
}.Calc()
events := []model.Event{}
if err := q.Find(nil).
Skip(p.Offset).
Limit(p.Limit).
Sort("-date").
All(&events); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
rp := eventsResponse{
CurrentPage: p.Page,
TotalPagesCount: p.TotalPages,
Events: events,
}
httpres.Json(w, http.StatusOK, rp)
}
func GetUserHandler(w http.ResponseWriter, r *http.Request) {
id, err := bsonutils.ObjectId(mux.Vars(r)["id"])
if err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
var user model.User
if err := ctx.M(r).DB("").C("users").FindId(id).One(&user); err != nil {
if err == mgo.ErrNotFound {
w.WriteHeader(http.StatusNotFound)
return
}
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
httpres.Json(w, http.StatusOK, userResponse{User: user})
}
func CreateTokenHandler(w http.ResponseWriter, r *http.Request) {
fields := createTokenForm{}
if formutils.ParseSend(w, r, &fields) {
return
}
var user model.User
if err := ctx.M(r).DB("").C("users").Find(bson.M{
"email": strings.TrimSpace(fields.Email),
}).One(&user); err != nil {
if err == mgo.ErrNotFound {
eres.New(w).SetMessage("bad credentials").Send()
return
}
log.Println(err)
w.WriteHeader(http.StatusBadRequest)
return
}
if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(fields.Password)); err != nil {
eres.New(w).SetMessage("bad credentials").Send()
return
}
token := model.NewToken(user.ID, fields.Forever)
if err := ctx.M(r).DB("").C("tokens").Insert(&token); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
httpres.Json(w, http.StatusCreated, tokenResponse{token.Token})
}
func GetUserHandler(w http.ResponseWriter, r *http.Request) {
id, ok := bsonutils.ObjectId(mux.Vars(r)["id"])
if !ok {
w.WriteHeader(http.StatusNotFound)
return
}
var user model.User
s := conf.M.Copy()
defer s.Close()
if err := s.DB("").C("users").FindId(id).One(&user); err != nil {
if err == mgo.ErrNotFound {
w.WriteHeader(http.StatusNotFound)
return
}
log.Println(err)
return
}
httpres.Json(w, http.StatusOK, UserResponse{user})
}
func GetMeHandler(w http.ResponseWriter, r *http.Request) {
user := model.CurrentUser(r)
httpres.Json(w, http.StatusOK, UserResponse{*user})
}
func (res *Response) Send() {
if res.Message == "" {
res.Message = "Invalid Data"
}
httpres.Json(res.w, http.StatusBadRequest, res)
}
