func TestReadTerm(t *testing.T) {
readTerm := new(data.Term)
testRead(t, "/taxonomy/"+term.Term, readTerm)
readTerm.UpdateTime = term.UpdateTime
structJSONCompare(t, term, readTerm)
}
func TestSelectTerm(t *testing.T) {
selectedTerm := new(data.Term)
selectedTerm.Term = term.Term
t.Log(selectedTerm.Term)
err := Select(selectedTerm)
if err != nil {
t.Error(err)
}
t.Log(term.UpdateTime.UTC())
t.Log(selectedTerm.UpdateTime.UTC())
selectedTerm.UpdateTime = term.UpdateTime
structJSONCompare(t, term, selectedTerm)
}
func scanTerm(term *data.Term, rows *sql.Rows) error {
var updateTimeString string
cols, err := rows.Columns()
if err != nil {
return err
}
if len(cols) < 5 {
err = rows.Scan(
&term.Term,
&term.Automated,
&term.Author,
&updateTimeString,
)
} else {
err = rows.Scan(
&term.Term,
&term.Automated,
&term.Author,
&updateTimeString,
&term.Count,
)
}
if err != nil {
return err
}
// TODO: this is a hacky fix for null times
if updateTimeString == "0000-00-00 00:00:00" {
updateTimeString = "0001-01-01 00:00:00"
}
updateTime, err := time.Parse("2006-01-02 15:04:05", updateTimeString) // this assumes UTC as timezone
if err != nil {
log.Println("Term scanner failed to parse time.")
return err
}
term.UpdateTime = updateTime
return nil
}
// Generic Delete handler
func Delete(w http.ResponseWriter, r *http.Request) {
user, permissions := auth.Challenge(w, r, true)
if user == nil || permissions < 1 {
http.Error(w, "Please Login", http.StatusUnauthorized)
return
}
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
vars := mux.Vars(r)
var (
val interface{} // Generic container for the deleted object
err error
)
// Build a URI like representation of the datatype
types := []string{vars["datatype"]}
if childtype, ok := vars["childtype"]; ok {
types = append(types, childtype)
}
// Switch based on that URI like representation and instantiate something in the generic container. Also infer the identifier from the vars and perform validation.
switch strings.Join(types, "/") {
case "items":
item := new(data.Item)
item.ID, err = strconv.ParseInt(vars["key"], 10, 64)
val = item
case "items/comments":
comment := new(data.ItemComment)
comment.ID, err = strconv.ParseInt(vars["childkey"], 10, 64)
val = comment
case "users":
if vars["key"] != user.Username {
http.Error(w, "Please don't delete other users", http.StatusUnauthorized)
return
}
user := new(data.User)
user.Username = vars["key"]
val = user
case "roles":
role := new(data.Role)
role.Title = vars["key"]
val = role
case "taxonomy":
term := new(data.Term)
term.Term = vars["key"]
val = term
default:
http.NotFound(w, r)
return
}
if err != nil {
log.Println(err)
http.Error(w, "Malformed key in URI", http.StatusBadRequest)
return
}
// Perform the delete
err = storage.Delete(val)
if err == storage.ErrZeroAffected {
http.Error(w, "No matches for query", http.StatusNotFound)
return
} else if err != nil {
log.Println(err)
http.Error(w, "Delete Database error, likely due to malformed request", http.StatusInternalServerError)
return
}
// Confirm the delete
w.WriteHeader(http.StatusNoContent)
}
// Generic Read handler for reading single objects
func Read(w http.ResponseWriter, r *http.Request) {
//No Auth for the moment
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
vars := mux.Vars(r)
var (
val interface{} // Generic container for the read object
err error
)
// Build a URI like representation of the datatype
types := []string{vars["datatype"]}
if childtype, ok := vars["childtype"]; ok {
types = append(types, childtype)
}
// Switch based on that URI like representation and instantiate something in the generic container. Also infer the identifier from the vars and perform validation.
switch strings.Join(types, "/") {
case "items":
item := new(data.Item)
item.ID, err = strconv.ParseInt(vars["key"], 10, 64)
val = item
case "items/comments":
comment := new(data.ItemComment)
comment.ID, err = strconv.ParseInt(vars["childkey"], 10, 64)
val = comment
case "users":
user := new(data.User)
user.Username = vars["key"]
val = user
case "users/direction":
direction := new(data.UserDirection)
direction.Username = vars["key"]
val = direction
case "roles":
role := new(data.Role)
role.Title = vars["key"]
val = role
case "taxonomy":
term := new(data.Term)
term.Term = vars["key"]
val = term
case "taxonomy/ranking":
ranking := new(data.TermRanking)
ranking.Term = vars["key"]
val = ranking
default:
http.NotFound(w, r)
return
}
if err != nil {
log.Println(err)
http.Error(w, "Malformed key in URI", http.StatusBadRequest)
return
}
// Perform the Select
err = storage.Select(val)
if err == storage.ErrZeroAffected {
http.Error(w, "No matches for query", http.StatusNotFound)
return
} else if err != nil {
log.Println(err)
http.Error(w, "Select Database error, likely due to malformed request", http.StatusInternalServerError)
return
}
// Important. Let's never send salt/hash out.
switch v := val.(type) {
case *data.User:
v.Salt = ""
v.Password = ""
}
w.Header().Set("Content-Type", "application/json") // Header are important when GZIP is enabled
// Return the object we've selected from the database.
encoder := json.NewEncoder(w)
err = encoder.Encode(val)
if err != nil {
log.Println(err)
}
}