func main() {

	r := gin.Default()
	r.Static("/assets", "assets")
	store := sessions.NewCookieStore([]byte("gssecret"))
	r.Use(sessions.Sessions("mysession", store))
	r.LoadHTMLGlob("templates/*")

	fc := new(FrontController)
	r.GET("/", fc.HomeCtr)
	r.GET("/about", fc.AboutCtr)
	r.GET("/view/:id", fc.ViewCtr)
	r.GET("/view.php", fc.ViewAltCtr)
	r.GET("/ping", fc.PingCtr)
	r.GET("/search", fc.SearchCtr)

	ac := new(AdminController)
	admin := r.Group("/admin")
	{
		admin.GET("/", ac.ListBlogCtr)
		admin.GET("/login", ac.LoginCtr)
		admin.POST("/login-process", ac.LoginProcessCtr)
		admin.GET("/logout", ac.LogoutCtr)
		admin.GET("/addblog", ac.AddBlogCtr)
		admin.POST("/save-blog-add", ac.SaveBlogAddCtr)
		admin.GET("/listblog", ac.ListBlogCtr)
		admin.GET("/deleteblog/:id", ac.DeleteBlogCtr)
		admin.POST("/save-blog-edit", ac.SaveBlogEditCtr)
		admin.GET("/editblog/:id", ac.EditBlogCtr)
	}
	// Listen and serve on 0.0.0.0:8080
	r.Run(":8080")
}

func Init() {
	if router == nil {
		gin.SetMode(gin.TestMode)
		router = gin.Default()
		templ := template.New("index")
		router.SetHTMLTemplate(templ)
		store := sessions.NewCookieStore([]byte("foundation"))
		router.Use(sessions.Sessions("foundation", store))
		portNo := 0
		go func() {
			router.GET("/", func(c *gin.Context) {
				shared = *c
			})

			for portNo = 8124; true; portNo++ {

				addr := fmt.Sprintf(`:%d`, portNo)
				err := router.Run(addr)
				if err != nil {
					if strings.HasSuffix(err.Error(), `address already in use`) {
						continue
					}
				}

				break
			}

		}()
		time.Sleep(50 * time.Millisecond)
		http.Get(fmt.Sprintf("http://localhost:%d/", portNo)) // portNoが0じゃなくなるまでwaitしたほうが良い気もするが一旦
	}
}

func init() {
	log.Logger.Info("init session ...")

	SessionStore = sessions.NewCookieStore([]byte("_IlikeUkeTravel.com_oyear"))

	log.Logger.Info("session inited")
}

func main() {
	r := gin.Default()
	store := sessions.NewCookieStore([]byte(helper.Cookiesecret))

	r.Use(sessions.Sessions("todo_session", store))

	r.LoadHTMLGlob("templates/*")

	r.GET("/todo", displayTodo)

	r.Run(":8200")
}

func Sessions() gin.HandlerFunc {
	switch conf.SESSION_STORE {
	case conf.REDIS:
		store, err := gin_sessions.NewRedisStore(10, "tcp", conf.REDIS_SERVER, conf.REDIS_PWD, []byte("secret"))
		if err != nil {
			panic(err)
		}
		return gin_sessions.Sessions("mysession", store)
	default:
		store := gin_sessions.NewCookieStore([]byte("secret"))
		return gin_sessions.Sessions("mysession", store)
	}
}

func main() {
	r := gin.Default()
	store := sessions.NewCookieStore([]byte(helper.Cookiesecret))

	r.Use(sessions.Sessions("todo_session", store))

	r.LoadHTMLGlob("templates/*")

	r.GET("/login", displayLogin)
	r.POST("/login", postLogin)
	r.GET("/user/:username", displayProfile)

	r.Run(":8100")
}

func Run(config *config.Config, etcd *store.Etcd) {
	oauthConf := oauth2.Config{
		ClientID:     config.GitHubClientID,
		ClientSecret: config.GitHubClientSecret,
		Scopes:       []string{"user", "read:public_key"},
		Endpoint:     githuboauth.Endpoint,
	}

	if config.ReleaseMode {
		gin.SetMode(gin.ReleaseMode)
	}

	sessionStore := sessions.NewCookieStore([]byte(config.SecretKeyBase))

	r := gin.Default()
	r.Use(sessions.Sessions(AppName, sessionStore))
	r.Static("/assets", "assets")
	r.LoadHTMLGlob("templates/*")

	rootController := controller.NewRootController(config, etcd)
	appController := controller.NewAppController(config, etcd)
	argController := controller.NewArgController(config, etcd)
	envController := controller.NewEnvController(config, etcd)
	healthcheckController := controller.NewHealthcheckController(config, etcd)
	sessionController := controller.NewSessionController(config, etcd, oauthConf)

	r.GET("/", rootController.Index)

	r.GET("/signin", sessionController.SignIn)
	r.GET("/signout", sessionController.SignOut)
	r.GET("/oauth/callback", sessionController.Callback)
	r.GET("/update-keys", sessionController.UpdateKeys)

	r.GET("/apps", appController.Index)
	r.POST("/apps", appController.New)

	r.GET("/apps/:appName", appController.Get)

	r.POST("/apps/:appName/build-args", argController.New)
	r.POST("/apps/:appName/build-args/delete", argController.Delete) // TODO: DELETE /apps/:appName/build-args

	r.POST("/apps/:appName/envs", envController.New)
	r.POST("/apps/:appName/envs/delete", envController.Delete) // TODO: DELETE /apps/:appName/envs
	r.POST("/apps/:appName/envs/upload", envController.Upload)

	r.POST("/apps/:appName/healthcheck", healthcheckController.Update)

	r.Run()
}

//setSessions initializes sessions & csrf middlewares
func setSessions(router *gin.Engine) {
	config := system.GetConfig()
	//https://github.com/gin-gonic/contrib/tree/master/sessions
	store := sessions.NewCookieStore([]byte(config.SessionSecret))
	store.Options(sessions.Options{HttpOnly: true, MaxAge: 7 * 86400}) //Also set Secure: true if using SSL, you should though
	router.Use(sessions.Sessions("gin-session", store))
	//https://github.com/utrack/gin-csrf
	router.Use(csrf.Middleware(csrf.Options{
		Secret: config.SessionSecret,
		ErrorFunc: func(c *gin.Context) {
			c.String(400, "CSRF token mismatch")
			c.Abort()
		},
	}))
}

func init() {
	gin.SetMode(gin.DebugMode)
	rand.Seed(time.Now().UnixNano())
	servidor = gin.Default()

	store := sessions.NewCookieStore([]byte("ef7fbfd3d599befe7a86cbf37c8f05c814dcad918b8dbefb441de846c4f62ea3"))
	servidor.Use(sessions.Sessions("mysession", store))

	cargarTemplates()
	servidor.Use(static.Serve("/", static.LocalFile("./public", false)))
	servidor.StaticFile("/login", "./public/index.html")
	servidor.NoRoute(func(c *gin.Context) {
		html.ExecuteTemplate(c.Writer, "404.html", nil)
	})
}

func NewRememberMe(engine *gin.Engine, cookieKey string, maxAge int, secret string) {

	rememberMeConf = RememberMeConf{
		CookieKey: cookieKey,
		MaxAge:    maxAge,
		Secret:    secret,
	}

	options := sessions.Options{
		Path:     "/",
		MaxAge:   rememberMeConf.MaxAge,
		HttpOnly: true,
	}
	cookieStore = sessions.NewCookieStore([]byte(rememberMeConf.Secret))
	cookieStore.Options(options)
}

// Setup the authorization path
func Setup(redirectURL, credFile string, scopes []string, secret []byte) {
	store = sessions.NewCookieStore(secret)
	var c Credentials
	file, err := ioutil.ReadFile(credFile)
	if err != nil {
		glog.Fatalf("[Gin-OAuth] File error: %v\n", err)
	}
	json.Unmarshal(file, &c)

	conf = &oauth2.Config{
		ClientID:     c.ClientID,
		ClientSecret: c.ClientSecret,
		RedirectURL:  redirectURL,
		Scopes:       scopes,
		Endpoint:     google.Endpoint,
	}
}

/*
 * Main function
 */
func main() {
	//fmt.Printf("Register function . Sqrt1(4) = %v\n", register.Sqrt1(4))

	r := gin.New()
	//	r := gin.Default()
	store := sessions.NewCookieStore([]byte("myappsecret"))
	r.Use(sessions.Sessions("mygroups", store))
	r.Use(Is_authorised())

	//r.LoadHTMLGlob("templates/*")

	templates := multitemplate.New()
	templates.AddFromFiles("home", "home.html", "header.html", "footer.html")
	templates.AddFromFiles("register", "register.html", "header.html", "footer.html")
	r.HTMLRender = templates

	//fmt.Println(register.Sqrt(2))
	//r.HTMLRender = loadTemplates("./templates")
	r.StaticFS("/css/", http.Dir("css"))
	r.StaticFS("/images/", http.Dir("images"))

	/*
		r.GET("/", func(c *gin.Context) {
			c.HTML(http.StatusOK,
				"home",
				gin.H{
					"Title": "Login Here",
				},
			)
		})
	*/

	r.GET("/", register.HomeHandler)
	r.POST("/", register.LoginHandler)
	r.POST("/register", register.RegisterHandler)
	r.GET("/register", func(c *gin.Context) {
		c.HTML(http.StatusOK,
			"register",
			gin.H{
				"Title": "New Registration",
			},
		)
	})
	r.Run(":8090")

}

func main() {
	r := gin.Default()
	store := sessions.NewCookieStore([]byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c *gin.Context) {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count += 1
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, gin.H{"count": count})
	})
	r.Run(":8000")
}

func main() {
	log.Printf("setting up gin ...")
	r := gin.Default()
	r.Static("/static", "static")
	r.LoadHTMLGlob("templates/*")

	log.Printf("setting up session store ...")
	store := sessions.NewCookieStore([]byte("secret"))
	r.Use(sessions.Sessions("whiskee", store))

	log.Printf("setting up database ...")
	r.Use(PostgresDatabase())

	log.Printf("setting up transloadit ...")
	r.Use(Transloadit())

	log.Printf("setting up routes ...")
	r.GET("/", HomeR)
	r.GET("/auth/callback", CallbackR)
	r.GET("/auth/logout", LogoutR)

	r.GET("/home", HomeR)
	r.GET("/whisky", WhiskyListR)
	r.GET("/whisky/:id", WhiskyR)
	r.GET("/user", UserListR)
	r.GET("/user/:id", UserR)

	r.GET("/add/whisky", AddWhiskyFormR)
	r.POST("/add/whisky", AddWhiskyR)
	r.GET("/edit/whisky/:id", EditWhiskyFormR)
	r.POST("/edit/whisky/:id", EditWhiskyR)

	r.POST("/add/review", AddReviewR)
	r.GET("/edit/review/:id", EditReviewFormR)
	r.POST("/edit/review/:id", EditReviewR)

	port := os.Getenv("PORT")
	log.Printf("listening on :%s", port)
	r.Run(":" + port)
}

func main() {
	// database
	mgoSession, err := mgo.Dial("128.199.130.44:27017")
	if err != nil {
		panic(err)
	}

	// register services
	userService := user.New(userStore.New(mgoSession, "example"))
	loginService := login.New(userService)
	registerService := register.New(userService)

	// create server
	r := render.New(render.Options{
		Directory:     "server/views",
		Layout:        "layout",
		Extensions:    []string{".html"},
		Delims:        render.Delims{"[[", "]]"},
		IsDevelopment: true,
	})

	g := gin.New()
	g.Use(cors.Middleware(cors.Config{
		Origins:         "*",
		Methods:         "GET, PUT, POST, DELETE",
		RequestHeaders:  "Origin, Content-Type",
		Credentials:     true,
		ValidateHeaders: false,
	}))
	g.Use(sessions.Sessions("webadmin", sessions.NewCookieStore([]byte("something-very-secret"))))
	g.Static("/assets", "./public")

	// register handlers
	NewUserHandlers(userService, r).RegisterHandlers(g)
	NewFrontendHandlers(loginService, registerService, r).RegisterHandlers(g)

	// run server
	g.Run(":3000")
}

func session(config *config.Config) (s sessions.Store, err error) {

	secret := []byte(config.UString("secret", "go-default-secret"))
	t := config.UString("type", "cookie")

	switch t {
	case "cookie":
		s = sessions.NewCookieStore(secret)
	case "redis":
		s, err = sessions.NewRedisStore(
			config.UInt("size"),
			config.UString("network"),
			config.UString("address"),
			config.UString("password"),
			secret,
		)
	default:
		err = errors.New("No session type allowed.")
	}

	if err != nil {
		return nil, err
	}

	o, _ := config.Get("options")

	if o != nil {
		s.Options(sessions.Options{
			Path:     o.UString("path"),
			Domain:   o.UString("domain"),
			MaxAge:   o.UInt("max_age", int(30*time.Minute)),
			Secure:   o.UBool("secure"),
			HttpOnly: o.UBool("http_only"),
		})
	}

	return s, nil
}

func main() {

	fmt.Println("Booting up the server....")
	gin.SetMode("release")
	r := gin.Default()

	r.Static("/static", "./public")

	//	store, _ := sessions.NewRedisStore(10, "tcp", "localhost:6379", "", []byte("secret"))
	//	r.Use(sessions.Sessions("__usid", store))
	store := sessions.NewCookieStore([]byte("secret"))
	r.Use(sessions.Sessions("__usid", store))

	ginext.LoadTemplates(r, "tpl")
	routes.SetRouters(r)

	// connect to as for global using
	setting := new(conf.Config)
	setting.LoadFromJson("./conf.json")

	dm.ConnectAS(setting.Aerospike.Host, setting.Aerospike.Port)

	r.Run(":8000")
}

func main() {
	s := db.Connect()
	defer db.Disconnect(s)
	craniumDB := db.SetDB(s)

	r := gin.Default()

	// Set up Gin cookies
	store := sessions.NewCookieStore([]byte("pladjamaicanwifflepoof"))
	r.Use(sessions.Sessions("cranium_session", store))

	var title string

	var de model.DataEntry

	r.LoadHTMLGlob("templates/*")
	r.Static("/assets", "./assets")

	// Routes
	r.GET("/", func(c *gin.Context) {
		session := sessions.Default(c)
		craniumId := session.Get("cranium_id")
		if craniumId == nil {
			// Insert a new user if the user has no cookie
			newCraniumId := randomString(30)
			db.InsertNewVisitor(craniumDB, newCraniumId)
			session.Set("cranium_id", newCraniumId)
			session.Save()
			title = newCraniumId
			readfile, _ := os.Open("templates/index-tmpl.html")
			outfile, _ := os.Create("templates/index.html")
			defer readfile.Close()
			defer outfile.Close()
			// Get all the Ids for tags in question
			aImpIds, pImpIds, imgImpIds, aNimpIds, pNimpIds, imgNimpIds := preprocess.GenerateTags(readfile, outfile)
			var atags []model.Atag
			var ptags []model.Ptag
			var imgtags []model.Imgtag

			for _, impId := range aImpIds {
				atag := model.AtagDefault
				atag.Id = impId
				atag.Important = true
				atags = append(atags, atag)
			}
			for _, impId := range pImpIds {
				ptag := model.PtagDefault
				ptag.Id = impId
				ptag.Important = true
				ptags = append(ptags, ptag)
			}
			for _, impId := range imgImpIds {
				imgtag := model.ImgtagDefault
				imgtag.Id = impId
				imgtag.Important = true
				imgtags = append(imgtags, imgtag)
			}
			for _, impId := range aNimpIds {
				atag := model.AtagDefault
				atag.Id = impId
				atag.Important = false
				atags = append(atags, atag)
			}
			for _, impId := range pNimpIds {
				ptag := model.PtagDefault
				ptag.Id = impId
				ptag.Important = false
				ptags = append(ptags, ptag)
			}
			for _, impId := range imgNimpIds {
				imgtag := model.ImgtagDefault
				imgtag.Id = impId
				imgtag.Important = false
				imgtags = append(imgtags, imgtag)
			}
			de = db.InsertNewDataEntry(craniumDB, newCraniumId, atags, ptags, imgtags)
		} else {
			readfile, _ := os.Open("templates/index-tmpl.html")
			outfile, _ := os.Create("templates/index.html")
			defer readfile.Close()
			defer outfile.Close()
			// Get all the Ids for tags in question
			preprocess.GenerateTags(readfile, outfile)
			// The user already exists, so ask the database for attributes
			title = craniumId.(string)
			visitor := db.FetchVisitor(craniumDB, craniumId.(string))
			de = visitor.Data[len(visitor.Data)-1]
		}
		craniumcss := cssgen.GenCss(de)
		c.HTML(http.StatusOK, "index.html", gin.H{
			"title":      "cranium.css | " + title,
			"craniumcss": template.CSS(craniumcss),
		})
	})

	type Entities struct {
		Data string `json:"data" binding:"required"`
	}

	r.POST("/data", func(c *gin.Context) {
//.........这里部分代码省略.........

func Serve(s *server.Server) {
	config, err := NewConfigFromJSON(options.ConfigFile)
	if err != nil {
		log.Fatal("no config file")
	}

	gauthConfig := server.GoogleAuthConfig(config.GAuthKeyFile, options.Debug)
	goth.UseProviders(
		twitter.New(config.TwitterApiKey, config.TwitterApiSecret, config.TwitterApiCallback),
		gplus.New(gauthConfig.ClientID, gauthConfig.ClientSecret, gauthConfig.RedirectURL),
	)
	providers := goth.GetProviders()
	providers["google"] = providers["gplus"]

	// Assign the GetState function variable so we can return the
	// state string we want to get back at the end of the oauth process.
	// Only works with facebook and gplus providers.
	gothic.GetState = func(req *http.Request) string {
		// Get the state string from the query parameters.
		return req.URL.Query().Get("next")
	}

	r := gin.Default()
	r.HTMLRender = NewRender()
	// session
	store := sessions.NewCookieStore([]byte(options.SecretKey))
	r.Use(sessions.Sessions("ffsession", store))

	// Serve static assets
	if options.Debug {
		log.Println("==> debug mode")
		r.Static("/static", "./static")
	} else {
		r.GET("/static/*path", AssetHandler)
	}

	// oauth2
	r.GET("/auth/:provider/callback", s.AuthCallback)
	r.GET("/auth/:provider", server.AuthProvider)

	// authed
	authorized := r.Group("/account", server.LoginRequired())
	{
		authorized.GET("/", s.AccountHandler)
		authorized.GET("/import/", s.ImportHandler)
		// authorized.POST("/ffimport/", s.FriendFeedImportHandler)
		authorized.GET("/import/twitter", s.TwitterImportHandler)
		// TODO: fix get
		authorized.GET("/service/:service/delete", s.DeleteServiceHandler)
	}

	r.GET("/", s.HomeHandler)
	r.GET("favicon.ico", FaviconHandler)
	r.GET("/logout", server.LogoutHandler)

	// TODO: httproute not support "/:name" to catch all
	// see: gin #205
	r.GET("/feed/:name", s.FeedHandler)
	r.GET("/e/:uuid", s.EntryHandler)

	r.GET("/a/entry/:uuid", s.ExpandCommentHandler)
	r.GET("/a/expandlikes/:uuid", s.ExpandLikeHandler)
	action := r.Group("/a", server.LoginRequired())
	{
		action.POST("/share", s.EntryPostHandler)
		action.POST("/like", s.LikeHandler)
		action.POST("/like/delete", s.LikeDeleteHandler)
		action.POST("/comment", s.CommentHandler)
		action.POST("/comment/delete", s.CommentDeleteHandler)
	}

	r.GET("/public", s.PublicHandler)

	r.NotFound404(NotFoundHandler)

	fmt.Println("Starting server...")
	r.Run(fmt.Sprintf(":%v", options.Port))
}

func main() {
	// database setting
	user := os.Getenv("ISHOCON1_DB_USER")
	pass := os.Getenv("ISHOCON1_DB_PASSWORD")
	dbname := "ishocon1"
	db, _ = sql.Open("mysql", user+":"+pass+"@/"+dbname)
	db.SetMaxIdleConns(5)

	r := gin.Default()
	// load templates
	r.Use(static.Serve("/css", static.LocalFile("public/css", true)))
	r.Use(static.Serve("/images", static.LocalFile("public/images", true)))
	layout := "templates/layout.tmpl"

	// session store
	store := sessions.NewCookieStore([]byte("showwin_happy"))
	store.Options(sessions.Options{HttpOnly: true})
	r.Use(sessions.Sessions("mysession", store))

	// GET /login
	r.GET("/login", func(c *gin.Context) {
		session := sessions.Default(c)
		session.Clear()
		session.Save()

		tmpl, _ := template.ParseFiles("templates/login.tmpl")
		r.SetHTMLTemplate(tmpl)
		c.HTML(http.StatusOK, "login", gin.H{
			"Message": "ECサイトで爆買いしよう！！！！",
		})
	})

	// POST /login
	r.POST("/login", func(c *gin.Context) {
		email := c.PostForm("email")
		pass := c.PostForm("password")

		session := sessions.Default(c)
		user, result := authenticate(email, pass)
		if result {
			// 認証成功
			session.Set("uid", user.ID)
			session.Save()

			user.UpdateLastLogin()

			c.Redirect(http.StatusSeeOther, "/")
		} else {
			// 認証失敗
			tmpl, _ := template.ParseFiles("templates/login.tmpl")
			r.SetHTMLTemplate(tmpl)
			c.HTML(http.StatusOK, "login", gin.H{
				"Message": "ログインに失敗しました",
			})
		}
	})

	// GET /logout
	r.GET("/logout", func(c *gin.Context) {
		session := sessions.Default(c)
		session.Clear()
		session.Save()

		tmpl, _ := template.ParseFiles("templates/login.tmpl")
		r.SetHTMLTemplate(tmpl)
		c.Redirect(http.StatusFound, "/login")
	})

	// GET /
	r.GET("/", func(c *gin.Context) {
		cUser := currentUser(sessions.Default(c))

		page, err := strconv.Atoi(c.Query("page"))
		if err != nil {
			page = 0
		}
		products := getProductsWithCommentsAt(page)
		// shorten description and comment
		var sProducts []ProductWithComments
		for _, p := range products {
			if utf8.RuneCountInString(p.Description) > 70 {
				p.Description = string([]rune(p.Description)[:70]) + "…"
			}

			var newCW []CommentWriter
			for _, c := range p.Comments {
				if utf8.RuneCountInString(c.Content) > 25 {
					c.Content = string([]rune(c.Content)[:25]) + "…"
				}
				newCW = append(newCW, c)
			}
			p.Comments = newCW
			sProducts = append(sProducts, p)
		}

		r.SetHTMLTemplate(template.Must(template.ParseFiles(layout, "templates/index.tmpl")))
		c.HTML(http.StatusOK, "base", gin.H{
			"CurrentUser": cUser,
			"Products":    sProducts,
		})
//.........这里部分代码省略.........