resourceCenter/test/openPower.go

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"time"

	. "app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/date"
	"app.yhyue.com/moapp/jybase/mongodb"
	ml "app.yhyue.com/moapp/jybase/mysql"
	"bp.jydev.jianyu360.cn/BaseService/resourceCenter/rpc/pb"
	"bp.jydev.jianyu360.cn/BaseService/resourceCenter/rpc/resource"
	upb "bp.jydev.jianyu360.cn/BaseService/userCenter/rpc/pb"
	"bp.jydev.jianyu360.cn/BaseService/userCenter/rpc/usercenter"
	"github.com/zeromicro/go-zero/core/discov"
	"github.com/zeromicro/go-zero/zrpc"
)

const (
	appid = "10000"
)

var (
	etcdAddress []string
	BaseService *ml.Mysql
	Mgo         *mongodb.MongodbSim
	JyOrder     *ml.Mysql
	goodsCode   string
	goodsSpecId int64
	all         map[string]string
	powerType   string
)

func main() {
	phone := flag.String("p", "", "手机号")
	m := flag.Int("m", 0, "1：查询权益 2：开通权益 3：取消权益")
	t := flag.String("t", "", "yxy：医械云 bi_yllyh：医疗领域化BI bi_ldx：立达信BI分析工具")
	isProduct := flag.Int("d", 0, "是否是线上环境；0：否 1：是")
	dayCount := flag.Int("c", 0, "自定义设置需要开通权益的天数，包含今天")
	flag.Parse()
	if *phone == "" {
		log.Fatalln("-p 参数无效")
	}
	var entity Entity
	if *t == "yxy" {
		entity = &Yxy{}
	} else if *t == "bi_yllyh" {
		entity = &Bi_yllyh{}
	} else if *t == "bi_ldx" {
		goodsCode = "special_nosale_goods"
		entity = &Bi_ldx{}
	} else {
		log.Fatalln("-t 参数无效")
	}
	powerType, goodsCode, goodsSpecId, all = entity.init()
	if *isProduct == 1 {
		etcdAddress = []string{"172.17.4.182:2379", "172.17.4.183:2379", "172.17.148.49:2379"}
		BaseService = &ml.Mysql{
			Address:      "172.17.145.164:14000",
			UserName:     "root",
			PassWord:     "Tibi#20211222",
			DBName:       "base_service",
			MaxOpenConns: 2,
			MaxIdleConns: 2,
		}
		Mgo = &mongodb.MongodbSim{
			MongodbAddr: "172.17.4.193:27080,172.17.4.83:27080",
			Size:        1,
			DbName:      "qfw",
			ReplSet:     "",
			UserName:    "",
			Password:    "",
		}
		JyOrder = &ml.Mysql{
			Address:      "172.17.145.169:3306",
			UserName:     "root",
			PassWord:     "TopMysql@123",
			DBName:       "jianyu",
			MaxOpenConns: 2,
			MaxIdleConns: 2,
		}
	} else {
		etcdAddress = []string{"127.0.0.1:2379"}
		BaseService = &ml.Mysql{
			Address:      "192.168.3.14:4000",
			UserName:     "root",
			PassWord:     "=PDT49#80Z!RVv52_z",
			DBName:       "base_service",
			MaxOpenConns: 2,
			MaxIdleConns: 2,
		}
		Mgo = &mongodb.MongodbSim{
			MongodbAddr: "192.168.3.206:27080",
			Size:        1,
			DbName:      "qfw",
			ReplSet:     "",
			UserName:    "",
			Password:    "",
		}
		JyOrder = &ml.Mysql{
			Address:      "192.168.3.11:3366",
			UserName:     "root",
			PassWord:     "Topnet123",
			DBName:       "jianyu",
			MaxOpenConns: 2,
			MaxIdleConns: 2,
		}
	}
	BaseService.Init()
	JyOrder.Init()
	Mgo.InitPool()
	ur := BaseService.SelectBySql(`select id from base_user where phone=?`, *phone)
	if ur == nil || len(*ur) <= 0 {
		log.Fatalln("没有找到该用户！")
	}
	for _, v := range *ur {
		id := Int64All(v["id"])
		msg := "用户：" + fmt.Sprint(id) + " 手机号：" + *phone
		u, ok := Mgo.FindOneByField("user", map[string]interface{}{"base_user_id": id}, `{"_id":1,"l_vip_endtime":1,"i_member_endtime":1,"s_member_mainid":1,"i_member_sub_status":1}`)
		if !ok || u == nil || len(*u) == 0 {
			log.Println(msg, "mongodb user 中没有找到该用户！")
			continue
		}
		var c = resource.NewResource(zrpc.MustNewClient(zrpc.RpcClientConf{
			Etcd: discov.EtcdConf{
				Hosts: etcdAddress,
				Key:   "resource.rpc",
			},
		}))
		if *m == 1 {
			r, err := c.Haspowers(context.Background(), &pb.HaspowersReq{
				Appid:     "10000",
				EntId:     0,
				EntUserId: 0,
				UserId:    id,
			})
			if err != nil {
				log.Println(msg, "查询", powerType, "权益失败！", err)
			} else {
				mp := map[string]bool{}
				for _, v := range r.Powers {
					mp[v] = true
				}
				flag := true
				for k, v := range all {
					if !mp[v] {
						log.Println(msg, powerType, "权益异常，缺少权益：", k)
						flag = false
						continue
					}
				}
				if flag {
					for k, _ := range all {
						log.Println(msg, "拥有", powerType, "权益：", k)
					}
				}
			}
		} else if *m == 2 {
			if !entity.beforeOpen(phone, u) {
				return
			}
			endTime := ""
			if *dayCount > 0 {
				now := time.Now()
				end_time := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, time.Local)
				end_time = end_time.AddDate(0, 0, *dayCount-1)
				endTime = date.FormatDate(&end_time, date.Date_Full_Layout)
			}
			r, err := c.PowerHandle(context.Background(), &pb.PowerReq{
				Appid:       appid,
				GoodsCode:   goodsCode,
				GoodsSpecId: goodsSpecId,
				EntId:       0,
				UserId:      id,
				BuyNum:      1,
				Type:        1,
				EndTime:     endTime,
			})
			if err != nil {
				log.Println(msg, powerType, "开通失败！", err)
			} else if r.Status == 1 {
				entity.afterOpen(phone, u)
				log.Println(msg, powerType, "已开通！")
			} else {
				log.Println(msg, powerType, "开通失败！")
			}
		} else if *m == 3 {
			r, err := c.PowerHandle(context.Background(), &pb.PowerReq{
				Appid:       appid,
				GoodsCode:   goodsCode,
				GoodsSpecId: goodsSpecId,
				EntId:       0,
				UserId:      id,
				BuyNum:      1,
				Type:        -1,
			})
			if err != nil {
				log.Println(msg, powerType, "取消失败！", err)
			} else if r.Status == 1 {
				log.Println(msg, powerType, "已取消！")
			} else {
				log.Println(msg, powerType, "取消失败！")
			}
		} else {
			log.Fatalln("-m 参数无效")
		}
		if *m == 2 || *m == 3 {
			var cc = usercenter.NewUserCenter(zrpc.MustNewClient(zrpc.RpcClientConf{
				Etcd: discov.EtcdConf{
					Hosts: etcdAddress,
					Key:   "usercenter.rpc",
				},
			}))
			userId := mongodb.BsonIdToSId((*u)["_id"])
			resp, err := cc.WorkDesktopClearUserInfo(context.Background(), &upb.WorkDesktopClearUserInfoReq{
				UserId:    userId,
				AppId:     appid,
				Platform:  "PC",
				UserIds:   userId,
				NewUserId: fmt.Sprint(id),
			})
			if err != nil {
				log.Println("清除用户工作桌面缓存失败", err)
			} else if resp.ErrorCode != 0 {
				log.Println("清除用户工作桌面缓存失败", resp.ErrorMsg)
			}
		}
	}
}

type Entity interface {
	init() (string, string, int64, map[string]string)
	beforeOpen(phone *string, u *map[string]interface{}) bool
	afterOpen(phone *string, u *map[string]interface{})
}

/******************************医疗领域化BI******************************************/
type Bi_yllyh struct {
}

//
func (b *Bi_yllyh) init() (string, string, int64, map[string]string) {
	return "医疗领域化BI", "special_nosale_goods", 14, map[string]string{"医疗领域化BI": "bi_yllyh"}
}

//
func (b *Bi_yllyh) beforeOpen(phone *string, u *map[string]interface{}) bool {
	return true
}

//
func (b *Bi_yllyh) afterOpen(phone *string, u *map[string]interface{}) {
}

/******************************立达信BI分析工具******************************************/
type Bi_ldx struct {
}

//
func (b *Bi_ldx) init() (string, string, int64, map[string]string) {
	return "立达信BI分析工具", "special_nosale_goods", 15, map[string]string{"立达信BI分析工具": "bi_ldx"}
}

//
func (b *Bi_ldx) beforeOpen(phone *string, u *map[string]interface{}) bool {
	return true
}

//
func (b *Bi_ldx) afterOpen(phone *string, u *map[string]interface{}) {
}

/******************************医械云******************************************/
type Yxy struct {
}

//
func (y *Yxy) init() (string, string, int64, map[string]string) {
	return "医械云权益", "lyh", 13, map[string]string{
		"医疗标讯搜索": "lyh_yl_ylbxss",
		"医疗机构搜索": "lyh_yl_yljgss",
		"经销商搜索":  "lyh_yl_jxsss",
		"医疗机构画像": "lyh_yl_yljghx",
		"医疗机构认领": "lyh_yl_yljgrl",
		"经销商认领":  "lyh_yl_jxsrl",
		"医疗订阅":   "lyh_yl_yldy",
	}
}

//
func (y *Yxy) beforeOpen(phone *string, u *map[string]interface{}) bool {
	ok, _, _, _ := y.isOK(*phone, *u)
	return ok
}

//
func (y *Yxy) afterOpen(phone *string, u *map[string]interface{}) {
	ok, orderVip, vipRs, bigRs := y.isOK(*phone, *u)
	if ok {
		y.createYxtOrder(*phone, *u, orderVip, vipRs, bigRs)
	}
}
func (y *Yxy) isOK(phone string, user map[string]interface{}) (bool, bool, *[]map[string]interface{}, *[]map[string]interface{}) {
	orderVip := true // 是否根据超级订阅订单处理 如果是大会员也是超级订阅则按大会员处理
	flag1 := false
	flag2 := false
	mainPhone := phone
	if IntAllDef(user["i_member_sub_status"], -1) == 1 {
		mainUser, ok := Mgo.FindById("user", ObjToString(user["s_member_mainid"]), `{"s_phone"1:,"s_m_phone":1}`)
		if ok && mainUser != nil {
			mainPhone = ObjToString((*mainUser)["s_phone"])
			if mainPhone == "" {
				mainPhone = ObjToString((*mainUser)["s_m_phone"])
			}
			if mainPhone == "" {
				log.Println("该用户是子账号，没有找到其主账号的手机号")
				return false, false, nil, nil
			}
		} else {
			log.Println("该用户是子账号，没有找到其主账号的信息")
			return false, false, nil, nil
		}
	}
	bigMemberRs := JyOrder.SelectBySql(`select * from dataexport_order where user_phone=? and order_status=1 and product_type ="大会员" and (timestampdiff(day,vip_starttime,vip_endtime)>=365) order by create_time desc limit 1`, mainPhone)
	if bigMemberRs != nil && len(*bigMemberRs) == 1 {
		(*bigMemberRs)[0]["user_phone"] = phone
		(*bigMemberRs)[0]["user_id"] = mongodb.BsonIdToSId(user["_id"])
	}
	vipRs := JyOrder.SelectBySql(`select * from dataexport_order where user_phone=? and order_status=1 and product_type ="VIP订阅" and (timestampdiff(day,vip_starttime,vip_endtime)>=365) order by create_time desc limit 1`, phone)
	if (bigMemberRs == nil || len(*bigMemberRs) == 0) && (vipRs == nil || len(*vipRs) == 0) {
		log.Println("没有查询到该用户的年度超级订阅或者大会员订单")
		return false, false, nil, nil
	}
	// 同时存在超级订阅和大会员年度订单  不再判断最晚到期时间 大会员优先
	if vipRs != nil && len(*vipRs) == 1 {
		vipEndTime := Int64All(user["l_vip_endtime"])
		leftdayvip := time.Unix(vipEndTime, 0).Sub(time.Now()).Hours() / 24
		if leftdayvip >= 90 {
			orderVip = true
			flag1 = true
		}
	}
	if *bigMemberRs != nil && len(*bigMemberRs) == 1 {
		// 判断最晚到期时间
		bigMemberEndTime := IntAll(user["i_member_endtime"])
		leftdaybig := time.Unix(int64(bigMemberEndTime), 0).Sub(time.Now()).Hours() / 24
		if leftdaybig >= 90 {
			orderVip = false
			flag2 = true
		}
	}
	if !flag1 && !flag2 {
		log.Println("该用户剩余不符合条件")
		return false, false, nil, nil
	}
	return true, orderVip, vipRs, bigMemberRs

}

// 生成医械通订单
func (y *Yxy) createYxtOrder(phone string, user map[string]interface{}, orderVip bool, vipRs, bigMemberRs *[]map[string]interface{}) {
	var insertOrder map[string]interface{}
	// 超级订阅
	if orderVip {
		insertOrder = (*vipRs)[0]
		// 生订单信息
		orderMoney := Float64All(insertOrder["order_money"])
		endTime := Int64All(user["l_vip_endtime"])
		var money int
		if IntAll(insertOrder["is_backstage_order"]) == 1 {
			filterData := (*vipRs)[0]["filter"]
			filterMap := map[string]interface{}{}
			err := json.Unmarshal([]byte(filterData.(string)), &filterMap)
			if err != nil {
				log.Println("反序列化失败", err)
				return
			}
			cycle := Float64All(filterMap["cyclecount"])
			cycleUnit := Float64All(filterMap["cycleunit"])
			money = y.getPriceBack(orderMoney, time.Unix(endTime, 0), cycle, cycleUnit)
		} else {
			money = y.getPrice(orderMoney, time.Unix(endTime, 0))
		}
		insertOrder["order_money"] = money
		insertOrder["original_price"] = money
		insertOrder["vip_endtime"] = time.Unix(endTime, 0).Format(date.Date_Full_Layout)
	} else {
		// 大会员
		endTime := Int64All(user["i_member_endtime"])
		filterData := (*bigMemberRs)[0]["filter"]
		filterMap := map[string]interface{}{}
		err := json.Unmarshal([]byte(filterData.(string)), &filterMap)
		if err != nil {
			log.Println("反序列化失败", err)
			return
		}
		filterMap["area"] = "-"
		insertOrder = (*bigMemberRs)[0]
		filter, _ := json.Marshal(filterMap)
		insertOrder["filter"] = string(filter)
		insertOrder["order_money"] = 0
		insertOrder["original_price"] = 0
		insertOrder["vip_endtime"] = time.Unix(endTime, 0).Format(date.Date_Full_Layout)
	}
	// 生订单信息
	insertOrder["product_type"] = "医械通"
	insertOrder["order_code"] = fmt.Sprintf("%s%s", time.Now().Format("150405"), GetRandom(6))
	insertOrder["prepay_id"] = ""
	insertOrder["pay_money"] = 0
	insertOrder["discount_price"] = 0
	insertOrder["pay_way"] = ""
	insertOrder["out_trade_no"] = ""
	insertOrder["create_time"] = date.NowFormat(date.Date_Full_Layout)
	insertOrder["vip_starttime"] = date.NowFormat(date.Date_Full_Layout)
	insertOrder["pay_time"] = insertOrder["vip_starttime"]
	insertOrder["prepay_time"] = insertOrder["vip_starttime"]
	delete(insertOrder, "id")
	saveRs := JyOrder.Insert("dataexport_order", insertOrder)
	if saveRs > 0 {
		log.Println("医械通订单保存成功")
	} else {
		log.Println("医械通订单保存失败", saveRs)
	}
}

// 计算价格 线上的
func (y *Yxy) getPrice(orderMoney float64, endTime time.Time) int {
	// 计算价格
	dis := endTime.Sub(time.Now())
	days := dis.Hours() / 24 // 剩余天数
	money := int(orderMoney / 360 * float64(int(days)))
	return money
}

// 计算价格 管理后台创建的
func (y *Yxy) getPriceBack(orderMoney float64, endTime time.Time, cycle, cycleUnit float64) int {
	//(1:年 2:月 3:天 4:季)
	// 计算价格
	unitPrice := 0.0
	switch cycleUnit {
	case 1:
		unitPrice = orderMoney / cycle / 360
	case 2:
		unitPrice = orderMoney / cycle / 30
	case 3:
		unitPrice = orderMoney / cycle
	case 4:
		unitPrice = orderMoney / cycle / 90
	}
	dis := endTime.Sub(time.Now())
	days := dis.Hours() / 24 // 剩余天数
	//log.Println("=========", int(days), "=================")
	money := unitPrice * float64(int(days))
	return int(money)
}