func main() {
autoUpdate()
m := martini.Classic()
m.Use(martini.Static("static"))
m.Use(render.Renderer())
m.Get("/", func(r render.Render) {
r.HTML(200, "content", []interface{}{getPage(1)})
})
m.Get("/api/:id", func(params martini.Params, r render.Render) {
s := strings.Trim(params["id"], " .)(")
id := atoi(s)
r.JSON(200, getPage(id))
})
m.Get("/page/:id", func(params martini.Params, r render.Render) {
s := strings.Trim(params["id"], " .)(")
id := atoi(s)
r.HTML(200, "content", []interface{}{getPage(id)})
})
http.ListenAndServe("0.0.0.0:8000", m)
m.Run()
}
func main() {
m := martini.Classic()
if os.Getenv("MARTINI_ENV") == "production" {
g.devMode = false
}
if g.IsDevMode() {
m.Use(runnerMiddleware)
}
g.InitDb()
m.Use(martini.Static("public/app"))
m.Use(func(resp http.ResponseWriter, req *http.Request) {
if strings.HasPrefix(req.URL.Path, "/api/") {
token := req.Header.Get("AuthToken")
if token != "" {
n, err := g.Db().SelectInt(`select count(*) from users where token=$1`, token)
if err != nil && err != sql.ErrNoRows {
log.Fatalf(err.Error())
}
if n > 0 {
return
}
}
resp.WriteHeader(http.StatusUnauthorized)
resp.Write([]byte("You're not allowed to do this, sorry."))
}
})
m.Get("/", func(r http.ResponseWriter) {
t, err := template.ParseFiles("public/app/index.html")
if err != nil {
panic(err.Error())
}
t.Execute(r, nil)
})
m.Get("/auth", func(r http.ResponseWriter) {
username, token := makeRandomUserToken()
user := &biz.User{
Username: username,
Token: token,
Role: biz.RoleUser,
}
checkErr(g.Db().Insert(user))
resp, err := json.Marshal(map[string]interface{}{
"username": user.Username,
"token": user.Token,
})
checkErr(err)
r.Write(resp)
})
m.Get("/api/test", func(r http.ResponseWriter) {
r.Write([]byte("CLGT"))
})
m.Run()
}
func main() {
m := martini.Classic()
// log before and after a request
m.Use(func(c martini.Context, log *log.Logger) {
log.Println("before a request")
c.Next()
log.Println("after a request")
})
sublime.Route(m)
store := sessions.NewCookieStore([]byte("secret_words_key_xxx"))
m.Use(sessions.Sessions("weiyan_session", store))
m.Get("/set", func(session sessions.Session) string {
session.Set("hello", "world")
return "OK"
})
m.Get("/get", func(session sessions.Session) string {
v := session.Get("hello")
if v == nil {
return ""
}
return v.(string)
})
//m.Use("/admin", auth.Basic("username", "secretpassword"))
m.Use(martini.Static("assets"))
m.Run()
}
func main() {
m := martini.Classic()
m.Map(SetupDB())
m.Use(render.Renderer(render.Options{
Layout: "layout",
}))
m.Use(martini.Static("assets"))
m.Get("/", func(ren render.Render, r *http.Request, db *sql.DB) {
rows, err := db.Query("SELECT * from videos")
PanicIf(err)
defer rows.Close()
videos := []Video{}
for rows.Next() {
v := Video{}
err := rows.Scan(&v.Id, &v.Title)
PanicIf(err)
videos = append(videos, v)
// fmt.Fprintf(rw, "Title: %s", title)
}
ren.HTML(200, "videos", videos)
})
m.Run()
}
func main() {
// Get the configuration
//
if *configFile == "" {
*configFile = "./nightcrawler.ini"
}
opts := globalconf.Options{Filename: *configFile, EnvPrefix: "NC_"}
conf, _ := globalconf.NewWithOptions(&opts)
conf.ParseAll()
// Static assets should be served by nginx in production
//
println(martini.Env)
m := martini.Classic()
if martini.Env != "production" {
m.Use(martini.Static("assets"))
}
// This is just a temp route in development mode
//
if martini.Env == "development" {
m.Get("/", UserRendererMiddleware(), func(r render.Render) {
r.HTML(200, "root", nil)
})
}
// Top level of app
// This section is everything outside of authentication
//
m.Group("/app", func(r martini.Router) {
r.Get("/sign_in", controllers.SignIn)
r.Post("/sign_in", csrf.Validate, controllers.SignIn)
r.Get("/sign_up", controllers.SignUp)
r.Post("/sign_up", csrf.Validate, controllers.CreateSignUp)
r.Get("/sign_out", controllers.SignOut)
r.NotFound(func(x render.Render) {
x.HTML(404, "404", nil)
})
},
CookieStore(*userCookieSecret, *userSessionName),
UserSessionAuth(),
CSRFMiddleware(*userSessionSecret, *userSessionKey),
UserRendererMiddleware(),
)
// Admin interface
m.Group("/app/admin", func(r martini.Router) {
r.Get("/sign_in", controllers.AdminSignIn)
r.NotFound(func(x render.Render) {
x.HTML(404, "404_admin", nil)
})
},
CookieStore("admin123", "nightcrawler_admin"),
AdminSessionAuth(),
CSRFMiddleware("admin123", "adminId"),
AdminRendererMiddleware(),
)
m.Run()
}
func main() {
fs, err := filestore.New("s3")
if err != nil {
log.Fatal(err)
}
port := os.Getenv("PORT")
m := martini.Classic()
m.Map(fs)
m.Use(martini.Static("../web/public"))
m.Use(render.Renderer(render.Options{
Directory: "../web/templates",
Layout: "layout",
}))
m.Get("/", func(fs *filestore.S3, r render.Render) {
files, err := fs.List("builds")
sort.Sort(ByTime(files))
if err != nil {
log.Fatal(err)
}
r.HTML(200, "home", files)
})
log.Printf("starting server at %s", port)
err = http.ListenAndServe(":"+port, m)
if err != nil {
log.Fatal(err)
}
}
func (s *Server) Start() error {
m := martini.Classic()
m.Use(martini.Static("public"))
m.Get("/jq", handleJQ)
return http.ListenAndServe(":"+s.Port, m)
}
func martiniInit() {
m := martini.New()
r := martini.NewRouter()
m.Map(db)
//m.Use(sessions.Sessions("my_session", sessions.NewCookieStore([]byte("secret123"))))
//m.Use(oauth2.Github(&oauth2.Options{
// ClientId: "64a641523f31dd5bfe4b",
// ClientSecret: "4fe3fbbca262835c424ca6a80aec6c6cb4228037",
// RedirectURL: "http://localhost:2714/github_callback",
// Scopes: []string{"user:email"},
//}))
//r.Get("/", index)
r.Get("/comments/:forum/:page", GetAllCommentsResource)
r.Post("/comment", PostCommentHandler)
//r.Get("/github_redirect", RedirectUrl)
//r.Get("/github_callback", func(request *http.Request) string {
// request.ParseForm()
// return fmt.Sprintf("%+v", request)
//})
m.Use(martini.Static("ui"))
m.Action(r.Handle)
fmt.Println("Running on port " + viper.GetString("port"))
sio.Handle("/", m)
//http.Handle("/", m)
//http.ListenAndServe(":"+viper.GetString("port"), m)
}
func main() {
// fmt.Println("Hello World!")
rand.Seed(time.Now().UTC().UnixNano())
/* database := models.GetDB()
database.Drop(tiedotmartini2.BAND_COL)
database.Drop(tiedotmartini2.LOCATION_COL)
database.Drop(tiedotmartini2.GENRE_COL)
database.Create(tiedotmartini2.BAND_COL, 1)
database.Create(tiedotmartini2.LOCATION_COL, 1)
database.Create(tiedotmartini2.GENRE_COL, 1)
col := database.Use(tiedotmartini2.BAND_COL)
col.Index([]string{"albums", "genre_id"})
database.Close()
*/
m := martini.Classic()
m.Get("/", controllers.HomeIndex)
m.Get("/home/index", controllers.HomeIndex)
m.Get("/band/add", controllers.BandAdd)
m.Post("/band/verify", controllers.BandVerify)
m.Get("/album/index/:id", controllers.AlbumIndex)
m.Get("/album/add/:id", controllers.AlbumAdd)
m.Post("/album/verify/:id", controllers.AlbumVerify)
m.Get("/home/genrelist", controllers.HomeGenreList)
m.Get("/home/bygenre/:id", controllers.HomeByGenre)
m.Use(martini.Static("assets"))
m.Run()
}
func main() {
m := martini.Classic()
m.Use(martini.Static("static"))
m.Use(render.Renderer())
m.Get("/", func(r render.Render) {
r.HTML(201, "index", nil)
})
// Authenticate user
m.Post("/auth", binding.Bind(User{}), func(user User, r render.Render) {
if user.UserId == ValidUser && user.Password == ValidPass {
// Create JWT token
token := jwt.New(jwt.GetSigningMethod("HS256"))
token.Claims["userid"] = user.UserId
// Expire in 5 mins
token.Claims["exp"] = time.Now().Add(time.Minute * 5).Unix()
tokenString, err := token.SignedString([]byte(SecretKey))
if err != nil {
r.HTML(201, "error", nil)
return
}
data := map[string]string{
"token": tokenString,
}
r.HTML(201, "success", data)
} else {
r.HTML(201, "error", nil)
}
})
// Check Key is ok
m.Get("/debug/:token", func(params martini.Params, r render.Render) string {
token, err := jwt.Parse(params["token"], func(token *jwt.Token) ([]byte, error) {
return []byte(SecretKey), nil
})
if err == nil && token.Valid {
return "User id: " + token.Claims["userid"].(string)
} else {
return "Invalid"
}
})
// Only accesible if authenticated
m.Post("/secret", func() {
})
m.Run()
}
func main() {
m := martini.Classic()
m.Get("/", func() string {
return "Hello world!"
})
m.Use(auth.Basic("username", "secretpassword"))
m.Use(martini.Static("./"))
m.Run()
}
func newMartini() *martini.ClassicMartini {
r := martini.NewRouter()
m := martini.New()
m.Use(middleware.Logger())
m.Use(martini.Recovery())
m.Use(martini.Static("public"))
m.MapTo(r, (*martini.Routes)(nil))
m.Action(r.Handle)
return &martini.ClassicMartini{m, r}
}
/**
* Martini application configuration.
*/
func configuration(app *martini.ClassicMartini) {
app.Use(martini.Static("public"))
app.Use(render.Renderer(render.Options{
Directory: "templets",
Layout: "layout",
Extensions: []string{".tmpl", ".html"},
Charset: "UTF-8",
IndentJSON: true,
}))
}
func main() {
m := martini.Classic()
m.Use(martini.Static("static"))
m.Get("/api/feed", FetchFeeds)
m.Post("/api/feed", AddFeed)
m.Delete("/api/feed", DeleteFeed)
m.Post("/api/feed/read", MarkUnread)
http.ListenAndServe(":"+os.Getenv("PORT"), m)
}
func main() {
m := martini.Classic()
m.Use(martini.Static("views"))
m.Get("/tasks", GetTasks)
m.Post("/task", CreateTask)
m.Get("/task/:id", FindTask, GetTask)
m.Put("/task/:id", FindTask, UpdateTask)
m.Run()
}
func main() {
m := martini.Classic()
m.Use(func(r http.ResponseWriter) {
r.Header().Set("Access-Control-Allow-Origin", "*")
})
m.Use(martini.Static("xrepo.manager/"))
m.Post("/xRepo/index.php/AuthenticationService/Login", mockApi)
m.Post("/xRepo/index.php/EventService/GetEventList", mockApi)
m.Post("/xRepo/index.php/EventService/GetEventDetails", mockApi)
log.Fatal(http.ListenAndServe(":8080", m))
}
func NewWebServer(car Car) *WebServer {
var ws WebServer
ws.m = martini.Classic()
ws.m.Handlers(martini.Static("public"))
ws.car = car
ws.registerHandlers()
return &ws
}
func main() {
devKey = "?api_key=349258f8-e96e-45f9-a89a-249dee4c607b"
m := martini.Classic()
m.Use(func(r http.ResponseWriter) {
r.Header().Set("Access-Control-Allow-Origin", "*")
})
m.Use(martini.Static("whosthefeeder/"))
m.Get("/summonerNames", getSummonerNames)
m.Post("/latestMatches", getLatestMatches)
log.Fatal(http.ListenAndServe(":8080", m))
}
func Start(DB *Connection, config *Config) {
// Create a new cookie store
store := sessions.NewCookieStore([]byte(config.SecretKey))
m := martini.Classic()
// It will be available to all handlers as *sessions.CookieStore
m.Map(store)
// It will be available to all handlers as *connection *Connection
m.Map(DB)
// It will be available to all handlers as *Config
m.Map(config)
// public folder will serve the static content
m.Use(martini.Static("public"))
// Tag-related routes
m.Get("/tag/:tag/:page", AuthRequired, GetTagHandler)
// Bookmark-related routes
m.Get("/bookmarks/:page", AuthRequired, GetBookmarksHandler)
m.Post("/bookmark/new", AuthRequired, NewBookmarkHandler)
m.Post("/bookmark/update/:bookmark", AuthRequired, EditBookmarkHandler)
m.Delete("/bookmark/delete/:bookmark", AuthRequired, DeleteBookmarkHandler)
// Search
m.Post("/search/:page", AuthRequired, SearchHandler)
// User-related routes
m.Post("/login", LoginPostHandler)
m.Get("/logout", AuthRequired, LogoutHandler)
m.Post("/signup", SignUpHandler)
m.Post("/new_token", AuthRequired, RequestNewToken)
// Test
m.Get("/test", TestHandler)
// Home
m.Get("/", func(cs *sessions.CookieStore, req *http.Request, w http.ResponseWriter, connection *Connection) {
if GetUserID(cs, req, connection) == "" {
LoginHandler(req, w)
}
}, IndexHandler)
csrfHandler := nosurf.New(m)
csrfHandler.SetFailureHandler(http.HandlerFunc(CsrfFailHandler))
http.ListenAndServe(config.Port, csrfHandler)
}
func main() {
m := martini.Classic()
m.Get("/", app.GetThoughts)
m.Get("/about", app.GetAbout)
m.Get("/thoughts", app.GetThoughts)
m.Get("/thoughts/:artile_name", app.GetArticle)
m.Use(martini.Static(os.Getenv("GOPATH") + "/src/github.com/bom-d-van/me/thoughts"))
println("Serving Me on Port", configs.Port)
for {
http.ListenAndServe(configs.Port, m)
}
}
func main() {
m := martini.Classic()
m.Use(render.Renderer())
m.Use(martini.Static("scripts"))
collection := monitor.New()
collection.AddMonitor(&monitor.Monitor{Name: "Motherbrain", HttpAddress: "10.10.8.81:80", MonitorType: "web"})
collection.AddMonitor(&monitor.Monitor{Name: "AQR Web 1", HttpAddress: "10.10.11.144:80", MonitorType: "web", ActiveRedirect: true})
collection.AddMonitor(&monitor.Monitor{Name: "AQR Web 2", HttpAddress: "10.10.9.8:80", MonitorType: "web"})
collection.AddMonitor(&monitor.Monitor{Name: "AQR Web 3", HttpAddress: "10.10.9.247:80", MonitorType: "web"})
collection.AddMonitor(&monitor.Monitor{Name: "AQR Web 4", HttpAddress: "10.10.8.32:80", MonitorType: "web"})
go collection.Run()
m.Get("/", func(w http.ResponseWriter, r *http.Request) {
if redirectAddress, err := collection.FetchActiveRedirect(); err == nil {
http.Redirect(w, r, "http://"+redirectAddress, http.StatusMovedPermanently)
}
})
m.Get("/dashboard", func(r render.Render) {
r.HTML(200, "master", nil)
})
m.Get("/api/getMonitors", func() string {
data, _ := json.Marshal(collection)
return string(data)
})
m.Post("/api/addMonitor", binding.Form(monitor.Monitor{}), func(monitor monitor.Monitor) {
collection.AddMonitor(&monitor)
})
m.Post("/api/removeMonitor", func(w http.ResponseWriter, r *http.Request) {
name := r.FormValue("removeName")
collection.Remove(name)
http.Redirect(w, r, "/dashboard", http.StatusFound)
})
m.Post("/api/activateMonitor", func(w http.ResponseWriter, r *http.Request) {
name := r.FormValue("activateName")
collection.ActivateMonitor(name)
http.Redirect(w, r, "/dashboard", http.StatusFound)
})
m.Run()
}
func main() {
m := martini.Classic()
m.Use(martini.Static("app"))
m.Use(render.Renderer())
m.Get("/", func(r render.Render) {
r.HTML(200, "index", nil)
})
m.Post("/upload", upload)
m.Run()
}
func NewMartiniServer() *martini.ClassicMartini {
conf := GetConfig()
m := martini.Classic()
m.Use(render.Renderer(render.Options{
Layout: "layout",
}))
m.Use(martini.Static("root"))
m.Map(conf.Servers)
for _, t := range conf.Templates {
setupTemplate(m, t)
}
return m
}
func init() {
m = martini.New()
m.Use(martini.Recovery())
m.Use(martini.Logger())
m.Use(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("Strict-Transport-Security", "max-age=60000")
})
m.Use(martini.Static("public"))
m.Use(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
})
r := martini.NewRouter()
r.Put("/candidates", mainHandler)
m.Action(r.Handle)
http.Handle("/", m)
}
func main() {
fmt.Printf("Using config %s\n", conf.Path)
fmt.Printf("Using models:\n")
for _, m := range db.Models {
t := reflect.TypeOf(m)
fmt.Printf(" %s\n", fmt.Sprintf("%s", t)[1:])
}
// Establish session with mongodb
db.Connect(conf.Config.DbHostString(), conf.Config.DbName)
db.RegisterAllIndexes()
m := martini.Classic()
m.Use(martini.Static("static"))
m.Use(DB(conf.Config.DbName))
m.Use(render.Renderer(render.Options{
Directory: "templates",
Layout: "layout", // Specify a layout template
Charset: "UTF-8", // Sets encoding for json and html content-types. Default is "UTF-8".
//IndentJSON: true, // Output human readable JSON
}))
m.NotFound(NotFoundHandler)
m.Get("/", HomeHandler)
m.Get("/events", event.EventListHandler)
m.Get("/events/past", event.EventPastHandler)
m.Get("/events/next", event.EventNextHandler)
m.Get("/organise", event.OrganiseHandler)
m.Get("/event/add", event.EventAddHandler)
// Facebook related features
// one-off link that allows event owner to grab group-specific events set with group-only perms
m.Get("/facebook/login", FacebookLoginHandler)
m.Get("/channel.html", FacebookChannelHandler)
m.Get("/events/grab", event.EventGrabHandler)
m.Post("/events/import", event.EventImportHandler)
m.Post("/events/register", binding.Bind(event.Attendee{}), event.RegisterEventAttendeeHandler)
m.Get("/event/:eid", event.ShowEventAttendees)
m.Run()
}
func main() {
m := martini.Classic()
unescapeFuncMap := template.FuncMap{"unescape": utils.Unescape}
m.Use(render.Renderer(render.Options{
Directory: "html",
Layout: "layout",
Funcs: []template.FuncMap{unescapeFuncMap},
Extensions: []string{".html"},
Charset: "utf-8",
}))
options := martini.StaticOptions{Prefix: "resources"}
m.Use(martini.Static("resources", options))
m.Get("/pdfte", indexHandler)
m.Post("/pdfte", extractHandler)
m.Get("/pdfte/download/:id", downloadHandler)
m.Get("/pdfte/example", exampleHandler)
m.Run()
}
func main() {
m := martini.Classic()
m.Use(martini.Static("public"))
// render html templates from templates directory
//m.Use(render.Renderer())
m.Use(render.Renderer(render.Options{
Directory: "templates", // specify what path to load the templates from
Extensions: []string{".tpl", ".tmpl", ".html"}, // Specify extensions to load for templates
}))
m.Get("/", RegIndex)
m.Post("/signup", RegSignup)
m.Get("/config", RegConfig)
m.Post("/config", RegConfig)
m.Get("/hello", func(r render.Render, req *http.Request) {
reqParams := req.URL.Query()
var str string = ""
log.Printf("req: %v", reqParams)
for k, _ := range reqParams {
str += k + " "
}
r.HTML(200, "hello", str)
})
m.Get("/name/:name", func(params martini.Params, r render.Render, req *http.Request) {
reqParams := req.URL.Query()
log.Printf("params: %v", params)
log.Printf("req: %v", reqParams)
r.HTML(200, "hello", params["name"])
})
/*
m.Get("/hello/**", func(params martini.Params, r render.Render) {
r.HTML(200, "hello", params["_1"])
})
*/
//m.Run()
log.Println("Listen on", ListenPort)
http.ListenAndServe(ListenPort, m)
}
func main() {
fmt.Println("Listening on port :3000")
session, err := mgo.Dial("localhost")
if err != nil {
panic(err)
}
db := session.DB("blog")
m := martini.Classic()
unescapeFuncMap := template.FuncMap{"unescape": unescape}
m.Map(db)
m.Use(s.Middleware)
m.Use(render.Renderer(render.Options{
Directory: "templates", // Specify what path to load the templates from.
Layout: "layout", // Specify a layout template. Layouts can call {{ yield }} to render the current template.
Extensions: []string{".tmpl", ".html"}, // Specify extensions to load for templates.
Funcs: []template.FuncMap{unescapeFuncMap}, // Specify helper function maps for templates to access.
Charset: "UTF-8", // Sets encoding for json and html content-types. Default is "UTF-8".
IndentJSON: true, // Output human readable JSON
}))
staticOptions := martini.StaticOptions{Prefix: "assets"}
m.Use(martini.Static("assets", staticOptions))
m.Get("/", routes.IndexHandler)
m.Get("/login", routes.GetLoginHandler)
m.Get("/logout", routes.LogoutHandler)
m.Post("/login", routes.PostLoginHandler)
m.Get("/write", routes.WriteHandler)
m.Get("/edit/:id", routes.EditHandler)
m.Get("/view/:id", routes.ViewHandler)
m.Get("/delete/:id", routes.DeleteHandler)
m.Post("/SavePost", routes.SavePostHandler)
m.Post("/gethtml", routes.GetHtmlHandler)
m.Run()
}
func main() {
m := martini.Classic()
postsController := new(controllers.PostsController)
m.Use(render.Renderer(render.Options{
Directory: "templates",
Layout: "layout",
}))
m.Use(PopulateAppContext)
m.Use(CloseDatabase)
m.Use(martini.Static("public"))
m.Get("/", postsController.Index)
m.Get("/posts/new", postsController.New)
m.Post("/posts/new", binding.Form(models.Post{}), postsController.Create)
log.Fatal(http.ListenAndServe("192.168.1.60:8080", m))
}
func main() {
_, err := flags.ParseArgs(&opts, os.Args)
PanicIf(err)
m := martini.Classic()
m.Map(SetupDB())
// Serve static files from "static" directory.
StaticOptions := martini.StaticOptions{Prefix: "static"}
m.Use(martini.Static(opts.StaticDir, StaticOptions))
// Render html templates from "templates" directory.
m.Use(render.Renderer(render.Options{Directory: opts.TemplatesDir}))
m.Get("/", IndexHandler)
m.Post("/subscribe/", binding.Form(Subscription{}), SubscribeHandler)
m.Run()
}