Example #1
0
func GetArticle(w app.ResponseWriter, r *app.Request) {
	article_id, err := strconv.Atoi(r.PathParams["article_id"])

	if err == nil {
		article := models.Article{}
		article.Find(article_id)

		if article.ID != 0 {
			w.WriteJson(article)
			return
		}
	}
	logging.Logger.Error(fmt.Sprintf("Error: %s", err))
	w.WriteHeader(404)
	w.WriteJson(map[string]string{"error": "article no found"})
}
Example #2
0
func PostArticle(w app.ResponseWriter, r *app.Request) {
	user := r.Env["user"].(*models.User)

	title, markdown, category, html := generateArticleContent(r)

	if title == "" {
		w.WriteHeader(400)
		w.WriteJson(map[string]string{"error": "missing stuff"})
		return
	}

	// create article
	article := models.Article{Title: title, Content: string(html), Markdown: markdown}
	user.AddArticle(&article)
	category.AddArticle(&article)
	article.Create()

	w.WriteJson(article)
}
Example #3
0
func (c articlesController) ServeHTTP(w app.ResponseWriter, r *app.Request) {
	var err error

	// default args
	offset := 0
	limit := c.PagePerNumberMAX
	category_id := 0
	err = nil

	str_category_id := r.PathParams["category_id"]
	if str_category_id != "" {
		category_id, err = strconv.Atoi(str_category_id)
		if err != nil {
			logging.Logger.Error(fmt.Sprintf("Error: %s", err))
			category_id = 0
		}
	}

	uri_params := r.URL.Query()

	if limit_str := uri_params["limit"]; limit_str != nil {
		limit, err = strconv.Atoi(limit_str[0])
		if err != nil {
			logging.Logger.Error(fmt.Sprintf("Error: %s", err))
			limit = c.PagePerNumberMAX
		}
	}

	if offset_str := uri_params["offset"]; offset_str != nil {
		offset, err = strconv.Atoi(offset_str[0])
		if err != nil {
			logging.Logger.Error(fmt.Sprintf("Error: %s", err))
			offset = 0
		}
	}

	category := models.Category{ID: category_id}
	articles := category.AllArticles(offset, limit)

	w.WriteJson(articles)
}
Example #4
0
func ModifyArticle(w app.ResponseWriter, r *app.Request) {
	article_id, err := strconv.Atoi(r.PathParams["article_id"])

	if err == nil {
		title, markdown, _, html := generateArticleContent(r)

		article := models.Article{}
		article.Find(article_id)

		if article.ID != 0 {
			article.Title = title
			article.Markdown = markdown
			article.Content = string(html)
			// category.AddArticle(&article)
			article.Save()
			w.WriteJson(article)
			return
		}
	}
	logging.Logger.Error(fmt.Sprintf("Error: %s", err))
	w.WriteHeader(404)
	w.WriteJson(map[string]string{"error": "article no found"})
}
Example #5
0
func (self *authMiddware) LoginController(w app.ResponseWriter, r *app.Request) {
	var tokenString string

	data := jsonLoginDate{}

	// Decode Json from request
	err := r.DecodeJsonPayload(&data)

	if err != nil {
		logging.Logger.Error(fmt.Sprintf("Error: %s", err))
		w.WriteHeader(500)
		w.WriteJson(map[string]string{"error": fmt.Sprintf("Error: %s", err)})
		return
	}

	// extract
	email := data.Email
	password := data.Password

	// use email get user
	user := models.User{}
	user.Find(email)

	// validate password generate jwt tokenString
	// user jwt we can ignore CRSF
	if user.Validate(password) {
		user.Last_seen = time.Now().UTC()
		user.Save()
		token := jwt.New(jwt.SigningMethodHS256)
		token.Claims["email"] = user.Email
		token.Claims["role"] = user.Role
		token.Claims["exp"] = time.Now().Add(time.Hour * 6).UTC().Unix()
		tokenString, err = token.SignedString(self.signingKey)
		if err != nil {
			logging.Logger.Error(fmt.Sprintf("Error: %s", err))
			w.WriteHeader(500)
			w.WriteJson(map[string]string{"error": fmt.Sprintf("Error: %s", err)})
		}
		w.WriteJson(responseUserData{user.Nickname, tokenString, user.Role})

	} else {
		w.WriteHeader(400)
		w.WriteJson(map[string]string{"error": "email or password incorrect"})
	}
}
Example #6
0
func CategorysController(w app.ResponseWriter, r *app.Request) {
	category := models.Category{}
	categorys := category.All()

	w.WriteJson(categorys)
}
Example #7
0
func OwnerController(w app.ResponseWriter, r *app.Request) {
	user := models.User{}
	user.Find("*****@*****.**")
	user.Skills = user.GetSkills()
	w.WriteJson(user)
}