355 lines
11 KiB
Go
355 lines
11 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
model "go-common/app/interface/main/credit/model"
|
|
"go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
ctime "go-common/library/time"
|
|
"go-common/library/xstr"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
const (
|
|
_insAnsLogSQL = "INSERT INTO blocked_labour_answer_log(mid,score,content,start_time) VALUES(?,?,?,?)"
|
|
_insQsSQL = "INSERT INTO blocked_labour_question(question,ans,av_id,status,source) VALUES(?,?,?,?,?)"
|
|
_updateQsSQL = "UPDATE blocked_labour_question SET ans=?,status=? WHERE id=?"
|
|
_delQsSQL = "UPDATE blocked_labour_question SET isdel=? WHERE id=?"
|
|
_selConfSQL = "SELECT config_key,content from blocked_config"
|
|
_selNoticeSQL = "SELECT id,content,url FROM blocked_notice WHERE status=0 ORDER BY id DESC LIMIT 1"
|
|
_selReasonSQL = "SELECT id,reason,content FROM blocked_reason WHERE status=0"
|
|
_selQuestionSQL = "SELECT id,question,ans FROM blocked_labour_question WHERE id IN(%s) AND status=2 ORDER BY find_in_set(id,'%s') "
|
|
_selAllQuestionSQL = "SELECT id,question,ans,av_id,status,source,ctime,mtime FROM blocked_labour_question WHERE id IN(%s) "
|
|
_isAnsweredSQL = "SELECT COUNT(*) FROM blocked_labour_answer_log WHERE mid=? AND score=100 AND mtime>=?"
|
|
_noAuditQuestionSQL = "SELECT id,av_id,question FROM blocked_labour_question WHERE status=2 ORDER BY id DESC LIMIT 20"
|
|
_auditQuestionSQL = "SELECT id,av_id,question FROM blocked_labour_question WHERE status=1 AND ans=0 ORDER BY id DESC LIMIT 20"
|
|
_selKPISQL = "SELECT k.mid,k.day,k.rate,k.rank,k.rank_per,k.rank_total,p.point,p.active_days,p.vote_total,p.opinion_likes,p.vote_real_total from blocked_kpi k inner join blocked_kpi_data p on k.mid=p.mid and k.day=p.day where k.mid = ?"
|
|
_announcementInfoSQL = `SELECT id,title,sub_title,publish_status,stick_status,content,url,ctime,mtime FROM blocked_publish WHERE id = ? AND publish_status = 1 AND status = 0`
|
|
_announcementListSQL = `SELECT id,title,sub_title,publish_status,stick_status,content,url,ptype,ctime,mtime FROM blocked_publish WHERE publish_status = 1 AND status = 0 AND show_time <= ? ORDER BY ctime desc`
|
|
_publishsSQL = "SELECT id,title,sub_title,stick_status,content,ctime FROM blocked_publish WHERE id IN (%s) AND publish_status = 1 AND status = 0"
|
|
_selNewKPISQL = "SELECT rate FROM blocked_kpi WHERE mid=? ORDER BY id DESC LIMIT 1"
|
|
)
|
|
|
|
// AddAnsLog add labour answer log.
|
|
func (d *Dao) AddAnsLog(c context.Context, mid int64, score int64, anstr string, stime ctime.Time) (affect int64, err error) {
|
|
result, err := d.db.Exec(c, _insAnsLogSQL, mid, score, anstr, stime)
|
|
if err != nil {
|
|
log.Error("AddAnsLog: db.Exec(mid:%d,score:%d,ans:%s) error(%v)", mid, score, anstr, err)
|
|
return
|
|
}
|
|
affect, err = result.LastInsertId()
|
|
return
|
|
}
|
|
|
|
// AddQs add labour question log.
|
|
func (d *Dao) AddQs(c context.Context, qs *model.LabourQs) (err error) {
|
|
if _, err = d.db.Exec(c, _insQsSQL, qs.Question, qs.Ans, qs.AvID, qs.Status, qs.Source); err != nil {
|
|
log.Error("AddQs: db.Exec(as:%v) error(%v)", qs, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetQs set labour question field.
|
|
func (d *Dao) SetQs(c context.Context, id int64, ans int64, status int64) (err error) {
|
|
if _, err = d.db.Exec(c, _updateQsSQL, ans, status, id); err != nil {
|
|
log.Error("setQs: db.Exec(ans:%d status:%d) error(%v)", ans, status, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// DelQs del labour question.
|
|
func (d *Dao) DelQs(c context.Context, id int64, isDel int64) (err error) {
|
|
if _, err = d.db.Exec(c, _delQsSQL, isDel, id); err != nil {
|
|
log.Error("setQs: db.Exec(id:%d isDel:%d) error(%v)", id, isDel, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// LoadConf load conf.
|
|
func (d *Dao) LoadConf(c context.Context) (cf map[string]string, err error) {
|
|
cf = make(map[string]string)
|
|
rows, err := d.db.Query(c, _selConfSQL)
|
|
if err != nil {
|
|
log.Error("d.loadConf err(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
var (
|
|
key string
|
|
value string
|
|
)
|
|
for rows.Next() {
|
|
if err = rows.Scan(&key, &value); err != nil {
|
|
log.Error("rows.Scan err(%v)", err)
|
|
return
|
|
}
|
|
cf[key] = value
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// Notice get notice
|
|
func (d *Dao) Notice(c context.Context) (n *model.Notice, err error) {
|
|
row := d.db.QueryRow(c, _selNoticeSQL)
|
|
if err != nil {
|
|
log.Error("Notice: d.QueryRow error(%v)", err)
|
|
return
|
|
}
|
|
n = &model.Notice{}
|
|
if err = row.Scan(&n.ID, &n.Content, &n.URL); err != nil {
|
|
log.Error("row.Scan() error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ReasonList get reason list
|
|
func (d *Dao) ReasonList(c context.Context) (res []*model.Reason, err error) {
|
|
rows, err := d.db.Query(c, _selReasonSQL)
|
|
if err != nil {
|
|
log.Error("reasonList: d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
r := new(model.Reason)
|
|
if err = rows.Scan(&r.ID, &r.Reason, &r.Content); err != nil {
|
|
log.Error("row.Scan() error(%v)", err)
|
|
res = nil
|
|
return
|
|
}
|
|
res = append(res, r)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// QsList get question list.
|
|
func (d *Dao) QsList(c context.Context, idStr string) (res []*model.LabourQs, err error) {
|
|
var rows *sql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_selQuestionSQL, idStr, idStr)); err != nil {
|
|
log.Error("d.QuestionList.Query(%s) error(%v)", idStr, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
r := new(model.LabourQs)
|
|
if err = rows.Scan(&r.ID, &r.Question, &r.Ans); err != nil {
|
|
log.Error("row.Scan() error(%v)", err)
|
|
res = nil
|
|
return
|
|
}
|
|
res = append(res, r)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// QsAllList get question list.
|
|
func (d *Dao) QsAllList(c context.Context, idStr string) (mlab map[int64]*model.LabourQs, labs []*model.LabourQs, avIDs []int64, err error) {
|
|
var rows *sql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_selAllQuestionSQL, idStr)); err != nil {
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
mlab = make(map[int64]*model.LabourQs, 40)
|
|
for rows.Next() {
|
|
r := new(model.LabourQs)
|
|
if err = rows.Scan(&r.ID, &r.Question, &r.Ans, &r.AvID, &r.Status, &r.Source, &r.Ctime, &r.Mtime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
}
|
|
mlab = nil
|
|
labs = nil
|
|
avIDs = nil
|
|
return
|
|
}
|
|
mlab[r.ID] = r
|
|
labs = append(labs, r)
|
|
if r.AvID != 0 {
|
|
avIDs = append(avIDs, r.AvID)
|
|
}
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// AnswerStatus get blocked user answer status.
|
|
func (d *Dao) AnswerStatus(c context.Context, mid int64, ts time.Time) (status bool, err error) {
|
|
row := d.db.QueryRow(c, _isAnsweredSQL, mid, ts)
|
|
var count int64
|
|
if err = row.Scan(&count); err != nil {
|
|
if err != sql.ErrNoRows {
|
|
err = errors.Wrap(err, "AnswerStatus")
|
|
return
|
|
}
|
|
count = 0
|
|
err = nil
|
|
}
|
|
status = count > 0
|
|
return
|
|
}
|
|
|
|
// LastNoAuditQuestion get new no audit question data.
|
|
func (d *Dao) LastNoAuditQuestion(c context.Context) (res []*model.LabourQs, avIDs []int64, err error) {
|
|
rows, err := d.db.Query(c, _noAuditQuestionSQL)
|
|
if err != nil {
|
|
log.Error("d.db.Query err(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
labourQs := &model.LabourQs{}
|
|
if err = rows.Scan(&labourQs.ID, &labourQs.AvID, &labourQs.Question); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("rows.Scan err(%v)", err)
|
|
}
|
|
res = []*model.LabourQs{}
|
|
avIDs = []int64{}
|
|
return
|
|
}
|
|
res = append(res, labourQs)
|
|
if labourQs.AvID != 0 {
|
|
avIDs = append(avIDs, labourQs.AvID)
|
|
}
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// LastAuditQuestion get new audit question data.
|
|
func (d *Dao) LastAuditQuestion(c context.Context) (res []*model.LabourQs, avIDs []int64, err error) {
|
|
rows, err := d.db.Query(c, _auditQuestionSQL)
|
|
if err != nil {
|
|
log.Error("d.db.Query err(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
labourQs := &model.LabourQs{}
|
|
if err = rows.Scan(&labourQs.ID, &labourQs.AvID, &labourQs.Question); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("rows.Scan err(%v)", err)
|
|
}
|
|
res = []*model.LabourQs{}
|
|
avIDs = []int64{}
|
|
return
|
|
}
|
|
res = append(res, labourQs)
|
|
if labourQs.AvID != 0 {
|
|
avIDs = append(avIDs, labourQs.AvID)
|
|
}
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// KPIList get kpi list.
|
|
func (d *Dao) KPIList(c context.Context, mid int64) (res []*model.KPIData, err error) {
|
|
var rows *sql.Rows
|
|
if rows, err = d.db.Query(c, _selKPISQL, mid); err != nil {
|
|
log.Error("KpiList: d.db.Query error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
r := new(model.KPIData)
|
|
if err = rows.Scan(&r.Mid, &r.Day, &r.Rate, &r.RankPer, &r.RankPer, &r.RankTotal, &r.Point, &r.ActiveDays, &r.VoteTotal, &r.OpinionLikes, &r.VoteRealTotal); err != nil {
|
|
log.Error("row.Scan() error(%v)", err)
|
|
res = nil
|
|
return
|
|
}
|
|
res = append(res, r)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// AnnouncementInfo get announcement detail.
|
|
func (d *Dao) AnnouncementInfo(c context.Context, aid int64) (r *model.BlockedAnnouncement, err error) {
|
|
row := d.db.QueryRow(c, _announcementInfoSQL, aid)
|
|
if err = row.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Content, &r.PublishStatus, &r.StickStatus, &r.URL, &r.Ptype, &r.CTime, &r.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "AnnouncementInfo")
|
|
}
|
|
return
|
|
}
|
|
|
|
// AnnouncementList get accnoucement list.
|
|
func (d *Dao) AnnouncementList(c context.Context) (res []*model.BlockedAnnouncement, err error) {
|
|
rows, err := d.db.Query(c, _announcementListSQL, time.Now())
|
|
if err != nil {
|
|
err = errors.Wrap(err, "AnnouncementList")
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
r := new(model.BlockedAnnouncement)
|
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.PublishStatus, &r.StickStatus, &r.Content, &r.URL, &r.Ptype, &r.CTime, &r.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "AnnouncementList")
|
|
return
|
|
}
|
|
res = append(res, r)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// BatchPublishs get publish info list.
|
|
func (d *Dao) BatchPublishs(c context.Context, ids []int64) (res map[int64]*model.BlockedAnnouncement, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_publishsSQL, xstr.JoinInts(ids)))
|
|
if err != nil {
|
|
err = errors.Wrap(err, "BatchPublishs")
|
|
return
|
|
}
|
|
res = make(map[int64]*model.BlockedAnnouncement)
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
r := new(model.BlockedAnnouncement)
|
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.StickStatus, &r.Content, &r.CTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "BatchPublishs")
|
|
return
|
|
}
|
|
res[r.ID] = r
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// NewKPI return user newest KPI rate.
|
|
func (d *Dao) NewKPI(c context.Context, mid int64) (rate int8, err error) {
|
|
row := d.db.QueryRow(c, _selNewKPISQL, mid)
|
|
if err != nil {
|
|
log.Error("NewKPI: d.QueryRow error(%v)", err)
|
|
return
|
|
}
|
|
if err = row.Scan(&rate); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
rate = model.KPILevelC
|
|
err = nil
|
|
return
|
|
}
|
|
log.Error("row.Scan() error(%v)", err)
|
|
}
|
|
return
|
|
}
|