Golang Session.Monsti方法代码示例

func getBlogContext(reqId uint, embed *service.EmbedNode,
	s *service.Session, settings *settings, renderer *mtemplate.Renderer) (
	map[string][]byte, *service.CacheMods, error) {
	req, err := s.Monsti().GetRequest(reqId)
	if err != nil {
		return nil, nil, fmt.Errorf("Could not get request: %v", err)
	}
	query := req.Query
	blogPath := req.NodePath
	if embed != nil {
		embedUrl, err := url.Parse(embed.URI)
		if err != nil {
			return nil, nil, fmt.Errorf("Could not parse embed URI")
		}
		query = embedUrl.Query()
		blogPath = embedUrl.Path
	}
	limit := -1
	if limitParam, err := strconv.Atoi(query.Get("limit")); err == nil {
		limit = limitParam
		if limit < 1 {
			limit = 1
		}
	}
	context := mtemplate.Context{}
	context["Embedded"] = embed
	context["Posts"], err = getBlogPosts(req, blogPath, s, limit)
	if err != nil {
		return nil, nil, fmt.Errorf("Could not retrieve blog posts: %v", err)
	}
	rendered, err := renderer.Render("core/blogpost-list", context,
		req.Session.Locale, settings.Monsti.GetSiteTemplatesPath(req.Site))
	if err != nil {
		return nil, nil, fmt.Errorf("Could not render template: %v", err)
	}
	mods := &service.CacheMods{
		Deps: []service.CacheDep{{Node: req.NodePath, Descend: 1}},
	}
	return map[string][]byte{"BlogPosts": rendered}, mods, nil
}

func getBlogPosts(req *service.Request, blogPath string, s *service.Session,
	limit int) ([]*service.Node, error) {
	var posts []*service.Node
	years, err := s.Monsti().GetChildren(req.Site, blogPath)
	if err != nil {
		return nil, fmt.Errorf("Could not fetch year children: %v", err)
	}
	for _, year := range years {
		months, err := s.Monsti().GetChildren(req.Site, year.Path)
		if err != nil {
			return nil, fmt.Errorf("Could not fetch month children: %v", err)
		}
		for _, month := range months {
			monthPosts, err := s.Monsti().GetChildren(req.Site, month.Path)
			if err != nil {
				return nil, fmt.Errorf("Could not fetch month children: %v", err)
			}
			posts = append(posts, monthPosts...)
		}
	}
	order := func(left, right *service.Node) bool {
		return left.PublishTime.Before(right.PublishTime)
	}
	sort.Sort(sort.Reverse(&nodes.Sorter{posts, order}))
	return posts, nil
}

func initBlog(settings *settings, session *service.Session,
	sessions *service.SessionPool, logger *log.Logger,
	renderer *mtemplate.Renderer) error {
	G := func(in string) string { return in }

	nodeType := service.NodeType{
		Id:        "core.Blog",
		AddableTo: []string{"."},
		Name:      i18n.GenLanguageMap(G("Blog"), availableLocales),
		Fields: []*service.FieldConfig{
			{Id: "core.Title"},
		},
	}
	if err := session.Monsti().RegisterNodeType(&nodeType); err != nil {
		return fmt.Errorf("Could not register blog node type: %v", err)
	}

	nodeType = service.NodeType{
		Id:        "core.BlogPost",
		AddableTo: []string{"core.Blog"},
		Name:      i18n.GenLanguageMap(G("Blog Post"), availableLocales),
		Fields: []*service.FieldConfig{
			{Id: "core.Title"},
			{Id: "core.Body"},
		},
		Hide:       true,
		PathPrefix: "$year/$month",
	}
	if err := session.Monsti().RegisterNodeType(&nodeType); err != nil {
		return fmt.Errorf("Could not register blog post node type: %v", err)
	}

	// Add a signal handler
	handler := service.NewNodeContextHandler(sessions,
		func(req uint, session *service.Session, nodeType string,
			embedNode *service.EmbedNode) (
			map[string][]byte, *service.CacheMods, error) {
			switch nodeType {
			case "core.Blog":
				ctx, mods, err := getBlogContext(req, embedNode, session, settings, renderer)
				if err != nil {
					return nil, nil, fmt.Errorf("Could not get blog context: %v", err)
				}
				return ctx, mods, nil
			default:
				return nil, nil, nil
			}
		})
	if err := session.Monsti().AddSignalHandler(handler); err != nil {
		logger.Fatalf("Could not add signal handler: %v", err)
	}
	return nil
}

func initNodeTypes(settings *settings, session *service.Session, logger *log.Logger) error {
	G := func(in string) string { return in }
	pathType := service.NodeType{
		Id:   "core.Path",
		Hide: true,
		Name: util.GenLanguageMap(G("Path"), availableLocales),
	}
	if err := session.Monsti().RegisterNodeType(&pathType); err != nil {
		return fmt.Errorf("Could not register path node type: %v", err)
	}

	documentType := service.NodeType{
		Id:        "core.Document",
		AddableTo: []string{"."},
		Name:      util.GenLanguageMap(G("Document"), availableLocales),
		Fields: []*service.NodeField{
			{
				Id:       "core.Title",
				Required: true,
				Name:     util.GenLanguageMap(G("Title"), availableLocales),
				Type:     "Text",
			},
			{
				Id:       "core.Body",
				Required: true,
				Name:     util.GenLanguageMap(G("Body"), availableLocales),
				Type:     "HTMLArea",
			},
		},
	}
	if err := session.Monsti().RegisterNodeType(&documentType); err != nil {
		return fmt.Errorf("Could not register document node type: %v", err)
	}

	fileType := service.NodeType{
		Id:        "core.File",
		AddableTo: []string{"."},
		Name:      util.GenLanguageMap(G("File"), availableLocales),
		Fields: []*service.NodeField{
			{Id: "core.Title"},
			{Id: "core.Body"},
			{
				Id:       "core.File",
				Required: true,
				Name:     util.GenLanguageMap(G("File"), availableLocales),
				Type:     "File",
			},
		},
	}
	if err := session.Monsti().RegisterNodeType(&fileType); err != nil {
		return fmt.Errorf("Could not register file node type: %v", err)
	}

	imageType := service.NodeType{
		Id:        "core.Image",
		AddableTo: []string{"."},
		Name:      util.GenLanguageMap(G("Image"), availableLocales),
		Fields: []*service.NodeField{
			{Id: "core.Title"},
			{Id: "core.File"},
		},
	}
	if err := session.Monsti().RegisterNodeType(&imageType); err != nil {
		return fmt.Errorf("Could not register image node type: %v", err)
	}

	contactFormType := service.NodeType{
		Id:        "core.ContactForm",
		AddableTo: []string{"."},
		Name:      util.GenLanguageMap(G("Contact form"), availableLocales),
		Fields: []*service.NodeField{
			{Id: "core.Title"},
			{Id: "core.Body"},
		},
	}
	if err := session.Monsti().RegisterNodeType(&contactFormType); err != nil {
		return fmt.Errorf("Could not register contactform node type: %v", err)
	}
	return nil
}

// renderInMaster renders the content in the master template.
func renderInMaster(r template.Renderer, content []byte, env masterTmplEnv,
	settings *settings, site string, siteSettings *service.Settings,
	userLocale string,
	s *service.Session) ([]byte, *service.CacheMods) {
	mods := &service.CacheMods{Deps: []service.CacheDep{{Node: "/", Descend: -1}}}
	if env.Flags&EDIT_VIEW != 0 {
		ret, err := r.Render("admin/master", template.Context{
			"Site":         site,
			"SiteSettings": siteSettings,
			"Page": template.Context{
				"Title":    env.Title,
				"Node":     env.Node,
				"EditView": true,
				"SlimView": env.Flags&SLIM_VIEW != 0,
				"Content":  htmlT.HTML(content),
			},
			"Session": env.Session}, userLocale,
			settings.Monsti.GetSiteTemplatesPath(site))
		if err != nil {
			panic("Can't render admin template: " + err.Error())
		}
		return ret, nil
	}
	firstDir := splitFirstDir(env.Node.Path)
	getNodeFn := func(path string) (*service.Node, error) {
		node, err := s.Monsti().GetNode(site, path)
		return node, err
	}
	getChildrenFn := func(path string) ([]*service.Node, error) {
		return s.Monsti().GetChildren(site, path)
	}

	priNavDepth := 1
	if nav, ok := siteSettings.Fields["core.Navigations"].(*service.MapField).
		Fields["core.Main"]; ok {
		priNavDepth = nav.(*service.CombinedField).
			Fields["depth"].Value().(int)
	}
	prinav, err := getNav("/", path.Join("/", firstDir), env.Session.User == nil,
		getNodeFn, getChildrenFn, priNavDepth)
	if err != nil {
		panic(fmt.Sprint("Could not get primary navigation: ", err))
	}
	prinav.MakeAbsolute("/")

	var secnav navigation = nil
	if env.Node.Path != "/" {
		secnav, err = getNav(env.Node.Path, env.Node.Path, env.Session.User == nil,
			getNodeFn, getChildrenFn, 1)
		if err != nil {
			panic(fmt.Sprint("Could not get secondary navigation: ", err))
		}
		secnav.MakeAbsolute(env.Node.Path)
	}

	blocks := make(map[string][]renderedBlock)

	// EXPERIMENTAL Render blocks
	if _, ok := siteSettings.Fields["core.RegionBlocks"].(*service.MapField).
		Fields["core.PrimaryNavigation"].(*service.ListField); ok {
		renderedNav, err := r.Render("blocks/core/Navigation", template.Context{
			"Id":    "core.PrimaryNavigation",
			"Links": prinav,
		}, userLocale, settings.Monsti.GetSiteTemplatesPath(site))
		if err != nil {
			panic(fmt.Sprintf("Could not render navigation: %v", err))
		}
		blocks["core.PrimaryNavigation"] = append(blocks["core.PrimaryNavigation"],
			renderedBlock{
				Rendered: htmlT.HTML(renderedNav),
			})
	}

	title := getNodeTitle(env.Node)
	ret, err := r.Render("master", template.Context{
		"Site":         site,
		"SiteSettings": siteSettings,
		"Page": template.Context{
			"Node":             env.Node,
			"PrimaryNav":       prinav, // TODO DEPRECATED
			"SecondaryNav":     secnav, // TODO DEPRECATED
			"EditView":         env.Flags&EDIT_VIEW != 0,
			"Title":            title,
			"Content":          htmlT.HTML(content),
			"ShowSecondaryNav": len(secnav) > 0, // TODO DEPRECATED
			"Blocks":           blocks,
		},
		"Session": env.Session}, userLocale,
		settings.Monsti.GetSiteTemplatesPath(site))
	if err != nil {
		panic(fmt.Sprintf(
			"Can't render master template for site %v: %v",
			site, err))
	}
	return ret, mods
}

// renderInMaster renders the content in the master template.
func renderInMaster(r template.Renderer, content []byte, env masterTmplEnv,
	settings *settings, site util.SiteSettings, locale string,
	s *service.Session) string {
	if env.Flags&EDIT_VIEW != 0 {
		ret, err := r.Render("admin/master", template.Context{
			"Site": site,
			"Page": template.Context{
				"Title":    env.Title,
				"Node":     env.Node,
				"EditView": env.Flags&EDIT_VIEW != 0,
				"Content":  htmlT.HTML(content),
			},
			"Session": env.Session}, locale,
			settings.Monsti.GetSiteTemplatesPath(site.Name))
		if err != nil {
			panic("Can't render: " + err.Error())
		}
		return ret
	}
	firstDir := splitFirstDir(env.Node.Path)
	getNodeFn := func(path string) (*service.Node, error) {
		node, err := s.Monsti().GetNode(site.Name, path)
		return node, err
	}
	getChildrenFn := func(path string) ([]*service.Node, error) {
		return s.Monsti().GetChildren(site.Name, path)
	}
	prinav, err := getNav("/", path.Join("/", firstDir), env.Session.User == nil,
		getNodeFn, getChildrenFn)
	if err != nil {
		panic(fmt.Sprint("Could not get primary navigation: ", err))
	}
	prinav.MakeAbsolute("/")
	var secnav navigation = nil
	if env.Node.Path != "/" {
		secnav, err = getNav(env.Node.Path, env.Node.Path, env.Session.User == nil,
			getNodeFn, getChildrenFn)
		if err != nil {
			panic(fmt.Sprint("Could not get secondary navigation: ", err))
		}
		secnav.MakeAbsolute(env.Node.Path)
	}

	title := getNodeTitle(env.Node)
	ret, err := r.Render("master", template.Context{
		"Site": site,
		"Page": template.Context{
			"Node":             env.Node,
			"PrimaryNav":       prinav,
			"SecondaryNav":     secnav,
			"EditView":         env.Flags&EDIT_VIEW != 0,
			"Title":            title,
			"Content":          htmlT.HTML(content),
			"ShowSecondaryNav": len(secnav) > 0},
		"Session": env.Session}, locale,
		settings.Monsti.GetSiteTemplatesPath(site.Name))
	if err != nil {
		panic("Can't render: " + err.Error())
	}
	return ret
}

func renderContactForm(req *service.Request, session *service.Session) (
	*service.RenderNodeRet, error) {

	m := session.Monsti()
	siteSettings, err := m.LoadSiteSettings(req.Site)
	if err != nil {
		return nil, fmt.Errorf("Could not get site settings: %v", err)
	}
	G, _, _, _ := gettext.DefaultLocales.Use("",
		siteSettings.Fields["core.Locale"].Value().(string))

	node, err := m.GetNode(req.Site, req.NodePath)
	if err != nil {
		return nil, fmt.Errorf("Could not get contact form node: %v", err)
	}

	data := make(service.NestedMap)
	var dataFields []dataField
	form := htmlwidgets.NewForm(data)

	formFields := node.Fields["core.ContactFormFields"].(*service.ListField)

	for i, field := range formFields.Fields {
		combinedField := field.(*service.CombinedField)
		name := combinedField.Fields["Name"].Value().(string)
		required := combinedField.Fields["Required"].Value().(bool)
		fieldId := fmt.Sprintf("field_%d", i)
		dataFields = append(dataFields, dataField{fieldId, name})
		data[fieldId] = ""
		innerFieldType := combinedField.Fields["Field"].(*service.DynamicTypeField).DynamicType
		var widget htmlwidgets.Widget
		switch innerFieldType {
		case "text":
			textWidget := &htmlwidgets.TextWidget{ValidationError: G("Required.")}
			if required {
				textWidget.MinLength = 1
			}
			widget = textWidget
		case "textarea":
			areaWidget := &htmlwidgets.TextAreaWidget{ValidationError: G("Required.")}
			if required {
				areaWidget.MinLength = 1
			}
			widget = areaWidget
		default:
			panic(fmt.Sprintf("Unknow inner field type <%v>", innerFieldType))
		}
		form.AddWidget(widget, fieldId, name, "")
	}

	if len(formFields.Fields) == 0 {
		// Add default fields for backward compatibility
		data["Name"] = ""
		data["Email"] = ""
		data["Subject"] = ""
		data["Message"] = ""
		dataFields = []dataField{
			{"Name", G("Name")},
			{"Email", G("Email")},
			{"Subject", G("Subject")},
			{"Message", G("Message")},
		}
		form.AddWidget(&htmlwidgets.TextWidget{MinLength: 1,
			ValidationError: G("Required.")}, "Name", G("Name"), "")
		form.AddWidget(&htmlwidgets.TextWidget{MinLength: 1,
			ValidationError: G("Required.")}, "Email", G("Email"), "")
		form.AddWidget(&htmlwidgets.TextWidget{MinLength: 1,
			ValidationError: G("Required.")}, "Subject", G("Subject"), "")
		form.AddWidget(&htmlwidgets.TextAreaWidget{MinLength: 1,
			ValidationError: G("Required.")}, "Message", G("Message"), "")
	}

	context := make(map[string]interface{})
	switch req.Method {
	case "GET":
		if _, submitted := req.Form["submitted"]; submitted {
			context["Submitted"] = 1
		}
	case "POST":
		if form.Fill(req.PostForm) {
			mail := gomail.NewMessage()
			mail.SetAddressHeader("From",
				siteSettings.StringValue("core.EmailAddress"),
				siteSettings.StringValue("core.EmailName"))
			mail.SetAddressHeader("To",
				siteSettings.StringValue("core.OwnerEmail"),
				siteSettings.StringValue("core.OwnerName"))
			// mail.SetAddressHeader("Reply-To", data.Email, data.Name)
			mail.SetHeader("Subject", "Contact form submission")
			var fieldValues string
			for _, v := range dataFields {
				fieldValues += fmt.Sprintf("%v: %v\n", v.Name, data[v.Id])
			}
			body := fmt.Sprintf("%v\n\n%v",
				fmt.Sprintf(G("Received from contact form at %v"),
					siteSettings.StringValue("core.Title")), fieldValues)
			mail.SetBody("text/plain", body)
			mailer := gomail.NewCustomMailer("", nil, gomail.SetSendMail(
				m.SendMailFunc()))
			err := mailer.Send(mail)
//.........这里部分代码省略.........

func initNodeTypes(settings *settings, session *service.Session, logger *log.Logger) error {
	G := func(in string) string { return in }
	pathType := service.NodeType{
		Id:   "core.Path",
		Hide: true,
		Name: i18n.GenLanguageMap(G("Path"), availableLocales),
	}
	if err := session.Monsti().RegisterNodeType(&pathType); err != nil {
		return fmt.Errorf("Could not register path node type: %v", err)
	}

	documentType := service.NodeType{
		Id:        "core.Document",
		AddableTo: []string{"."},
		Name:      i18n.GenLanguageMap(G("Document"), availableLocales),
		Fields: []*service.FieldConfig{
			{
				Id:       "core.Title",
				Required: true,
				Name:     i18n.GenLanguageMap(G("Title"), availableLocales),
				Type:     new(service.TextFieldType),
			},
			{
				Id:   "core.Description",
				Name: i18n.GenLanguageMap(G("Description"), availableLocales),
				Type: new(service.TextFieldType),
			},
			{
				Id:   "core.Thumbnail",
				Name: i18n.GenLanguageMap(G("Thumbnail"), availableLocales),
				Type: new(service.RefFieldType),
			},
			{
				Id:       "core.Body",
				Required: true,
				Name:     i18n.GenLanguageMap(G("Body"), availableLocales),
				Type:     new(service.HTMLFieldType),
			},
		},
	}
	if err := session.Monsti().RegisterNodeType(&documentType); err != nil {
		return fmt.Errorf("Could not register document node type: %v", err)
	}

	fileType := service.NodeType{
		Id:        "core.File",
		AddableTo: []string{"."},
		Name:      i18n.GenLanguageMap(G("File"), availableLocales),
		Fields: []*service.FieldConfig{
			{Id: "core.Title"},
			{
				Id:       "core.File",
				Required: true,
				Name:     i18n.GenLanguageMap(G("File"), availableLocales),
				Type:     new(service.FileFieldType),
			},
		},
	}
	if err := session.Monsti().RegisterNodeType(&fileType); err != nil {
		return fmt.Errorf("Could not register file node type: %v", err)
	}

	imageType := service.NodeType{
		Id:        "core.Image",
		Hide:      true,
		AddableTo: []string{"."},
		Name:      i18n.GenLanguageMap(G("Image"), availableLocales),
		Fields: []*service.FieldConfig{
			{Id: "core.Title"},
			{Id: "core.File"},
		},
	}
	if err := session.Monsti().RegisterNodeType(&imageType); err != nil {
		return fmt.Errorf("Could not register image node type: %v", err)
	}

	return nil
}