Esempio n. 1
0
// Compile or copy in our assets from src into the public assets folder, for use by the app
func setupAssets(server *server.Server) {
	defer server.Timef("#info Finished loading assets in %s", time.Now())

	// Compilation of assets is done on deploy
	// We just load them here
	assetsCompiled := server.ConfigBool("assets_compiled")
	appAssets = assets.New(assetsCompiled)

	// Load asset details from json file on each run
	err := appAssets.Load()
	if err != nil {
		// Compile assets for the first time
		server.Logf("#info Compiling assets")
		err := appAssets.Compile("src", "public")
		if err != nil {
			server.Fatalf("#error compiling assets %s", err)
		}
	}

	// Set up helpers which are aware of fingerprinted assets
	// These behave differently depending on the compile flag above
	// when compile is set to no, they use precompiled assets
	// otherwise they serve all files in a group separately
	view.Helpers["style"] = appAssets.StyleLink
	view.Helpers["script"] = appAssets.ScriptLink

}
Esempio n. 2
0
// Setup sets up our application
func Setup(server *server.Server) {

	// Setup log
	server.Logger = log.New(server.Config("log"), server.Production())

	// Set up our assets
	setupAssets(server)

	// Setup our view templates
	setupView(server)

	// Setup our database
	setupDatabase(server)

	// Routing
	router, err := router.New(server.Logger, server)
	if err != nil {
		server.Fatalf("Error creating router %s", err)
	}

	// Setup our authentication and authorisation
	authorise.Setup(server)

	// Add a prefilter to store the current user on the context, so that we only fetch it once
	// We use this below in Resource, and also in views to determine current user attributes
	router.AddFilter(authorise.CurrentUserFilter)

	// Add an authenticity token filter to write out a secret token for each request (CSRF protection)
	router.AddFilter(authorise.AuthenticityTokenFilter)

	// Setup our router and handlers
	setupRoutes(router)

}
Esempio n. 3
0
// Setup db - at present query pkg manages this...
func setupDatabase(server *server.Server) {
	defer server.Timef("#info Finished opening in %s database %s for user %s", time.Now(), server.Config("db"), server.Config("db_user"))

	config := server.Configuration()
	options := map[string]string{
		"adapter":  config["db_adapter"],
		"user":     config["db_user"],
		"password": config["db_pass"],
		"db":       config["db"],
	}

	// If host and port supplied in config, apply them
	if len(config["db_host"]) > 0 {
		options["host"] = config["db_host"]
	}
	if len(config["db_port"]) > 0 {
		options["port"] = config["db_port"]
	}
	if len(config["db_params"]) > 0 {
		options["params"] = config["db_params"]
	}

	// Ask query to open the database
	err := query.OpenDatabase(options)

	if err != nil {
		server.Fatalf("Error reading database %s", err)
	}

}
Esempio n. 4
0
func setupView(server *server.Server) {
	defer server.Timef("#info Finished loading templates in %s", time.Now())

	view.Production = server.Production()
	err := view.LoadTemplates()
	if err != nil {
		server.Fatalf("Error reading templates %s", err)
	}

}
Esempio n. 5
0
// Setup authentication and authorization keys for this app
func Setup(s *server.Server) {

	// Set up our secret keys which we take from the config
	// NB these are hex strings which we convert to bytes, for ease of presentation in secrets file
	c := s.Configuration()
	auth.HMACKey = auth.HexToBytes(c["hmac_key"])
	auth.SecretKey = auth.HexToBytes(c["secret_key"])
	auth.SessionName = "gohackernews"

	// Enable https cookies on production server - we don't have https, so don't do this
	//	if s.Production() {
	//		auth.SecureCookies = true
	//	}

}
Esempio n. 6
0
func setupView(server *server.Server) {
	defer server.Timef("#info Finished loading templates in %s", time.Now())

	// A very limited translation - would prefer to use editable.js
	// instead and offer proper editing TODO: move to editable.js instead
	view.Helpers["markup"] = markup
	view.Helpers["timeago"] = timeago

	view.Production = server.Production()
	err := view.LoadTemplates()
	if err != nil {
		server.Fatalf("Error reading templates %s", err)
	}

}
Esempio n. 7
0
// setupServices sets up external services from our config file
func setupServices(server *server.Server) {
	config := server.Configuration()

	context := schedule.NewContext(server.Logger, server)

	now := time.Now().UTC()

	// Set up twitter if available, and schedule tweets
	if config["twitter_secret"] != "" {
		twitter.Setup(config["twitter_key"], config["twitter_secret"], config["twitter_token"], config["twitter_token_secret"])

		tweetTime := time.Date(now.Year(), now.Month(), now.Day(), 11, 0, 0, 0, time.UTC)
		tweetInterval := 12 * time.Hour // Daily check for new stories to tweet twice a day

		// For testing
		//tweetTime = now.Add(time.Second * 5)

		schedule.At(storyactions.TweetTopStory, context, tweetTime, tweetInterval)
	}

	// Set up mail
	if config["mail_secret"] != "" {
		mail.Setup(config["mail_secret"], config["mail_from"])

		// Schedule emails to go out at 09:00 every day, starting from the next occurance
		emailTime := time.Date(now.Year(), now.Month(), now.Day(), 9, 0, 0, 0, time.UTC)
		emailInterval := 24 * time.Hour // Daily check for new emails/texts to send

		// For testing send immediately on launch
		//emailTime = now.Add(time.Second * 2)

		schedule.At(useractions.DailyEmail, context, emailTime, emailInterval)
	}

}
Esempio n. 8
0
// Setup db - at present query pkg manages this...
func setupDatabase(server *server.Server) {
	defer server.Timef("#info Finished opening in %s database %s for user %s", time.Now(), server.Config("db"), server.Config("db_user"))

	config := server.Configuration()
	options := map[string]string{
		"adapter":  config["db_adapter"],
		"user":     config["db_user"],
		"password": config["db_pass"],
		"db":       config["db"],
	}

	// Ask query to open the database
	err := query.OpenDatabase(options)

	if err != nil {
		server.Fatalf("Error reading database %s", err)
	}

}
Esempio n. 9
0
// Setup sets up our application
func Setup(server *server.Server) {

	// Setup log
	server.Logger = log.New(server.Config("log"), server.Production())

	// Set up our assets
	setupAssets(server)

	// Setup our view templates
	setupView(server)

	// Setup our database
	setupDatabase(server)

	// Routing
	router, err := router.New(server.Logger, server)
	if err != nil {
		server.Fatalf("Error creating router %s", err)
	}

	// Setup our router and handlers
	setupRoutes(router)

}