306 lines
8.5 KiB
Go
306 lines
8.5 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
|
|
"go-common/app/interface/main/growup/model"
|
|
"go-common/library/log"
|
|
"go-common/library/xstr"
|
|
)
|
|
|
|
const (
|
|
_openAwardsSQL = "SELECT award_id,award_name,cycle_start FROM special_award WHERE open_status=2"
|
|
_joinedAwardsSQL = "SELECT award_id,award_name,cycle_start,cycle_end,open_status FROM special_award WHERE award_id IN (%s)"
|
|
|
|
_awardScheSQL = "SELECT award_name,cycle_start,cycle_end,announce_date FROM special_award WHERE award_id=?"
|
|
_awardResourceSQL = "SELECT resource_type,content,resource_index FROM special_award_resource WHERE award_id=? AND is_deleted=0"
|
|
_awardWinnerSQL = "SELECT mid FROM special_award_winner WHERE award_id=? AND is_deleted=0"
|
|
|
|
_winnerIDsSQL = "SELECT award_id,prize_id FROM special_award_winner WHERE mid=? AND is_deleted=0"
|
|
_winnerDivisionSQL = "SELECT award_id,division_name FROM special_award_winner WHERE mid=? AND is_deleted=0"
|
|
|
|
_awardBonusSQL = "SELECT bonus FROM special_award_prize WHERE award_id=? AND prize_id=?"
|
|
|
|
_inSpecialAwardRecordSQL = "INSERT INTO special_award_record(mid,award_id) VALUES(?,?)"
|
|
_joinedCountSQL = "SELECT count(*) FROM special_award_record WHERE mid=? AND award_id=?"
|
|
|
|
_specialAwardsSQL = "SELECT award_id, award_name, cycle_start, cycle_end, announce_date FROM special_award WHERE display_status = 2 AND is_deleted = 0"
|
|
_awardDivisionSQL = "SELECT division_name FROM special_award_division WHERE award_id = ? AND is_deleted = 0"
|
|
_awardWinRecordSQL = "SELECT award_id FROM special_award_winner WHERE mid = ? AND is_deleted = 0"
|
|
_awardJoinRecordSQL = "SELECT award_id FROM special_award_record WHERE mid = ? AND is_deleted = 0"
|
|
)
|
|
|
|
// PastAwards get award basic info
|
|
func (d *Dao) PastAwards(c context.Context) (as []*model.SimpleSpecialAward, err error) {
|
|
rows, err := d.db.Query(c, _openAwardsSQL)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
as = make([]*model.SimpleSpecialAward, 0)
|
|
for rows.Next() {
|
|
a := &model.SimpleSpecialAward{}
|
|
err = rows.Scan(&a.AwardID, &a.AwardName, &a.CycleStart)
|
|
if err != nil {
|
|
return
|
|
}
|
|
as = append(as, a)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// JoinedSpecialAwards get joined awards
|
|
func (d *Dao) JoinedSpecialAwards(c context.Context, awardIDs []int64) (sas []*model.SpecialAward, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_joinedAwardsSQL, xstr.JoinInts(awardIDs)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
sas = make([]*model.SpecialAward, 0)
|
|
for rows.Next() {
|
|
sa := &model.SpecialAward{}
|
|
err = rows.Scan(&sa.AwardID, &sa.AwardName, &sa.CycleStart, &sa.CycleEnd, &sa.OpenStatus)
|
|
if err != nil {
|
|
log.Error("row scan error(%v)", err)
|
|
return
|
|
}
|
|
sas = append(sas, sa)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// GetAwardSchedule get special award by award id
|
|
func (d *Dao) GetAwardSchedule(c context.Context, awardID int64) (award *model.SpecialAward, err error) {
|
|
award = &model.SpecialAward{}
|
|
row := d.db.QueryRow(c, _awardScheSQL, awardID)
|
|
if err = row.Scan(&award.AwardName, &award.CycleStart, &award.CycleEnd, &award.AnnounceDate); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetResources get special award resource map[type]map[index]content
|
|
func (d *Dao) GetResources(c context.Context, awardID int64) (res map[int]map[int]string, err error) {
|
|
rows, err := d.db.Query(c, _awardResourceSQL, awardID)
|
|
if err != nil {
|
|
log.Error("GetResources d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
res = make(map[int]map[int]string)
|
|
for rows.Next() {
|
|
var rtype, index int
|
|
var content string
|
|
err = rows.Scan(&rtype, &content, &index)
|
|
if err != nil {
|
|
log.Error("GetDivisions rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
if cs, ok := res[rtype]; ok {
|
|
cs[index] = content
|
|
} else {
|
|
m := make(map[int]string)
|
|
m[index] = content
|
|
res[rtype] = m
|
|
}
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// GetWinners get winner mids by award_id
|
|
func (d *Dao) GetWinners(c context.Context, awardID int64) (mids []int64, err error) {
|
|
rows, err := d.db.Query(c, _awardWinnerSQL, awardID)
|
|
if err != nil {
|
|
log.Error("GetWinners d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
mids = make([]int64, 0)
|
|
for rows.Next() {
|
|
var mid int64
|
|
err = rows.Scan(&mid)
|
|
if err != nil {
|
|
log.Error("GetWinners rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
mids = append(mids, mid)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// AwardIDsByWinner get winner's record, am map[award_id]prize_id
|
|
func (d *Dao) AwardIDsByWinner(c context.Context, mid int64) (am map[int64]int64, err error) {
|
|
rows, err := d.db.Query(c, _winnerIDsSQL, mid)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
am = make(map[int64]int64)
|
|
for rows.Next() {
|
|
var awardID, prizeID int64
|
|
err = rows.Scan(&awardID, &prizeID)
|
|
if err != nil {
|
|
log.Error("rows scan error(%v)", err)
|
|
return
|
|
}
|
|
am[awardID] = prizeID
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// DivisionName division name by mid, names map[award_id]division_name
|
|
func (d *Dao) DivisionName(c context.Context, mid int64) (names map[int64]string, err error) {
|
|
rows, err := d.db.Query(c, _winnerDivisionSQL, mid)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
names = make(map[int64]string)
|
|
for rows.Next() {
|
|
var awardID int64
|
|
var name string
|
|
err = rows.Scan(&awardID, &name)
|
|
if err != nil {
|
|
log.Error("rows scan error(%v)", err)
|
|
return
|
|
}
|
|
names[awardID] = name
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// JoinedCount get signed up count by mid, award_id
|
|
func (d *Dao) JoinedCount(c context.Context, mid, awardID int64) (count int64, err error) {
|
|
row := d.db.QueryRow(c, _joinedCountSQL, mid, awardID)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// AwardBonus get bonus by award_id and prize_id
|
|
func (d *Dao) AwardBonus(c context.Context, awardID, prizeID int64) (bonus int64, err error) {
|
|
row := d.db.QueryRow(c, _awardBonusSQL, awardID, prizeID)
|
|
if err = row.Scan(&bonus); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddToAwardRecord add to award record
|
|
func (d *Dao) AddToAwardRecord(c context.Context, mid, awardID int64) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, _inSpecialAwardRecordSQL, mid, awardID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// GetSpecialAwards get all display sepcial award
|
|
func (d *Dao) GetSpecialAwards(c context.Context) (awards []*model.SpecialAward, err error) {
|
|
awards = make([]*model.SpecialAward, 0)
|
|
rows, err := d.db.Query(c, _specialAwardsSQL)
|
|
if err != nil {
|
|
log.Error("GetSpecialAwards d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
sa := &model.SpecialAward{}
|
|
err = rows.Scan(&sa.AwardID, &sa.AwardName, &sa.CycleStart, &sa.CycleEnd, &sa.AnnounceDate)
|
|
if err != nil {
|
|
log.Error("GetSpecialAwards rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
awards = append(awards, sa)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// GetSpecialAwardDivision get special award division name
|
|
func (d *Dao) GetSpecialAwardDivision(c context.Context, awardID int64) (divisions []string, err error) {
|
|
divisions = make([]string, 0)
|
|
rows, err := d.db.Query(c, _awardDivisionSQL, awardID)
|
|
if err != nil {
|
|
log.Error("GetSpecialAwardDivision d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var name string
|
|
err = rows.Scan(&name)
|
|
if err != nil {
|
|
log.Error("GetSpecialAwardDivision rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
divisions = append(divisions, name)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// GetAwardWinRecord get award win record
|
|
func (d *Dao) GetAwardWinRecord(c context.Context, mid int64) (awardIDs map[int64]bool, err error) {
|
|
awardIDs = make(map[int64]bool)
|
|
rows, err := d.db.Query(c, _awardWinRecordSQL, mid)
|
|
if err != nil {
|
|
log.Error("GetAwardWinRecord d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var id int64
|
|
err = rows.Scan(&id)
|
|
if err != nil {
|
|
log.Error("GetAwardWinRecord rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
awardIDs[id] = true
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// GetAwardJoinRecord get award join record
|
|
func (d *Dao) GetAwardJoinRecord(c context.Context, mid int64) (awardIDs map[int64]bool, err error) {
|
|
awardIDs = make(map[int64]bool)
|
|
rows, err := d.db.Query(c, _awardJoinRecordSQL, mid)
|
|
if err != nil {
|
|
log.Error("GetAwardJoinRecord d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var id int64
|
|
err = rows.Scan(&id)
|
|
if err != nil {
|
|
log.Error("GetAwardJoinRecord rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
awardIDs[id] = true
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|