Beispiel #1
0
func Remove(ctx *web.Context, val string) string {
	id, err := strconv.Atoi(val)
	if err != nil {
		return "Invalid or malformed id"
	}

	db := util.GetDb()

	_, submit_exists := ctx.Params["doit"]
	if submit_exists {
		db.Exec("DELETE FROM entries WHERE id=$1", id)
		ctx.Redirect(302, "/manage/existing")
		return "Redirect"
	}

	// Get the post
	row := db.QueryRow("SELECT title FROM entries WHERE id=$1", id)
	entry := new(util.Entry)
	row.Scan(&entry.Title)

	send := map[string]interface{}{
		"Title": entry.Title,
	}

	return util.RenderTemplate("remove.mustache", send)
}
Beispiel #2
0
func logout(ctx *web.Context) string {
	session, _ := CookieStore.Get(ctx.Request, "monet-session")
	session.Values["authenticated"] = false
	session.Save(ctx.Request, ctx.ResponseWriter)
	ctx.Redirect(302, "/admin/login/")
	return ""
}
Beispiel #3
0
/*
	serve a link with extras (a path relative to the short-link and/or GET parameters)
	Parameters:
		ctx:	the context of the http request
		hash:	the short-hash of the link
		extras:	the extra path component
*/
func serveLinkWithExtras(ctx *web.Context, hash string, extras string) {
	//make the hash all uppercase
	upperHash := strings.ToUpper(hash)

	//Check to see if a link exists for the given hash
	link, numReports, exists, err := db_linkForHash(upperHash)
	if err != nil {
		//There was an error in the database
		internalError(ctx, errors.New("Database Error: "+err.Error()))
	} else if exists {
		//Check to see if the link has been flagged for review
		if numReports >= NUM_REPORTS_TO_FLAG {

			redir := link

			//If there were any path extras passed to us, append them to the redir link
			if extras != "" {
				redir += "/" + extras
			}

			//If there are any GET parameters being passed to us, append them to the redir link
			if len(ctx.Params) > 0 {
				params := "?"
				for k, v := range ctx.Params {
					params += k + "=" + v + "&"
				}
				//remove the trailing ampersand and append to the redir link
				redir += strings.TrimSuffix(params, "&")
			}

			flaggedLink(ctx, hash, redir)
			return

		} else {
			//The hash=>link exists
			redir := link

			//If there were any path extras passed to us, append them to the redir link
			if extras != "" {
				redir += "/" + extras
			}

			//If there are any GET parameters being passed to us, append them to the redir link
			if len(ctx.Params) > 0 {
				params := "?"
				for k, v := range ctx.Params {
					params += k + "=" + v + "&"
				}
				//remove the trailing ampersand and append to the redir link
				redir += strings.TrimSuffix(params, "&")
			}

			//if the hash exists in the link table, issue a '302 Found' to the client with the link URL
			ctx.Redirect(302, redir)
		}
	} else {
		//No link exists for the hash, so serve a '404 Not Found' error page
		error404(ctx, hash)
	}
}
Beispiel #4
0
func (c *Controller) Publish(ctx *web.Context) {
	if !c.sessionManager.LoggedIn(ctx) {
		ctx.Redirect(303, "/login")
		return
	}
	ctx.WriteString(c.Page("publish.html"))
}
Beispiel #5
0
func update(ctx *web.Context) {
	if ctx.Params["submit"] == "Delete" {
		ctx.SetCookie(web.NewCookie(cookieName, "", -1))
	} else {
		ctx.SetSecureCookie(cookieName, ctx.Params["cookie"], 0)
	}
	ctx.Redirect(301, "/")
}
Beispiel #6
0
func RequireAuthentication(ctx *web.Context) bool {
	session, _ := CookieStore.Get(ctx.Request, "monet-session")

	if session.Values["authenticated"] != true {
		ctx.Redirect(302, "/admin/login/")
		return true
	}
	return false
}
Beispiel #7
0
// renders /
func index(ctx *web.Context) string {
	css, ok := ctx.Params["css"]
	if ok {
		SetCSS(ctx, css)
		ctx.Redirect(302, "/")
		return "ok"
	}
	//posts := postsForMonth(time.LocalTime()) //Db.GetLastNPosts(10)

	//	posts := lastPosts(0xff)
	posts := postsForLastNDays(4)
	if len(posts) <= 0 {
		posts = lastPosts(23)
	}
	//fmt.Printf("posts: %#v\n", posts)
	//embedded struct - our mustache templates need a NumOfComments field to render
	//but we don't want to put that field into the BlogPost Struct so it won't get stored
	//into the DB
	type MyPost struct {
		BlogPost
		NumOfComments int
	}

	//posts ordered by date. this is ugly. TODO: look up if mustache hase something to handle this situation
	type Date struct {
		Date  string
		Posts []MyPost
	}
	Db := DBGet()
	defer Db.Close()

	//loop through our posts and put them into the appropriate date structure
	dates := []Date{}
	var cur_date time.Time
	var date *Date
	for _, p := range posts {
		post_date := time.Unix(p.Timestamp, 0)
		if !(cur_date.Day == post_date.Day && cur_date.Month == post_date.Month && cur_date.Year == post_date.Year) {
			cur_date = *post_date
			dates = append(dates, Date{Date: cur_date.Format("Mon Jan _2 2006")})
			date = &dates[len(dates)-1]
		}
		p.Comments, _ = Db.GetComments(p.Id)
		mp := MyPost{p, len(p.Comments)}
		date.Posts = append(date.Posts, mp)
	}
	m := map[string]interface{}{
		"Dates": dates,
	}

	tmpl, _ := mustache.ParseFile("templ/index.mustache")
	s := tmpl.Render(&m, getCSS(ctx))
	return s
}
Beispiel #8
0
func postDelete(ctx *web.Context, slug string) string {
	if app.RequireAuthentication(ctx) {
		return ""
	}
	db.Cursor(&Post{}).Remove(M{"slug": slug})
	referer := ctx.Request.Header.Get("referer")
	if len(referer) == 0 {
		referer = "/admin/"
	}
	ctx.Redirect(302, referer)
	return ""
}
Beispiel #9
0
func pageDelete(ctx *web.Context, url string) string {
	if app.RequireAuthentication(ctx) {
		return ""
	}
	db.Cursor(&Page{}).Remove(M{"url": url})
	referer := ctx.Request.Header.Get("referer")
	if len(referer) == 0 {
		referer = "/admin/"
	}
	ctx.Redirect(302, referer)
	return ""
}
Beispiel #10
0
func S3GetHandler(ctx *web.Context, key string) (ret string) {
	val := FakeS3[key]
	if val == "" {
		ctx.Abort(404, "Not Found")
		return
	} else if val == "FAIL" {
		ctx.Redirect(301, "htttttttp://idon'twork")
		return
	} else {
		return val
	}
}
Beispiel #11
0
func login(ctx *web.Context) string {
	if ctx.Params != nil {
		p := ctx.Params
		if ValidateUser(p["username"], p["password"]) {
			session, _ := CookieStore.Get(ctx.Request, "monet-session")
			session.Values["authenticated"] = true
			session.Save(ctx.Request, ctx.ResponseWriter)
			ctx.Redirect(302, "/admin/")
		}
	}
	return adminBase.Render("admin/login.mandira", ctx.Params, M{"login": true})
}
Beispiel #12
0
// Handler for adding a new feed
func addNewFeed(ctx *web.Context) string {
	url := ctx.Params["url"]
	source, err := loadFeed(url)
	if err != nil {
		return err.Error()
	}

	lock.Lock()
	folders["uncategorized"] = append(folders["uncategorized"], source)
	lock.Unlock()

	ctx.Redirect(303, "/")
	return ""
}
Beispiel #13
0
// Checks login
func login(wr *web.Context) {

	// Login user
	if wr.Params["username"] != "" && wr.Params["password"] != "" {
		username := wr.Params["username"]
		password := wr.Params["password"]
		loginName := jailgo.Authenticate(username, password)

		// If you have a valid user
		if loginName != nil {
			log.Println("DEBUG Controller *Username type: ", loginName.User)
			wr.SetSecureCookie("user", loginName.User, 20000) //15 minutes for session
			wr.Redirect(303, "/jail?check=ok")

			// If you haven't
		} else {
			wr.Redirect(303, "/jail?check=err")
		}

		// Maybe you're going out
	} else if wr.Params["logout"] != "" {
		wr.SetSecureCookie("user", "off", 0)
		wr.Redirect(303, "/jail?check=out")
	} else {

		// If you wrote nothing
		log.Println("DEBUG Controller user: "******"username"])
		log.Println("DEBUG Controller pass: "******"password"])
		wr.Redirect(303, "/jail?check=err")
	}
}
Beispiel #14
0
// Update database for articles and render main page
func updateArt(wr *web.Context) {
	loginUser, err := wr.GetSecureCookie("user")
	if err {
		log.Println("DEBUG User logged updating article: ", loginUser)
		jailgo.Updateart(wr.Params["title"], wr.Params["description"])

		// Redirect to the main page which will show the specified art
		wr.Redirect(303, "/jail")

		// We could show this art directly using show(wr, art_num)
		// but see: http://en.wikipedia.org/wiki/Post/Redirect/Get
	} else {
		wr.Redirect(303, "/jail?check=err")
	}
}
Beispiel #15
0
func pageAdd(ctx *web.Context) string {
	if app.RequireAuthentication(ctx) {
		return ""
	}

	if ctx.Request.Method == "GET" {
		ctx.Params["Url"] = strings.TrimLeft(ctx.Params["Url"], "/")
		return adminBase.Render("blog/admin/pages-edit.mandira", ctx.Params)
	}

	var page = new(Page)
	page.FromParams(ctx.Params)
	db.Upsert(page)
	ctx.Redirect(302, "/admin/")
	return ""
	//ctx.Redirect(302, "/admin/posts/edit/" + post.Slug + "/")
}
Beispiel #16
0
func (c *Controller) PublishPost(ctx *web.Context) {
	if !c.sessionManager.LoggedIn(ctx) {
		ctx.Redirect(303, "/login")
		return
	}

	file, head, err := ctx.Request.FormFile("publishFile")
	if err != nil {
		ctx.Abort(405, "error, post without a file")
		return
	}
	saveFile, err := os.Create("articles/" + head.Filename)
	defer saveFile.Close()
	io.Copy(saveFile, file)
	file.Close()
	ctx.Redirect(303, "/publish")
}
Beispiel #17
0
func pageEdit(ctx *web.Context, url string) string {
	if app.RequireAuthentication(ctx) {
		return ""
	}
	var page *Page
	err := db.Find(page, M{"url": url}).One(&page)
	if err != nil {
		fmt.Println(err)
		ctx.Redirect(302, "/admin/")
		return ""
	}
	if len(ctx.Params) > 1 {
		page.FromParams(ctx.Params)
		db.Upsert(page)
	}
	return adminBase.Render("blog/admin/pages-edit.mandira", page)
}
Beispiel #18
0
func admin(wr *web.Context) {
	loginUser, err := wr.GetSecureCookie("user")
	if err == true && loginUser != "off" {

		// Log username to control and render Admin page
		log.Println("DEBUG User logged accessing administration: ", loginUser)
		adminshow.Exec(wr)
		getdeleteart(wr)
		adminshow2.Exec(wr)
		getalldeletentry(wr)
		adminshow3.Exec(wr)
		check := ""
		foot1.Exec(wr, ViewCtxLogin{BlogLogin(wr, check), vinfo()})
		last(wr)
		foot2.Exec(wr)
	} else {
		wr.Redirect(303, "/jail?check=err")
	}
}
Beispiel #19
0
func postAdd(ctx *web.Context) string {
	if app.RequireAuthentication(ctx) {
		return ""
	}

	if ctx.Request.Method == "GET" {
		return adminBase.Render("blog/admin/posts-edit.mandira",
			ctx.Params, M{"Published": 0, "IsPublished": false})
	}

	post := new(Post)
	post.FromParams(ctx.Params)
	_, err := db.Upsert(post)
	if err != nil {
		fmt.Println(err)
	}
	ctx.Redirect(302, "/admin/")
	return ""
	//ctx.Redirect(302, "/admin/posts/edit/" + post.Slug + "/")
}
Beispiel #20
0
func postEdit(ctx *web.Context, slug string) string {
	if app.RequireAuthentication(ctx) {
		return ""
	}
	var post *Post
	err := db.Find(post, M{"slug": slug}).One(&post)
	if err != nil {
		fmt.Println(err)
		ctx.Redirect(302, "/admin/")
		return ""
	}
	if len(ctx.Params) > 1 {
		post.FromParams(ctx.Params)
		db.Upsert(post)
	}

	return adminBase.Render("blog/admin/posts-edit.mandira", post, M{
		"IsPublished": post.Published == 1,
		"IdHex":       post.Id.Hex()})
}
Beispiel #21
0
func adminPost(ctx *web.Context) {
	level := ctx.Params["godlevel"]
	godlevel := godHash(level)

	if ctx.Params["what"] == "login" {
		if godlevel == admin_pass {
			ctx.SetSecureCookie("godlevel", level, 3600)
			ctx.Redirect(301, "/admin")
			return
		}
		ctx.SetSecureCookie("godlevel", "fefe", 3600)
		ctx.Redirect(301, "/")
		return
	}

	if !checkGodLevel(ctx) {
		ctx.SetSecureCookie("godlevel", "fefe", 3600)
		ctx.Redirect(301, "/")
		return
	}

	if ctx.Params["what"] == "post" {
		err := createNewPost(ctx.Params["content"])
		if err != nil {
			ctx.WriteString("couldn't post: " + err.Error())
			ctx.WriteString("<br><br><A href='/'>Index</a>")
			return
		}
		ctx.WriteString(successpage)
		return
	}
}
Beispiel #22
0
func editPost(ctx *web.Context) {
	if !checkGodLevel(ctx) {
		ctx.Redirect(301, "/")
		return
	}
	Db := DBGet()
	defer Db.Close()

	id, _ := strconv.ParseInt(ctx.Params["postid"], 10, 64)
	post, err := Db.GetPost(id)
	if err != nil {
		ctx.WriteString("couldn't load post with given id!")
		return
	}
	post.Content = ctx.Params["content"]
	_, err = Db.StorePost(&post)
	if err != nil {
		ctx.WriteString("couldn't store post!")
		return
	}

	ctx.WriteString(successpage)
}
Beispiel #23
0
// Update database for comments and render main page
func updateEntry(wr *web.Context) {

	// Getting captcha
	//captstr, err := wr.GetSecureCookie("captstr")
	// Patch until set another secure cookie works again
	captstr := wr.Params["captstr"]
	if captstr != "" && wr.Params["content"] != "" {
		if processForm(captstr, wr.Params["captchaSolution"]) {
			id := wr.Params["threadId"]
			if artid, err := strconv.Atoi(id); err != nil {
				log.Println("DEBUG updateEntry Invalid String", err)
				log.Println("DEBUG updateEntry threadID Atoi", artid)

				// Redirect to the comment page which will show the specified art
				wr.Redirect(303, "comment?threadid="+id)
			} else {
				jailgo.UpdateEntry(artid, wr.Params["content"], wr.Params["author"])

				// Redirect to the comment page which will show the specified art
				wr.Redirect(303, "comment?threadid="+id)
			}

			// Redirect with fail if you typed incorrect captcha
			// We could show this comment directly using entry(wr, art_num)
			// but see: http://en.wikipedia.org/wiki/Post/Redirect/Get
		} else {
			id := wr.Params["threadId"]
			log.Println("DEBUG captcha verification failed!! (Error typed)", wr.Params["captchaSolution"])
			wr.Redirect(303, "comment?fail=on&threadid="+id)
		}
	} else {
		id := wr.Params["threadId"]
		log.Println("DEBUG Secure Cookie not found!!!", captstr)
		wr.Redirect(303, "comment?fail=on&threadid="+id)
	}

}
Beispiel #24
0
func home(ctx *web.Context) {
	ctx.Redirect(301, "/stat.html")
}