399 lines
12 KiB
Go
399 lines
12 KiB
Go
package dao
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"github.com/fonchain/fonchain-artistinfo/cmd/model"
|
|
"github.com/fonchain/fonchain-artistinfo/pb/supplyinfo"
|
|
db "github.com/fonchain/fonchain-artistinfo/pkg/db"
|
|
"github.com/fonchain/fonchain-artistinfo/pkg/m"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
func GetSupplyInfoList(id, num int32) (rep *supplyinfo.GetSupplyInfoListRespond, err error) {
|
|
rep = &supplyinfo.GetSupplyInfoListRespond{}
|
|
var datas []*supplyinfo.GetSupplyInfoData
|
|
|
|
var supplyInfoList []model.SupplyInfo
|
|
if err := db.DB.Where("user_id = ? and types <= ?", id, num).Find(&supplyInfoList).Error; err != nil {
|
|
zap.L().Error("get supplyInfo infos err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
for i, v := range supplyInfoList {
|
|
supplyInfoList[i].CreateTime = v.CreatedAt.Format("2006-01-02")
|
|
data := &supplyinfo.GetSupplyInfoData{}
|
|
data.ID = uint64(supplyInfoList[i].ID)
|
|
data.ArtworkId = supplyInfoList[i].ArtworkId
|
|
data.ArtistId = supplyInfoList[i].ArtistId
|
|
data.UserId = uint64(supplyInfoList[i].UserId)
|
|
data.Name = supplyInfoList[i].Name
|
|
data.ModelYear = supplyInfoList[i].ModelYear
|
|
data.Photo = supplyInfoList[i].Photo
|
|
data.ArtistPhoto = supplyInfoList[i].ArtistPhoto
|
|
data.Width = uint64(supplyInfoList[i].Width)
|
|
data.Height = uint64(supplyInfoList[i].Height)
|
|
data.Ruler = uint64(supplyInfoList[i].Ruler)
|
|
data.ExhibitInfo = supplyInfoList[i].ExhibitInfo
|
|
data.ExhibitPic1 = supplyInfoList[i].ExhibitPic1
|
|
data.ExhibitPic2 = supplyInfoList[i].ExhibitPic2
|
|
data.CreateTime = supplyInfoList[i].CreateTime
|
|
data.Introduct = supplyInfoList[i].Introduct
|
|
data.NetworkTrace = supplyInfoList[i].NetworkTrace
|
|
data.CreateAddress = supplyInfoList[i].CreateAddress
|
|
data.Url = supplyInfoList[i].Url
|
|
data.Types = supplyInfoList[i].State
|
|
data.Remark = supplyInfoList[i].Remark
|
|
data.Remark2 = supplyInfoList[i].Remark2
|
|
data.Enable = supplyInfoList[i].Enable
|
|
datas = append(datas, data)
|
|
}
|
|
rep.Data = datas
|
|
|
|
return
|
|
}
|
|
|
|
func GetSupplyInfo(req *supplyinfo.GetSupplyInfoRequest) (rep *supplyinfo.GetSupplyInfoData, err error) {
|
|
rep = &supplyinfo.GetSupplyInfoData{}
|
|
|
|
var supplyInfoTmp model.SupplyInfo
|
|
if err := db.DB.Where("id = ?", req.Id).Find(&supplyInfoTmp).Error; err != nil {
|
|
zap.L().Error("get supplyInfo infos err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
rep.ID = uint64(supplyInfoTmp.ID)
|
|
rep.ArtworkId = supplyInfoTmp.ArtworkId
|
|
rep.ArtistId = supplyInfoTmp.ArtistId
|
|
rep.UserId = uint64(supplyInfoTmp.UserId)
|
|
rep.Name = supplyInfoTmp.Name
|
|
rep.ModelYear = supplyInfoTmp.ModelYear
|
|
rep.Photo = supplyInfoTmp.Photo
|
|
rep.ArtistPhoto = supplyInfoTmp.ArtistPhoto
|
|
rep.Width = uint64(supplyInfoTmp.Width)
|
|
rep.Height = uint64(supplyInfoTmp.Height)
|
|
rep.Ruler = uint64(supplyInfoTmp.Ruler)
|
|
rep.ExhibitInfo = supplyInfoTmp.ExhibitInfo
|
|
rep.ExhibitPic1 = supplyInfoTmp.ExhibitPic1
|
|
rep.ExhibitPic2 = supplyInfoTmp.ExhibitPic2
|
|
rep.CreateTime = supplyInfoTmp.CreateTime
|
|
rep.Introduct = supplyInfoTmp.Introduct
|
|
rep.NetworkTrace = supplyInfoTmp.NetworkTrace
|
|
rep.CreateAddress = supplyInfoTmp.CreateAddress
|
|
rep.Url = supplyInfoTmp.Url
|
|
rep.Types = supplyInfoTmp.State
|
|
rep.Remark = supplyInfoTmp.Remark
|
|
rep.Remark2 = supplyInfoTmp.Remark2
|
|
rep.Enable = supplyInfoTmp.Enable
|
|
|
|
return
|
|
}
|
|
|
|
func UpdateSupplyInfo(req *supplyinfo.UpdateSupplyInfoRequest) (rep *supplyinfo.UpdateSupplyInfoRespond, err error) {
|
|
var SupplyInfo model.SupplyInfo
|
|
if err := db.DB.Where("id = ? ", req.ID).Find(&SupplyInfo).Error; err != nil {
|
|
zap.L().Error("get supplyInfo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
SupplyInfo.CreateTime = req.CreateTime
|
|
SupplyInfo.ModelYear = req.ModelYear
|
|
SupplyInfo.NetworkTrace = req.NetworkTrace
|
|
SupplyInfo.Url = req.Url
|
|
SupplyInfo.Introduct = req.Introduct
|
|
SupplyInfo.State = req.Types
|
|
SupplyInfo.ExhibitInfo = req.ExhibitInfo
|
|
SupplyInfo.ExhibitPic1 = req.ExhibitPic1
|
|
SupplyInfo.ExhibitPic2 = req.ExhibitPic2
|
|
|
|
if err = db.DB.Save(&SupplyInfo).Error; err != nil {
|
|
zap.L().Error("save supplyInfo info err", zap.Error(err))
|
|
err = errors.New(m.SAVE_ERROR)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func GetVideoList(id int32) (rep *supplyinfo.GetVideoListRespond, err error) {
|
|
rep = &supplyinfo.GetVideoListRespond{}
|
|
var datas []*supplyinfo.GetVideoListData
|
|
|
|
var ExhVideo []model.ExhVideo
|
|
if err := db.DB.Where("user_id = ? and types <=4", id).Find(&ExhVideo).Error; err != nil {
|
|
zap.L().Error("get exhVideo infos err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
for _, v := range ExhVideo {
|
|
var data supplyinfo.GetVideoListData
|
|
data.ID = uint64(v.ID)
|
|
data.UserId = uint64(v.UserId)
|
|
data.Url = v.Url
|
|
data.Types = v.State
|
|
data.Remark = v.Remark
|
|
data.Remark2 = v.Remark2
|
|
data.Enable = v.Enable
|
|
|
|
datas = append(datas, &data)
|
|
}
|
|
|
|
rep.Data = datas
|
|
|
|
return
|
|
}
|
|
|
|
func GetVideo(req *supplyinfo.GetVideoRequest) (rep *supplyinfo.GetVideoListData, err error) {
|
|
rep = &supplyinfo.GetVideoListData{}
|
|
|
|
var ExhVideo model.ExhVideo
|
|
if err := db.DB.Where("id = ?", req.ID).First(&ExhVideo).Error; err != nil {
|
|
zap.L().Error("get exhVideo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
rep.ID = uint64(ExhVideo.ID)
|
|
rep.UserId = uint64(ExhVideo.UserId)
|
|
rep.Url = ExhVideo.Url
|
|
rep.Types = ExhVideo.State
|
|
rep.Remark = ExhVideo.Remark
|
|
rep.Remark2 = ExhVideo.Remark2
|
|
rep.Enable = ExhVideo.Enable
|
|
|
|
return
|
|
}
|
|
|
|
func UpdateVideo(req *supplyinfo.UpdateVideoRequest) (rep *supplyinfo.UpdateVideoRespond, err error) {
|
|
rep = &supplyinfo.UpdateVideoRespond{}
|
|
|
|
var ExhVideo model.ExhVideo
|
|
if err := db.DB.Where("id = ? ", req.ID).First(&ExhVideo).Error; err != nil {
|
|
zap.L().Error("get exhVideo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
ExhVideo.Url = req.Url
|
|
ExhVideo.State = req.Types
|
|
|
|
if err := db.DB.Save(&ExhVideo).Error; err != nil {
|
|
zap.L().Error("save exhVideo info err", zap.Error(err))
|
|
err = errors.New(m.SAVE_ERROR)
|
|
return nil, err
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func GetExam(req *supplyinfo.GetExamRequest) (rep *supplyinfo.GetExamListData, err error) {
|
|
rep = &supplyinfo.GetExamListData{}
|
|
|
|
var ExhExam model.ExhExam
|
|
if err := db.DB.Where("id = ?", req.ID).First(&ExhExam).Error; err != nil {
|
|
zap.L().Error("get exhVideo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
rep.ID = uint64(ExhExam.ID)
|
|
rep.UserId = uint64(ExhExam.UserId)
|
|
rep.Title = ExhExam.Title
|
|
rep.Class = ExhExam.Class
|
|
rep.TitleScore = uint64(ExhExam.TitleScore)
|
|
rep.Score = ExhExam.Score
|
|
rep.Types = ExhExam.State
|
|
rep.Remark = ExhExam.Remark
|
|
rep.Remark2 = ExhExam.Remark2
|
|
rep.Enable = ExhExam.Enable
|
|
return
|
|
}
|
|
|
|
func GetExamList(req *supplyinfo.GetExamListRequest) (rep *supplyinfo.GetExamListRespond, err error) {
|
|
rep = &supplyinfo.GetExamListRespond{}
|
|
var datas []*supplyinfo.GetExamListData
|
|
|
|
var ExhExam []model.ExhExam
|
|
if err := db.DB.Where("user_id = ? and types <=4", req.ID).Find(&ExhExam).Error; err != nil {
|
|
zap.L().Error("get exhVideo infos err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
for _, v := range ExhExam {
|
|
var data supplyinfo.GetExamListData
|
|
|
|
data.ID = uint64(v.ID)
|
|
data.UserId = uint64(v.UserId)
|
|
data.Title = v.Title
|
|
data.Class = v.Class
|
|
data.TitleScore = uint64(v.TitleScore)
|
|
data.Score = v.Score
|
|
data.Types = v.State
|
|
data.Remark = v.Remark
|
|
data.Remark2 = v.Remark2
|
|
data.Enable = v.Enable
|
|
|
|
datas = append(datas, &data)
|
|
}
|
|
|
|
rep.Data = datas
|
|
|
|
return
|
|
}
|
|
|
|
func UpdateExam(req *supplyinfo.UpdateExamRequest) (rep *supplyinfo.UpdateExamRespond, err error) {
|
|
rep = &supplyinfo.UpdateExamRespond{}
|
|
|
|
var ExhExam model.ExhExam
|
|
if err := db.DB.Where("id = ? ", req.ID).First(&ExhExam).Error; err != nil {
|
|
zap.L().Error("get exhVideo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
ExhExam.Score = req.Score
|
|
ExhExam.Class = req.Class
|
|
ExhExam.State = req.Types
|
|
ExhExam.Title = req.Title
|
|
ExhExam.Class = req.Class
|
|
ExhExam.TitleScore = uint(req.TitleScore)
|
|
ExhExam.Score = req.Score
|
|
ExhExam.State = req.Types
|
|
ExhExam.Remark = req.Remark
|
|
ExhExam.Remark2 = req.Remark2
|
|
|
|
var score map[string]int32
|
|
var titleScore int32
|
|
|
|
json.Unmarshal([]byte(req.Score), &score)
|
|
|
|
for _, v := range score {
|
|
titleScore = titleScore + v
|
|
}
|
|
|
|
ExhExam.TitleScore = uint(titleScore)
|
|
|
|
if err = db.DB.Save(&ExhExam).Error; err != nil {
|
|
zap.L().Error("save supplyInfo info err", zap.Error(err))
|
|
err = errors.New(m.SAVE_ERROR)
|
|
return
|
|
}
|
|
|
|
if req.Types == "2" {
|
|
type titleScore struct {
|
|
UserId uint
|
|
Score int
|
|
}
|
|
|
|
var tmp []model.ExhExam
|
|
if err = db.DB.Where("class = ?", req.Class).Order("title_score desc").Find(&tmp).Error; err != nil {
|
|
zap.L().Error("get exhExam infos err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
var ranking int
|
|
for k, v := range tmp {
|
|
if v.UserId == uint(req.UserId) {
|
|
ranking = k
|
|
}
|
|
}
|
|
|
|
percent := (ranking + 1) / len(tmp) * 100
|
|
rep.Percent = int32(percent)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func GetArtistInfoList(id int32) (rep *supplyinfo.GetArtistInfoListRespond, err error) {
|
|
rep = &supplyinfo.GetArtistInfoListRespond{}
|
|
var datas []*supplyinfo.GetArtistInfoListData
|
|
|
|
var artistInfoTmp []model.ArtistInfo
|
|
if err = db.DB.Where("user_id = ? and state <=4 ", id).Find(&artistInfoTmp).Error; err != nil {
|
|
zap.L().Error("get artistInfo infos err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
for k, v := range artistInfoTmp {
|
|
artistInfoTmp[k].Model.ID = v.ID
|
|
data := &supplyinfo.GetArtistInfoListData{}
|
|
|
|
data.ID = uint64(artistInfoTmp[k].ID)
|
|
data.UserId = uint64(artistInfoTmp[k].UserId)
|
|
data.ArtistId = artistInfoTmp[k].ArtistId
|
|
data.BankAccount = artistInfoTmp[k].BankAccount
|
|
data.BankName = artistInfoTmp[k].BankName
|
|
data.Introduct = artistInfoTmp[k].Introduct
|
|
data.CountryArtLevel = artistInfoTmp[k].CountryArtLevel
|
|
data.ArtistCertPic = artistInfoTmp[k].ArtistCertPic
|
|
data.Remark = artistInfoTmp[k].Remark
|
|
data.Remark2 = artistInfoTmp[k].Remark2
|
|
data.State = uint64(artistInfoTmp[k].State)
|
|
|
|
datas = append(datas, data)
|
|
}
|
|
|
|
rep.Data = datas
|
|
|
|
return
|
|
}
|
|
|
|
func GetArtistInfo(req *supplyinfo.GetArtistInfoRequest) (rep *supplyinfo.GetArtistInfoListData, err error) {
|
|
rep = &supplyinfo.GetArtistInfoListData{}
|
|
|
|
var artistInfoTmp model.ArtistInfo
|
|
if err := db.DB.Where("id = ?", req.ID).Find(&artistInfoTmp).Error; err != nil {
|
|
zap.L().Error("get artistInfo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
rep.ID = uint64(artistInfoTmp.ID)
|
|
rep.UserId = uint64(artistInfoTmp.UserId)
|
|
rep.ArtistId = artistInfoTmp.ArtistId
|
|
rep.BankAccount = artistInfoTmp.BankAccount
|
|
rep.BankName = artistInfoTmp.BankName
|
|
rep.Introduct = artistInfoTmp.Introduct
|
|
rep.CountryArtLevel = artistInfoTmp.CountryArtLevel
|
|
rep.ArtistCertPic = artistInfoTmp.ArtistCertPic
|
|
rep.Remark = artistInfoTmp.Remark
|
|
rep.Remark2 = artistInfoTmp.Remark2
|
|
rep.State = uint64(artistInfoTmp.State)
|
|
|
|
return
|
|
}
|
|
|
|
func UpdateArtistInfo(req *supplyinfo.UpdateArtistInfoRequest) (rep *supplyinfo.UpdateArtistInfoRespond, err error) {
|
|
rep = &supplyinfo.UpdateArtistInfoRespond{}
|
|
|
|
var artistInfoTmp model.ArtistInfo
|
|
if err := db.DB.Where("id = ? ", req.ID).Find(&artistInfoTmp).Error; err != nil {
|
|
zap.L().Error("get artistInfo info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return nil, err
|
|
}
|
|
|
|
artistInfoTmp.BankAccount = req.BankAccount
|
|
artistInfoTmp.BankName = req.BankName
|
|
artistInfoTmp.Introduct = req.Introduct
|
|
artistInfoTmp.State = uint(req.State)
|
|
artistInfoTmp.CountryArtLevel = req.CountryArtLevel
|
|
artistInfoTmp.ArtistCertPic = req.ArtistCertPic
|
|
|
|
if err = db.DB.Save(&artistInfoTmp).Error; err != nil {
|
|
zap.L().Error("save supplyInfo info err", zap.Error(err))
|
|
err = errors.New(m.SAVE_ERROR)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|