func (cc *CommentController) Post() {
form := new(CommentForm)
if err := cc.Validator.Validate(form, cc); err != nil {
cc.JSONError(200, err)
return
}
form.Type = cc.Param("type")
form.Id = cc.ParamInt64("id")
// create comment object
var (
c = new(model.Comment)
)
if err := service.Call(service.Comment.Create, form.toCreateOption(), c); err != nil {
cc.JSONError(200, err)
return
}
// save comment object
if err := service.Call(service.Comment.Save, c, c); err != nil {
cc.JSONError(200, err)
return
}
cc.JSON(map[string]interface{}{
"comment": model.NewFrontComment(c),
})
}
func (ac *ArticleController) Get() {
var (
article = new(model.Article)
opt = service.ArticleReadOption{
Id: ac.ParamInt64(":id"),
Link: ac.Param(":link"),
Status: model.ARTICLE_STATUS_PUBLISH,
IsHit: true,
IsPublish: true,
}
opt2 = service.CommentListOption{
From: model.COMMENT_FROM_ARTICLE,
Status: 0,
}
comments = make([]*model.Comment, 0)
)
if err := service.Call(service.Article.Read, opt, article); err != nil {
status := 500
if err == service.ErrArticleNotFound {
status = 404
}
ac.RenderError(status, err)
return
}
if article.Id != opt.Id || article.Link != opt.Link {
ac.RenderError(404, nil)
return
}
opt2.FromId = article.Id
if service.Setting.Comment.ShowWaitComment {
opt2.AllAccessible = true
} else {
opt2.AllApproved = true
}
if err := service.Call(service.Comment.ListForContent, opt2, &comments); err != nil {
ac.RenderError(500, err)
return
}
shouldShowComments := true
if article.IsCommentClosed() && len(comments) == 0 {
shouldShowComments = false
}
if ac.AuthUser != nil {
ac.Assign(middle.AuthUserTemplateField, nil) // set auth user nil instead of middleware assignment
ac.Assign("FrontUser", model.NewFrontUser(ac.AuthUser))
}
ac.Title(article.Title + " - " + service.Setting.General.Title)
ac.Assign("Article", article)
ac.Assign("Comments", comments)
ac.Assign("ShouldShowComments", shouldShowComments)
ac.Assign("IsCommentEnable", article.IsCommentable(service.Setting.Comment.AutoCloseDay))
ac.Assign("CommentUrl", fmt.Sprintf("/comment/article/%d", article.Id))
ac.Assign("XsrfHTML", ac.XsrfFormHtml())
ac.Render("single.tmpl")
}
func (aic *AdvImportController) Post() {
opt := service.ImportOption{
User: aic.AuthUser,
}
t := strings.ToLower(aic.Param("type"))
if t == "goblog" {
opt.Type = service.IMPORT_TYPE_GOBLOG
_, h, err := aic.Req().FormFile("file")
if err != nil {
aic.JSONError(500, err)
return
}
savePath := fmt.Sprintf("_temp/%s", h.Filename)
if err := os.MkdirAll(path.Dir(savePath), os.ModePerm); err != nil {
aic.JSONError(500, err)
return
}
if err := aic.SaveToFile("file", savePath); err != nil {
aic.JSONError(500, err)
return
}
opt.TempFile = savePath
if err := service.Call(service.Import.Import, opt); err != nil {
aic.JSONError(500, err)
return
}
}
aic.JSON(nil)
}
func (pc *PageController) Get() {
pageLink := pc.Param(":link")
if len(pageLink) == 0 {
pc.RenderError(404, nil)
return
}
var (
page = new(model.Page)
opt = service.PageReadOption{
Id: pc.ParamInt64(":id"),
Link: pageLink,
Status: model.PAGE_STATUS_PUBLISH,
IsHit: true,
IsPublish: true,
}
)
if err := service.Call(service.Page.Read, opt, page); err != nil {
status := 500
if err == service.ErrPageNotFound {
status = 404
}
pc.RenderError(status, err)
return
}
if page.Link != pageLink {
pc.RenderError(404, nil)
return
}
pc.Title(page.Title + " - " + service.Setting.General.Title)
pc.Assign("Page", page)
pc.Render(page.Template)
}
func (t *AdminRender) SetTheme(*model.Theme) error {
var theme = new(model.Theme)
if err := service.Call(service.Theme.Admin, nil, theme); err != nil {
return err
}
t.baseTheme.SetTheme(theme)
return nil
}
func (rc *RssController) Get() {
var buf bytes.Buffer
if err := service.Call(service.RSS.RSS, nil, &buf); err != nil {
panic(err)
}
rc.Header().Add("Content-Type", "application/rss+xml;charset=UTF-8")
rc.Write(buf.Bytes())
}
func (apc *ArticlePublicController) Get() {
if id := apc.FormInt64("id"); id > 0 {
if err := service.Call(service.Article.ToPublish, &id); err != nil {
apc.RenderError(500, err)
return
}
}
apc.Redirect(apc.Req().Referer())
}
func (adc *ArticleDeleteController) Get() {
id := adc.FormInt64("id")
if id > 0 {
if err := service.Call(service.Article.Delete, id); err != nil {
adc.RenderError(500, err)
return
}
}
adc.Redirect(adc.Req().Referer())
}
func (stc *SettingThemeController) Get() {
themes := make([]*model.Theme, 0)
if err := service.Call(service.Theme.All, nil, &themes); err != nil {
stc.RenderError(500, err)
return
}
stc.Title("THEME - PUGO")
stc.Assign("Themes", themes)
stc.Render("setting_theme.tmpl")
}
func (pdc *PageDeleteController) Get() {
id := pdc.FormInt64("id")
if id > 0 {
if err := service.Call(service.Page.Delete, id); err != nil {
pdc.RenderError(500, err)
return
}
}
pdc.Redirect(pdc.Req().Referer())
}
func (mdc *MediaDeleteController) Get() {
id := mdc.FormInt64("id")
if id > 0 {
if err := service.Call(service.Media.Delete, id); err != nil {
mdc.RenderError(500, err)
return
}
}
mdc.Redirect(mdc.Req().Referer())
}
func (lc *LoginController) Logout() {
if token := lc.ReadToken(lc.Context); token != "" {
if err := service.Call(service.User.Unauthorize, &token); err != nil {
lc.RenderError(500, err)
return
}
}
lc.WriteToken(lc.Context, nil)
lc.Redirect("/admin/login")
}
func (sm *SettingMenuController) Post() {
menuSettings := []*model.SettingMenu{}
form := sm.Req().Form
if err := service.Call(service.Setting.CreateMenu, form, &menuSettings); err != nil {
sm.JSONError(200, err)
return
}
setting := &model.Setting{
Name: "menu",
UserId: 0,
Type: model.SETTING_TYPE_MENU,
}
setting.Encode(menuSettings)
if err := service.Call(service.Setting.Write, setting); err != nil {
sm.JSONError(200, err)
return
}
service.Setting.Menu = menuSettings
sm.JSON(nil)
}
func (cc *CommentController) Reply() {
c := &model.Comment{
UserId: cc.AuthUser.Id,
Body: cc.Form("content"),
ParentId: cc.FormInt64("pid"),
}
if err := service.Call(service.Comment.Reply, c); err != nil {
cc.RenderError(500, err)
return
}
cc.Redirect("/admin/manage/comment")
}
func Install(ctx *cli.Context) {
opt := service.BootstrapInitOption{true, false, false}
if err := service.Call(service.Bootstrap.Init, opt); err != nil {
log15.Crit("Install.fail", "error", err)
}
if core.Cfg.Install == "0" {
log15.Info("Install.start")
opt = service.BootstrapInitOption{false, true, false} // connect to database
if err := service.Call(service.Bootstrap.Init, opt); err != nil {
log15.Crit("Install.fail", "error", err)
}
opt2 := newBootstrapInstallOption(ctx)
if err := service.Call(service.Bootstrap.Install, opt2); err != nil {
log15.Crit("Install.fail", "error", err)
}
log15.Info("Install.finish")
return
}
i, _ := strconv.ParseInt(core.Cfg.Install, 10, 64)
log15.Warn("Install.HadInstalled", "version", core.Cfg.Version, "installed", time.Unix(i, 0))
}
func (cc *CommentController) Delete() {
if id := cc.FormInt64("id"); id > 0 {
opt := service.CommentSwitchOption{
Id: id,
Status: model.COMMENT_STATUS_DELETED,
}
if err := service.Call(service.Comment.SwitchStatus, opt); err != nil {
cc.RenderError(500, err)
return
}
}
cc.Redirect(cc.Req().Referer())
}
func (abc *AdvBackupController) Backup() {
opt := service.BackupOption{
true, true, true, true,
}
fileName := ""
if err := service.Call(service.Backup.Backup, opt, &fileName); err != nil {
abc.JSONError(200, err)
return
}
abc.JSON(map[string]interface{}{
"file": fileName,
})
}
func (ac *ArchiveController) Get() {
ac.Title("Archive - " + service.Setting.General.Title)
var (
opt = service.ArchiveListOption{}
archives = make([]*model.ArticleArchive, 0)
)
if err := service.Call(service.Article.Archive, opt, &archives); err != nil {
ac.RenderError(500, err)
return
}
ac.Assign("Archives", archives)
ac.Render("archive.tmpl")
}
func (pc *ProfileController) Post() {
form := new(ProfileForm)
if err := pc.Validator.Validate(form, pc); err != nil {
pc.JSONError(200, err)
return
}
user := form.toUser()
user.Id = pc.AuthUser.Id
if err := service.Call(service.User.Profile, user); err != nil {
pc.JSONError(200, err)
return
}
pc.JSON(nil)
}
func (pc *ProfileController) Password() {
form := new(PasswordForm)
if err := pc.Validator.Validate(form, pc); err != nil {
pc.JSONError(200, err)
return
}
opt := form.toOption()
opt.User = pc.AuthUser
if err := service.Call(service.User.Password, opt); err != nil {
pc.JSONError(200, err)
return
}
pc.JSON(nil)
}
func (mc *MediaController) uploadFormEditor(opt service.MediaUploadOption) {
m := new(model.Media)
if err := service.Call(service.Media.Upload, opt, m); err != nil {
mc.JSONRaw(map[string]interface{}{
"success": 0,
"message": err.Error(),
})
return
}
mc.JSONRaw(map[string]interface{}{
"success": 1,
"url": "/" + m.FilePath,
})
}
func (abc *AdvBackupController) Get() {
if file := abc.Form("file"); file != "" {
abc.ServeFile(file)
return
}
files := make([]*model.BackupFile, 0)
if err := service.Call(service.Backup.Files, nil, &files); err != nil {
abc.RenderError(500, err)
return
}
abc.Title("BACKUP - PUGO")
abc.Assign("BackupFiles", files)
abc.Render("advance_backup.tmpl")
}
func (pwc *PageWriteController) Get() {
pwc.Title("WRITE PAGE - PUGO")
pwc.Assign("XsrfHTML", pwc.XsrfFormHtml())
if id := pwc.FormInt64("id"); id > 0 {
var (
opt = service.PageReadOption{Id: id}
page = new(model.Page)
)
if err := service.Call(service.Page.Read, opt, page); err != nil {
pwc.RenderError(500, err)
return
}
pwc.Assign("Page", page)
}
pwc.Render("write_page.tmpl")
}
func (awc *ArticleWriteController) Get() {
awc.Title("WRITE ARTICLE - PUGO")
awc.Assign("XsrfHTML", awc.XsrfFormHtml())
if id := awc.FormInt64("id"); id > 0 {
var (
opt = service.ArticleReadOption{Id: id}
article = new(model.Article)
)
if err := service.Call(service.Article.Read, opt, article); err != nil {
awc.RenderError(500, err)
return
}
awc.Assign("Article", article)
}
awc.Render("write_article.tmpl")
}
func (awc *ArticleWriteController) Post() {
form := new(ArticleForm)
if err := awc.Validator.Validate(form, awc); err != nil {
awc.JSONError(200, err)
return
}
form.UserId = awc.AuthUser.Id
var article = new(model.Article)
if err := service.Call(service.Article.Write, form.toArticle(), article); err != nil {
awc.JSONError(200, err)
return
}
awc.JSON(map[string]interface{}{
"article": article,
})
}
func (mc *MediaController) Upload() {
opt := service.MediaUploadOption{
Ctx: mc.Ctx,
User: mc.AuthUser.Id, // media's owner int
FormName: mc.Form("field", "file"), // form field name
}
if mc.Form("from") == "editor" {
mc.uploadFormEditor(opt)
return
}
if err := service.Call(service.Media.Upload, opt); err != nil {
mc.JSONError(500, err)
return
}
mc.JSON(nil)
}
func (mc *MediaController) Get() {
var (
opt = service.MediaListOption{IsCount: true}
mediaFiles = make([]*model.Media, 0)
pager = new(utils.Pager)
)
if err := service.Call(service.Media.List, opt, &mediaFiles, pager); err != nil {
mc.RenderError(500, err)
return
}
mc.Assign("MediaFiles", mediaFiles)
mc.Assign("Pager", pager)
mc.Title("MEDIA - PUGO")
mc.Assign("MaxSize", service.Setting.Media.MaxFileSize/1024)
mc.Render("manage_media.tmpl")
}
func (pwc *PageWriteController) Post() {
form := new(PagePostForm)
if err := pwc.Validator.Validate(form, pwc); err != nil {
pwc.JSONError(200, err)
return
}
form.UserId = pwc.AuthUser.Id
var page = new(model.Page)
if err := service.Call(service.Page.Write, form.toPage(), page); err != nil {
pwc.JSONError(200, err)
return
}
pwc.JSON(map[string]interface{}{
"page": page,
})
}
func (cc *CommentController) Get() {
cc.Title("COMMENT - " + strings.ToUpper(core.PUGO_NAME))
var (
opt = service.CommentListOption{
Page: cc.FormInt("page", 1),
Size: cc.FormInt("size", 10),
IsCount: true,
}
comments = make([]*model.Comment, 0)
pager = new(utils.Pager)
)
// load comment
switch cc.Form("status") {
case "all":
opt.Status = 0
case "approved":
opt.Status = model.COMMENT_STATUS_APPROVED
case "wait":
opt.Status = model.COMMENT_STATUS_WAIT
case "spam":
opt.Status = model.COMMENT_STATUS_SPAM
default:
opt.Status = 0
}
if err := service.Call(service.Comment.List, opt, &comments, pager); err != nil {
cc.RenderError(500, err)
return
}
// build pager url
query := cc.Req().URL.Query()
query.Del("page")
queryStr := query.Encode()
if len(queryStr) == 0 {
queryStr = "/admin/manage/comment?page=%d"
} else {
queryStr = "/admin/manage/comment?" + queryStr + "&page=%d"
}
cc.Assign("PageUrl", queryStr)
cc.Assign("Comments", comments)
cc.Assign("Pager", pager)
cc.Render("manage_comment.tmpl")
}
func (pmc *PageManageController) Get() {
pmc.Title("PAGES - PUGO")
var (
opt = service.PageListOption{
IsCount: true,
Page: pmc.FormInt("page", 0),
}
pages = make([]*model.Page, 0)
pager = new(utils.Pager)
)
if err := service.Call(service.Page.List, opt, &pages, pager); err != nil {
pmc.RenderError(500, err)
return
}
pmc.Assign("Pages", pages)
pmc.Assign("Pager", pager)
pmc.Render("manage_page.tmpl")
}
