youngee_b_api/db/enterprise.go

package db

import (
	"context"
	"fmt"
	"time"
	"youngee_b_api/model/gorm_model"
	"youngee_b_api/model/http_model"
	"youngee_b_api/util"

	"github.com/issue9/conv"

	"gorm.io/gorm"
)

func CreateEnterprise(ctx context.Context, newEnterprise gorm_model.Enterprise) (*int64, error) {
	db := GetReadDB(ctx)
	err := db.Create(&newEnterprise).Error
	if err != nil {
		return nil, err
	}
	return &newEnterprise.EnterpriseID, nil
}

//用户ID查找
func GetEnterpriseByUID(ctx context.Context, userID int64) (*gorm_model.Enterprise, error) {
	db := GetReadDB(ctx)
	enterprise := gorm_model.Enterprise{}
	err := db.Where("user_id = ?", userID).First(&enterprise).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &enterprise, nil
}

// GetEnterpriseByEnterpriseID 企业ID查找
func GetEnterpriseByEnterpriseID(ctx context.Context, EnterpriseID int64) (*gorm_model.Enterprise, error) {
	db := GetReadDB(ctx)
	enterprise := gorm_model.Enterprise{}
	err := db.Where("enterprise_id = ?", EnterpriseID).First(&enterprise).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &enterprise, nil
}

// GetEnterpriseBalance 获取企业可用余额等信息
func GetEnterpriseBalance(ctx context.Context, EnterpriseID int64) (*http_model.EnterpriseBalanceData, error) {
	db := GetReadDB(ctx)
	enterprise := gorm_model.Enterprise{}
	err := db.Where("enterprise_id = ?", EnterpriseID).First(&enterprise).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	res := &http_model.EnterpriseBalanceData{
		Balance:          enterprise.Balance,
		FrozenBalance:    enterprise.FrozenBalance,
		AvailableBalance: enterprise.AvailableBalance,
	}
	return res, nil
}

// 支付-修改企业账户余额
func UpdateEnterpriseBalance(ctx context.Context, EnterpriseID int64, balance float64, availableBalance float64, frozenBalance float64) (*float64, error) {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.Enterprise{}).Where("enterprise_id", EnterpriseID).
		Updates(map[string]interface{}{"balance": gorm.Expr("balance + ?", balance), "available_balance": gorm.Expr("available_balance + ?", availableBalance), "frozen_balance": gorm.Expr("frozen_balance + ?", frozenBalance)}).Error
	if err != nil {
		return nil, err
	}
	enterprise := gorm_model.Enterprise{}
	err = db.Model(gorm_model.Enterprise{}).Where("enterprise_id", EnterpriseID).Scan(&enterprise).Error
	if err != nil {
		return nil, err
	}

	return &enterprise.Balance, nil
}

func RechargeAmount(ctx context.Context, EnterpriseID int64, Amount float64) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.Enterprise{}).Where("enterprise_id", EnterpriseID).
		Updates(map[string]interface{}{"balance": gorm.Expr("balance + ?", Amount), "available_balance": gorm.Expr("available_balance + ?", Amount)}).Error
	if err != nil {
		return err
	}
	enterprise := gorm_model.Enterprise{}
	err = db.Model(gorm_model.Enterprise{}).Where("enterprise_id", EnterpriseID).Scan(&enterprise).Error
	if err != nil {
		return err
	}
	// 1、年月日
	year := time.Now().Year()
	month := time.Now().Month()
	day := time.Now().Day()
	yearData, _ := util.GetDayNum("year", year)
	monthData, _ := util.GetDayNum("month", int(month))
	dayData, _ := util.GetDayNum("day", day)
	sum := 0
	sum += dayData + monthData
	leap := 0
	if (yearData%400 == 0) || ((yearData%4 == 0) && (yearData%100 != 0)) {
		leap = 1
	}
	if (leap == 1) && (monthData > 2) {
		sum += 1
	}
	last := ""
	rechargeIdPrefix := "8" + conv.MustString(EnterpriseID)[len(conv.MustString(EnterpriseID))-2:] + conv.MustString(sum)
	var rechargeIdLast string
	err = db.Model(gorm_model.YounggeeRechargeRecord{}).Select("recharge_id").Where("recharge_id like ?", rechargeIdPrefix+"%").
		Last(&rechargeIdLast).Error
	if err != nil {
		last = "0"
	} else {
		last = rechargeIdLast[len(rechargeIdLast)-2:]
	}
	var lastInt int
	lastInt = conv.MustInt(last)
	if lastInt+1 < 10 {
		last = "0" + conv.MustString(conv.MustInt(last)+1)
	} else {
		last = conv.MustString(conv.MustInt(last) + 1)
	}
	err = db.Model(gorm_model.YounggeeRechargeRecord{}).Create(&gorm_model.YounggeeRechargeRecord{
		RechargeID:         rechargeIdPrefix + last,
		RechargeAmount:     Amount,
		EnterpriseID:       EnterpriseID,
		Status:             1,
		InvoiceStatus:      1,
		CommitAt:           time.Now(),
		RechargeMethod:     3,
		TransferVoucherUrl: "--",
		ConfirmAt:          time.Now(),
	}).Error
	if err != nil {
		return err
	}
	return nil
}

func UpdateEnterprise(ctx context.Context, EnterpriseID int64, BusinessName string) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.Enterprise{}).Where("enterprise_id=?", EnterpriseID).Update("business_name", BusinessName).Error
	if err != nil {
		fmt.Println("Update Enterprise Failed!")
		return err
	}
	return nil
}