package rule import ( "code.fnuoos.com/EggPlanet/egg_models.git/src/implement" "code.fnuoos.com/EggPlanet/egg_models.git/src/model" "code.fnuoos.com/EggPlanet/egg_system_rules.git/md" md2 "code.fnuoos.com/EggPlanet/egg_system_rules.git/rule/egg_energy/md" "code.fnuoos.com/EggPlanet/egg_system_rules.git/utils" "code.fnuoos.com/EggPlanet/egg_system_rules.git/utils/cache" "code.fnuoos.com/EggPlanet/egg_system_rules.git/utils/logx" "errors" "fmt" "math" "strconv" "strings" "time" "xorm.io/xorm" ) // AddPublicPlatoonUserRelationCommission 新增公排用户关系记录 func AddPublicPlatoonUserRelationCommission(engine *xorm.Engine, AddPublicPlatoonUserRelationCommissionReqList []*md2.AddPublicPlatoonUserRelationCommissionReq) (map[string]*model.PublicPlatoonUserRelation, error) { var resp = map[string]*model.PublicPlatoonUserRelation{} //查找 `public_platoon_basic_setting` 基础设置 publicPlatoonBasicSettingDb := implement.NewPublicPlatoonBasicSettingDb(engine) publicPlatoonBasicSetting, err := publicPlatoonBasicSettingDb.PublicPlatoonBasicSettingGetOneByParams(map[string]interface{}{ "key": "is_open", "value": 1, }) if err != nil { return nil, err } if publicPlatoonBasicSetting == nil { return nil, errors.New("公排制度未开启") } publicPlatoonUserRelationDb := implement.NewPublicPlatoonUserRelationDb(engine) for _, param := range AddPublicPlatoonUserRelationCommissionReqList { isHasPublicPlatoonUserRelation, err11 := publicPlatoonUserRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{ "key": "uid", "value": param.Uid, }) if err11 != nil { return nil, err11 } if isHasPublicPlatoonUserRelation != nil { return nil, errors.New("当前用户已加入公排") } //1、判断是否有推荐人 if param.RecommendUid != "" { //2、有推荐人 //判断是否有uid为-1 (代表等待新用户填充) 的记录 PublicPlatoonUserRelation, err1 := publicPlatoonUserRelationDb.PublicPlatoonUserRelationGetOneByPid(param.RecommendUid, map[string]interface{}{ "key": "uid", "value": -1, }) if err1 != nil { return nil, err1 } if PublicPlatoonUserRelation != nil { now := time.Now() oldUid := PublicPlatoonUserRelation.Uid PublicPlatoonUserRelation.Uid = egg_system_rules.StrToInt64(param.Uid) PublicPlatoonUserRelation.RecommendUid = egg_system_rules.StrToInt64(param.RecommendUid) PublicPlatoonUserRelation.CreateAt = now.Format("2006-01-02 15:04:05") PublicPlatoonUserRelation.UpdateAt = now.Format("2006-01-02 15:04:05") PublicPlatoonUserRelation.JoinAt = now.Format("2006-01-02 15:04:05") updateAffected, err2 := publicPlatoonUserRelationDb.PublicPlatoonUserRelationUpdate(engine.NewSession(), PublicPlatoonUserRelation.Id, PublicPlatoonUserRelation) if err2 != nil { return nil, err2 } if updateAffected == 0 { err = errors.New("更新 public_platoon_user_relation 记录失败") return nil, err } else { for n := 1; n <= 9; n++ { str := "father_uid" + strconv.Itoa(n) sql := fmt.Sprintf("UPDATE `public_platoon_user_relation` SET %s=%s where %s=%s", str, param.Uid, str, egg_system_rules.Int64ToStr(oldUid)) fmt.Println(">>>>>>>sql>>>>>>>", sql) _, err = engine.Exec(sql) if err != nil { return nil, err } } resp[param.Uid] = PublicPlatoonUserRelation } continue } res, err := PublicPlatoon(engine, egg_system_rules.StrToInt64(param.Uid), egg_system_rules.StrToInt64(param.RecommendUid), *publicPlatoonBasicSetting) if err != nil { return nil, err } resp[param.Uid] = &res } } return resp, nil } /* 公排方法 TODO 相关公式: 1: 每个等级的起始值(1+5^0+5^1+5^2+...+5^x-2), 每个等级的结束值(`5^0+5^1+5^2+...+5^x-1) 2: 根据position查找父级position { (position-1)/5 } 3: 根据position查找等级level {position-5^0-5^1-5^2-...-5^x 是否 <0 ? => x+1 } 4: 根据最新自增`id` 逆向推导 position {levelFirstPosition + (position-1)%5} */ func PublicPlatoon(engine *xorm.Engine, uid, recommendUid int64, PublicPlatoonBasicSetting model.PublicPlatoonBasicSetting) (model.PublicPlatoonUserRelation, error) { var standardPublicPlatoonRelation md.StandardPublicPlatoonRelation var PublicPlatoonUserRelation model.PublicPlatoonUserRelation var fatherUid int64 //1、 查找当前 public_platoon_user_relation 中 recommendUid 的记录 publicPlatoonUserRelationDb := implement.NewPublicPlatoonUserRelationDb(engine) m, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{ "key": "uid", "value": recommendUid, }) if err != nil { return model.PublicPlatoonUserRelation{}, err } if m == nil { return model.PublicPlatoonUserRelation{}, errors.New("未查询到推荐人记录") } //2、 查找当前 public_platoon_user_relation 中 recommendUid 所有的子记录 PublicPlatoonUserRelations, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationFindByPid(m.Uid, "father_uid1", "position1") if err != nil { return model.PublicPlatoonUserRelation{}, err } if len(PublicPlatoonUserRelations) == 0 { fatherUid = m.Uid //证明是第一个 standardPublicPlatoonRelation.FatherUid1 = m.Uid standardPublicPlatoonRelation.FatherUid2 = m.FatherUid1 standardPublicPlatoonRelation.FatherUid3 = m.FatherUid2 standardPublicPlatoonRelation.FatherUid4 = m.FatherUid3 standardPublicPlatoonRelation.FatherUid5 = m.FatherUid4 standardPublicPlatoonRelation.FatherUid6 = m.FatherUid5 standardPublicPlatoonRelation.FatherUid7 = m.FatherUid6 standardPublicPlatoonRelation.FatherUid8 = m.FatherUid7 standardPublicPlatoonRelation.FatherUid9 = m.FatherUid8 standardPublicPlatoonRelation.Pid1 = m.Position standardPublicPlatoonRelation.Pid2 = m.Position1 standardPublicPlatoonRelation.Pid3 = m.Position2 standardPublicPlatoonRelation.Pid4 = m.Position3 standardPublicPlatoonRelation.Pid5 = m.Position4 standardPublicPlatoonRelation.Pid6 = m.Position5 standardPublicPlatoonRelation.Pid7 = m.Position6 standardPublicPlatoonRelation.Pid8 = m.Position7 standardPublicPlatoonRelation.Pid9 = m.Position8 standardPublicPlatoonRelation.Position1 = SearchPositionFirstSonPosition(m.Position, int64(PublicPlatoonBasicSetting.SeveralTimes)) standardPublicPlatoonRelation.Position2 = ReverseDeductionPositionByFather(m.Position1, int64(m.Level1), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position3 = ReverseDeductionPositionByFather(m.Position2, int64(m.Level2), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position4 = ReverseDeductionPositionByFather(m.Position3, int64(m.Level3), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position5 = ReverseDeductionPositionByFather(m.Position4, int64(m.Level4), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position6 = ReverseDeductionPositionByFather(m.Position5, int64(m.Level5), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position7 = ReverseDeductionPositionByFather(m.Position6, int64(m.Level6), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position8 = ReverseDeductionPositionByFather(m.Position7, int64(m.Level7), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) standardPublicPlatoonRelation.Position9 = ReverseDeductionPositionByFather(m.Position8, int64(m.Level8), int64(PublicPlatoonBasicSetting.SeveralTimes), 0) if m.Level1 == 0 { m.Level1-- } if m.Level2 == 0 { m.Level2-- } if m.Level3 == 0 { m.Level3-- } if m.Level4 == 0 { m.Level4-- } if m.Level5 == 0 { m.Level5-- } if m.Level6 == 0 { m.Level6-- } if m.Level7 == 0 { m.Level7-- } if m.Level8 == 0 { m.Level8-- } if m.Level9 == 0 { m.Level9-- } standardPublicPlatoonRelation.Level1 = m.Level + 1 standardPublicPlatoonRelation.Level2 = m.Level1 + 1 standardPublicPlatoonRelation.Level3 = m.Level2 + 1 standardPublicPlatoonRelation.Level4 = m.Level3 + 1 standardPublicPlatoonRelation.Level5 = m.Level4 + 1 standardPublicPlatoonRelation.Level6 = m.Level5 + 1 standardPublicPlatoonRelation.Level7 = m.Level6 + 1 standardPublicPlatoonRelation.Level8 = m.Level7 + 1 standardPublicPlatoonRelation.Level9 = m.Level8 + 1 standardPublicPlatoonRelation.LevelTotal = m.LevelTotal + 1 } else { //TODO::判断直属下级是否排满 if len(PublicPlatoonUserRelations) >= PublicPlatoonBasicSetting.SeveralTimes { var fatherLevel float64 makeSearchLevel(&m.Position, float64(PublicPlatoonBasicSetting.SeveralTimes), &fatherLevel) var times = 0 data, father, err := FindSuitablePosition(engine, &m.Position, float64(PublicPlatoonBasicSetting.SeveralTimes), m.Uid, int64(fatherLevel), ×) if err != nil { return model.PublicPlatoonUserRelation{}, err } fatherUid = father standardPublicPlatoonRelation = data } else { fatherUid = m.Uid standardPublicPlatoonRelation.FatherUid1 = PublicPlatoonUserRelations[0].FatherUid1 standardPublicPlatoonRelation.FatherUid2 = PublicPlatoonUserRelations[0].FatherUid2 standardPublicPlatoonRelation.FatherUid3 = PublicPlatoonUserRelations[0].FatherUid3 standardPublicPlatoonRelation.FatherUid4 = PublicPlatoonUserRelations[0].FatherUid4 standardPublicPlatoonRelation.FatherUid5 = PublicPlatoonUserRelations[0].FatherUid5 standardPublicPlatoonRelation.FatherUid6 = PublicPlatoonUserRelations[0].FatherUid6 standardPublicPlatoonRelation.FatherUid7 = PublicPlatoonUserRelations[0].FatherUid7 standardPublicPlatoonRelation.FatherUid8 = PublicPlatoonUserRelations[0].FatherUid8 standardPublicPlatoonRelation.FatherUid9 = PublicPlatoonUserRelations[0].FatherUid9 standardPublicPlatoonRelation.Pid1 = PublicPlatoonUserRelations[0].Pid1 standardPublicPlatoonRelation.Pid2 = PublicPlatoonUserRelations[0].Pid2 standardPublicPlatoonRelation.Pid3 = PublicPlatoonUserRelations[0].Pid3 standardPublicPlatoonRelation.Pid4 = PublicPlatoonUserRelations[0].Pid4 standardPublicPlatoonRelation.Pid5 = PublicPlatoonUserRelations[0].Pid5 standardPublicPlatoonRelation.Pid6 = PublicPlatoonUserRelations[0].Pid6 standardPublicPlatoonRelation.Pid7 = PublicPlatoonUserRelations[0].Pid7 standardPublicPlatoonRelation.Pid8 = PublicPlatoonUserRelations[0].Pid8 standardPublicPlatoonRelation.Pid9 = PublicPlatoonUserRelations[0].Pid9 standardPublicPlatoonRelation.Position1 = PublicPlatoonUserRelations[0].Position1 + 1 if PublicPlatoonUserRelations[0].Position2 != 0 { standardPublicPlatoonRelation.Position2 = PublicPlatoonUserRelations[0].Position2 + 1 } if PublicPlatoonUserRelations[0].Position3 != 0 { standardPublicPlatoonRelation.Position3 = PublicPlatoonUserRelations[0].Position3 + 1 } if PublicPlatoonUserRelations[0].Position4 != 0 { standardPublicPlatoonRelation.Position4 = PublicPlatoonUserRelations[0].Position4 + 1 } if PublicPlatoonUserRelations[0].Position5 != 0 { standardPublicPlatoonRelation.Position5 = PublicPlatoonUserRelations[0].Position5 + 1 } if PublicPlatoonUserRelations[0].Position6 != 0 { standardPublicPlatoonRelation.Position6 = PublicPlatoonUserRelations[0].Position6 + 1 } if PublicPlatoonUserRelations[0].Position7 != 0 { standardPublicPlatoonRelation.Position7 = PublicPlatoonUserRelations[0].Position7 + 1 } if PublicPlatoonUserRelations[0].Position8 != 0 { standardPublicPlatoonRelation.Position8 = PublicPlatoonUserRelations[0].Position8 + 1 } if PublicPlatoonUserRelations[0].Position9 != 0 { standardPublicPlatoonRelation.Position9 = PublicPlatoonUserRelations[0].Position9 + 1 } standardPublicPlatoonRelation.Level1 = PublicPlatoonUserRelations[0].Level1 standardPublicPlatoonRelation.Level2 = PublicPlatoonUserRelations[0].Level2 standardPublicPlatoonRelation.Level3 = PublicPlatoonUserRelations[0].Level3 standardPublicPlatoonRelation.Level4 = PublicPlatoonUserRelations[0].Level4 standardPublicPlatoonRelation.Level5 = PublicPlatoonUserRelations[0].Level5 standardPublicPlatoonRelation.Level6 = PublicPlatoonUserRelations[0].Level6 standardPublicPlatoonRelation.Level7 = PublicPlatoonUserRelations[0].Level7 standardPublicPlatoonRelation.Level8 = PublicPlatoonUserRelations[0].Level8 standardPublicPlatoonRelation.Level9 = PublicPlatoonUserRelations[0].Level9 standardPublicPlatoonRelation.LevelTotal = PublicPlatoonUserRelations[0].LevelTotal } } //2、查找对应pid的 public_platoon_user_relation 记录 var m1 model.PublicPlatoonUserRelation if has, err := engine.Where("uid=?", fatherUid).Get(&m1); err != nil || has == false { return PublicPlatoonUserRelation, err } var fatherUidStr string if m1.FatherUid == "" { //TODO::顶级 fatherUidStr = egg_system_rules.Int64ToStr(m1.Id) } else { fatherUids := strings.Split(m1.FatherUid, "-") if len(fatherUids) >= PublicPlatoonBasicSetting.SeveralRows { fatherUidStr = egg_system_rules.Int64ToStr(m1.Id) + "-" + strings.Join(fatherUids[0:PublicPlatoonBasicSetting.SeveralRows:len(fatherUids)], "-") } else { fatherUidStr = egg_system_rules.Int64ToStr(m1.Id) + "-" + m1.FatherUid } } // 3、插入 public_platoon_user_relation 记录 now := time.Now() PublicPlatoonUserRelation.Uid = uid PublicPlatoonUserRelation.FatherUid = fatherUidStr PublicPlatoonUserRelation.FatherUid1 = standardPublicPlatoonRelation.FatherUid1 PublicPlatoonUserRelation.FatherUid2 = standardPublicPlatoonRelation.FatherUid2 PublicPlatoonUserRelation.FatherUid3 = standardPublicPlatoonRelation.FatherUid3 PublicPlatoonUserRelation.FatherUid4 = standardPublicPlatoonRelation.FatherUid4 PublicPlatoonUserRelation.FatherUid5 = standardPublicPlatoonRelation.FatherUid5 PublicPlatoonUserRelation.FatherUid6 = standardPublicPlatoonRelation.FatherUid6 PublicPlatoonUserRelation.FatherUid7 = standardPublicPlatoonRelation.FatherUid7 PublicPlatoonUserRelation.FatherUid8 = standardPublicPlatoonRelation.FatherUid8 PublicPlatoonUserRelation.FatherUid9 = standardPublicPlatoonRelation.FatherUid9 PublicPlatoonUserRelation.Pid1 = standardPublicPlatoonRelation.Pid1 PublicPlatoonUserRelation.Pid2 = standardPublicPlatoonRelation.Pid2 PublicPlatoonUserRelation.Pid3 = standardPublicPlatoonRelation.Pid3 PublicPlatoonUserRelation.Pid4 = standardPublicPlatoonRelation.Pid4 PublicPlatoonUserRelation.Pid5 = standardPublicPlatoonRelation.Pid5 PublicPlatoonUserRelation.Pid6 = standardPublicPlatoonRelation.Pid6 PublicPlatoonUserRelation.Pid7 = standardPublicPlatoonRelation.Pid7 PublicPlatoonUserRelation.Pid8 = standardPublicPlatoonRelation.Pid8 PublicPlatoonUserRelation.Pid9 = standardPublicPlatoonRelation.Pid9 PublicPlatoonUserRelation.Position = 1 PublicPlatoonUserRelation.Position1 = standardPublicPlatoonRelation.Position1 PublicPlatoonUserRelation.Position2 = standardPublicPlatoonRelation.Position2 PublicPlatoonUserRelation.Position3 = standardPublicPlatoonRelation.Position3 PublicPlatoonUserRelation.Position4 = standardPublicPlatoonRelation.Position4 PublicPlatoonUserRelation.Position5 = standardPublicPlatoonRelation.Position5 PublicPlatoonUserRelation.Position6 = standardPublicPlatoonRelation.Position6 PublicPlatoonUserRelation.Position7 = standardPublicPlatoonRelation.Position7 PublicPlatoonUserRelation.Position8 = standardPublicPlatoonRelation.Position8 PublicPlatoonUserRelation.Position9 = standardPublicPlatoonRelation.Position9 PublicPlatoonUserRelation.Level = 1 PublicPlatoonUserRelation.Level1 = standardPublicPlatoonRelation.Level1 PublicPlatoonUserRelation.Level2 = standardPublicPlatoonRelation.Level2 PublicPlatoonUserRelation.Level3 = standardPublicPlatoonRelation.Level3 PublicPlatoonUserRelation.Level4 = standardPublicPlatoonRelation.Level4 PublicPlatoonUserRelation.Level5 = standardPublicPlatoonRelation.Level5 PublicPlatoonUserRelation.Level6 = standardPublicPlatoonRelation.Level6 PublicPlatoonUserRelation.Level7 = standardPublicPlatoonRelation.Level7 PublicPlatoonUserRelation.Level8 = standardPublicPlatoonRelation.Level8 PublicPlatoonUserRelation.Level9 = standardPublicPlatoonRelation.Level9 PublicPlatoonUserRelation.LevelTotal = standardPublicPlatoonRelation.LevelTotal PublicPlatoonUserRelation.RecommendUid = recommendUid PublicPlatoonUserRelation.JoinAt = now.Format("2006-01-02 15:04:05") PublicPlatoonUserRelation.CreateAt = now.Format("2006-01-02 15:04:05") PublicPlatoonUserRelation.UpdateAt = now.Format("2006-01-02 15:04:05") PublicPlatoonUserRelation.HasSonNum = 0 _, err = publicPlatoonUserRelationDb.PublicPlatoonUserRelationInsert(&PublicPlatoonUserRelation) if err != nil { return model.PublicPlatoonUserRelation{}, err } // 4、改变直属父级的 has_son_num 数量 update, err := engine.Where("uid = ?", fatherUid).SetExpr("has_son_num", "has_son_num + 1").Update(new(model.PublicPlatoonUserRelation)) if err != nil { return PublicPlatoonUserRelation, err } if update == 0 { return PublicPlatoonUserRelation, errors.New("更新has_son_num数据出错") } return PublicPlatoonUserRelation, nil } // ReverseDeductionPosition 逆向推导 position func ReverseDeductionPosition(calcPosition, levelFirstPosition, severalTimes int) (position int) { remainder := (calcPosition - 1) % severalTimes position = levelFirstPosition + remainder return } func ReverseDeductionPositionByFather(fatherPosition, level, severalTimes, remainder int64) (position int64) { if fatherPosition == 0 { position = 0 return } firstPosition := GetLevelForFirstPosition(level, severalTimes) endPosition := firstPosition + int64(math.Pow(float64(severalTimes), float64(level-1))) - 1 position = fatherPosition + (fatherPosition-firstPosition)*severalTimes + (endPosition - fatherPosition) + 1 return } func FindSuitablePosition(engine *xorm.Engine, position *int64, severalTimes float64, fuid, fatherLevel int64, times *int) (standardPublicPlatoonRelation md.StandardPublicPlatoonRelation, fatherUid int64, err error) { *times++ positionName := "position" + egg_system_rules.IntToStr(*times) fatherName := "father_uid" + egg_system_rules.IntToStr(*times) firstSonPosition := SearchPositionFirstSonPosition(*position, int64(severalTimes)) var tempLevel float64 makeSearchLevel(&firstSonPosition, severalTimes, &tempLevel) firstSonLevel := int64(tempLevel) endSonPosition := firstSonPosition + int64(math.Pow(severalTimes, float64(firstSonLevel-fatherLevel))) - 1 publicPlatoonUserRelationDb := implement.NewPublicPlatoonUserRelationDb(engine) list, _, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationFindCountByPosition(fuid, fatherName, positionName, int64(firstSonPosition), int64(endSonPosition)) if err != nil { return standardPublicPlatoonRelation, fatherUid, err } if list[0].HasSonNum == int(severalTimes) { //TODO::则证明该层直属下级无空位 position = &firstSonPosition return FindSuitablePosition(engine, position, severalTimes, fuid, fatherLevel, times) } else if list[0].HasSonNum == 0 { fatherUid = list[0].Uid //TODO::新的一层 standardPublicPlatoonRelation.FatherUid1 = list[0].Uid standardPublicPlatoonRelation.FatherUid2 = list[0].FatherUid1 standardPublicPlatoonRelation.FatherUid3 = list[0].FatherUid2 standardPublicPlatoonRelation.FatherUid4 = list[0].FatherUid3 standardPublicPlatoonRelation.FatherUid5 = list[0].FatherUid4 standardPublicPlatoonRelation.FatherUid6 = list[0].FatherUid5 standardPublicPlatoonRelation.FatherUid7 = list[0].FatherUid6 standardPublicPlatoonRelation.FatherUid8 = list[0].FatherUid7 standardPublicPlatoonRelation.FatherUid9 = list[0].FatherUid8 standardPublicPlatoonRelation.Pid1 = list[0].Position standardPublicPlatoonRelation.Pid2 = list[0].Position1 standardPublicPlatoonRelation.Pid3 = list[0].Position2 standardPublicPlatoonRelation.Pid4 = list[0].Position3 standardPublicPlatoonRelation.Pid5 = list[0].Position4 standardPublicPlatoonRelation.Pid6 = list[0].Position5 standardPublicPlatoonRelation.Pid7 = list[0].Position6 standardPublicPlatoonRelation.Pid8 = list[0].Position7 standardPublicPlatoonRelation.Pid9 = list[0].Position8 standardPublicPlatoonRelation.Position1 = SearchPositionFirstSonPosition(list[0].Position, int64(severalTimes)) standardPublicPlatoonRelation.Position2 = ReverseDeductionPositionByFather(list[0].Position1, int64(list[0].Level1), int64(severalTimes), 0) standardPublicPlatoonRelation.Position3 = ReverseDeductionPositionByFather(list[0].Position2, int64(list[0].Level2), int64(severalTimes), 0) standardPublicPlatoonRelation.Position4 = ReverseDeductionPositionByFather(list[0].Position3, int64(list[0].Level3), int64(severalTimes), 0) standardPublicPlatoonRelation.Position5 = ReverseDeductionPositionByFather(list[0].Position4, int64(list[0].Level4), int64(severalTimes), 0) standardPublicPlatoonRelation.Position6 = ReverseDeductionPositionByFather(list[0].Position5, int64(list[0].Level5), int64(severalTimes), 0) standardPublicPlatoonRelation.Position7 = ReverseDeductionPositionByFather(list[0].Position6, int64(list[0].Level6), int64(severalTimes), 0) standardPublicPlatoonRelation.Position8 = ReverseDeductionPositionByFather(list[0].Position7, int64(list[0].Level7), int64(severalTimes), 0) standardPublicPlatoonRelation.Position9 = ReverseDeductionPositionByFather(list[0].Position8, int64(list[0].Level8), int64(severalTimes), 0) if list[0].Level1 == 0 { list[0].Level1-- } if list[0].Level2 == 0 { list[0].Level2-- } if list[0].Level3 == 0 { list[0].Level3-- } if list[0].Level4 == 0 { list[0].Level4-- } if list[0].Level5 == 0 { list[0].Level5-- } if list[0].Level6 == 0 { list[0].Level6-- } if list[0].Level7 == 0 { list[0].Level7-- } if list[0].Level8 == 0 { list[0].Level8-- } if list[0].Level9 == 0 { list[0].Level9-- } standardPublicPlatoonRelation.Level1 = list[0].Level + 1 standardPublicPlatoonRelation.Level2 = list[0].Level1 + 1 standardPublicPlatoonRelation.Level3 = list[0].Level2 + 1 standardPublicPlatoonRelation.Level4 = list[0].Level3 + 1 standardPublicPlatoonRelation.Level5 = list[0].Level4 + 1 standardPublicPlatoonRelation.Level6 = list[0].Level5 + 1 standardPublicPlatoonRelation.Level7 = list[0].Level6 + 1 standardPublicPlatoonRelation.Level8 = list[0].Level7 + 1 standardPublicPlatoonRelation.Level9 = list[0].Level8 + 1 standardPublicPlatoonRelation.LevelTotal = list[0].LevelTotal + 1 } else { fatherUid = list[0].Uid _, _, _, _, getPositionName, _, _, _ := GetPosition(list[0], *times+1) //PublicPlatoonUserRelations, err := db.PublicPlatoonUserRelationFindByPid(engine, m.Position, m.Uid, "pid1", "father_uid1", "position1") PublicPlatoonUserRelations, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationFindByPid(list[0].Uid, "father_uid1", getPositionName) if err != nil { return standardPublicPlatoonRelation, fatherUid, err } if PublicPlatoonUserRelations[0].Position2 == 0 { PublicPlatoonUserRelations[0].Position2 = -1 } if PublicPlatoonUserRelations[0].Position3 == 0 { standardPublicPlatoonRelation.Position3 = -1 } if PublicPlatoonUserRelations[0].Position4 == 0 { standardPublicPlatoonRelation.Position4 = -1 } if PublicPlatoonUserRelations[0].Position5 == 0 { standardPublicPlatoonRelation.Position5 = -1 } if PublicPlatoonUserRelations[0].Position6 == 0 { standardPublicPlatoonRelation.Position6 = -1 } if PublicPlatoonUserRelations[0].Position7 == 0 { standardPublicPlatoonRelation.Position7 = -1 } if PublicPlatoonUserRelations[0].Position8 == 0 { standardPublicPlatoonRelation.Position8 = -1 } if PublicPlatoonUserRelations[0].Position9 == 0 { standardPublicPlatoonRelation.Position9 = -1 } standardPublicPlatoonRelation = md.StandardPublicPlatoonRelation{ FatherUid1: PublicPlatoonUserRelations[0].FatherUid1, FatherUid2: PublicPlatoonUserRelations[0].FatherUid2, FatherUid3: PublicPlatoonUserRelations[0].FatherUid3, FatherUid4: PublicPlatoonUserRelations[0].FatherUid4, FatherUid5: PublicPlatoonUserRelations[0].FatherUid5, FatherUid6: PublicPlatoonUserRelations[0].FatherUid6, FatherUid7: PublicPlatoonUserRelations[0].FatherUid7, FatherUid8: PublicPlatoonUserRelations[0].FatherUid8, FatherUid9: PublicPlatoonUserRelations[0].FatherUid9, Pid1: PublicPlatoonUserRelations[0].Pid1, Pid2: PublicPlatoonUserRelations[0].Pid2, Pid3: PublicPlatoonUserRelations[0].Pid3, Pid4: PublicPlatoonUserRelations[0].Pid4, Pid5: PublicPlatoonUserRelations[0].Pid5, Pid6: PublicPlatoonUserRelations[0].Pid6, Pid7: PublicPlatoonUserRelations[0].Pid7, Pid8: PublicPlatoonUserRelations[0].Pid8, Pid9: PublicPlatoonUserRelations[0].Pid9, Position1: PublicPlatoonUserRelations[0].Position1 + 1, Position2: PublicPlatoonUserRelations[0].Position2 + 1, Position3: PublicPlatoonUserRelations[0].Position3 + 1, Position4: PublicPlatoonUserRelations[0].Position4 + 1, Position5: PublicPlatoonUserRelations[0].Position5 + 1, Position6: PublicPlatoonUserRelations[0].Position6 + 1, Position7: PublicPlatoonUserRelations[0].Position7 + 1, Position8: PublicPlatoonUserRelations[0].Position8 + 1, Position9: PublicPlatoonUserRelations[0].Position9 + 1, Level1: PublicPlatoonUserRelations[0].Level1, Level2: PublicPlatoonUserRelations[0].Level2, Level3: PublicPlatoonUserRelations[0].Level3, Level4: PublicPlatoonUserRelations[0].Level4, Level5: PublicPlatoonUserRelations[0].Level5, Level6: PublicPlatoonUserRelations[0].Level6, Level7: PublicPlatoonUserRelations[0].Level7, Level8: PublicPlatoonUserRelations[0].Level8, Level9: PublicPlatoonUserRelations[0].Level9, LevelTotal: PublicPlatoonUserRelations[0].LevelTotal, } return standardPublicPlatoonRelation, fatherUid, nil } return } func GetPosition(m model.PublicPlatoonUserRelation, times int) (position, pid int64, level int, fatherUid int64, positionName, pidName, levelName, fatherUidName string) { if times == 1 { position = m.Position1 positionName = "position1" pid = m.Pid1 pidName = "pid1" level = m.Level1 levelName = "level1" fatherUid = m.FatherUid1 fatherUidName = "father_uid1" } if times == 2 { position = m.Position2 positionName = "position2" pid = m.Pid2 pidName = "pid2" level = m.Level2 levelName = "level2" fatherUid = m.FatherUid2 fatherUidName = "father_uid2" } if times == 3 { position = m.Position3 positionName = "position3" pid = m.Pid3 pidName = "pid3" level = m.Level3 levelName = "level3" fatherUid = m.FatherUid3 fatherUidName = "father_uid3" } if times == 4 { position = m.Position4 positionName = "position4" pid = m.Pid4 pidName = "pid4" level = m.Level4 levelName = "level4" fatherUid = m.FatherUid4 fatherUidName = "father_uid4" } if times == 5 { position = m.Position5 positionName = "position5" pid = m.Pid5 pidName = "pid5" level = m.Level5 levelName = "level5" fatherUid = m.FatherUid5 fatherUidName = "father_uid5" } if times == 6 { position = m.Position6 positionName = "position6" pid = m.Pid6 pidName = "pid6" level = m.Level6 levelName = "level6" fatherUid = m.FatherUid6 fatherUidName = "father_uid6" } if times == 7 { position = m.Position7 positionName = "position7" pid = m.Pid7 pidName = "pid7" level = m.Level7 levelName = "level7" fatherUid = m.FatherUid7 fatherUidName = "father_uid7" } if times == 8 { position = m.Position8 positionName = "position8" pid = m.Pid8 pidName = "pid8" level = m.Level8 levelName = "level8" fatherUid = m.FatherUid8 fatherUidName = "father_uid8" } if times == 9 { position = m.Position9 positionName = "position9" pid = m.Pid9 pidName = "pid9" level = m.Level9 levelName = "level9" fatherUid = m.FatherUid9 fatherUidName = "father_uid9" } return } // GetLevelForFirstPosition 返回当前等级的起始值 func GetLevelForFirstPosition(level, severalTimes int64) (position int64) { position = position + 1 for n := int64(0); n <= (level - 2); n++ { position += int64(math.Pow(float64(severalTimes), float64(n))) } return } // 查找归属父级id func MakeSearchPid(position int, row int) (pid int) { divisionValue := (position - 1) / row if divisionValue == 0 { pid = 1 return } else { if (divisionValue*row + 1) == position { pid = divisionValue return } else { pid = divisionValue + 1 return } } } // 查找当前位置下的第一个子集位置 func SearchPositionFirstSonPosition(position int64, times int64) (sonPosition int64) { sonPosition = (position * times) - (times - 2) return } // 查找当前位位置相当于父级的等级 func SearchPositionSonForLevel(fatherUid string, fatherPosition int64) (level int) { fatherUids := strings.Split(fatherUid, "-") for key, item := range fatherUids { if item == egg_system_rules.Int64ToStr(fatherPosition) { level = key + 1 break } } return } // FindWaitForDealUsers 查询待处理的用户 func FindWaitForDealUsers(engine *xorm.Engine, page, pageSize int) (err error, resp []int64) { now := time.Now().Format("2006-01-02") publicPlatoonUserRelationDb := implement.NewPublicPlatoonUserRelationDb(engine) lists, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationFindByParamsByPage(map[string]interface{}{ "key": "wait_for_settlement_date", "value": now, }, page, pageSize) if err != nil { return } for _, list := range *lists { resp = append(resp, list.Uid) } return } // 递归查找等级 func makeSearchLevel(position *int64, rows float64, times *float64) (level int) { difference := *position - int64(math.Pow(rows, *times)) *times++ if difference <= 0 { return int(*times) } else { position = &difference return makeSearchLevel(position, rows, times) } } // DealCommonWealthPunish 处理公排处罚 func DealCommonWealthPunish(engine *xorm.Engine, uid int64, reason string) (err error, resp []map[string]string) { session := engine.NewSession() defer func() { session.Close() if err := recover(); err != nil { _ = zhios_order_relate_logx.Error(err) } }() session.Begin() //1、查找 `user_public_platoon_setting` 基础设置 publicPlatoonBasicSettingDb := implement.NewPublicPlatoonBasicSettingDb(engine) PublicPlatoonBasicSetting, err := publicPlatoonBasicSettingDb.PublicPlatoonBasicSettingGetOneByParams(map[string]interface{}{ "key": "is_open", "value": 1, }) if err != nil { _ = session.Rollback() return } //2、查询出 `public_platoon_user_relation` 中相关记录 && 将该记录的uid置为 -1 publicPlatoonUserRelationDb := implement.NewPublicPlatoonUserRelationDb(engine) params, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{ "key": "uid", "value": uid, }) if err != nil { _ = session.Rollback() return } if params == nil { fmt.Println("未查询到公排关系记录!!!!!!!", uid) return } //TODO::判断是否为推荐用户 if params.RecommendUid == 0 { params.Uid = params.Uid - int64(time.Now().Unix()) } else { params.Uid = params.Uid - int64(time.Now().Unix()) } for n := 1; n <= 9; n++ { str := "father_uid" + strconv.Itoa(n) sql := fmt.Sprintf("UPDATE `public_platoon_user_relation` SET %s=%s where %s=%s", str, egg_system_rules.Int64ToStr(params.Uid), str, egg_system_rules.Int64ToStr(uid)) fmt.Println(">>>>>>>sql>>>>>>>", sql) _, err = session.Exec(sql) if err != nil { _ = session.Rollback() return } } updateAffected, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationUpdate(session, params.Id, params) if err != nil { _ = session.Rollback() return } if updateAffected == 0 { err = errors.New("更新 public_platoon_user_relation 记录失败") _ = session.Rollback() return } //3、新增一条 `public_platoon_user_relation` 记录 params.Uid = uid res, err := PublicPlatoon(engine, params.Uid, params.RecommendUid, *PublicPlatoonBasicSetting) if err != nil { _ = session.Rollback() return } //4、新增一条 `public_platoon_user_system_punish_records` 记录 now := time.Now() publicPlatoonUserSystemPunishRecordsDb := implement.NewPublicPlatoonUserSystemPunishRecordsDb(engine) insertAffected, err := publicPlatoonUserSystemPunishRecordsDb.PublicPlatoonUserSystemPunishRecordsInsert(session, &model.PublicPlatoonUserSystemPunishRecords{ Uid: params.Uid, OldPosition: params.Position, NewPosition: res.Position, Date: now.AddDate(0, 0, 30).Format("2006-01-02"), Title: "系统处罚记录", Reason: reason, Type: 2, CreateAt: now.Format("2006-01-02 15:04:05"), UpdateAt: now.Format("2006-01-02 15:04:05"), }) if err != nil { _ = session.Rollback() return } if insertAffected == 0 { err = errors.New("新增 public_platoon_user_system_punish_records 记录失败") _ = session.Rollback() return } err = session.Commit() return } // DealPublicPlatoon 处理公排注销 func DealPublicPlatoon(engine *xorm.Engine, uid int64, reason string) (err error, resp []map[string]string) { session := engine.NewSession() defer func() { session.Close() if err := recover(); err != nil { _ = zhios_order_relate_logx.Error(err) } }() session.Begin() //1、查找 `user_public_platoon_setting` 基础设置 publicPlatoonBasicSettingDb := implement.NewPublicPlatoonBasicSettingDb(engine) PublicPlatoonBasicSetting, err := publicPlatoonBasicSettingDb.PublicPlatoonBasicSettingGetOneByParams(map[string]interface{}{ "key": "is_open", "value": 1, }) if err != nil { _ = session.Rollback() return } //2、查询出 `public_platoon_user_relation` 中相关记录 && 将该记录的uid置为 -1 publicPlatoonUserRelationDb := implement.NewPublicPlatoonUserRelationDb(engine) params, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{ "key": "uid", "value": uid, }) if err != nil { _ = session.Rollback() return } if params == nil { fmt.Println("未查询到公排关系记录!!!!!!!", uid) return } //TODO::判断是否为推荐用户 if params.RecommendUid == 0 { params.Uid = params.Uid - int64(time.Now().Unix()) } else { params.Uid = params.Uid - int64(time.Now().Unix()) } for n := 1; n <= 9; n++ { str := "father_uid" + strconv.Itoa(n) sql := fmt.Sprintf("UPDATE `public_platoon_user_relation` SET %s=%s where %s=%s", str, egg_system_rules.Int64ToStr(params.Uid), str, egg_system_rules.Int64ToStr(uid)) fmt.Println(">>>>>>>sql>>>>>>>", sql) _, err = session.Exec(sql) if err != nil { _ = session.Rollback() return } } updateAffected, err := publicPlatoonUserRelationDb.PublicPlatoonUserRelationUpdate(session, params.Id, params) if err != nil { _ = session.Rollback() return } if updateAffected == 0 { err = errors.New("更新 public_platoon_user_relation 记录失败") _ = session.Rollback() return } //3、新增一条 `public_platoon_user_relation` 记录 params.Uid = uid res, err := PublicPlatoon(engine, params.Uid, params.RecommendUid, *PublicPlatoonBasicSetting) if err != nil { _ = session.Rollback() return } //4、新增一条 `public_platoon_user_system_punish_records` 记录 now := time.Now() publicPlatoonUserSystemPunishRecordsDb := implement.NewPublicPlatoonUserSystemPunishRecordsDb(engine) insertAffected, err1 := publicPlatoonUserSystemPunishRecordsDb.PublicPlatoonUserSystemPunishRecordsInsert(session, &model.PublicPlatoonUserSystemPunishRecords{ Uid: params.Uid, OldPosition: params.Id, NewPosition: res.Id, Date: now.AddDate(0, 0, 30).Format("2006-01-02"), Title: "用户注销", Reason: reason, Type: 2, CreateAt: now.Format("2006-01-02 15:04:05"), UpdateAt: now.Format("2006-01-02 15:04:05"), }) if err1 != nil { fmt.Println(err1.Error()) _ = session.Rollback() return } if insertAffected == 0 { err = errors.New("新增 public_platoon_user_system_punish_records 记录失败") _ = session.Rollback() return } err = session.Commit() return } const DealUserPublicPlatoonPunishLockKey = "deal_user_public_platoon_lock_key" // DealUserPublicPlatoonPunish 处理公排处罚 func DealUserPublicPlatoonPunish(engine *xorm.Engine) (err error) { now := time.Now() fmt.Println(now.Hour()) if !(now.Hour() > 22 && now.Hour() < 24) { //TODO::只在凌晨一点 ~ 凌晨 8 点运行 return errors.New("非运行时间") } //TODO::增加“悲观锁”防止串行 getString, _ := cache.GetString(DealUserPublicPlatoonPunishLockKey) if getString != "" { fmt.Println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!", "上一次结算未执行完") return errors.New("上一次结算未执行完") } cache.SetEx(DealUserPublicPlatoonPunishLockKey, "running", 3600*8) //8小时 //查找 `public_platoon_basic_setting` 基础设置 publicPlatoonBasicSettingDb := implement.NewPublicPlatoonBasicSettingDb(engine) PublicPlatoonBasicSetting, err := publicPlatoonBasicSettingDb.PublicPlatoonBasicSettingGetOneByParams(map[string]interface{}{ "key": "is_open", "value": 1, }) if err != nil { return err } if PublicPlatoonBasicSetting == nil { return errors.New("公排制度未开启") } publicPlatoonFreePunishWithUserDb := implement.NewPublicPlatoonFreePunishWithUserDb(engine) mapPublicPlatoonFreePunishWithUser, err := publicPlatoonFreePunishWithUserDb.FindAllPublicPlatoonFreePunishWithUser() if err != nil { return err } if PublicPlatoonBasicSetting.SystemPunishReplace == 1 { systemPunishReplaceValue := PublicPlatoonBasicSetting.SystemPunishReplaceValue startDate := now.AddDate(0, 0, -systemPunishReplaceValue).Format("2006-01-02") + " 00:00:00" var page = 1 var pageSize = 100 for { var users []model.User err = engine.Limit(pageSize, (page-1)*pageSize).Desc("uid").Find(&users) if err != nil { return err } if len(users) <= 0 { break } for _, user := range users { var list []model.EggSignIn err = engine.Where("start_time >= ?", startDate).And("uid = ?", user.Id).Find(&list) if len(list) <= 0 && mapPublicPlatoonFreePunishWithUser[user.Id] == nil { var PublicPlatoonRecordsPunishWithUser model.PublicPlatoonRecordsPunishWithUser has, err1 := engine.Where("uid = ?", user.Id).Get(&PublicPlatoonRecordsPunishWithUser) if err1 != nil { return err1 } PublicPlatoonRecordsPunishWithUserDate, _ := time.ParseInLocation("2006-01-02", PublicPlatoonRecordsPunishWithUser.Date, time.Local) if has && now.AddDate(0, 0, -7).After(PublicPlatoonRecordsPunishWithUserDate) { //TODO::不进行重复处罚 continue } //进行处罚 err, _ = DealCommonWealthPunish(engine, user.Id, "公排处罚") if err != nil { return err } //添加 public_platoon_records_punish_with_user 记录 publicPlatoonRecordsPunishWithUserDb := implement.NewPublicPlatoonRecordsPunishWithUserDb(engine) if has { PublicPlatoonRecordsPunishWithUser.Date = now.Format("2006-01-02") _, err2 := publicPlatoonRecordsPunishWithUserDb.PublicPlatoonRecordsPunishWithUserUpdate(PublicPlatoonRecordsPunishWithUser.Id, &PublicPlatoonRecordsPunishWithUser, "date") if err2 != nil { return err2 } } else { _, err2 := publicPlatoonRecordsPunishWithUserDb.PublicPlatoonRecordsPunishWithUserInsert(&model.PublicPlatoonRecordsPunishWithUser{ Uid: user.Id, Date: now.Format("2006-01-02"), }) if err2 != nil { return err2 } } } } page++ } } return }