From 72138aeedb64e087372930dbf2631845684a6c57 Mon Sep 17 00:00:00 2001 From: wucongxing8150 <815046773@qq.com> Date: Wed, 10 Jul 2024 14:10:48 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E4=BA=86dao=E5=92=8Cmodel?= =?UTF-8?q?=E6=95=B0=E6=8D=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- api/dao/BaseAgreement.go | 108 +++++++++++++++++++++++++++++++++ api/dao/BaseClass.go | 108 +++++++++++++++++++++++++++++++++ api/dao/Coupon.go | 108 +++++++++++++++++++++++++++++++++ api/dao/OrderMember.go | 108 +++++++++++++++++++++++++++++++++ api/dao/OrderMemberCoupon.go | 108 +++++++++++++++++++++++++++++++++ api/dao/OrderMemberRefund.go | 108 +++++++++++++++++++++++++++++++++ api/dao/OrderSingle.go | 108 +++++++++++++++++++++++++++++++++ api/dao/OrderSingleCoupon.go | 108 +++++++++++++++++++++++++++++++++ api/dao/OrderSingleRefund.go | 108 +++++++++++++++++++++++++++++++++ api/dao/Question.go | 108 +++++++++++++++++++++++++++++++++ api/dao/QuestionClass.go | 108 +++++++++++++++++++++++++++++++++ api/dao/SystemMember.go | 108 +++++++++++++++++++++++++++++++++ api/dao/SystemSingle.go | 108 +++++++++++++++++++++++++++++++++ api/dao/User.go | 108 +++++++++++++++++++++++++++++++++ api/dao/UserCollection.go | 108 +++++++++++++++++++++++++++++++++ api/dao/UserCoupon.go | 108 +++++++++++++++++++++++++++++++++ api/dao/UserInfo.go | 108 +++++++++++++++++++++++++++++++++ api/model/BaseAgreement.go | 33 ++++++++++ api/model/BaseClass.go | 36 +++++++++++ api/model/Coupon.go | 45 ++++++++++++++ api/model/OrderMember.go | 48 +++++++++++++++ api/model/OrderMemberCoupon.go | 35 +++++++++++ api/model/OrderMemberRefund.go | 40 ++++++++++++ api/model/OrderSingle.go | 48 +++++++++++++++ api/model/OrderSingleCoupon.go | 35 +++++++++++ api/model/OrderSingleRefund.go | 40 ++++++++++++ api/model/Question.go | 43 +++++++++++++ api/model/QuestionClass.go | 33 ++++++++++ api/model/SystemMember.go | 35 +++++++++++ api/model/SystemSingle.go | 33 ++++++++++ api/model/User.go | 44 ++++++++++++++ api/model/UserCollection.go | 33 ++++++++++ api/model/UserCoupon.go | 36 +++++++++++ api/model/UserInfo.go | 43 +++++++++++++ 34 files changed, 2496 insertions(+) create mode 100644 api/dao/BaseAgreement.go create mode 100644 api/dao/BaseClass.go create mode 100644 api/dao/Coupon.go create mode 100644 api/dao/OrderMember.go create mode 100644 api/dao/OrderMemberCoupon.go create mode 100644 api/dao/OrderMemberRefund.go create mode 100644 api/dao/OrderSingle.go create mode 100644 api/dao/OrderSingleCoupon.go create mode 100644 api/dao/OrderSingleRefund.go create mode 100644 api/dao/Question.go create mode 100644 api/dao/QuestionClass.go create mode 100644 api/dao/SystemMember.go create mode 100644 api/dao/SystemSingle.go create mode 100644 api/dao/User.go create mode 100644 api/dao/UserCollection.go create mode 100644 api/dao/UserCoupon.go create mode 100644 api/dao/UserInfo.go create mode 100644 api/model/BaseAgreement.go create mode 100644 api/model/BaseClass.go create mode 100644 api/model/Coupon.go create mode 100644 api/model/OrderMember.go create mode 100644 api/model/OrderMemberCoupon.go create mode 100644 api/model/OrderMemberRefund.go create mode 100644 api/model/OrderSingle.go create mode 100644 api/model/OrderSingleCoupon.go create mode 100644 api/model/OrderSingleRefund.go create mode 100644 api/model/Question.go create mode 100644 api/model/QuestionClass.go create mode 100644 api/model/SystemMember.go create mode 100644 api/model/SystemSingle.go create mode 100644 api/model/User.go create mode 100644 api/model/UserCollection.go create mode 100644 api/model/UserCoupon.go create mode 100644 api/model/UserInfo.go diff --git a/api/dao/BaseAgreement.go b/api/dao/BaseAgreement.go new file mode 100644 index 0000000..ef33ae1 --- /dev/null +++ b/api/dao/BaseAgreement.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type BaseAgreementDao struct { +} + +// GetBaseAgreementById 获取数据-id +func (r *BaseAgreementDao) GetBaseAgreementById(BaseAgreementId int64) (m *model.BaseAgreement, err error) { + err = global.Db.First(&m, BaseAgreementId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBaseAgreementPreloadById 获取数据-加载全部关联-id +func (r *BaseAgreementDao) GetBaseAgreementPreloadById(BaseAgreementId int64) (m *model.BaseAgreement, err error) { + err = global.Db.Preload(clause.Associations).First(&m, BaseAgreementId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteBaseAgreement 删除 +func (r *BaseAgreementDao) DeleteBaseAgreement(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.BaseAgreement{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteBaseAgreementById 删除-id +func (r *BaseAgreementDao) DeleteBaseAgreementById(tx *gorm.DB, BaseAgreementId int64) error { + if err := tx.Delete(&model.BaseAgreement{}, BaseAgreementId).Error; err != nil { + return err + } + return nil +} + +// EditBaseAgreement 修改 +func (r *BaseAgreementDao) EditBaseAgreement(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.BaseAgreement{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditBaseAgreementById 修改-id +func (r *BaseAgreementDao) EditBaseAgreementById(tx *gorm.DB, BaseAgreementId int64, data interface{}) error { + err := tx.Model(&model.BaseAgreement{}).Where("agreement_id = ?", BaseAgreementId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetBaseAgreementList 获取列表 +func (r *BaseAgreementDao) GetBaseAgreementList(maps interface{}) (m []*model.BaseAgreement, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBaseAgreementCount 获取数量 +func (r *BaseAgreementDao) GetBaseAgreementCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.BaseAgreement{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetBaseAgreementListRand 获取列表-随机 +func (r *BaseAgreementDao) GetBaseAgreementListRand(maps interface{}, limit int) (m []*model.BaseAgreement, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddBaseAgreement 新增 +func (r *BaseAgreementDao) AddBaseAgreement(tx *gorm.DB, model *model.BaseAgreement) (*model.BaseAgreement, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetBaseAgreement 获取 +func (r *BaseAgreementDao) GetBaseAgreement(maps interface{}) (m *model.BaseAgreement, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/BaseClass.go b/api/dao/BaseClass.go new file mode 100644 index 0000000..a44d695 --- /dev/null +++ b/api/dao/BaseClass.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type BaseClassDao struct { +} + +// GetBaseClassById 获取数据-id +func (r *BaseClassDao) GetBaseClassById(BaseClassId int64) (m *model.BaseClass, err error) { + err = global.Db.First(&m, BaseClassId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBaseClassPreloadById 获取数据-加载全部关联-id +func (r *BaseClassDao) GetBaseClassPreloadById(BaseClassId int64) (m *model.BaseClass, err error) { + err = global.Db.Preload(clause.Associations).First(&m, BaseClassId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteBaseClass 删除 +func (r *BaseClassDao) DeleteBaseClass(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.BaseClass{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteBaseClassById 删除-id +func (r *BaseClassDao) DeleteBaseClassById(tx *gorm.DB, BaseClassId int64) error { + if err := tx.Delete(&model.BaseClass{}, BaseClassId).Error; err != nil { + return err + } + return nil +} + +// EditBaseClass 修改 +func (r *BaseClassDao) EditBaseClass(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.BaseClass{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditBaseClassById 修改-id +func (r *BaseClassDao) EditBaseClassById(tx *gorm.DB, BaseClassId int64, data interface{}) error { + err := tx.Model(&model.BaseClass{}).Where("class_id = ?", BaseClassId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetBaseClassList 获取列表 +func (r *BaseClassDao) GetBaseClassList(maps interface{}) (m []*model.BaseClass, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBaseClassCount 获取数量 +func (r *BaseClassDao) GetBaseClassCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.BaseClass{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetBaseClassListRand 获取列表-随机 +func (r *BaseClassDao) GetBaseClassListRand(maps interface{}, limit int) (m []*model.BaseClass, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddBaseClass 新增 +func (r *BaseClassDao) AddBaseClass(tx *gorm.DB, model *model.BaseClass) (*model.BaseClass, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetBaseClass 获取 +func (r *BaseClassDao) GetBaseClass(maps interface{}) (m *model.BaseClass, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/Coupon.go b/api/dao/Coupon.go new file mode 100644 index 0000000..f466675 --- /dev/null +++ b/api/dao/Coupon.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type CouponDao struct { +} + +// GetCouponById 获取数据-id +func (r *CouponDao) GetCouponById(CouponId int64) (m *model.Coupon, err error) { + err = global.Db.First(&m, CouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetCouponPreloadById 获取数据-加载全部关联-id +func (r *CouponDao) GetCouponPreloadById(CouponId int64) (m *model.Coupon, err error) { + err = global.Db.Preload(clause.Associations).First(&m, CouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteCoupon 删除 +func (r *CouponDao) DeleteCoupon(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.Coupon{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteCouponById 删除-id +func (r *CouponDao) DeleteCouponById(tx *gorm.DB, CouponId int64) error { + if err := tx.Delete(&model.Coupon{}, CouponId).Error; err != nil { + return err + } + return nil +} + +// EditCoupon 修改 +func (r *CouponDao) EditCoupon(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.Coupon{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditCouponById 修改-id +func (r *CouponDao) EditCouponById(tx *gorm.DB, CouponId int64, data interface{}) error { + err := tx.Model(&model.Coupon{}).Where("coupon_id = ?", CouponId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetCouponList 获取列表 +func (r *CouponDao) GetCouponList(maps interface{}) (m []*model.Coupon, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetCouponCount 获取数量 +func (r *CouponDao) GetCouponCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.Coupon{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetCouponListRand 获取列表-随机 +func (r *CouponDao) GetCouponListRand(maps interface{}, limit int) (m []*model.Coupon, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddCoupon 新增 +func (r *CouponDao) AddCoupon(tx *gorm.DB, model *model.Coupon) (*model.Coupon, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetCoupon 获取 +func (r *CouponDao) GetCoupon(maps interface{}) (m *model.Coupon, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/OrderMember.go b/api/dao/OrderMember.go new file mode 100644 index 0000000..58b931c --- /dev/null +++ b/api/dao/OrderMember.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type OrderMemberDao struct { +} + +// GetOrderMemberById 获取数据-id +func (r *OrderMemberDao) GetOrderMemberById(OrderMemberId int64) (m *model.OrderMember, err error) { + err = global.Db.First(&m, OrderMemberId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderMemberPreloadById 获取数据-加载全部关联-id +func (r *OrderMemberDao) GetOrderMemberPreloadById(OrderMemberId int64) (m *model.OrderMember, err error) { + err = global.Db.Preload(clause.Associations).First(&m, OrderMemberId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteOrderMember 删除 +func (r *OrderMemberDao) DeleteOrderMember(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.OrderMember{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteOrderMemberById 删除-id +func (r *OrderMemberDao) DeleteOrderMemberById(tx *gorm.DB, OrderMemberId int64) error { + if err := tx.Delete(&model.OrderMember{}, OrderMemberId).Error; err != nil { + return err + } + return nil +} + +// EditOrderMember 修改 +func (r *OrderMemberDao) EditOrderMember(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.OrderMember{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditOrderMemberById 修改-id +func (r *OrderMemberDao) EditOrderMemberById(tx *gorm.DB, OrderMemberId int64, data interface{}) error { + err := tx.Model(&model.OrderMember{}).Where("order_id = ?", OrderMemberId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetOrderMemberList 获取列表 +func (r *OrderMemberDao) GetOrderMemberList(maps interface{}) (m []*model.OrderMember, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderMemberCount 获取数量 +func (r *OrderMemberDao) GetOrderMemberCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.OrderMember{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetOrderMemberListRand 获取列表-随机 +func (r *OrderMemberDao) GetOrderMemberListRand(maps interface{}, limit int) (m []*model.OrderMember, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddOrderMember 新增 +func (r *OrderMemberDao) AddOrderMember(tx *gorm.DB, model *model.OrderMember) (*model.OrderMember, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetOrderMember 获取 +func (r *OrderMemberDao) GetOrderMember(maps interface{}) (m *model.OrderMember, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/OrderMemberCoupon.go b/api/dao/OrderMemberCoupon.go new file mode 100644 index 0000000..bef4f7c --- /dev/null +++ b/api/dao/OrderMemberCoupon.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type OrderMemberCouponDao struct { +} + +// GetOrderMemberCouponById 获取数据-id +func (r *OrderMemberCouponDao) GetOrderMemberCouponById(OrderMemberCouponId int64) (m *model.OrderMemberCoupon, err error) { + err = global.Db.First(&m, OrderMemberCouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderMemberCouponPreloadById 获取数据-加载全部关联-id +func (r *OrderMemberCouponDao) GetOrderMemberCouponPreloadById(OrderMemberCouponId int64) (m *model.OrderMemberCoupon, err error) { + err = global.Db.Preload(clause.Associations).First(&m, OrderMemberCouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteOrderMemberCoupon 删除 +func (r *OrderMemberCouponDao) DeleteOrderMemberCoupon(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.OrderMemberCoupon{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteOrderMemberCouponById 删除-id +func (r *OrderMemberCouponDao) DeleteOrderMemberCouponById(tx *gorm.DB, OrderMemberCouponId int64) error { + if err := tx.Delete(&model.OrderMemberCoupon{}, OrderMemberCouponId).Error; err != nil { + return err + } + return nil +} + +// EditOrderMemberCoupon 修改 +func (r *OrderMemberCouponDao) EditOrderMemberCoupon(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.OrderMemberCoupon{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditOrderMemberCouponById 修改-id +func (r *OrderMemberCouponDao) EditOrderMemberCouponById(tx *gorm.DB, OrderMemberCouponId int64, data interface{}) error { + err := tx.Model(&model.OrderMemberCoupon{}).Where("order_coupon_id = ?", OrderMemberCouponId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetOrderMemberCouponList 获取列表 +func (r *OrderMemberCouponDao) GetOrderMemberCouponList(maps interface{}) (m []*model.OrderMemberCoupon, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderMemberCouponCount 获取数量 +func (r *OrderMemberCouponDao) GetOrderMemberCouponCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.OrderMemberCoupon{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetOrderMemberCouponListRand 获取列表-随机 +func (r *OrderMemberCouponDao) GetOrderMemberCouponListRand(maps interface{}, limit int) (m []*model.OrderMemberCoupon, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddOrderMemberCoupon 新增 +func (r *OrderMemberCouponDao) AddOrderMemberCoupon(tx *gorm.DB, model *model.OrderMemberCoupon) (*model.OrderMemberCoupon, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetOrderMemberCoupon 获取 +func (r *OrderMemberCouponDao) GetOrderMemberCoupon(maps interface{}) (m *model.OrderMemberCoupon, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/OrderMemberRefund.go b/api/dao/OrderMemberRefund.go new file mode 100644 index 0000000..83ffe78 --- /dev/null +++ b/api/dao/OrderMemberRefund.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type OrderMemberRefundDao struct { +} + +// GetOrderMemberRefundById 获取数据-id +func (r *OrderMemberRefundDao) GetOrderMemberRefundById(OrderMemberRefundId int64) (m *model.OrderMemberRefund, err error) { + err = global.Db.First(&m, OrderMemberRefundId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderMemberRefundPreloadById 获取数据-加载全部关联-id +func (r *OrderMemberRefundDao) GetOrderMemberRefundPreloadById(OrderMemberRefundId int64) (m *model.OrderMemberRefund, err error) { + err = global.Db.Preload(clause.Associations).First(&m, OrderMemberRefundId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteOrderMemberRefund 删除 +func (r *OrderMemberRefundDao) DeleteOrderMemberRefund(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.OrderMemberRefund{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteOrderMemberRefundById 删除-id +func (r *OrderMemberRefundDao) DeleteOrderMemberRefundById(tx *gorm.DB, OrderMemberRefundId int64) error { + if err := tx.Delete(&model.OrderMemberRefund{}, OrderMemberRefundId).Error; err != nil { + return err + } + return nil +} + +// EditOrderMemberRefund 修改 +func (r *OrderMemberRefundDao) EditOrderMemberRefund(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.OrderMemberRefund{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditOrderMemberRefundById 修改-id +func (r *OrderMemberRefundDao) EditOrderMemberRefundById(tx *gorm.DB, OrderMemberRefundId int64, data interface{}) error { + err := tx.Model(&model.OrderMemberRefund{}).Where("order_refund_id = ?", OrderMemberRefundId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetOrderMemberRefundList 获取列表 +func (r *OrderMemberRefundDao) GetOrderMemberRefundList(maps interface{}) (m []*model.OrderMemberRefund, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderMemberRefundCount 获取数量 +func (r *OrderMemberRefundDao) GetOrderMemberRefundCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.OrderMemberRefund{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetOrderMemberRefundListRand 获取列表-随机 +func (r *OrderMemberRefundDao) GetOrderMemberRefundListRand(maps interface{}, limit int) (m []*model.OrderMemberRefund, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddOrderMemberRefund 新增 +func (r *OrderMemberRefundDao) AddOrderMemberRefund(tx *gorm.DB, model *model.OrderMemberRefund) (*model.OrderMemberRefund, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetOrderMemberRefund 获取 +func (r *OrderMemberRefundDao) GetOrderMemberRefund(maps interface{}) (m *model.OrderMemberRefund, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/OrderSingle.go b/api/dao/OrderSingle.go new file mode 100644 index 0000000..d9e73b0 --- /dev/null +++ b/api/dao/OrderSingle.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type OrderSingleDao struct { +} + +// GetOrderSingleById 获取数据-id +func (r *OrderSingleDao) GetOrderSingleById(OrderSingleId int64) (m *model.OrderSingle, err error) { + err = global.Db.First(&m, OrderSingleId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderSinglePreloadById 获取数据-加载全部关联-id +func (r *OrderSingleDao) GetOrderSinglePreloadById(OrderSingleId int64) (m *model.OrderSingle, err error) { + err = global.Db.Preload(clause.Associations).First(&m, OrderSingleId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteOrderSingle 删除 +func (r *OrderSingleDao) DeleteOrderSingle(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.OrderSingle{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteOrderSingleById 删除-id +func (r *OrderSingleDao) DeleteOrderSingleById(tx *gorm.DB, OrderSingleId int64) error { + if err := tx.Delete(&model.OrderSingle{}, OrderSingleId).Error; err != nil { + return err + } + return nil +} + +// EditOrderSingle 修改 +func (r *OrderSingleDao) EditOrderSingle(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.OrderSingle{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditOrderSingleById 修改-id +func (r *OrderSingleDao) EditOrderSingleById(tx *gorm.DB, OrderSingleId int64, data interface{}) error { + err := tx.Model(&model.OrderSingle{}).Where("order_id = ?", OrderSingleId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetOrderSingleList 获取列表 +func (r *OrderSingleDao) GetOrderSingleList(maps interface{}) (m []*model.OrderSingle, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderSingleCount 获取数量 +func (r *OrderSingleDao) GetOrderSingleCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.OrderSingle{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetOrderSingleListRand 获取列表-随机 +func (r *OrderSingleDao) GetOrderSingleListRand(maps interface{}, limit int) (m []*model.OrderSingle, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddOrderSingle 新增 +func (r *OrderSingleDao) AddOrderSingle(tx *gorm.DB, model *model.OrderSingle) (*model.OrderSingle, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetOrderSingle 获取 +func (r *OrderSingleDao) GetOrderSingle(maps interface{}) (m *model.OrderSingle, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/OrderSingleCoupon.go b/api/dao/OrderSingleCoupon.go new file mode 100644 index 0000000..38b982d --- /dev/null +++ b/api/dao/OrderSingleCoupon.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type OrderSingleCouponDao struct { +} + +// GetOrderSingleCouponById 获取数据-id +func (r *OrderSingleCouponDao) GetOrderSingleCouponById(OrderSingleCouponId int64) (m *model.OrderSingleCoupon, err error) { + err = global.Db.First(&m, OrderSingleCouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderSingleCouponPreloadById 获取数据-加载全部关联-id +func (r *OrderSingleCouponDao) GetOrderSingleCouponPreloadById(OrderSingleCouponId int64) (m *model.OrderSingleCoupon, err error) { + err = global.Db.Preload(clause.Associations).First(&m, OrderSingleCouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteOrderSingleCoupon 删除 +func (r *OrderSingleCouponDao) DeleteOrderSingleCoupon(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.OrderSingleCoupon{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteOrderSingleCouponById 删除-id +func (r *OrderSingleCouponDao) DeleteOrderSingleCouponById(tx *gorm.DB, OrderSingleCouponId int64) error { + if err := tx.Delete(&model.OrderSingleCoupon{}, OrderSingleCouponId).Error; err != nil { + return err + } + return nil +} + +// EditOrderSingleCoupon 修改 +func (r *OrderSingleCouponDao) EditOrderSingleCoupon(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.OrderSingleCoupon{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditOrderSingleCouponById 修改-id +func (r *OrderSingleCouponDao) EditOrderSingleCouponById(tx *gorm.DB, OrderSingleCouponId int64, data interface{}) error { + err := tx.Model(&model.OrderSingleCoupon{}).Where("order_coupon_id = ?", OrderSingleCouponId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetOrderSingleCouponList 获取列表 +func (r *OrderSingleCouponDao) GetOrderSingleCouponList(maps interface{}) (m []*model.OrderSingleCoupon, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderSingleCouponCount 获取数量 +func (r *OrderSingleCouponDao) GetOrderSingleCouponCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.OrderSingleCoupon{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetOrderSingleCouponListRand 获取列表-随机 +func (r *OrderSingleCouponDao) GetOrderSingleCouponListRand(maps interface{}, limit int) (m []*model.OrderSingleCoupon, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddOrderSingleCoupon 新增 +func (r *OrderSingleCouponDao) AddOrderSingleCoupon(tx *gorm.DB, model *model.OrderSingleCoupon) (*model.OrderSingleCoupon, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetOrderSingleCoupon 获取 +func (r *OrderSingleCouponDao) GetOrderSingleCoupon(maps interface{}) (m *model.OrderSingleCoupon, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/OrderSingleRefund.go b/api/dao/OrderSingleRefund.go new file mode 100644 index 0000000..1c69f9c --- /dev/null +++ b/api/dao/OrderSingleRefund.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type OrderSingleRefundDao struct { +} + +// GetOrderSingleRefundById 获取数据-id +func (r *OrderSingleRefundDao) GetOrderSingleRefundById(OrderSingleRefundId int64) (m *model.OrderSingleRefund, err error) { + err = global.Db.First(&m, OrderSingleRefundId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderSingleRefundPreloadById 获取数据-加载全部关联-id +func (r *OrderSingleRefundDao) GetOrderSingleRefundPreloadById(OrderSingleRefundId int64) (m *model.OrderSingleRefund, err error) { + err = global.Db.Preload(clause.Associations).First(&m, OrderSingleRefundId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteOrderSingleRefund 删除 +func (r *OrderSingleRefundDao) DeleteOrderSingleRefund(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.OrderSingleRefund{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteOrderSingleRefundById 删除-id +func (r *OrderSingleRefundDao) DeleteOrderSingleRefundById(tx *gorm.DB, OrderSingleRefundId int64) error { + if err := tx.Delete(&model.OrderSingleRefund{}, OrderSingleRefundId).Error; err != nil { + return err + } + return nil +} + +// EditOrderSingleRefund 修改 +func (r *OrderSingleRefundDao) EditOrderSingleRefund(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.OrderSingleRefund{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditOrderSingleRefundById 修改-id +func (r *OrderSingleRefundDao) EditOrderSingleRefundById(tx *gorm.DB, OrderSingleRefundId int64, data interface{}) error { + err := tx.Model(&model.OrderSingleRefund{}).Where("order_refund_id = ?", OrderSingleRefundId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetOrderSingleRefundList 获取列表 +func (r *OrderSingleRefundDao) GetOrderSingleRefundList(maps interface{}) (m []*model.OrderSingleRefund, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetOrderSingleRefundCount 获取数量 +func (r *OrderSingleRefundDao) GetOrderSingleRefundCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.OrderSingleRefund{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetOrderSingleRefundListRand 获取列表-随机 +func (r *OrderSingleRefundDao) GetOrderSingleRefundListRand(maps interface{}, limit int) (m []*model.OrderSingleRefund, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddOrderSingleRefund 新增 +func (r *OrderSingleRefundDao) AddOrderSingleRefund(tx *gorm.DB, model *model.OrderSingleRefund) (*model.OrderSingleRefund, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetOrderSingleRefund 获取 +func (r *OrderSingleRefundDao) GetOrderSingleRefund(maps interface{}) (m *model.OrderSingleRefund, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/Question.go b/api/dao/Question.go new file mode 100644 index 0000000..a0a8c5d --- /dev/null +++ b/api/dao/Question.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type QuestionDao struct { +} + +// GetQuestionById 获取数据-id +func (r *QuestionDao) GetQuestionById(QuestionId int64) (m *model.Question, err error) { + err = global.Db.First(&m, QuestionId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetQuestionPreloadById 获取数据-加载全部关联-id +func (r *QuestionDao) GetQuestionPreloadById(QuestionId int64) (m *model.Question, err error) { + err = global.Db.Preload(clause.Associations).First(&m, QuestionId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteQuestion 删除 +func (r *QuestionDao) DeleteQuestion(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.Question{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteQuestionById 删除-id +func (r *QuestionDao) DeleteQuestionById(tx *gorm.DB, QuestionId int64) error { + if err := tx.Delete(&model.Question{}, QuestionId).Error; err != nil { + return err + } + return nil +} + +// EditQuestion 修改 +func (r *QuestionDao) EditQuestion(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.Question{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditQuestionById 修改-id +func (r *QuestionDao) EditQuestionById(tx *gorm.DB, QuestionId int64, data interface{}) error { + err := tx.Model(&model.Question{}).Where("question_id = ?", QuestionId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetQuestionList 获取列表 +func (r *QuestionDao) GetQuestionList(maps interface{}) (m []*model.Question, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetQuestionCount 获取数量 +func (r *QuestionDao) GetQuestionCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.Question{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetQuestionListRand 获取列表-随机 +func (r *QuestionDao) GetQuestionListRand(maps interface{}, limit int) (m []*model.Question, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddQuestion 新增 +func (r *QuestionDao) AddQuestion(tx *gorm.DB, model *model.Question) (*model.Question, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetQuestion 获取 +func (r *QuestionDao) GetQuestion(maps interface{}) (m *model.Question, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/QuestionClass.go b/api/dao/QuestionClass.go new file mode 100644 index 0000000..7e3fb93 --- /dev/null +++ b/api/dao/QuestionClass.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type QuestionClassDao struct { +} + +// GetQuestionClassById 获取数据-id +func (r *QuestionClassDao) GetQuestionClassById(QuestionClassId int64) (m *model.QuestionClass, err error) { + err = global.Db.First(&m, QuestionClassId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetQuestionClassPreloadById 获取数据-加载全部关联-id +func (r *QuestionClassDao) GetQuestionClassPreloadById(QuestionClassId int64) (m *model.QuestionClass, err error) { + err = global.Db.Preload(clause.Associations).First(&m, QuestionClassId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteQuestionClass 删除 +func (r *QuestionClassDao) DeleteQuestionClass(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.QuestionClass{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteQuestionClassById 删除-id +func (r *QuestionClassDao) DeleteQuestionClassById(tx *gorm.DB, QuestionClassId int64) error { + if err := tx.Delete(&model.QuestionClass{}, QuestionClassId).Error; err != nil { + return err + } + return nil +} + +// EditQuestionClass 修改 +func (r *QuestionClassDao) EditQuestionClass(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.QuestionClass{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditQuestionClassById 修改-id +func (r *QuestionClassDao) EditQuestionClassById(tx *gorm.DB, QuestionClassId int64, data interface{}) error { + err := tx.Model(&model.QuestionClass{}).Where("question_class_id = ?", QuestionClassId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetQuestionClassList 获取列表 +func (r *QuestionClassDao) GetQuestionClassList(maps interface{}) (m []*model.QuestionClass, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetQuestionClassCount 获取数量 +func (r *QuestionClassDao) GetQuestionClassCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.QuestionClass{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetQuestionClassListRand 获取列表-随机 +func (r *QuestionClassDao) GetQuestionClassListRand(maps interface{}, limit int) (m []*model.QuestionClass, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddQuestionClass 新增 +func (r *QuestionClassDao) AddQuestionClass(tx *gorm.DB, model *model.QuestionClass) (*model.QuestionClass, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetQuestionClass 获取 +func (r *QuestionClassDao) GetQuestionClass(maps interface{}) (m *model.QuestionClass, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/SystemMember.go b/api/dao/SystemMember.go new file mode 100644 index 0000000..2c909f2 --- /dev/null +++ b/api/dao/SystemMember.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type SystemMemberDao struct { +} + +// GetSystemMemberById 获取数据-id +func (r *SystemMemberDao) GetSystemMemberById(SystemMemberId int64) (m *model.SystemMember, err error) { + err = global.Db.First(&m, SystemMemberId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetSystemMemberPreloadById 获取数据-加载全部关联-id +func (r *SystemMemberDao) GetSystemMemberPreloadById(SystemMemberId int64) (m *model.SystemMember, err error) { + err = global.Db.Preload(clause.Associations).First(&m, SystemMemberId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteSystemMember 删除 +func (r *SystemMemberDao) DeleteSystemMember(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.SystemMember{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteSystemMemberById 删除-id +func (r *SystemMemberDao) DeleteSystemMemberById(tx *gorm.DB, SystemMemberId int64) error { + if err := tx.Delete(&model.SystemMember{}, SystemMemberId).Error; err != nil { + return err + } + return nil +} + +// EditSystemMember 修改 +func (r *SystemMemberDao) EditSystemMember(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.SystemMember{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditSystemMemberById 修改-id +func (r *SystemMemberDao) EditSystemMemberById(tx *gorm.DB, SystemMemberId int64, data interface{}) error { + err := tx.Model(&model.SystemMember{}).Where("system_member_id = ?", SystemMemberId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetSystemMemberList 获取列表 +func (r *SystemMemberDao) GetSystemMemberList(maps interface{}) (m []*model.SystemMember, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetSystemMemberCount 获取数量 +func (r *SystemMemberDao) GetSystemMemberCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.SystemMember{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetSystemMemberListRand 获取列表-随机 +func (r *SystemMemberDao) GetSystemMemberListRand(maps interface{}, limit int) (m []*model.SystemMember, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddSystemMember 新增 +func (r *SystemMemberDao) AddSystemMember(tx *gorm.DB, model *model.SystemMember) (*model.SystemMember, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetSystemMember 获取 +func (r *SystemMemberDao) GetSystemMember(maps interface{}) (m *model.SystemMember, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/SystemSingle.go b/api/dao/SystemSingle.go new file mode 100644 index 0000000..5304dc5 --- /dev/null +++ b/api/dao/SystemSingle.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type SystemSingleDao struct { +} + +// GetSystemSingleById 获取数据-id +func (r *SystemSingleDao) GetSystemSingleById(SystemSingleId int64) (m *model.SystemSingle, err error) { + err = global.Db.First(&m, SystemSingleId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetSystemSinglePreloadById 获取数据-加载全部关联-id +func (r *SystemSingleDao) GetSystemSinglePreloadById(SystemSingleId int64) (m *model.SystemSingle, err error) { + err = global.Db.Preload(clause.Associations).First(&m, SystemSingleId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteSystemSingle 删除 +func (r *SystemSingleDao) DeleteSystemSingle(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.SystemSingle{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteSystemSingleById 删除-id +func (r *SystemSingleDao) DeleteSystemSingleById(tx *gorm.DB, SystemSingleId int64) error { + if err := tx.Delete(&model.SystemSingle{}, SystemSingleId).Error; err != nil { + return err + } + return nil +} + +// EditSystemSingle 修改 +func (r *SystemSingleDao) EditSystemSingle(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.SystemSingle{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditSystemSingleById 修改-id +func (r *SystemSingleDao) EditSystemSingleById(tx *gorm.DB, SystemSingleId int64, data interface{}) error { + err := tx.Model(&model.SystemSingle{}).Where("system_single_id = ?", SystemSingleId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetSystemSingleList 获取列表 +func (r *SystemSingleDao) GetSystemSingleList(maps interface{}) (m []*model.SystemSingle, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetSystemSingleCount 获取数量 +func (r *SystemSingleDao) GetSystemSingleCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.SystemSingle{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetSystemSingleListRand 获取列表-随机 +func (r *SystemSingleDao) GetSystemSingleListRand(maps interface{}, limit int) (m []*model.SystemSingle, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddSystemSingle 新增 +func (r *SystemSingleDao) AddSystemSingle(tx *gorm.DB, model *model.SystemSingle) (*model.SystemSingle, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetSystemSingle 获取 +func (r *SystemSingleDao) GetSystemSingle(maps interface{}) (m *model.SystemSingle, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/User.go b/api/dao/User.go new file mode 100644 index 0000000..3f55f33 --- /dev/null +++ b/api/dao/User.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-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 +} diff --git a/api/dao/UserCollection.go b/api/dao/UserCollection.go new file mode 100644 index 0000000..3656895 --- /dev/null +++ b/api/dao/UserCollection.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type UserCollectionDao struct { +} + +// GetUserCollectionById 获取数据-id +func (r *UserCollectionDao) GetUserCollectionById(UserCollectionId int64) (m *model.UserCollection, err error) { + err = global.Db.First(&m, UserCollectionId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetUserCollectionPreloadById 获取数据-加载全部关联-id +func (r *UserCollectionDao) GetUserCollectionPreloadById(UserCollectionId int64) (m *model.UserCollection, err error) { + err = global.Db.Preload(clause.Associations).First(&m, UserCollectionId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteUserCollection 删除 +func (r *UserCollectionDao) DeleteUserCollection(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.UserCollection{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteUserCollectionById 删除-id +func (r *UserCollectionDao) DeleteUserCollectionById(tx *gorm.DB, UserCollectionId int64) error { + if err := tx.Delete(&model.UserCollection{}, UserCollectionId).Error; err != nil { + return err + } + return nil +} + +// EditUserCollection 修改 +func (r *UserCollectionDao) EditUserCollection(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.UserCollection{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditUserCollectionById 修改-id +func (r *UserCollectionDao) EditUserCollectionById(tx *gorm.DB, UserCollectionId int64, data interface{}) error { + err := tx.Model(&model.UserCollection{}).Where("user_coupon_id = ?", UserCollectionId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetUserCollectionList 获取列表 +func (r *UserCollectionDao) GetUserCollectionList(maps interface{}) (m []*model.UserCollection, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetUserCollectionCount 获取数量 +func (r *UserCollectionDao) GetUserCollectionCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.UserCollection{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetUserCollectionListRand 获取列表-随机 +func (r *UserCollectionDao) GetUserCollectionListRand(maps interface{}, limit int) (m []*model.UserCollection, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddUserCollection 新增 +func (r *UserCollectionDao) AddUserCollection(tx *gorm.DB, model *model.UserCollection) (*model.UserCollection, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetUserCollection 获取 +func (r *UserCollectionDao) GetUserCollection(maps interface{}) (m *model.UserCollection, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/UserCoupon.go b/api/dao/UserCoupon.go new file mode 100644 index 0000000..7ef4cff --- /dev/null +++ b/api/dao/UserCoupon.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type UserCouponDao struct { +} + +// GetUserCouponById 获取数据-id +func (r *UserCouponDao) GetUserCouponById(UserCouponId int64) (m *model.UserCoupon, err error) { + err = global.Db.First(&m, UserCouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetUserCouponPreloadById 获取数据-加载全部关联-id +func (r *UserCouponDao) GetUserCouponPreloadById(UserCouponId int64) (m *model.UserCoupon, err error) { + err = global.Db.Preload(clause.Associations).First(&m, UserCouponId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteUserCoupon 删除 +func (r *UserCouponDao) DeleteUserCoupon(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.UserCoupon{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteUserCouponById 删除-id +func (r *UserCouponDao) DeleteUserCouponById(tx *gorm.DB, UserCouponId int64) error { + if err := tx.Delete(&model.UserCoupon{}, UserCouponId).Error; err != nil { + return err + } + return nil +} + +// EditUserCoupon 修改 +func (r *UserCouponDao) EditUserCoupon(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.UserCoupon{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditUserCouponById 修改-id +func (r *UserCouponDao) EditUserCouponById(tx *gorm.DB, UserCouponId int64, data interface{}) error { + err := tx.Model(&model.UserCoupon{}).Where("user_coupon_id = ?", UserCouponId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetUserCouponList 获取列表 +func (r *UserCouponDao) GetUserCouponList(maps interface{}) (m []*model.UserCoupon, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetUserCouponCount 获取数量 +func (r *UserCouponDao) GetUserCouponCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.UserCoupon{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetUserCouponListRand 获取列表-随机 +func (r *UserCouponDao) GetUserCouponListRand(maps interface{}, limit int) (m []*model.UserCoupon, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddUserCoupon 新增 +func (r *UserCouponDao) AddUserCoupon(tx *gorm.DB, model *model.UserCoupon) (*model.UserCoupon, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetUserCoupon 获取 +func (r *UserCouponDao) GetUserCoupon(maps interface{}) (m *model.UserCoupon, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/UserInfo.go b/api/dao/UserInfo.go new file mode 100644 index 0000000..5e97ddd --- /dev/null +++ b/api/dao/UserInfo.go @@ -0,0 +1,108 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hepa-calc-api/api/model" + "hepa-calc-api/global" +) + +type UserInfoDao struct { +} + +// GetUserInfoById 获取数据-id +func (r *UserInfoDao) GetUserInfoById(UserInfoId int64) (m *model.UserInfo, err error) { + err = global.Db.First(&m, UserInfoId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetUserInfoPreloadById 获取数据-加载全部关联-id +func (r *UserInfoDao) GetUserInfoPreloadById(UserInfoId int64) (m *model.UserInfo, err error) { + err = global.Db.Preload(clause.Associations).First(&m, UserInfoId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteUserInfo 删除 +func (r *UserInfoDao) DeleteUserInfo(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.UserInfo{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteUserInfoById 删除-id +func (r *UserInfoDao) DeleteUserInfoById(tx *gorm.DB, UserInfoId int64) error { + if err := tx.Delete(&model.UserInfo{}, UserInfoId).Error; err != nil { + return err + } + return nil +} + +// EditUserInfo 修改 +func (r *UserInfoDao) EditUserInfo(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.UserInfo{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditUserInfoById 修改-id +func (r *UserInfoDao) EditUserInfoById(tx *gorm.DB, UserInfoId int64, data interface{}) error { + err := tx.Model(&model.UserInfo{}).Where("user_info_id = ?", UserInfoId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetUserInfoList 获取列表 +func (r *UserInfoDao) GetUserInfoList(maps interface{}) (m []*model.UserInfo, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetUserInfoCount 获取数量 +func (r *UserInfoDao) GetUserInfoCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.UserInfo{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetUserInfoListRand 获取列表-随机 +func (r *UserInfoDao) GetUserInfoListRand(maps interface{}, limit int) (m []*model.UserInfo, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddUserInfo 新增 +func (r *UserInfoDao) AddUserInfo(tx *gorm.DB, model *model.UserInfo) (*model.UserInfo, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetUserInfo 获取 +func (r *UserInfoDao) GetUserInfo(maps interface{}) (m *model.UserInfo, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/model/BaseAgreement.go b/api/model/BaseAgreement.go new file mode 100644 index 0000000..74a4f8e --- /dev/null +++ b/api/model/BaseAgreement.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// BaseAgreement 基础数据-协议 +type BaseAgreement struct { + AgreementId int64 `gorm:"column:agreement_id;type:bigint(19);primary_key;comment:主键id" json:"agreement_id"` + AgreementTitle string `gorm:"column:agreement_title;type:varchar(100);comment:协议标题" json:"agreement_title"` + AgreementContent string `gorm:"column:agreement_content;type:text;comment:协议内容" json:"agreement_content"` + Model +} + +func (m *BaseAgreement) TableName() string { + return "base_agreement" +} + +func (m *BaseAgreement) BeforeCreate(tx *gorm.DB) error { + if m.AgreementId == 0 { + m.AgreementId = 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 +} diff --git a/api/model/BaseClass.go b/api/model/BaseClass.go new file mode 100644 index 0000000..1f7324c --- /dev/null +++ b/api/model/BaseClass.go @@ -0,0 +1,36 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// BaseClass 基础数据-分类表 +type BaseClass struct { + ClassId int64 `gorm:"column:class_id;type:bigint(19);primary_key;comment:主键id" json:"class_id"` + ClassName string `gorm:"column:class_name;type:varchar(100);comment:分类名称" json:"class_name"` + ClassStatus int `gorm:"column:class_status;type:tinyint(1);default:1;comment:分类状态（1:正常 2:隐藏）" json:"class_status"` + ClassIcon string `gorm:"column:class_icon;type:varchar(255);comment:图标地址" json:"class_icon"` + ClassBrief string `gorm:"column:class_brief;type:text;comment:分类简介" json:"class_brief"` + Sort uint `gorm:"column:sort;type:int(10) unsigned;default:1;comment:排序值（越大排名越靠前）" json:"sort"` + Model +} + +func (m *BaseClass) TableName() string { + return "base_class" +} + +func (m *BaseClass) BeforeCreate(tx *gorm.DB) error { + if m.ClassId == 0 { + m.ClassId = 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 +} diff --git a/api/model/Coupon.go b/api/model/Coupon.go new file mode 100644 index 0000000..4049eba --- /dev/null +++ b/api/model/Coupon.go @@ -0,0 +1,45 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +type Coupon struct { + CouponId int64 `gorm:"column:coupon_id;type:bigint(19);primary_key;comment:主键id" json:"coupon_id"` + CouponName string `gorm:"column:coupon_name;type:varchar(255);comment:优惠卷名称" json:"coupon_name"` + CouponType string `gorm:"column:coupon_type;type:varchar(255);comment:优惠卷类型（1:无门槛 2:满减）" json:"coupon_type"` + CouponStatus int `gorm:"column:coupon_status;type:tinyint(1);default:1;comment:状态（1:正常 2:强制失效 3:结束 4:删除）" json:"coupon_status"` + ApplicationScope int `gorm:"column:application_scope;type:tinyint(1);default:1;comment:适用范围（1:全场通用）" json:"application_scope"` + IsMutex int `gorm:"column:is_mutex;type:tinyint(1);default:1;comment:是否互斥（0:否 1:是）互斥情况下无法和其他优惠卷同时使用" json:"is_mutex"` + CouponCount int `gorm:"column:coupon_count;type:int(10);default:1;comment:发放数量;NOT NULL" json:"coupon_count"` + CouponTakeCount int `gorm:"column:coupon_take_count;type:int(10);comment:已领取数量" json:"coupon_take_count"` + CouponUsedCount int `gorm:"column:coupon_used_count;type:int(10);default:0;comment:已使用数量" json:"coupon_used_count"` + CouponPrice float64 `gorm:"column:coupon_price;type:decimal(10,2) unsigned;default:0.00;comment:优惠卷金额" json:"coupon_price"` + WithAmount float64 `gorm:"column:with_amount;type:decimal(10,2);comment:符合满减标准金额（优惠卷类型为满减时使用）" json:"with_amount"` + ValidType int `gorm:"column:valid_type;type:tinyint(1);comment:有效类型（1:绝对时效，xxx-xxx时间段有效 2:相对时效 n天内有效）;NOT NULL" json:"valid_type"` + ValidDays int `gorm:"column:valid_days;type:int(3);comment:自领取之日起有效天数" json:"valid_days"` + ValidStartTime LocalTime `gorm:"column:valid_start_time;type:datetime;comment:开始使用时间" json:"valid_start_time"` + ValidEndTime LocalTime `gorm:"column:valid_end_time;type:datetime;comment:结束使用时间" json:"valid_end_time"` + CouponDesc string `gorm:"column:coupon_desc;type:varchar(200);comment:优惠卷描述" json:"coupon_desc"` + Model +} + +func (m *Coupon) TableName() string { + return "coupon" +} + +func (m *Coupon) BeforeCreate(tx *gorm.DB) error { + if m.CouponId == 0 { + m.CouponId = 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 +} diff --git a/api/model/OrderMember.go b/api/model/OrderMember.go new file mode 100644 index 0000000..6ebcff7 --- /dev/null +++ b/api/model/OrderMember.go @@ -0,0 +1,48 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// OrderMember 订单-单项 +type OrderMember struct { + OrderId int64 `gorm:"column:order_id;type:bigint(19);primary_key;comment:主键id" json:"order_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"` + SystemMemberId int64 `gorm:"column:system_member_id;type:bigint(19);comment:会员id;NOT NULL" json:"system_member_id"` + OrderStatus int `gorm:"column:order_status;type:tinyint(1);default:1;comment:订单状态（1:待支付 2:已完成 3:已取消）" json:"order_status"` + IsDelete int `gorm:"column:is_delete;type:tinyint(1);default:0;comment:用户删除状态（0:否 1:是）" json:"is_delete"` + PayChannel int `gorm:"column:pay_channel;type:tinyint(1);comment:支付渠道（1:h5支付 2:app支付 3:会员支付）;NOT NULL" json:"pay_channel"` + PayStatus int `gorm:"column:pay_status;type:tinyint(1);default:1;comment:支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）;NOT NULL" json:"pay_status"` + PayTime LocalTime `gorm:"column:pay_time;type:datetime;comment:支付时间" json:"pay_time"` + RefundStatus int `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）;NOT NULL" json:"refund_status"` + OrderNo string `gorm:"column:order_no;type:varchar(30);comment:系统订单编号;NOT NULL" json:"order_no"` + EscrowTradeNo string `gorm:"column:escrow_trade_no;type:varchar(100);comment:第三方支付流水号;NOT NULL" json:"escrow_trade_no"` + AmountTotal float64 `gorm:"column:amount_total;type:decimal(10,2) unsigned;default:0.00;comment:订单金额" json:"amount_total"` + CouponAmountTotal float64 `gorm:"column:coupon_amount_total;type:decimal(10,2);default:0.00;comment:优惠卷总金额" json:"coupon_amount_total"` + PaymentAmountTotal float64 `gorm:"column:payment_amount_total;type:decimal(10,2);default:0.00;comment:实际付款金额" json:"payment_amount_total"` + CancelStatus int `gorm:"column:cancel_status;type:tinyint(1);default:0;comment:取消状态（0:否 1:是）" json:"cancel_status"` + CancelTime LocalTime `gorm:"column:cancel_time;type:datetime;comment:订单取消时间" json:"cancel_time"` + CancelRemarks string `gorm:"column:cancel_remarks;type:varchar(255);comment:取消订单备注" json:"cancel_remarks"` + OrderRemarks string `gorm:"column:order_remarks;type:varchar(255);comment:订单备注" json:"order_remarks"` + Model +} + +func (m *OrderMember) TableName() string { + return "order_member" +} + +func (m *OrderMember) BeforeCreate(tx *gorm.DB) error { + if m.OrderId == 0 { + m.OrderId = 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 +} diff --git a/api/model/OrderMemberCoupon.go b/api/model/OrderMemberCoupon.go new file mode 100644 index 0000000..50916b2 --- /dev/null +++ b/api/model/OrderMemberCoupon.go @@ -0,0 +1,35 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// OrderMemberCoupon 订单-单项-优惠卷表 +type OrderMemberCoupon struct { + OrderCouponId int64 `gorm:"column:order_coupon_id;type:bigint(19);primary_key;comment:主键id" json:"order_coupon_id"` + OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:单项订单id;NOT NULL" json:"order_id"` + UserCouponId int64 `gorm:"column:user_coupon_id;type:bigint(19);comment:用户优惠卷表id;NOT NULL" json:"user_coupon_id"` + CouponName string `gorm:"column:coupon_name;type:varchar(255);comment:优惠卷名称" json:"coupon_name"` + CouponUsePrice float64 `gorm:"column:coupon_use_price;type:decimal(10,2) unsigned;default:0.00;comment:优惠卷使用金额" json:"coupon_use_price"` + Model +} + +func (m *OrderMemberCoupon) TableName() string { + return "order_member_coupon" +} + +func (m *OrderMemberCoupon) BeforeCreate(tx *gorm.DB) error { + if m.OrderCouponId == 0 { + m.OrderCouponId = 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 +} diff --git a/api/model/OrderMemberRefund.go b/api/model/OrderMemberRefund.go new file mode 100644 index 0000000..1a284cd --- /dev/null +++ b/api/model/OrderMemberRefund.go @@ -0,0 +1,40 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// OrderMemberRefund 订单-会员-退款表 +type OrderMemberRefund struct { + OrderRefundId int64 `gorm:"column:order_refund_id;type:bigint(19);primary_key;comment:主键id" json:"order_refund_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"` + OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:订单id;NOT NULL" json:"order_id"` + OrderNo string `gorm:"column:order_no;type:varchar(40);comment:系统订单编号" json:"order_no"` + RefundNo string `gorm:"column:refund_no;type:varchar(50);comment:系统退款编号" json:"refund_no"` + RefundId string `gorm:"column:refund_id;type:varchar(50);comment:第三方退款单号" json:"refund_id"` + RefundStatus int `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）" json:"refund_status"` + RefundTotal float64 `gorm:"column:refund_total;type:decimal(10,2) unsigned;default:0.00;comment:退款金额" json:"refund_total"` + RefundReason string `gorm:"column:refund_reason;type:varchar(255);comment:退款原因" json:"refund_reason"` + SuccessTime LocalTime `gorm:"column:success_time;type:datetime;comment:退款成功时间" json:"success_time"` + Model +} + +func (m *OrderMemberRefund) TableName() string { + return "order_member_refund" +} + +func (m *OrderMemberRefund) BeforeCreate(tx *gorm.DB) error { + if m.OrderRefundId == 0 { + m.OrderRefundId = 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 +} diff --git a/api/model/OrderSingle.go b/api/model/OrderSingle.go new file mode 100644 index 0000000..09f02e3 --- /dev/null +++ b/api/model/OrderSingle.go @@ -0,0 +1,48 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// OrderSingle 订单-单项 +type OrderSingle struct { + OrderId int64 `gorm:"column:order_id;type:bigint(19);primary_key;comment:主键id" json:"order_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"` + QuestionId int64 `gorm:"column:question_id;type:bigint(19);comment:问题id;NOT NULL" json:"question_id"` + OrderStatus int `gorm:"column:order_status;type:tinyint(1);default:1;comment:订单状态（1:待支付 2:已完成 3:已取消）" json:"order_status"` + IsDelete int `gorm:"column:is_delete;type:tinyint(1);default:0;comment:用户删除状态（0:否 1:是）" json:"is_delete"` + PayChannel int `gorm:"column:pay_channel;type:tinyint(1);comment:支付渠道（1:h5支付 2:app支付 3:会员支付）;NOT NULL" json:"pay_channel"` + PayStatus int `gorm:"column:pay_status;type:tinyint(1);default:1;comment:支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）;NOT NULL" json:"pay_status"` + PayTime LocalTime `gorm:"column:pay_time;type:datetime;comment:支付时间" json:"pay_time"` + RefundStatus int `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）;NOT NULL" json:"refund_status"` + OrderNo string `gorm:"column:order_no;type:varchar(30);comment:系统订单编号;NOT NULL" json:"order_no"` + EscrowTradeNo string `gorm:"column:escrow_trade_no;type:varchar(100);comment:第三方支付流水号;NOT NULL" json:"escrow_trade_no"` + AmountTotal float64 `gorm:"column:amount_total;type:decimal(10,2) unsigned;default:0.00;comment:订单金额" json:"amount_total"` + CouponAmountTotal float64 `gorm:"column:coupon_amount_total;type:decimal(10,2);default:0.00;comment:优惠卷总金额" json:"coupon_amount_total"` + PaymentAmountTotal float64 `gorm:"column:payment_amount_total;type:decimal(10,2);default:0.00;comment:实际付款金额" json:"payment_amount_total"` + CancelStatus int `gorm:"column:cancel_status;type:tinyint(1);default:0;comment:取消状态（0:否 1:是）" json:"cancel_status"` + CancelTime LocalTime `gorm:"column:cancel_time;type:datetime;comment:订单取消时间" json:"cancel_time"` + CancelRemarks string `gorm:"column:cancel_remarks;type:varchar(255);comment:取消订单备注" json:"cancel_remarks"` + OrderRemarks string `gorm:"column:order_remarks;type:varchar(255);comment:订单备注" json:"order_remarks"` + Model +} + +func (m *OrderSingle) TableName() string { + return "order_single" +} + +func (m *OrderSingle) BeforeCreate(tx *gorm.DB) error { + if m.OrderId == 0 { + m.OrderId = 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 +} diff --git a/api/model/OrderSingleCoupon.go b/api/model/OrderSingleCoupon.go new file mode 100644 index 0000000..ef5f9e2 --- /dev/null +++ b/api/model/OrderSingleCoupon.go @@ -0,0 +1,35 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// OrderSingleCoupon 订单-单项-优惠卷表 +type OrderSingleCoupon struct { + OrderCouponId int64 `gorm:"column:order_coupon_id;type:bigint(19);primary_key;comment:主键id" json:"order_coupon_id"` + OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:单项订单id;NOT NULL" json:"order_id"` + UserCouponId int64 `gorm:"column:user_coupon_id;type:bigint(19);comment:用户优惠卷表id;NOT NULL" json:"user_coupon_id"` + CouponName string `gorm:"column:coupon_name;type:varchar(255);comment:优惠卷名称" json:"coupon_name"` + CouponUsePrice float64 `gorm:"column:coupon_use_price;type:decimal(10,2) unsigned;default:0.00;comment:优惠卷使用金额" json:"coupon_use_price"` + Model +} + +func (m *OrderSingleCoupon) TableName() string { + return "order_single_coupon" +} + +func (m *OrderSingleCoupon) BeforeCreate(tx *gorm.DB) error { + if m.OrderCouponId == 0 { + m.OrderCouponId = 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 +} diff --git a/api/model/OrderSingleRefund.go b/api/model/OrderSingleRefund.go new file mode 100644 index 0000000..fc6066a --- /dev/null +++ b/api/model/OrderSingleRefund.go @@ -0,0 +1,40 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// OrderSingleRefund 订单-单项-退款表 +type OrderSingleRefund struct { + OrderRefundId int64 `gorm:"column:order_refund_id;type:bigint(19);primary_key;comment:主键id" json:"order_refund_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"` + OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:订单id;NOT NULL" json:"order_id"` + OrderNo string `gorm:"column:order_no;type:varchar(40);comment:系统订单编号" json:"order_no"` + RefundNo string `gorm:"column:refund_no;type:varchar(50);comment:系统退款编号" json:"refund_no"` + RefundId string `gorm:"column:refund_id;type:varchar(50);comment:第三方退款单号" json:"refund_id"` + RefundStatus int `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）" json:"refund_status"` + RefundTotal float64 `gorm:"column:refund_total;type:decimal(10,2) unsigned;default:0.00;comment:退款金额" json:"refund_total"` + RefundReason string `gorm:"column:refund_reason;type:varchar(255);comment:退款原因" json:"refund_reason"` + SuccessTime LocalTime `gorm:"column:success_time;type:datetime;comment:退款成功时间" json:"success_time"` + Model +} + +func (m *OrderSingleRefund) TableName() string { + return "order_single_refund" +} + +func (m *OrderSingleRefund) BeforeCreate(tx *gorm.DB) error { + if m.OrderRefundId == 0 { + m.OrderRefundId = 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 +} diff --git a/api/model/Question.go b/api/model/Question.go new file mode 100644 index 0000000..0ca70af --- /dev/null +++ b/api/model/Question.go @@ -0,0 +1,43 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// Question 问题表 +type Question struct { + QuestionId int64 `gorm:"column:question_id;type:bigint(19);primary_key;comment:主键id" json:"question_id"` + QuestionTitle string `gorm:"column:question_title;type:varchar(200);comment:标题" json:"question_title"` + QuestionSubtitle string `gorm:"column:question_subtitle;type:varchar(200);comment:副标题" json:"question_subtitle"` + QuestionStatus string `gorm:"column:question_status;type:varchar(255);comment:问题状态（1:正常 2:待发布）" json:"question_status"` + IsHide int `gorm:"column:is_hide;type:tinyint(1);default:0;comment:是否隐藏（0:否 1:是）" json:"is_hide"` + IsRecommend int `gorm:"column:is_recommend;type:tinyint(1);default:0;comment:是否推荐（0:否 1:是）" json:"is_recommend"` + ClickCount int `gorm:"column:click_count;type:int(5);default:0;comment:点击次数（点击进入详情页的人次）" json:"click_count"` + SubmitCount int `gorm:"column:submit_count;type:int(5);default:0;comment:提交次数（提交个人信息进行了算算的人次）" json:"submit_count"` + PayCount int `gorm:"column:pay_count;type:int(5);default:0;comment:支付次数（查看报告的人次）" json:"pay_count"` + Price float64 `gorm:"column:price;type:decimal(10,2) unsigned;default:0.00;comment:价格（原价）" json:"price"` + DiscountPrice float64 `gorm:"column:discount_price;type:decimal(10,2);comment:优惠价格" json:"discount_price"` + QuestionBrief string `gorm:"column:question_brief;type:text;comment:问题介绍" json:"question_brief"` + QuestionExplain string `gorm:"column:question_explain;type:text;comment:问题解释/科普" json:"question_explain"` + Model +} + +func (m *Question) TableName() string { + return "question" +} + +func (m *Question) BeforeCreate(tx *gorm.DB) error { + if m.QuestionId == 0 { + m.QuestionId = 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 +} diff --git a/api/model/QuestionClass.go b/api/model/QuestionClass.go new file mode 100644 index 0000000..393f822 --- /dev/null +++ b/api/model/QuestionClass.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// QuestionClass 中间表-问题/分类 +type QuestionClass struct { + QuestionClassId int64 `gorm:"column:question_class_id;type:bigint(19);primary_key;comment:主键id" json:"question_class_id"` + QuestionId int64 `gorm:"column:question_id;type:bigint(19);comment:问题id;NOT NULL" json:"question_id"` + ClassId int64 `gorm:"column:class_id;type:bigint(19);comment:分类id;NOT NULL" json:"class_id"` + Model +} + +func (m *QuestionClass) TableName() string { + return "question_class" +} + +func (m *QuestionClass) BeforeCreate(tx *gorm.DB) error { + if m.QuestionClassId == 0 { + m.QuestionClassId = 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 +} diff --git a/api/model/SystemMember.go b/api/model/SystemMember.go new file mode 100644 index 0000000..22e5d46 --- /dev/null +++ b/api/model/SystemMember.go @@ -0,0 +1,35 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// SystemMember 配置-会员配置 +type SystemMember struct { + SystemMemberId int64 `gorm:"column:system_member_id;type:bigint(19);primary_key;comment:主键id" json:"system_member_id"` + MemberDays uint `gorm:"column:member_days;type:int(10) unsigned;default:0;comment:会员天数" json:"member_days"` + Price float64 `gorm:"column:price;type:decimal(10,2);default:0.00;comment:价格（原价）" json:"price"` + DiscountPrice float64 `gorm:"column:discount_price;type:decimal(10,2);comment:优惠价格" json:"discount_price"` + FirstTimePrice float64 `gorm:"column:first_time_price;type:decimal(10,2) unsigned;default:0.00;comment:首次购买价格" json:"first_time_price"` + Model +} + +func (m *SystemMember) TableName() string { + return "system_member" +} + +func (m *SystemMember) BeforeCreate(tx *gorm.DB) error { + if m.SystemMemberId == 0 { + m.SystemMemberId = 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 +} diff --git a/api/model/SystemSingle.go b/api/model/SystemSingle.go new file mode 100644 index 0000000..3547ac0 --- /dev/null +++ b/api/model/SystemSingle.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// SystemSingle 配置-单项配置 +type SystemSingle struct { + SystemSingleId int64 `gorm:"column:system_single_id;type:bigint(19);primary_key;comment:主键id" json:"system_single_id"` + FirstTimePrice float64 `gorm:"column:first_time_price;type:decimal(10,2);default:0.00;comment:首次购买价格" json:"first_time_price"` + ValidDays int `gorm:"column:valid_days;type:int(5);default:1;comment:购买后有效天数" json:"valid_days"` + Model +} + +func (m *SystemSingle) TableName() string { + return "system_single" +} + +func (m *SystemSingle) BeforeCreate(tx *gorm.DB) error { + if m.SystemSingleId == 0 { + m.SystemSingleId = 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 +} diff --git a/api/model/User.go b/api/model/User.go new file mode 100644 index 0000000..c6b0ba0 --- /dev/null +++ b/api/model/User.go @@ -0,0 +1,44 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// User 用户表 +type User struct { + UserId int64 `gorm:"column:user_id;type:bigint(19);primary_key;comment:用户id" json:"user_id"` + UserName string `gorm:"column:user_name;type:varchar(200);comment:用户名称" json:"user_name"` + Mobile string `gorm:"column:mobile;type:varchar(20);comment:手机号;NOT NULL" json:"mobile"` + UserStatus int `gorm:"column:user_status;type:tinyint(1);default:1;comment:状态（1:正常 2:禁用）" json:"user_status"` + RegisterSource int `gorm:"column:register_source;type:tinyint(1);default:1;comment:注册来源（1：app注册 2：公众号注册）" json:"register_source"` + OpenId string `gorm:"column:open_id;type:varchar(100);comment:用户微信标识" json:"open_id"` + UnionId string `gorm:"column:union_id;type:varchar(100);comment:微信开放平台标识" json:"union_id"` + Age uint `gorm:"column:age;type:int(10) unsigned;comment:年龄" json:"age"` + Sex uint `gorm:"column:sex;type:tinyint(1) unsigned;default:0;comment:性别（0:未知 1:男 2:女）" json:"sex"` + Avatar string `gorm:"column:avatar;type:varchar(255);comment:头像" json:"avatar"` + IsMember int `gorm:"column:is_member;type:tinyint(1);default:0;comment:是否会员（0:否 1:是）" json:"is_member"` + MemberExpireDate LocalTime `gorm:"column:member_expire_date;type:datetime;comment:会员到期时间（非会员时为null）" json:"member_expire_date"` + 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 +} diff --git a/api/model/UserCollection.go b/api/model/UserCollection.go new file mode 100644 index 0000000..86828ba --- /dev/null +++ b/api/model/UserCollection.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// UserCollection 用户收藏表 +type UserCollection struct { + CollectionId int64 `gorm:"column:collection_id;type:bigint(19);primary_key;comment:主键id" json:"collection_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id" json:"user_id"` + QuestionId int64 `gorm:"column:question_id;type:bigint(19);comment:问题id" json:"question_id"` + Model +} + +func (m *UserCollection) TableName() string { + return "user_collection" +} + +func (m *UserCollection) BeforeCreate(tx *gorm.DB) error { + if m.CollectionId == 0 { + m.CollectionId = 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 +} diff --git a/api/model/UserCoupon.go b/api/model/UserCoupon.go new file mode 100644 index 0000000..e76987c --- /dev/null +++ b/api/model/UserCoupon.go @@ -0,0 +1,36 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +type UserCoupon struct { + UserCouponId int64 `gorm:"column:user_coupon_id;type:bigint(19);primary_key;comment:主键id" json:"user_coupon_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"` + CouponId int64 `gorm:"column:coupon_id;type:bigint(19);comment:优惠卷id;NOT NULL" json:"coupon_id"` + UserCouponStatus int `gorm:"column:user_coupon_status;type:tinyint(1);default:0;comment:状态（0:未使用 1:已使用 3:已过期）" json:"user_coupon_status"` + CouponUseDate LocalTime `gorm:"column:coupon_use_date;type:datetime;comment:使用时间" json:"coupon_use_date"` + ValidStartTime LocalTime `gorm:"column:valid_start_time;type:datetime;comment:有效使用时间" json:"valid_start_time"` + ValidEndTime LocalTime `gorm:"column:valid_end_time;type:datetime;comment:过期使用时间" json:"valid_end_time"` + Model +} + +func (m *UserCoupon) TableName() string { + return "user_coupon" +} + +func (m *UserCoupon) BeforeCreate(tx *gorm.DB) error { + if m.UserCouponId == 0 { + m.UserCouponId = 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 +} diff --git a/api/model/UserInfo.go b/api/model/UserInfo.go new file mode 100644 index 0000000..e8592fc --- /dev/null +++ b/api/model/UserInfo.go @@ -0,0 +1,43 @@ +package model + +import ( + "gorm.io/gorm" + "hepa-calc-api/global" + "time" +) + +// UserInfo 用户表-基础信息 +type UserInfo struct { + UserInfoId int64 `gorm:"column:user_info_id;type:bigint(19);primary_key;comment:主键id" json:"user_info_id"` + UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id" json:"user_id"` + Height string `gorm:"column:height;type:varchar(20);comment:身高（cm）" json:"height"` + Weight string `gorm:"column:weight;type:varchar(20);comment:体重（kg）" json:"weight"` + NationId int64 `gorm:"column:nation_id;type:bigint(19);comment:民族id" json:"nation_id"` + FamilyHistoryId int64 `gorm:"column:family_history_id;type:bigint(19);comment:家族病史id" json:"family_history_id"` + ProvinceId int `gorm:"column:province_id;type:int(11);comment:省份id" json:"province_id"` + Province string `gorm:"column:province;type:varchar(40);comment:省份" json:"province"` + CityId int `gorm:"column:city_id;type:int(11);comment:城市id" json:"city_id"` + City string `gorm:"column:city;type:varchar(50);comment:城市" json:"city"` + CountyId int `gorm:"column:county_id;type:int(11);comment:区县id" json:"county_id"` + County string `gorm:"column:county;type:varchar(255);comment:区县" json:"county"` + DiseaseClassId int64 `gorm:"column:disease_class_id;type:bigint(19);comment:疾病分类id" json:"disease_class_id"` + Model +} + +func (m *UserInfo) TableName() string { + return "user_info" +} + +func (m *UserInfo) BeforeCreate(tx *gorm.DB) error { + if m.UserInfoId == 0 { + m.UserInfoId = 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 +}