// Handler for HTTP Post - "/tasks"
// Insert a new Task document
func CreateTask(w http.ResponseWriter, r *http.Request) {
var dataResource TaskResource
// Decode the incoming Task json
err := json.NewDecoder(r.Body).Decode(&dataResource)
if err != nil {
common.DisplayAppError(
w,
err,
"Invalid Task data",
500,
)
return
}
task := &dataResource.Data
context := NewContext()
defer context.Close()
c := context.DbCollection("tasks")
repo := &data.TaskRepository{c}
// Insert a task document
repo.Create(task)
if j, err := json.Marshal(TaskResource{Data: *task}); err != nil {
common.DisplayAppError(
w,
err,
"An unexpected error has occurred",
500,
)
return
} else {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
w.Write(j)
}
}
// Handler for HTTP Get - "/notes/{id}"
// Returns a single Note document by id
func GetNoteById(w http.ResponseWriter, r *http.Request) {
// Get id from the incoming url
vars := mux.Vars(r)
id := vars["id"]
context := NewContext()
defer context.Close()
c := context.DbCollection("notes")
repo := &data.NoteRepository{c}
note, err := repo.GetById(id)
if err != nil {
if err == mgo.ErrNotFound {
w.WriteHeader(http.StatusNoContent)
return
} else {
common.DisplayAppError(w, err, "An unexpected error has occurred", 500)
return
}
}
if j, err := json.Marshal(note); err != nil {
common.DisplayAppError(w, err, "An unexpected error has occurred", 500)
return
} else {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(j)
}
}
// Handler for HTTP Post - "/notes"
// Insert a new Note document for a TaskId
func CreateNote(w http.ResponseWriter, r *http.Request) {
var dataResource NoteResource
// Decode the incoming Note json
err := json.NewDecoder(r.Body).Decode(&dataResource)
if err != nil {
common.DisplayAppError(w, err, "Invalid Note data", 500)
return
}
noteModel := dataResource.Data
note := &models.TaskNote{
TaskId: bson.ObjectIdHex(noteModel.TaskId),
Description: noteModel.Description,
}
context := NewContext()
defer context.Close()
c := context.DbCollection("notes")
//Insert a note document
repo := &data.NoteRepository{c}
repo.Create(note)
if j, err := json.Marshal(note); err != nil {
common.DisplayAppError(w, err, "An unexpected error has occurred", 500)
return
} else {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
w.Write(j)
}
}
// Handler for HTTP Put - "/notes/{id}"
// Update an existing Note document
func UpdateNote(w http.ResponseWriter, r *http.Request) {
// Get id from the incoming url
vars := mux.Vars(r)
id := bson.ObjectIdHex(vars["id"])
var dataResource NoteResource
// Decode the incoming Note json
err := json.NewDecoder(r.Body).Decode(&dataResource)
if err != nil {
common.DisplayAppError(w, err, "Invalid Note data", 500)
return
}
noteModel := dataResource.Data
note := &models.TaskNote{
Id: id,
Description: noteModel.Description,
}
context := NewContext()
defer context.Close()
c := context.DbCollection("notes")
repo := &data.NoteRepository{c}
//Update note document
if err := repo.Update(note); err != nil {
common.DisplayAppError(w, err, "An unexpected error has occurred", 500)
return
} else {
w.WriteHeader(http.StatusNoContent)
}
}
// Handler for HTTP Put - "/tasks/{id}"
// Update an existing Task document
func UpdateTask(w http.ResponseWriter, r *http.Request) {
// Get id from the incoming url
vars := mux.Vars(r)
id := bson.ObjectIdHex(vars["id"])
var dataResource TaskResource
// Decode the incoming Task json
err := json.NewDecoder(r.Body).Decode(&dataResource)
if err != nil {
common.DisplayAppError(
w,
err,
"Invalid Task data",
500,
)
return
}
task := &dataResource.Data
task.Id = id
context := NewContext()
defer context.Close()
c := context.DbCollection("tasks")
repo := &data.TaskRepository{c}
// Update an existing Task document
if err := repo.Update(task); err != nil {
common.DisplayAppError(
w,
err,
"An unexpected error has occurred",
500,
)
return
} else {
w.WriteHeader(http.StatusNoContent)
}
}
// Handler for HTTP Post - "/users/register"
// Add a new User document
func Register(w http.ResponseWriter, r *http.Request) {
var dataResource UserResource
// Decode the incoming User json
err := json.NewDecoder(r.Body).Decode(&dataResource)
if err != nil {
common.DisplayAppError(
w,
err,
"Invalid User data",
500,
)
return
}
user := &dataResource.Data
context := NewContext()
defer context.Close()
c := context.DbCollection("users")
repo := &data.UserRepository{c}
// Insert User document
repo.CreateUser(user)
// Clean-up the hashpassword to eliminate it from response JSON
user.HashPassword = nil
if j, err := json.Marshal(UserResource{Data: *user}); err != nil {
common.DisplayAppError(
w,
err,
"An unexpected error has occurred",
500,
)
return
} else {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
w.Write(j)
}
}
// Handler for HTTP Get - "/notes"
// Returns all Note documents
func GetNotes(w http.ResponseWriter, r *http.Request) {
context := NewContext()
defer context.Close()
c := context.DbCollection("notes")
repo := &data.NoteRepository{c}
notes := repo.GetAll()
j, err := json.Marshal(NotesResource{Data: notes})
if err != nil {
common.DisplayAppError(w, err, "An unexpected error has occurred", 500)
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(j)
}
// Handler for HTTP Delete - "/notes/{id}"
// Delete an existing Note document
func DeleteNote(w http.ResponseWriter, r *http.Request) {
// Get id from the incoming url
vars := mux.Vars(r)
id := vars["id"]
context := NewContext()
defer context.Close()
c := context.DbCollection("notes")
repo := &data.NoteRepository{c}
//Delete a note document
err := repo.Delete(id)
if err != nil {
common.DisplayAppError(w, err, "An unexpected error has occurred", 500)
return
}
w.WriteHeader(http.StatusNoContent)
}
// Handler for HTTP Delete - "/tasks/{id}"
// Delete an existing Task document
func DeleteTask(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id := vars["id"]
context := NewContext()
defer context.Close()
c := context.DbCollection("tasks")
repo := &data.TaskRepository{c}
// Delete an existing Task document
err := repo.Delete(id)
if err != nil {
common.DisplayAppError(
w,
err,
"An unexpected error has occurred",
500,
)
return
}
w.WriteHeader(http.StatusNoContent)
}
// Handler for HTTP Get - "/tasks/users/{id}"
// Returns all Tasks created by a User
func GetTasksByUser(w http.ResponseWriter, r *http.Request) {
// Get id from the incoming url
vars := mux.Vars(r)
user := vars["id"]
context := NewContext()
defer context.Close()
c := context.DbCollection("tasks")
repo := &data.TaskRepository{c}
tasks := repo.GetByUser(user)
j, err := json.Marshal(TasksResource{Data: tasks})
if err != nil {
common.DisplayAppError(
w,
err,
"An unexpected error has occurred",
500,
)
return
}
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
w.Write(j)
}
// Handler for HTTP Post - "/users/login"
// Authenticate with username and apssword
func Login(w http.ResponseWriter, r *http.Request) {
var dataResource LoginResource
var token string
// Decode the incoming Login json
err := json.NewDecoder(r.Body).Decode(&dataResource)
if err != nil {
common.DisplayAppError(
w,
err,
"Invalid Login data",
500,
)
return
}
loginModel := dataResource.Data
loginUser := models.User{
Email: loginModel.Email,
Password: loginModel.Password,
}
context := NewContext()
defer context.Close()
c := context.DbCollection("users")
repo := &data.UserRepository{c}
// Authenticate the login user
if user, err := repo.Login(loginUser); err != nil {
common.DisplayAppError(
w,
err,
"Invalid login credentials",
401,
)
return
} else { //if login is successful
// Generate JWT token
token, err = common.GenerateJWT(user.Email, "member")
if err != nil {
common.DisplayAppError(
w,
err,
"Eror while generating the access token",
500,
)
return
}
w.Header().Set("Content-Type", "application/json")
// Clean-up the hashpassword to eliminate it from response JSON
user.HashPassword = nil
authUser := AuthUserModel{
User: user,
Token: token,
}
j, err := json.Marshal(AuthUserResource{Data: authUser})
if err != nil {
common.DisplayAppError(
w,
err,
"An unexpected error has occurred",
500,
)
return
}
w.WriteHeader(http.StatusOK)
w.Write(j)
}
}