Example #1
0
func BaseHandlers() *Handlers {
	lr := render.New(render.Options{
		Layout: "layout",
	})

	r := render.New(render.Options{})

	return &Handlers{LayoutRender: lr, Render: r}
}
Example #2
0
// This function is called from main.go and from the tests
// to create a new application.
func NewApp(root string) *App {

	CheckEnv()

	// Use negroni for middleware
	ne := negroni.New()

	// Use gorilla/mux for routing
	ro := mux.NewRouter()

	// Use Render for template. Pass in path to templates folder
	// as well as asset helper functions.
	re := render.New(render.Options{
		Directory:  filepath.Join(root, "templates"),
		Layout:     "layouts/layout",
		Extensions: []string{".html"},
		Funcs: []template.FuncMap{
			AssetHelpers(root),
		},
	})
	qre := render.New(render.Options{
		Directory:  filepath.Join(root, "templates"),
		Layout:     "layouts/message",
		Extensions: []string{".html"},
		Funcs: []template.FuncMap{
			AssetHelpers(root),
		},
	})

	// Establish connection to DB as specificed in database.go
	db := NewDB()

	// Add middleware to the stack
	ne.Use(negroni.NewRecovery())
	ne.Use(negroni.NewLogger())
	ne.Use(NewAssetHeaders())
	ne.Use(negroni.NewStatic(http.Dir("public")))
	ne.UseHandler(ro)

	train.Config.SASS.DebugInfo = true
	train.Config.SASS.LineNumbers = true
	train.Config.Verbose = true
	train.Config.BundleAssets = true
	//ZZZtrain.ConfigureHttpHandler(ro)

	// Return a new App struct with all these things.
	return &App{ne, ro, re, qre, db}
}
Example #3
0
// CreateContact ... add new contact to a person
func (c PersonController) CreateContact(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	contact := new(models.Contacts)
	errs := binding.Bind(req, contact)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := contact.Validate(req, errs)
	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}

	p := models.Contacts{
		BaseModel:         c.BaseModel,
		PhoneNo:           contact.PhoneNo,
		PhoneNo2:          contact.PhoneNo2,
		PhoneNo3:          contact.PhoneNo3,
		Email:             contact.Email,
		Website:           contact.Website,
		FacebookID:        contact.FacebookID,
		PersonID:          contact.PersonID,
		CompanyEntitiesID: contact.CompanyEntitiesID}

	err := c.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}
	// render response
	r.JSON(res, 200, p)
}
Example #4
0
func NewApp() *App {
	db := newDB()

	// Use negroni for middleware
	ne := negroni.New(
		negroni.NewRecovery(),
		negroni.NewLogger(),
		negroni.NewStatic(http.Dir("public")),
	)

	// Use gorilla/mux for routing
	ro := mux.NewRouter()

	// Set StrictSlash to allow /things/ to automatically redirect to /things
	ro.StrictSlash(true)

	// Use Render for template. Pass in path to templates folder
	// as well as asset helper functions.
	re := render.New(render.Options{
		Layout:     "layouts/layout",
		Extensions: []string{".html"},
	})

	ne.UseHandler(ro)

	return &App{ne, ro, re, db}
}
Example #5
0
// CreatePersonIDType ... add new contact to a person
func (c PersonController) CreatePersonIDType(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	personIDType := new(models.PersonIDType)
	errs := binding.Bind(req, personIDType)
	idTypes := models.IDType{}
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := personIDType.Validate(req, errs)
	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}
	p := models.PersonIDType{
		BaseModel:      c.BaseModel,
		PersonID:       personIDType.PersonID,
		IDType:         personIDType.IDType,
		IDNumber:       personIDType.IDNumber,
		DateIssued:     personIDType.DateIssued,
		ExpiryDate:     personIDType.ExpiryDate,
		ScannedPicture: personIDType.ScannedPicture,
		IDTypes:        idTypes}
	err := c.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}
	r.JSON(res, 200, p)
}
Example #6
0
func TestGetRandomMovie(t *testing.T) {

	s := &mockStore{}
	s.mockGetRandom = func() (*models.Movie, error) {
		return &models.Movie{
			ImdbID: "tt090909090",
			Title:  "The Martian",
			Actors: "Matt Damon",
		}, nil
	}
	c := AppConfig{
		Store:   s,
		Render:  render.New(),
		Options: Options{},
	}
	router := c.Router()
	r, err := http.NewRequest("GET", "/api/", nil)
	if err != nil {
		t.Fatal(err)
	}
	w := httptest.NewRecorder()

	router.ServeHTTP(w, r)
	if w.Code != http.StatusOK {
		t.Error("Should be a 200 OK")
	}

}
Example #7
0
//RegisterUser ...
func (client *ClientController) RegisterUser(res http.ResponseWriter, req *http.Request) {
	//Extract the models from the request
	render := render.New(render.Options{})
	registeredType := new(services.RegisteredUser)
	errs := binding.Bind(req, registeredType)
	userlogic.ServiceList = client.ServiceList
	userlogic.Logger = client.Logger
	if errs.Handle(res) {
		client.Logger.Crit(errs.Error())
		render.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := registeredType.Validate(req, errs)
	if bindingErr != nil {
		client.Logger.Crit(bindingErr.Error())
		render.JSON(res, 422, bindingErr.Error())
		return
	}

	person, user, err := userlogic.RegisterUser(registeredType.Person, registeredType.User)
	if err != nil {
		client.Logger.Error(err.Error())
		panic(err)
	}
	render.JSON(res, 200, map[string]interface{}{"Person": person, "User": user})
}
Example #8
0
func main() {
	fmt.Println("jøkulhlaup ", Version)

	r := render.New(render.Options{})

	m := martini.Classic()

	fizz := fizz.New()

	// Dashboard
	m.Get("/", func(w http.ResponseWriter, req *http.Request) {
		data := map[string]string{
			"title":  "Jøkulhlaup",
			"imgsrc": "img/jøkulhlaup.png",
			"width":  "1440",
			"height": "900",
		}

		// !! Reload template !!
		//r = render.New(render.Options{})

		// Render the specified templates/.tmpl file as HTML and return
		r.HTML(w, http.StatusOK, "black", data)
	})

	// Activate the permission middleware
	m.Use(fizz.All())

	// Share the files in static
	m.Use(martini.Static("static"))

	m.Run() // port 3000 by default
}
Example #9
0
// CreateAccount ... add new contact to a person
func (acct AccountController) CreateAccount(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	account := new(models.Account)
	errs := binding.Bind(req, account)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := account.Validate(req, errs)
	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}

	p := models.Account{acct.BaseModel, account.AccountType, account.AccountNo, account.AccountCategoryID, account.AccountFundSource, account.AccountFundSourceID,
		account.AccountLimit, account.AccountLimitID, account.MaxBalance, account.MinBalance, account.CurrentBalance, account.CustomerID, account.Customer}
	//p := models.User{acct.BaseModel, user.Realm, user.Username, user.Password, user.Credential, user.Challenges, user.Email, user.Emailverified, user.Verificationtoken,
	//	user.LogInCummulative, user.FailedAttemptedLogin, uuid.New(), user.PersonID, user.PhoneNum, user.VerifiedPhoneNum}

	err := acct.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}
	// render response
	r.JSON(res, 200, p)
}
Example #10
0
// CreateAddress ... add new address to a person
func (c PersonController) CreateAddress(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	address := new(models.Addresses)
	errs := binding.Bind(req, address)
	bs, _ := ioutil.ReadAll(req.Body)
	if errs.Handle(res) {
		c.Logger.Error(fmt.Sprintf("%s, %s", errs.Error(), string(bs)))
		r.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := address.Validate(req, errs)
	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}

	p := &models.Addresses{
		BaseModel:         c.BaseModel,
		AddressType:       address.AddressType,
		HouseNo:           address.HouseNo,
		Street:            address.Street,
		Area:              address.Area,
		TownsID:           address.TownsID,
		RegionStateID:     address.RegionStateID,
		CountryID:         address.CountryID,
		PersonID:          address.PersonID,
		CompanyEntitiesID: address.CompanyEntitiesID}

	err := c.DataStore.SaveDatabaseObject(p)
	if err != nil {
		panic(err)
	}
	c.Logger.Info(fmt.Sprintf("%v", &p))
	r.JSON(res, 200, p)
}
Example #11
0
// CreateCountry ... create new country
func (c CommonController) CreateCountry(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	country := new(models.Country)
	errs := binding.Bind(req, country)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}

	bindingErr := country.Validate(req, errs)

	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}
	// save to database
	p := models.Country{c.BaseModel, country.ISOCode, country.Name, country.RegionStates, country.Language, country.LanguageID}

	err := c.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		fmt.Println(err.Error())
		panic(err)
	} else {
		r.JSON(res, 200, p)
	}

	// render response

}
Example #12
0
// CreateGood ... create new merchant
func (mer MerchantController) CreateGood(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	good := new(models.Goods)
	errs := binding.Bind(req, good)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}

	bindingErr := good.Validate(req, errs)

	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}
	// save to database
	p := models.Goods{mer.BaseModel, good.MerchantID, good.PercentDiscount, good.AvailFrom, good.AvailTo, good.Promo, good.UnitPrice, good.GoodServices, good.GoodserviceID,
		good.GoodCategoryID, good.GoodHist}

	err := mer.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}

	// render response
	r.JSON(res, 200, p)
}
Example #13
0
func Participate(config ConfigFactory, logger func(interface{})) func(http.ResponseWriter, *http.Request) {
	cfg := *config()

	return func(w http.ResponseWriter, req *http.Request) {
		r := render.New()
		if req.Method != "POST" {
			r.JSON(w, http.StatusMethodNotAllowed, "Method not supported")
			fmt.Errorf("ERROR: method not supported")
			return
		}

		preq := ParticipateRequest{}

		body, rerr := ioutil.ReadAll(req.Body)
		if rerr != nil {
			r.JSON(w, http.StatusBadRequest, fmt.Sprintf("Error reading body: %s", rerr))
			fmt.Errorf("ERROR: reading body: %v", rerr)
			return
		}

		err := json.Unmarshal(body, &preq)
		if err != nil {
			r.JSON(w, http.StatusBadRequest, fmt.Sprintf("Error decoding json: %s", err))
			fmt.Errorf("ERROR: decoding json: %s received: %s", err, string(body))
			return
		}

		presp := new(ParticipateResponse)
		presp.Experiments = CheckExperiments(preq.Experiments, preq.Context.Uid, cfg)
		presp.Features = CheckFeatures(preq.Features, preq.Context.Uid, cfg)

		r.JSON(w, http.StatusOK, presp)
		go logger(*presp)
	}
}
Example #14
0
// CreateMerchant ... create new merchant
func (mer MerchantController) CreateMerchant(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	merchant := new(models.Merchant)
	errs := binding.Bind(req, merchant)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}

	bindingErr := merchant.Validate(req, errs)

	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}
	// save to database

	p := models.Merchant{mer.BaseModel, merchant.Account, merchant.AccountID, merchant.Customer, merchant.CustomerID, merchant.AlternativeID, merchant.Goods}

	err := mer.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}

	// render response
	r.JSON(res, 200, p)
}
Example #15
0
File: api.go Project: Qlean/silvia
func RingApi(w http.ResponseWriter, r *http.Request, worker *Worker) {
	var ring interface{}
	u, _ := url.Parse(r.URL.String())
	queryParams := u.Query()
	switch queryParams.Get("tracker") {
	case "snowplow":
		switch queryParams.Get("ring") {
		case "success":
			ring = worker.Stats.SnowplowSuccessRing.Display()
		case "failed":
			ring = worker.Stats.SnowplowFailRing.Display()
		}
	case "adjust":
		switch queryParams.Get("ring") {
		case "success":
			ring = worker.Stats.AdjustSuccessRing.Display()
		case "failed":
			ring = worker.Stats.AdjustFailRing.Display()
		}
	}

	rndr := render.New()
	b, err := json.MarshalIndent(ring, "", "  ")
	if err != nil {
		rndr.Text(w, http.StatusBadRequest, "Cant draw pretty JSON")
		return
	}

	rndr.Text(w, http.StatusOK, string(b))
}
Example #16
0
File: api.go Project: Qlean/silvia
func StatusApi(w http.ResponseWriter, r *http.Request, worker *Worker) {
	rndr := render.New()

	stats := worker.Stats

	adjustSuccessRing := stats.AdjustSuccessRing.Display()
	adjustFailRing := stats.AdjustFailRing.Display()
	snowplowSuccessRing := stats.SnowplowSuccessRing.Display()
	snowplowFailRing := stats.SnowplowFailRing.Display()

	status := Status{
		RabbitHealth:    stats.RabbitHealth.Get(),
		PostgresHealth:  stats.PostgresHealth.Get(),
		AdjustSuccess:   adjustSuccessRing.Total,
		AdjustFailed:    adjustFailRing.Total,
		SnowplowSuccess: snowplowSuccessRing.Total,
		SnowplowFailed:  snowplowFailRing.Total,
		Uptime:          time.Since(stats.StartTime).String(),
	}

	b, err := json.MarshalIndent(status, "", "  ")
	if err != nil {
		rndr.Text(w, http.StatusBadRequest, "Cant draw pretty JSON")
		return
	}

	httpStatus := http.StatusOK

	if !status.RabbitHealth || !status.PostgresHealth {
		httpStatus = http.StatusTooManyRequests
	}

	rndr.Text(w, httpStatus, string(b))
}
Example #17
0
func New(db *database.DB,
	mailer mailer.Mailer,
	log *logrus.Logger,
	cfg *config.Config) *Server {

	secureCookieKey, _ := base64.StdEncoding.DecodeString(cfg.SecureCookieKey)

	cookie := securecookie.New(
		[]byte(cfg.SecretKey),
		secureCookieKey,
	)

	renderOptions := render.Options{
		IsDevelopment: cfg.IsDev(),
	}

	renderer := render.New(renderOptions)

	f := feedparser.New(db, log)

	return &Server{
		DB:         db,
		Config:     cfg,
		Log:        log,
		Render:     renderer,
		Cookie:     cookie,
		Feedparser: f,
		Mailer:     mailer,
	}
}
Example #18
0
func LoadEnvironment(env string) (err error) {
	if !isValidEnvironment(env) {
		return fmt.Errorf("'%s' is not one of the supported enviroments: %v", env, strings.Join(Environments, ","))
	}
	Env = env

	// Load environment variables
	envFileName := Env + ".env"
	if err = godotenv.Load(envFileName); err != nil {
		return
	}

	// Connect to database
	if err = connectDB(); err != nil {
		return
	}

	// Initialize render
	Render = render.New(render.Options{
		Directory:     "templates",
		Layout:        "",
		Delims:        render.Delims{Left: "{{%", Right: "%}}"},
		Extensions:    []string{".tmpl", ".html"},
		IsDevelopment: Env == EnvDevelopment,
	})

	return
}
Example #19
0
// CreateLanguage ... create new language
func (c CommonController) CreateLanguage(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	language := new(models.Language)
	errs := binding.Bind(req, language)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := language.Validate(req, errs)

	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}
	// save to database
	p := models.Language{c.BaseModel, language.ISOCode, language.Name}

	err := c.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}

	// render response
	r.JSON(res, 200, p)
}
Example #20
0
func GetNodeInfo(res http.ResponseWriter, req *http.Request) {
	r := render.New()
	vars := mux.Vars(req)

	node := vars["node"]
	if node == "" {
		r.JSON(res, http.StatusInternalServerError, "No node name provided")
		return
	}

	sets, err := Resolv(node)
	if err != nil {
		r.JSON(res, http.StatusNotFound, "Node could not be resolved")
		return
	}

	for _, s := range sets {
		for _, n := range networks {
			if n.Contains(s.Addr) {
				r.JSON(res, http.StatusOK, n)
				return
			}
		}
	}
	r.JSON(res, http.StatusNotFound, "No matching network found")
}
Example #21
0
// CreateRegion ... create new region
func (c CommonController) CreateRegion(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	region := new(models.RegionState)
	errs := binding.Bind(req, region)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}

	bindingErr := region.Validate(req, errs)

	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}

	// save to database
	p := models.RegionState{c.BaseModel, region.Name, region.CountryID, region.Towns}

	err := c.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}

	// render response
	r.JSON(res, 200, p)
}
Example #22
0
func GetNetworkIps(res http.ResponseWriter, req *http.Request) {
	r := render.New()
	vars := mux.Vars(req)

	network_name := vars["net"]
	if network_name == "" {
		r.JSON(res, http.StatusInternalServerError, "No network name provided")
		return
	}

	for _, network := range networks {
		if network.Name == network_name {
			ips, err := network.ExpandDetailed()
			if err != nil {
				r.JSON(res, http.StatusInternalServerError, "Network could not be expanded")
				return
			}

			c := NewCheck(ips)
			c.Run()
			network.Utilization = c.utilization

			var out []*ResultSet

			for _, elem := range c.results {
				out = append(out, elem)
			}

			r.JSON(res, http.StatusOK, out)
			return

		}
	}
	r.JSON(res, http.StatusNotFound, "No matching network found")
}
Example #23
0
// CreateCustomer ... Add new customer
func (acct AccountController) CreateCustomer(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	r := render.New(render.Options{})
	customer := new(models.Customer)
	errs := binding.Bind(req, customer)
	if errs.Handle(res) {
		r.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := customer.Validate(req, errs)
	if bindingErr != nil {
		r.JSON(res, 422, bindingErr.Error())
		return
	}

	p := models.Customer{acct.BaseModel, customer.Person, customer.PersonID, customer.CompanyEntites, customer.CompanyEntitesID, customer.CustomerType, customer.CustomerTypeID}
	//p := models.User{acct.BaseModel, user.Realm, user.Username, user.Password, user.Credential, user.Challenges, user.Email, user.Emailverified, user.Verificationtoken,
	//	user.LogInCummulative, user.FailedAttemptedLogin, uuid.New(), user.PersonID, user.PhoneNum, user.VerifiedPhoneNum}

	err := acct.DataStore.SaveDatabaseObject(&p)
	if err != nil {
		panic(err)
	}
	// render response
	r.JSON(res, 200, p)
}
Example #24
0
func main() {
	// Render engine
	r := render.New(render.Options{
		Layout: "layout",
	})

	// Handlers
	router := mux.NewRouter()
	router.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		r.HTML(w, http.StatusOK, "home", nil)
	})
	router.HandleFunc("/about", func(w http.ResponseWriter, req *http.Request) {
		r.HTML(w, http.StatusOK, "about", nil)
	})
	router.HandleFunc("/start", func(w http.ResponseWriter, req *http.Request) {
		time := req.FormValue("time")
		stepsPerMinute, _ := strconv.Atoi(req.FormValue("steps"))
		var hours, minutes, seconds int
		fmt.Sscanf(time, "%d:%d:%d", &hours, &minutes, &seconds)
		fmt.Println(hours, minutes, seconds)
		go startLapse((hours*3600)+(minutes*60)+seconds, stepsPerMinute)
		r.HTML(w, http.StatusOK, "home", nil)
	}).Methods("POST")

	// HTTP Server
	n := negroni.Classic()
	n.UseHandler(router)
	n.Run(":3000")
}
Example #25
0
// New returns a new blank Engine instance with no middleware attached
func New(opts Options) *Engine {
	namespace := opts.Namespace
	if len(namespace) == 0 {
		namespace = "/"
	}

	engine := &Engine{}
	engine.Router = &Router{
		namespace: namespace,
		engine:    engine,
		mux:       chi.NewRouter(),
	}
	engine.options = opts
	engine.pool.New = func() interface{} {
		ctx := &Context{
			Engine: engine,
			render: render.New(render.Options{
				Layout: "layout",
			}),
		}
		return ctx
	}

	return engine
}
Example #26
0
// Init :init controller methods
func init() {
	Render = render.New(render.Options{
		Directory: "templates",
		Layout:    "layout",
	})
	RedisPool = newRedisPool()
}
Example #27
0
//AddNewAddressToUser ... Add address to a user profile
func (client *ClientController) AddNewAddressToUser(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) {

	render := render.New(render.Options{})
	address := models.Addresses{}
	errs := binding.Bind(req, &address)
	userlogic.ServiceList = client.ServiceList
	userlogic.Logger = client.Logger
	userlogic.AuthorizationToken = req.Header.Get("Authorization")
	if errs.Handle(res) {
		client.Logger.Crit(errs.Error())
		render.JSON(res, 422, errs.Error())
		return
	}
	bindingErr := address.Validate(req, errs)
	if bindingErr != nil {
		client.Logger.Crit(bindingErr.Error())
		render.JSON(res, 422, bindingErr.Error())
		return
	}

	savedEntity, bSave, err := userlogic.AddNewAddressToUser(address)
	if !bSave && err != nil {
		client.Logger.Error(err.Error())
		panic(err)
	}
	render.JSON(res, 200, savedEntity)
}
Example #28
0
func InjectRender(c *web.C, h http.Handler) http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {

		c.Env["render"] = render.New(render.Options{
			Directory:  "views",
			Layout:     "",
			Extensions: []string{".tmpl"},
			Funcs: []template.FuncMap{template.FuncMap{
				"classIfHere": func(path, class string) template.HTMLAttr {
					if r.URL.Path == path {
						return template.HTMLAttr(fmt.Sprintf(`class="%s"`, class))
					}
					return template.HTMLAttr("")
				},
				"date": func(date time.Time) string {
					return date.Format("January 2, 2006")
				},
				"checkIfInArray": func(x string, slice []string) template.HTMLAttr {
					for _, y := range slice {
						if x == y {
							return template.HTMLAttr("checked")
						}
					}
					return template.HTMLAttr("")
				},
			}},
		})

		h.ServeHTTP(w, r)

	}

	return http.HandlerFunc(fn)
}
Example #29
0
func indexHandler(c web.C, w http.ResponseWriter, r *http.Request) {
	ren := render.New(render.Options{
		Layout:     "layout",
		Extensions: []string{".html"},
	})
	ren.HTML(w, http.StatusOK, "index", nil)
}
Example #30
0
func main() {
	render := render.New(render.Options{
		Directory:  "src/views",
		Extensions: []string{".html"},
	})

	http.HandleFunc("/img/", serveResource)
	http.HandleFunc("/css/", serveResource)
	http.HandleFunc("/js/", serveResource)

	goji.Get("/hello/:name", func(c web.C, w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Hello, %s!", c.URLParams["name"])
	})

	goji.Get("/wow", func(c web.C, w http.ResponseWriter, r *http.Request) {
		render.HTML(w, http.StatusOK, "index", nil)
	})

	goji.Get("/bar", func(c web.C, w http.ResponseWriter, r *http.Request) {
		render.HTML(w, http.StatusOK, "bar", nil)
	})

	goji.Get("/", func(c web.C, w http.ResponseWriter, r *http.Request) {
		render.HTML(w, http.StatusOK, "index", nil)
	})

	goji.Serve()
}