增加了dao和model数据

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}