fonchain-artistinfo/cmd/internal/logic/statement.go
2023-04-18 16:00:10 +08:00

595 lines
16 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package logic
import (
"fmt"
"github.com/fonchain/fonchain-artistinfo/cmd/internal/dao"
statement "github.com/fonchain/fonchain-artistinfo/pb/artistinfoStatement"
db "github.com/fonchain/fonchain-artistinfo/pkg/db"
"github.com/fonchain/fonchain-artistinfo/pkg/util"
"gorm.io/gorm"
)
type IStatement interface {
UploadExcelOneTx(req *statement.UploadExcelOneTxRequest) (rep *statement.UploadExcelOneTxRespond, err error)
UploadExcelTwoTx(req *statement.UploadExcelTwoTxRequest) (rep *statement.UploadExcelTwoTxRespond, err error)
UploadExcelOneCopy(req *statement.UploadExcelOneCopyRequest) (rep *statement.UploadExcelOneCopyRespond, err error)
UploadExcelTwoCopy(req *statement.UploadExcelTwoCopyRequest) (rep *statement.UploadExcelTwoCopyRespond, err error)
GetAllBatchTimeTx(req *statement.GetAllBatchTimeTxRequest) (rep *statement.GetAllBatchTimeTxRespond, err error)
GetArtworkSoldTxDetailList(req *statement.GetArtworkSoldTxDetailListRequest) (rep *statement.GetArtworkSoldTxDetailListRespond, err error)
StatementList(req *statement.StatementListRequest) (rep *statement.StatementListRespond, err error)
GetTxInfoByBatchUid(req *statement.GetTxInfoByBatchUidRequest) (rep *statement.GetTxInfoByBatchUidRespond, err error)
GetCopyInfoByBatchUid(req *statement.GetCopyInfoByBatchUidRequest) (rep *statement.GetCopyInfoByBatchUidRespond, err error)
}
func NewStatement() IStatement {
return &Statement{}
}
type Statement struct {
}
func (a *Statement) UploadExcelOneTx(req *statement.UploadExcelOneTxRequest) (rep *statement.UploadExcelOneTxRespond, err error) {
rep = &statement.UploadExcelOneTxRespond{}
fmt.Println("req.ExcelOneInfo", req.ExcelOneInfo)
//开启事务,遇到错误就回滚
tx := db.DB.Begin()
defer func() {
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
}()
for _, v := range req.ExcelOneInfo {
//查看是否已经被生成了批次,没有的就生成物权批次
exist, artworkTx, err := dao.IsExistArtworkTx(v.BatchTime, v.ArtistUid)
if err != nil {
return rep, err
}
if exist {
//获取批次uid
uid1, err := util.GetUid()
if err != nil {
return rep, err
}
//生成批次
err = dao.CreateArtworkTx(tx, uid1, v.BatchTime, v.ArtistUid, v.ArtistName)
if err != nil {
return rep, err
}
//对账单画作物权委托详情uid
uid2, err := util.GetUid()
if err != nil {
return rep, err
}
//将数据插入对账单画作物权委托详情
err = dao.CreateArtworkTxDetail(tx, uid1, uid2, v)
if err != nil {
return rep, err
}
} else {
//查看画作是否已经被该批次录入过,被录入过就跳过
count, err := dao.IsExistArtworkTxDetail(artworkTx.Uid, v.TfNum)
if err != nil {
return rep, err
}
if count != 1 {
continue
}
//获取批次uid
uid, err := util.GetUid()
if err != nil {
return rep, err
}
err = dao.CreateArtworkTxDetail(tx, artworkTx.Uid, uid, v)
if err != nil {
return rep, err
}
}
}
return
}
func (a *Statement) UploadExcelTwoTx(req *statement.UploadExcelTwoTxRequest) (rep *statement.UploadExcelTwoTxRespond, err error) {
rep = &statement.UploadExcelTwoTxRespond{}
//开启事务,遇到错误就回滚
tx := db.DB.Begin()
defer func() {
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
}()
for _, v := range req.ExcelTwoInfo {
//查看是否已经被生成了物权批次
exist, artworkTx, err := dao.IsExistArtworkTx(v.BatchTime, v.ArtistUid)
if err != nil {
return rep, err
}
//没有的就生成物权批次
if exist {
//获取批次uid
uid1, err := util.GetUid()
if err != nil {
return rep, err
}
//生成批次
err = dao.CreateArtworkTx(tx, uid1, v.BatchTime, v.ArtistUid, v.ArtistName)
if err != nil {
return rep, err
}
//对账单画作物权委托详情uid
uid2, err := util.GetUid()
if err != nil {
return rep, err
}
//将数据插入对账单画作物权销售委托详情
err = dao.CreateArtworkSoldTxDetail(tx, uid1, uid2, v)
if err != nil {
return rep, err
}
} else {
//查看画作是否已经被该批次录入过,被录入过就跳过
count, err := dao.IsExistArtworkSoldTxDetail(artworkTx.Uid, v.TfNum)
if err != nil {
return rep, err
}
if count != 1 {
continue
}
//获取批次uid
uid, err := util.GetUid()
if err != nil {
return rep, err
}
err = dao.CreateArtworkSoldTxDetail(tx, artworkTx.Uid, uid, v)
if err != nil {
return rep, err
}
}
}
return
}
func (a *Statement) UploadExcelOneCopy(req *statement.UploadExcelOneCopyRequest) (rep *statement.UploadExcelOneCopyRespond, err error) {
rep = &statement.UploadExcelOneCopyRespond{}
//开启事务,遇到错误就回滚
tx := db.DB.Begin()
defer func() {
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
}()
for _, v := range req.ExcelOneInfo {
//查看是否已经被生成了批次,没有的就生成版权批次
exist, artworkCopy, err := dao.IsExistArtworkCopy(v.BatchTime, v.ArtistUid)
if err != nil {
return rep, err
}
if exist {
//获取批次uid
uid1, err := util.GetUid()
if err != nil {
return rep, err
}
//生成批次
err = dao.CreateArtworkCopy(tx, uid1, v.BatchTime, v.ArtistUid, v.ArtistName)
if err != nil {
tx.Rollback()
return rep, err
}
//对账单画作物权委托详情uid
uid2, err := util.GetUid()
if err != nil {
return rep, err
}
//将数据插入对账单画作物权委托详情
err = dao.CreateArtworkCopyDetail(tx, uid1, uid2, v)
if err != nil {
return rep, err
}
} else {
count, err := dao.IsExistArtworkCopyDetail(artworkCopy.Uid, v.TfNum)
if err != nil {
return rep, err
}
if count != 1 {
continue
}
//获取批次uid
uid, err := util.GetUid()
if err != nil {
return rep, err
}
err = dao.CreateArtworkCopyDetail(tx, artworkCopy.Uid, uid, v)
if err != nil {
return rep, err
}
}
}
return
}
func (a *Statement) UploadExcelTwoCopy(req *statement.UploadExcelTwoCopyRequest) (rep *statement.UploadExcelTwoCopyRespond, err error) {
rep = &statement.UploadExcelTwoCopyRespond{}
//开启事务,遇到错误就回滚
tx := db.DB.Begin()
defer func() {
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
}()
for _, v := range req.ExcelTwoInfo {
//查看是否已经被生成了物权批次
exist, artworkCopy, err := dao.IsExistArtworkCopy(v.BatchTime, v.ArtistUid)
if err != nil {
return rep, err
}
//没有的就生成物权批次
if exist {
//获取批次uid
uid1, err := util.GetUid()
if err != nil {
return rep, err
}
//生成批次
err = dao.CreateArtworkCopy(tx, uid1, v.BatchTime, v.ArtistUid, v.ArtistName)
if err != nil {
tx.Rollback()
return rep, err
}
//对账单画作物权委托详情uid
uid2, err := util.GetUid()
if err != nil {
return rep, err
}
//将数据插入对账单画作物权销售委托详情
err = dao.CreateArtworkSoldCopyDetail(tx, uid1, uid2, v)
if err != nil {
return rep, err
}
} else {
//查看画作是否已经被该批次录入过,被录入过就跳过
count, err := dao.IsExistArtworkSoldCopyDetail(artworkCopy.Uid, v.TfNum)
if err != nil {
return rep, err
}
if count != 1 {
continue
}
//获取批次uid
uid, err := util.GetUid()
if err != nil {
return rep, err
}
err = dao.CreateArtworkSoldCopyDetail(tx, artworkCopy.Uid, uid, v)
if err != nil {
return rep, err
}
}
}
return
}
func (a *Statement) GetAllBatchTimeTx(req *statement.GetAllBatchTimeTxRequest) (rep *statement.GetAllBatchTimeTxRespond, err error) {
rep = &statement.GetAllBatchTimeTxRespond{}
//batchTime去重查询只获取batchTime字段值
batchTime, err := dao.GetAllBatchTimeTx()
if err != nil {
return
}
rep.BatchTime = batchTime
return
}
func (a *Statement) GetAllBatchTimeCopy(req *statement.GetAllBatchTimeCopyRequest) (rep *statement.GetAllBatchTimeCopyRespond, err error) {
rep = &statement.GetAllBatchTimeCopyRespond{}
//batchTime去重查询只获取batchTime字段值
batchTime, err := dao.GetAllBatchTimeCopy()
if err != nil {
return
}
rep.BatchTime = batchTime
return
}
func (a *Statement) GetArtworkSoldTxDetailList(req *statement.GetArtworkSoldTxDetailListRequest) (rep *statement.GetArtworkSoldTxDetailListRespond, err error) {
rep = &statement.GetArtworkSoldTxDetailListRespond{}
artistList := &statement.ArtistList{}
artworkSoldDetailList := &statement.ArtworkSoldDetailList{}
var query *gorm.DB = db.DB // 初始化query变量
//画家姓名不为空,模糊查询(根据画家姓名的某个字也可以查询)
if req.ArtistName != "" {
query = query.Where("artist_name LiKE ?", "%"+req.ArtistName+"%")
}
//批次不为空
if req.BatchTime != "" {
query = query.Where("batch_time = ?", req.BatchTime)
}
//画家姓名不为空
if req.State != 0 {
query = query.Where("state = ?", req.State)
}
//合同分页查询操作
if req.Page < 1 {
req.Page = 1
}
if req.Num < 1 {
req.Num = 15
}
offset := (req.Page - 1) * req.Num
artworkTxList, err := dao.GetArtworkTxList(query, req.Num, offset)
if err != nil {
return
}
for _, v := range artworkTxList {
artistList.BatchUid = v.Uid
artistList.ArtistName = v.ArtistName
artistList.BatchTime = v.BatchTime
artistList.State = v.State
//当已经签署了合同时
if v.State == 3 {
//获取合同预览和下载链接
contract, err := dao.GetContractUrlTx(v.Uid)
if err != nil {
return rep, err
}
artistList.ViewUrl = contract.ViewUrl
artistList.DownloadUrl = contract.DownloadUrl
} else {
artistList.ViewUrl = ""
artistList.DownloadUrl = ""
}
//查询对账单画作物权销售委托详情
artworkSoldTxDetail, err := dao.GetArtworkSoldTxDetailList(v.Uid)
if err != nil {
return rep, err
}
//获取该画家该批次所有的已售出的画信息
for _, m := range artworkSoldTxDetail {
artworkSoldDetailList.ArtworkName = m.ArtworkName
artworkSoldDetailList.TfNum = m.TfNum
artworkSoldDetailList.Ruler = m.Ruler
artworkSoldDetailList.SaleNo = m.SaleNo
artworkSoldDetailList.CompleteDate = m.CompleteDate
artworkSoldDetailList.SalePrice = m.SalePrice
artistList.ArtworkSoldDetailList = append(artistList.ArtworkSoldDetailList, artworkSoldDetailList)
}
rep.ArtistList = append(rep.ArtistList, artistList)
}
return
}
func (a *Statement) GetArtworkSoldCopyDetailList(req *statement.GetArtworkSoldCopyDetailListRequest) (rep *statement.GetArtworkSoldCopyDetailListRespond, err error) {
rep = &statement.GetArtworkSoldCopyDetailListRespond{}
artistList := &statement.ArtistList{}
artworkSoldDetailList := &statement.ArtworkSoldDetailList{}
var query *gorm.DB = db.DB // 初始化query变量
//画家姓名不为空
if req.ArtistName != "" {
query = query.Where("artist_name LiKE ?", "%"+req.ArtistName+"%")
}
//批次不为空
if req.BatchTime != "" {
query = query.Where("batch_time = ?", req.BatchTime)
}
//画家姓名不为空
if req.State != 0 {
query = query.Where("state = ?", req.State)
}
//合同分页查询操作
if req.Page < 1 {
req.Page = 1
}
if req.Num < 1 {
req.Num = 15
}
offset := (req.Page - 1) * req.Num
artworkCopyList, err := dao.GetArtworkCopyList(query, req.Num, offset)
if err != nil {
return
}
for _, v := range artworkCopyList {
artistList.BatchUid = v.Uid
artistList.ArtistName = v.ArtistName
artistList.BatchTime = v.BatchTime
artistList.State = v.State
//当已经签署了合同时
if v.State == 3 {
//获取合同预览和下载链接
contract, err := dao.GetContractUrlTx(v.Uid)
if err != nil {
return rep, err
}
artistList.ViewUrl = contract.ViewUrl
artistList.DownloadUrl = contract.DownloadUrl
} else {
artistList.ViewUrl = ""
artistList.DownloadUrl = ""
}
//查询对账单画作物权销售委托详情
artworkSoldTxDetail, err := dao.GetArtworkSoldTxDetailList(v.Uid)
if err != nil {
return rep, err
}
//获取该画家该批次所有的已售出的画信息
for _, m := range artworkSoldTxDetail {
artworkSoldDetailList.ArtworkName = m.ArtworkName
artworkSoldDetailList.TfNum = m.TfNum
artworkSoldDetailList.Ruler = m.Ruler
artworkSoldDetailList.SaleNo = m.SaleNo
artworkSoldDetailList.CompleteDate = m.CompleteDate
artworkSoldDetailList.SalePrice = m.SalePrice
artistList.ArtworkSoldDetailList = append(artistList.ArtworkSoldDetailList, artworkSoldDetailList)
}
rep.ArtistList = append(rep.ArtistList, artistList)
}
return
}
func (a *Statement) StatementList(req *statement.StatementListRequest) (rep *statement.StatementListRespond, err error) {
//查看是否有该画家
user, err := dao.GetArtistInfoById(req.ArtistUid)
if err != nil {
return
}
ContractData, err := dao.StatementList(user.MgmtArtistUid, req.State)
if err != nil {
return
}
rep = &statement.StatementListRespond{
Data: ContractData,
}
return
}
func (a *Statement) GetTxInfoByBatchUid(req *statement.GetTxInfoByBatchUidRequest) (rep *statement.GetTxInfoByBatchUidRespond, err error) {
rep = &statement.GetTxInfoByBatchUidRespond{}
//获取画家名
artworkTx, err := dao.GetTxArtistNameByBatchUid(req.BatchUid)
if err != nil {
return
}
rep.ArtistName = artworkTx.ArtistName
//获取物权画作详细信息
artworkTxDetails, err := dao.GetArtworkTxDetailByBatchUid(req.BatchUid)
if err != nil {
return
}
rep.ArtistName = artworkTx.ArtistName
//获取物权画作被售卖详细信息
artworkSoldTxDetails, err := dao.GetArtworkSoldTxDetailByBatchUid(req.BatchUid)
if err != nil {
return
}
artworkTxDetail := new(statement.ArtworkTxDetail)
artworkSoldTxDetail := new(statement.ArtworkSoldTxDetail)
for _, v := range artworkTxDetails {
artworkTxDetail.TfNum = v.TfNum
artworkTxDetail.ArtworkName = v.ArtworkName
artworkTxDetail.Ruler = v.Ruler
artworkTxDetail.MinPrice = v.MinPrice
artworkTxDetail.GuaranteePrice = v.GuaranteePrice
rep.ArtworkTxDetail = append(rep.ArtworkTxDetail, artworkTxDetail)
}
for _, v := range artworkSoldTxDetails {
artworkSoldTxDetail.TfNum = v.TfNum
artworkSoldTxDetail.ArtworkName = v.ArtworkName
artworkSoldTxDetail.Ruler = v.Ruler
artworkSoldTxDetail.SaleNo = v.SaleNo
artworkSoldTxDetail.CompleteDate = v.CompleteDate
artworkSoldTxDetail.SalePrice = v.SalePrice
rep.ArtworkSoldTxDetail = append(rep.ArtworkSoldTxDetail, artworkSoldTxDetail)
}
return
}
func (a *Statement) GetCopyInfoByBatchUid(req *statement.GetCopyInfoByBatchUidRequest) (rep *statement.GetCopyInfoByBatchUidRespond, err error) {
rep = &statement.GetCopyInfoByBatchUidRespond{}
//获取画家名
artworkTx, err := dao.GetCopyArtistNameByBatchUid(req.BatchUid)
if err != nil {
return
}
rep.ArtistName = artworkTx.ArtistName
//获取版权画作详细信息
artworkTxDetails, err := dao.GetArtworkCopyDetailByBatchUid(req.BatchUid)
if err != nil {
return
}
rep.ArtistName = artworkTx.ArtistName
//获取版权画作被售卖详细信息
artworkSoldTxDetails, err := dao.GetArtworkSoldCopyDetailByBatchUid(req.BatchUid)
if err != nil {
return
}
artworkCopyDetail := new(statement.ArtworkCopyDetail)
artworkSoldCopyDetail := new(statement.ArtworkSoldCopyDetail)
for _, v := range artworkTxDetails {
artworkCopyDetail.TfNum = v.TfNum
artworkCopyDetail.ArtworkName = v.ArtworkName
artworkCopyDetail.Ruler = v.Ruler
artworkCopyDetail.MinPrice = v.MinPrice
artworkCopyDetail.GuaranteePrice = v.GuaranteePrice
rep.ArtworkCopyDetail = append(rep.ArtworkCopyDetail, artworkCopyDetail)
}
for _, v := range artworkSoldTxDetails {
artworkSoldCopyDetail.TfNum = v.TfNum
artworkSoldCopyDetail.ArtworkName = v.ArtworkName
artworkSoldCopyDetail.Ruler = v.Ruler
artworkSoldCopyDetail.SaleNo = v.SaleNo
artworkSoldCopyDetail.CompleteDate = v.CompleteDate
artworkSoldCopyDetail.MinPrice = v.MinPrice
artworkSoldCopyDetail.SalePrice = v.SalePrice
artworkSoldCopyDetail.GuaranteePrice = v.GuaranteePrice
rep.ArtworkSoldCopyDetail = append(rep.ArtworkSoldCopyDetail, artworkSoldCopyDetail)
}
return
}