Пример #1
0
func Login(session sessions.Session, su models.User, r render.Render, p *models.Page) {

	// Check if we are already logged in
	if su.Id > 0 {
		r.Redirect(strings.Join([]string{utils.AppCfg.Url(), "albums"}, "/"), http.StatusFound)
		return
	}

	session.Set("loggedin", "false")

	// Init error holder
	errs := make(map[string]string)

	err_flash := session.Get("flash")
	if err_flash != nil {
		errs["flash"] = err_flash.(string)
		session.Set("flash", nil)
	}

	genform := utils.GenerateForm(&forms.Login{}, "/login", "POST", errs)

	p.SetUser(su)
	p.SetTitle("Login")
	p.Data = LoginVars{Form: genform}

	encoder.Render(p.Encoding, 200, "login", p, r)
}
Пример #2
0
func Login(session sessions.Session, re render.Render, r *http.Request) {
	client_id := common.Config.OAuth2Client_ID

	letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

	b := make([]rune, 10)
	for i := range b {
		b[i] = letters[rand.Intn(len(letters))]
	}
	session.AddFlash(string(b), "state")

	redirectBack := r.URL.Query().Get("redirect_back")
	ref := r.Referer()

	if redirectBack == "true" && ref != "" {
		session.Set("redirect_to", ref)
	} else {
		session.Set("redirect_to", nil)
	}

	query := url.Values{}
	query.Set("client_id", client_id)
	query.Set("state", string(b))
	query.Set("scope", "repo")

	dest := url.URL{
		Scheme:   "https",
		Host:     "github.com",
		Path:     "/login/oauth/authorize",
		RawQuery: query.Encode(),
	}
	re.Redirect(dest.String())
}
Пример #3
0
func getLoginPage(user sessionauth.User, r render.Render) {
	if user.IsAuthenticated() {
		r.Redirect(INDEX_PAGE)
		return
	}
	r.HTML(200, LOGIN_PAGE, nil)
}
Пример #4
0
func UpdatePlant(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	id, _ := strconv.ParseInt(params["id"], 10, 64)

	plant := entity.NewPlant()

	plant.Populate(getPlantMap(r, params["id"]))

	val, errors := validation.ValidateDefaultEntity(plant, db, PLANT)

	if val {
		_, err := repository.UpdatePlant(plant, db, params["id"])

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to update plant.")
		} else {
			sessionMessages.AddSuccess("Successfully update plant.")

			updatePopularNames(db, id, PLANT, plant.GetPopularNames().GetValues())
			createMedia(r, mediaManager, db, sessionMessages, PLANT, id)
		}

		ren.Redirect("/plant/")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/plant/" + params["id"])
	}
}
func upload_battle(w http.ResponseWriter, r *http.Request, out render.Render) {
	file, _, err := r.FormFile("txtUpload")

	if err != nil {
		fmt.Fprintln(w, err)
		return
	}

	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		str := scanner.Text()

		//fmt.Println(str)

		beg := strings.Index(str, "\"")
		end := strings.LastIndex(str, "\"")
		if beg != -1 && end != -1 {
			jsonString := strings.Replace(str[beg+1:end], "\\\"", "\"", -1)
			saveBattle(jsonString)
		}
	}

	if err = scanner.Err(); err != nil {
		//fmt.Fprintln(w, err)
		fmt.Println(err)
	}

	out.Redirect("/")
}
Пример #6
0
func Random(db model.Model, r render.Render, req *http.Request, isJson IsJson) {
	qs := req.URL.Query()

	search := qs.Get("query")

	maxLines, err := strconv.Atoi(qs.Get("max-lines"))
	if err != nil || maxLines < 1 {
		maxLines = 0
	}

	quotes, err := db.GetQuotes(model.Query{
		Limit:       1,
		Search:      search,
		MaxLines:    maxLines,
		OrderBy:     []string{"rand()"},
		IncludeTags: qs["tags"],
		ExcludeTags: qs["exclude-tags"],
	})

	if err != nil || len(quotes) == 0 {
		RenderError(r, 500, isJson, fmt.Sprint("quote not found", err))
		return
	}

	quote := quotes[0]

	if isJson {
		r.JSON(200, quote)
	} else {
		r.Redirect(fmt.Sprintf("/quote/%d", quote.ID))
	}
}
Пример #7
0
func EditPlant(ren render.Render, db *sql.DB, params martini.Params, t *template.TemplateData) {
	var plant_id string = params["id"]

	if plant_id != "new" {
		plant, err := repository.GetPlant(db, plant_id)

		if err != nil || plant == nil {
			t.SessionMessage.AddDanger("Failed to load plant.")

			ren.Redirect("/plant")

			return
		}

		id, _ := strconv.ParseInt(params["id"], 10, 64)

		plant.PopularNames.Names, err = repository.GetPopularNames(db, id, PLANT)

		t.Data = plant

		t.MediaList = getMediaList(db, PLANT, id)

		ren.HTML(200, "blah/plant/edit", t)
	} else {
		ren.HTML(200, "blah/plant/edit", nil)
	}
}
Пример #8
0
func CreateInvertebrate(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	invertebrate := entity.NewInvertebrate()

	invertebrate.Populate(getInvertebrateMap(r, ""))

	val, errors := validation.ValidateDefaultEntity(invertebrate, db, INVERTEBRATE)

	if val {
		res, err := repository.InsertInvertebrate(invertebrate, db)

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to create invertebrate.")
		} else {
			sessionMessages.AddSuccess("Successfully created invertebrate.")

			id, _ := res.LastInsertId()

			insertPopularNames(db, id, INVERTEBRATE, invertebrate.GetPopularNames().GetValues())
			createMedia(r, mediaManager, db, sessionMessages, INVERTEBRATE, id)
		}

		ren.Redirect("/invertebrate")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/invertebrate/new")
	}
}
Пример #9
0
func UpdateInvertebrate(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	id, _ := strconv.ParseInt(params["id"], 10, 64)

	invertebrate := entity.NewInvertebrate()

	invertebrate.Populate(getInvertebrateMap(r, params["id"]))

	val, errors := validation.ValidateDefaultEntity(invertebrate, db, INVERTEBRATE)

	if val {
		_, err := repository.UpdateInvertebrate(invertebrate, db, params["id"])

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to upload invertebrate.")
		} else {
			sessionMessages.AddSuccess("Successfully upload invertebrate.")

			updatePopularNames(db, id, INVERTEBRATE, invertebrate.GetPopularNames().GetValues())
			createMedia(r, mediaManager, db, sessionMessages, INVERTEBRATE, id)
		}

		ren.Redirect("/invertebrate")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/invertebrate/" + params["id"])
	}
}
Пример #10
0
func UpdateCoral(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	id, _ := strconv.ParseInt(params["id"], 10, 64)

	coral := entity.NewCoral()

	coral.Populate(getCoralMap(r, params["id"]))

	val, errors := validation.ValidateCoral(coral, db, CORAL)

	if val {
		_, err := repository.UpdateCoral(coral, db, params["id"])

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to update coral.")
		} else {
			sessionMessages.AddSuccess("Successfully update coral.")

			updatePopularNames(db, id, CORAL, coral.GetPopularNames().GetValues())
			createMedia(r, mediaManager, db, sessionMessages, CORAL, id)
		}

		ren.Redirect("/coral")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/coral/" + params["id"])
	}
}
Пример #11
0
func EditInvertebrate(ren render.Render, db *sql.DB, params martini.Params, t *template.TemplateData) {
	var invertebrate_id string = params["id"]

	if invertebrate_id != "new" {
		invertebrate, err := repository.GetInvertebrate(db, invertebrate_id)

		if err != nil || invertebrate == nil {
			t.SessionMessage.AddDanger("Failed to load invertebrate.")

			ren.Redirect("/invertebrate")

			return
		}

		id, _ := strconv.ParseInt(params["id"], 10, 64)

		invertebrate.PopularNames.Names, err = repository.GetPopularNames(db, id, INVERTEBRATE)

		t.Data = invertebrate

		t.MediaList = getMediaList(db, INVERTEBRATE, id)

		ren.HTML(200, "blah/invertebrate/edit", t)
	} else {
		ren.HTML(200, "blah/invertebrate/edit", nil)
	}
}
Пример #12
0
func CreateCoral(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	coral := entity.NewCoral()

	coral.Populate(getCoralMap(r, ""))

	val, errors := validation.ValidateCoral(coral, db, CORAL)

	if val {
		res, err := repository.InsertCoral(coral, db)

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to create coral.")
		} else {
			sessionMessages.AddSuccess("Successfully created coral.")

			id, _ := res.LastInsertId()

			insertPopularNames(db, id, CORAL, coral.GetPopularNames().GetValues())
			createMedia(r, mediaManager, db, sessionMessages, CORAL, id)
		}

		ren.Redirect("/coral")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/coral/new")
	}
}
Пример #13
0
func EditCoral(ren render.Render, db *sql.DB, params martini.Params, t *template.TemplateData) {
	var coral_id string = params["id"]

	if coral_id != "new" {
		coral, err := repository.GetCoral(db, coral_id)

		if err != nil || coral == nil {
			t.SessionMessage.AddDanger("Failed to load coral.")

			ren.Redirect("/coral")

			return
		}

		id, _ := strconv.ParseInt(params["id"], 10, 64)

		coral.PopularNames.Names, err = repository.GetPopularNames(db, id, CORAL)

		t.Data = coral

		t.MediaList = getMediaList(db, CORAL, id)

		ren.HTML(200, "blah/coral/edit", t)
	} else {
		ren.HTML(200, "blah/coral/edit", nil)
	}
}
Пример #14
0
func LoginPost(lu forms.Login, session sessions.Session, r render.Render, dbh *db.Dbh) {
	errs := ValidateLogin(&lu)
	if len(errs) > 0 {
		log.Printf("errors: %+v\n", errs)
	}

	user := dbh.GetUserByEmail(lu.Email)

	match := auth.MatchPassword(lu.Password, user.Password, user.Salt)

	if match {
		sessionkey := SessionKey(user.Email, user.Password, user.Salt)

		session.Set("loggedin", "true")
		session.Set("uid", user.Id)
		session.Set("email", user.Email)
		session.Set("key", sessionkey)

		dbh.CreateSession(models.UserSession{UserId: user.Id, SessionKey: sessionkey, Active: true, Timestamp: time.Now().Unix()})

		r.Redirect(strings.Join([]string{utils.AppCfg.Url(), "albums"}, "/"), http.StatusFound)
		return
	}

	session.Set("flash", "Invalid Email or Password")

	r.Redirect(strings.Join([]string{utils.AppCfg.Url(), "login"}, "/"), http.StatusFound)
}
Пример #15
0
// Handler to require a user to log in. If the user is currently logged in
// nothing happens. Otherwise clear existing session and redirect the user
// to the login page
func RequireLogin(s sessions.Session, r render.Render) {
	session := s.Get("user_session")
	if session == nil {
		s.Clear()
		r.Redirect("/login")
	}
}
Пример #16
0
func CreateAdmin(r render.Render, req *http.Request) {
	if len(cache.Users) > 0 {
		r.Error(404)
		return
	}
	if req.Method == "GET" {
		r.HTML(200, "user_add", map[string]interface{}{})
		return
	}

	req.ParseForm()
	values := req.Form
	m := &model.User{}
	m.Account = values.Get("account")
	m.Password = model.Md5(values.Get("password"))
	m.Info = values.Get("info")
	m.Name = values.Get("name")
	if !checkNull([]string{m.Account, m.Password, m.Info, m.Name}...) {
		service.Logs.Error("args err")
		return
	}
	m.Status = model.UserStatusAdmin
	_, err := dao.AddUser(m)
	if err != nil {
		service.Logs.Error("dao.InsertUser err(%v)", err)
		return
	}
	r.Redirect("/", 302)
	return
}
Пример #17
0
func (us UserService) SignOut(w http.ResponseWriter, req *http.Request, r render.Render) {
	// delete logged in session
	session, _ := utils.SessionStore.Get(req, "chroniton")
	session.Options.MaxAge = -1
	session.Save(req, w)
	r.Redirect("/")
}
Пример #18
0
func UpdateLatestNews(ren render.Render, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	latest_news := entity.NewLatestNews()

	latest_news.Populate(getLatestNewsMap(r))

	val, errors := validation.ValidateLatestNews(latest_news, db, LATEST_NEWS)

	if val {
		_, err := repository.UpdateLatestNews(latest_news, db, params["id"])

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to upload news.")
		} else {
			sessionMessages.AddSuccess("Successfully upload news.")
		}

		ren.Redirect("/latest_news")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/latest_news/" + params["id"])
	}
}
Пример #19
0
// Process register: check form, create new inactive user and send activation email
func (self *RegisterController) ProcessRegister(params martini.Params, req *http.Request, r render.Render, di *di.DI) {
	userManager := di.UserManager()
	user := userManager.NewUser()

	// need validate

	user.Email = req.FormValue("Email")
	rawPassword := req.FormValue("Password")
	user.Password = userManager.CryptPassword(rawPassword)
	user.FullName = req.FormValue("FullName")
	user.Address = req.FormValue("Address")
	user.Phone = req.FormValue("Phone")
	user.IsActive = false
	user.Hash = userManager.GenerateHash(user.Email + user.FullName)

	userManager.Create(user)

	// send email
	mailer := di.Mailer()
	go mailer.Send(mailer.BuildRegistrationMail(user))

	// message: "Activation link was sent to your email."

	r.Redirect("/users/")
}
Пример #20
0
func createHub(user sessionauth.User, newHub hub, rend render.Render, req *http.Request) {

	var hubInDB hub
	query := r.Table("hub").Filter(r.Row.Field("name").Eq(newHub.HubName))
	row, err := query.RunRow(dbSession)

	if err == nil && !row.IsNil() {
		// Register, error case.
		if err := row.Scan(&hubInDB); err != nil {
			fmt.Println("Error reading DB")
		} else {
			fmt.Println("User already exists. Redirecting to login.")
		}

		rend.Redirect(sessionauth.RedirectUrl)
		return
	} else { // User doesn't exist, continue with registration.
		if row.IsNil() {
			fmt.Println("User doesn't exist. Registering...")
		} else {
			fmt.Println(err)
		}
	}

	r.Table("hub").Insert(newHub).RunWrite(dbSession)
	fmt.Println("New hub done. Try to con")

	rend.Redirect(sessionauth.RedirectUrl)
}
Пример #21
0
func CreatePlant(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	plant := entity.NewPlant()

	plant.Populate(getPlantMap(r, ""))

	val, errors := validation.ValidateDefaultEntity(plant, db, PLANT)

	if val {
		res, err := repository.InsertPlant(plant, db)

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to create plant.")
		} else {
			sessionMessages.AddSuccess("Successfully created plant.")

			id, _ := res.LastInsertId()

			insertPopularNames(db, id, PLANT, plant.GetPopularNames().GetValues())
			createMedia(r, mediaManager, db, sessionMessages, PLANT, id)
		}

		ren.Redirect("/plant")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/plant/new")
	}
}
Пример #22
0
func DeleteComponent(ren render.Render, mediaManager *media.Manager, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	var err error

	id, _ := strconv.ParseInt(params["id"], 10, 64)

	media_list := getMediaList(db, COMPONENT, id)

	if media_list != nil {
		_, errors := DeleteEntityMedia(*media_list, mediaManager, db)

		for _, err := range errors {
			log.Println(err)
		}

		_, err = repository.DeleteEntityMedia(db, id, COMPONENT)
		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to delete media for component.")
		}
	}

	_, err = repository.DeleteComponent(db, id)
	if err != nil {
		log.Println(err)
		sessionMessages.AddDanger("Failed to delete component.")
	} else {
		sessionMessages.AddSuccess("Successfully deleted component.")
	}

	ren.Redirect("/component")
}
Пример #23
0
func PostLoginHandler(w http.ResponseWriter, rnd render.Render, r *http.Request, s *session.Session) {
	username := r.FormValue("username")
	password := r.FormValue("password")

	s.Username = username
	s.IsAuthorized = true

	fmt.Println(username)
	fmt.Println(password)

	token := jwt.New(jwt.SigningMethodHS256)
	token.Claims["Name"] = "token"
	token.Claims["exp"] = time.Now().Add(time.Minute * 5).Unix()
	tokenString, err := token.SignedString([]byte(session.TOKEN_STR))
	fmt.Println(tokenString)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Printf("Token Signing error: %v\n", err)
		fmt.Fprintln(w, "Sorry, error while Signing Token!")
	}

	http.SetCookie(w, &http.Cookie{
		Name:  session.TOKEN_NAME,
		Value: tokenString,
	})
	s.Id = tokenString

	storage, err := models.GetStorage()
	if err != nil {
		log.Fatalln(err)
	}
	storage.SaveUser(models.NewUser(username))
	rnd.Redirect("/")
}
Пример #24
0
func EditComponent(ren render.Render, db *sql.DB, params martini.Params, t *template.TemplateData) {
	var component_id string = params["id"]

	if component_id != "new" {
		component, err := repository.GetComponent(db, component_id)

		if err != nil || component == nil {
			t.SessionMessage.AddDanger("Failed to load component.")

			ren.Redirect("/component")

			return
		}

		t.Data = component

		id, _ := strconv.ParseInt(params["id"], 10, 64)

		t.MediaList = getMediaList(db, COMPONENT, id)

		ren.HTML(200, "blah/component/edit", t)
	} else {
		ren.HTML(200, "blah/component/edit", nil)
	}
}
Пример #25
0
func PreventReauth(session sessions.Session, r render.Render) {
	_, ok := session.Get("id").(int64)
	if ok {
		session.AddFlash("warning: You are already signed in!")
		r.Redirect("/dashboard")
	}
}
Пример #26
0
func CreateComponent(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	component := entity.NewComponent()

	component.Populate(getComponentMap(r, ""))

	val, errors := validation.ValidateComponent(component, db, COMPONENT)

	if val {
		res, err := repository.InsertComponent(component, db)

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to create component.")
		} else {
			sessionMessages.AddSuccess("Successfully created component.")

			id, _ := res.LastInsertId()

			createMedia(r, mediaManager, db, sessionMessages, "component", id)
		}

		ren.Redirect("/component")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/component/new")
	}
}
Пример #27
0
func UpdUserTodo(r render.Render, rq *http.Request) {
	for i := 0; i < 1; i++ {

		idStr := strings.TrimSpace(rq.FormValue("id"))
		id, err := strconv.ParseInt(idStr, 10, 64)
		if err != nil {
			break
		}

		username := strings.TrimSpace(rq.FormValue("username"))
		if len(username) == 0 {
			break
		}

		password := strings.TrimSpace(rq.FormValue("password"))
		if len(password) == 0 {
			break
		}

		user := make(map[string]interface{}, 2)
		user["username"] = username
		user["password"] = password

		models.UpdUser(id, user)
	}

	r.Redirect("/user/list")
}
Пример #28
0
func UpdateComponent(ren render.Render, mediaManager *media.Manager, r *http.Request, db *sql.DB, params martini.Params, sessionMessages *template.Messages) {
	id, _ := strconv.ParseInt(params["id"], 10, 64)

	component := entity.NewComponent()

	component.Populate(getComponentMap(r, params["id"]))

	val, errors := validation.ValidateComponent(component, db, COMPONENT)

	if val {
		_, err := repository.UpdateComponent(component, db, params["id"])

		if err != nil {
			log.Println(err)
			sessionMessages.AddDanger("Failed to update component.")
		} else {
			sessionMessages.AddSuccess("Successfully updated component.")

			createMedia(r, mediaManager, db, sessionMessages, COMPONENT, id)
		}

		ren.Redirect("/component")
	} else {
		for k, msg := range errors {
			sessionMessages.AddDanger(k + ": " + msg)
		}

		ren.Redirect("/component/" + params["id"])
	}
}
Пример #29
0
func getRegisterPage(user sessionauth.User, r render.Render) {
	if user.IsAuthenticated() {
		r.Redirect(INDEX_PAGE)
		return
	}
	r.HTML(200, REGISTER_PAGE, nil)
}
func (c ReleaseWatchersController) WatchOrUnwatch(req *http.Request, r martrend.Render, params mart.Params) {
	action := req.FormValue("action")

	switch {
	case action == "watch":
		err := c.watchersRepo.Add(req.FormValue("relSource"), req.FormValue("minVersion"))
		if err != nil {
			r.HTML(500, c.errorTmpl, err)
			return
		}

	case action == "unwatch":
		err := c.watchersRepo.Remove(req.FormValue("relSource"))
		if err != nil {
			r.HTML(500, c.errorTmpl, err)
			return
		}

	default:
		r.HTML(500, c.errorTmpl, bosherr.New("Unknown action '%s'", action))
		return
	}

	r.Redirect("/release_watchers")
}