func main() {
flag.StringVar(&repoPrefix, "prefix", "", "The repo name prefix required in order to build.")
flag.Parse()
if repoPrefix == "" {
log.Fatal("Specify a prefix to look for in the repo names with -prefix='name'")
}
if f, err := os.Stat(sourceBase); f == nil || os.IsNotExist(err) {
log.Fatalf("The -src folder, %s, doesn't exist.", sourceBase)
}
if f, err := os.Stat(destBase); f == nil || os.IsNotExist(err) {
log.Fatalf("The -dest folder, %s, doesn't exist.", destBase)
}
if dbConnString != "" {
InitDatabase()
}
goji.Get("/", buildsIndexHandler)
goji.Get("/:name/:repo_tag", buildsShowHandler)
goji.Post("/_github", postReceiveHook)
goji.Serve()
}
func Start(conn *CGRConnector, user, pass string) {
connector = conn
username = user
password = pass
templates = template.Must(template.ParseGlob("templates/*.tmpl"))
rpc.Register(conn)
goji.Get(LOGIN_PATH, loginGet)
goji.Post(LOGIN_PATH, loginPost)
goji.Get("/app/*", http.FileServer(http.Dir("./static")))
auth := web.New()
goji.Handle("/*", auth)
auth.Use(SessionAuth)
auth.Handle("/ws", websocket.Handler(func(ws *websocket.Conn) {
jsonrpc.ServeConn(ws)
}))
auth.Post("/import/", importPost)
auth.Post("/exportcdrs/", exportCdrsPost)
auth.Post("/exporttpcsv/", exportTpToCsvPost)
auth.Get("/accounts/logout", logoutGet)
auth.Get("/", http.RedirectHandler("/app/", 301))
}
func main() {
// setup genmai
db, err := genmai.New(&genmai.SQLite3Dialect{}, ":memory:")
if err != nil {
log.Fatalln(err)
}
if err := db.CreateTableIfNotExists(&NodeInfo{}); err != nil {
log.Fatalln(err)
}
// setup pongo
pongo2.DefaultSet.SetBaseDirectory("templates")
fantasy := &Fantasy{
DB: db,
}
pongo2.Globals["Fantasy"] = fantasy
// setup goji
goji.Use(func(c *web.C, h http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
c.Env["Fantasy"] = fantasy
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
})
goji.Get("/", index)
goji.Post("/create", create)
goji.Get("/console/:id", console)
goji.Get("/assets/*", http.FileServer(http.Dir(".")))
goji.Serve()
}
func main() {
goji.Get("/", root)
goji.Get("/slow", slow)
goji.Get("/bad", bad)
goji.Get("/timeout", timeout)
goji.Serve()
}
func routing() {
///// Website /////
goji.Get("/", Index)
/////API///////
//inscription
goji.Post("/api/signup", Signup)
//connexion
goji.Post("/api/signin", Signin)
//creation de poste
goji.Post("/api/post", CreatePost)
//obtenir ses propres posts
goji.Get("/api/post", GetOwnPosts)
//obtenir un post par son id
goji.Get("/api/post/:id", GetPost)
//obtenir une liste de post par le login
goji.Get("/api/:login/post", GetUserPosts)
//suppresion d'un poste
goji.Delete("/api/post/:id", DeletePost)
//comfirmation de l'email si le fichier app.json est configuré pour
if models.Conf.Status == "prod" || models.Conf.EmailCheck == true {
goji.Get("/comfirmation", Comfirmation)
}
}
func main() {
Logger.Formatter = new(logrus.JSONFormatter)
// init
db := InitDatabase("./myapp.db")
defer db.Close()
// middleware
goji.Use(func(c *web.C, h http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
c.Env["DB"] = db
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
})
goji.Use(glogrus.NewGlogrus(Logger, "myapp"))
goji.Use(middleware.Recoverer)
goji.Use(middleware.NoCache)
goji.Use(SetProperties)
// handlers
goji.Get("/users/", ListUsers)
goji.Get(regexp.MustCompile(`/users/(?P<name>\w+)$`), GetUser)
goji.Get("/*", AllMatchHandler)
goji.Post(regexp.MustCompile(`/users/(?P<name>\w+)$`), RegisterUser)
goji.Put("/users/:name", UpdateUserInfo)
goji.Delete("/users/:name", DeleteUserInfo)
goji.Serve()
}
func main() {
//setup sessions
/*
sh := redis.NewSessionHolder()
redisconfig := viper.GetStringMapString("redis")
if _, ok := redisconfig["host"]; !ok {
panic("failed to read redis host")
}
if _, ok := redisconfig["port"]; !ok {
panic("failed to read redis port")
}
redisip, err := alias2ipaddr(redisconfig["host"])
if err != nil {
panic("failed to lookup redis IP address")
}
goji.Use(redis.BuildRedis(fmt.Sprintf("%s:%s", redisip, redisconfig["port"])))
goji.Use(base.BuildSessionMiddleware(sh))
*/
c := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
})
goji.Use(c.Handler)
//setup render middleware
goji.Use(middleware.RenderMiddleware)
//setup database
/*
dbconfig := viper.GetStringMapString("db")
if _, ok := dbconfig["host"]; !ok {
panic("failed to read db host")
}
if _, ok := dbconfig["name"]; !ok {
panic("failed to read db name")
}
goji.Use(middleware.PostgresMiddleware)
goji.Use(middleware.AuthMiddleware)
*/
//setup routes
goji.Get("/home", controllers.IndexHandler)
goji.Get("/healthcheck", controllers.HealthCheckHandler)
goji.Get("/login", controllers.Login)
goji.Get("/oauth2callback", controllers.OAuth2Callback)
//goji.Get("/logout", controllers.Logout)
//setup static assets
goji.Use(gojistatic.Static("/go/src/bower_components", gojistatic.StaticOptions{SkipLogging: true, Prefix: "bower_components"}))
goji.Use(gojistatic.Static("/go/src/frontend/js", gojistatic.StaticOptions{SkipLogging: true, Prefix: "js"}))
//begin
log.Info("Starting App...")
flag.Set("bind", ":80")
goji.Serve()
}
func main() {
kiiApp := models.KiiApp{AppID: "1ef175ad", AppKey: "2a0ed4f8a93d83d9ff3991f75087602d"}
userCtl := controllers.NewUserController(kiiApp)
eventCtl := controllers.NewEventController(kiiApp)
likeCtl := controllers.NewLikeController(kiiApp)
// Create User
goji.Post(VERSION+"/user/create", userCtl.CreateUser)
// Login User
goji.Post(VERSION+"/user/login", userCtl.LoginUser)
// Get Login User Info
goji.Get(VERSION+"/user/me", userCtl.Me)
// Create Event
goji.Post(VERSION+"/event", eventCtl.CreateEvent)
// Delete Event
goji.Post(VERSION+"/event/delete", eventCtl.DeleteEvent)
// Get Event
goji.Get(VERSION+"/events", eventCtl.GetEvents)
// Add Visit Number
goji.Post(VERSION+"/event/visit", eventCtl.Visit)
// Add Like
goji.Post(VERSION+"/like", likeCtl.AddLike)
goji.Serve()
}
func main() {
rand.Seed(time.Now().UnixNano())
goji.Get("/slow", slow)
goji.Get("/bad", bad)
goji.Get("/timeout", timeout)
goji.Serve()
}
func main() {
flag.Parse()
// Initialize db.
var db db.DB
if err := db.Open(*dbFile, 0600); err != nil {
log.Fatal(err)
}
defer db.Close()
// Initialize wiki.
w, err := wiki.NewWiki(&db)
if err != nil {
log.Fatal(err)
}
if *loggerEnabled != true {
goji.Abandon(middleware.Logger)
}
// Setup up the routes for the wiki
goji.Get("/", w.Show)
goji.Get("/:name", w.Show)
goji.Get("/:name/", w.RedirectToShow)
goji.Get("/:name/edit", w.Edit)
goji.Post("/:name", w.Update)
// Start the web server
goji.Serve()
}
func main() {
var cfg Config
stderrBackend := logging.NewLogBackend(os.Stderr, "", 0)
stderrFormatter := logging.NewBackendFormatter(stderrBackend, stdout_log_format)
logging.SetBackend(stderrFormatter)
logging.SetFormatter(stdout_log_format)
if cfg.ListenAddr == "" {
cfg.ListenAddr = "127.0.0.1:63636"
}
flag.Set("bind", cfg.ListenAddr)
log.Info("Starting app")
log.Debug("version: %s", version)
webApp := webapi.New()
goji.Get("/dns", webApp.Dns)
goji.Post("/dns", webApp.Dns)
goji.Get("/isItWorking", webApp.Healthcheck)
goji.Post("/redir/batch", webApp.BatchAddRedir)
goji.Post("/redir/:from/:to", webApp.AddRedir)
goji.Delete("/redir/:from", webApp.DeleteRedir)
goji.Get("/redir/list", webApp.ListRedir)
//_, _ = api.New(api.CallbackList{})
goji.Serve()
}
func main() {
createDB()
goji.Get("/api/posts/", readPosts)
goji.Post("/api/posts/", insertPost)
goji.Get("/*", http.FileServer(http.Dir("./static/")))
goji.Serve()
}
func StartWebServer(bind, auth string) error {
err := loadTemplates()
if err != nil {
return err
}
if auth != "" {
authParts := strings.Split(auth, ":")
goji.Use(httpauth.SimpleBasicAuth(authParts[0], authParts[1]))
}
goji.Get("/", homeRoute)
goji.Get("/status", statusRoute)
goji.Get("/robots.txt", robotsRoute)
goji.Get("/setEnabled", setEnabledRoute)
goji.Handle("/config", configRoute)
listener, err := net.Listen("tcp", bind)
if err != nil {
return err
}
goji.ServeListener(listener)
return nil
}
func startApi(n ApiConfigurationNetwork) {
apiListener, err := net.Listen("tcp", fmt.Sprintf("%v:%v", n.BindIP, n.BindPort))
if err != nil {
panic(err)
}
// Adding items:
goji.Post("/food/add", routeAddFood)
// Getting items
goji.Get("/food/get/all", routeGetFoodAll)
goji.Get("/food/get/id/:id", routeGetFoodById)
goji.Get("/food/get/date/:year/:month/:day", routeGetFoodByDate)
// goji.Get("/food/get/name/:name", routeGetFoodByName)
// Removing items
goji.Delete("/food/delete/id/:id", routeDeleteFoodById)
goji.Delete("/food/delete/name/:name", routeDeleteFoodByName)
// Updating items
// goji.Put("/food/edit/id/:id", routeUpdateItemById)
// goji.Put("/food/edit/name/:name", routeUpdateItemByName)
goji.Get("/food/email/today", routeEmailSendToday)
goji.ServeListener(apiListener)
}
func WebServer(ip string, port int) {
goji.Get("/", func(c web.C, w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Welcome to the home page!")
})
goji.Get("/search", func(c web.C, w http.ResponseWriter, r *http.Request) {
filter := db.Filter{}
options := &db.Options{}
r.ParseForm()
startDate := r.Form.Get("startDate")
endDate := r.Form.Get("endDate")
if startDate != "" {
filter.StartDate = startDate
}
if endDate != "" {
filter.EndDate = endDate
}
order := r.Form["orderby"]
options.Sort = order
var results []db.DbObject
db.Db.Find(&filter, options, &results)
jsonResults, err := json.Marshal(results)
if err != nil {
fmt.Fprint(w, err)
return
}
fmt.Fprintf(w, "%s", string(jsonResults))
})
goji.Get("/call/:id", func(c web.C, w http.ResponseWriter, r *http.Request) {
callId := c.URLParams["id"]
fmt.Print(callId)
filter := db.NewFilter()
options := &db.Options{}
filter.Equals["callid"] = callId
var results []db.DbObject
db.Db.Find(&filter, options, &results)
jsonResults, err := json.Marshal(results)
if err != nil {
fmt.Fprint(w, err)
return
}
fmt.Fprintf(w, "%s", string(jsonResults))
})
goji.Serve()
}
func Include() {
goji.Get("/", controllers.Home)
// API
goji.Get("/api/godocstats", controllers.GodocStats)
goji.Get("/api/github/stars", controllers.GithubRepoStarsHistory)
}
func main() {
// Construct the dsn used for the database
dsn := os.Getenv("DATABASE_USERNAME") + ":" + os.Getenv("DATABASE_PASSWORD") + "@tcp(" + os.Getenv("DATABASE_HOST") + ":" + os.Getenv("DATABASE_PORT") + ")/" + os.Getenv("DATABASE_NAME")
// Construct a new AccessorGroup and connects it to the database
ag := new(accessors.AccessorGroup)
ag.ConnectToDB("mysql", dsn)
// Constructs a new ControllerGroup and gives it the AccessorGroup
cg := new(controllers.ControllerGroup)
cg.Accessors = ag
c := cron.New()
c.AddFunc("0 0 20 * * 1-5", func() { // Run at 2:00pm MST (which is 21:00 UTC) Monday through Friday
helpers.Webhook(helpers.ReportLeaders(ag))
})
c.Start()
goji.Get("/health", cg.Health)
goji.Get("/leaderboard", cg.ReportLeaders)
goji.Post("/slack", cg.Slack) // The main endpoint that Slack hits
goji.Post("/play", cg.User)
goji.Post("/portfolio", cg.Portfolio)
goji.Get("/check/:symbol", cg.Check)
goji.Post("/buy/:quantity/:symbol", cg.Buy)
goji.Post("/sell/:quantity/:symbol", cg.Sell)
goji.Serve()
}
func main() {
render := render.New(render.Options{
Directory: "src/views",
Extensions: []string{".html"},
})
http.HandleFunc("/img/", serveResource)
http.HandleFunc("/css/", serveResource)
http.HandleFunc("/js/", serveResource)
goji.Get("/hello/:name", func(c web.C, w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %s!", c.URLParams["name"])
})
goji.Get("/wow", func(c web.C, w http.ResponseWriter, r *http.Request) {
render.HTML(w, http.StatusOK, "index", nil)
})
goji.Get("/bar", func(c web.C, w http.ResponseWriter, r *http.Request) {
render.HTML(w, http.StatusOK, "bar", nil)
})
goji.Get("/", func(c web.C, w http.ResponseWriter, r *http.Request) {
render.HTML(w, http.StatusOK, "index", nil)
})
goji.Serve()
}
func setupAndServe() {
goji.Post("/state", post)
goji.Get("/state/:id", get)
goji.Get("/target", target)
goji.Get("/inputs", inputs)
goji.Serve()
}
func main() {
var dumpConf bool
var confFile string
flag.BoolVar(&dumpConf, "dumpconf", false, "dump the default configuration file")
flag.StringVar(&confFile, "conf", "", "use this alternative configuration file")
flag.Parse()
stdoutLogger = log.New(os.Stderr, "", log.Flags())
if dumpConf {
dumpDefaultConf()
return
}
rand.Seed(time.Now().Unix())
if confFile != "" {
setConf(confFile)
}
if conf.RealIP {
goji.Insert(middleware.RealIP, middleware.Logger)
}
goji.Get("/", root)
goji.Get("/:id", getPaste)
goji.Post("/", createPaste)
goji.Serve()
}
func main() {
goji.Get("/", home)
goji.Get("/script/ajax.php", ajax)
goji.Get("/assets/*", http.FileServer(FS(false)))
goji.Serve()
}
func initServer(conf *configuration.Configuration, conn *zk.Conn, eventBus *event_bus.EventBus) {
stateAPI := api.StateAPI{Config: conf, Zookeeper: conn}
serviceAPI := api.ServiceAPI{Config: conf, Zookeeper: conn}
eventSubAPI := api.EventSubscriptionAPI{Conf: conf, EventBus: eventBus}
conf.StatsD.Increment(1.0, "restart", 1)
// Status live information
goji.Get("/status", api.HandleStatus)
// State API
goji.Get("/api/state", stateAPI.Get)
// Service API
goji.Get("/api/services", serviceAPI.All)
goji.Post("/api/services", serviceAPI.Create)
goji.Put("/api/services/:id", serviceAPI.Put)
goji.Delete("/api/services/:id", serviceAPI.Delete)
goji.Post("/api/marathon/event_callback", eventSubAPI.Callback)
// Static pages
goji.Get("/*", http.FileServer(http.Dir("./webapp")))
registerMarathonEvent(conf)
goji.Serve()
}
func ServeSchedulerAPI(address string, port int) string {
goji.Get("/whampire_executor", http.FileServer(http.Dir("./executor")))
goji.Get("/api/url", listUrls)
goji.Get("/api/snapshots", listSnapshots)
flag.Set("bind", fmt.Sprintf(":%d", port))
go goji.Serve()
return fmt.Sprintf("http://%s:%d/whampire_executor", address, port)
}
func main() {
goji.Use(negotiatormw)
goji.Get("/", appHandler(homeHandler))
goji.Get("/oneoffnegotiator", appHandler(customHandler))
goji.Get("/multinegotiator", appHandler(multiNegotiatorHandler))
goji.Get("/multinegotiatoragain", appHandler(multiNegotiatorHandlerAgain))
goji.Serve()
}
func InitRoutes() {
goji.Get("/users", UserList)
goji.Get("/users/:id", UserView)
goji.Delete("/users/:id", UserDelete)
goji.Post("/users", UserCreate)
goji.Put("/users/:id", UserUpdate)
goji.Get("/", Index)
}
func main() {
http.HandleFunc(template.STATIC_URL, template.StaticHandler)
goji.Get("/", Home)
goji.Get("/about", About)
goji.NotFound(NotFound)
goji.Serve()
}
func main() {
goji.Get("/todo", todos)
goji.Post("/todo/newTodo", newTodo)
goji.Get("/todo:id", getTodo)
goji.Put("/todo:id", putTodo)
goji.Delete("/todo:id", delTodo)
goji.Serve()
}
func main() {
goji.Get("/recipes/:id", getRecipes)
goji.Get("/recipes", getAllRecipes)
goji.Delete("/recipes/:id", deleteRecipe)
goji.Put("/recipes", putRecipe)
goji.Serve()
}
func Include() {
goji.Get("/", controllers.Home)
goji.Get("/about", controllers.About)
// Bookmarks app
bookmarks := web.New()
routes.Bookmarks(bookmarks)
}
func main() {
goji.Get("/bind/:name", hello)
goji.Get("/yuck/:name", hello)
goji.Get("/none/:name", hello)
goji.Get("/bye/:name", hello)
goji.Get("/hello/:name", hello)
goji.Serve()
}