Example #1
0
func HandleIndex(r render.Render) {
	tip := models.Tips{}

	db := GetDBInstance()
	total, err := db.C("tips").Count()

	if err != nil || total == 0 {
		r.HTML(200, "500", nil)
		return
	}

	index := getRandomIndex(total)

	if index == total {
		index = total - 1
	}

	db.C("tips").Find(nil).Skip(index).One(&tip)

	if db.Session != nil {
		defer db.Session.Close()
	}

	r.HTML(200, "index", map[string]interface{}{
		"Comment": tip.Comment,
		"Content": tip.Content,
		"Id":      tip.Id.Hex(),
		"IsIndex": true})
}
Example #2
0
func popularLinks(r render.Render) {
	links, err := store.Popular()

	if err != nil {
		log.WithField("package", "web").Error(err)

		r.JSON(500, map[string]string{
			"error": err.Error(),
		})

		return
	}

	var formattedLinks []map[string]interface{}

	for _, link := range links {
		formattedLinks = append(formattedLinks, map[string]interface{}{
			"id":    link.ID(),
			"title": link.Title,
			"url":   link.URL,
			"score": link.Score,
		})
	}

	r.JSON(200, formattedLinks)
}
Example #3
0
func HandleCreateIRLMoji(r render.Render, bindErr binding.Errors, im models.IRLMoji, db *models.DB, backchannel Backchannel) {
	if bindErr.Count() > 0 {
		r.JSON(400, JsonErrBinding(bindErr))
		return
	}

	if backchannel.UserId() == "" {
		r.JSON(403, JsonErr("The provided credentials were invalid."))
		return
	}

	user, err := db.GetUserWithId(backchannel.UserId())
	if err != nil {
		r.JSON(403, "Could not find a user with your credentials.")
		return
	}

	// Now let's create that user, shall we?
	insertedIM, err := db.InsertIM(user.Id, im.Emoji, im.Picture)
	if err != nil {
		log.Println("Error creating user:"******"Sorry, an internal server error has occurred."))
		return
	}

	r.JSON(200, map[string]*models.IRLMoji{"irlmoji": insertedIM})
}
func ArticlesIndex(r render.Render) {

	hal := HAL{}

	hal.Links = map[string]Link{
		"self": Link{"/articles", false},
		"show": Link{"/articles/{id}", true},
	}

	//result := []Todo{}
	//
	//rows, err := rethink.Table("todos").Run(session)
	//if err != nil {
	//    log.Println(err)
	//}
	//
	//for rows.Next() {
	//    var t Todo
	//    err := rows.Scan(&t)
	//    if err != nil {
	//        log.Println(err)
	//    }
	//    result = append(result, t)
	//}
	//r.JSON(200, result)

	//r.JSON(200, "hello")

	r.JSON(200, hal)

}
Example #5
0
// Called on a POST to /events/:id/comments
// Assuming valid comment; Adds the comment under the given id
func AddComment(db *mgo.Database, r render.Render, comment models.Comment, p martini.Params) {
	var eventId bson.ObjectId

	// Create a unique id
	comment.Id = bson.NewObjectId()

	if bson.IsObjectIdHex(p["event_id"]) {
		eventId = bson.ObjectIdHex(p["event_id"])
	} else {
		r.JSON(400, "Bad Request: Invalid Event ID")
		return
	}

	comment.EventId = eventId

	// TODO Should be the user Id
	comment.CreatedBy = bson.NewObjectId()
	comment.CreatedAt = time.Now().UTC()

	err := db.C("comments").Insert(comment)
	if err != nil {
		panic(err)
	}

	r.JSON(201, comment)
}
Example #6
0
func HandleRandomJsonTip(r render.Render) {

	db := GetDBInstance()
	tip := models.Tips{}
	api := models.API{}
	total, _ := db.C("tips").Count()
	index := getRandomIndex(total)
	db.C("tips").Find(nil).Skip(index).One(&tip)
	err := db.C("apis").Find(bson.M{"type": "json"}).One(&api)

	api.Count++

	if err != nil {
		db.C("apis").Insert(&models.API{Id: bson.NewObjectId(), Type: "json", Count: 0})
	} else {
		db.C("apis").Update(bson.M{"type": "json"}, bson.M{"type": "json", "count": api.Count})
	}

	data, err := json.Marshal(api)

	if err == nil {
		sendAll(data)
	}

	if db.Session != nil {
		defer db.Session.Close()
	}

	r.JSON(200, tip)
}
func SearchAnswersNew(r render.Render, db *mgo.Database, req *http.Request, session sessions.Session) {
	lastGameIdSearched := session.Get("last_game_id_searched")

	templateData := map[string]interface{}{"metatitle": "Battle Answers", "currentPath": req.URL.Path,
		"lastGameIdSearched": lastGameIdSearched, "games": models.GetGameRecs(db, nil)}
	r.HTML(200, "search_answers/new", templateData)
}
func handleTemplate(r render.Render, req *http.Request, t Template, s ServerList) {
	tmpl_data := make(map[string]interface{})
	tmpl_data["title"] = t.Title
	tmpl_data["server"] = getServerInfo(req, s)

	r.HTML(200, t.Tmpl, tmpl_data)
}
Example #9
0
func EventListHandler(r render.Render) {

	search := bson.M{"data.start_time": bson.M{"$gte": time.Now()}}
	sort := "data.start_time"
	var results []Event
	err := db.Find(&Event{}, search).Sort(sort).All(&results)
	if err != nil && err != mgo.ErrNotFound {
		panic(err)
	}

	if err == mgo.ErrNotFound {
		fmt.Println("No such object in db. Redirect")
		//http.Redirect(w, r, "/404/", http.StatusFound)
		return
	}

	type templateData struct {
		Context *conf.Context
		Events  []Event
	}

	data := templateData{conf.DefaultContext(conf.Config), results}

	r.HTML(200, "event_list", data)

}
Example #10
0
func getDrop(params martini.Params, db *database.Database, r render.Render) {
	d, err := db.GetDrop(params["url"])
	if err != nil {
		r.JSON(500, map[string]interface{}{"error": err.Error()})
	} else {
		r.JSON(200, map[string]interface{}{"drop": d})
	}
}
Example #11
0
File: posts.go Project: judg3/blog
func GetPost(params martini.Params, r render.Render) {
	hd := services.GetDb()

	var results []models.Posts
	hd.Where("id", "=", params["id"]).Limit(1).Find(&results)

	r.JSON(200, results)
}
func ProjectGet(db gorm.DB, r render.Render, params martini.Params) {
	var project models.Project
	if err := db.First(&project, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Project not found"})
		return
	}
	r.JSON(http.StatusOK, project)
}
Example #13
0
File: posts.go Project: judg3/blog
func ListPosts(params martini.Params, r render.Render) {
	hd := services.GetDb()

	var results []models.Posts
	hd.Find(&results)

	r.JSON(200, results)
}
Example #14
0
func removeHero(db HeroDB, parms martini.Params, r render.Render) {
	u := (db).(*heroDB)
	id, _ := strconv.Atoi(parms["id"])

	delete(u.heros, id)

	r.JSON(http.StatusOK, nil)
}
Example #15
0
func validateSession(r render.Render, s sessions.Session) {
	isLogin := s.Get("IsLogin")

	if isLogin == nil {
		fmt.Println("Not login...")
		r.Redirect("/admin/login")
	}
}
Example #16
0
func allHeros(db HeroDB, parms martini.Params, r render.Render) {
	u := (db).(*heroDB)
	var heros []Hero

	for _, v := range u.heros {
		heros = append(heros, v)
	}
	r.JSON(http.StatusOK, heros)
}
Example #17
0
func renderTutorial(ren render.Render) {
	var tutorial Tutorial
	file, err := ioutil.ReadFile("neutrino.json")
	if err != nil {
		panic(err)
	}
	json.Unmarshal(file, &tutorial)
	ren.JSON(200, tutorial)
}
Example #18
0
/////////////////////////////////////////////////////////////////////////////////////////////
// Controller Actions
/////////////////////////////////////////////////////////////////////////////////////////////
func GamesIndex(r render.Render, db *mgo.Database, req *http.Request) {
	var recs []models.GameRec

	recs = models.GetGameRecs(db, nil)

	templateData := map[string]interface{}{"metatitle": "Battle Answers", "currentPath": req.URL.Path,
		"recs": populateGameDisplays(db, recs)}
	r.HTML(200, "games/index", templateData)
}
Example #19
0
func deleteDrop(params martini.Params, db *database.Database, r render.Render) {
	url := params["url"]
	err := db.DeleteDrop(url)
	if err != nil {
		r.JSON(500, map[string]interface{}{"error": err.Error()})
	} else {
		r.JSON(200, map[string]interface{}{"ok": url})
	}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Controller Actions
/////////////////////////////////////////////////////////////////////////////////////////////
func BattleAnswersIndex(r render.Render, db *mgo.Database, req *http.Request) {
	var recs []models.BattleAnswerRec

	recs = models.GetBattleAnswerRecs(db, nil)

	templateData := map[string]interface{}{"metatitle": "Battle Answers", "currentPath": req.URL.Path,
		"recs": helpers.GetBattleAnswerDisplays(db, recs)}
	r.HTML(200, "battle_answers/index", templateData)
}
Example #21
0
func AdminAddTips(req *http.Request, r render.Render, db *mgo.Database) {
	content := req.FormValue("tip")
	comment := req.FormValue("comment")

	tip := models.Tips{Id: bson.NewObjectId(), Content: content, Comment: comment}
	db.C("tips").Insert(tip)

	r.Redirect("/admin/tips")
}
Example #22
0
func listDrops(db *database.Database, r render.Render) {
	// when there's none it returns a null?
	drops, err := json.Marshal(db.ListDrops())
	fmt.Println(drops)
	if err != nil {
		r.JSON(500, map[string]interface{}{"error": err})
	} else {
		r.JSON(200, map[string]interface{}{"drops": string(drops)})
	}
}
Example #23
0
func NotFoundHandler(r render.Render) {

	type templateData struct {
		Context *conf.Context
	}

	data := templateData{conf.DefaultContext(conf.Config)}

	r.HTML(200, "404", data)
}
Example #24
0
func HomeHandler(r render.Render) {

	type templateData struct {
		Context *conf.Context
	}

	data := templateData{conf.DefaultContext(conf.Config)}

	r.HTML(200, "home", data)
}
Example #25
0
func EventGrabHandler(r render.Render) {

	type templateData struct {
		Context *conf.Context
	}

	data := templateData{conf.DefaultContext(conf.Config)}

	r.HTML(200, "event_grab", data)

}
Example #26
0
func AdminModifyCasts(r render.Render, db *mgo.Database, params martini.Params) {

	cast := models.Casts{}

	db.C("casts").FindId(bson.ObjectIdHex(params["Id"])).One(&cast)

	r.HTML(200, "admin/casts_modify", map[string]interface{}{
		"IsCasts": true,
		"Id":      params["Id"],
		"Cast":    cast}, render.HTMLOptions{Layout: "admin/layout"})
}
Example #27
0
// Render error page
func renderError(code int, r render.Render) {
	r.HTML(404, "404", Page{
		HttpCode:    404,
		HttpMethod:  "GET",
		Template:    "404",
		Path:        "/404",
		Slug:        "404",
		Title:       "Página não encontrada - Hera Modas",
		Description: "A página que você tentou acessar não existe ou foi removida.",
	})
}
func HomeIndex(r render.Render) {

	hal := HAL{}

	hal.Links = map[string]Link{
		"self":      Link{"/", false},
		"portfolio": Link{"/portfolio", false},
	}

	r.JSON(200, hal)
}
Example #29
0
func ShowLoginPage(r render.Render, s sessions.Session) {

	isLogin := s.Get("IsLogin")

	if isLogin != nil {
		r.Redirect("/admin/index")
		return
	}

	r.HTML(200, "admin/login", map[string]interface{}{
		"IsAbout": true}, render.HTMLOptions{})
}
Example #30
0
func Login(r *http.Request, render render.Render, db *gorp.DbMap, s sessions.Session) {
	user := User{}
	email, password := r.FormValue("email"), r.FormValue("password")
	err := db.SelectOne(&user, "Select * from users where email=? ", email)
	//tmp_pass, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	//err := db.QueryRow("select id, password from users where email=$1", email).Scan(&userId, &dbPasswd)
	if err != nil || bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)) != nil {
		render.HTML(400, "404", "")
	}
	s.Set("userId", user.Id)
	render.HTML(200, "dashboard", "")
}