Beispiel #1
0
func postedHandler(s Services, w http.ResponseWriter, r *http.Request) {
	user, err := getUser(s, w, r)
	if err != nil {
		// TODO don't leak errors
		renderError(w, fmt.Sprintf("%s", err))
		return
	}
	if user == nil {
		renderError(w, "You aren't logged in!")
		return
	}

	tweets, err := getTweets(s, *user, true)
	if err != nil {
		renderError(w, fmt.Sprintf("%s", err))
		return
	}

	args := map[string]interface{}{
		"posted":   "yes",
		"username": user.screenName,
		"tweets":   tweets,
	}

	data := mustache.RenderFileInLayout(
		"/usr/share/tweetautofeeder/templates/posted_page.must",
		"/usr/share/tweetautofeeder/templates/layout.must",
		args)
	w.Write([]byte(data))

	return
}
Beispiel #2
0
// LoginHandler writes out login template
func LoginHandler(r *http.Request, w http.ResponseWriter) {
	context := map[string]interface{}{
		"title":      "Access magnet",
		"csrf_token": nosurf.Token(r),
	}
	w.Write([]byte(mustache.RenderFileInLayout("templates/login.mustache", "templates/base.mustache", context)))
}
Beispiel #3
0
func DiscoverHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	vineApi := VineRequest{c}
	db := DB{c}
	var recentUsers []*VineUser
	var recentVerified []StoredUserMeta

	recent := datastore.NewQuery("Queue").Order("-Discovered").Limit(5).KeysOnly()
	k, _ := recent.GetAll(c, nil)
	for i, _ := range k {
		user, err := vineApi.GetUser(strconv.FormatInt(k[i].IntID(), 10))
		if err == nil {
			recentUsers = append(recentUsers, user)
		}
	}
	verified := datastore.NewQuery("UserMeta").Filter("Verified =", true).Limit(5).KeysOnly()
	k, _ = verified.GetAll(c, nil)
	for i, _ := range k {
		user, err := db.GetUserMeta(k[i].IntID())
		if err == nil {
			recentVerified = append(recentVerified, user.(StoredUserMeta))
		}
	}
	data := map[string]interface{}{"recentUsers": recentUsers, "recentVerified": recentVerified}
	dir := path.Join(os.Getenv("PWD"), "templates")
	discover := path.Join(dir, "discover.html")
	layout := path.Join(dir, "pageLayout.html")
	page := mustache.RenderFileInLayout(discover, layout, data)
	fmt.Fprint(w, page)
}
Beispiel #4
0
func DonateHandler(w http.ResponseWriter, r *http.Request) {
	dir := path.Join(os.Getenv("PWD"), "templates")
	donate := path.Join(dir, "donate.html")
	layout := path.Join(dir, "pageLayout.html")
	page := mustache.RenderFileInLayout(donate, layout, nil)
	fmt.Fprint(w, page)
}
Beispiel #5
0
func listHosts(store configstore.Store, w http.ResponseWriter, req *http.Request) {
	names, err := store.Names()
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	if req.Header.Get("Accept") == "application/json" {
		w.Header().Set("Content-type", "application/json")

		enc := json.NewEncoder(w)
		err := enc.Encode(struct {
			Hostnames []string
		}{
			Hostnames: names,
		})

		if err != nil {
			log.Printf("Error: %s", err)
			http.Error(w, "error :(", 500)
			return
		}
	} else {
		io.WriteString(w, mustache.RenderFileInLayout("templates/hosts.html.mustache", "templates/layout.html.mustache", names))
	}
}
Beispiel #6
0
func renderPage(ctx *web.Context) string {
	home := new(Home)
	user := ctx.Params["user"]
	followedBy, following, err := GetFollow(user)

	if err != nil {
		print(err.Error() + " in renderPage ")
	}

	jits, err := GetJits(user)
	if err != nil {
		print(err.Error() + " in renderPage jiterror ")
	}

	home.CardRender = FetchUserInfo(user)
	home.StreamRender = &Stream{UserID: user, Items: jits}
	//home.StreamRender = &Stream{UserID: user, Items: []*StreamItem{
	//	dummyStreamItem(), dummyStreamItem()}}
	home.FollowRender = new(Follow)
	home.FollowRender.UserID = user
	home.FollowRender.FollowedBy = followedBy
	home.FollowRender.Following = following

	compileHome(home)
	home.Html = mustache.RenderFileInLayout("Pages/Home.mustache", "Pages/layout.mustache", home)
	return home.Html
}
Beispiel #7
0
func contact(w http.ResponseWriter, r *http.Request) {
	var submitted string
	if r.Method == "POST" {
		c := appengine.NewContext(r)
		name := r.FormValue("name")
		email := r.FormValue("email")
		info := r.FormValue("info")
		if name == "" || email == "" || info == "" {
			submitted = "Submission failed. Please enter all the information on the form. Thanks!"
		} else {
			msg := &mail.Message{
				Sender:   "*****@*****.**",
				To:       []string{"*****@*****.**"},
				Subject:  fmt.Sprintf("Website Contact - %s", name),
				Body:     fmt.Sprintf("Name: %s\nEmail: %s\nInformation: %s", name, email, info),
				HTMLBody: fmt.Sprintf("<html><body><p>Name: %s</p><p>Email: %s</p><p>Information: %s</p></body></html>", name, email, info),
			}
			if err := mail.Send(c, msg); err != nil {
				c.Errorf("Could not send email: %v", err)
				submitted = "Your information could not be sent. Could you try again later? Apologies!"
			} else {
				submitted = "Your information has been sent. I'll get back to you as soon as possible!"
			}
		}
		c.Infof("Contact submitted: name=%s, email=%s, info=%s", name, email, info)
	}
	out := mustache.RenderFileInLayout("mustache/contact.html.mustache", "mustache/layout.html.mustache", map[string]string{"submitted": submitted})
	fmt.Fprint(w, out)
}
Beispiel #8
0
func diffBackup(store configstore.Store, w http.ResponseWriter, req *http.Request) {
	vars := mux.Vars(req)

	t1, err := time.Parse(file.DefaultDateFormat, vars["date1"])
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	t2, err := time.Parse(file.DefaultDateFormat, vars["date2"])
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	e1 := configstore.Entry{
		Name: vars["hostname"],
		Date: t1,
	}

	e2 := configstore.Entry{
		Name: vars["hostname"],
		Date: t2,
	}

	err = store.Get(&e1)
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	err = store.Get(&e2)
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	dmp := diffmatchpatch.New()
	diffs := dmp.DiffMain(e1.Content.String(), e2.Content.String(), true)

	em := struct {
		Hostname string
		Date1    time.Time
		Date2    time.Time
		Diff     string
	}{
		vars["hostname"],
		t1,
		t2,
		dmp.DiffPrettyHtml(diffs),
	}

	io.WriteString(w, mustache.RenderFileInLayout("templates/diff.html.mustache", "templates/layout.html.mustache", em))
}
Beispiel #9
0
func NotFoundHandler(w http.ResponseWriter, r *http.Request) {
	dir := path.Join(os.Getenv("PWD"), "templates")
	notFound := path.Join(dir, "404.html")
	layout := path.Join(dir, "pageLayout.html")
	data := map[string]string{"url": r.RequestURI}
	page := mustache.RenderFileInLayout(notFound, layout, data)
	w.WriteHeader(404)
	fmt.Fprint(w, page)
}
Beispiel #10
0
func homeHandler(w http.ResponseWriter, r *http.Request) {
	data.Title = "Home"
	data.Posts = make([]Post, 5)
	for k, v := range posts[:5] {
		data.Posts[k] = *v
		data.Posts[k].PrettyDate = humanize.Time(v.Date)
	}
	fmt.Fprint(w, mustache.RenderFileInLayout("templates/home.html.mustache", "templates/layout.html.mustache", data))
}
Beispiel #11
0
func hostBackup(store configstore.Store, w http.ResponseWriter, req *http.Request) {
	vars := mux.Vars(req)

	t, err := time.Parse(file.DefaultDateFormat, vars["date"])
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	e := configstore.Entry{
		Name: vars["hostname"],
		Date: t,
	}

	err = store.Get(&e)
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	if req.Header.Get("Accept") == "application/json" {
		w.Header().Set("Content-type", "application/json")

		enc := json.NewEncoder(w)
		err := enc.Encode(struct {
			Hostname string
			Date     string
			Content  string
		}{
			Hostname: e.Name,
			Date:     e.Date.Format(file.DefaultDateFormat),
			Content:  e.Content.String(),
		})
		if err != nil {
			log.Printf("Error: %s", err)
			http.Error(w, "error :(", 500)
			return
		}
	} else {

		em := struct {
			Hostname string
			Date     string
			Content  string
		}{
			vars["hostname"],
			t.String(),
			e.Content.String(),
		}

		io.WriteString(w, mustache.RenderFileInLayout("templates/entry.html.mustache", "templates/layout.html.mustache", em))
	}
}
Beispiel #12
0
func renderError(w http.ResponseWriter, errorMessage string) {
	data := mustache.RenderFileInLayout(
		"/usr/share/tweetautofeeder/templates/error_page.must",
		"/usr/share/tweetautofeeder/templates/layout.must",
		map[string]string{
			"errorMessage": errorMessage,
		})
	w.Write([]byte(data))
	w.WriteHeader(http.StatusBadRequest)
	return
}
func loginHandler(s Services, w http.ResponseWriter, r *http.Request) {

	url, _ := s.router.Get("login_begin").URLPath()

	data := mustache.RenderFileInLayout(
		"/usr/share/tweetautofeeder/templates/main_page.must",
		"/usr/share/tweetautofeeder/templates/layout.must",
		map[string]string{"url": url.String()})
	w.Write([]byte(data))
	return
}
Beispiel #14
0
func listDates(store configstore.Store, w http.ResponseWriter, req *http.Request) {
	vars := mux.Vars(req)
	datesStore, err := store.Dates(vars["hostname"])
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	if req.Header.Get("Accept") == "application/json" {
		w.Header().Set("Content-type", "application/json")

		var dates []string
		for _, date := range datesStore {
			dates = append(dates, date.Format(file.DefaultDateFormat))
		}

		enc := json.NewEncoder(w)
		err := enc.Encode(struct {
			Hostname string
			Dates    []string
		}{
			Hostname: vars["hostname"],
			Dates:    dates,
		})
		if err != nil {
			log.Printf("Error: %s", err)
			http.Error(w, "error :(", 500)
			return
		}
	} else {

		var data = struct {
			Hostname string
			Dates    []struct {
				String string
				URL    string
			}
		}{
			Hostname: vars["hostname"],
		}
		for _, date := range datesStore {
			data.Dates = append(data.Dates, struct {
				String string
				URL    string
			}{
				String: date.String(),
				URL:    date.Format(file.DefaultDateFormat),
			})
		}

		io.WriteString(w, mustache.RenderFileInLayout("templates/dates.html.mustache", "templates/layout.html.mustache", data))
	}
}
Beispiel #15
0
func TopHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	db := DB{c}

	dir := path.Join(os.Getenv("PWD"), "templates")
	top := path.Join(dir, "top.html")
	layout := path.Join(dir, "pageLayout.html")
	data := db.GetTop()
	data["LastUpdated"] = db.GetLastUpdated()
	page := mustache.RenderFileInLayout(top, layout, data)
	fmt.Fprint(w, page)
}
Beispiel #16
0
func showBackupDate(store configstore.Store, w http.ResponseWriter, req *http.Request) {
	vars := mux.Vars(req)

	t, err := time.Parse(file.DefaultDateFormat, vars["date"])
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	datesStore, err := store.Dates(vars["hostname"])
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	// Find the backup on or after the specified date
	var idx int
	for i, date := range datesStore {
		if t.Before(date) {
			idx = i - 1
		}
	}

	if idx == -1 {
		idx = 0
	}

	e := configstore.Entry{
		Name: vars["hostname"],
		Date: datesStore[idx],
	}

	err = store.Get(&e)
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	em := struct {
		Hostname string
		Date     string
		Content  string
	}{
		vars["hostname"],
		datesStore[idx].String(),
		e.Content.String(),
	}

	io.WriteString(w, mustache.RenderFileInLayout("templates/entry.html.mustache", "templates/layout.html.mustache", em))
}
Beispiel #17
0
func renderStream() string {
	items := []*StreamItem{
		dummyStreamItem(), dummyStreamItem(), dummyStreamItem()}
	str := new(Stream)
	str.Items = make([]*StreamItem, len(items))
	for i, v := range items {
		str.Items[i] = compileStreamItem(v)
	}

	html := mustache.RenderFileInLayout("Pages/Stream.mustache", "Pages/layout.mustache", str)
	return html
}
Beispiel #18
0
func AboutHandler(w http.ResponseWriter, r *http.Request) {
	dir := path.Join(os.Getenv("PWD"), "templates")
	aboutPage := path.Join(dir, "about.html")
	layout := path.Join(dir, "pageLayout.html")

	db := DB{appengine.NewContext(r)}
	totalUsers, _ := db.GetTotalUsers()
	stats := map[string]interface{}{"users": totalUsers}
	stats["lastUpdated"] = db.GetLastUpdated()
	data := mustache.RenderFileInLayout(aboutPage, layout, stats)

	fmt.Fprint(w, data)
}
Beispiel #19
0
// IndexHandler writes out templates
func IndexHandler(req *http.Request, w http.ResponseWriter, cs *sessions.CookieStore, connection *Connection) {
	username, userID := GetUserData(cs, req)
	context := map[string]interface{}{
		"title":      "Magnet",
		"csrf_token": nosurf.Token(req),
		"bookmarks":  GetBookmarks(0, connection, userID),
		"tags":       GetTags(connection, userID),
		"username":   username,
	}

	context["load_more"] = len(context["bookmarks"].([]Bookmark)) == 50

	w.Write([]byte(mustache.RenderFileInLayout("templates/home.mustache", "templates/base.mustache", context)))
}
Beispiel #20
0
/*
* Handles rendering templates in a normalized context
 */
func RenderTemplate(template string, context map[string]interface{}) string {
	title, _ := Config.GetString("general", "title")
	motto, _ := Config.GetString("general", "motto")

	var send = map[string]interface{}{
		"blog_title": title,
		"blog_motto": motto,
	}
	// Append all values of context to the global context
	for key, val := range context {
		send[key] = val
	}

	return mustache.RenderFileInLayout("templates/"+template, "templates/base.mustache", send)
}
Beispiel #21
0
func indexHandler(s Services, w http.ResponseWriter, r *http.Request) {
	args := map[string]string{
		"homepage": "yes",
	}

	user, _ := getUser(s, w, r)
	if user != nil {
		args["username"] = user.screenName
	}

	data := mustache.RenderFileInLayout(
		"/usr/share/tweetautofeeder/templates/main_page.must",
		"/usr/share/tweetautofeeder/templates/layout.must",
		args)
	w.Write([]byte(data))
	return
}
Beispiel #22
0
func SearchHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	dir := path.Join(os.Getenv("PWD"), "templates")
	search := path.Join(dir, "search.html")
	layout := path.Join(dir, "pageLayout.html")
	data := map[string]interface{}{
		"query": r.FormValue("q"),
		"count": 0,
	}
	if len(r.FormValue("q")) > 0 {
		results, err := SearchUsers(c, r.FormValue("q"))
		if err != nil {
			c.Errorf("got err on search: %v", err)
		}

		switch r.FormValue("s") {
		case "overall":
			sort.Sort(ByOverall(results))
			break
		case "followers":
			sort.Sort(ByFollowers(results))
			break
		case "loops":
			sort.Sort(ByLoops(results))
			break
		case "posts":
			sort.Sort(ByPosts(results))
			break
		case "revines":
			sort.Sort(ByRevines(results))
			break
		}

		if r.Method == "GET" {
			data["count"] = len(results)
			data["results"] = results
		} else if r.Method == "POST" {
			jsonData, _ := json.Marshal(results)
			fmt.Fprint(w, string(jsonData))
			return
		}
	}

	page := mustache.RenderFileInLayout(search, layout, data)
	fmt.Fprint(w, page)
}
Beispiel #23
0
func ExportHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	db := DB{c}
	vars := mux.Vars(r)

	if r.Method == "GET" {
		StartupHandler(w, r)
		userId, err := strconv.ParseInt(vars["user"], 10, 64)
		if err != nil {
			c.Errorf("got err: %v", err)
			http.Redirect(w, r, "/404", 301)
			return
		}
		userMeta, err := db.GetUserMeta(userId)
		if err == datastore.ErrNoSuchEntity {
			http.Redirect(w, r, "/404", 301)
			return
		}
		user := userMeta.(StoredUserMeta)
		data := map[string]string{"username": user.Username, "userId": vars["user"], "captcha": Config["captchaPublic"]}
		dir := path.Join(os.Getenv("PWD"), "templates")
		export := path.Join(dir, "export.html")
		layout := path.Join(dir, "pageLayout.html")
		page := mustache.RenderFileInLayout(export, layout, data)
		fmt.Fprint(w, page)
	} else if r.Method == "POST" {
		client := urlfetch.Client(c)
		url := "https://www.google.com/recaptcha/api/siteverify?secret=" + Config["captchaPrivate"]
		url += "&response=" + r.FormValue("g-recaptcha-response") + "&remoteip=" + r.RemoteAddr
		req, _ := http.NewRequest("GET", url, nil)
		resp, err := client.Do(req)
		if err != nil {
			c.Errorf("got err: %v", err)
			return
		}
		body, _ := ioutil.ReadAll(resp.Body)
		var data map[string]interface{}
		json.Unmarshal(body, &data)
		if data["success"].(bool) {
			export := Export{c}
			export.User(vars["user"], w)
		} else {
			fmt.Fprint(w, "Seems like your CAPTCHA was wrong. Please press back and try again.")
		}
	}
}
func main() {
	fmt.Println("### Welcome to the Blue Mandarin Lab Flash Card Server ###")

	err := zhDicts.LoadDb()
	if err != nil {
		panic(err)
	}
	defer zhDicts.CloseDb()

	err = cedict.Initialize()
	if err != nil {
		panic(err)
	}
	err = moedict.Initialize()
	if err != nil {
		panic(err)
	}

	findWordsInSentencesRegexp, err = regexp.Compile("\\[(.*?)\\]")
	if err != nil {
		panic(err)
	}
	findCharInMcdsRegexp, err = regexp.Compile(clozeBegin + "(.*?)" + clozeEnd)
	if err != nil {
		panic(err)
	}

	// Load html files, the array at the end contains the js files to be loaded
	homeHtml := mustache.RenderFileInLayout("home.html", layoutFile, map[string]interface{}{})
	vocabHtml := mustache.RenderFileInLayout("vocab.html", layoutFile, map[string]interface{}{"jsfiles": []string{"vocab"}})
	moeVocabHtml := mustache.RenderFileInLayout("moe-vocab.html", layoutFile, map[string]interface{}{"jsfiles": []string{"moe-vocab"}})
	sentencesHtml := mustache.RenderFileInLayout("sentences.html", layoutFile, map[string]interface{}{"jsfiles": []string{"sentences"}})
	mcdsHtml := mustache.RenderFileInLayout("mcds.html", layoutFile, map[string]interface{}{"jsfiles": []string{"mcds", "mcds-dict"}})
	pinyinifyHtml := mustache.RenderFileInLayout("pinyinify.html", layoutFile, map[string]interface{}{"jsfiles": []string{"pinyinify"}})
	settingsHtml := mustache.RenderFileInLayout("settings.html", layoutFile, map[string]interface{}{"jsfiles": []string{"settings"}})

	// FIXME set active class in navbar

	// Set up the http server

	// small helper function (used below)
	addStaticHtmlHandler := func(path string, html string) {
		http.HandleFunc(path, func(writer http.ResponseWriter, request *http.Request) {
			fmt.Fprintf(writer, html)
		})
	}

	addStaticHtmlHandler(homePath, homeHtml)
	addStaticHtmlHandler(vocabPath, vocabHtml)
	addStaticHtmlHandler(moeVocabPath, moeVocabHtml)
	addStaticHtmlHandler(sentencesPath, sentencesHtml)
	addStaticHtmlHandler(mcdsPath, mcdsHtml)
	addStaticHtmlHandler(pinyinifyPath, pinyinifyHtml)
	addStaticHtmlHandler(settingsPath, settingsHtml)

	http.HandleFunc(vocabLookupPath, vocabLookupHandler)
	http.HandleFunc(moeVocabLookupPath, moeVocabLookupHandler)
	http.HandleFunc(sentencesLookupPath, sentencesLookupHandler)
	http.HandleFunc(mcdsLookupPath, mcdsLookupHandler)
	http.HandleFunc(pinyinifyLookupPath, pinyinifyLookupHandler)

	// assets file server
	http.Handle(assetsPath, http.FileServer(http.Dir(".")))

	http.ListenAndServe(":8080", nil)
}
Beispiel #25
0
func apiDoc(w http.ResponseWriter, req *http.Request) {
	io.WriteString(w, mustache.RenderFileInLayout("templates/api.html.mustache", "templates/layout.html.mustache", nil))
}
Beispiel #26
0
// Renders with a layout template.
//
// Layout should have {{content}} variable
func RenderInLayout(txn *Txn, path, layoutPath string, context map[string]interface{}) {
	viewsPath := txn.ServerConfig.MustString("http.html.view_directory", "")
	layPath := fmt.Sprintf("%s%s", viewsPath, layoutPath)
	templatePath := fmt.Sprintf("%s%s", viewsPath, path)
	writeResponse(txn, "text/html", mustache.RenderFileInLayout(templatePath, layPath, contxt(txn, context)))
}
Beispiel #27
0
func dashboard(store configstore.Store, w http.ResponseWriter, req *http.Request) {

	names, err := store.Names()
	if err != nil {
		log.Printf("Error: %s", err)
		http.Error(w, "error :(", 500)
		return
	}

	if req.Header.Get("Accept") == "application/json" {
		w.Header().Set("Content-type", "application/json")

		var data = []interface{}{}

		for _, name := range names {
			dates, err := store.Dates(name)
			if err != nil {
				continue
			}

			var date *time.Time
			if len(dates) > 0 {
				date = &dates[0]
			} else {
				date = nil
			}

			data = append(data, struct {
				Hostname   string
				LastBackup *time.Time `json:",omitempty"`
			}{
				Hostname:   name,
				LastBackup: date,
			})

		}

		enc := json.NewEncoder(w)
		err = enc.Encode(data)

	} else {

		var data = struct {
			Entries []struct {
				Hostname   string
				LastBackup *time.Time
				Ago        string
				AgoStatus  string
			}
		}{}

		for _, name := range names {
			dates, err := store.Dates(name)
			if err != nil {
				continue
			}

			var date *time.Time
			if len(dates) > 0 {
				date = &dates[0]
			} else {
				date = nil
			}

			data.Entries = append(data.Entries, struct {
				Hostname   string
				LastBackup *time.Time
				Ago        string
				AgoStatus  string
			}{
				Hostname:   name,
				LastBackup: date,
				Ago:        dashboardAgo(date, 24, 72),
				AgoStatus:  dashboardAgoStatus(date, 24, 72),
			})
		}

		io.WriteString(w, mustache.RenderFileInLayout("templates/dashboard.html.mustache", "templates/layout.html.mustache", data))
	}
}
Beispiel #28
0
func renderSplash() string {
	html := mustache.RenderFileInLayout("Pages/Splash.mustache", "Pages/layout.mustache")
	return html
}
Beispiel #29
0
// TestHandler runs the tests
func TestHandler(req *http.Request, w http.ResponseWriter, cs *sessions.CookieStore, connection *Connection) {
	w.Write([]byte(mustache.RenderFileInLayout("templates/test.mustache", "templates/test.base.mustache", nil)))
}
/**
 * Takes a template name and context and renders using the layout defined below
 */
func renderHTML(template string, context map[string]string) string {
	layoutPath := "templates/layout.mustache"
	templatePath := "templates/" + template + ".mustache"

	return mustache.RenderFileInLayout(templatePath, layoutPath, context)
}