back/internal/api/manage/vend/update.go

package vend

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/golangkit/formatime"
	"recook/internal/api/manage/gys/logic"
	"recook/internal/back"
	"recook/internal/dbc"
	"recook/internal/model/goods"
	"recook/internal/model/manage"
	"recook/internal/model/vend"
	"recook/tools"
)

type yesVendParam struct {
	UserId    string       `json:"UserId" validator:"required"`
	BrandList []BrandList2 `json:"BrandList" `
}
type BrandList2 struct {
	ID    int64 `json:"id"`
	Brand Brand `json:"brand"`
}

type Brand struct {
	ID         uint   `json:"id"`
	Name       string `json:"name"`
	Desc       string `json:"desc"`
	Web        string `json:"web"`
	GoodsCount int64  `json:"goodsCount"`
	LogoURL    string `json:"logoUrl"`
	AuthURL    string `json:"authUrl"`
	ShowURL    string `json:"showUrl"`
	Key        int64  `json:"key"`
}

func YesVend(c *gin.Context) {
	var p yesVendParam
	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	if len(p.UserId) == 0 {
		back.Fail(c, "服务器异常请联系管理员")
		return
	}
	var userId = c.MustGet("Manager_ID").(uint)

	var user manage.UserInfo
	user.ID = userId
	if err = dbc.DB.Find(&user).Error; err != nil {
		back.Fail(c, "数据错误:"+err.Error())
		return
	}
	tx := dbc.DB.Begin()
	infoE := vend.GysEnterpriseState{}
	dbc.DB.Where("user_id = ?", p.UserId).Order("id DESC").First(&infoE)
	if infoE.ID == 0 {
		tx.Rollback()
		back.Fail(c, "没有可审核信息")
		return
	}
	//infoE.State = "2"
	//infoE.AdminUser = user.name
	//infoE.AdminID = user.ID
	//infoE.AdminDate = formatime.NewSecondNow()
	if infoE.State == "1" {
		if err = tx.Table("gys_auth_group_access").Create(&vend.GysAuthGroupAccess{
			Uid:     p.UserId,
			GroupID: 2,
		}).Error; err != nil {
			tx.Rollback()
			back.Fail(c, "权限组"+err.Error())
			return
		}
	}
	if err = tx.Table("gys_enterprise_state").Where("id = ?", infoE.ID).Update(&vend.GysEnterpriseState{
		State:     "2",
		AdminUser: user.Name,
		AdminID:   user.ID,
		AdminDate: formatime.NewSecondNow(),
	}).Error; err != nil {
		tx.Rollback()
		back.Fail(c, "状态"+err.Error())
		return
	}
	insertVendMap := map[string]goods.Brand{}
	for _, _info := range p.BrandList {
		brandInfo := goods.Brand{}
		dbc.DB.Where("name = ?", _info.Brand.Name).Find(&brandInfo)
		vendBrandInfo := vend.GysEnterpriseBrand{}

		vendBrandInfo.ID = _info.Brand.ID
		dbc.DB.Find(&vendBrandInfo)
		if brandInfo.ID == 0 {
			brandInfo = insertVendMap[vendBrandInfo.Name]
			if brandInfo.ID == 0 {
				brandInfo = goods.Brand{
					Name:    vendBrandInfo.Name,
					LogoURL: vendBrandInfo.Log,
					InfoId:  vendBrandInfo.ID,
				}
				err = tx.Create(&brandInfo).Error
				if err != nil {
					tx.Rollback()
					back.Fail(c, "品牌"+err.Error())
					return
				}
				insertVendMap[vendBrandInfo.Name] = brandInfo
			}
		} else {
			brandInfo.LogoURL = vendBrandInfo.Log
			brandInfo.InfoId = vendBrandInfo.ID
			err = dbc.DB.Save(&brandInfo).Error
			if err != nil {
				tx.Rollback()
				back.Fail(c, err.Error())
				return
			}
		}
		if err = tx.Table("gys_enterprise_brand").Where("enterprise_id = ? and id=?", infoE.ID, vendBrandInfo.ID).Update(&vend.GysEnterpriseBrand{
			State:     "2",
			AdminUser: user.Name,
			AdminID:   user.ID,
			AdminDate: formatime.NewSecondNow(),
			MainID:    brandInfo.ID,
		}).Error; err != nil {
			tx.Rollback()
			back.Fail(c, err.Error())
			return
		}
	}

	tx.Commit()
	back.Suc(c, "操作成功", p)
	return
}

type brandYesParam struct {
	Id      string `json:"id" validator:"required"`
	BrandID string `json:"brand_id"`
}

func BrandYes(c *gin.Context) {
	var p brandYesParam
	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	var userId = c.MustGet("Manager_ID").(uint)

	var user manage.UserInfo
	user.ID = userId
	if err = dbc.DB.Find(&user).Error; err != nil {
		back.Fail(c, "数据错误:"+err.Error())
		return
	}
	tx := dbc.DB.Begin()
	vendBrandInfo := vend.GysEnterpriseBrand{}

	dbc.DB.Where("id = ? ", p.Id).Find(&vendBrandInfo)
	brandInfo := goods.Brand{}
	dbc.DB.Where("name = ?", vendBrandInfo.Name).Find(&brandInfo)

	if brandInfo.ID == 0 {
		brandInfo = goods.Brand{
			Name:    vendBrandInfo.Name,
			LogoURL: vendBrandInfo.Log,
			InfoId:  vendBrandInfo.ID,
		}
		err = tx.Create(&brandInfo).Error
		if err != nil {
			back.Fail(c, err.Error())
			return
		}
	} else {
		brandInfo.LogoURL = vendBrandInfo.Log
		brandInfo.InfoId = vendBrandInfo.ID
		err = dbc.DB.Save(&brandInfo).Error
		if err != nil {
			back.Fail(c, err.Error())
			return
		}
	}

	if err = tx.Table("gys_enterprise_brand").Where("id = ?", p.Id).Update(&vend.GysEnterpriseBrand{
		State:     "2",
		AdminUser: user.Name,
		AdminID:   user.ID,
		AdminDate: formatime.NewSecondNow(),
		MainID:    brandInfo.ID,
	}).Error; err != nil {
		back.Fail(c, err.Error())
		return
	}

	tx.Commit()
	back.Suc(c, "操作成功", p)
	return
}

type brandNoParam struct {
	Id     string `json:"id" validator:"required"`
	Detail string `json:"detail"`
}

func BrandNo(c *gin.Context) {
	var p brandNoParam
	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	var userId = c.MustGet("Manager_ID").(uint)

	var user manage.UserInfo
	user.ID = userId
	if err = dbc.DB.Find(&user).Error; err != nil {
		back.Fail(c, "数据错误:"+err.Error())
		return
	}
	tx := dbc.DB.Begin()

	if err = tx.Table("gys_enterprise_brand").Where("id = ?", p.Id).Update(&vend.GysEnterpriseBrand{
		State:     "3",
		StateInfo: p.Detail,
		AdminUser: user.Name,
		AdminID:   user.ID,
		AdminDate: formatime.NewSecondNow(),
	}).Error; err != nil {
		back.Fail(c, err.Error())
		return
	}
	tx.Commit()
	back.Suc(c, "操作成功", p)
	return

}

type noVendParam struct {
	UserId string `json:"UserId" validator:"required"`
	Detail string `json:"detail"`
}

func NoVend(c *gin.Context) {
	var p noVendParam
	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	if len(p.UserId) == 0 {
		back.Fail(c, "服务器异常请联系管理员")
		return
	}
	var userId = c.MustGet("Manager_ID").(uint)

	var user manage.UserInfo
	user.ID = userId
	if err = dbc.DB.Find(&user).Error; err != nil {
		back.Fail(c, "数据错误:"+err.Error())
		return
	}
	tx := dbc.DB.Begin()
	infoE := vend.GysEnterpriseState{}
	dbc.DB.Where("user_id = ?", p.UserId).Order("id DESC").First(&infoE)
	if infoE.ID == 0 {
		back.Fail(c, "没有可审核信息")
		return
	}
	//infoE.State = "2"
	//infoE.AdminUser = user.name
	//infoE.AdminID = user.ID
	//infoE.AdminDate = formatime.NewSecondNow()
	if err = tx.Table("gys_enterprise_state").Where("id = ?", infoE.ID).Update(&vend.GysEnterpriseState{
		State:     "3",
		StateInfo: p.Detail,
		AdminUser: user.Name,
		AdminID:   user.ID,
		AdminDate: formatime.NewSecondNow(),
	}).Error; err != nil {
		back.Fail(c, err.Error())
		return
	}
	if err = tx.Table("gys_enterprise_brand").Where("enterprise_id = ?", infoE.ID).Update(&vend.GysEnterpriseBrand{
		State:     "3",
		StateInfo: p.Detail,
		AdminUser: user.Name,
		AdminID:   user.ID,
		AdminDate: formatime.NewSecondNow(),
	}).Error; err != nil {
		back.Fail(c, err.Error())
		return
	}
	tx.Commit()
	back.Suc(c, "操作成功", p)
	return
}

type argsUpdate struct {
	BrandId uint `json:"brandId" form:"brandId"`
	logic.BrandItem
}

// @Style 修改品牌信息
func BrandUpdate(c *gin.Context) {
	// 参数获取
	args := argsUpdate{}
	err := tools.Params(&args, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	info := &vend.GysEnterpriseBrand{ID: args.BrandId}
	if err := dbc.DB.First(&info).Error; err != nil {
		back.Fail(c, "数据错误")
		return
	}
	args.BrandItem.Name = info.Name
	args.BrandItem.Category = fmt.Sprintf("%s,%s", info.Category, info.CategoryId)
	data := []logic.BrandItem{args.BrandItem}
	if err = logic.BrandLogic.VerfiyBrand(&data); err != nil {
		back.Fail(c, err.Error())
		return
	}

	db := dbc.DB.Begin()
	defer func() {
		if r := recover(); r != nil {
			db.Rollback()
			back.Fail(c, "网络异常")
		} else if err != nil {
			db.Rollback()
		} else {
			db.Commit()
		}
	}()
	err = logic.BrandLogic.HandBrand(args.BrandId, info.UserID, data, 1, "", db)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	back.Suc(c, "操作成功", nil)
}

type argsInterior struct {
	VendId uint `json:"vendId" form:"vendId"`
}

// @Style 设置为需要单独显示权限的内部账号
func Interior(c *gin.Context) {
	args := argsInterior{}
	err := tools.Params(&args, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	if args.VendId <= 0 {
		back.Fail(c, "参数错误")
		return
	}

	vendUser := vend.GysUsers{
		ID: args.VendId,
	}
	if dbc.DB.Model(&vendUser).Update("is_interior", 1).Error != nil {
		back.Fail(c, "网络异常")
		return
	}
	back.Suc(c, "操作成功", "")
	return
}

// @Style 取消需要单独显示权限的内部账号权限
func CancelInterior(c *gin.Context) {
	args := argsInterior{}
	err := tools.Params(&args, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}
	if args.VendId <= 0 {
		back.Fail(c, "参数错误")
		return
	}

	vendUser := vend.GysUsers{
		ID: args.VendId,
	}
	if dbc.DB.Model(&vendUser).Update("is_interior", 0).Error != nil {
		back.Fail(c, "网络异常")
		return
	}
	back.Suc(c, "操作成功", "")
	return
}