368 lines
10 KiB
Go
368 lines
10 KiB
Go
package dao
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"github.com/alibaba/sentinel-golang/logging"
|
|
"github.com/fonchain-artistserver/cmd/model"
|
|
"github.com/fonchain-artistserver/pb/artwork"
|
|
db "github.com/fonchain-artistserver/pkg/db"
|
|
"github.com/fonchain-artistserver/pkg/m"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
func ArtworkAdd(res *artwork.ArtworkAddRequest) (req *artwork.ArtworkAddRespond, err error) {
|
|
CreataAddByte, err := json.Marshal(res.CreateAddress)
|
|
if err != nil {
|
|
zap.L().Error("marshal createAddress failed", zap.Error(err))
|
|
err = errors.New(m.ERROR_MARSHAL)
|
|
return
|
|
}
|
|
artwork := &model.Artwork{
|
|
ArtistId: int32(res.ArtistId),
|
|
Name: res.Name,
|
|
ModelYear: res.ModelYear,
|
|
Photo: res.Photo,
|
|
ArtistPhoto: res.ArtistPhoto,
|
|
CreateAddress: string(CreataAddByte),
|
|
Width: int32(res.Width),
|
|
AgeOfCreation: res.AgeOfCreation,
|
|
Height: int32(res.Height),
|
|
Ruler: int32(res.Ruler),
|
|
Introduct: res.Introduct,
|
|
NetworkTrace: res.NetworkTrace,
|
|
Url: res.Url,
|
|
State: int32(res.State),
|
|
}
|
|
|
|
if err = db.DB.Create(&artwork).Error; err != nil {
|
|
zap.L().Error("create artwork info err", zap.Error(err))
|
|
err = errors.New(m.CREATE_ERROR)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
|
|
|
|
//Get 用户修改信息
|
|
func (service UserUpdateInfoService) Update(id uint) serializer.Response {
|
|
var user model.User
|
|
code := e.SUCCESS
|
|
//找到用户
|
|
err := model.DB.First(&user, "id = ?", id).Error
|
|
if err != nil {
|
|
logging.Info(err)
|
|
code = e.ErrorDatabase
|
|
return serializer.Response{
|
|
Status: 400,
|
|
Msg: e.GetMsg(code),
|
|
Error: err.Error(),
|
|
}
|
|
}
|
|
user.PenName = service.PenName
|
|
user.Photo = service.Photo
|
|
user.Video = service.Video
|
|
user.CertificateImg = service.CertificateImg
|
|
conAddessByte, err := json.Marshal(service.ConAddress)
|
|
if err != nil {
|
|
logging.Info(err)
|
|
code = e.ErrorDatabase
|
|
return serializer.Response{
|
|
Status: 400,
|
|
Msg: e.GetMsg(code),
|
|
Error: err.Error(),
|
|
}
|
|
}
|
|
user.ConAddress = string(conAddessByte)
|
|
user.WxAccount = service.WxAccount
|
|
user.CertificateNum = service.CertificateNum
|
|
err = model.DB.Save(&user).Error
|
|
if err != nil {
|
|
logging.Info(err)
|
|
code = e.ErrorDatabase
|
|
return serializer.Response{
|
|
Status: 400,
|
|
Msg: e.GetMsg(code),
|
|
Error: err.Error(),
|
|
}
|
|
}
|
|
var realName model.RealName
|
|
err = model.DB.First(&realName, "id = ?", user.RealNameID).Error
|
|
if err != nil {
|
|
logging.Info(err)
|
|
code = e.ErrorDatabase
|
|
return serializer.Response{
|
|
Status: 400,
|
|
Msg: e.GetMsg(code),
|
|
Error: err.Error(),
|
|
}
|
|
}
|
|
realName.IdcardBack = service.IdCardBack
|
|
realName.IdcardFront = service.IdCardFront
|
|
err = model.DB.Save(&realName).Error
|
|
if err != nil {
|
|
logging.Info(err)
|
|
code = e.ErrorDatabase
|
|
return serializer.Response{
|
|
Status: 400,
|
|
Msg: e.GetMsg(code),
|
|
Error: err.Error(),
|
|
}
|
|
}
|
|
return serializer.Response{
|
|
Status: code,
|
|
Data: serializer.BuildUser(user),
|
|
Msg: e.GetMsg(code),
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func CheckUserLock(id int64) (err error) {
|
|
var user model.User
|
|
if err = db.DB.Where("id = ? ", id).First(&user).Error; err != nil {
|
|
zap.L().Error("get user info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
|
|
if user.IsLock {
|
|
zap.L().Error("user is lock")
|
|
return errors.New(m.ERROR_ISLOCK)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func UpdateArtwork(data *artwork.UpdateArtworkRequest) (err error) {
|
|
var artwork model.Artwork
|
|
artwork.ID = int32(data.ID)
|
|
if err = db.DB.First(&artwork).Error; err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
|
|
CreataAddByte, _ := json.Marshal(data.CreateAddress)
|
|
artwork.ID = int32(data.ID)
|
|
artwork.ArtistId = int32(data.ArtistId)
|
|
artwork.Name = data.Name
|
|
artwork.ModelYear = data.ModelYear
|
|
artwork.Photo = data.Photo
|
|
artwork.ArtistPhoto = data.ArtistPhoto
|
|
artwork.Width = int32(data.Width)
|
|
artwork.AgeOfCreation = data.AgeOfCreation
|
|
artwork.CreateAddress = string(CreataAddByte)
|
|
artwork.Height = int32(data.Height)
|
|
artwork.Ruler = int32(data.Ruler)
|
|
artwork.Introduct = data.Introduct
|
|
artwork.NetworkTrace = data.NetworkTrace
|
|
artwork.Url = data.Url
|
|
artwork.State = 1
|
|
|
|
if err = db.DB.Save(&artwork).Error; err != nil {
|
|
zap.L().Error("save artwork info err", zap.Error(err))
|
|
err = errors.New(m.SAVE_ERROR)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func DelArtwork(id int32) (err error) {
|
|
if err = db.DB.Where("id = ?", id).Delete(&model.Artwork{}).Error; err != nil {
|
|
zap.L().Error("delete artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_DELETE)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
func ApproveArtwork(req *artwork.ApproveArtworkRequest)(rep *artwork.ApproveArtworkRespond,err error){
|
|
|
|
var artwork model.Artwork
|
|
artwork.ID = int32(data.ID)
|
|
var state int
|
|
if req.IsApprove {
|
|
state = 3
|
|
} else {
|
|
state = 4
|
|
}
|
|
if err = db.DB.Update(&artwork).Where("state = ?,remark = ?,remark2 = ?",state,req.Remark,req.Remark2).Error; err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func GetArtworkList(req *artwork.GetArtworkListRequest) (rep *artwork.GetArtworkListRespond, err error) {
|
|
rep = &artwork.GetArtworkListRespond{}
|
|
var datas []*artwork.UpdateArtworkRequest
|
|
|
|
var artworkList []model.Artwork
|
|
//找到用户 p[]
|
|
if err = db.DB.Order("created_at desc").Where("id = ?", req.Id).Find(&artworkList).Error; err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
for k, v := range artworkList {
|
|
artworkList[k].CreateTime = v.CreatedAt.Format("2006-01-02")
|
|
var data artwork.UpdateArtworkRequest
|
|
var createAddressByte []string
|
|
json.Unmarshal([]byte(artworkList[k].CreateAddress), &createAddressByte)
|
|
data.ID = uint64(artworkList[k].ID)
|
|
// data.ArtistId = uint64(artworkList[k].ArtistId)
|
|
data.Name = artworkList[k].Name
|
|
data.ModelYear = artworkList[k].ModelYear
|
|
data.Photo = artworkList[k].Photo
|
|
data.ArtistPhoto = artworkList[k].ArtistPhoto
|
|
data.Width = uint64(artworkList[k].Width)
|
|
data.CreateAddress = createAddressByte
|
|
data.Height = uint64(artworkList[k].Height)
|
|
data.Ruler = uint64(artworkList[k].Ruler)
|
|
data.Introduct = artworkList[k].Introduct
|
|
data.AgeOfCreation = artworkList[k].AgeOfCreation
|
|
data.CreateAt = artworkList[k].CreateTime
|
|
data.NetworkTrace = artworkList[k].NetworkTrace
|
|
data.Url = artworkList[k].Url
|
|
data.State = uint64(artworkList[k].State)
|
|
datas = append(datas, &data)
|
|
}
|
|
rep.Data = datas
|
|
return
|
|
}
|
|
|
|
func GetArtwork(id int32) (rep *artwork.GetArtworkRespond, err error) {
|
|
rep = &artwork.GetArtworkRespond{}
|
|
|
|
var artworkRes model.Artwork
|
|
if err = db.DB.Find(&artworkRes, "id = ? and deleted_at is null", id).Error; err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
|
|
artworkRes.CreateTime = artworkRes.CreatedAt.Format("2006-01-02")
|
|
var createAddressByte []string
|
|
json.Unmarshal([]byte(artworkRes.CreateAddress), &createAddressByte)
|
|
rep.ID = uint64(artworkRes.ID)
|
|
// rep.ArtistId = uint64(artworkRes.ArtistId)
|
|
rep.Name = artworkRes.Name
|
|
rep.ModelYear = artworkRes.ModelYear
|
|
rep.Photo = artworkRes.Photo
|
|
rep.ArtistPhoto = artworkRes.ArtistPhoto
|
|
rep.Width = uint64(artworkRes.Width)
|
|
rep.CreateAddress = createAddressByte
|
|
rep.Height = uint64(artworkRes.Height)
|
|
rep.Ruler = uint64(artworkRes.Ruler)
|
|
rep.Introduct = artworkRes.Introduct
|
|
rep.AgeOfCreation = artworkRes.AgeOfCreation
|
|
rep.CreateAt = artworkRes.CreateTime
|
|
rep.NetworkTrace = artworkRes.NetworkTrace
|
|
rep.Url = artworkRes.Url
|
|
rep.State = uint64(artworkRes.State)
|
|
return
|
|
}
|
|
|
|
func UploadArtwork(Id uint64) (err error) {
|
|
var artwork model.Artwork
|
|
if err = db.DB.Find(&artwork, "id = ?", Id).Error; err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
artwork.State = 1
|
|
|
|
if err = db.DB.Save(&artwork).Error; err != nil {
|
|
zap.L().Error("save artwork info err", zap.Error(rr))
|
|
err = errors.New(m.SAVE_ERROR)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetMgmtArtworkList(req *artwork.GetMgmtArtworkListRequest) (rep *artwork.GetMgmtArtworkListRespond, err error) {
|
|
rep = &artwork.GetArtworkListRespond{}
|
|
var datas []*artwork.UpdateArtworkRequest
|
|
id, err := GetUserId(req.ArtistId)
|
|
if err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
var args []interface{}
|
|
var sqlWhere = " (state >=1 and state <=3) "
|
|
if req.Name != "" {
|
|
sqlWhere += ` and name like ? `
|
|
args = append(args, "%"+req.Name+"%")
|
|
}
|
|
// if req.BatchId != 0 {
|
|
// sqlWhere += `and c.batch_id = ? `
|
|
// args = append(args, req.BatchId)
|
|
// }
|
|
if req.ArtistId != 0 {
|
|
sqlWhere += ` artist_id = ? `
|
|
args = append(args, id)
|
|
}
|
|
if req.State != 0 {
|
|
sqlWhere += ` and state = ? `
|
|
args = append(args, req.State)
|
|
}
|
|
//找到用户
|
|
var artworkCount model.Artwork
|
|
|
|
tx = db.DB.Where(sqlWhere, args...).Count(&artworkCount)
|
|
if tx.Error != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
rep.Count = tx.
|
|
var artworkList []model.Artwork
|
|
//找到用户
|
|
var sqlLimit = sqlWhere + " limit ?,? "
|
|
args = append(args, (req.Page-1)*req.PageSize)
|
|
args = append(args, req.Num)
|
|
if err = db.DB.Order("created_at desc").Where(sqlWhere, args...).Find(&artworkList).Error; err != nil {
|
|
zap.L().Error("get artwork info err", zap.Error(err))
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return
|
|
}
|
|
for k, v := range artworkList {
|
|
artworkList[k].CreateTime = v.CreatedAt.Format("2006-01-02")
|
|
var data artwork.UpdateArtworkRequest
|
|
var createAddressByte []string
|
|
json.Unmarshal([]byte(artworkList[k].CreateAddress), &createAddressByte)
|
|
data.Name = artworkList[k].Name
|
|
data.ModelYear = artworkList[k].ModelYear
|
|
data.Photo = artworkList[k].Photo
|
|
data.ArtistPhoto = artworkList[k].ArtistPhoto
|
|
data.CreateAt = artworkList[k].CreateTme
|
|
data.NetworkTrace = artworkList[k].Netor
|
|
data.Url = artworkList[k].Url
|
|
data.State = uint64(artworkList[k].State)
|
|
datas = append(datas, &data)
|
|
}
|
|
rep.Data = datas
|
|
return
|
|
}
|
|
|
|
func GetUserId(artistId string) (uint64, error) {
|
|
var user model.User
|
|
if err := db.DB.First(&user, "id = ? and deleted_at is null", id).Error; err != nil {
|
|
|
|
|
|
err = errors.New(m.ERROR_SELECT)
|
|
return 0, err
|
|
}
|
|
return user.ID, nil
|
|
|
|
}
|