Exemple #1
0
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
}
Exemple #2
0
func setup(c *module.ModuleContext) error {
	gettext.DefaultLocales.Domain = "monsti-daemon"
	G := func(in string) string { return in }
	m := c.Session.Monsti()

	nodeType := &service.NodeType{
		Id:        "core.ContactForm",
		AddableTo: []string{"."},
		Name:      i18n.GenLanguageMap(G("Contact form"), availableLocales),
		Fields: append(service.CoreFields, []*service.FieldConfig{
			{
				Id:     "core.ContactFormFields",
				Hidden: true,
				Type: &service.ListFieldType{
					ElementType: &service.CombinedFieldType{map[string]service.FieldConfig{
						"Name":     {Type: new(service.TextFieldType)},
						"Required": {Type: new(service.BoolFieldType)},
						"Field": {Type: &service.DynamicTypeFieldType{
							Fields: []service.FieldConfig{
								{
									Id:   "text",
									Type: new(service.DummyFieldType),
								},
								{
									Id:   "textarea",
									Type: new(service.DummyFieldType),
								},
							}}}}}}}}...)}
	if err := m.RegisterNodeType(nodeType); err != nil {
		c.Logger.Fatalf("Could not register %q node type: %v", nodeType.Id, err)
	}

	handler := service.NewRenderNodeHandler(c.Sessions,
		func(args *service.RenderNodeArgs, session *service.Session) (
			*service.RenderNodeRet, error) {
			if args.NodeType == "core.ContactForm" {
				req, err := session.Monsti().GetRequest(args.Request)
				if err != nil || req == nil {
					return nil, fmt.Errorf("Could not get request: %v", err)
				}
				return renderContactForm(req, session)
			}
			return nil, nil
		})
	if err := m.AddSignalHandler(handler); err != nil {
		c.Logger.Fatalf("Could not add signal handler: %v", err)
	}

	return nil
}
func setup(c *module.ModuleContext) error {
	G := func(in string) string { return in }
	m := c.Session.Monsti()

	// Register a new node type
	nodeType := service.NodeType{
		Id:   "example.ExampleType",
		Name: i18n.GenLanguageMap(G("Example node type"), availableLocales),
		Fields: []*service.FieldConfig{
			// core.Title and core.Body are already known to the system,
			// just specify their IDs to include them.
			{Id: "core.Title"},
			{Id: "core.Body"},
			{
				Id:   "example.Foo",
				Name: i18n.GenLanguageMap(G("Foo"), availableLocales),
				Type: new(service.TextFieldType),
			},
			{
				Id:   "example.Bar",
				Name: i18n.GenLanguageMap(G("Bar"), availableLocales),
				Type: new(service.DateTimeFieldType),
			},
		},
	}
	if err := m.RegisterNodeType(&nodeType); err != nil {
		c.Logger.Fatalf("Could not register %q node type: %v", nodeType.Id, err)
	}

	nodeType = service.NodeType{
		Id:   "example.Embed",
		Name: i18n.GenLanguageMap(G("Embed example"), availableLocales),
		Fields: []*service.FieldConfig{
			// core.Title and core.Body are already known to the system,
			// just specify their IDs to include them.
			{Id: "core.Title"},
			{Id: "core.Body"},
		},
	}
	if err := m.RegisterNodeType(&nodeType); err != nil {
		c.Logger.Fatalf("Could not register %q node type: %v", nodeType.Id, err)
	}

	nodeType = service.NodeType{
		Id:   "example.Fields",
		Name: i18n.GenLanguageMap(G("Fields example"), availableLocales),
		Fields: []*service.FieldConfig{
			// core.Title and core.Body are already known to the system,
			// just specify their IDs to include them.
			{Id: "core.Title"},
			{Id: "core.Body"},
			{
				Id:   "example.Bool",
				Name: i18n.GenLanguageMap(G("Bool"), availableLocales),
				Type: new(service.BoolFieldType),
			},
			{
				Id:   "example.DateTime",
				Name: i18n.GenLanguageMap(G("DateTime"), availableLocales),
				Type: new(service.DateTimeFieldType),
			},
			{
				Id:   "example.HTMLArea",
				Name: i18n.GenLanguageMap(G("HTML"), availableLocales),
				Type: new(service.HTMLFieldType),
			},
			{
				Id:     "example.Hidden",
				Name:   i18n.GenLanguageMap(G("Hidden"), availableLocales),
				Hidden: true,
				Type:   new(service.TextFieldType),
			},
			{
				Id:   "example.Text",
				Name: i18n.GenLanguageMap(G("Text"), availableLocales),
				Type: new(service.TextFieldType),
			},
			{
				Id:   "example.TextList",
				Name: i18n.GenLanguageMap(G("Text list"), availableLocales),
				Type: &service.ListFieldType{new(service.TextFieldType)},
			},
			{
				Id:   "example.Map",
				Name: i18n.GenLanguageMap(G("Map"), availableLocales),
				Type: &service.MapFieldType{new(service.TextFieldType)},
			},
			{
				Id:   "example.Combined",
				Name: i18n.GenLanguageMap(G("Combined"), availableLocales),
				Type: &service.CombinedFieldType{
					map[string]service.FieldConfig{
						"Text": {
							Name: i18n.GenLanguageMap(G("Text"), availableLocales),
							Type: new(service.TextFieldType),
						},
						"Bool": {
							Name: i18n.GenLanguageMap(G("Bool"), availableLocales),
							Type: new(service.BoolFieldType),
						},
					}},
			},
		},
	}
	if err := m.RegisterNodeType(&nodeType); err != nil {
		c.Logger.Fatalf("Could not register %q node type: %v", nodeType.Id, err)
	}

	// Add a signal handler
	handler := service.NewNodeContextHandler(c.Sessions,
		func(id uint, session *service.Session, nodeType string,
			embedNode *service.EmbedNode) (
			map[string][]byte, *service.CacheMods, error) {
			if nodeType == "example.ExampleType" {
				req, err := session.Monsti().GetRequest(id)
				if err != nil || req == nil {
					return nil, nil, fmt.Errorf("Could not get request: %v", err)
				}
				return map[string][]byte{
					"SignalFoo": []byte(fmt.Sprintf("Hello Signal! Site name: %v", req.Site)),
				}, nil, nil
			}
			return nil, nil, nil
		})
	if err := m.AddSignalHandler(handler); err != nil {
		c.Logger.Fatalf("Could not add signal handler: %v", err)
	}

	return nil
}
Exemple #4
0
// LoadSiteSettings loads settings for the given site.
func (s *MonstiClient) LoadSiteSettings(site string) (*Settings, error) {
	if s.Error != nil {
		return nil, s.Error
	}
	var reply []byte
	err := s.RPCClient.Call("Monsti.LoadSiteSettings", site, &reply)
	if err != nil {
		return nil, fmt.Errorf("service: LoadSiteSettings error: %v", err)
	}

	G := func(in string) string { return in }
	types := []*FieldConfig{
		{
			Id:       "core.Title",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Title"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.BaseURL",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Base URL"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.Locale",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Locale"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.Timezone",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Timezone"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.EmailName",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Email name"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.EmailAddress",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Email address"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.OwnerName",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Owner name"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.OwnerEmail",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Owner email address"), []string{"de", "en"}),
			Type:     new(TextFieldType),
		},
		{
			Id:       "core.SessionAuthKey",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Session auth key"), []string{"de", "en"}),
			Type:     new(TextFieldType),
			Hidden:   true,
		},
		{
			Id:       "core.PasswordTokenKey",
			Required: true,
			Name:     i18n.GenLanguageMap(G("Password token key"), []string{"de", "en"}),
			Type:     new(TextFieldType),
			Hidden:   true,
		},
		{
			Id:     "core.CacheDisabled",
			Hidden: true,
			Type:   new(BoolFieldType),
		},
		{
			Id:     "core.Navigations",
			Name:   i18n.GenLanguageMap(G("Navigations"), []string{"de", "en"}),
			Hidden: true,
			Type: &MapFieldType{
				&CombinedFieldType{
					map[string]FieldConfig{
						"depth": {
							Type: new(IntegerFieldType),
						},
					}},
			},
		},
		{
			Id:     "core.ImageStyles",
			Hidden: true,
			Type: &MapFieldType{
				&CombinedFieldType{
					map[string]FieldConfig{
						"width": {
							Type: new(IntegerFieldType),
						},
						"height": {
							Type: new(IntegerFieldType),
						},
					}},
			},
		},
		{
			// EXPERIMENTAL
			Id:     "core.RegionBlocks",
			Hidden: true,
			Type: &MapFieldType{
				&ListFieldType{
					ElementType: &CombinedFieldType{map[string]FieldConfig{
						"id": {Type: new(TextFieldType)}}}}},
		},
	}

	settings, err := newSettingsFromData(reply, types, s, site)
	if err != nil {
		return nil, fmt.Errorf("service: Could not convert node: %v", err)
	}
	return settings, nil
}
Exemple #5
0
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)
	}

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