handler

var AboutGet core.HandlerFunc = func(c *core.Context) core.Response {
	c.Set("url", "about")
	return ArticleGet(c)
}

var AdminArticleDelete core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()

	post := &models.Posts{Id: id}
	if _, err := gosql.Model(post).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect(c.Request.Referer())
}

var AdminArticleGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}
	id := helpers.StrTo(c.Query("id")).MustInt()

	if id > 0 {
		post := &models.Posts{Id: id}
		gosql.Model(post).Get()
		cate := &models.Cates{Id: post.CateId}
		gosql.Model(cate).Get()
		user := &models.Users{Id: post.UserId}
		gosql.Model(user).Get()

		newpost := &models.UserPosts{Posts: *post, Cate: cate, User: user}
		h["Post"] = newpost
	}

	cates := make([]*models.Cates, 0)
	err := gosql.Model(&cates).All()
	h["Cates"] = cates

	if err != nil {
		return c.ErrorMessage(err)
	}
	return c.HTML("admin/post_article", h)
}

var AdminArticlePost core.HandlerFunc = func(c *core.Context) core.Response {
	post := &models.Posts{}
	if err := c.ShouldBind(post); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	post.UserId = c.Session().Get("UserId").(int)

	if post.Title == "" {
		return c.Fail(201, "文章标题不能为空")
	}

	if post.Id > 0 {
		if _, err := gosql.Model(post).Update(); err != nil {
			logger.Error(err)
			return c.Fail(201, "更新文章失败")
		}
	} else {
		if _, err := gosql.Model(post).Create(); err != nil {
			logger.Error(err)
			return c.Fail(201, "发表文章失败")
		}
	}

	return c.Success(post)
}

var AdminArticlesGet core.HandlerFunc = func(c *core.Context) core.Response {
	num := 10
	h := gin.H{}
	post := &models.Posts{}
	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	cateId := helpers.StrTo(c.DefaultQuery("cate_id", "0")).MustInt()
	h["CateId"] = cateId
	if cateId > 0 {
		post.CateId = cateId
	}

	posts, err := models.PostGetList(post, page, num, "", "")

	if err != nil {
		return c.ErrorMessage(err)
	}

	cates := make([]*models.Cates, 0)
	gosql.Model(&cates).All()

	h["Posts"] = posts
	h["Cates"] = cates

	total, err := gosql.Model(&models.Posts{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}

	return c.HTML("admin/articles", h)
}

var AdminCateDelete core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()
	total, _ := gosql.Model(&models.Posts{}).Where("cate_id = ?", id).Count()

	if total > 0 {
		return c.Fail(201, "该分类下面还有文章，不能删除")
	}

	if _, err := gosql.Model(&models.Cates{Id: id}).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect("/admin/cates")
}

var AdminCateGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}

	id := helpers.StrTo(c.Query("id")).MustInt()
	if id > 0 {
		cate := &models.Cates{Id: id}
		gosql.Model(cate).Get()
		h["Cate"] = cate
	}
	num := 10
	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	cates, err := models.CateArtivleCountGetList(page, num)
	h["Cates"] = cates

	total, err := gosql.Model(&models.Cates{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}

	return c.HTML("admin/cates", h)

}

var AdminCatePost core.HandlerFunc = func(c *core.Context) core.Response {
	cates := &models.Cates{}
	if err := c.Bind(cates); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	if cates.Name == "" {
		return c.Fail(201, "分类名不能为空")
	}

	if cates.Domain == "" {
		return c.Fail(201, "分类缩略名不能为空")
	}

	if cates.Id > 0 {
		if _, err := gosql.Model(cates).Update(); err != nil {
			logger.Error(err)
			return c.Fail(201, "更新失败")
		}
	} else {
		if _, err := gosql.Model(cates).Create(); err != nil {
			logger.Error(err)
			return c.Fail(201, "创建失败")
		}
	}

	return c.Success(nil)
}

var AdminCommentDelete core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()
	if _, err := gosql.Model(&models.Comments{Id: id}).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect("/admin/comments")
}

var AdminCommentGet core.HandlerFunc = func(c *core.Context) core.Response {

	h := gin.H{}
	num := 10
	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	comments, err := models.CommentList(page, num)
	h["Comments"] = comments

	total, err := gosql.Model(&models.Comments{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}

	return c.HTML("admin/comments", h)
}

var AdminIndex core.HandlerFunc = func(c *core.Context) core.Response {
	return c.HTML("admin/index")
}

var AdminIndexPost core.HandlerFunc = func(c *core.Context) core.Response {
	c.Request.ParseForm()
	options := c.Request.PostForm

	for k, v := range options {
		gosql.Model(&models.Options{
			OptionValue: v[0],
		}).Where("option_key = ?", k).Update()
	}

	return c.Success(options)
}

var AdminLinkDelete core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()

	if _, err := gosql.Model(&models.Links{Id: id}).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect(c.Request.Referer())
}

var AdminLinkGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}

	id, _ := helpers.StrTo(c.Query("id")).Int()
	if id > 0 {
		link := &models.Links{Id: id}
		gosql.Model(link).Get()
		h["Link"] = link
	}

	num := 10

	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	links, err := models.LinkGetList(page, num)
	h["Links"] = links

	total, err := gosql.Model(&models.Links{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}

	return c.HTML("admin/links", h)
}

var AdminLinkPost core.HandlerFunc = func(c *core.Context) core.Response {
	links := &models.Links{}
	if err := c.Bind(links); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	if links.Name == "" {
		return c.Fail(201, "连接名称不能为空")
	}

	if links.Url == "" {
		return c.Fail(201, "连接地址不能为空")
	}

	if links.Id > 0 {
		if _, err := gosql.Model(links).Update(); err != nil {
			logger.Error(err)
			return c.Fail(201, "更新失败")
		}
	} else {
		if _, err := gosql.Model(links).Create(); err != nil {
			logger.Error(err)
			return c.Fail(201, "创建失败")
		}
	}

	return c.Success(nil)
}

var AdminMoodDelete core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()

	mood := &models.Moods{Id: id}
	if _, err := gosql.Model(mood).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect(c.Request.Referer())
}

var AdminMoodGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}

	id := helpers.StrTo(c.Query("id")).MustInt()
	if id > 0 {
		mood := &models.Moods{Id: id}
		gosql.Model(mood).Get()
		h["Mood"] = mood
	}

	num := 10

	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	moods, err := models.MoodGetList(page, num)
	h["Moods"] = moods

	total, err := gosql.Model(&models.Moods{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}
	return c.HTML("admin/moods", h)
}

var AdminMoodPost core.HandlerFunc = func(c *core.Context) core.Response {
	moods := &models.Moods{}
	if err := c.Bind(moods); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	moods.UserId = c.Session().Get("UserId").(int)

	if moods.Content == "" {
		return c.Fail(201, "内容不能为空")
	}

	if moods.Id > 0 {
		if _, err := gosql.Model(moods).Update(); err != nil {
			logger.Error(err)
			return c.Fail(201, "更新失败")
		}
	} else {
		if _, err := gosql.Model(moods).Create(); err != nil {
			logger.Error(err)
			return c.Fail(201, "发表失败")
		}
	}
	return c.Success(nil)
}

var AdminRemindDelete core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()

	if _, err := gosql.Model(&models.Reminds{Id: id}).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect(c.Request.Referer())
}

var AdminRemindGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}

	id := helpers.StrTo(c.Query("id")).MustInt()
	if id > 0 {
		remind := &models.Reminds{Id: id}
		gosql.Model(remind).Get()
		h["Remind"] = remind
	}

	num := 10

	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	reminds, err := models.RemindGetList(page, num)

	h["Reminds"] = reminds

	total, err := gosql.Model(&models.Reminds{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	h["Types"] = map[int]string{
		0: "固定",
		1: "每分钟",
		2: "每小时",
		3: "每天",
		4: "每周",
		5: "每月",
		6: "每年",
	}

	h["Layouts"] = map[int]string{
		0: "2006-01-02 15:04:05",
		1: "",
		2: "",
		3: "15:04:00",
		4: "15:04:00",
		5: "02日15:04:05",
		6: "01月02日15:04:05",
	}

	h["CurrDate"] = time.Now().Format("2006-01-02 15:04:05")

	if err != nil {
		return c.ErrorMessage(err)
	}
	return c.HTML("admin/remind", h)
}

var AdminRemindPost core.HandlerFunc = func(c *core.Context) core.Response {
	reminds := &models.Reminds{}
	if err := c.ShouldBind(reminds); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	if reminds.Content == "" {
		return c.Fail(201, "提醒内容不能为空")
	}

	if reminds.Id > 0 {
		if _, err := gosql.Model(reminds).Update(); err != nil {
			logger.Error(err)
			return c.Fail(201, "更新失败:"+err.Error())
		}
	} else {
		if _, err := gosql.Model(reminds).Create(); err != nil {
			logger.Error(err)
			return c.Fail(201, "创建失败")
		}
	}

	return c.Success(nil)
}

var AdminUploadPost core.HandlerFunc = func(c *core.Context) core.Response {

	if config.App.Common.Env == "local" {
		return AdminUploadPostLocal(c)
	}

	file, _, err := c.Request.FormFile("uploadFile")
	if err != nil {
		c.Status(http.StatusBadRequest)
		return c.String("Bad request")
	}
	client, err := oss.New(config.App.OSS.Endpoint, config.App.OSS.AccessKey, config.App.OSS.AccessSecret)

	if err != nil {
		return c.JSON(gin.H{
			"jsonrpc": "2.0",
			"error": gin.H{
				"code":    101,
				"message": err.Error(),
			},
			"id": "id",
		})
	}

	bucket, _ := client.Bucket(config.App.OSS.Bucket)
	day := time.Now().Format("20060102")

	filename := "upload/" + day + "/" + helpers.Md5File(file) + ".png"
	file.Seek(0, 0)

	err = bucket.PutObject(filename, file)
	if err != nil {
		return c.JSON(gin.H{
			"jsonrpc": "2.0",
			"error": gin.H{
				"code":    100,
				"message": err.Error(),
			},
			"id": "id",
		})
	}

	return c.String("https://static.fifsky.com/" + filename + "!blog")
}

var AdminUploadPostLocal core.HandlerFunc = func(c *core.Context) core.Response {
	file, header, err := c.Request.FormFile("uploadFile")
	if err != nil {
		c.Status(http.StatusBadRequest)
		return c.String("Bad request")
	}
	filename := header.Filename
	day := time.Now().Format("20060102")
	dir := "static/upload/" + day
	exists, _ := helpers.PathExists(dir)
	if !exists {
		err := os.MkdirAll(dir, 0755)
		if err != nil {
			logger.Fatal(err)
			return c.JSON(gin.H{
				"jsonrpc": "2.0",
				"error": gin.H{
					"code":    100,
					"message": "Failed to create directory.",
				},
				"id": "id",
			})
		}
	}

	out, err := os.Create(dir + "/" + filename)
	if err != nil {
		logger.Fatal(err)

		return c.JSON(gin.H{
			"jsonrpc": "2.0",
			"error": gin.H{
				"code":    100,
				"message": "Failed to create file.",
			},
			"id": "id",
		})
	}
	defer out.Close()

	img, err := png.Decode(file)
	if err != nil {
		logger.Fatal(err)
	}
	file.Close()

	m := resize.Resize(800, 0, img, resize.Lanczos3)
	err = png.Encode(out, m)

	if err != nil {
		logger.Fatal(err)
		return c.JSON(gin.H{
			"jsonrpc": "2.0",
			"error": gin.H{
				"code":    100,
				"message": "Failed to save directory.",
			},
			"id": "id",
		})
	}
	return c.String("/static/upload/" + day + "/" + filename)
}

var AdminUserGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}
	id := helpers.StrTo(c.Query("id")).MustInt()
	if id > 0 {
		user := &models.Users{Id: id}
		err := gosql.Model(user).Get()
		if err != nil {
			return c.Message("用户不存在", "您访问的用户不存在或已经删除！")
		}
		h["User"] = user
	}

	return c.HTML("admin/post_user", h)
}

var AdminUserPost core.HandlerFunc = func(c *core.Context) core.Response {
	users := &models.Users{}
	if err := c.Bind(users); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	if users.Name == "" {
		return c.Fail(201, "用户名不能为空")
	}

	if users.Password == "" {
		return c.Fail(201, "密码不能为空")
	}

	if users.NickName == "" {
		return c.Fail(201, "昵称不能为空")
	}

	users.Password = helpers.Md5(users.Password)

	if users.Id > 0 {
		if _, err := gosql.Model(users).Update(); err != nil {
			logger.Error(err)
			return c.Fail(201, "更新失败")
		}
	} else {
		if _, err := gosql.Model(users).Create(); err != nil {
			logger.Error(err)
			return c.Fail(201, "创建失败")
		}
	}

	return c.Success(nil)
}

var AdminUserStatus core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Query("id")).MustInt()
	status := helpers.StrTo(c.Query("status")).MustInt()

	if _, err := gosql.Model(&models.Users{}).Where("id = ? and status = ?", id, status).Delete(); err != nil {
		logger.Error(err)
		return c.Fail(201, "删除失败")
	}
	return c.Redirect("/admin/users")
}

var AdminUsersGet core.HandlerFunc = func(c *core.Context) core.Response {
	h := gin.H{}
	num := 10

	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	users, err := models.UserGetList(page, num)

	h["Users"] = users

	total, err := gosql.Model(&models.Users{}).Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}
	return c.HTML("admin/users", h)
}

var ArticleGet core.HandlerFunc = func(c *core.Context) core.Response {
	id := helpers.StrTo(c.Param("id")).MustInt()
	url := c.GetString("url")
	post := &models.UserPosts{}

	if id > 0 {
		post.Id = id
	}

	if url != "" {
		post.Url = url
	}

	err := gosql.Model(post).Get()

	if err != nil {
		return c.Message("文章不存在", "您访问的文章不存在或已经删除！")
	}

	_, err = gosql.Table("posts").Where("id = ?", post.Id).Update(map[string]interface{}{
		"view_num": gosql.Expr("view_num + 1"),
	})

	if err != nil {
		logger.Error("view num add error", err)
	}

	h := gin.H{}
	h["Title"] = post.Title
	h["Post"] = post

	if url == "" {
		prev, err := models.PostPrev(post.Id)
		if err == nil {
			h["Prev"] = prev
		}
		next, err := models.PostNext(post.Id)
		if err == nil {
			h["Next"] = next
		}
	}

	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	comments, err := models.PostComments(post.Id, page, 100)
	if err == nil {
		h["Comments"] = comments
	}

	return c.HTML("index/article", h)
}

var Avatar core.HandlerFunc = func(c *core.Context) core.Response {
	name := c.DefaultQuery("name", "default")

	ig, err := identicon.New(
		"fifsky",
		5,
		5,
	)

	if err != nil {
		panic(err)
	}

	ii, err := ig.Draw(name)

	if err != nil {
		return nil
	}

	ii.Png(300, c.Writer)
	return nil
}

var CaptchaGet core.HandlerFunc = func(c *core.Context) core.Response {
	_, file := path.Split(c.Request.URL.Path)
	ext := path.Ext(file)
	id := file[:len(file)-len(ext)]
	if ext == "" || id == "" {
		return c.Fail(202, "id not found")
	}

	if c.Query("reload") != "" {
		captcha.Reload(id)
	}

	var imgHeight = captcha.StdHeight
	var imgWidth = captcha.StdWidth
	if c.Query("h") != "" {
		ih, err := strconv.Atoi(c.Query("h"))
		if err == nil {
			imgHeight = ih
		}
	}

	if c.Query("w") != "" {
		iw, err := strconv.Atoi(c.Query("w"))
		if err == nil {
			imgWidth = iw
		}
	}

	switch ext {
	case ".png":
		c.Header("Content-Type", "image/png")
		captcha.WriteImage(c.Writer, id, imgWidth, imgHeight)
		return nil
	default:
		return c.Fail(202, "ext not found")
	}

	return c.Fail(202, "ext not found")
}

var CommentPost core.HandlerFunc = func(c *core.Context) core.Response {
	comment := &models.Comments{}
	if err := c.ShouldBind(comment); err != nil {
		return c.Fail(201, "参数错误:"+err.Error())
	}

	if comment.Name == "" {
		return c.Fail(201, "昵称不能为空")
	}

	if comment.Content == "" {
		return c.Fail(201, "评论内容不能为空")
	}

	if comment.PostId <= 0 {
		return c.Fail(201, "非法评论")
	}

	if err := TCaptchaVerify(c.PostForm("ticket"), c.PostForm("randstr"), c.ClientIP()); err != nil {
		return c.Fail(201, err)
	}

	post := &models.Posts{}
	err := gosql.Model(post).Where("id = ?", comment.PostId).Get()
	if err != nil {
		return c.Fail(201, "文章不存在")
	}

	comment.CreatedAt = time.Now()
	comment.IP = c.ClientIP()

	if _, err := gosql.Model(comment).Create(); err != nil {
		logger.Error(err)
		return c.Fail(201, "评论失败"+err.Error())
	}

	body := c.HTMLRender("layout/comment_item", comment)

	content := "您有新的评论!\n"
	content += fmt.Sprintf("文章:%s\n", post.Title)
	content += fmt.Sprintf("评论内容:%s\n", comment.Content)
	content += fmt.Sprintf("评论昵称:%s\n", comment.Name)
	content += fmt.Sprintf("评论时间:%s\n", comment.CreatedAt.Format("2006-01-02 15:04:05"))
	content += fmt.Sprintf("评论IP:%s\n", comment.IP)

	ding.Alarm(content)

	return c.Success(gin.H{
		"content": body,
	})
}

var FeedGet core.HandlerFunc = func(c *core.Context) core.Response {
	now := time.Now()
	options := c.GetStringMapString("options")

	feed := &feeds.Feed{
		Title:       options["site_name"],
		Link:        &feeds.Link{Href: "https://fifsky.com"},
		Description: options["site_desc"],
		Author:      &feeds.Author{Name: "fifsky", Email: "[email protected]"},
		Created:     now,
	}

	cid := helpers.StrTo(c.DefaultQuery("cid", "0")).MustInt()

	post := &models.Posts{}
	if cid > 0 {
		post.CateId = cid
	}

	posts, err := models.PostGetList(post, 1, 10, "", "")

	if err != nil {
		return c.ErrorMessage(err)
	}

	for _, v := range posts {
		feed.Items = append(feed.Items, &feeds.Item{
			Title:       v.Title,
			Link:        &feeds.Link{Href: fmt.Sprintf("https://fifsky.com/article/%d", v.Id)},
			Description: v.Content,
			Author:      &feeds.Author{Name: v.User.NickName, Email: "[email protected]"},
			Created:     now,
		})
	}

	err = feed.WriteAtom(c.Writer)
	if err != nil {
		return c.ErrorMessage(err)
	}
	return nil
}

var Handle404 core.HandlerFunc = func(c *core.Context) core.Response {
	return c.Message("未找到(404 Not Found)", "抱歉，您浏览的页面未找到。")
}

var IndexGet core.HandlerFunc = func(c *core.Context) core.Response {
	options := c.GetStringMapString("options")
	num, err := helpers.StrTo(options["post_num"]).Int()
	if err != nil || num < 1 {
		num = 10
	}

	domain := c.Param("domain")
	cate := &models.Cates{}

	if domain != "" {
		cate.Domain = domain
		gosql.Model(cate).Get()
	}

	artdate := ""
	year := c.Param("year")
	month := c.Param("month")

	if year != "" && month != "" {
		artdate = year + "-" + month
	}

	page := helpers.StrTo(c.DefaultQuery("page", "1")).MustInt()
	post := &models.Posts{}
	if cate.Id > 0 {
		post.CateId = cate.Id
	}

	keyword := c.Query("keyword")

	post.Type = 1
	posts, err := models.PostGetList(post, page, num, artdate, keyword)
	if err != nil {
		return c.ErrorMessage(err)
	}

	h := gin.H{}
	h["Posts"] = posts

	builder := gosql.Model(post)

	if artdate != "" {
		builder.Where("DATE_FORMAT(created_at,'%Y-%m') = ?", artdate)
	}

	if keyword != "" {
		builder.Where("title like ?", "%"+keyword+"%")
	}

	total, err := builder.Count()
	h["Pager"] = c.Pagination(total, num, page)

	if err != nil {
		return c.ErrorMessage(err)
	}
	return c.HTML("index/index", h)
}

var LoginGet core.HandlerFunc = func(c *core.Context) core.Response {
	if _, ok := c.SharedData["LoginUser"]; ok {
		return c.Redirect("/admin/index")
	}
	return c.HTML("admin/login")
}

var LoginPost core.HandlerFunc = func(c *core.Context) core.Response {
	user_name := c.PostForm("user_name")
	password := c.PostForm("user_pass")

	if user_name == "" || password == "" {
		return c.Fail(201, "用户名或密码不能为空")
	}

	if err := TCaptchaVerify(c.PostForm("ticket"), c.PostForm("randstr"), c.ClientIP()); err != nil {
		return c.Fail(201, err)
	}

	user := &models.Users{Name: user_name}
	err := gosql.Model(user).Get()

	if err != nil {
		return c.Fail(201, "用户名或者密码错误")
	}

	if user.Password != helpers.Md5(password) {
		return c.Fail(201, "用户名或者密码错误")
	}

	c.Session().Set("UserId", user.Id)
	c.Session().Save()

	return c.Success(nil)
}

var LogoutGet core.HandlerFunc = func(c *core.Context) core.Response {
	c.Session().Delete("UserId")
	c.Session().Save()
	return c.Redirect("/")
}