func main() { LoadDatabase() StartAutoSave() m := martini.Classic() // API endpoints m.Get("/app/report/:host", GetReports) m.Post("/app/report", binding.Bind(InboundReport{}), FileReport) m.Get("/app/suggest/:prefix", SuggestHosts) // API endpoints for report actions m.Post("/app/update/:reportID/ack", binding.Bind(ActionMeta{}), Acknowledge) m.Post("/app/update/:reportID/fixed", binding.Bind(ActionMeta{}), Fixed) m.Post("/app/update/:reportID/reject", binding.Bind(ActionMeta{}), Reject) m.Post("/app/update/:reportID/delete", binding.Bind(ActionMeta{}), Delete) // Serve up the report page m.Get("/report/:host", func(req *http.Request, resp http.ResponseWriter) { http.ServeFile(resp, req, "public/report.html") }) m.Get("/test", func() string { return "test successful" }) m.Run() }
func (h *Httpd) Run() { m := martini.Classic() m.Get("/", func() string { return "Hello, I'm Takosan!!1" }) m.Post("/notice", binding.Bind(Param{}), messageHandler) m.Post("/privmsg", binding.Bind(Param{}), messageHandler) m.RunOnAddr(fmt.Sprintf("%s:%d", h.Host, h.Port)) }
func main() { // Initialize m := martini.Classic() // Connect to mongo m.Use(middlewares.Connect()) // Templating support m.Use(middlewares.Templates()) // Routes m.Get("/", func(r render.Render) { r.Redirect("/available") }) m.Group("/available", func(r martini.Router) { r.Get("", available.List) r.Get("/new", available.New) r.Get("/:_id", available.Edit) r.Post("", binding.Bind(models.AvailableTopic{}), available.Create) r.Post("/:_id", binding.Bind(models.AvailableTopic{}), available.Update) r.Delete("/:_id", available.Delete) }) // Start listening m.Run() }
func main() { var host string var port int flag.StringVar(&host, "host", "", "The address to bind to") flag.IntVar(&port, "port", 9999, "The port to listen at") m := martini.Classic() m.Use(func(c martini.Context, w http.ResponseWriter) { c.MapTo(encoder.JsonEncoder{PrettyPrint: false}, (*encoder.Encoder)(nil)) w.Header().Set("Content-Type", "application/json; charset=utf-8") }) m.Get("/users", GetUsers) m.Post("/users", binding.Bind(User{}), CreateUser) m.Get("/users/:id", GetUser) m.Delete("/users/:id", DeleteUser) m.Get("/users/:id/teams", GetUserTeams) m.Get("/users/:id/goals", GetUserGoals) m.Get("/teams", GetTeams) m.Post("/teams", binding.Bind(Team{}), CreateTeam) m.Get("/teams/:id", GetTeam) m.Delete("/teams/:id", DeleteTeam) m.Put("/users/:uid/teams/:tid", AddUserToTeam) m.Delete("/users/:uid/teams/:tid", DeleteUserFromTeam) m.Post("/goals", binding.Bind(Goal{}), CreateGoal) m.Get("/goals/:id", GetGoal) m.Post("/goals/:id", binding.Bind(GoalCompleteParams{}), CompleteGoal) log.Fatal(http.ListenAndServe(":8080", m)) m.Run() }
func Routes() http.Handler { // Middlewares are setup and run before each incoming request // the ones named like *Provider provide singleton instances // of injectable objects. For instance appx, logger, appengine context // can be injected in our routes handlers (a.k.a controllers) router := martini.Classic() router.Use(render.Renderer()) router.Use(middlewares.AppengineContextProvider) router.Use(middlewares.LoggerProvider) router.Use(middlewares.AppxProvider) router.Post("/login", binding.Bind(controllers.LoginForm{}), controllers.Login) router.Group("/account", func(r martini.Router) { r.Post("/registerDropbox", binding.Bind(controllers.RegisterDropboxForm{}), controllers.RegisterDropbox) r.Post("/update", binding.Bind(controllers.AccountUpdateForm{}), controllers.UpdateAccount) r.Group("/dropbox", func(r martini.Router) { r.Post("/init", controllers.DropboxInit) r.Post("/delta", controllers.DropboxDelta) }, middlewares.ExternalServiceAuthorizationProvider) r.Group("/trails", func(r martini.Router) { r.Get("/next_evaluation", controllers.TrailNextEvaluation) r.Patch("/:trail_id/like", controllers.TrailLike) r.Patch("/:trail_id/dislike", controllers.TrailDislike) r.Get("/tags", controllers.Tags) r.Get("/tags/:tag_id", controllers.TagTrails) }) }, middlewares.AuthorizationAccountProvider) return router }
func (self *oprPrevSeasonRankCom) Start(peer netfw.IPeer) { m := peer.(martinihttp.IMartiniAcceptor).GetInterface() m.Get("/seasonrank", sessionauth.LoginRequired, binding.Bind(queryZone{}), func(r render.Render, msg queryZone) { var zones []zoneInfo dbopr.IterateShowDB(func(name, showname string) { zones = append(zones, zoneInfo{ Name: name, ShowName: showname, }) }) r.HTML(200, "index", nil) r.HTML(200, "seasonrank", zones) }) m.Post("/rankdata", sessionauth.LoginRequired, binding.Bind(queryZone{}), func(r render.Render, msg queryZone) { res, err := dbopr.ExecuteSQL(msg.Zone, &dbLastSeason{}, "select $FIELD_NAME$ from tb_last_season") if err != nil { r.Data(200, []byte(err.Error())) return } r.JSON(200, res) }) }
// Route return the route handler for this func (s ServiceRegistryWebService) Route() martini.Router { r := martini.NewRouter() r.Group("/apiversions/", func(r martini.Router) { r.Get("", s.getAPIVersions) r.Post("", binding.Bind(common.APIVersion{}), s.createAPIVersion) }) r.Group("/apiversions/:version/", func(r martini.Router) { r.Get("", s.getAPIVersion) r.Get("services/", s.getAPIServices) r.Post("services/", binding.Bind(common.ServiceVersion{}), s.createAPIService) }) r.Group("/services/", func(r martini.Router) { r.Get("", s.getServices) r.Post("", binding.Bind(common.ServiceDefinition{}), s.createService) r.Delete(":service/", s.dropService) }) r.Group("/services/:service/versions", func(r martini.Router) { r.Get("", s.getServiceVersions) r.Post("", binding.Bind(common.ServiceVersion{}), s.createServiceVersion) }) r.Group("/services/:service/:version/hosts/", func(r martini.Router) { r.Get("", s.getServiceHosts) r.Post("", binding.Bind(common.ServiceHost{}), s.attachServiceHost) }) return r }
func main() { m := martini.Classic() m.Post("/text", binding.Bind(DisplayMessage{}), createText) m.Post("/image", binding.MultipartForm(ImageMessage{}), createImage) m.Post("/display", binding.Bind(IDMessage{}), displayImage) m.Run() }
func main() { config, err := config.Load() if err != nil { log.Fatal(err) } fishhubService, err := fishhub.NewService(config.MongoURL) if err != nil { log.Fatal(err) } sessionService, err := session.NewService(config.MongoURL) if err != nil { log.Fatal(err) } store := sessions.NewCookieStore([]byte("@!#$%^&*")) m := martini.Classic() m.Map(fishhubService) m.Map(sessionService) m.Use(sessions.Sessions("go_session", store)) // Setup routes m.Get("/", home) m.Group("/users", func(r martini.Router) { r.Post("", binding.Bind(UserForm{}), NewUser) r.Get("/:id", GetUser) r.Put("/update/:id", UpdateUser) r.Delete("/delete/:id", DeleteUser) }) m.Group("/login", func(r martini.Router) { r.Post("", binding.Bind(LoginForm{}), CheckCredential) }) m.Handlers( render.Renderer(render.Options{ Delims: render.Delims{"<%", "%>"}, }), martini.Logger(), martini.Static("public"), ) m.NotFound(func(r render.Render) { r.HTML(404, "404", nil) }) err = http.ListenAndServe(":"+config.Port, m) if err != nil { log.Fatal(err) } }
func SetupRoutes(db *mgo.Database, m *martini.ClassicMartini) { m.Group("/oauth", func(r martini.Router) { r.Get("/register/:type", modules.Register) r.Get("/github", binding.Bind(models.GithubOAuth{}), modules.GithubOAuth) }) m.Group("/api/user", func(r martini.Router) { r.Put("/", binding.Bind(models.User{}), api.RegisterUser) }) }
func init() { // BASE_URL, AUTH_USER and AUTH_PASS, AWS_S3_BASE_URL are not required or else wercker tests would fail baseURL = os.Getenv("BASE_URL") authUser = os.Getenv("AUTH_USER") authPass = os.Getenv("AUTH_PASS") s3BaseURL = os.Getenv("AWS_S3_BASE_URL") if awsAuth, err := aws.EnvAuth(); err != nil { // not required or else wercker tests would fail log.Println(err) } else { // TODO(jrubin) allow region to be chosen by env variable s3Data := s3.New(awsAuth, aws.USWest2) s3Bucket = s3Data.Bucket(os.Getenv("AWS_S3_BUCKET_NAME")) } m = martini.Classic() m.Use(gzip.All()) m.Use(render.Renderer()) m.Get("/", func() string { return "hello, world" }) m.Post( "/v1/transcribe", auth.Basic(authUser, authPass), strict.Accept("application/json"), strict.ContentType("application/x-www-form-urlencoded"), binding.Bind(transcribeData{}), binding.ErrorHandler, handleTranscribe, ) m.Post( "/v1/transcribe/process", strict.ContentType("application/x-www-form-urlencoded"), binding.Bind(telapi.TranscribeCallbackData{}), binding.ErrorHandler, handleTranscribeProcess, ) m.Post( "/v1/transcribe/upload", auth.Basic(authUser, authPass), strict.Accept("application/json"), binding.MultipartForm(transcribeUploadData{}), binding.ErrorHandler, handleTranscribeUpload, ) m.Router.NotFound(strict.MethodNotAllowed, strict.NotFound) }
func registerRoutes(server *martini.ClassicMartini) { // Box server.Post("/boxes", binding.Bind(request.CreateRequest{}), boxCreate) server.Put("/boxes/:name", binding.Bind(request.DeployRequest{}), boxDeploy) server.Get("/boxes", boxList) server.Get("/boxes/:name", boxInspect) server.Delete("/boxes/:name", boxDelete) // Domain server.Post("/boxes/:name/domain", binding.Bind(request.Domain{}), domainAdd) server.Delete("/boxes/:name/domain/:domain", domainDelete) }
func main() { config := config.New() config.Load("config.json") cfbase := config.GetString("database", "sqlite3") cfconn := config.GetString("connection", "./app.db") db, err := gorm.Open(cfbase, cfconn) checkErr(err, "Database connection failed") db.AutoMigrate(&models.Blog{}) db.AutoMigrate(&models.Classify{}) defer db.Close() admin := &fun.Admins{Account: config.GetString("web_account", "admin"), Password: config.GetString("web_password", "admin")} jade := gojade.New() jade.ViewPath = "./jade" jade.RegisterFunction("date", fun.Date) jade.RegisterFunction("dateformat", fun.DateFormat) jade.RegisterFunction("compare", fun.Compare) jade.RegisterFunction("compare_not", fun.CompareNot) jade.RegisterFunction("substr", fun.Substr) jade.RegisterFunction("subtext", fun.Subtext) jade.RegisterFunction("img", fun.Img) jade.RegisterFunction("html2str", fun.HTML2str) jade.RegisterFunction("str2html", fun.Str2html) jade.RegisterFunction("htmlquote", fun.Htmlquote) jade.RegisterFunction("htmlunquote", fun.Htmlunquote) jade.RegisterFunction("map_get", fun.MapGet) m := martini.Classic() m.Map(db) m.Map(jade) m.Map(admin) m.Use(martini.Static("static")) m.Get("/", controllers.Home) m.Get("/:tag.html", controllers.Tag) m.Get("/view/:id.html", controllers.View) m.Get("/_login", controllers.Login) m.Get("/_logout", controllers.Logout) m.Get("/_add", controllers.Check, controllers.Create) m.Get("/_class", controllers.Check, controllers.Classify) m.Get("/_edit/:id", controllers.Check, controllers.Edit) m.Get("/_delete/:id", controllers.Check, controllers.Delete) m.Post("/_login", binding.Bind(models.Admin{}), controllers.LoginPost) m.Post("/_add", binding.Bind(models.Blog{}), controllers.CreatePost) m.Post("/_class", binding.Bind(models.Classify{}), controllers.ClassifyPost) m.Post("/_edit/:id", binding.Bind(models.Blog{}), controllers.UpdatePost) m.NotFound(controllers.NotFound) m.Run() }
func main() { m := martini.Classic() m.Use(cors.Allow(&cors.Options{ AllowOrigins: []string{"*"}, AllowMethods: []string{"PUT", "PATCH", "GET", "POST", "OPTIONS"}, AllowHeaders: []string{"Origin", "content-type"}, ExposeHeaders: []string{"Content-Length"}, AllowCredentials: true, })) session, err := mgo.Dial("localhost") if err != nil { panic(err) } defer session.Close() m.Map(session) m.Group("/foods", func(r martini.Router) { r.Get("", GetFood) r.Get("/:id", GetFood) r.Get("/queries/:name", GetFoodByName) r.Post("/new", binding.Bind(d.Food{}), NewFood) r.Put("/update/:id", binding.Bind(d.Food{}), UpdateFood) r.Delete("/delete/:id", DeleteFood) }) m.Group("/recipes", func(r martini.Router) { r.Get("", GetRecipe) r.Get("/:id", GetRecipe) r.Post("", binding.Bind(Recipe{}), NewRecipe) r.Put("/update/:id", binding.Bind(Recipe{}), UpdateRecipe) r.Delete("/delete/:id", DeleteRecipe) }) m.Get("/foodGroup", func() []byte { foodGroupDB := session.DB("CNF").C("foodGroup") query := foodGroupDB.Find(nil) var result []d.FoodGroup query.All(&result) b, _ := json.Marshal(result) return b }) m.Run() }
func main() { m := martini.Classic() if envGet(ENV_RESTRICT_DOMAINS) == "" { m.Get("/qr", binding.Bind(meddler.Payload{}), presentQRCode) m.Post("/qr", binding.Bind(meddler.Payload{}), presentQRCode) } m.Get("/drive/qr", binding.Bind(meddler.Payload{}), googleDriveDomainRestrictedQRCode) m.Post("/drive/qr", binding.Bind(meddler.Payload{}), googleDriveDomainRestrictedQRCode) // m.Post("/gen", GenerateKeySet) m.Run() // m.RunOnAddr(envAddrInfo.ConnectionString()) }
func (us UserService) Register(router martini.Router) { utils.Log.Debug("Registering UserService!") router.Group("/users", func(rtr martini.Router) { rtr.Post("", PreventReauth, binding.Bind(models.User{}), us.Create) rtr.Post("/update", EnsureAuth, binding.Bind(models.User{}), us.Update) }) router.Get("/signout", us.SignOut) router.Get("/signup", PreventReauth, us.SignUp) router.Get("/signin", PreventReauth, us.SignIn) router.Get("/dashboard", EnsureAuth, us.Dashboard) router.Get("/settings/edit", EnsureAuth, us.Edit) router.Get("/settings/edit/:category", EnsureAuth, us.Edit) router.Get("/wakatime/sync", EnsureAuth, us.SyncHeartbeats) }
func EnsureAuth(r martini.Router, mainDb *d.MainDb) martini.Router { r.Get("/", func(r render.Render, prms martini.Params, req *http.Request) { flashMessage, fType := flash.GetMessage() query := req.URL.Query() result := map[string]interface{}{ fmt.Sprintf("flash_%v", fType): flashMessage, "from": query.Get("from"), } r.HTML(200, "login", AddCurrentUser(result, req, mainDb), render.HTMLOptions{Layout: "base"}) }) r.Post("/", binding.Bind(user{}), func(postedUser user, r render.Render, req *http.Request, w http.ResponseWriter) { userData, err := mainDb.Users.LoginUser(postedUser.LoginName, postedUser.Password) if err != nil { log.Printf("AUTH user %+v not found: %v", postedUser, err) flash.SetMessage("К сожалению, пользователь с такими данными не найден.", "error") r.Redirect(AUTH_URL) return } else { log.Printf("AUTH found user data: %v, %v, %v", userData.UserId, userData.UserName, userData.Auth) } user := NewUser(userData) StartAuthSession(user, w) redirect := req.URL.Query().Get(REDIRECT_PARAM) if redirect == "" { redirect = DefaultUrlMap.GetDefaultUrl(user.BelongsToCompany()) } http.Redirect(w, req, redirect, 302) }) return r }
func apiHandler(router *Router) http.Handler { r := martini.NewRouter() m := martini.New() m.Use(martini.Logger()) m.Use(martini.Recovery()) m.Use(render.Renderer()) m.Action(r.Handle) m.Map(router) r.Post("/routes", binding.Bind(strowger.Route{}), createRoute) r.Put("/routes", binding.Bind(strowger.Route{}), createOrReplaceRoute) r.Get("/routes", getRoutes) r.Get("/routes/:route_type/:route_id", getRoute) r.Delete("/routes/:route_type/:route_id", deleteRoute) return m }
func main() { m := martini.Classic() m.Use(martini.Static("public")) m.Use(render.Renderer(render.Options{ Layout: "layout", Extensions: []string{".tmpl.html"}, })) var opts db.Options level, err := leveldb.Open("database/messageDB", &opts) if err != nil { panic(err) } defer level.Close() m.Map(level) m.Get("/", Index) m.Get("/add", Add) m.Post("/create", binding.Bind(Message{}), Create) m.Run() }
//-------------------------------------- //文件管理逻辑 // //KindEditor提交参数: //dir{"image", "flash", "media", "file"},默认"image" //path,默认"",格式:"2014年","2014年1月","201401-<filename>" //order,默认"name" // //返回给KindEditor的参数: //moveup_dir_path": "", //"current_dir_path": "", //"current_url": "/ke4/php/../attached/", //"total_count": 5, //"file_list": [ // //{ // "is_dir": false, // "has_file": false, // "filesize": 208736, // "is_photo": true, // "filetype": "jpg", // "filename": "1241601537255682809.jpg", // "datetime": "2011-08-02 15:32:43" //}, //{ // "is_dir": true, // "has_file": (file.listFiles() != null), // "filesize": 0L, // "is_photo": false, // "filetype": "", // "filename": file.getName(), // "datetime": "2011-08-02 15:32:43" //}, //-------------------------------------- //martini handler func ListFilesHandlers() []martini.Handler { var bind = binding.Bind(ListReqData{}) var listHandler = func(data ListReqData, w http.ResponseWriter, r *http.Request) { if strings.ToUpper(data.Dir) != "IMAGE" { data.Err(w, "dir should be IMAGE") return } //根据path建立KindList list := &KindList{CurrentDirPath: strings.TrimSuffix(data.Path, "/")} switch length := len([]rune(list.CurrentDirPath)); length { case 0: //"" listYears(r, list) case 5: //"2014年, 2014年" if err := listMonths(r, list); err != nil { data.Err(w, err.Error()) return } case 7, 8: //"2014年4月" if err := listFiles(&data, list); err != nil { data.Err(w, err.Error()) return } default: data.Err(w, `Path wrong:`+data.Path) return } io.WriteString(w, data.Callback+"(") resJson(w, list) io.WriteString(w, ")") } return []martini.Handler{bind, listHandler} }
func main() { m := martini.Classic() m.Use(render.Renderer(render.Options{ Directory: "templates", Extensions: []string{".tmpl", ".html"}, Charset: "UTF-8", Funcs: []template.FuncMap{ { "equal": func(args ...interface{}) bool { return args[0] == args[1] }, }, }, })) store := sessions.NewCookieStore([]byte("secret123")) m.Use(sessions.Sessions("my_session", store)) m.Get("/", youth) m.Get("/firtConfirm", firtConfirm) m.Post("/firtConfirm", binding.Form(model.User{}), firtConfirmPost) m.Post("/userSiginCheck", binding.Bind(SiginIfo{}), userSiginCheck) m.Get("/userInforEdit", userInforEdit) m.Post("/userInforEdit", binding.Form(model.User{}), userInforEditPost) m.Get("/editReruenInfo/:status", editReruenInfo) m.Run() }
func (web *MailWeb) initHandlers() { // Public Handlers web.martini.Get("/", web.welcome) web.martini.Post("/", binding.Bind(auth.WatneyUser{}), web.authenticate) // Reserved for martini sessionauth forwarding, in case the session timed out web.martini.Get("/sessionTimeout", web.timeout) // Private Handlers web.martini.Get("/logout", sessionauth.LoginRequired, web.logout) web.martini.Get("/main", sessionauth.LoginRequired, web.main) web.martini.Post("/mailContent", sessionauth.LoginRequired, web.mailContent) web.martini.Post("/mails", sessionauth.LoginRequired, web.mails) web.martini.Post("/poll", sessionauth.LoginRequired, web.poll) web.martini.Post("/sendMail", sessionauth.LoginRequired, web.sendMail) web.martini.Post("/moveMail", sessionauth.LoginRequired, web.moveMail) web.martini.Post("/trashMail", sessionauth.LoginRequired, web.trashMail) web.martini.Post("/updateFlags", sessionauth.LoginRequired, web.updateFlags) web.martini.Post("/userInfo", sessionauth.LoginRequired, web.userInfo) // Static content web.martini.Use(martini.Static("static/resources/libs/", martini.StaticOptions{Prefix: "/libs/"})) web.martini.Use(martini.Static("static/resources/js/", martini.StaticOptions{Prefix: "/js/"})) web.martini.Use(martini.Static("static/resources/css/", martini.StaticOptions{Prefix: "/css/"})) }
func main() { m := martini.Classic() m.Map(SetupDB()) m.Use(render.Renderer()) m.Get("/", func() string { return "Hello!" }) m.Get("/todos", TodoIndex) m.Post("/todos", binding.Bind(Todo{}), TodoCreate) m.Get("/todos/:id", TodoShow) m.Patch("/todos/:id", binding.Bind(Todo{}), TodoUpdate) m.Put("/todos/:id", binding.Bind(Todo{}), TodoUpdate) m.Delete("/todos/:id", TodoDestroy) m.Run() }
func main() { if envKeySet.PublicKey == "" { errorPrint("publicKey not set. Please set %s in your env.\n", envKeyAlias.PubKeyAlias) return } if envKeySet.PrivateKey == "" { errorPrint("privateKey not set. Please set %s in your env.\n", envKeyAlias.PrivKeyAlias) return } m := martini.Classic() m.Get("/", requestDownloadForm) m.Get("/gif", requestDownloadFormGif) m.Get("/webm", requestDownloadFormWebm) m.Get("/png", requestDownloadFormPng) m.Get("/head", binding.Bind(downloader.DownloadItem{}), downloader.HeadGet) m.Get("/download", binding.Bind(downloader.DownloadItem{}), download) m.Post("/extrict/gif", binding.Bind(downloader.DownloadItem{}), extrictGif) m.Post("/extrict/mp4", binding.Bind(downloader.DownloadItem{}), extrictMp4) m.Post("/extrict/webm", binding.Bind(downloader.DownloadItem{}), extrictWebm) m.Post("/extrict/png", binding.Bind(downloader.DownloadItem{}), extrictPng) m.Post("/download", binding.Bind(downloader.DownloadItem{}), download) m.Run() }
func main() { store := sessions.NewCookieStore([]byte("secret123")) dbmap = initDb() m := martini.Classic() m.Use(render.Renderer()) // Default our store to use Session cookies, so we don't leave logged in // users roaming around store.Options(sessions.Options{ MaxAge: 0, }) m.Use(sessions.Sessions("my_session", store)) m.Use(sessionauth.SessionUser(GenerateAnonymousUser)) sessionauth.RedirectUrl = "/login" sessionauth.RedirectParam = "index" m.Get("/", func(r render.Render) { r.HTML(200, "index", nil) }) m.Get("/login", func(r render.Render) { r.HTML(200, "login", nil) }) m.Post("/new-login", binding.Bind(MyUserModel{}), func(session sessions.Session, postedUser MyUserModel, r render.Render, req *http.Request) { // You should verify credentials against a database or some other mechanism at this point. // Then you can authenticate this session. user := MyUserModel{} err := dbmap.SelectOne(&user, "SELECT * FROM users WHERE username = $1 and password = $2", postedUser.Username, postedUser.Password) if err != nil { r.Redirect(sessionauth.RedirectUrl) return } else { err := sessionauth.AuthenticateSession(session, &user) if err != nil { r.JSON(500, err) } params := req.URL.Query() redirect := params.Get(sessionauth.RedirectParam) r.Redirect(redirect) return } }) m.Get("/private", sessionauth.LoginRequired, func(r render.Render, user sessionauth.User) { r.HTML(200, "private", user.(*MyUserModel)) }) m.Get("/logout", sessionauth.LoginRequired, func(session sessions.Session, user sessionauth.User, r render.Render) { sessionauth.Logout(session, user) r.Redirect("/") }) m.Run() }
func main() { if envKeySet.PublicKey == "" { errorPrint("publicKey not set. Please set %s in your env.\n", envKeyAlias.PubKeyAlias) return } if envKeySet.PrivateKey == "" { errorPrint("privateKey not set. Please set %s in your env.\n", envKeyAlias.PrivKeyAlias) return } m := martini.Classic() m.Get("/qr", binding.Bind(meddler.Payload{}), presentQRCode) m.Post("/qr", binding.Bind(meddler.Payload{}), presentQRCode) m.RunOnAddr(envAddrInfo.ConnectionString()) }
func main() { m := martini.Classic() m.Use(render.Renderer(render.Options{ Layout: "_layout", })) m.Use(secure.Secure(secure.Options{ SSLRedirect: true, SSLProxyHeaders: map[string]string{"X-Forwarded-Proto": "https"}, })) store := sessions.NewCookieStore([]byte(os.Getenv("COOKIE_SECRET"))) m.Use(sessions.Sessions("the_session", store)) m.Use(sessionauth.SessionUser(GenerateAnonymousUser)) /** Main router **/ m.Get("/", sessionauth.LoginRequired, cameraList) m.Get("/camimage", sessionauth.LoginRequired, cameraImage) /** Login Handling **/ m.Get("/login", func(r render.Render) { r.HTML(200, "login", nil, render.HTMLOptions{ Layout: "_login_layout", }) }) m.Post("/login", binding.Bind(User{}), func(session sessions.Session, postedUser User, r render.Render, req *http.Request) { // if not logged in if postedUser.Passcode != "" && postedUser.Passcode == os.Getenv("WEB_PASSCODE") { user := &User{} err := sessionauth.AuthenticateSession(session, user) if err != nil { r.Text(500, "Error authenticating session") return } params := req.URL.Query() redirect := params.Get(sessionauth.RedirectParam) r.Redirect(redirect) return } else { r.Redirect(sessionauth.RedirectUrl) return } }) m.Get("/logout", sessionauth.LoginRequired, func(session sessions.Session, user sessionauth.User, r render.Render) { sessionauth.Logout(session, user) r.Redirect("/") }) m.Run() }
func main() { m := martini.Classic() m.Use(render.Renderer()) m.Get("/", func(r render.Render) { r.JSON(200, map[string]interface{}{"hello": "world"}) }) m.Get("/person", func(r render.Render) { r.JSON(200, Person{ Name: "newegg", Age: 30, Card: GetCard(), }) }) //get route param m.Get("/order/:orderid", func(params martini.Params) string { return "this.is " + params["orderid"] }) //get query string m.Get("/product", func(r *http.Request) string { qs := r.URL.Query() return qs.Get("productid") }) //反序列化json m.Post("/card", binding.Bind(PersonCard{}), func(card PersonCard) string { return fmt.Sprintf("CardId: %d", card.CardId) }) //读取并输出json, martini会通过Injector来匹配HandlerFunc的参数类型 m.Put("/card", binding.Bind(PersonCard{}), func(r render.Render, card PersonCard) { r.JSON(http.StatusOK, Person{ Name: "newegg", Age: 30, Card: GetCard(), }) }) //m.Run() http.ListenAndServe(":8060", m) }
func main() { var err error sqlConnection = "doug:doug@tcp(127.0.0.1:3306)/martini-gorm?parseTime=True" db, err = gorm.Open("mysql", sqlConnection) if err != nil { panic(err) return } m := martini.Classic() m.Use(render.Renderer()) m.Get("/", func(r render.Render) { var retData struct { Items []Item } db.Find(&retData.Items) r.HTML(200, "index", retData) }) m.Get("/item/add", func(r render.Render) { var retData struct { Item Item } r.HTML(200, "item_edit", retData) }) m.Post("/item/save", binding.Bind(Item{}), func(r render.Render, i Item) { db.Save(&i) r.Redirect("/") }) m.Get("/item/edit/:id", func(r render.Render, p martini.Params) { var retData struct { Item Item } db.Where("id = ?", p["id"]).Find(&retData.Item) r.HTML(200, "item_edit", retData) }) m.Get("/item/remove/:id", func(r render.Render, p martini.Params) { var item Item db.Where("id = ?", p["id"]).Delete(&item) r.Redirect("/") }) m.Run() }
func init() { m := martini.Classic() m.Use(render.Renderer(render.Options{IndentJSON: true})) m.Use(middleware.AppengineContextProvider) m.Use(middleware.AppxProvider) m.Use(middleware.RequestLocationProvider) m.Post("/login", binding.Bind(model.User{}), handler.LoginHandler) m.Group("/posts", func(r martini.Router) { r.Post("", binding.Bind(model.Post{}), handler.CreatePostHandler) r.Get("", handler.ListPostsHandler) r.Get("/:plate", handler.ListPostsByCarPlateHandler) r.Put("/:post_id", handler.FlagPostHandler) }) http.Handle("/", m) }