func dirList(ci inject.CopyInject, logger termlog.Logger, w http.ResponseWriter, name string, f http.File, templates *template.Template) { w.Header().Set("Cache-Control", "no-store, must-revalidate") files, err := f.Readdir(0) if err != nil { logger.Shout("Error reading directory for listing: %s", err) return } data := dirData{Name: name, Files: files} buff := bytes.NewBuffer(make([]byte, 0, 0)) err = templates.Lookup("dirlist.html").Execute(buff, data) length := buff.Len() if err != nil { logger.Shout("Error producing directory listing: %s", err) } inj, err := ci.Sniff(buff) if err != nil { logger.Shout("Failed to inject in dir listing: %s", err) return } w.Header().Set( "Content-Length", fmt.Sprintf("%d", length+inj.Extra()), ) _, err = inj.Copy(w) if err != nil { logger.Shout("Failed to inject in dir listing: %s", err) return } }
func (context *Context) Execute(name string, result interface{}) { var tmpl *template.Template var cacheKey string if context.Action == "" { context.Action = name } if context.Resource != nil { cacheKey = path.Join(context.resourcePath(), name) } else { cacheKey = name } if t, ok := templates[cacheKey]; !ok || true { var err error tmpl = template.New("layout.tmpl").Funcs(context.FuncMap()) if tmpl, err = context.FindTemplate(tmpl, "layout.tmpl"); err == nil { for _, name := range []string{"header", "footer"} { if tmpl.Lookup(name) == nil { tmpl, _ = context.FindTemplate(tmpl, name+".tmpl") } } } } else { tmpl = t } context.Content = context.Render(name, result) if err := tmpl.Execute(context.Writer, context); err != nil { fmt.Println(err) } }
func (r *TemplateRender) initTemplates(t *template.Template, tmps []string, exclude *[]string) error { firstLevel := 0 == len(*exclude) for tkey, tpl := range r.prepareTemplates(tmps...) { if nil == t.Lookup(tkey) { if data, err := ioutil.ReadFile(tpl); nil == err { tmps := templatesRegex.FindAllStringSubmatch(string(data), -1) ntemplates := []string{} if nil != tmps && len(tmps) > 0 { for _, it := range tmps { if sIndexOf(it[1], *exclude) < 0 { *exclude = append(*exclude, it[1]) ntemplates = append(ntemplates, it[1]) } } } // Prepare new templates if len(ntemplates) > 0 { if err = r.initTemplates(t, ntemplates, exclude); nil != err { return err } } if _, err = t.New(tkey).Parse(string(data)); nil != err { return err } } else if firstLevel { return err } } } return nil }
func findTemplate(name string, tpls *template.Template) (*template.Template, error) { tpl := tpls.Lookup(name) if tpl == nil { return nil, fmt.Errorf("unable to find template: %q", name) } return tpl, nil }
func notFound(ci inject.CopyInject, templates *template.Template, w http.ResponseWriter) error { err := ci.ServeTemplate(http.StatusNotFound, w, templates.Lookup("404.html"), nil) if err != nil { return err } return nil }
func readtemplates(dir string, titles map[Language]string) (err error) { var templates *template.Template templates, err = template.New("base").Funcs(tmplFuncs).ParseGlob(dir + "/*.tmpl") if err != nil { return } var d *os.File d, err = os.Open(dir) if err != nil { return } var v []os.FileInfo v, err = d.Readdir(0) if err != nil { return } for _, fi := range v { if fi.IsDir() { var t *template.Template t, err = templates.Clone() if err != nil { return } subdir := dir + "/" + fi.Name() _, err = t.ParseGlob(subdir + "/*.tmpl") if err != nil { return } th := t.Lookup("home") ti := t.Lookup("info") if th == nil { return fmt.Errorf(`Template "home" is missing in %s`, subdir) } if ti == nil { return fmt.Errorf(`Template "info" is missing in %s`, subdir) } title, ok := "", false if title, ok = titles[Language(fi.Name())]; !ok { if title, ok = titles[defaultlang]; !ok { title = "Uploader" } } langtmpl[Language(fi.Name())] = &tmpl{title, th, ti} } } defaulttmpl = langtmpl[defaultlang] if defaulttmpl == nil { fmt.Errorf("missing " + string(defaultlang) + " template") } languages = make([]Language, 0, len(langtmpl)) languages = append(languages, defaultlang) for k := range langtmpl { if k != defaultlang { languages = append(languages, k) } } return }
// HandleNotFound handles pages not found. In particular, this handler is used // when we have no matching route for a request. This also means it's not // useful to inject the livereload paraphernalia here. func HandleNotFound(templates *template.Template) httpctx.Handler { return httpctx.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusNotFound) err := templates.Lookup("404.html").Execute(w, nil) if err != nil { logger := termlog.FromContext(ctx) logger.Shout("Could not execute template: %s", err) } }) }
func (f *RestHtmlFormattor) getMethodTemplate(m *template.Template, rest *RestContext) *template.Template { t := m.Lookup(rest.Method + f.dotsuffix) var err error if t == nil { t, err = m.New(rest.Method + f.dotsuffix).ParseFiles(filepath.Join(document_root, rest.Url, rest.Method+f.dotsuffix)) if err != nil { fmt.Println("ERROR template.ParseFile: %v", err) } } return t }
func dirList(ci inject.CopyInject, logger termlog.Logger, w http.ResponseWriter, name string, f http.File, templates *template.Template) { w.Header().Set("Cache-Control", "no-store, must-revalidate") files, err := f.Readdir(0) if err != nil { logger.Shout("Error reading directory for listing: %s", err) return } data := dirData{Name: name, Files: files} err = ci.ServeTemplate(http.StatusOK, w, templates.Lookup("dirlist.html"), data) if err != nil { logger.Shout("Failed to generate dir listing: %s", err) } }
func (p *Page) Render(outdir string, templates *template.Template) error { tpl := templates.Lookup(p.Template) if tpl == nil { return fmt.Errorf("page: template %q not found", p.Template) } if err := os.MkdirAll(filepath.Join(outdir, filepath.Dir(p.Filename)), 0755); err != nil { return err } f, err := os.Create(filepath.Join(outdir, p.Filename)) if err != nil { return err } defer f.Close() return tpl.Execute(f, p) }
func (cfg *LocalConnectorConfig) Connector(ns url.URL, lf oidc.LoginFunc, tpls *template.Template) (Connector, error) { tpl := tpls.Lookup(LoginPageTemplateName) if tpl == nil { return nil, fmt.Errorf("unable to find necessary HTML template") } idpc := &LocalConnector{ id: cfg.ID, namespace: ns, loginFunc: lf, loginTpl: tpl, } return idpc, nil }
func optionalTemplate(t *template.Template) func(string, ...interface{}) (template.HTML, error) { return func(name string, data ...interface{}) (template.HTML, error) { var tm = t.Lookup(name) if tm != nil { var b bytes.Buffer err := tm.ExecuteTemplate(&b, name, data) if err != nil { return template.HTML(""), err } return template.HTML(b.String()), nil } else { return template.HTML(""), nil } } }
func (context *Context) Execute(name string, result interface{}) { var tmpl *template.Template var cacheKey string if name == "show" && !context.Resource.isSetShowAttrs { name = "edit" } if context.Action == "" { context.Action = name } if context.Resource != nil { cacheKey = path.Join(context.resourcePath(), name) } else { cacheKey = name } if t, ok := templates[cacheKey]; !ok || true { if file, err := context.FindTemplate("layout.tmpl"); err == nil { if tmpl, err = template.New(filepath.Base(file)).Funcs(context.FuncMap()).ParseFiles(file); err == nil { for _, name := range []string{"header", "footer"} { if tmpl.Lookup(name) == nil { if file, err := context.FindTemplate(name + ".tmpl"); err == nil { tmpl.ParseFiles(file) } } else { utils.ExitWithMsg(err) } } } else { utils.ExitWithMsg(err) } } } else { tmpl = t } context.Result = result context.Content = context.Render(name, result) if err := tmpl.Execute(context.Writer, context); err != nil { utils.ExitWithMsg(err) } }
func executeTpl(ctx echo.Context, tpl *template.Template, data map[string]interface{}) error { objLog := logic.GetLogger(ctx) // 如果没有定义css和js模板,则定义之 if jsTpl := tpl.Lookup("js"); jsTpl == nil { tpl.Parse(`{{define "js"}}{{end}}`) } if jsTpl := tpl.Lookup("css"); jsTpl == nil { tpl.Parse(`{{define "css"}}{{end}}`) } // 当前用户信息 curUser, ok := ctx.Get("user").(*model.Me) if ok { data["me"] = curUser } else { data["me"] = map[string]interface{}{} } // websocket主机 if global.OnlineEnv() { data["wshost"] = config.ConfigFile.MustValue("global", "domain") } else { data["wshost"] = global.App.Host + ":" + global.App.Port } global.App.SetUptime() data["app"] = global.App data["online_users"] = map[string]int{"online": logic.Book.Len(), "maxonline": logic.MaxOnlineNum()} buf := new(bytes.Buffer) err := tpl.Execute(buf, data) if err != nil { objLog.Errorln("excute template error:", err) return err } return ctx.HTML(http.StatusOK, buf.String()) }
func get(driver *Template, name string) *Template { var contents string var t *template.Template var err error pth := "resources/template/" + name + ".tmpl" partials := filepath.Join(filepath.Dir(pth), "partials", "_*.tmpl") contents, err = load(pth) if err != nil { return &Template{nil, err} } if driver != nil { t, err = driver.Clone() if err != nil { return &Template{nil, err} } _, err = t.Parse(contents) for _, name := range blocknames { if found := t.Lookup(name); found == nil { t.Parse("{{ define `" + name + "`}}{{ end }}") } } t.ParseGlob(partials) } else { t = template.New(name) if err != nil { return &Template{nil, err} } t, err = t.Funcs(funcMap).Parse(contents) } return &Template{t, err} }
func (vc *viewContainer) getTemplateDeep(file, viewExt, parent string, t *template.Template) (*template.Template, [][]string, error) { var fileAbsPath string if filepath.HasPrefix(file, "../") { fileAbsPath = filepath.Join(vc.viewDir, filepath.Dir(parent), file) } else { fileAbsPath = filepath.Join(vc.viewDir, file) } if e := IsFile(fileAbsPath); !e { return nil, [][]string{}, errNotFoundTpl(file) } data, err := ioutil.ReadFile(fileAbsPath) if err != nil { return nil, [][]string{}, err } t, err = t.New(file).Parse(string(data)) if err != nil { return nil, [][]string{}, err } reg := regexp.MustCompile("{{" + "[ ]*template[ ]+\"([^\"]+)\"") allSub := reg.FindAllStringSubmatch(byte2Str(data), -1) for _, m := range allSub { if len(m) == 2 { look := t.Lookup(m[1]) if look != nil { continue } if !strings.HasSuffix(strings.ToLower(m[1]), viewExt) { continue } t, _, err = vc.getTemplateDeep(m[1], viewExt, file, t) if err != nil { return nil, [][]string{}, err } } } return t, allSub, nil }
func getTplDeep(root, file, parent string, t *template.Template) (*template.Template, [][]string, error) { var fileAbsPath string if filepath.HasPrefix(file, "../") { fileAbsPath = filepath.Join(root, filepath.Dir(parent), file) } else { fileAbsPath = filepath.Join(root, file) } if e := utils.FileExists(fileAbsPath); !e { panic("can't find template file:" + file) } data, err := ioutil.ReadFile(fileAbsPath) if err != nil { return nil, [][]string{}, err } t, err = t.New(file).Parse(string(data)) if err != nil { return nil, [][]string{}, err } reg := regexp.MustCompile(BConfig.WebConfig.TemplateLeft + "[ ]*template[ ]+\"([^\"]+)\"") allSub := reg.FindAllStringSubmatch(string(data), -1) for _, m := range allSub { if len(m) == 2 { tl := t.Lookup(m[1]) if tl != nil { continue } if !HasTemplateExt(m[1]) { continue } t, _, err = getTplDeep(root, m[1], file, t) if err != nil { return nil, [][]string{}, err } } } return t, allSub, nil }
//Register mounts an entry point at / on the supplied http mux. //staticFiles is the directory that contains the CSS and .js files //If no mux is supplied, it will be mounted by the default http.Handler func Register(t *template.Template, staticFiles string, mux *http.ServeMux) { if mux == nil { mux = http.DefaultServeMux } //Instantiate our controllers indexController := indexController{template: t.Lookup("index.html")} settingsController := settingsController{template: t.Lookup("settings.html")} chatController := chatController{template: t.Lookup("chat.html")} accountsController := accountsController{template: t.Lookup("register.html")} //Associate routes with our controllers mux.Handle("/", indexController) mux.Handle("/settings/", settingsController) mux.Handle("/chat/", chatController) mux.Handle("/register/", accountsController) mux.Handle("/login", accountsController) mux.Handle("/logout", accountsController) mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir(staticFiles)))) mux.Handle("/chat/socket", websocket.Handler(webSocketHandler)) }
func StartWeb() { store = sessions.NewCookieStore([]byte(Config.CookieSecret)) staticServer := http.FileServer(http.Dir("./static")) http.Handle("/static/", http.StripPrefix("/static/", staticServer)) var templates *template.Template ParseTemplates := func() *template.Template { tmpls := template.New("") err := filepath.Walk("./template", func(path string, info os.FileInfo, err error) error { if err != nil || info.IsDir() || !strings.HasSuffix(path, ".html") { return err } relativePath, err := filepath.Rel("./template", path) if err != nil { return err } subtmpl, err := template.ParseFiles(path) if err != nil { return err } _, err = tmpls.AddParseTree(relativePath, subtmpl.Tree) return err }) if err != nil { log.Fatalln("Couldn't load HTML templates:", err.Error()) } return tmpls } LookupTemplate := func(name string) *template.Template { tmpl := templates.Lookup(name) if tmpl == nil { log.Fatalln("Couldn't find HTML template", name) } return tmpl } // If in Debug mode, re-parse templates with each request. if Config.Debug { getTemplate = func(name string) *template.Template { templates = ParseTemplates() return LookupTemplate(name) } } else { getTemplate = LookupTemplate } http.HandleFunc("/signin", WebSignIn) http.HandleFunc("/signout", WebSignOut) webThingHandler := RequireAccountFunc(WebThing) http.Handle("/thing/", webThingHandler) http.Handle("/player/", webThingHandler) http.Handle("/place/", webThingHandler) http.Handle("/action/", webThingHandler) http.Handle("/program/", webThingHandler) webThingMux = http.NewServeMux() webThingMux.HandleFunc("/", WebThingEdit) webThingMux.HandleFunc("/table", WebThingTable) webThingMux.HandleFunc("/program", WebThingProgram) webThingMux.HandleFunc("/access", WebThingAccess) http.Handle("/create-thing", RequireAccountFunc(WebCreateThing)) indexHandler := RequireAccountFunc(WebIndex) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { if r.URL.String() != "/" { http.NotFound(w, r) return } indexHandler.ServeHTTP(w, r) }) log.Println("Listening for web requests at address", Config.WebAddress) webHandler := context.ClearHandler(nosurf.New(http.DefaultServeMux)) http.ListenAndServe(Config.WebAddress, webHandler) }
// Register the handlers for a given route. func Register(db *sql.DB, authorizer httpauth.Authorizer, authBackend httpauth.AuthBackend, roles map[string]httpauth.Role, templates *template.Template, pinger *pinger.Pinger, version string, cookieKey []byte, secureCookie bool) { // setup CSRF protection for the post requests. CSRF := csrf.Protect(cookieKey, csrf.Secure(secureCookie)) router := mux.NewRouter() hc := new(homeController) hc.template = templates.Lookup("home.gohtml") hc.authorizer = authorizer hc.DB = db router.Handle("/", authorizeRole(appHandler(hc.get), authorizer, "user")) rc := new(reportsController) rc.template = templates.Lookup("reports.gohtml") rc.authorizer = authorizer rc.DB = db router.Handle("/reports", authorizeRole(appHandler(rc.get), authorizer, "user")) pc := new(profileController) pc.template = templates.Lookup("profile.gohtml") pc.authorizer = authorizer pc.authBackend = authBackend pc.DB = db router.Handle("/profile", authorizeRole(appHandler(pc.get), authorizer, "user")).Methods("GET") router.Handle("/profile", authorizeRole(appHandler(pc.post), authorizer, "user")).Methods("POST") ac := new(aboutController) ac.template = templates.Lookup("about.gohtml") ac.authorizer = authorizer ac.version = version router.HandleFunc("/about", ac.get) lc := new(loginController) lc.template = templates.Lookup("login.gohtml") lc.authorizer = authorizer router.HandleFunc("/login", lc.get).Methods("GET") router.HandleFunc("/login", lc.post).Methods("POST") loc := new(logoutController) loc.authorizer = authorizer router.HandleFunc("/logout", loc.get) sc := new(settingsController) sc.template = templates.Lookup("settings.gohtml") sc.authorizer = authorizer sc.DB = db router.Handle("/settings", authorizeRole(appHandler(sc.get), authorizer, "admin")) //settingsSub is a subrouter "/settings" settingsSub := router.PathPrefix("/settings").Subrouter() // /settings/users uc := new(usersController) uc.getTemplate = templates.Lookup("users.gohtml") uc.editTemplate = templates.Lookup("user_edit.gohtml") uc.newTemplate = templates.Lookup("user_new.gohtml") uc.deleteTemplate = templates.Lookup("user_delete.gohtml") uc.authorizer = authorizer uc.authBackend = authBackend uc.roles = roles settingsSub.Handle("/users", authorizeRole(appHandler(uc.get), authorizer, "admin")) settingsSub.Handle("/users/{username}/edit", authorizeRole(appHandler(uc.editGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/users/{username}/edit", authorizeRole(appHandler(uc.editPost), authorizer, "admin")).Methods("POST") settingsSub.Handle("/users/{username}/delete", authorizeRole(appHandler(uc.deleteGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/users/{username}/delete", authorizeRole(appHandler(uc.deletePost), authorizer, "admin")).Methods("POST") settingsSub.Handle("/users/new", authorizeRole(appHandler(uc.newGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/users/new", authorizeRole(appHandler(uc.newPost), authorizer, "admin")).Methods("POST") // /settings/contacts cc := new(contactsController) cc.getTemplate = templates.Lookup("contacts.gohtml") cc.editTemplate = templates.Lookup("contact_edit.gohtml") cc.newTemplate = templates.Lookup("contact_new.gohtml") cc.deleteTemplate = templates.Lookup("contact_delete.gohtml") cc.authorizer = authorizer cc.pinger = pinger cc.DB = db settingsSub.Handle("/contacts", authorizeRole(appHandler(cc.get), authorizer, "admin")) settingsSub.Handle("/contacts/{contactID}/edit", authorizeRole(appHandler(cc.editGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/contacts/{contactID}/edit", authorizeRole(appHandler(cc.editPost), authorizer, "admin")).Methods("POST") settingsSub.Handle("/contacts/{contactID}/delete", authorizeRole(appHandler(cc.deleteGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/contacts/{contactID}/delete", authorizeRole(appHandler(cc.deletePost), authorizer, "admin")).Methods("POST") settingsSub.Handle("/contacts/new", authorizeRole(appHandler(cc.newGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/contacts/new", authorizeRole(appHandler(cc.newPost), authorizer, "admin")).Methods("POST") // /settings/sites stc := new(sitesController) stc.detailsTemplate = templates.Lookup("site_details.gohtml") stc.editTemplate = templates.Lookup("site_edit.gohtml") stc.newTemplate = templates.Lookup("site_new.gohtml") stc.changeContactsTemplate = templates.Lookup("site_change_contacts.gohtml") stc.authorizer = authorizer stc.pinger = pinger stc.DB = db // Site list is handled on main settings page so not required here. settingsSub.Handle("/sites/new", authorizeRole(appHandler(stc.newGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/sites/new", authorizeRole(appHandler(stc.newPost), authorizer, "admin")).Methods("POST") settingsSub.Handle("/sites/{siteID}", authorizeRole(appHandler(stc.getDetails), authorizer, "admin")) settingsSub.Handle("/sites/{siteID}/edit", authorizeRole(appHandler(stc.editGet), authorizer, "admin")).Methods("GET") settingsSub.Handle("/sites/{siteID}/edit", authorizeRole(appHandler(stc.editPost), authorizer, "admin")).Methods("POST") // Wrap the router in the CSRF protection. http.Handle("/", CSRF(router)) http.HandleFunc("/img/", serveResource) http.HandleFunc("/css/", serveResource) http.HandleFunc("/js/", serveResource) http.HandleFunc("/fonts/", serveResource) }
func (cfg *LDAPConnectorConfig) Connector(ns url.URL, lf oidc.LoginFunc, tpls *template.Template) (Connector, error) { ns.Path = path.Join(ns.Path, httpPathCallback) tpl := tpls.Lookup(LDAPLoginPageTemplateName) if tpl == nil { return nil, fmt.Errorf("unable to find necessary HTML template") } if cfg.UseTLS && cfg.UseSSL { return nil, fmt.Errorf("Invalid configuration. useTLS and useSSL are mutual exclusive.") } if len(cfg.CertFile) > 0 && len(cfg.KeyFile) == 0 { return nil, fmt.Errorf("Invalid configuration. Both certFile and keyFile must be specified.") } // Set default values if cfg.NameAttribute == "" { cfg.NameAttribute = "cn" } if cfg.EmailAttribute == "" { cfg.EmailAttribute = "mail" } if cfg.MaxIdleConn > 0 { cfg.MaxIdleConn = 5 } if cfg.BindTemplate == "" { cfg.BindTemplate = "uid=%u,%b" } else if cfg.SearchBeforeAuth { log.Warningf("bindTemplate not used when searchBeforeAuth specified.") } searchScope := ldap.ScopeWholeSubtree if cfg.SearchScope != "" { switch { case strings.EqualFold(cfg.SearchScope, "BASE"): searchScope = ldap.ScopeBaseObject case strings.EqualFold(cfg.SearchScope, "ONE"): searchScope = ldap.ScopeSingleLevel case strings.EqualFold(cfg.SearchScope, "SUB"): searchScope = ldap.ScopeWholeSubtree default: return nil, fmt.Errorf("Invalid value for searchScope: '%v'. Must be one of 'base', 'one' or 'sub'.", cfg.SearchScope) } } if cfg.Host == "" { if cfg.ServerHost == "" { return nil, errors.New("no host provided") } // For backward compatibility construct host form old fields. cfg.Host = fmt.Sprintf("%s:%d", cfg.ServerHost, cfg.ServerPort) } host, _, err := net.SplitHostPort(cfg.Host) if err != nil { return nil, fmt.Errorf("host is not of form 'host:port': %v", err) } tlsConfig := &tls.Config{ServerName: host} if (cfg.UseTLS || cfg.UseSSL) && len(cfg.CaFile) > 0 { buf, err := ioutil.ReadFile(cfg.CaFile) if err != nil { return nil, err } rootCertPool := x509.NewCertPool() ok := rootCertPool.AppendCertsFromPEM(buf) if ok { tlsConfig.RootCAs = rootCertPool } else { return nil, fmt.Errorf("%v: Unable to parse certificate data.", cfg.CaFile) } } if (cfg.UseTLS || cfg.UseSSL) && len(cfg.CertFile) > 0 && len(cfg.KeyFile) > 0 { cert, err := tls.LoadX509KeyPair(cfg.CertFile, cfg.KeyFile) if err != nil { return nil, err } tlsConfig.Certificates = []tls.Certificate{cert} } idpc := &LDAPConnector{ id: cfg.ID, namespace: ns, loginFunc: lf, loginTpl: tpl, baseDN: cfg.BaseDN, nameAttribute: cfg.NameAttribute, emailAttribute: cfg.EmailAttribute, searchBeforeAuth: cfg.SearchBeforeAuth, searchFilter: cfg.SearchFilter, searchScope: searchScope, searchBindDN: cfg.SearchBindDN, searchBindPw: cfg.SearchBindPw, bindTemplate: cfg.BindTemplate, ldapPool: &LDAPPool{ MaxIdleConn: cfg.MaxIdleConn, PoolCheckTimer: defaultPoolCheckTimer, Host: cfg.Host, UseTLS: cfg.UseTLS, UseSSL: cfg.UseSSL, TLSConfig: tlsConfig, }, } return idpc, nil }
func (cfg *LDAPConnectorConfig) Connector(ns url.URL, lf oidc.LoginFunc, tpls *template.Template) (Connector, error) { ns.Path = path.Join(ns.Path, httpPathCallback) tpl := tpls.Lookup(LDAPLoginPageTemplateName) if tpl == nil { return nil, fmt.Errorf("unable to find necessary HTML template") } // defaults const defaultNameAttribute = "cn" const defaultEmailAttribute = "mail" const defaultBindTemplate = "uid=%u,%b" const defaultSearchScope = ldap.ScopeWholeSubtree if cfg.UseTLS && cfg.UseSSL { return nil, fmt.Errorf("Invalid configuration. useTLS and useSSL are mutual exclusive.") } if len(cfg.CertFile) > 0 && len(cfg.KeyFile) == 0 { return nil, fmt.Errorf("Invalid configuration. Both certFile and keyFile must be specified.") } nameAttribute := defaultNameAttribute if len(cfg.NameAttribute) > 0 { nameAttribute = cfg.NameAttribute } emailAttribute := defaultEmailAttribute if len(cfg.EmailAttribute) > 0 { emailAttribute = cfg.EmailAttribute } bindTemplate := defaultBindTemplate if len(cfg.BindTemplate) > 0 { if cfg.SearchBeforeAuth { log.Warningf("bindTemplate not used when searchBeforeAuth specified.") } bindTemplate = cfg.BindTemplate } searchScope := defaultSearchScope if len(cfg.SearchScope) > 0 { switch { case strings.EqualFold(cfg.SearchScope, "BASE"): searchScope = ldap.ScopeBaseObject case strings.EqualFold(cfg.SearchScope, "ONE"): searchScope = ldap.ScopeSingleLevel case strings.EqualFold(cfg.SearchScope, "SUB"): searchScope = ldap.ScopeWholeSubtree default: return nil, fmt.Errorf("Invalid value for searchScope: '%v'. Must be one of 'base', 'one' or 'sub'.", cfg.SearchScope) } } if cfg.Timeout != 0 { ldap.DefaultTimeout = cfg.Timeout * time.Millisecond } tlsConfig := &tls.Config{ ServerName: cfg.ServerHost, InsecureSkipVerify: cfg.SkipCertVerification, } if (cfg.UseTLS || cfg.UseSSL) && len(cfg.CaFile) > 0 { buf, err := ioutil.ReadFile(cfg.CaFile) if err != nil { return nil, err } rootCertPool := x509.NewCertPool() ok := rootCertPool.AppendCertsFromPEM(buf) if ok { tlsConfig.RootCAs = rootCertPool } else { return nil, fmt.Errorf("%v: Unable to parse certificate data.", cfg.CaFile) } } if (cfg.UseTLS || cfg.UseSSL) && len(cfg.CertFile) > 0 && len(cfg.KeyFile) > 0 { cert, err := tls.LoadX509KeyPair(cfg.CertFile, cfg.KeyFile) if err != nil { return nil, err } tlsConfig.Certificates = []tls.Certificate{cert} } idp := &LDAPIdentityProvider{ serverHost: cfg.ServerHost, serverPort: cfg.ServerPort, useTLS: cfg.UseTLS, useSSL: cfg.UseSSL, baseDN: cfg.BaseDN, nameAttribute: nameAttribute, emailAttribute: emailAttribute, searchBeforeAuth: cfg.SearchBeforeAuth, searchFilter: cfg.SearchFilter, searchScope: searchScope, searchBindDN: cfg.SearchBindDN, searchBindPw: cfg.SearchBindPw, bindTemplate: bindTemplate, tlsConfig: tlsConfig, } idpc := &LDAPConnector{ id: cfg.ID, idp: idp, namespace: ns, trustedEmailProvider: cfg.TrustedEmailProvider, loginFunc: lf, loginTpl: tpl, } return idpc, nil }
func Register(templates *template.Template) { // http.HandleFunc("/", Helloworld) //HOME hc := new(homeController) hc.template = templates.Lookup("home.html") http.HandleFunc("/", hc.get) //THREAD VIEW tc := new(threadController) tc.template = templates.Lookup("thread.html") http.HandleFunc("/view/", tc.get) //EDIT AND SAVE MAIN emc := new(editMainController) emc.template = templates.Lookup("editMain.html") http.HandleFunc("/edit/topic/", emc.handle) //EDIT AND SAVE REPLY erc := new(editReplyController) erc.template = templates.Lookup("editReply.html") http.HandleFunc("/edit/reply/", erc.handle) //Delete main, it's the same as to delete thread dt := new(deleteController) http.HandleFunc("/delete/", dt.delete) //Register user and edit profile info euc := new(editUserController) euc.template = templates.Lookup("register.html") http.HandleFunc("/edit/user/", euc.handle) //Login Controller lc := new(loginController) lc.template = templates.Lookup("login.html") http.HandleFunc("/login/", lc.handle) //Logout Controller loc := new(logoutController) http.HandleFunc("/logout/", loc.get) }
func SetTemplateCache(tc *template.Template) { login.loginTemplate = tc.Lookup("login.html") parts.autoMakeTemplate = tc.Lookup("make.html") parts.autoModelTemplate = tc.Lookup("model.html") parts.autoYearTemplate = tc.Lookup("year.html") parts.autoEngineTemplate = tc.Lookup("engine.html") parts.searchResultTemplate = tc.Lookup("search_results.html") parts.partTemplate = tc.Lookup("part.html") parts.searchResultPartialTemplate = tc.Lookup("_result.html") checkout.template = tc.Lookup("checkout.html") admin.loginTemplate = tc.Lookup("admin_login.html") admin.menuTemplate = tc.Lookup("admin_menu.html") admin.createEmpTemplate = tc.Lookup("admin_create_emp.html") admin.viewEmpTemplate = tc.Lookup("admin_employee.html") }
func Register(templates *template.Template) { router := mux.NewRouter() hc := new(homeController) hc.template = templates.Lookup("home.html") hc.loginTemplate = templates.Lookup("login.html") router.HandleFunc("/home", hc.get) router.HandleFunc("/login", hc.login) cc := new(categoriesController) cc.template = templates.Lookup("categories.html") router.HandleFunc("/categories", cc.get) categoryController := new(categoryController) categoryController.template = templates.Lookup("products.html") router.HandleFunc("/categories/{id}", categoryController.get) productController := new(productController) productController.template = templates.Lookup("product.html") router.HandleFunc("/product/{id}", productController.get) profileController := new(profileController) profileController.template = templates.Lookup("profile.html") router.HandleFunc("/profile", profileController.handle) standLocatorController := new(standLocatorController) standLocatorController.template = templates.Lookup("stand_locator.html") router.HandleFunc("/stand-locator", standLocatorController.get) router.HandleFunc("/api/stand-locator", standLocatorController.apiSearch) http.Handle("/", router) http.HandleFunc("/img/", serveResource) http.HandleFunc("/css/", serveResource) }