jyOrderManager/internal/logic/user/getService.go

package user

import (
	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/date"
	"app.yhyue.com/moapp/jybase/mongodb"
	"context"
	"fmt"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/pkg/errors"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/model"
	"time"
)

func GetUserService(ctx context.Context, param model.UserServiceParams) (interface{}, error) {
	var (
		serviceArrMap []map[string]interface{}
		userData      *map[string]interface{}
		vipExist      bool
	)
	if param.Phone != "" {
		if param.BuySubject == "1" { //个人版本会员状态查询
			userData, _ = jyutil.MG.DB().FindOne("user", map[string]interface{}{
				"$or": []map[string]interface{}{
					{"s_phone": param.Phone},
					{"s_m_phone": param.Phone},
				},
			})
			if userData == nil || len(*userData) == 0 {
				return map[string]interface{}{
					"willEffect": false,
					//"userData":      userData,
					"serviceArrMap": nil,
				}, nil
			}
			if userData != nil && len(*userData) > 0 {
				userId := mongodb.BsonIdToSId((*userData)["_id"])
				if param.ProductType != "大会员" && param.ProductType != "VIP订阅" {
					serviceArrMap = SpecialService(ctx, userId, param.ProductType)
				} else {
					sqlStr := fmt.Sprintf(`SELECT  * FROM jy_order_detail 
WHERE status = 1 and is_service_open = 0 and user_id = '%s' and product_type like '%s'  AND service_endtime < '%s'`, userId, common.If(param.ProductType == "VIP订阅", "%VIP订阅%", "%大会员%"), time.Now().Format(date.Date_Full_Layout))
					if param.OrderCode != "" {
						sqlStr += fmt.Sprintf(" AND order_code != '%s'", param.OrderCode)
					}
					//检验订单是否可以进行传创建
					order, _ := g.DB().Query(ctx, sqlStr)
					if !order.IsEmpty() && order.Len() > 0 {
						return map[string]interface{}{
							"willEffect":    true,
							"userData":      userData,
							"serviceArrMap": nil,
						}, nil
					}

					var (
						serviceList                    []int
						endTime, startTime             string
						paySubNum, areaCount, linkedId int
						orderArr                       []map[string]interface{}
					)
					var whereEntTime string
					//购买关联
					if param.ServiceType != 1 && param.ServiceType != 4 {
						whereEntTime = "and a.is_service_open = 1"
					} else {
						//续费升级关联
						whereEntTime = "and b.order_status = 1"
					}
					orderData, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT   a.id,a.service_type,a.order_code,b.create_time   FROM jy_order_detail  a
INNER JOIN dataexport_order b on a.order_code = b.order_code
WHERE a.status = 1 %s and a.user_id = '%s' and a.product_type like '%s' ORDER BY b.create_time desc `, whereEntTime, userId, common.If(param.ProductType == "VIP订阅", "%VIP订阅%", "%大会员%")))
					if !orderData.IsEmpty() {
						for _, m2 := range orderData.List() {
							if linkedId == 0 {
								linkedId = gconv.Int(m2["id"])
							}
							orderArr = append(orderArr, map[string]interface{}{
								"order_code":      m2["order_code"],
								"create_time":     m2["create_time"],
								"service_type":    m2["service_type"],
								"order_detail_id": m2["id"],
							})
						}
					}
					var comboId int
					switch param.ProductType {
					case "VIP订阅":
						var (
							newVip, nationwide bool
						)
						vipExist = gconv.Int((*userData)["i_vip_status"]) == 2
						if vipExist {
							paySubNum = 1
							vipInfo := common.ObjToMap((*userData)["o_vipjy"])
							buySet := common.ObjToMap((*vipInfo)["o_buyset"])
							areaCount = common.IntAll((*buySet)["areacount"])
							//判断是新版超级订阅还是老版超级订阅
							if common.IntAll((*buySet)["upgrade"]) == 1 {
								newVip = true
							}

							if areaCount == -1 {
								nationwide = true
							}
							endTime = time.Unix(common.Int64All((*userData)["l_vip_endtime"]), 0).Format("2006-01-02 15:04:05")
						}
						serviceArrMap = append(serviceArrMap, map[string]interface{}{
							"vipExist":         vipExist, //当前服务是否在有限期内
							"nationwide":       nationwide,
							"name":             param.ProductType, //产品名称
							"serviceEndTime":   endTime,           //服务结束时间
							"serviceStartTime": startTime,         //服务开始时间
							"newVip":           newVip,
							"empowerCount":     paySubNum,   //服务授权数
							"provinceCount":    areaCount,   //订阅省份
							"buySubject":       1,           //个体
							"comboId":          comboId,     //套餐id
							"serviceList":      serviceList, //大会员服务id
							"linkedId":         linkedId,    //关联id
							"linkedOrder":      orderArr,    //关联订单
						})
					case "大会员":
						bigStart := common.Int64All((*userData)["i_member_starttime"])
						bigEnd := common.Int64All((*userData)["i_member_endtime"])
						subStatus := common.IntAll((*userData)["i_member_sub_status"])
						memberStatus := common.IntAll((*userData)["i_member_status"])
						comboId = common.If(memberStatus == 5, 0, memberStatus).(int)
						mainId := common.ObjToString((*userData)["s_member_mainid"])
						if memberJyMap, ok1 := ((*userData)["o_member_jy"]).(map[string]interface{}); ok1 {
							areaCount = common.IntAll(memberJyMap["i_areacount"])
						}
						if bigStart >= time.Now().Unix() {
							endTime = time.Unix(bigEnd, 0).Format("2006-01-02 15:04:05")
							vipExist = true
						} else if (time.Now().Unix() < bigEnd && memberStatus > 0) || bigStart >= time.Now().Unix() {
							vipExist = true
							endTime = time.Unix(bigEnd, 0).Format("2006-01-02 15:04:05")
						}
						if (subStatus == 0 && memberStatus < 0 && mainId != "") || (subStatus == 1 && memberStatus > 0 && mainId != "") {
							vipExist = true
						}
						userServer, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT s_serviceid,s_smainid,l_endtime,l_starttime FROM bigmember_service_user WHERE s_userid = '%s' and i_status =0`, userId))
						if !userServer.IsEmpty() {
							vipExist = true
							count, _ := g.DB().GetCount(ctx, fmt.Sprintf(`SELECT *  FROM bigmember_service_user WHERE s_userid = '%s' and i_status =0 and (s_serviceid=4 or s_serviceid =19)`, userId))
							isHUa := count > 0
							for _, v := range userServer.List() {
								if isHUa && v["s_serviceid"] == 26 {
									continue
								}
								if common.IntAll(v["s_smainid"]) == 0 {
									if common.IntAll(v["s_serviceid"]) == 12 {
										serviceList = append(serviceList, 23)
									} else {
										serviceList = append(serviceList, common.IntAll(v["s_serviceid"]))
									}

								} else {
									if common.IntAll(v["s_smainid"]) == 12 {
										serviceList = append(serviceList, 23)
									} else {
										serviceList = append(serviceList, common.IntAll(v["s_smainid"]))
									}
								}
							}
						}
						if vipExist {
							paySubNum = common.IntAll((*userData)["i_pay_sub_num"]) + common.IntAll((*userData)["i_free_sub_num"]) + 1
						}
						serviceArrMap = append(serviceArrMap, map[string]interface{}{
							"vipExist":         vipExist,          //当前服务是否在有限期内
							"name":             param.ProductType, //产品名称
							"serviceEndTime":   endTime,           //服务结束时间
							"serviceStartTime": startTime,         //服务开始时间
							"empowerCount":     paySubNum,         //服务授权数
							"provinceCount":    areaCount,         //订阅省份
							"buySubject":       1,                 //个体
							"comboId":          comboId,           //套餐id
							"serviceList":      serviceList,       //大会员服务id
							"linkedId":         linkedId,          //关联id
							"linkedOrder":      orderArr,          //关联订单
						})
					}
				}

			}
		} else { //企业版本会员状态查询
			if param.EntName == "" {
				return nil, errors.New("企业名称获取异常")
			}
			//获取企业信息
			if param.ProductType == "大会员" {
				vipRes1, _ := g.DB().Ctx(ctx).GetOne(ctx, fmt.Sprintf("SELECT ewe.* ,bc.id AS comoboId FROM entniche_info ei INNER JOIN entniche_wait_empower ewe ON ei.id = ewe.ent_id  LEFT JOIN bigmember_combo bc ON REPLACE(ewe.product_type,\"大会员\",\"\") = bc.s_name WHERE ei.NAME = '%s'  AND phone = '%s' ORDER BY ewe.create_time DESC LIMIT 1", param.EntName, param.Phone))
				if !vipRes1.IsEmpty() {
					start := common.ObjToString(vipRes1.Map()["start_time"])
					end := common.ObjToString(vipRes1.Map()["end_time"])
					starts, _ := time.ParseInLocation(date.Date_Full_Layout, start, time.Local)
					ends, _ := time.ParseInLocation(date.Date_Full_Layout, end, time.Local)
					bigStart := starts.Unix()
					bigEnd := ends.Unix()
					nowTime := time.Now().Unix()
					if nowTime < bigEnd && nowTime < bigStart {
						return map[string]interface{}{
							"willEffect":    true,
							"userData":      userData,
							"serviceArrMap": nil,
						}, nil
					}
				}
			}

			vipRes, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT a.id,b.id as entUserId FROM entniche_info a
inner JOIN entniche_user b on a.id = b.ent_id
WHERE b.phone = '%s' and a.name = '%s'`, param.Phone, param.EntName))
			if !vipRes.IsEmpty() {
				if param.ProductType != "大会员" && param.ProductType != "VIP订阅" {
					serviceArrMap = SpecialService(ctx, gconv.String(vipRes.Map()["entUserId"]), param.ProductType)
				} else {

					entID := gconv.String(vipRes.Map()["id"])
					var whereEntTime string
					if param.ServiceType != 1 && param.ServiceType != 4 {
						whereEntTime = fmt.Sprintf(` and a.end_time>'%s' `, time.Now().Format("2006-01-02 15:04:05"))
					}
					//获取企业下的服务
					entService, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT * FROM entniche_wait_empower a 
WHERE a.ent_id = '%s'  %s and a.product_type like '%s' and  ORDER BY a.end_time desc`, entID, whereEntTime, common.If(param.ProductType == "VIP订阅", "%VIP订阅%", `%大会员%`)))
					if !entService.IsEmpty() {
						for _, m := range entService.List() {
							var (
								serviceList []int
								comboId     int
							)
							if param.ProductType == "大会员" {
								//大会员获取下服务最新id
								serviceId, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT  b.filter FROM entniche_order a 
	INNER JOIN  jy_order_detail b on a.order_detail_id = b.id WHERE a.wait_empower_id = %d ORDER BY a.create_time desc LIMIT 1`, gconv.Int(m["id"])))
								if !serviceId.IsEmpty() {
									comboId = gconv.Int(gconv.Map(serviceId.Map()["filter"])["comboId"])
									for _, id := range gconv.Ints(gconv.Map(serviceId.Map()["filter"])["serviceIds"]) {
										if id == 12 {
											serviceList = append(serviceList, 23)
										} else if id == 19 {
											serviceList = append(serviceList, 4)
										} else {
											serviceList = append(serviceList, id)
										}
									}
								}
							}
							vipExist = jyutil.StrToTime(gconv.String(m["end_time"])).Unix() > time.Now().Unix()
							var (
								orderArr []map[string]interface{}
								linkedId int
							)
							//获取订单
							entOrderService, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT  b.id,b.service_type,b.order_code,c.create_time FROM entniche_order a 
	INNER JOIN  jy_order_detail b on a.order_detail_id = b.id
	LEFT JOIN dataexport_order c on b.order_code = c.order_code WHERE a.wait_empower_id = %d order by b.id desc`, gconv.Int(m["id"])))
							if !entOrderService.IsEmpty() {
								for _, m2 := range entOrderService.List() {
									if linkedId == 0 {
										linkedId = gconv.Int(m2["id"])
									}
									orderArr = append(orderArr, map[string]interface{}{
										"order_code":      m2["order_code"],
										"create_time":     m2["create_time"],
										"service_type":    m2["service_type"],
										"order_detail_id": m2["id"],
									})
								}
							}
							serviceArrMap = append(serviceArrMap, map[string]interface{}{
								"name":             gconv.String(m["product_type"]),   //产品名称
								"vipExist":         vipExist,                          //当前服务是否在有限期内
								"serviceEndTime":   gconv.String(m["end_time"]),       //服务结束时间
								"serviceStartTime": gconv.String(m["start_time"]),     //服务开始时间
								"empowerCount":     gconv.String(m["empower_count"]),  //服务授权数
								"provinceCount":    gconv.String(m["province_count"]), //订阅省份
								"buySubject":       2,                                 //个体
								"linkedId":         linkedId,                          //关联id
								"comboId":          comboId,                           //套餐id
								"serviceList":      serviceList,                       //大会员服务id
								"linkedOrder":      orderArr,                          //关联订单
							})
						}
					}
				}
			}
		}
	}

	return map[string]interface{}{
		"willEffect":    false,
		"userData":      userData,
		"serviceArrMap": serviceArrMap,
	}, nil
}

func SpecialService(ctx context.Context, userId, productType string) []map[string]interface{} {
	var (
		linkedId           int
		orderArr           []map[string]interface{}
		vipExist           bool
		endTime, startTime string
	)
	//serviceArrMap = append(serviceArrMap, map[string]interface{}{
	//							"name":             gconv.String(m["product_type"]),   //产品名称
	//							"vipExist":         vipExist,                          //当前服务是否在有限期内
	//							"serviceEndTime":   gconv.String(m["end_time"]),       //服务结束时间
	//							"serviceStartTime": gconv.String(m["start_time"]),     //服务开始时间
	//							"empowerCount":     gconv.String(m["empower_count"]),  //服务授权数
	//							"provinceCount":    gconv.String(m["province_count"]), //订阅省份
	//							"buySubject":       2,                                 //个体
	//							"linkedId":         linkedId,                          //关联id
	//							"comboId":          comboId,                           //套餐id
	//							"serviceList":      serviceList,                       //大会员服务id
	//							"linkedOrder":      orderArr,                          //关联订单
	//						})

	orderData, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT jod.service_endtime,jod.id,jod.service_starttime,jod.service_type,jod.order_code,dor.create_time FROM dataexport_order dor 
INNER JOIN jy_order_detail jod on dor.order_code = jod.order_code 
WHERE dor.user_id = '%s' and jod.product_type = '%s'  ORDER BY dor.create_time desc `, userId, productType))
	if !orderData.IsEmpty() {
		for _, m2 := range orderData.List() {
			if linkedId == 0 {
				linkedId = gconv.Int(m2["id"])
			}
			if gconv.String(m2["service_endtime"]) > time.Now().String() {
				vipExist = true
			}
			if gconv.String(m2["service_starttime"]) > endTime {
				endTime = gconv.String(m2["service_starttime"])
			}
			if gconv.String(m2["service_starttime"]) < startTime {
				startTime = gconv.String(m2["service_starttime"])
			}
			orderArr = append(orderArr, map[string]interface{}{
				"order_code":      m2["order_code"],
				"create_time":     m2["create_time"],
				"service_type":    m2["service_type"],
				"order_detail_id": m2["id"],
			})
		}
		return []map[string]interface{}{{
			"name":             fmt.Sprintf("%s标准版", productType),              //产品名称
			"vipExist":         vipExist,                                       //当前服务是否在有限期内
			"serviceEndTime":   common.If(endTime != "", endTime, "-"),         //服务结束时间
			"serviceStartTime": startTime,                                      //服务开始时间
			"buySubject":       common.If(mongodb.IsObjectIdHex(userId), 1, 2), //个体
			"empowerCount":     common.If(productType == "数据流量包", "1", "-"),    //B.产品属性为“资源包”，则为“1”； C.产品属性非“会员服务”且非“资源包”，则展示-
			"linkedId":         linkedId,                                       //关联id
			"linkedOrder":      orderArr,                                       //关联订单
		}}
	}
	return nil
}