You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
305 lines
8.5 KiB
305 lines
8.5 KiB
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 |
|
}
|
|
|