// POST: /node
func (cr *Controller) Create(cx *goweb.Context) {
// Log Request and check for Auth
request.Log(cx.Request)
u, err := request.Authenticate(cx.Request)
if err != nil && err.Error() != e.NoAuth {
request.AuthError(err, cx)
return
}
// Fake public user
if u == nil {
if conf.Bool(conf.Conf["anon-write"]) {
u = &user.User{Uuid: ""}
} else {
cx.RespondWithErrorMessage(e.NoAuth, http.StatusUnauthorized)
return
}
}
// Parse uploaded form
params, files, err := request.ParseMultipartForm(cx.Request)
if err != nil {
// If not multipart/form-data it will create an empty node.
// TODO: create another request parser for non-multipart request
// to handle this cleaner.
if err.Error() == "request Content-Type isn't multipart/form-data" {
n, err := node.CreateNodeUpload(u, params, files)
if err != nil {
logger.Error("Error at create empty: " + err.Error())
cx.RespondWithError(http.StatusInternalServerError)
return
}
if n == nil {
// Not sure how you could get an empty node with no error
// Assume it's the user's fault
cx.RespondWithError(http.StatusBadRequest)
return
} else {
cx.RespondWithData(n)
return
}
} else {
// Some error other than request encoding. Theoretically
// could be a lost db connection between user lookup and parsing.
// Blame the user, Its probaby their fault anyway.
logger.Error("Error parsing form: " + err.Error())
cx.RespondWithError(http.StatusBadRequest)
return
}
}
// Create node
n, err := node.CreateNodeUpload(u, params, files)
if err != nil {
logger.Error("err@node_CreateNodeUpload: " + err.Error())
cx.RespondWithErrorMessage(err.Error(), http.StatusBadRequest)
return
}
cx.RespondWithData(n)
return
}
// POST: /node
func (cr *NodeController) Create(ctx context.Context) error {
u, err := request.Authenticate(ctx.HttpRequest())
if err != nil && err.Error() != e.NoAuth {
return request.AuthError(err, ctx)
}
// Fake public user
if u == nil {
if conf.Bool(conf.Conf["anon-write"]) {
u = &user.User{Uuid: ""}
} else {
return responder.RespondWithError(ctx, http.StatusUnauthorized, e.NoAuth)
}
}
// Parse uploaded form
params, files, err := request.ParseMultipartForm(ctx.HttpRequest())
if err != nil {
if err.Error() == "request Content-Type isn't multipart/form-data" {
// If not multipart/form-data it will try to read the Body of the
// request. If the Body is not empty it will create a file from
// the Body contents. If the Body is empty it will create an empty
// node.
if ctx.HttpRequest().ContentLength != 0 {
params, files, err = request.DataUpload(ctx.HttpRequest())
if err != nil {
err_msg := "Error uploading data from request body:" + err.Error()
logger.Error(err_msg)
return responder.RespondWithError(ctx, http.StatusInternalServerError, err_msg)
}
}
n, cn_err := node.CreateNodeUpload(u, params, files)
if cn_err != nil {
err_msg := "Error at create empty node: " + cn_err.Error()
logger.Error(err_msg)
return responder.RespondWithError(ctx, http.StatusInternalServerError, err_msg)
}
if n == nil {
// Not sure how you could get an empty node with no error
// Assume it's the user's fault
return responder.RespondWithError(ctx, http.StatusBadRequest, "Error, could not create node.")
} else {
return responder.RespondWithData(ctx, n)
}
} else {
// Some error other than request encoding. Theoretically
// could be a lost db connection between user lookup and parsing.
// Blame the user, Its probaby their fault anyway.
err_msg := "Error parsing form: " + err.Error()
logger.Error(err_msg)
return responder.RespondWithError(ctx, http.StatusBadRequest, err_msg)
}
}
// Create node
n, err := node.CreateNodeUpload(u, params, files)
if err != nil {
err_msg := "err@node_CreateNodeUpload: " + err.Error()
logger.Error(err_msg)
return responder.RespondWithError(ctx, http.StatusBadRequest, err_msg)
}
return responder.RespondWithData(ctx, n)
}
