Golang service.Call函数代码示例

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 (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 (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 (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)
}