初始化

api/amqp/consumer/base.go

@@ -0,0 +1,5 @@
+package consumer
+
+func checkHandleNumber(key string) {
+
+}

api/controller/Base.go

@@ -0,0 +1,6 @@
+package controller
+
+// Api api接口
+type Api struct {
+	Login // 登录
+}

api/controller/Login.go

@@ -0,0 +1,89 @@
+package controller
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"time"
+	"vote-api/api/dao"
+	"vote-api/api/dto"
+	"vote-api/api/model"
+	"vote-api/api/requests"
+	"vote-api/api/responses"
+	"vote-api/api/service"
+	"vote-api/global"
+	"vote-api/utils"
+)
+
+type Login struct{}
+
+func (r *Login) Login(c *gin.Context) {
+	loginRequest := requests.LoginRequest{}
+	req := loginRequest.Login
+	if err := c.ShouldBind(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+			utils.LogJsonErr("操作失败", r)
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+	}()
+
+	// 检测用户信息
+	userDao := dao.UserDao{}
+	maps := make(map[string]interface{})
+	maps["open_id"] = req.OpenId
+	user, err := userDao.GetUser(maps)
+	// 新用户处理方式
+	if user == nil {
+		// 登录ip
+		publicService := service.PublicService{}
+		loginIp := publicService.GetUserIP(c.Request)
+
+		// 新增用户
+		user = &model.User{
+			OpenId:  req.OpenId,
+			LoginIp: loginIp,
+		}
+		loginAt := model.LocalTime(time.Now())
+		user.LoginAt = &loginAt
+		user, err = userDao.AddUser(tx, user)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+	}
+
+	// 下发token
+	token := &utils.Token{
+		UserId: fmt.Sprintf("%d", user.UserId),
+	}
+
+	// 生成jwt
+	jwt, err := token.NewJWT()
+	if err != nil || jwt == "" {
+		responses.FailWithMessage("登陆失败", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.LoginDto{
+		UserId: fmt.Sprintf("%d", user.UserId),
+		Token:  jwt,
+	}
+
+	responses.OkWithData(g, c)
+}

api/dao/Article.go

@@ -0,0 +1,126 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type ArticleDao struct {
+}
+
+// GetArticleById 获取数据-id
+func (r *ArticleDao) GetArticleById(ArticleId int64) (m *model.Article, err error) {
+	err = global.Db.First(&m, ArticleId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetArticlePreloadById 获取数据-加载全部关联-id
+func (r *ArticleDao) GetArticlePreloadById(ArticleId int64) (m *model.Article, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, ArticleId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteArticle 删除
+func (r *ArticleDao) DeleteArticle(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.Article{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteArticleById 删除-id
+func (r *ArticleDao) DeleteArticleById(tx *gorm.DB, ArticleId int64) error {
+	if err := tx.Delete(&model.Article{}, ArticleId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditArticle 修改
+func (r *ArticleDao) EditArticle(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.Article{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditArticleById 修改-id
+func (r *ArticleDao) EditArticleById(tx *gorm.DB, ArticleId int64, data interface{}) error {
+	err := tx.Model(&model.Article{}).Where("article_id = ?", ArticleId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetArticleList 获取列表
+func (r *ArticleDao) GetArticleList(maps interface{}) (m []*model.Article, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetArticleCount 获取数量
+func (r *ArticleDao) GetArticleCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.Article{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetArticleListRand 获取列表-随机
+func (r *ArticleDao) GetArticleListRand(maps interface{}, limit int) (m []*model.Article, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddArticle 新增
+func (r *ArticleDao) AddArticle(tx *gorm.DB, model *model.Article) (*model.Article, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetArticle 获取
+func (r *ArticleDao) GetArticle(maps interface{}) (m *model.Article, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *ArticleDao) Inc(tx *gorm.DB, ArticleId int64, field string, numeral int) error {
+	err := tx.Model(&model.Article{}).Where("article_id = ?", ArticleId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *ArticleDao) Dec(tx *gorm.DB, ArticleId int64, field string, numeral int) error {
+	err := tx.Model(&model.Article{}).Where("article_id = ?", ArticleId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/ArticleAuthor.go

@@ -0,0 +1,126 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type ArticleAuthorDao struct {
+}
+
+// GetArticleAuthorById 获取数据-id
+func (r *ArticleAuthorDao) GetArticleAuthorById(AuthorId int64) (m *model.ArticleAuthor, err error) {
+	err = global.Db.First(&m, AuthorId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetArticleAuthorPreloadById 获取数据-加载全部关联-id
+func (r *ArticleAuthorDao) GetArticleAuthorPreloadById(AuthorId int64) (m *model.ArticleAuthor, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, AuthorId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteArticleAuthor 删除
+func (r *ArticleAuthorDao) DeleteArticleAuthor(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.ArticleAuthor{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteArticleAuthorById 删除-id
+func (r *ArticleAuthorDao) DeleteArticleAuthorById(tx *gorm.DB, ArticleAuthorId int64) error {
+	if err := tx.Delete(&model.ArticleAuthor{}, ArticleAuthorId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditArticleAuthor 修改
+func (r *ArticleAuthorDao) EditArticleAuthor(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.ArticleAuthor{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditArticleAuthorById 修改-id
+func (r *ArticleAuthorDao) EditArticleAuthorById(tx *gorm.DB, AuthorId int64, data interface{}) error {
+	err := tx.Model(&model.ArticleAuthor{}).Where("author_id = ?", AuthorId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetArticleAuthorList 获取列表
+func (r *ArticleAuthorDao) GetArticleAuthorList(maps interface{}) (m []*model.ArticleAuthor, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetArticleAuthorCount 获取数量
+func (r *ArticleAuthorDao) GetArticleAuthorCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.ArticleAuthor{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetArticleAuthorListRand 获取列表-随机
+func (r *ArticleAuthorDao) GetArticleAuthorListRand(maps interface{}, limit int) (m []*model.ArticleAuthor, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddArticleAuthor 新增
+func (r *ArticleAuthorDao) AddArticleAuthor(tx *gorm.DB, model *model.ArticleAuthor) (*model.ArticleAuthor, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetArticleAuthor 获取
+func (r *ArticleAuthorDao) GetArticleAuthor(maps interface{}) (m *model.ArticleAuthor, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *ArticleAuthorDao) Inc(tx *gorm.DB, AuthorId int64, field string, numeral int) error {
+	err := tx.Model(&model.ArticleAuthor{}).Where("author_id = ?", AuthorId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *ArticleAuthorDao) Dec(tx *gorm.DB, AuthorId int64, field string, numeral int) error {
+	err := tx.Model(&model.ArticleAuthor{}).Where("author_id = ?", AuthorId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/ArticleVoteDay.go

@@ -0,0 +1,126 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type ArticleVoteDayDao struct {
+}
+
+// GetArticleVoteDayById 获取数据-id
+func (r *ArticleVoteDayDao) GetArticleVoteDayById(voteDayId int64) (m *model.ArticleVoteDay, err error) {
+	err = global.Db.First(&m, voteDayId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetArticleVoteDayPreloadById 获取数据-加载全部关联-id
+func (r *ArticleVoteDayDao) GetArticleVoteDayPreloadById(voteDayId int64) (m *model.ArticleVoteDay, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, voteDayId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteArticleVoteDay 删除
+func (r *ArticleVoteDayDao) DeleteArticleVoteDay(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.ArticleVoteDay{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteArticleVoteDayById 删除-id
+func (r *ArticleVoteDayDao) DeleteArticleVoteDayById(tx *gorm.DB, voteDayId int64) error {
+	if err := tx.Delete(&model.ArticleVoteDay{}, voteDayId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditArticleVoteDay 修改
+func (r *ArticleVoteDayDao) EditArticleVoteDay(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.ArticleVoteDay{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditArticleVoteDayById 修改-id
+func (r *ArticleVoteDayDao) EditArticleVoteDayById(tx *gorm.DB, voteDayId int64, data interface{}) error {
+	err := tx.Model(&model.ArticleVoteDay{}).Where("vote_day_id = ?", voteDayId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetArticleVoteDayList 获取列表
+func (r *ArticleVoteDayDao) GetArticleVoteDayList(maps interface{}) (m []*model.ArticleVoteDay, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetArticleVoteDayCount 获取数量
+func (r *ArticleVoteDayDao) GetArticleVoteDayCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.ArticleVoteDay{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetArticleVoteDayListRand 获取列表-随机
+func (r *ArticleVoteDayDao) GetArticleVoteDayListRand(maps interface{}, limit int) (m []*model.ArticleVoteDay, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddArticleVoteDay 新增
+func (r *ArticleVoteDayDao) AddArticleVoteDay(tx *gorm.DB, model *model.ArticleVoteDay) (*model.ArticleVoteDay, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetArticleVoteDay 获取
+func (r *ArticleVoteDayDao) GetArticleVoteDay(maps interface{}) (m *model.ArticleVoteDay, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *ArticleVoteDayDao) Inc(tx *gorm.DB, voteDayId int64, field string, numeral int) error {
+	err := tx.Model(&model.ArticleVoteDay{}).Where("vote_day_id = ?", voteDayId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *ArticleVoteDayDao) Dec(tx *gorm.DB, voteDayId int64, field string, numeral int) error {
+	err := tx.Model(&model.ArticleVoteDay{}).Where("vote_day_id = ?", voteDayId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/Data.go

@@ -0,0 +1,135 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type DataDao struct {
+}
+
+// GetDataById 获取数据-id
+func (r *DataDao) GetDataById(DataId int64) (m *model.Data, err error) {
+	err = global.Db.First(&m, DataId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetDataPreloadById 获取数据-加载全部关联-id
+func (r *DataDao) GetDataPreloadById(DataId int64) (m *model.Data, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, DataId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteData 删除
+func (r *DataDao) DeleteData(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.Data{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteDataById 删除-id
+func (r *DataDao) DeleteDataById(tx *gorm.DB, DataId int64) error {
+	if err := tx.Delete(&model.Data{}, DataId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditData 修改
+func (r *DataDao) EditData(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.Data{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditDataById 修改-id
+func (r *DataDao) EditDataById(tx *gorm.DB, DataId int64, data interface{}) error {
+	err := tx.Model(&model.Data{}).Where("data_id = ?", DataId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetDataList 获取列表
+func (r *DataDao) GetDataList(maps interface{}) (m []*model.Data, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetDataCount 获取数量
+func (r *DataDao) GetDataCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.Data{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetDataListRand 获取列表-随机
+func (r *DataDao) GetDataListRand(maps interface{}, limit int) (m []*model.Data, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddData 新增
+func (r *DataDao) AddData(tx *gorm.DB, model *model.Data) (*model.Data, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetData 获取
+func (r *DataDao) GetData(maps interface{}) (m *model.Data, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetDataListByMemberValidTime 获取列表-今天开始时间/过期时间
+func (r *DataDao) GetDataListByMemberValidTime(maps interface{}, startTime, endTime string) (m []*model.Data, err error) {
+	err = global.Db.Where(maps).Where("member_expire_date BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *DataDao) Inc(tx *gorm.DB, DataId int64, field string, numeral int) error {
+	err := tx.Model(&model.Data{}).Where("data_id = ?", DataId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *DataDao) Dec(tx *gorm.DB, DataId int64, field string, numeral int) error {
+	err := tx.Model(&model.Data{}).Where("data_id = ?", DataId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/User.go

@@ -0,0 +1,135 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type UserDao struct {
+}
+
+// GetUserById 获取数据-id
+func (r *UserDao) GetUserById(UserId int64) (m *model.User, err error) {
+	err = global.Db.First(&m, UserId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserPreloadById 获取数据-加载全部关联-id
+func (r *UserDao) GetUserPreloadById(UserId int64) (m *model.User, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, UserId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteUser 删除
+func (r *UserDao) DeleteUser(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.User{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteUserById 删除-id
+func (r *UserDao) DeleteUserById(tx *gorm.DB, UserId int64) error {
+	if err := tx.Delete(&model.User{}, UserId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUser 修改
+func (r *UserDao) EditUser(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.User{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserById 修改-id
+func (r *UserDao) EditUserById(tx *gorm.DB, UserId int64, data interface{}) error {
+	err := tx.Model(&model.User{}).Where("user_id = ?", UserId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetUserList 获取列表
+func (r *UserDao) GetUserList(maps interface{}) (m []*model.User, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCount 获取数量
+func (r *UserDao) GetUserCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.User{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetUserListRand 获取列表-随机
+func (r *UserDao) GetUserListRand(maps interface{}, limit int) (m []*model.User, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddUser 新增
+func (r *UserDao) AddUser(tx *gorm.DB, model *model.User) (*model.User, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetUser 获取
+func (r *UserDao) GetUser(maps interface{}) (m *model.User, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserListByMemberValidTime 获取列表-今天开始时间/过期时间
+func (r *UserDao) GetUserListByMemberValidTime(maps interface{}, startTime, endTime string) (m []*model.User, err error) {
+	err = global.Db.Where(maps).Where("member_expire_date BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *UserDao) Inc(tx *gorm.DB, userId int64, field string, numeral int) error {
+	err := tx.Model(&model.User{}).Where("user_id = ?", userId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *UserDao) Dec(tx *gorm.DB, userId int64, field string, numeral int) error {
+	err := tx.Model(&model.User{}).Where("user_id = ?", userId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/Video.go

@@ -0,0 +1,126 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type VideoDao struct {
+}
+
+// GetVideoById 获取数据-id
+func (r *VideoDao) GetVideoById(VideoId int64) (m *model.Video, err error) {
+	err = global.Db.First(&m, VideoId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetVideoPreloadById 获取数据-加载全部关联-id
+func (r *VideoDao) GetVideoPreloadById(VideoId int64) (m *model.Video, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, VideoId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteVideo 删除
+func (r *VideoDao) DeleteVideo(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.Video{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteVideoById 删除-id
+func (r *VideoDao) DeleteVideoById(tx *gorm.DB, VideoId int64) error {
+	if err := tx.Delete(&model.Video{}, VideoId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditVideo 修改
+func (r *VideoDao) EditVideo(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.Video{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditVideoById 修改-id
+func (r *VideoDao) EditVideoById(tx *gorm.DB, VideoId int64, data interface{}) error {
+	err := tx.Model(&model.Video{}).Where("video_id = ?", VideoId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetVideoList 获取列表
+func (r *VideoDao) GetVideoList(maps interface{}) (m []*model.Video, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetVideoCount 获取数量
+func (r *VideoDao) GetVideoCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.Video{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetVideoListRand 获取列表-随机
+func (r *VideoDao) GetVideoListRand(maps interface{}, limit int) (m []*model.Video, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddVideo 新增
+func (r *VideoDao) AddVideo(tx *gorm.DB, model *model.Video) (*model.Video, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetVideo 获取
+func (r *VideoDao) GetVideo(maps interface{}) (m *model.Video, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *VideoDao) Inc(tx *gorm.DB, VideoId int64, field string, numeral int) error {
+	err := tx.Model(&model.Video{}).Where("video_id = ?", VideoId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *VideoDao) Dec(tx *gorm.DB, VideoId int64, field string, numeral int) error {
+	err := tx.Model(&model.Video{}).Where("video_id = ?", VideoId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/VideoAuthor.go

@@ -0,0 +1,126 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type VideoAuthorDao struct {
+}
+
+// GetVideoAuthorById 获取数据-id
+func (r *VideoAuthorDao) GetVideoAuthorById(authorId int64) (m *model.VideoAuthor, err error) {
+	err = global.Db.First(&m, authorId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetVideoAuthorPreloadById 获取数据-加载全部关联-id
+func (r *VideoAuthorDao) GetVideoAuthorPreloadById(authorId int64) (m *model.VideoAuthor, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, authorId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteVideoAuthor 删除
+func (r *VideoAuthorDao) DeleteVideoAuthor(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.VideoAuthor{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteVideoAuthorById 删除-id
+func (r *VideoAuthorDao) DeleteVideoAuthorById(tx *gorm.DB, authorId int64) error {
+	if err := tx.Delete(&model.VideoAuthor{}, authorId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditVideoAuthor 修改
+func (r *VideoAuthorDao) EditVideoAuthor(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.VideoAuthor{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditVideoAuthorById 修改-id
+func (r *VideoAuthorDao) EditVideoAuthorById(tx *gorm.DB, authorId int64, data interface{}) error {
+	err := tx.Model(&model.VideoAuthor{}).Where("authorId = ?", authorId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetVideoAuthorList 获取列表
+func (r *VideoAuthorDao) GetVideoAuthorList(maps interface{}) (m []*model.VideoAuthor, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetVideoAuthorCount 获取数量
+func (r *VideoAuthorDao) GetVideoAuthorCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.VideoAuthor{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetVideoAuthorListRand 获取列表-随机
+func (r *VideoAuthorDao) GetVideoAuthorListRand(maps interface{}, limit int) (m []*model.VideoAuthor, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddVideoAuthor 新增
+func (r *VideoAuthorDao) AddVideoAuthor(tx *gorm.DB, model *model.VideoAuthor) (*model.VideoAuthor, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetVideoAuthor 获取
+func (r *VideoAuthorDao) GetVideoAuthor(maps interface{}) (m *model.VideoAuthor, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *VideoAuthorDao) Inc(tx *gorm.DB, authorId int64, field string, numeral int) error {
+	err := tx.Model(&model.VideoAuthor{}).Where("authorId = ?", authorId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *VideoAuthorDao) Dec(tx *gorm.DB, authorId int64, field string, numeral int) error {
+	err := tx.Model(&model.VideoAuthor{}).Where("authorId = ?", authorId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dao/VideoVoteDay.go

@@ -0,0 +1,126 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"vote-api/api/model"
+	"vote-api/global"
+)
+
+type VideoVoteDayDao struct {
+}
+
+// GetVideoVoteDayById 获取数据-id
+func (r *VideoVoteDayDao) GetVideoVoteDayById(voteDayId int64) (m *model.VideoVoteDay, err error) {
+	err = global.Db.First(&m, voteDayId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetVideoVoteDayPreloadById 获取数据-加载全部关联-id
+func (r *VideoVoteDayDao) GetVideoVoteDayPreloadById(voteDayId int64) (m *model.VideoVoteDay, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, voteDayId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteVideoVoteDay 删除
+func (r *VideoVoteDayDao) DeleteVideoVoteDay(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.VideoVoteDay{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteVideoVoteDayById 删除-id
+func (r *VideoVoteDayDao) DeleteVideoVoteDayById(tx *gorm.DB, authorId int64) error {
+	if err := tx.Delete(&model.VideoVoteDay{}, authorId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditVideoVoteDay 修改
+func (r *VideoVoteDayDao) EditVideoVoteDay(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.VideoVoteDay{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditVideoVoteDayById 修改-id
+func (r *VideoVoteDayDao) EditVideoVoteDayById(tx *gorm.DB, voteDayId int64, data interface{}) error {
+	err := tx.Model(&model.VideoVoteDay{}).Where("vote_day_id = ?", voteDayId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetVideoVoteDayList 获取列表
+func (r *VideoVoteDayDao) GetVideoVoteDayList(maps interface{}) (m []*model.VideoVoteDay, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetVideoVoteDayCount 获取数量
+func (r *VideoVoteDayDao) GetVideoVoteDayCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.VideoVoteDay{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetVideoVoteDayListRand 获取列表-随机
+func (r *VideoVoteDayDao) GetVideoVoteDayListRand(maps interface{}, limit int) (m []*model.VideoVoteDay, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddVideoVoteDay 新增
+func (r *VideoVoteDayDao) AddVideoVoteDay(tx *gorm.DB, model *model.VideoVoteDay) (*model.VideoVoteDay, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetVideoVoteDay 获取
+func (r *VideoVoteDayDao) GetVideoVoteDay(maps interface{}) (m *model.VideoVoteDay, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *VideoVoteDayDao) Inc(tx *gorm.DB, voteDayId int64, field string, numeral int) error {
+	err := tx.Model(&model.VideoVoteDay{}).Where("vote_day_id = ?", voteDayId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *VideoVoteDayDao) Dec(tx *gorm.DB, voteDayId int64, field string, numeral int) error {
+	err := tx.Model(&model.VideoVoteDay{}).Where("vote_day_id = ?", voteDayId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/dto/Login.go

@@ -0,0 +1,6 @@
+package dto
+
+type LoginDto struct {
+	UserId string `json:"user_id"` // 用户id
+	Token  string `json:"token"`   // token
+}

api/dto/User.go

@@ -0,0 +1,16 @@
+package dto
+
+import (
+	"vote-api/api/model"
+)
+
+// UserDto 用户表
+type UserDto struct {
+	UserId     string           `json:"user_id"`     // 用户id
+	UserStatus int              `json:"user_status"` // 状态（1:正常 2:禁用）
+	OpenId     string           `json:"open_id"`     // 用户微信标识
+	LoginAt    *model.LocalTime `json:"login_at"`    // 登陆时间
+	LoginIp    string           `json:"login_ip"`    // 登陆ip
+	CreatedAt  model.LocalTime  `json:"created_at"`  // 创建时间
+	UpdatedAt  model.LocalTime  `json:"updated_at"`  // 更新时间
+}

api/exception/exception.go

@@ -0,0 +1,43 @@
+package exception
+
+import (
+	"github.com/gin-gonic/gin"
+	"log"
+	"net/http"
+	"runtime/debug"
+	"vote-api/consts"
+)
+
+// Recover
+// @Description: 处理全局异常
+// @return gin.HandlerFunc
+func Recover() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		defer func() {
+			if r := recover(); r != nil {
+				// 打印错误堆栈信息
+				log.Printf("panic: %v\n", r)
+				debug.PrintStack()
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"code":    consts.ServerError,
+					"message": errorToString(r),
+					"data":    "",
+				})
+				// 终止后续接口调用，不加的话recover到异常后，还会继续执行接口里后续代码
+				c.Abort()
+			}
+		}()
+		// 加载完 defer recover，继续后续接口调用
+		c.Next()
+	}
+}
+
+// recover错误，转string
+func errorToString(r interface{}) string {
+	switch v := r.(type) {
+	case error:
+		return v.Error()
+	default:
+		return r.(string)
+	}
+}

api/middlewares/auth.go

@@ -0,0 +1,39 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"vote-api/api/dao"
+	"vote-api/api/responses"
+)
+
+// Auth Auth认证
+func Auth() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 获取用户id
+		userId := c.GetInt64("UserId")
+		if userId == 0 {
+			responses.Fail(c)
+			c.Abort()
+			return
+		}
+
+		// 获取用户数据
+		userDao := dao.UserDao{}
+		user, err := userDao.GetUserById(userId)
+		if err != nil || user == nil {
+			responses.FailWithMessage("用户数据错误", c)
+			c.Abort()
+			return
+		}
+
+		if user.UserStatus == 2 {
+			responses.FailWithMessage("用户已禁用", c)
+			c.Abort()
+			return
+		}
+
+		c.Set("UserId", userId) // 用户id
+
+		c.Next()
+	}
+}

api/middlewares/cors.go

@@ -0,0 +1,29 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+// Cors
+// @Description: 跨域中间件
+// @return gin.HandlerFunc
+func Cors() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		method := c.Request.Method
+		origin := c.Request.Header.Get("Origin")
+		if origin != "" {
+			c.Header("Access-Control-Allow-Origin", origin)
+			c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
+			c.Header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization")
+			c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type")
+			c.Header("Access-Control-Allow-Credentials", "false")
+			c.Set("content-type", "application/json")
+		}
+		if method == "OPTIONS" {
+			c.AbortWithStatus(http.StatusNoContent)
+			return
+		}
+		c.Next()
+	}
+}

api/middlewares/jwt.go

@@ -0,0 +1,72 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"strings"
+	"vote-api/consts"
+	"vote-api/global"
+	"vote-api/utils"
+)
+
+// Jwt jwt认证
+func Jwt() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authorization := c.Request.Header.Get("Authorization")
+		if authorization == "" || !strings.HasPrefix(authorization, "Bearer ") {
+			c.JSON(http.StatusUnauthorized, gin.H{
+				"message": "请求未授权",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+			c.Abort()
+			return
+		}
+
+		// 去除Bearer
+		authorization = authorization[7:] // 截取字符
+
+		// 检测是否存在黑名单
+		res, _ := global.Redis.Get(c, "jwt_black_"+authorization).Result()
+		if res != "" {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "token错误/过期",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+
+			c.Abort()
+			return
+		}
+
+		// 解析jwt
+		t, err := utils.ParseJwt(authorization)
+		if err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "token错误/过期",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+
+			c.Abort()
+			return
+		}
+
+		// 转换类型
+		userId, err := strconv.ParseInt(t.UserId, 10, 64)
+		if err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "token错误",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+
+			c.Abort()
+			return
+		}
+
+		c.Set("UserId", userId) // 用户id
+		c.Next()
+	}
+}

api/middlewares/logrus.go

@@ -0,0 +1,60 @@
+package middlewares
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"time"
+	"vote-api/global"
+)
+
+// Logrus 日志中间件
+func Logrus() gin.HandlerFunc {
+	return func(c *gin.Context) {
+
+		// 开始时间
+		startTime := time.Now()
+
+		// 处理请求
+		c.Next()
+
+		// 获取 请求 参数
+		params := make(map[string]string)
+
+		paramsRaw, ok := c.Get("params")
+		if ok {
+			requestParams, ok := paramsRaw.(map[string]string)
+			if ok || len(requestParams) > 0 {
+				params = requestParams
+			}
+		}
+
+		// 结束时间
+		endTime := time.Now()
+
+		// 执行时间
+		latencyTime := fmt.Sprintf("%6v", endTime.Sub(startTime))
+
+		// 请求方式
+		reqMethod := c.Request.Method
+
+		// 请求路由
+		reqUri := c.Request.RequestURI
+
+		// 状态码
+		statusCode := c.Writer.Status()
+
+		// 请求IP
+		clientIP := c.ClientIP()
+
+		// 日志格式
+		global.Logger.WithFields(logrus.Fields{
+			"http_status": statusCode,
+			"total_time":  latencyTime,
+			"ip":          clientIP,
+			"method":      reqMethod,
+			"uri":         reqUri,
+			"params":      params,
+		}).Info("access")
+	}
+}

api/middlewares/requestParamsMiddleware.go

@@ -0,0 +1,92 @@
+package middlewares
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"vote-api/consts"
+)
+
+// RequestParamsMiddleware 获取请求参数中间件
+func RequestParamsMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		contentType := c.Request.Header.Get("Content-Type")
+
+		params := make(map[string]string)
+
+		// 判断请求参数类型
+		switch contentType {
+		case "application/json":
+			// 解析 application/json 请求体
+			bodyBytes, err := io.ReadAll(c.Request.Body)
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read request body"})
+				c.Abort()
+				return
+			}
+
+			// 创建新的请求对象，并设置请求体数据
+			c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+			var jsonParams map[string]interface{}
+			err = json.Unmarshal(bodyBytes, &jsonParams)
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"message": "Invalid JSON data",
+					"code":    consts.HttpError,
+					"data":    "",
+				})
+				c.Abort()
+				return
+			}
+
+			for key, value := range jsonParams {
+				params[key] = fmt.Sprintf("%v", value)
+			}
+
+			// 存储参数到上下文
+			c.Set("params", params)
+
+		case "multipart/form-data", "application/form-data", "application/x-www-form-urlencoded":
+			// 解析 Form 表单参数
+			err := c.Request.ParseForm()
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"message": "Invalid form data",
+					"code":    consts.HttpError,
+					"data":    "",
+				})
+				c.Abort()
+				return
+			}
+
+			for key, values := range c.Request.Form {
+				if len(values) > 0 {
+					params[key] = fmt.Sprintf("%v", values[0])
+				}
+			}
+
+			// 存储参数到上下文
+			c.Set("params", params)
+
+		default:
+			// 解析 URL 参数
+			queryParams := c.Request.URL.Query()
+
+			for key, values := range queryParams {
+				if len(values) > 0 {
+					params[key] = fmt.Sprintf("%v", values[0])
+				}
+			}
+
+			// 存储参数到上下文
+			c.Set("params", params)
+		}
+
+		// 继续处理请求
+		c.Next()
+	}
+}

api/model/Article.go

@@ -0,0 +1,37 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// Article 文章表
+type Article struct {
+	ArticleId      int64      `gorm:"column:article_id;type:bigint(19);primary_key;comment:主键id" json:"article_id"`
+	ArticleTitle   string     `gorm:"column:article_title;type:varchar(200);comment:文章标题" json:"article_title"`
+	ArticleStatus  int        `gorm:"column:article_status;type:tinyint(1);default:1;comment:文章状态（1:正常 2:禁用）" json:"article_status"`
+	StartTime      *LocalTime `gorm:"column:start_time;type:datetime;comment:开始投票时间" json:"start_time"`
+	EndTime        *LocalTime `gorm:"column:end_time;type:datetime;comment:结束投票时间" json:"end_time"`
+	VoteNum        uint       `gorm:"column:vote_num;type:int(10) unsigned;default:0;comment:总票数" json:"vote_num"`
+	ArticleContent string     `gorm:"column:article_content;type:text;comment:文章内容" json:"article_content"`
+	Model
+}
+
+func (m *Article) TableName() string {
+	return "article"
+}
+
+func (m *Article) BeforeCreate(tx *gorm.DB) error {
+	if m.ArticleId == 0 {
+		m.ArticleId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/ArticleAuthor.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// ArticleAuthor 文章-作者表
+type ArticleAuthor struct {
+	AuthorId   int64  `gorm:"column:author_id;type:bigint(19);primary_key;comment:主键id" json:"author_id"`
+	ArticleId  int64  `gorm:"column:article_id;type:bigint(19);comment:文章id;NOT NULL" json:"article_id"`
+	AuthorName string `gorm:"column:author_name;type:varchar(100);comment:作者姓名" json:"author_name"`
+	HospitalId int64  `gorm:"column:hospital_id;type:bigint(19);comment:作者所属医院id" json:"hospital_id"`
+	Model
+}
+
+func (m *ArticleAuthor) TableName() string {
+	return "article_author"
+}
+
+func (m *ArticleAuthor) BeforeCreate(tx *gorm.DB) error {
+	if m.AuthorId == 0 {
+		m.AuthorId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/ArticleVoteDay.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// ArticleVoteDay 文章-每日投票
+type ArticleVoteDay struct {
+	VoteDayId int64      `gorm:"column:vote_day_id;type:bigint(19);primary_key;comment:主键id" json:"vote_day_id"`
+	ArticleId int64      `gorm:"column:article_id;type:bigint(19);comment:文章id;NOT NULL" json:"article_id"`
+	UserId    int64      `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	VotedAt   *LocalTime `gorm:"column:voted_at;type:date;comment:投票时间（日）" json:"voted_at"`
+	Model
+}
+
+func (m *ArticleVoteDay) TableName() string {
+	return "article_vote_day"
+}
+
+func (m *ArticleVoteDay) BeforeCreate(tx *gorm.DB) error {
+	if m.VoteDayId == 0 {
+		m.VoteDayId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/Data.go

@@ -0,0 +1,33 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// Data 数据表
+type Data struct {
+	DataId  int64 `gorm:"column:data_id;type:bigint(19);primary_key;comment:主键id" json:"data_id"`
+	ViewNum uint  `gorm:"column:view_num;type:int(10) unsigned;default:0;comment:浏览数量" json:"view_num"`
+	VoteNum uint  `gorm:"column:vote_num;type:int(10) unsigned;comment:投票数量" json:"vote_num"`
+	Model
+}
+
+func (m *Data) TableName() string {
+	return "data"
+}
+
+func (m *Data) BeforeCreate(tx *gorm.DB) error {
+	if m.DataId == 0 {
+		m.DataId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/User.go

@@ -0,0 +1,36 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// User 用户表
+type User struct {
+	UserId     int64      `gorm:"column:user_id;type:bigint(19);primary_key;comment:用户id" json:"user_id"`
+	AppIden    string     `gorm:"column:app_iden;type:varchar(50);comment:app唯一标识" json:"app_iden"`
+	UserStatus int        `gorm:"column:user_status;type:tinyint(1);default:1;comment:状态（1:正常 2:禁用）" json:"user_status"`
+	OpenId     string     `gorm:"column:open_id;type:varchar(100);comment:用户微信标识" json:"open_id"`
+	LoginAt    *LocalTime `gorm:"column:login_at;type:datetime;comment:登陆时间" json:"login_at"`
+	LoginIp    string     `gorm:"column:login_ip;type:varchar(255);comment:登陆ip" json:"login_ip"`
+	Model
+}
+
+func (m *User) TableName() string {
+	return "user"
+}
+
+func (m *User) BeforeCreate(tx *gorm.DB) error {
+	if m.UserId == 0 {
+		m.UserId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/Video.go

@@ -0,0 +1,37 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// Video 视频表
+type Video struct {
+	VideoId     int64      `gorm:"column:video_id;type:bigint(19);primary_key;comment:主键id" json:"video_id"`
+	VideoTitle  string     `gorm:"column:video_title;type:varchar(200);comment:视频标题" json:"video_title"`
+	VideoStatus int        `gorm:"column:video_status;type:tinyint(1);default:1;comment:视频状态（1:正常 2:禁用）" json:"video_status"`
+	StartTime   *LocalTime `gorm:"column:start_time;type:datetime;comment:开始投票时间" json:"start_time"`
+	EndTime     *LocalTime `gorm:"column:end_time;type:datetime;comment:结束投票时间" json:"end_time"`
+	VoteNum     uint       `gorm:"column:vote_num;type:int(10) unsigned;default:0;comment:总票数" json:"vote_num"`
+	VideoUrl    string     `gorm:"column:video_url;type:varchar(255);comment:视频地址" json:"video_url"`
+	Model
+}
+
+func (m *Video) TableName() string {
+	return "video"
+}
+
+func (m *Video) BeforeCreate(tx *gorm.DB) error {
+	if m.VideoId == 0 {
+		m.VideoId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/VideoAuthor.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// VideoAuthor 视频-作者表
+type VideoAuthor struct {
+	AuthorId   int64  `gorm:"column:author_id;type:bigint(19);primary_key;comment:主键id" json:"author_id"`
+	VideoId    int64  `gorm:"column:video_id;type:bigint(19);comment:视频id;NOT NULL" json:"video_id"`
+	AuthorName string `gorm:"column:author_name;type:varchar(100);comment:作者姓名" json:"author_name"`
+	HospitalId int64  `gorm:"column:hospital_id;type:bigint(19);comment:作者所属医院id" json:"hospital_id"`
+	Model
+}
+
+func (m *VideoAuthor) TableName() string {
+	return "video_author"
+}
+
+func (m *VideoAuthor) BeforeCreate(tx *gorm.DB) error {
+	if m.AuthorId == 0 {
+		m.AuthorId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/VideoVoteDay.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"time"
+	"vote-api/global"
+)
+
+// VideoVoteDay 视频-每日投票
+type VideoVoteDay struct {
+	VoteDayId int64      `gorm:"column:vote_day_id;type:bigint(19);primary_key;comment:主键id" json:"vote_day_id"`
+	VideoId   int64      `gorm:"column:video_id;type:bigint(19);comment:视频id;NOT NULL" json:"video_id"`
+	UserId    int64      `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	VotedAt   *LocalTime `gorm:"column:voted_at;type:date;comment:投票时间（日）" json:"voted_at"`
+	Model
+}
+
+func (m *VideoVoteDay) TableName() string {
+	return "video_vote_day"
+}
+
+func (m *VideoVoteDay) BeforeCreate(tx *gorm.DB) error {
+	if m.VoteDayId == 0 {
+		m.VoteDayId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/model.go

@@ -0,0 +1,87 @@
+package model
+
+import (
+	"database/sql/driver"
+	"errors"
+	"fmt"
+	"gorm.io/gorm"
+	"strings"
+	"time"
+)
+
+type Model struct {
+	CreatedAt LocalTime `gorm:"column:created_at;type:datetime;comment:创建时间" json:"created_at"`
+	UpdatedAt LocalTime `gorm:"column:updated_at;type:datetime;comment:修改时间" json:"updated_at"`
+}
+
+// LocalTime 自定义数据类型
+type LocalTime time.Time
+
+func (t *LocalTime) UnmarshalJSON(data []byte) error {
+	if string(data) == "null" {
+		return nil
+	}
+	var err error
+	// 前端接收的时间字符串
+	str := string(data)
+	// 去除接收的str收尾多余的"
+	timeStr := strings.Trim(str, "\"")
+	t1, err := time.Parse("2006-01-02 15:04:05", timeStr)
+	*t = LocalTime(t1)
+	return err
+}
+
+func (t LocalTime) MarshalJSON() ([]byte, error) {
+	formatted := fmt.Sprintf("\"%v\"", time.Time(t).Format("2006-01-02 15:04:05"))
+	return []byte(formatted), nil
+}
+
+func (t LocalTime) Value() (driver.Value, error) {
+	// MyTime 转换成 time.Time 类型
+	tTime := time.Time(t)
+	return tTime.Format("2006-01-02 15:04:05"), nil
+}
+
+func (t *LocalTime) Scan(v interface{}) error {
+	switch vt := v.(type) {
+	case time.Time:
+		// 字符串转成 time.Time 类型
+		*t = LocalTime(vt)
+	default:
+		return errors.New("类型处理错误")
+	}
+	return nil
+}
+
+func (t *LocalTime) String() string {
+	return fmt.Sprintf("hhh:%s", time.Time(*t).String())
+}
+
+func (t *LocalTime) IsEmpty() bool {
+	return time.Time(*t).IsZero()
+}
+
+func (m *Model) BeforeUpdate(tx *gorm.DB) (err error) {
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}
+
+func Paginate(page, pageSize int) func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		if page <= 0 {
+			page = 1
+		}
+
+		switch {
+		case pageSize > 100:
+			pageSize = 100
+		case pageSize <= 0:
+			pageSize = 10
+		}
+
+		offset := (page - 1) * pageSize
+		return db.Offset(offset).Limit(pageSize)
+	}
+}

api/requests/Login.go

@@ -0,0 +1,10 @@
+package requests
+
+type LoginRequest struct {
+	Login // 登录
+}
+
+// Login 登录
+type Login struct {
+	OpenId string `json:"openid" form:"openid" label:"openid"`
+}

api/requests/base.go

@@ -0,0 +1,4 @@
+package requests
+
+type Requests struct {
+}

api/responses/responses.go

@@ -0,0 +1,52 @@
+package responses
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"vote-api/consts"
+)
+
+type res struct {
+	Code    int         `json:"code"`
+	Data    interface{} `json:"data"`
+	Message string      `json:"message"`
+}
+
+func result(code int, data interface{}, msg string, c *gin.Context) {
+	//if data == nil {
+	//	data = gin.H{}
+	//}
+	c.JSON(http.StatusOK, res{
+		code,
+		data,
+		msg,
+	})
+}
+
+func Ok(c *gin.Context) {
+	result(consts.HttpSuccess, map[string]interface{}{}, "成功", c)
+}
+
+func OkWithMessage(message string, c *gin.Context) {
+	result(consts.HttpSuccess, map[string]interface{}{}, message, c)
+}
+
+func OkWithData(data interface{}, c *gin.Context) {
+	result(consts.HttpSuccess, data, "成功", c)
+}
+
+func OkWithDetailed(data interface{}, message string, c *gin.Context) {
+	result(consts.HttpSuccess, data, message, c)
+}
+
+func Fail(c *gin.Context) {
+	result(consts.HttpError, map[string]interface{}{}, "失败", c)
+}
+
+func FailWithMessage(message string, c *gin.Context) {
+	result(consts.HttpError, map[string]interface{}{}, message, c)
+}
+
+func FailWithDetailed(data interface{}, message string, c *gin.Context) {
+	result(consts.HttpError, data, message, c)
+}

api/router/router.go

@@ -0,0 +1,91 @@
+package router
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"vote-api/api/controller"
+	"vote-api/api/exception"
+	"vote-api/api/middlewares"
+	"vote-api/config"
+	"vote-api/consts"
+)
+
+// Init 初始化路由
+func Init() *gin.Engine {
+	r := gin.New()
+
+	// 环境设置
+	if config.C.Env == "prod" {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	// 获取请求参数中间件-json格式下会导致接口获取不到请求数据
+	r.Use(middlewares.RequestParamsMiddleware())
+
+	// 日志中间件
+	r.Use(middlewares.Logrus())
+
+	// 异常
+	r.Use(gin.Recovery())
+
+	// 404处理
+	r.NoRoute(func(c *gin.Context) {
+		path := c.Request.URL.Path
+		method := c.Request.Method
+		c.JSON(http.StatusNotFound, gin.H{
+			"msg":  fmt.Sprintf("%s %s not found", method, path),
+			"code": consts.ClientHttpNotFound,
+			"data": "",
+		})
+	})
+
+	// 异常处理
+	r.Use(exception.Recover())
+
+	// 跨域处理
+	r.Use(middlewares.Cors())
+
+	// 加载基础路由
+	api := controller.Api{}
+
+	// 公开路由-不验证权限
+	publicRouter(r, api)
+
+	// 验证jwt
+	r.Use(middlewares.Jwt())
+
+	// 验证权限
+	r.Use(middlewares.Auth())
+
+	// 私有路由-验证权限
+	privateRouter(r, api)
+
+	// 公共路由-验证权限
+	adminRouter(r, api)
+
+	// 基础数据-验证权限
+	basicRouter(r, api)
+
+	return r
+}
+
+// publicRouter 公开路由-不验证权限
+func publicRouter(r *gin.Engine, api controller.Api) {
+	// 登录
+	r.POST("/login", api.Login.Login)
+}
+
+// adminRouter 公共路由-验证权限
+func adminRouter(r *gin.Engine, api controller.Api) {
+
+}
+
+// basicRouter 基础数据-验证权限
+func basicRouter(r *gin.Engine, api controller.Api) {
+
+}
+
+// privateRouter 私有路由-验证权限
+func privateRouter(r *gin.Engine, api controller.Api) {
+}

api/service/Public.go

@@ -0,0 +1,17 @@
+package service
+
+import (
+	"net/http"
+)
+
+type PublicService struct {
+}
+
+// GetUserIP 获取用户ip
+func (r *PublicService) GetUserIP(h *http.Request) string {
+	forwarded := h.Header.Get("X-FORWARDED-FOR")
+	if forwarded != "" {
+		return forwarded
+	}
+	return h.RemoteAddr
+}