func init() {
ALL_METHODS = []string{GET, HEAD, POST, CONNECT, DELETE, OPTIONS, PUT, TRACE}
defaultMimeTypes = make(map[string]string)
defaultMimeTypes[".htm"] = MIME_TYPE_HTML
defaultMimeTypes[".html"] = MIME_TYPE_HTML
defaultMimeTypes[".xhtml"] = MIME_TYPE_XHTML_XML
defaultMimeTypes[".xml"] = MIME_TYPE_XML
defaultMimeTypes[".css"] = MIME_TYPE_CSS
defaultMimeTypes[".js"] = MIME_TYPE_JAVASCRIPT
defaultMimeTypes[".json"] = MIME_TYPE_JSON
defaultMimeTypes[".jpg"] = MIME_TYPE_JPEG
defaultMimeTypes[".jpeg"] = MIME_TYPE_JPEG
defaultMimeTypes[".gif"] = MIME_TYPE_GIF
defaultMimeTypes[".png"] = MIME_TYPE_PNG
defaultMimeTypes[".ico"] = MIME_TYPE_ICO
defaultMimeTypes[".swf"] = MIME_TYPE_SWF
defaultMimeTypes[".zip"] = MIME_TYPE_ZIP
defaultMimeTypes[".bz2"] = MIME_TYPE_BZIP2
defaultMimeTypes[".gz"] = MIME_TYPE_GZ
defaultMimeTypes[".tar"] = MIME_TYPE_TAR
defaultMimeTypes[".tgz"] = MIME_TYPE_GZ
defaultMimeTypes[".htc"] = MIME_TYPE_COMPONENT
defaultMimeTypes[".manifest"] = MIME_TYPE_CACHE_MANIFEST
defaultMimeTypes[".svg"] = MIME_TYPE_SVG
defaultMimeTypes[".txt"] = MIME_TYPE_TEXT_PLAIN
defaultMimeTypes[".text"] = MIME_TYPE_TEXT_PLAIN
defaultMimeTypes[".csv"] = MIME_TYPE_CSV
var err error
HTML_DIRECTORY_LISTING_SUCCESS_TEMPLATE, err = template.New("directory_listing_success").Parse(HTML_DIRECTORY_LISTING_SUCCESS_TEMPLATE_STRING)
template.Must(HTML_DIRECTORY_LISTING_SUCCESS_TEMPLATE, err)
HTML_DIRECTORY_LISTING_ERROR_TEMPLATE, err = template.New("directory_listing_error").Parse(HTML_DIRECTORY_LISTING_ERROR_TEMPLATE_STRING)
template.Must(HTML_DIRECTORY_LISTING_ERROR_TEMPLATE, err)
}
func InitAdminTemplates() {
serverPage = template.Must(template.ParseFiles("views/admin/templates/server.html"))
banlogsTempl = template.Must(template.ParseFiles("views/admin/templates/ban_logs.html"))
chatLogsTempl = template.Must(template.ParseFiles("views/admin/templates/chatlogs.html"))
lobbiesTempl = template.Must(template.ParseFiles("views/admin/templates/lobbies.html"))
adminPageTempl = template.Must(template.ParseFiles("views/admin/index.html"))
}
func (c *Controller) Login() (string, error) {
var pool_tech_works int
funcMap := template.FuncMap{
"noescape": func(s string) template.HTML {
return template.HTML(s)
},
}
data, err := static.Asset("static/templates/login.html")
if err != nil {
return "", err
}
modal, err := static.Asset("static/templates/modal.html")
if err != nil {
return "", err
}
t := template.Must(template.New("template").Funcs(funcMap).Parse(string(data)))
t = template.Must(t.Parse(string(modal)))
b := new(bytes.Buffer)
// есть ли установочный пароль и был ли начально записан ключ
var setupPassword bool
if !c.Community {
setupPassword_, err := c.Single("SELECT setup_password FROM config").String()
if err != nil {
return "", err
}
myKey, err := c.GetMyPublicKey(c.MyPrefix)
if err != nil {
return "", err
}
if len(myKey) == 0 && (len(setupPassword_) > 0 || setupPassword_ == string(utils.DSha256(""))) {
setupPassword = true
}
}
//fmt.Println(c.Lang)
// проверим, не идут ли тех. работы на пуле
if len(c.NodeConfig["pool_admin_user_id"]) > 0 && c.NodeConfig["pool_admin_user_id"] != utils.Int64ToStr(c.UserId) && c.NodeConfig["pool_tech_works"] == "1" && c.Community {
pool_tech_works = 1
} else {
pool_tech_works = 0
}
err = t.ExecuteTemplate(b, "login", &loginStruct{
Lang: c.Lang,
MyModalIdName: "myModalLogin",
UserID: c.UserId,
PoolTechWorks: pool_tech_works,
SetupPassword: setupPassword,
Community: c.Community,
Desktop: utils.Desktop(),
Mobile: utils.Mobile()})
if err != nil {
return "", err
}
return b.String(), nil
}
func init() {
http.HandleFunc("/", authOnly(root))
http.HandleFunc("/sign", authOnly(sign))
guestbookTemplate = template.Must(template.ParseFiles("tmpl/index.tmpl"))
signinTemplate = template.Must(template.ParseFiles("tmpl/signin.tmpl"))
}
func TestTemplate_FuncMap_url(t *testing.T) {
app := kocha.NewTestApp()
funcMap := template.FuncMap(app.Template.FuncMap)
func() {
tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{url "root"}}`))
var buf bytes.Buffer
if err := tmpl.Execute(&buf, nil); err != nil {
panic(err)
}
actual := buf.String()
expected := "/"
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expect %q, but %q", expected, actual)
}
}()
func() {
tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{url "user" 713}}`))
var buf bytes.Buffer
if err := tmpl.Execute(&buf, nil); err != nil {
panic(err)
}
actual := buf.String()
expected := "/user/713"
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expect %v, but %v", expected, actual)
}
}()
}
func TestRender(t *testing.T) {
driverNames := [...]string{"file", "memory"}
for _, v := range driverNames {
d, err := render.New(v, map[string]string{
"dir": "./_testdata",
})
if err != nil {
t.Fatal(err)
}
d.AddCommonTpl("base.html")
tpl := template.Must(d.GetTemplate("index.html"))
buf := &bytes.Buffer{}
tpl.Execute(buf, map[string]string{
"Title": "标题",
"Content": "内容",
})
if testdata1 != buf.String() {
t.Fatalf("Content not equal %q", v)
}
_ = template.Must(d.GetTemplate("index1.html"))
}
}
func CompileUserTemplates() {
usersTemplates = template.Must(layout.Clone()).Funcs(template.FuncMap{
"sliceBy12": func(problems []models.Problem) [][]models.Problem {
slices := make([][]models.Problem, 0, len(problems)/12+1)
for i := 0; i+11 < len(problems); i += 12 {
slice := make([]models.Problem, 12)
for j := i; j < i+12; j++ {
slice[j] = problems[i+j]
}
slices = append(slices, slice)
}
if len(problems)%12 != 0 {
slice := make([]models.Problem, len(problems)%12)
for i := 0; i < len(problems)%12; i++ {
slice[i] = problems[len(problems)-len(problems)%12+i]
}
slices = append(slices, slice)
}
return slices
},
})
usersTemplates = template.Must(usersTemplates.ParseGlob("./templates/users/*.html"))
}
// Handle errors here, this allows us to control the format of the output rather
// than using http.Error() defaults
func errorHandler(w http.ResponseWriter, r *http.Request, status int, err string) {
w.WriteHeader(status)
switch status {
case http.StatusNotFound:
logHandler("ERROR", fmt.Sprintf("client %s tried to request %v", r.RemoteAddr, r.URL.Path))
page := template.Must(template.ParseFiles(
"static/_base.html",
"static/404.html",
))
if err := page.Execute(w, nil); err != nil {
errorHandler(w, r, http.StatusInternalServerError, err.Error())
return
}
case http.StatusInternalServerError:
logHandler("ERROR", fmt.Sprintf("an internal server error occured when %s requested %s with error:\n%s", r.RemoteAddr, r.URL.Path, err))
page := template.Must(template.ParseFiles(
"static/_base.html",
"static/500.html",
))
if err := page.Execute(w, nil); err != nil {
// IF for some reason the tempalets for 500 errors fails, fallback
// on http.Error()
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
}
func serveCmd() {
var err error
// load and parse templates
baseTmplPath := *templatePath + "/base.html"
tmplHome = template.Must(template.ParseFiles(*templatePath+"/home.html", baseTmplPath))
tmplAccount = template.Must(template.ParseFiles(*templatePath+"/account.html", baseTmplPath))
//tmplLogout = template.Must(template.ParseFiles(*templatePath+"/logout.html", baseTmplPath))
//tmplNewUser = template.Must(template.ParseFiles(*templatePath+"/newuser.html", baseTmplPath))
tmplUser = template.Must(template.ParseFiles(*templatePath+"/user.html", baseTmplPath))
tmplBomView = template.Must(template.ParseFiles(*templatePath+"/bom_view.html", baseTmplPath))
tmplBomUpload = template.Must(template.ParseFiles(*templatePath+"/bom_upload.html", baseTmplPath))
if err != nil {
log.Fatal(err)
}
openBomStore()
openAuthStore()
openPricingSource()
// serve template static assets (images, CSS, JS)
http.Handle("/static/", http.FileServer(http.Dir(*templatePath+"/")))
http.Handle("/favicon.ico", http.FileServer(http.Dir(*templatePath+"/static/")))
// fall through to default handler
http.HandleFunc("/", baseHandler)
listenString := fmt.Sprintf("%s:%d", *listenHost, *listenPort)
http.ListenAndServe(listenString, nil)
fmt.Println("Serving at " + listenString)
}
func init() {
layout, err := ioutil.ReadFile("templates/layout.html")
if err != nil {
log.Fatal("Could not read layout:", err)
}
files, err := filepath.Glob("templates/*")
if err != nil {
log.Fatal("Could not glob templates:", err)
}
for _, f := range files {
if filepath.Base(f) == "layout.html" {
continue
}
content, err := ioutil.ReadFile(f)
if err != nil {
log.Fatalf("Could not read %q: %v", f, err)
}
t := template.New("page")
t.Funcs(map[string]interface{}{
"toEuros": func(x int) float64 {
return float64(x) / 100
},
})
t = template.Must(t.Parse(string(layout)))
template.Must(t.New("content").Parse(string(content)))
parsedTemplates[filepath.Base(f)] = t
}
}
func errorHandler(w http.ResponseWriter, r *http.Request, status int, err string) {
w.WriteHeader(status)
page := template.Must(template.ParseFiles(
"static/_base.html",
"static/baseError.html",
))
switch status {
case http.StatusNotFound:
page = template.Must(template.ParseFiles(
"static/_base.html",
"static/404.html",
))
case http.StatusInternalServerError:
page = template.Must(template.ParseFiles(
"static/_base.html",
"static/500.html",
))
case http.StatusUnauthorized:
page = template.Must(template.ParseFiles(
"static/_base.html",
"static/401.html",
))
}
if err := page.Execute(w, nil); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func reports(c *appcontext.AppContext, w http.ResponseWriter, r *http.Request) (int, error) {
SetCache(w, 60*60)
report := r.FormValue("report")
var (
p Page
err error
)
if report == "items" || report == "" {
templates.Templates = template.Must(template.ParseFiles("templates/reports/items.html", "templates/reports.html", templates.LayoutPath))
err = templates.Templates.ExecuteTemplate(w, "base", p)
} else if report == "itemTrends" {
templates.Templates = template.Must(template.ParseFiles("templates/reports/itemTrends.html", "templates/reports.html", templates.LayoutPath))
err = templates.Templates.ExecuteTemplate(w, "base", p)
} else if report == "telVar" {
templates.Templates = template.Must(template.ParseFiles("templates/reports/telVar.html", "templates/reports.html", templates.LayoutPath))
err = templates.Templates.ExecuteTemplate(w, "base", p)
} else if report == "ap" {
templates.Templates = template.Must(template.ParseFiles("templates/reports/ap.html", "templates/reports.html", templates.LayoutPath))
err = templates.Templates.ExecuteTemplate(w, "base", p)
} else if report == "guilds" {
templates.Templates = template.Must(template.ParseFiles("templates/reports/guilds.html", "templates/reports.html", templates.LayoutPath))
err = templates.Templates.ExecuteTemplate(w, "base", p)
}
if err != nil {
return http.StatusInternalServerError, err
}
return http.StatusOK, nil
}
// checkEnvironment checks if required dirs and files exist, uses defaults if not.
func checkEnvironment() {
_, err := os.Stat(dataDir)
if err != nil {
if os.IsNotExist(err) {
err = os.Mkdir(dataDir, 0644)
if err != nil {
fmt.Println(`Unable to create "notes" directory:`, err)
os.Exit(0)
}
} else {
fmt.Println(`Unable to check existence of "notes" directory:`, err)
os.Exit(0)
}
}
_, err = os.Stat(templatesDir)
if err != nil {
if os.IsNotExist(err) {
// Template dir does not exist
fmt.Println("Using default templates.")
templates = template.Must(template.New("index.html").Parse(defaultTemplateIndexHtml))
template.Must(templates.New("view.html").Parse(defaultTemplateViewHtml))
template.Must(templates.New("edit.html").Parse(defaultTemplateEditHtml))
template.Must(templates.New("error.html").Parse(defaultTemplateErrorHtml))
}
} else {
fmt.Println("Using file templates.")
templates = template.Must(template.ParseFiles(
templatesDir+"index.html",
templatesDir+"view.html",
templatesDir+"edit.html",
templatesDir+"error.html"))
}
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
tmpl := template.New("base")
template.Must(tmpl.Parse(BaseTmpl))
template.Must(tmpl.Parse(ConfigTemp))
nodes := GetScattrData()
tmpl.Execute(w, nodes)
}
func viewHandler(w http.ResponseWriter, r *http.Request) {
entries := Store.AllEntries()
tmpl := template.New("base")
template.Must(tmpl.Parse(BaseTmplStr))
template.Must(tmpl.Parse(ViewTmplStr))
tmpl.Execute(w, entries)
}
func FindHandler(rw http.ResponseWriter, req *http.Request) {
var _, er = req.Cookie("fishme")
if er != nil {
http.Redirect(rw, req, "/", http.StatusFound)
} else {
term := req.FormValue("find")
if term != "" {
term = strings.ToLower(term)
term = strings.Replace(term, term[:1], strings.ToUpper(term[:1]), 1)
log.Println(term)
temp, err := template.ParseFiles("template/find.html")
utility.ShitAppend(err)
temp = template.Must(temp.Parse(ParseNavbarFile("template/navbar"))) // Add The content of the navbar.tmpl to the current template
temp = template.Must(temp.ParseFiles("template/add_fish.tmpl"))
temp = template.Must(temp.ParseFiles("template/map.tmpl")) // Map template
fishFind := FindFish(term)
temp.Execute(rw, ParseSecureFishFile(fishFind))
} else {
http.Redirect(rw, req, "/home", http.StatusFound)
}
}
}
func compileTemplate(name string) *template.Template {
t := template.New(name)
t = template.Must(t.Funcs(funcMap).ParseGlob("www/views/layouts/*.html"))
t.Delims("#{", "}#")
return template.Must(t.ParseFiles("www/views/" + name + ".html"))
}
// Main entry point
func main() {
// Connect to DB
dbConn = dbConnect()
defer dbConn.Close()
// Parse initial flags
flag.Parse()
// Define home template and hub
homeTempl = template.Must(template.ParseFiles(filepath.Join(templatesPath, "map.html")))
routesTempl = template.Must(template.ParseFiles(filepath.Join(templatesPath, "routes.html")))
h := newHub()
// Run hub concurrently
go h.runHub()
// Define handlers
http.HandleFunc("/", homeHandler)
http.Handle("/ws", wsHandler{h: h})
http.Handle("/routes/ws", wsHandler{h: h})
http.HandleFunc("/routes/", routeSimulatorHandler)
http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir(httpStaticPath))))
// Start server
if err := http.ListenAndServe(*addr, nil); err != nil {
log.Fatal("ListenAndServe:", err)
}
}
// Sends email based on the result of all batches
func (r *GlobalResults) sendMail() {
funcMap := template.FuncMap{
"odd": func(i int) bool { return i%2 == 0 },
}
tHeader := template.Must(template.New("header").Parse(emailTemplateHtmlHeader))
tBody := template.Must(template.New("body").Funcs(funcMap).Parse(emailTemplateHtmlBody))
var docHeader bytes.Buffer
tHeader.Execute(&docHeader, r.Author)
for _, br := range r.BatchResultList {
var docBody bytes.Buffer
tBody.Execute(&docBody, br)
TraceActivity.Printf("----------------------------------------------------------------------------- \n")
TraceActivity.Printf("GeneratedCOntent : \n")
TraceActivity.Printf("%s\n", docBody.String())
TraceActivity.Printf("----------------------------------------------------------------------------- \n")
var buffer bytes.Buffer
buffer.WriteString(docHeader.String())
buffer.WriteString(docBody.String())
br.Smtp.sendEmailHtml(br, buffer.String())
}
}
func init() {
if templates == nil {
templates = make(map[string]*template.Template)
}
templates["index"] = template.Must(template.ParseFiles("tmpl/base.tmpl", "tmpl/index.tmpl"))
templates["index1"] = template.Must(template.ParseFiles("tmpl/base.tmpl", "tmpl/index1.tmpl"))
templates["edit"] = template.Must(template.ParseFiles("tmpl/base.tmpl", "tmpl/edit.tmpl"))
templates["preview"] = template.Must(template.ParseFiles("tmpl/preview.tmpl"))
//handle image/css and generated html files
http.Handle("/css/", http.StripPrefix("/css/", http.FileServer(http.Dir("css"))))
http.Handle("/_images/", http.StripPrefix("/_images/", http.FileServer(http.Dir("_images"))))
http.Handle("/_html/", http.StripPrefix("/_html/", http.FileServer(http.Dir("_html"))))
http.Handle("/_html/_images/", http.StripPrefix("/_html/_images/", http.FileServer(http.Dir("_html/_images"))))
http.Handle("/_html/css", http.StripPrefix("/_html/css", http.FileServer(http.Dir("_html/css"))))
// set up html options
htmlExt = 0
htmlExt |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
htmlExt |= blackfriday.EXTENSION_TABLES
htmlExt |= blackfriday.EXTENSION_FENCED_CODE
htmlExt |= blackfriday.EXTENSION_AUTOLINK
htmlExt |= blackfriday.EXTENSION_STRIKETHROUGH
htmlExt |= blackfriday.EXTENSION_SPACE_HEADERS
htmlFlags = blackfriday.HTML_USE_XHTML |
blackfriday.HTML_USE_SMARTYPANTS |
blackfriday.HTML_SMARTYPANTS_FRACTIONS |
blackfriday.HTML_SMARTYPANTS_LATEX_DASHES |
blackfriday.HTML_FOOTNOTE_RETURN_LINKS |
blackfriday.HTML_SMARTYPANTS_ANGLED_QUOTES
}
func init() {
// Create buffer pool
bufpool = bpool.NewBufferPool(64)
// Get the contents of all layouts.
layoutData := make(map[string]string)
for _, lname := range layouts.AssetNames() {
d, _ := layouts.Asset(lname)
layoutData[lname] = string(d)
}
// For each template, we parse it.
templatesMap = make(map[string]*template.Template)
for _, aname := range templates.AssetNames() {
tname := filepath.Base(aname)
// Create new template with functions
tmpl := template.New(tname).Funcs(templateFuncs)
// Get the template's data
d, _ := templates.Asset(aname)
// Parse the main template, then all the layouts.
tmpl = template.Must(tmpl.Parse(string(d)))
for _, layout := range layouts.AssetNames() {
tmpl = template.Must(tmpl.Parse(layoutData[layout]))
}
// Insert
templatesMap[tname] = tmpl
}
}
func init() {
Router.Get("/_ah/cron/search", appstats.NewHandler(ahCronSearchHandler))
Router.Get("/_ah/status", appstats.NewHandler(ahStatusHandler))
Router.Get("/_ah/", appstats.NewHandler(ahHandler))
Router.Get("/debug/prepare_test", appstats.NewHandler(debugPrepareTestHandler))
Router.Get("/-/about", appstats.NewHandler(aboutHandler))
Router.Get("/-/doc", appstats.NewHandler(docHandler))
Router.Get("/-/doc/:section", appstats.NewHandler(docHandler))
Router.Get("/-/me", appstats.NewHandler(myHandler))
Router.Post("/-/me/register", appstats.NewHandler(registerHandler))
Router.Get("/-/me/generate", appstats.NewHandler(generateHandler))
Router.Post("/-/me/openid", appstats.NewHandler(openIdHandler))
Router.Get("/-/nuts", appstats.NewHandler(nutsHandler))
Router.Put("/:vendor/:name/:version", appstats.NewHandler(nutCreateHandler))
Router.Get("/:vendor/:name/:version", appstats.NewHandler(nutShowHandler))
Router.Get("/:vendor/:name", appstats.NewHandler(nutShowHandler))
Router.Get("/:vendor", appstats.NewHandler(nutsHandler))
Router.Get("/", appstats.NewHandler(welcomeHandler))
http.Handle("/", Router)
Base = template.Must(template.ParseFiles("gonuts/templates/base.html"))
template.Must(Base.ParseGlob("gonuts/templates/base/*.html"))
}
func treeOperations(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
err := r.ParseForm()
if err != nil {
io.WriteString(w, fmt.Sprintf("Error parsing the submitted form:\n%s", err))
}
var v int
v, err = strconv.Atoi(r.Form["number"][0])
if err != nil {
io.WriteString(w, fmt.Sprintf("Error parsing the given number:\n%s", err))
}
if r.Form["insert"] != nil {
fmt.Printf("\nInserting [%d]\n", v)
btree = Insert(btree, v)
} else if r.Form["delete"] != nil {
fmt.Printf("\nDeleting [%d]\n", v)
btree = Delete(btree, v)
} else {
io.WriteString(w, "Neither an insert request, nor a delete request")
return
}
renderer := PrintbTree(btree, r.Form["numbers"][0])
err =
template.Must(template.ParseFiles("treedisplay.html")).Execute(w, &renderer)
if err != nil {
io.WriteString(w, fmt.Sprintf("Error generating HTML file from the template:\n%s", err))
return
}
} else {
/* The next if loop is a hack to avoid re-initialization due to
* the GET request that will come when the page gets rendered
* during the response of the POST (the above block) */
if btree == nil {
btree, _ = InitializebTree(3)
fmt.Println("Initializing the btree")
for _, v := range []int{6, 1, 3, 10, 4, 7, 8, 9, 18, 12, 13,
19, 15, 22, 33, 35, 44, 70, 37, 38, 39, 50, 60, 55, 80,
90, 101, 102, 100, 110, 120, 57, 58} {
btree = Insert(btree, v)
}
renderer := PrintbTree(btree, "")
err :=
template.Must(template.ParseFiles("treedisplay.html")).Execute(w, &renderer)
if err != nil {
io.WriteString(w, fmt.Sprintf("Error generating HTML file from the template:\n%s", err))
return
}
}
}
}
func init() {
t = make(map[string]*template.Template)
temp := template.Must(template.ParseFiles("base.html", "user.html"))
t["user.html"] = temp
temp = template.Must(template.ParseFiles("base.html", "page.html"))
t["page.html"] = temp
}
// Login template
func (ctrl *Access) Login(w http.ResponseWriter, r *http.Request) {
if r.Method == "GET" {
t := template.Must(template.ParseFiles("views/layouts/application.htm", "views/login/login.htm"))
if err := t.Execute(w, &Access{}); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
} else {
r.ParseForm()
user := ctrl.Auth(r.Form["username"][0], r.Form["password"][0])
if user != nil {
t := template.Must(template.ParseFiles("views/layouts/application.htm", "views/login/info.htm"))
page := &Access{LoginPage: &LoginPage{UserName: r.Form["username"][0], HasVideoAccess: user.HasVideoAccess}}
if err := t.Execute(w, page); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
} else {
http.Error(w, "Auth", http.StatusForbidden)
}
}
}
func LoadTemplates() {
EmailTmpl = text_template.Must(text_template.New("Email").ParseGlob(
filepath.Join(cfg.TemplatesDir, "email", "*.txt"),
))
SignupTmpl = template.Must(template.New("Signup").ParseFiles(
filepath.Join(cfg.TemplatesDir, "account", "base.html"),
filepath.Join(cfg.TemplatesDir, "account", "signup.html"),
))
SignupOkTmpl = template.Must(template.New("SignupOk").ParseFiles(
filepath.Join(cfg.TemplatesDir, "account", "base.html"),
filepath.Join(cfg.TemplatesDir, "account", "signup_ok.html"),
))
HelloTmpl = template.Must(template.New("Hello").ParseFiles(
filepath.Join(cfg.TemplatesDir, "account", "base.html"),
filepath.Join(cfg.TemplatesDir, "account", "hello.html"),
))
LoginTmpl = template.Must(template.New("Login").ParseFiles(
filepath.Join(cfg.TemplatesDir, "account", "base.html"),
filepath.Join(cfg.TemplatesDir, "account", "login.html"),
))
}
// HTTPServer is the constructor of the HTTP server
func HTTPServer(redis *redisobj, cache *Cache) *HTTP {
h := new(HTTP)
h.redis = redis
h.geoip = NewGeoIP()
h.templates.mirrorlist = template.Must(h.LoadTemplates("mirrorlist"))
h.templates.mirrorstats = template.Must(h.LoadTemplates("mirrorstats"))
h.cache = cache
h.stats = NewStats(redis)
h.engine = DefaultEngine{}
http.Handle("/", NewGzipHandler(h.requestDispatcher))
// Load the GeoIP database
if err := h.geoip.LoadGeoIP(); err != nil {
log.Critical("Can't load the GeoIP databases: %v", err)
if len(GetConfig().Fallbacks) > 0 {
log.Warning("All requests will be served by the backup mirrors!")
} else {
log.Error("Please configure fallback mirrors!")
}
}
// Initialize the random number generator
rand.Seed(time.Now().UnixNano())
return h
}
func TestTemplateFuncs_url(t *testing.T) {
oldAppConfig := appConfig
appConfig = newTestAppConfig()
defer func() {
appConfig = oldAppConfig
}()
tmpl := template.Must(template.New("test").Funcs(TemplateFuncs).Parse(`{{url "root"}}`))
var buf bytes.Buffer
if err := tmpl.Execute(&buf, nil); err != nil {
panic(err)
}
actual := buf.String()
expected := "/"
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expect %q, but %q", expected, actual)
}
tmpl = template.Must(template.New("test").Funcs(TemplateFuncs).Parse(`{{url "user" 713}}`))
buf.Reset()
if err := tmpl.Execute(&buf, nil); err != nil {
panic(err)
}
actual = buf.String()
expected = "/user/713"
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expect %v, but %v", expected, actual)
}
}
func TestTemplateFuncs_date(t *testing.T) {
base := `{{date . "%v"}}`
now := time.Now()
tmpl := template.Must(template.New("test").Funcs(TemplateFuncs).Parse(fmt.Sprintf(base, "2006/01/02 15:04:05.999999999")))
var buf bytes.Buffer
if err := tmpl.Execute(&buf, now); err != nil {
panic(err)
}
actual := buf.String()
expected := now.Format("2006/01/02 15:04:05.999999999")
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expect %q, but %q", expected, actual)
}
tmpl = template.Must(template.New("test").Funcs(TemplateFuncs).Parse(fmt.Sprintf(base, "Jan 02 2006 03:04.999999999")))
buf.Reset()
if err := tmpl.Execute(&buf, now); err != nil {
panic(err)
}
actual = buf.String()
expected = now.Format("Jan 02 2006 03:04.999999999")
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expect %q, but %q", expected, actual)
}
}
func NewRuleHandler(w http.ResponseWriter, r *http.Request) {
rule := NewRule("", defaultJs, []string{""})
tmpl := template.New("base")
template.Must(tmpl.Parse(BaseTemplateStr))
template.Must(tmpl.Parse(NewTemplateStr))
tmpl.Execute(w, rule)
}
