resourceCenter/openPower/openPower.go

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"strings"
	"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"
	. "app.yhyue.com/moapp/jypkg/middleground"
	"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"
)

const (
	appid = "10000"
)

var (
	etcdAddress  []string
	BaseService  *ml.Mysql
	Mgo          *mongodb.MongodbSim
	MysqlMain    *ml.Mysql
	goodsCode    string
	goodsSpecId  int64
	all          map[string]string
	powerType    string
	middleground *Middleground
	allEntity    = map[string]Entity{
		"yxy": &Yxy{},
	}
	c *Config
)

type Config struct {
	EtcdAddr []string
	Mongodb  struct {
		Main *mgoConf
	}
	Mysql struct {
		Main *mysqlConf
		Base *mysqlConf
	}
	Products []int64
}

type mgoConf struct {
	Address    string
	Size       int
	DbName     string
	ReplSet    string
	UserName   string
	Password   string
	Collection string
}
type mysqlConf struct {
	DbName       string
	Address      string
	UserName     string
	PassWord     string
	MaxOpenConns int
	MaxIdleConns int
}

func init() {
	ReadConfig(&c)
}

func main() {
	MysqlMain = &ml.Mysql{
		Address:      c.Mysql.Main.Address,
		UserName:     c.Mysql.Main.UserName,
		PassWord:     c.Mysql.Main.PassWord,
		DBName:       c.Mysql.Main.DbName,
		MaxOpenConns: c.Mysql.Main.MaxOpenConns,
		MaxIdleConns: c.Mysql.Main.MaxIdleConns,
	}
	filterSpec := map[int64]bool{}
	for _, v := range c.Products {
		filterSpec[v] = true
	}
	MysqlMain.Init()
	allEntity := map[int64]*Common{}
	allT := ""
	for _, v := range *MysqlMain.SelectBySql(`select a.id,c.code,c.name,a.goods_code,a.name as spec_name from base_service.base_goods_spec a
		inner join base_service.base_goods_spec_power b on (a.id=b.spec_id)
		inner join base_service.base_function c on (b.function_code=c.code) order by a.id`) {
		id := Int64All(v["id"])
		if !filterSpec[id] {
			continue
		}
		name, _ := v["name"].(string)
		code, _ := v["code"].(string)
		if allEntity[id] == nil {
			spec_name, _ := v["spec_name"].(string)
			spec_name = strings.TrimPrefix(spec_name, "特殊非售卖商品_")
			if allT != "" {
				allT += " "
			}
			allT += fmt.Sprintf("%d：%s", id, spec_name)
			goods_code, _ := v["goods_code"].(string)
			allEntity[id] = &Common{
				Name:        spec_name,
				GoodsCode:   goods_code,
				GoodsSpecId: id,
				All:         map[string]string{name: code},
			}
		} else {
			allEntity[id].All[name] = code
		}
	}
	phone := flag.String("p", "", "手机号")
	m := flag.Int("m", 0, "1：查询权益 2：开通权益 3：取消权益")
	t := flag.Int64("t", 0, allT)
	dayCount := flag.Int("c", 0, "自定义设置需要开通权益的天数，包含今天")
	entName := flag.String("n", "", "企业名称")
	isCheck := flag.Int("b", 1, "是否前置校验和后置处理")
	powerWay := flag.Int("a", 0, "权益开通/取消方式；0：一个身份 1：全部身份 2：仅仅企业上")
	flag.Parse()
	if *phone == "" {
		log.Fatalln("-p 参数无效")
	}
	entity := allEntity[*t]
	if entity == nil {
		log.Fatalln("-t 参数无效")
	}
	powerType, goodsCode, goodsSpecId, all = entity.init()
	middleground = NewMiddleground(c.EtcdAddr)
	middleground.RegResourceCenter("resource.rpc").RegUserCenter("usercenter.rpc")
	//
	Mgo = &mongodb.MongodbSim{
		MongodbAddr: c.Mongodb.Main.Address,
		Size:        c.Mongodb.Main.Size,
		DbName:      c.Mongodb.Main.DbName,
		ReplSet:     c.Mongodb.Main.ReplSet,
		UserName:    c.Mongodb.Main.UserName,
		Password:    c.Mongodb.Main.Password,
	}
	Mgo.InitPool()
	//
	ur, _ := Mgo.Find("user", map[string]interface{}{
		"$or": []map[string]interface{}{
			map[string]interface{}{
				"s_phone": *phone,
			},
			map[string]interface{}{
				"s_m_phone": *phone,
			},
		},
		"i_appid": 2,
	}, nil, `{"base_user_id":1}`, false, -1, -1)
	if ur == nil || len(*ur) <= 0 {
		log.Fatalln("没有找到该用户！")
	}
	for _, v := range *ur {
		id := Int64All(v["base_user_id"])
		for _, identity := range middleground.UserCenter.IdentityList(id) {
			if *powerWay == 0 {
				if *entName == "" && identity.PositionType == 1 {
					continue
				} else if *entName != "" && (identity.PositionType == 0 || *entName != identity.Name) {
					continue
				}
			} else if *powerWay == 2 {
				if *entName == "" {
					continue
				} else if identity.PositionType == 0 || *entName != identity.Name {
					continue
				}
			}
			msg := "身份信息：" + fmt.Sprintf("%+v", identity) + " 手机号：" + *phone
			var resClient = resource.NewResource(middleground.ResourceCenter.NewClient())
			if *m == 1 {
				r, err := resClient.Haspowers(context.Background(), &pb.HaspowersReq{
					Appid:        "10000",
					EntId:        identity.EntId,
					EntUserId:    identity.EntUserId,
					AccountId:    identity.AccountId,
					EntAccountId: identity.EntAccountId,
				})
				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 *isCheck == 1 && !entity.beforeOpen(phone, identity) {
					return
				}
				for _, v := range all {
					wed, err := resClient.WaitEmpowerDetail(context.Background(), &pb.WaitEmpowerDetailReq{
						Appid:        "10000",
						EntId:        identity.EntId,
						FunctionCode: v,
					})
					if err != nil {
						log.Println(msg, powerType, "开通失败！", err)
					} else if wed.Id == 0 {
						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)
						}
						powerReq := &pb.PowerReq{
							Appid:       appid,
							GoodsCode:   goodsCode,
							GoodsSpecId: goodsSpecId,
							BuyNum:      0,
							Type:        1,
							EndTime:     endTime,
						}
						if *powerWay == 2 {
							powerReq.EntAccountId = identity.EntAccountId
							powerReq.EntId = identity.EntId
						} else {
							powerReq.AccountId = identity.AccountId
						}
						r, err := resClient.PowerHandle(context.Background(), powerReq)
						if err != nil {
							log.Println(msg, powerType, "开通失败！", err)
						} else if r.Status == 1 {
							if *isCheck == 1 {
								entity.afterOpen(phone, identity)
							}
							log.Println(msg, powerType, "已开通！")
						} else {
							log.Println(msg, powerType, "开通失败！")
						}
					}
					resClient.Empower(context.Background(), &pb.EmpowerReq{
						Appid:        "10000",
						FunctionCode: v,
						EntId:        identity.EntId,
						EntUserId:    []int64{identity.EntUserId},
					})
				}
			} else if *m == 3 {
				powerReq := &pb.PowerReq{
					Appid:       appid,
					GoodsCode:   goodsCode,
					GoodsSpecId: goodsSpecId,
					BuyNum:      1,
					Type:        -1,
				}
				if *powerWay == 2 {
					powerReq.EntAccountId = identity.EntAccountId
					powerReq.EntId = identity.EntId
				} else {
					powerReq.AccountId = identity.AccountId
					powerReq.EntAccountId = identity.EntAccountId
					powerReq.EntId = identity.EntId
				}
				r, err := resClient.PowerHandle(context.Background(), powerReq)
				if err != nil {
					log.Println(msg, powerType, "取消失败！", err)
				} else if r.Status == 1 {
					log.Println(msg, powerType, "已取消！")
				} else {
					log.Println(msg, powerType, "取消失败！", r.Status)
				}
			} else {
				log.Fatalln("-m 参数无效")
			}
			if *m == 2 || *m == 3 {
				_, err := usercenter.NewUserCenter(middleground.UserCenter.NewClient()).WorkDesktopClearUserInfo(context.Background(), &upb.WorkDesktopClearUserInfoReq{
					PositionId: fmt.Sprint(identity.PositionId),
					AppId:      appid,
				})
				if err != nil {
					log.Println("清除用户工作桌面缓存失败", err)
				}
			}
		}
	}
}

type Entity interface {
	init() (string, string, int64, map[string]string)
	beforeOpen(phone *string, identity *upb.Identity) bool
	afterOpen(phone *string, identity *upb.Identity)
}

type Common struct {
	Name        string
	GoodsCode   string
	GoodsSpecId int64
	All         map[string]string
}

//
func (c *Common) init() (string, string, int64, map[string]string) {
	return c.Name, c.GoodsCode, c.GoodsSpecId, c.All
}

//
func (c *Common) beforeOpen(phone *string, identity *upb.Identity) bool {
	return true
}

//
func (c *Common) afterOpen(phone *string, identity *upb.Identity) {
}

/******************************医械云******************************************/
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, identity *upb.Identity) bool {
	order_user_id, u := y.getUser(identity)
	if u == nil {
		return false
	}
	ok, _, _, _ := y.isOK(*phone, *u, order_user_id)
	return ok
}

//
func (y *Yxy) getUser(identity *upb.Identity) (string, *map[string]interface{}) {
	if identity.PositionType == 0 {
		u, _ := Mgo.FindOneByField("user", map[string]interface{}{"base_user_id": identity.UserId}, `{"_id":1,"l_vip_endtime":1,"i_member_endtime":1,"s_member_mainid":1,"i_member_sub_status":1}`)
		if u == nil || len(*u) == 0 {
			log.Println(fmt.Sprintf("%+v", identity), "mongodb user 中没有找到该用户！")
			return "", nil
		}
		return mongodb.BsonIdToSId((*u)["_id"]), u
	} else {
		u, _ := Mgo.FindOneByField("ent_user", map[string]interface{}{"i_userid": identity.EntUserId}, `{"_id":1,"l_vip_endtime":1,"i_member_endtime":1,"s_member_mainid":1,"i_member_sub_status":1}`)
		if u == nil || len(*u) == 0 {
			log.Println(fmt.Sprintf("%+v", identity), "mongodb ent_user 中没有找到该用户！")
			return "", nil
		}
		return fmt.Sprint(identity.PositionId), u
	}
}

//
func (y *Yxy) afterOpen(phone *string, identity *upb.Identity) {
	order_user_id, u := y.getUser(identity)
	if u == nil {
		return
	}
	ok, orderVip, vipRs, bigRs := y.isOK(*phone, *u, order_user_id)
	if ok {
		y.createYxtOrder(*phone, *u, orderVip, vipRs, bigRs)
	}
}
func (y *Yxy) isOK(phone string, user map[string]interface{}, order_user_id string) (bool, bool, *[]map[string]interface{}, *[]map[string]interface{}) {
	orderVip := true // 是否根据超级订阅订单处理 如果是大会员也是超级订阅则按大会员处理
	flag1 := false
	flag2 := false
	mainUserId := order_user_id
	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 {
			mainUserId = mongodb.BsonIdToSId((*mainUser)["_id"])
		} else {
			log.Println("该用户是子账号，没有找到其主账号的信息")
			return false, false, nil, nil
		}
	}
	bigMemberRs := MysqlMain.SelectBySql(`select * from dataexport_order where user_id=? and order_status=1 and product_type ="大会员" and (timestampdiff(day,vip_starttime,vip_endtime)>=365) order by create_time desc limit 1`, mainUserId)
	if bigMemberRs != nil && len(*bigMemberRs) == 1 {
		(*bigMemberRs)[0]["user_phone"] = phone
		(*bigMemberRs)[0]["user_id"] = order_user_id
	}
	vipRs := MysqlMain.SelectBySql(`select * from dataexport_order where user_id=? and order_status=1 and product_type ="VIP订阅" and (timestampdiff(day,vip_starttime,vip_endtime)>=365) order by create_time desc limit 1`, order_user_id)
	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{}
	filterMap := map[string]interface{}{}
	// 超级订阅
	if orderVip {
		insertOrder = (*vipRs)[0]
		// 生订单信息
		orderMoney := Float64All(insertOrder["order_money"])
		endTime := Int64All(user["l_vip_endtime"])
		var money int
		filterData := (*vipRs)[0]["filter"]
		err := json.Unmarshal([]byte(filterData.(string)), &filterMap)
		if err != nil {
			log.Println("反序列化失败", err)
			return
		}
		if IntAll(insertOrder["is_backstage_order"]) == 1 {
			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"]
		err := json.Unmarshal([]byte(filterData.(string)), &filterMap)
		if err != nil {
			log.Println("反序列化失败", err)
			return
		}
		filterMap["area"] = "-"
		insertOrder = (*bigMemberRs)[0]
		insertOrder["order_money"] = 0
		insertOrder["original_price"] = 0
		insertOrder["vip_endtime"] = time.Unix(endTime, 0).Format(date.Date_Full_Layout)
	}
	filterMap["source"] = "qmx" // 后台订单
	// 生订单信息
	filter, _ := json.Marshal(filterMap)
	insertOrder["filter"] = string(filter)
	insertOrder["is_backstage_order"] = 1 // 后台创建
	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 := MysqlMain.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)
}