func ImageHandler(ctx wombat.Context, a *articles.Article, path, filename string) {
ctx.Response.Header().Set("Content-Type", "application/json")
// Save the image
img, err := web.SaveImage(ctx.Request, ctx.Response, path, filename)
if err != nil {
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
return
}
s := img.Bounds().Size()
exists := false
// Add or Update the image
for _, v := range a.Imgs {
if v.Src == filename {
v.W, v.H = s.X, s.Y
exists = true
}
}
if !exists {
a.Imgs = append(a.Imgs, articles.Img{filename, "", s.X, s.Y})
}
// Update the article's images
if err = a.SetImgs(a.Imgs); err != nil {
log.Println("Failed to persit new image: ", filename, " for article: ", a.TitlePath)
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
} else {
j := fmt.Sprintf(`{"image":"%s", "w":%d,"h":%d}`, filename, s.X, s.Y)
ctx.Response.Write([]byte(j))
}
}
func ThumbHandler(ctx wombat.Context, a *articles.Article, path, filename string) {
ctx.Response.Header().Set("Content-Type", "application/json")
// Save & resize the image to a thumbnail
img, err := web.SaveImage(ctx.Request, ctx.Response, path, filename)
if err == nil {
// Resize the image and save it
if img, err = imagery.ResizeWidth(img, 200); err == nil {
err = imagery.WriteTo(web.ImageType(ctx.Request), img, path, filename)
}
}
if err != nil {
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
return
}
oldThumb := filepath.Join(path, a.TitlePath, a.Img.Src)
s := img.Bounds().Size()
// Update the article's thumbnail
if err = a.SetImg(articles.Img{filename, filename, s.X, s.Y}); err != nil {
log.Println("Failed to persit new thumbnail: ", filename, " for article: ", a.TitlePath)
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
} else {
os.Remove(oldThumb)
j := fmt.Sprintf(`{"thumb":"%s", "w":%d,"h":%d}`, filename, s.X, s.Y)
ctx.Response.Write([]byte(j))
}
}
func JSONHandler(ctx wombat.Context, a *articles.Article, imagePath string, data []byte) {
// Get the JSONMessage from the request
var msg JSONMessage
err := json.Unmarshal(data, &msg)
if err != nil {
ctx.HttpError(http.StatusBadRequest, GetError(ctx.Request, err))
return
}
// Perform the given action
switch msg.Action {
default:
// Invalid/missing action
err = errors.New("Invalid Action")
case "setSynopsis":
err = a.SetSynopsis(msg.Data)
case "setContent":
err = a.SetContent(msg.Data)
case "setActive":
// Toggle
err = a.Publish(!a.IsPublished)
case "deleteImage":
err = RemoveImage(a, msg.Data, imagePath)
}
// Report if the action resulted in an error
if err != nil {
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
}
}
func (h Handler) DeleteArticle(ctx wombat.Context, titlePath string) {
ctx.Response.Header().Set("Content-Type", "application/json")
o, ok := h.Article(titlePath, true)
if !ok {
ctx.HttpError(http.StatusNotFound)
return
}
a := h.ItoArticle(o)
if err := a.Delete(); err != nil {
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
}
}
func (h Handler) PostArticles(ctx wombat.Context) {
title := ctx.FormValue("title")
if request.IsApplicationJson(ctx.Request) {
ctx.Response.Header().Set("Content-Type", "application/json")
defer ctx.Body.Close()
if b, err := ioutil.ReadAll(ctx.Body); err != nil {
m := make(map[string]interface{})
json.Unmarshal(b, &m)
title, _ = m["title"].(string)
}
}
if title == "" {
// Missing title
ctx.HttpError(http.StatusBadRequest, GetErrorStr(ctx.Request, "Missing title"))
return
}
t, err := CreateArticle(ctx, title)
if err != nil {
ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
return
}
// When not a JSON request issue redirect to new article
if !request.IsApplicationJson(ctx.Request) {
ctx.Redirect(fmt.Sprintf("%s/%s?view=edit", h.BasePath, t))
}
}
func ImagesHandler(ctx wombat.Context, a *articles.Article, imagePath string) {
// Get the name of the image, or random name if missing/empty
filename := ctx.FormValue("name")
if filename == "" {
filename = web.RandName(5)
}
// Save the thumbnail, or image
path := filepath.Join(imagePath, a.TitlePath)
if t := ctx.FormValue("type"); t == "thumb" {
ThumbHandler(ctx, a, path, "thumb."+filename)
} else {
ImageHandler(ctx, a, path, filename)
}
}
/*----------Article-----------*/
func (h Handler) GetArticle(ctx wombat.Context, titlePath string) {
isAdmin := ctx.User.IsAdmin()
o, ok := h.Article(titlePath, isAdmin)
if !ok {
ctx.HttpError(http.StatusNotFound)
return
}
tmpl := "view"
if isAdmin && ctx.FormValue("view") == "edit" {
tmpl = "edit"
}
// Handle HTTP/JSON response
articleResponse(ctx, &h, o, tmpl, titlePath)
}
/*----------Articles----------*/
func (h Handler) GetArticles(ctx wombat.Context) {
var tmpl string
var o interface{}
switch view := ctx.FormValue("view"); {
default:
tmpl = "list"
page, err := strconv.Atoi(ctx.FormValue("page"))
if err != nil {
page = 0
}
o, _ = h.articles.Recent(h.PageCount, page, ctx.User.IsAdmin())
case view == "create" && ctx.User.IsAdmin():
tmpl = "create"
}
// Handle HTTP/JSON response
articleResponse(ctx, &h, o, tmpl, "")
}
func (h Handler) PutArticle(ctx wombat.Context, titlePath string) {
ctx.Response.Header().Set("Content-Type", "application/json")
o, ok := h.Article(titlePath, true)
if !ok {
ctx.HttpError(http.StatusNotFound)
return
}
a := h.ItoArticle(o)
// JSON message
if request.IsApplicationJson(ctx.Request) {
// Get the bytes for JSON processing
defer ctx.Body.Close()
if data, err := ioutil.ReadAll(ctx.Body); err != nil {
ctx.HttpError(http.StatusBadRequest, GetError(ctx.Request, err))
} else {
JSONHandler(ctx, a, h.ImagePath, data)
}
} else if IsImageRequest(ctx) {
ImagesHandler(ctx, a, h.ImagePath)
} else {
// Nothing could be done for the given request
ctx.HttpError(http.StatusBadRequest)
}
}