fonchain-fiee/pkg/service/preorder.go

package service

import (
	"context"
	"fmt"

	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"github.com/fonchain_enterprise/fonchain-main/api/preorder"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/gin-gonic/gin"
)

//增加团队预约类型
func AddTeamType(c *gin.Context) {
	var req preorder.AddTeamTypereq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Add ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.AddTeamType(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	if len(resp.Data) > 0 {
		// 获取第一个元素的唯一标识
		uuid := resp.Data[0].Uuid
		ResponseQuickMsg(c, e.Ok, resp.Msg, map[string]interface{}{
			"Uuid": uuid,
		})
	} else {
		ResponseQuickMsg(c, e.Ok, resp.Msg, nil)
	}

	return
}

//团队预约类型列表
func TeamTypeList(c *gin.Context) {
	var req preorder.TeamTypeListreq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Select ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.TeamTypeList(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, resp)
	return
}

//修改团队预约类型
func EditTeamType(c *gin.Context) {
	var req preorder.EditTeamTypereq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("EditTeamType ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	addData := make([]*preorder.AddTeamTypereq_Info, 0)
	delUuid := make([]*preorder.DelTeamTypereq_Info, 0)
	editData := make([]*preorder.EditTeamTypereq_Info, 0)

	for i := 0; i < len(req.Data); i++ {
		switch {
		case req.Data[i].Uuid == "":
			fmt.Println("第一次：", i)
			fmt.Println(req.Data)
			fmt.Println("++++++++++++++++++++++++++++++++++++++++++++")

			info := &preorder.AddTeamTypereq_Info{
				TypeName:  req.Data[i].TypeName,
				TypePrice: req.Data[i].TypePrice,
				Resolve:   req.Data[i].Resolve,
			}
			addData = append(addData, info)
			continue // 跳过当前迭代，继续下一个迭代

		case req.Data[i].Uuid != "":
			fmt.Println("第二次：", i)
			needEdit := &preorder.EditTeamTypereq_Info{
				Uuid:      req.Data[i].Uuid,
				TypeName:  req.Data[i].TypeName,
				TypePrice: req.Data[i].TypePrice,
			}

			// 更新
			editData = append(editData, needEdit)

			// 删除
			uuid := &preorder.DelTeamTypereq_Info{
				Uuid: req.Data[i].Uuid,
			}

			delUuid = append(delUuid, uuid)

			continue

		}
	}

	if len(editData) > 0 {
		req3 := &preorder.EditTeamTypereq{
			Data: editData,
		}
		fmt.Println(req3.Data)

		_, err := GrpcPreorderImpl.EditTeamType(context.Background(), req3)
		if err != nil {
			ResponseQuickMsg(c, e.Ok, err.Error(), nil)
			return
		}
		// ResponseQuickMsg(c, e.Ok, resp.Msg, nil)
	}

	if len(delUuid) > 0 {
		req2 := &preorder.DelTeamTypereq{
			Data: delUuid,
		}
		fmt.Println(req2.Data)
		_, err := GrpcPreorderImpl.DelTeamType(context.Background(), req2)
		if err != nil {
			ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
	}

	if len(addData) > 0 {
		req1 := &preorder.AddTeamTypereq{
			Data: addData,
		}

		fmt.Println(req1.Data)
		_, err := GrpcPreorderImpl.AddTeamType(context.Background(), req1)
		if err != nil {
			ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
	}

	ResponseQuickMsg(c, e.Ok, "成功", nil)
	return
}

//删除团队预约类型
func DelTeamType(c *gin.Context) {
	var req preorder.DelTeamTypereq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("DelTeamType ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	resp, err := GrpcPreorderImpl.DelTeamType(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, nil)
	return
}

//批量设置
func LotSet(c *gin.Context) {
	var req preorder.LotSetreq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Add ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.LotSet(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, map[string]interface{}{
		"Uuid": resp.Data.Uuid,
	})
	return
}

//日历查看批量设置列表
func SetList(c *gin.Context) {
	var req preorder.SetListreq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Select ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.SetList(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, resp)
	return
}

//删除当天
func EditSet(c *gin.Context) {
	var req preorder.EditSetreq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Edit ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.EditSet(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, resp)
	return
}

//设置当天的时间段
func AddLongTime(c *gin.Context) {
	var req preorder.AddLongTimereq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Add ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.AddLongTime(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	if len(resp.Data) > 0 {
		// 获取第一个元素的唯一标识
		uuid := resp.Data[0].Uuid
		ResponseQuickMsg(c, e.Ok, resp.Msg, map[string]interface{}{
			"Uuid": uuid,
		})
	} else {
		ResponseQuickMsg(c, e.Ok, resp.Msg, nil)
	}
}

//时间段的增删改查
func EditTime(c *gin.Context) {
	var req preorder.EditTimereq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("EditTime", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	addData := make([]*preorder.AddLongTimereq_Info, 0)
	delUuid := make([]*preorder.DelTimereq_Info, 0)
	editData := make([]*preorder.EditTimereq_Info, 0)

	for i := 0; i < len(req.Data); i++ {
		switch {
		case req.Data[i].Uuid == "":
			fmt.Println("新增", i)
			fmt.Println(req.Data)
			fmt.Println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")

			info := &preorder.AddLongTimereq_Info{
				StartTime: req.Data[i].StartTime,
				EndTime:   req.Data[i].EndTime,
				MaxCount:  req.Data[i].MaxCount,
			}
			addData = append(addData, info)
			continue

		case req.Data[i].Uuid != "":
			fmt.Println("第二次", i)
			needEdit := &preorder.EditTimereq_Info{
				Uuid:      req.Data[i].Uuid,
				StartTime: req.Data[i].StartTime,
				EndTime:   req.Data[i].EndTime,
				MaxCount:  req.Data[i].MaxCount,
			}

			editData = append(editData, needEdit)
			uuid := &preorder.DelTimereq_Info{
				Uuid: req.Data[i].Uuid,
			}
			delUuid = append(delUuid, uuid)
			continue
		}
	}

	if len(editData) > 0 {
		req3 := &preorder.EditTimereq{
			Data: editData,
		}
		fmt.Println(req3.Data)

		_, err := GrpcPreorderImpl.EditTime(context.Background(), req3)
		if err != nil {
			ResponseQuickMsg(c, e.Ok, err.Error(), nil)
			return
		}
	}

	if len(delUuid) > 0 {
		req2 := &preorder.DelTimereq{
			Data: delUuid,
		}
		fmt.Println(req2.Data)
		_, err := GrpcPreorderImpl.DelTime(context.Background(), req2)
		if err != nil {
			ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
	}

	if len(addData) > 0 {
		req1 := &preorder.AddLongTimereq{
			Data: addData,
		}

		fmt.Println(req1.Data)
		_, err := GrpcPreorderImpl.AddLongTime(context.Background(), req1)
		if err != nil {
			ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
	}
	ResponseQuickMsg(c, e.Ok, "时间段设置成功", nil)
	return

}

//时间列表
func AllTime(c *gin.Context) {
	var req preorder.AllTimereq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("Select ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}

	resp, err := GrpcPreorderImpl.AllTime(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, resp)
	return
}