/** * attach all api endpoints */ func SetupApiEndpoints(m *martini.ClassicMartini) { m.Get("/api/:project", GetProject) m.Put("/api/:project", PutProject) m.Delete("/api/:project", DeleteProject) m.Get("/api/:project/translation/:key", GetTranslation) m.Put("/api/:project/translation/:key/:locale", PutLocale) m.Delete("/api/:project/translation/:key/:locale", DeleteLocale) m.Get("/api/:project/file/:locale", GetLanguageFile) m.Put("/api/:project/file/:locale", PutLanguageFile) }
func RegisterWebService(server *martini.ClassicMartini) { path := "/api/v1/keys" server.Get(path, Get) //server.Get(path+"/:email", Get) server.Post(path, Post) server.Delete(path, Delete) server.Delete(path+"/:id", Delete) }
func setupUsersCtrl(app *martini.ClassicMartini) { app.Group("/users", func(r martini.Router) { app.Get("", usersIndexAction) app.Get("/add", usersAddAction) app.Post("", sessions.RequireCsrfToken, usersCreateAction) app.Get("/:id", usersEditAction) app.Put("/:id", sessions.RequireCsrfToken, usersUpdateAction) app.Delete("/:id", sessions.RequireCsrfToken, usersDeleteAction) app.Get("/:id/delete", usersDeleteConfirmAction) }, sessions.RequireLogin) }
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 RegisterRESTFunction(f RESTFunction, cm *martini.ClassicMartini) { path := f.GetPath() cm.Get(path, f.RGet) cm.Get(path+"/:id", f.RGet) cm.Post(path, f.RPost) cm.Post(path+"/:id", f.RPost) cm.Delete(path, f.RDelete) cm.Delete(path+"/:id", f.RDelete) }
// RegisterWebService adds martini routes to the relevant webservice methods // based on the path returned by GetPath. Each method is registered once for // the collection and once for each id in the collection. func RegisterWebService(webService WebService, classicMartini *martini.ClassicMartini) { path := webService.GetPath() classicMartini.Get(path, webService.WebGet) classicMartini.Get(path+"/:id", webService.WebGet) classicMartini.Post(path, webService.WebPost) classicMartini.Post(path+"/:id", webService.WebPost) classicMartini.Delete(path, webService.WebDelete) classicMartini.Delete(path+"/:id", webService.WebDelete) }
func addLatestNewsRoutes(m *martini.ClassicMartini) { m.Get("/latest_news", ShowLatestNewsCollection) m.Get("/latest_news/:id", EditLatestNews) m.Post("/latest_news", CreateLatestNews) m.Post("/latest_news/new", CreateLatestNews) m.Put("/latest_news/:id", UpdateLatestNews) m.Post("/latest_news/:id", UpdateLatestNews) m.Delete("/latest_news/:id", DeleteLatestNews) m.Get("/latest_news/del/:id", DeleteLatestNews) }
func addComponentRoutes(m *martini.ClassicMartini) { m.Get("/component", ShowComponents) m.Get("/component/:id", EditComponent) m.Post("/component", CreateComponent) m.Post("/component/new", CreateComponent) m.Put("/component/:id", UpdateComponent) m.Post("/component/:id", UpdateComponent) m.Delete("/component/:id", DeleteComponent) m.Get("/component/del/:id", DeleteComponent) }
func addInvertebrateRoutes(m *martini.ClassicMartini) { m.Get("/invertebrate", ShowInvertebrates) m.Get("/invertebrate/:id", EditInvertebrate) m.Post("/invertebrate", CreateInvertebrate) m.Post("/invertebrate/new", CreateInvertebrate) m.Put("/invertebrate/:id", UpdateInvertebrate) m.Post("/invertebrate/:id", UpdateInvertebrate) m.Delete("/invertebrate/:id", DeleteInvertebrate) m.Get("/invertebrate/del/:id", DeleteInvertebrate) }
func addCoralRoutes(m *martini.ClassicMartini) { m.Get("/coral", ShowCorals) m.Get("/coral/:id", EditCoral) m.Post("/coral", CreateCoral) m.Post("/coral/new", CreateCoral) m.Put("/coral/:id", UpdateCoral) m.Post("/coral/:id", UpdateCoral) m.Delete("/coral/:id", DeleteCoral) m.Get("/coral/del/:id", DeleteCoral) }
func addPlantRoutes(m *martini.ClassicMartini) { m.Get("/plant", ShowPlants) m.Get("/plant/:id", EditPlant) m.Post("/plant", CreatePlant) m.Post("/plant/new", CreatePlant) m.Put("/plant/:id", UpdatePlant) m.Post("/plant/:id", UpdatePlant) m.Delete("/plant/:id", DeletePlant) m.Get("/plant/del/:id", DeletePlant) }
func addInhabitantRoutes(m *martini.ClassicMartini) { m.Get("/inhabitant", ShowInhabitants) m.Get("/inhabitant/:id", EditInhabitant) m.Post("/inhabitant", CreateInhabitant) m.Post("/inhabitant/new", CreateInhabitant) m.Put("/inhabitant/:id", UpdateInhabitant) m.Post("/inhabitant/:id", UpdateInhabitant) m.Delete("/inhabitant/:id", DeleteInhabitant) m.Get("/inhabitant/del/:id", DeleteInhabitant) }
func setupConsumersCtrl(app *martini.ClassicMartini) { app.Group("/consumers", func(r martini.Router) { app.Get("", consumersIndexAction) app.Get("/add", consumersAddAction) app.Post("", sessions.RequireCsrfToken, consumersCreateAction) app.Get("/:id", consumersEditAction) app.Put("/:id", sessions.RequireCsrfToken, consumersUpdateAction) app.Delete("/:id", sessions.RequireCsrfToken, consumersDeleteAction) app.Get("/:id/delete", consumersDeleteConfirmAction) app.Get("/:id/urls", consumersUrlsAction) }, sessions.RequireLogin) // public app.Get("/info/:consumer/:token", consumerInfoAction) }
func SetupAuth(martini *martini.ClassicMartini) { os.Mkdir(backendfile, 0755) backend_, err := httpauth.NewLeveldbAuthBackend(backendfile) if err != nil { log.Fatal(err.Error()) } backend = backend_ roles = make(map[string]httpauth.Role) roles["user"] = 30 roles["admin"] = 80 aaa, err = httpauth.NewAuthorizer(backend, []byte("cookie-encryption-key"), "user", roles) if err != nil { log.Fatal(err.Error()) } users, err := backend.Users() if err != nil || len(users) == 0 { // create a default user hash, err := bcrypt.GenerateFromPassword([]byte("toor"), bcrypt.DefaultCost) //hash, err := bcrypt.GenerateFromPassword([]byte("l4ngu4g3"), bcrypt.DefaultCost) if err != nil { panic(err) } defaultUser := httpauth.UserData{Username: "******", Email: "", Hash: hash, Role: "admin"} //defaultUser := httpauth.UserData{Username: "******", Email: "", Hash: hash, Role: "admin"} err = backend.SaveUser(defaultUser) if err != nil { panic(err) } } martini.Post("/auth/login", doLogin) martini.Get("/auth/logout", doLogout) martini.Get("/auth/token", doGetToken) martini.Post("/auth/user", AssertRole("admin"), doAddUser) martini.Get("/auth/currentuser", doGetCurrentUser) martini.Get("/auth/user", AssertRole("admin"), doGetUsers) martini.Get("/auth/user/:username", AssertRole("admin"), doGetUser) martini.Put("/auth/user/:username", AssertRole("admin"), doUpdateUser) martini.Delete("/auth/user/:username", AssertRole("admin"), doDeleteUser) martini.Post("/auth/user/:username/allow", AssertRole("admin"), doAllow) martini.Post("/auth/user/:username/forbid", AssertRole("admin"), doForbid) }
func api(mart *martini.ClassicMartini) { var engine = backend.GetEngine() mart.Post(API+"/datasets/?", binding.Bind(DatasetForm{}), func(form DatasetForm, r render.Render) { var err error var file *backend.File var tag *backend.Tag var dataset *backend.Dataset if form.FileId > 0 { file = &backend.File{Id: form.FileId} if has, _ := engine.Get(file); !has { r.JSON(http.StatusOK, map[string]interface{}{"err": "file not exists."}) return } } else { if file, err = backend.UploadFile(form.File); err != nil { r.JSON(http.StatusInternalServerError, map[string]interface{}{"err": err.Error()}) return } } if tag, err = backend.SaveTag(form.Tag); err != nil { r.JSON(http.StatusInternalServerError, map[string]interface{}{"err": err.Error()}) return } if dataset, err = backend.SaveDataset(file, tag, form.DataType, form.Description); err != nil { r.JSON(http.StatusInternalServerError, map[string]interface{}{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]*backend.Dataset{"dataset": dataset}) }) mart.Post(API+"/datasets/(?P<dataset_id>\\d+)/?", func(req *http.Request, params martini.Params, r render.Render) { datasetId, _ := strconv.Atoi(params["dataset_id"]) var dataset = new(backend.Dataset) if has, err := engine.Id(datasetId).Get(dataset); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else if has { dataset.FillObject() dataset.Description = req.Form.Get("description") if _, err := engine.Id(datasetId).Update(dataset); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]*backend.Dataset{"dataset": dataset}) } else { r.JSON(http.StatusNotFound, map[string]string{"err": "Dataset not exists."}) } }) mart.Get(API+"/datasets/(?P<dataset_id>\\d+)/?", func(params martini.Params, r render.Render) { datasetId, _ := strconv.Atoi(params["dataset_id"]) var dataset = new(backend.Dataset) if has, err := engine.Id(datasetId).Get(dataset); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else if has { dataset.FillObject() r.JSON(http.StatusOK, map[string]*backend.Dataset{"dataset": dataset}) } else { r.JSON(http.StatusNotFound, map[string]string{"err": "Dataset not exists."}) } }) mart.Delete(API+"/datasets/(?P<dataset_id>\\d+)/?", func(params martini.Params, r render.Render) { datasetId, _ := strconv.Atoi(params["dataset_id"]) var dataset = new(backend.Dataset) if has, err := engine.Id(datasetId).Get(dataset); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else if has { if _, err := engine.Id(datasetId).Delete(dataset); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else { var sql string if dataset.DataType == backend.TRAIN { sql = "update `tag` set `train_count` = `train_count` - 1 where `id` = ?" } else if dataset.DataType == backend.VAL { sql = "update `tag` set `test_count` = `test_count` - 1 where `id` = ?" } engine.Exec(sql, dataset.TagId) r.JSON(http.StatusOK, map[string]string{}) } } else { r.JSON(http.StatusNotFound, map[string]string{"err": "Dataset not exists."}) } }) mart.Get(API+"/datasets/?", func(req *http.Request, r render.Render) { var qs = req.URL.Query() var err error var max, limit int if max, err = strconv.Atoi(qs.Get("max")); err != nil { max = -1 } if limit, err = strconv.Atoi(qs.Get("limit")); err != nil { limit = 10 } if limit > 100 { limit = 100 } var dataType = qs.Get("data_type") var tagName = qs.Get("tag") var datasets = make([]backend.Dataset, 0) var q = engine.Desc("id") if max > -1 { q = q.Where("id < ?", max) } if tagName != "" { tag := &backend.Tag{Name: tagName} has, _ := engine.Get(tag) if !has { r.JSON(http.StatusNotFound, map[string]string{"err": "tag: " + tagName + " not found."}) return } q = q.And("tag_id = ?", tag.Id) } if dataType == "train" { q = q.And("data_type = ?", backend.TRAIN) } else if dataType == "val" { q = q.And("data_type = ?", backend.VAL) } q = q.Limit(limit) if err = q.Find(&datasets); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } for idx, dataset := range datasets { dataset.FillObject() datasets[idx] = dataset } r.JSON(http.StatusOK, map[string][]backend.Dataset{"datasets": datasets}) }) mart.Post(API+"/upload/?", binding.Bind(FileForm{}), func(form FileForm, r render.Render) { var err error var file *backend.File if file, err = backend.UploadFile(form.File); err != nil { r.JSON(http.StatusInternalServerError, map[string]interface{}{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]*backend.File{"file": file}) }) mart.Post(API+"/tags/?", binding.Bind(TagForm{}), func(form TagForm, r render.Render) { var err error var tag *backend.Tag if tag, err = backend.SaveTag(form.Tag); err != nil { r.JSON(http.StatusInternalServerError, map[string]interface{}{"err": err.Error()}) } r.JSON(http.StatusOK, map[string]*backend.Tag{"file": tag}) }) mart.Post(API+"/tags/(?P<tag_id>\\d+)/?", binding.Bind(TagForm{}), func(form TagForm, params martini.Params, r render.Render) { tagId, _ := strconv.Atoi(params["tag_id"]) var tag = new(backend.Tag) if has, err := engine.Id(tagId).Get(tag); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else if has { if tag.Name != form.Tag { tag.Name = form.Tag if _, err := engine.Id(tagId).Update(tag); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } } r.JSON(http.StatusOK, map[string]*backend.Tag{"tag": tag}) } else { r.JSON(http.StatusNotFound, map[string]string{"err": "Tag not exists."}) } }) mart.Get(API+"/tags/(?P<tag_id>\\d+)/?", func(params martini.Params, r render.Render) { tagId, _ := strconv.Atoi(params["tag_id"]) var tag = new(backend.Tag) if has, err := engine.Id(tagId).Get(tag); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else if has { r.JSON(http.StatusOK, map[string]*backend.Tag{"tag": tag}) } else { r.JSON(http.StatusNotFound, map[string]string{"err": "Tag not exists."}) } }) mart.Delete(API+"/tags/(?P<tag_id>\\d+)/?", func(params martini.Params, r render.Render) { tagId, _ := strconv.Atoi(params["tag_id"]) var tag = new(backend.Tag) if has, err := engine.Id(tagId).Get(tag); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } else if has { backend.DeleteTag(tag.Id) r.JSON(http.StatusOK, map[string]*backend.Tag{"tag": tag}) } else { r.JSON(http.StatusNotFound, map[string]string{"err": "Tag not exists."}) } }) mart.Get(API+"/tags/hint/?", func(req *http.Request, r render.Render) { var qs = req.URL.Query() var word = qs.Get("word") var q = engine.Desc("id") q = q.And("name like \"%" + word + "%\"") q = q.Limit(5) var tags = make([]backend.Tag, 0) var err = q.Find(&tags) log.Printf("err: %s\n", err) r.JSON(http.StatusOK, map[string][]backend.Tag{"tags": tags}) }) mart.Get(API+"/tags/?", func(req *http.Request, r render.Render) { var qs = req.URL.Query() var err error var max, limit int if max, err = strconv.Atoi(qs.Get("max")); err != nil { max = -1 } if limit, err = strconv.Atoi(qs.Get("limit")); err != nil { limit = 10 } if limit > 100 { limit = 100 } var tags = make([]backend.Tag, 0) var q = engine.Desc("id") if max > -1 { q = q.Where("id < ?", max) } q = q.Limit(limit) if err = q.Find(&tags); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) } r.JSON(http.StatusOK, map[string][]backend.Tag{"tags": tags}) }) mart.Post(API+"/solve/?", func(r render.Render) { caffe.Solve() r.JSON(http.StatusOK, caffe.LastStatus()) return }) mart.Get(API+"/solve/?", func(r render.Render) { r.JSON(http.StatusOK, caffe.LastStatus()) return }) mart.Delete(API+"/solve/?", func(r render.Render) { caffe.StopSolve() r.JSON(http.StatusOK, caffe.LastStatus()) return }) mart.Get(API+"/train.txt", func(r render.Render) { text, err := backend.ExportDataset(backend.TRAIN) if err != nil { r.Data(http.StatusInternalServerError, nil) return } r.Data(http.StatusOK, []byte(text)) }) mart.Get(API+"/val.txt", func(r render.Render) { text, err := backend.ExportDataset(backend.VAL) if err != nil { r.Data(http.StatusInternalServerError, nil) return } r.Data(http.StatusOK, []byte(text)) }) mart.Get(API+"/loss.png", func(r render.Render) { result, err := caffe.Plot("loss") if err != nil { r.Redirect("/static/images/loading.png") return } r.Data(http.StatusOK, result) return }) mart.Get(API+"/acc.png", func(r render.Render) { result, err := caffe.Plot("acc") if err != nil { r.Redirect("/static/images/loading.png") return } r.Data(http.StatusOK, result) return }) mart.Post(API+"/predict/?", binding.Bind(PredictForm{}), func(form PredictForm, r render.Render) { var err error var result caffe.PredictResult if len(form.ImgUrl) > 0 { result, err = caffe.PredictUrl(form.ImgUrl) } else { var source multipart.File if source, err = form.File.Open(); err == nil { defer source.Close() result, err = caffe.Predict(source) } } if err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, result) return }) mart.Post(API+"/predict/process/?", func(r render.Render) { if err := caffe.StartPredict(); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]string{}) return }) mart.Delete(API+"/predict/process/?", func(r render.Render) { if err := caffe.StopPredict(); err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]string{}) return }) mart.Get(API+"/proxy/?", func(req *http.Request, r render.Render) { var qs = req.URL.Query() var url = qs.Get("url") var resp *http.Response var err error if resp, err = http.Get(url); err != nil { r.Data(http.StatusNotFound, nil) return } defer resp.Body.Close() data, _ := ioutil.ReadAll(resp.Body) r.Data(http.StatusOK, data) return }) mart.Get(API+"/models", func(r render.Render) { modelNames, err := caffe.ListModels() if err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string][]string{"models": modelNames}) return }) mart.Get(API+"/models/current", func(r render.Render) { modelName, err := caffe.GetCurrentModel() if err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]string{"model": modelName}) return }) mart.Post(API+"/models/apply", binding.Bind(ModelForm{}), func(model ModelForm, r render.Render) { err := caffe.ApplyModel(model.ModelName) if err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]string{}) return }) mart.Delete(API+"/models/(?P<modelName>[^/]+.caffemodel)", func(params martini.Params, r render.Render) { err := caffe.RemoveModel(params["modelName"]) if err != nil { r.JSON(http.StatusInternalServerError, map[string]string{"err": err.Error()}) return } r.JSON(http.StatusOK, map[string]string{}) return }) }