diff --git a/db/db_user_public_platoon_amount.go b/db/db_user_public_platoon_amount.go new file mode 100644 index 0000000..cc61438 --- /dev/null +++ b/db/db_user_public_platoon_amount.go @@ -0,0 +1,117 @@ +package db + +import ( + "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model" + zhios_order_relate_utils "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils" + zhios_order_relate_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/logx" + "errors" + "fmt" + "reflect" + "xorm.io/xorm" +) + +// BatchSelectUserPublicPlatoonAmounts 批量查询数据 TODO::和下面的方法重复了，建议采用下面的 `UserPublicPlatoonAmountFindByParams` 方法 +func BatchSelectUserPublicPlatoonAmounts(Db *xorm.Engine, params map[string]interface{}) (*[]model.UserPublicPlatoonAmount, error) { + var UserPublicPlatoonAmountData []model.UserPublicPlatoonAmount + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]). + Find(&UserPublicPlatoonAmountData); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &UserPublicPlatoonAmountData, nil +} + +// UserPublicPlatoonAmountInsert 插入单条数据 +func UserPublicPlatoonAmountInsert(Db *xorm.Engine, UserPublicPlatoonAmount *model.UserPublicPlatoonAmount) (int64, error) { + _, err := Db.InsertOne(UserPublicPlatoonAmount) + if err != nil { + return 0, err + } + return UserPublicPlatoonAmount.Id, nil +} + +// BatchAddUserPublicPlatoonAmounts 批量新增数据 +func BatchAddUserPublicPlatoonAmounts(Db *xorm.Engine, UserPublicPlatoonAmountData []*model.UserPublicPlatoonAmount) (int64, error) { + affected, err := Db.Insert(UserPublicPlatoonAmountData) + if err != nil { + return 0, err + } + return affected, nil +} + +func GetUserPublicPlatoonAmountCount(Db *xorm.Engine) int { + var UserPublicPlatoonAmount model.UserPublicPlatoonAmount + session := Db.Where("") + count, err := session.Count(&UserPublicPlatoonAmount) + if err != nil { + return 0 + } + return int(count) +} + +// UserPublicPlatoonAmountDelete 删除记录 +func UserPublicPlatoonAmountDelete(Db *xorm.Engine, id interface{}) (int64, error) { + if reflect.TypeOf(id).Kind() == reflect.Slice { + return Db.In("id", id).Delete(model.UserPublicPlatoonAmount{}) + } else { + return Db.Where("id = ?", id).Delete(model.UserPublicPlatoonAmount{}) + } +} + +// UserPublicPlatoonAmountUpdate 更新记录 +func UserPublicPlatoonAmountUpdate(session *xorm.Session, id interface{}, UserPublicPlatoonAmount *model.UserPublicPlatoonAmount, forceColums ...string) (int64, error) { + var ( + affected int64 + err error + ) + if forceColums != nil { + affected, err = session.Where("id=?", id).Cols(forceColums...).Update(UserPublicPlatoonAmount) + } else { + affected, err = session.Where("id=?", id).Update(UserPublicPlatoonAmount) + } + if err != nil { + return 0, err + } + return affected, nil +} + +// UserPublicPlatoonAmountGetOneByParams 通过传入的参数查询数据(单条) +func UserPublicPlatoonAmountGetOneByParams(Db *xorm.Engine, params map[string]interface{}) (*model.UserPublicPlatoonAmount, error) { + var m model.UserPublicPlatoonAmount + var query = fmt.Sprintf("%s =?", params["key"]) + if has, err := Db.Where(query, params["value"]).Get(&m); err != nil || has == false { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil +} + +// UserPublicPlatoonAmountFindByParams 通过传入的参数查询数据(多条) +func UserPublicPlatoonAmountFindByParams(Db *xorm.Engine, params map[string]interface{}) (*[]model.UserPublicPlatoonAmount, error) { + var m []model.UserPublicPlatoonAmount + if params["value"] == nil { + return nil, errors.New("参数有误") + } + if params["key"] == nil { + //查询全部数据 + err := Db.Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } else { + if reflect.TypeOf(params["value"]).Kind() == reflect.Slice { + //指定In查询 + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]).Find(&m); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &m, nil + } else { + var query = fmt.Sprintf("%s =?", params["key"]) + err := Db.Where(query, params["value"]).Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } + + } +} diff --git a/db/db_user_public_platoon_relation.go b/db/db_user_public_platoon_relation.go index ccde514..208d7d5 100644 --- a/db/db_user_public_platoon_relation.go +++ b/db/db_user_public_platoon_relation.go @@ -58,15 +58,15 @@ func UserPublicPlatoonRelationDelete(Db *xorm.Engine, id interface{}) (int64, er } // UserPublicPlatoonRelationUpdate 更新记录 -func UserPublicPlatoonRelationUpdate(Db *xorm.Engine, id interface{}, UserPublicPlatoonRelation *model.UserPublicPlatoonRelation, forceColums ...string) (int64, error) { +func UserPublicPlatoonRelationUpdate(session *xorm.Session, id interface{}, UserPublicPlatoonRelation *model.UserPublicPlatoonRelation, forceColums ...string) (int64, error) { var ( affected int64 err error ) if forceColums != nil { - affected, err = Db.Where("id=?", id).Cols(forceColums...).Update(UserPublicPlatoonRelation) + affected, err = session.Where("id=?", id).Cols(forceColums...).Update(UserPublicPlatoonRelation) } else { - affected, err = Db.Where("id=?", id).Update(UserPublicPlatoonRelation) + affected, err = session.Where("id=?", id).Update(UserPublicPlatoonRelation) } if err != nil { return 0, err @@ -115,3 +115,39 @@ func UserPublicPlatoonRelationFindByParams(Db *xorm.Engine, params map[string]in } } + +func UserPublicPlatoonRelationFindByParamsByPage(Db *xorm.Engine, params map[string]interface{}, page, pageSize int) (*[]model.UserPublicPlatoonRelation, error) { + var m []model.UserPublicPlatoonRelation + if params["value"] == nil { + return nil, errors.New("参数有误") + } + if page == 0 && pageSize == 0 { + page = 1 + pageSize = 10 + } + + if params["key"] == nil { + //查询全部数据 + err := Db.Limit(pageSize, (page-1)*pageSize).Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } else { + if reflect.TypeOf(params["value"]).Kind() == reflect.Slice { + //指定In查询 + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]).Limit(pageSize, (page-1)*pageSize).Find(&m); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &m, nil + } else { + var query = fmt.Sprintf("%s =?", params["key"]) + err := Db.Where(query, params["value"]).Limit(pageSize, (page-1)*pageSize).Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } + + } +} diff --git a/db/db_user_public_platoon_settlement_records.go b/db/db_user_public_platoon_settlement_records.go new file mode 100644 index 0000000..399b21f --- /dev/null +++ b/db/db_user_public_platoon_settlement_records.go @@ -0,0 +1,117 @@ +package db + +import ( + "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model" + zhios_order_relate_utils "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils" + zhios_order_relate_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/logx" + "errors" + "fmt" + "reflect" + "xorm.io/xorm" +) + +// BatchSelectUserPublicPlatoonSettlementRecordss 批量查询数据 TODO::和下面的方法重复了，建议采用下面的 `UserPublicPlatoonSettlementRecordsFindByParams` 方法 +func BatchSelectUserPublicPlatoonSettlementRecordss(Db *xorm.Engine, params map[string]interface{}) (*[]model.UserPublicPlatoonSettlementRecords, error) { + var UserPublicPlatoonSettlementRecordsData []model.UserPublicPlatoonSettlementRecords + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]). + Find(&UserPublicPlatoonSettlementRecordsData); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &UserPublicPlatoonSettlementRecordsData, nil +} + +// UserPublicPlatoonSettlementRecordsInsert 插入单条数据 +func UserPublicPlatoonSettlementRecordsInsert(Db *xorm.Engine, UserPublicPlatoonSettlementRecords *model.UserPublicPlatoonSettlementRecords) (int64, error) { + _, err := Db.InsertOne(UserPublicPlatoonSettlementRecords) + if err != nil { + return 0, err + } + return UserPublicPlatoonSettlementRecords.Id, nil +} + +// BatchAddUserPublicPlatoonSettlementRecordss 批量新增数据 +func BatchAddUserPublicPlatoonSettlementRecordss(session *xorm.Session, UserPublicPlatoonSettlementRecordsData []*model.UserPublicPlatoonSettlementRecords) (int64, error) { + affected, err := session.Insert(UserPublicPlatoonSettlementRecordsData) + if err != nil { + return 0, err + } + return affected, nil +} + +func GetUserPublicPlatoonSettlementRecordsCount(Db *xorm.Engine) int { + var UserPublicPlatoonSettlementRecords model.UserPublicPlatoonSettlementRecords + session := Db.Where("") + count, err := session.Count(&UserPublicPlatoonSettlementRecords) + if err != nil { + return 0 + } + return int(count) +} + +// UserPublicPlatoonSettlementRecordsDelete 删除记录 +func UserPublicPlatoonSettlementRecordsDelete(Db *xorm.Engine, id interface{}) (int64, error) { + if reflect.TypeOf(id).Kind() == reflect.Slice { + return Db.In("id", id).Delete(model.UserPublicPlatoonSettlementRecords{}) + } else { + return Db.Where("id = ?", id).Delete(model.UserPublicPlatoonSettlementRecords{}) + } +} + +// UserPublicPlatoonSettlementRecordsUpdate 更新记录 +func UserPublicPlatoonSettlementRecordsUpdate(Db *xorm.Engine, id interface{}, UserPublicPlatoonSettlementRecords *model.UserPublicPlatoonSettlementRecords, forceColums ...string) (int64, error) { + var ( + affected int64 + err error + ) + if forceColums != nil { + affected, err = Db.Where("id=?", id).Cols(forceColums...).Update(UserPublicPlatoonSettlementRecords) + } else { + affected, err = Db.Where("id=?", id).Update(UserPublicPlatoonSettlementRecords) + } + if err != nil { + return 0, err + } + return affected, nil +} + +// UserPublicPlatoonSettlementRecordsGetOneByParams 通过传入的参数查询数据(单条) +func UserPublicPlatoonSettlementRecordsGetOneByParams(Db *xorm.Engine, params map[string]interface{}) (*model.UserPublicPlatoonSettlementRecords, error) { + var m model.UserPublicPlatoonSettlementRecords + var query = fmt.Sprintf("%s =?", params["key"]) + if has, err := Db.Where(query, params["value"]).Get(&m); err != nil || has == false { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil +} + +// UserPublicPlatoonSettlementRecordsFindByParams 通过传入的参数查询数据(多条) +func UserPublicPlatoonSettlementRecordsFindByParams(Db *xorm.Engine, params map[string]interface{}) (*[]model.UserPublicPlatoonSettlementRecords, error) { + var m []model.UserPublicPlatoonSettlementRecords + if params["value"] == nil { + return nil, errors.New("参数有误") + } + if params["key"] == nil { + //查询全部数据 + err := Db.Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } else { + if reflect.TypeOf(params["value"]).Kind() == reflect.Slice { + //指定In查询 + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]).Find(&m); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &m, nil + } else { + var query = fmt.Sprintf("%s =?", params["key"]) + err := Db.Where(query, params["value"]).Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } + + } +} diff --git a/db/db_user_public_platoon_system_punish_records.go b/db/db_user_public_platoon_system_punish_records.go new file mode 100644 index 0000000..f57f970 --- /dev/null +++ b/db/db_user_public_platoon_system_punish_records.go @@ -0,0 +1,117 @@ +package db + +import ( + "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model" + zhios_order_relate_utils "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils" + zhios_order_relate_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/logx" + "errors" + "fmt" + "reflect" + "xorm.io/xorm" +) + +// BatchSelectUserPublicPlatoonSystemPunishRecordss 批量查询数据 TODO::和下面的方法重复了，建议采用下面的 `UserPublicPlatoonSystemPunishRecordsFindByParams` 方法 +func BatchSelectUserPublicPlatoonSystemPunishRecordss(Db *xorm.Engine, params map[string]interface{}) (*[]model.UserPublicPlatoonSystemPunishRecords, error) { + var UserPublicPlatoonSystemPunishRecordsData []model.UserPublicPlatoonSystemPunishRecords + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]). + Find(&UserPublicPlatoonSystemPunishRecordsData); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &UserPublicPlatoonSystemPunishRecordsData, nil +} + +// UserPublicPlatoonSystemPunishRecordsInsert 插入单条数据 +func UserPublicPlatoonSystemPunishRecordsInsert(session *xorm.Session, UserPublicPlatoonSystemPunishRecords *model.UserPublicPlatoonSystemPunishRecords) (int64, error) { + _, err := session.InsertOne(UserPublicPlatoonSystemPunishRecords) + if err != nil { + return 0, err + } + return UserPublicPlatoonSystemPunishRecords.Id, nil +} + +// BatchAddUserPublicPlatoonSystemPunishRecords 批量新增数据 +func BatchAddUserPublicPlatoonSystemPunishRecords(session *xorm.Session, UserPublicPlatoonSystemPunishRecordsData []*model.UserPublicPlatoonSystemPunishRecords) (int64, error) { + affected, err := session.Insert(UserPublicPlatoonSystemPunishRecordsData) + if err != nil { + return 0, err + } + return affected, nil +} + +func GetUserPublicPlatoonSystemPunishRecordsCount(Db *xorm.Engine) int { + var UserPublicPlatoonSystemPunishRecords model.UserPublicPlatoonSystemPunishRecords + session := Db.Where("") + count, err := session.Count(&UserPublicPlatoonSystemPunishRecords) + if err != nil { + return 0 + } + return int(count) +} + +// UserPublicPlatoonSystemPunishRecordsDelete 删除记录 +func UserPublicPlatoonSystemPunishRecordsDelete(Db *xorm.Engine, id interface{}) (int64, error) { + if reflect.TypeOf(id).Kind() == reflect.Slice { + return Db.In("id", id).Delete(model.UserPublicPlatoonSystemPunishRecords{}) + } else { + return Db.Where("id = ?", id).Delete(model.UserPublicPlatoonSystemPunishRecords{}) + } +} + +// UserPublicPlatoonSystemPunishRecordsUpdate 更新记录 +func UserPublicPlatoonSystemPunishRecordsUpdate(Db *xorm.Engine, id interface{}, UserPublicPlatoonSystemPunishRecords *model.UserPublicPlatoonSystemPunishRecords, forceColums ...string) (int64, error) { + var ( + affected int64 + err error + ) + if forceColums != nil { + affected, err = Db.Where("id=?", id).Cols(forceColums...).Update(UserPublicPlatoonSystemPunishRecords) + } else { + affected, err = Db.Where("id=?", id).Update(UserPublicPlatoonSystemPunishRecords) + } + if err != nil { + return 0, err + } + return affected, nil +} + +// UserPublicPlatoonSystemPunishRecordsGetOneByParams 通过传入的参数查询数据(单条) +func UserPublicPlatoonSystemPunishRecordsGetOneByParams(Db *xorm.Engine, params map[string]interface{}) (*model.UserPublicPlatoonSystemPunishRecords, error) { + var m model.UserPublicPlatoonSystemPunishRecords + var query = fmt.Sprintf("%s =?", params["key"]) + if has, err := Db.Where(query, params["value"]).Get(&m); err != nil || has == false { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil +} + +// UserPublicPlatoonSystemPunishRecordsFindByParams 通过传入的参数查询数据(多条) +func UserPublicPlatoonSystemPunishRecordsFindByParams(Db *xorm.Engine, params map[string]interface{}) (*[]model.UserPublicPlatoonSystemPunishRecords, error) { + var m []model.UserPublicPlatoonSystemPunishRecords + if params["value"] == nil { + return nil, errors.New("参数有误") + } + if params["key"] == nil { + //查询全部数据 + err := Db.Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } else { + if reflect.TypeOf(params["value"]).Kind() == reflect.Slice { + //指定In查询 + if err := Db.In(zhios_order_relate_utils.AnyToString(params["key"]), params["value"]).Find(&m); err != nil { + return nil, zhios_order_relate_logx.Warn(err) + } + return &m, nil + } else { + var query = fmt.Sprintf("%s =?", params["key"]) + err := Db.Where(query, params["value"]).Find(&m) + if err != nil { + return nil, zhios_order_relate_logx.Error(err) + } + return &m, nil + } + + } +} diff --git a/db/model/user_public_platoon_amount.go b/db/model/user_public_platoon_amount.go new file mode 100644 index 0000000..ec3d8e0 --- /dev/null +++ b/db/model/user_public_platoon_amount.go @@ -0,0 +1,8 @@ +package model + +type UserPublicPlatoonAmount struct { + Id int64 `json:"id" xorm:"pk autoincr BIGINT(20)"` + Uid int `json:"uid" xorm:"unique(idx_uid_coin_id) INT(11)"` + CoinId int `json:"coin_id" xorm:"unique(idx_uid_coin_id) INT(11)"` + Amount string `json:"amount" xorm:"DECIMAL(16,6)"` +} diff --git a/db/model/user_public_platoon_relation.go b/db/model/user_public_platoon_relation.go index 23e4367..a93d666 100644 --- a/db/model/user_public_platoon_relation.go +++ b/db/model/user_public_platoon_relation.go @@ -5,15 +5,17 @@ import ( ) type UserPublicPlatoonRelation struct { - Id int `json:"id" xorm:"not null pk autoincr INT(11)"` - Uid int `json:"uid" xorm:"not null default 0 comment('用户id') unique INT(11)"` - FatherUid string `json:"father_uid" xorm:"not null default '' comment('父级id(123456-563464-438384)') index VARCHAR(100)"` - Pid int `json:"pid" xorm:"not null default 0 comment('父级id') INT(11)"` - RecommendUid int `json:"recommend_uid" xorm:"not null default 0 comment('推荐人id') INT(11)"` - Level int `json:"level" xorm:"not null default 1 comment('等级(整个系统)') INT(11)"` - Position int `json:"position" xorm:"not null default 1 comment('当前等级上位置') INT(11)"` - UniqueIdentifier string `json:"unique_identifier" xorm:"not null default '' comment('唯一标识符(uid-推荐人id-等级-位置)') unique CHAR(100)"` - ReturnCommissionNum int `json:"return_commission_num" xorm:"not null default 0 comment('返佣次数') INT(11)"` - CreateAt time.Time `json:"create_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` - UpdateAt time.Time `json:"update_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` + Id int `json:"id" xorm:"not null pk autoincr INT(11)"` + Uid int `json:"uid" xorm:"not null default 0 comment('用户id(若为-1,则代表等待新用户填充)') unique INT(11)"` + FatherUid string `json:"father_uid" xorm:"not null default '' comment('父级id(123456-563464-438384)') index VARCHAR(100)"` + Pid int `json:"pid" xorm:"not null default 0 comment('父级id') INT(11)"` + RecommendUid int `json:"recommend_uid" xorm:"not null default 0 comment('推荐人id') INT(11)"` + Level int `json:"level" xorm:"not null default 1 comment('等级(整个系统)') INT(11)"` + Position int `json:"position" xorm:"not null default 1 comment('位置') unique INT(11)"` + UniqueIdentifier string `json:"unique_identifier" xorm:"not null default '' comment('唯一标识符(父级id-uid-等级-位置)') unique CHAR(100)"` + ReturnCommissionNum int `json:"return_commission_num" xorm:"not null default 0 comment('返佣次数') INT(11)"` + JoinAt time.Time `json:"join_at" xorm:"not null default 'CURRENT_TIMESTAMP' comment('加入公排时间') DATETIME"` + WaitForSettlementDate string `json:"wait_for_settlement_date" xorm:"not null default '' comment('待结算时间(0000-00)') CHAR(50)"` + CreateAt time.Time `json:"create_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` + UpdateAt time.Time `json:"update_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` } diff --git a/db/model/user_public_platoon_settlement_records.go b/db/model/user_public_platoon_settlement_records.go new file mode 100644 index 0000000..83cc239 --- /dev/null +++ b/db/model/user_public_platoon_settlement_records.go @@ -0,0 +1,17 @@ +package model + +import ( + "time" +) + +type UserPublicPlatoonSettlementRecords struct { + Id int64 `json:"id" xorm:"pk autoincr BIGINT(20)"` + Uid int `json:"uid" xorm:"not null comment('用户id') index INT(11)"` + CoinId int `json:"coin_id" xorm:"not null default 0 comment('虚拟币id(0为金额)') INT(11)"` + Amount string `json:"amount" xorm:"not null default '' comment('结算金额') VARCHAR(50)"` + Title string `json:"title" xorm:"comment('标题') VARCHAR(255)"` + Date string `json:"date" xorm:"not null default '' comment('结算日期(0000-00)') VARCHAR(50)"` + Kind int `json:"kind" xorm:"not null default 1 comment('结算种类(1:转入用户余额 2:清零)') TINYINT(1)"` + CreateAt time.Time `json:"create_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` + UpdateAt time.Time `json:"update_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` +} diff --git a/db/model/user_public_platoon_system_punish_records.go b/db/model/user_public_platoon_system_punish_records.go new file mode 100644 index 0000000..26ea145 --- /dev/null +++ b/db/model/user_public_platoon_system_punish_records.go @@ -0,0 +1,17 @@ +package model + +import ( + "time" +) + +type UserPublicPlatoonSystemPunishRecords struct { + Id int64 `json:"id" xorm:"pk autoincr BIGINT(20)"` + Uid int `json:"uid" xorm:"not null comment('用户id') index INT(11)"` + OldPostion int `json:"old_postion" xorm:"not null default 0 comment('位置(旧)') INT(11)"` + NewPostion int `json:"new_postion" xorm:"not null default 0 comment('位置(新)') INT(11)"` + Date string `json:"date" xorm:"not null default '' comment('日期(0000-00)') VARCHAR(50)"` + Title string `json:"title" xorm:"not null default '' comment('标题') VARCHAR(100)"` + Reason string `json:"reason" xorm:"not null default '' comment('原因') VARCHAR(255)"` + CreateAt time.Time `json:"create_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` + UpdateAt time.Time `json:"update_at" xorm:"not null default 'CURRENT_TIMESTAMP' DATETIME"` +} diff --git a/rule/public_platoon_relate_commission.go b/rule/public_platoon_relate_commission.go index 939e693..a040605 100644 --- a/rule/public_platoon_relate_commission.go +++ b/rule/public_platoon_relate_commission.go @@ -73,17 +73,29 @@ func BatchGetPublicPlatoonRelateCommissionByOrder(engine *xorm.Engine, masterId if userPublicPlatoonRelation == nil { return nil, errors.New("未查询到公排关系记录") } - fatherUids := strings.Split(userPublicPlatoonRelation.FatherUid, "-") + fatherPositions := strings.Split(userPublicPlatoonRelation.FatherUid, "-") + var fatherPosition string userPublicPlatoonRelation.ReturnCommissionNum++ remainder := (userPublicPlatoonRelation.ReturnCommissionNum) % userPublicPlatoonSetting.SeveralRows if remainder == 0 { - nowBenefitUid = fatherUids[userPublicPlatoonSetting.SeveralRows-1] + fatherPosition = fatherPositions[userPublicPlatoonSetting.SeveralRows-1] } else { - nowBenefitUid = fatherUids[remainder-1] + fatherPosition = fatherPositions[remainder-1] } + nowBenefitUsers, err := db.UserPublicPlatoonRelationGetOneByParams(engine, map[string]interface{}{ + "key": "position", + "value": fatherPosition, + }) + if err != nil { + return nil, err + } + if nowBenefitUsers == nil { + return nil, errors.New("未查询到父级公排关系记录") + } + nowBenefitUid = zhios_order_relate_utils.AnyToString(nowBenefitUsers.Uid) //TODO::更新 公排关系记录 中 `return_commission_num` - affected, err := db.UserPublicPlatoonRelationUpdate(engine, userPublicPlatoonRelation.Id, userPublicPlatoonRelation, "return_commission_num") + affected, err := db.UserPublicPlatoonRelationUpdate(engine.NewSession(), userPublicPlatoonRelation.Id, userPublicPlatoonRelation, "return_commission_num") if err != nil { return nil, err } @@ -116,6 +128,28 @@ func AddPublicPlatoonRelateCommission(engine *xorm.Engine, masterId string, AddP return nil, err } for _, param := range AddPublicPlatoonRelateCommissionReqList { + //TODO::判断是否有uid为-1 (代表等待新用户填充) 的记录 + userPublicPlatoonRelation, err := db.UserPublicPlatoonRelationGetOneByParams(engine, map[string]interface{}{ + "key": "uid", + "value": -1, + }) + if err != nil { + return nil, err + } + if userPublicPlatoonRelation != nil { + userPublicPlatoonRelation.Uid = zhios_order_relate_utils.StrToInt(param.Uid) + updateAffected, err := db.UserPublicPlatoonRelationUpdate(engine.NewSession(), userPublicPlatoonRelation.Id, userPublicPlatoonRelation) + if err != nil { + return nil, err + } + if updateAffected == 0 { + err = errors.New("更新 user_public_platoon_relation 记录失败") + return nil, err + } else { + resp[param.Uid] = userPublicPlatoonRelation + } + continue + } res, err := publicPlatoon(engine, zhios_order_relate_utils.StrToInt(param.Uid), zhios_order_relate_utils.StrToInt(param.RecommendUid), *userPublicPlatoonSetting) if err != nil { return nil, err @@ -154,9 +188,14 @@ func publicPlatoon(engine *xorm.Engine, uid, recommendUid int, userPublicPlatoon var fatherUid string if m1.FatherUid == "" { //TODO::顶级 - fatherUid = zhios_order_relate_utils.IntToStr(m1.Uid) + fatherUid = zhios_order_relate_utils.IntToStr(m1.Position) } else { - fatherUid = zhios_order_relate_utils.IntToStr(m1.Uid) + "-" + m1.FatherUid + fatherUids := strings.Split(m1.FatherUid, "-") + if len(fatherUids) > userPublicPlatoonSetting.SeveralRows { + fatherUid = zhios_order_relate_utils.IntToStr(m1.Position) + "-" + strings.Join(fatherUids[0:userPublicPlatoonSetting.SeveralRows:len(fatherUids)], "-") + } else { + fatherUid = zhios_order_relate_utils.IntToStr(m1.Position) + "-" + m1.FatherUid + } } //唯一标识符(父级id-uid-等级-位置) @@ -171,6 +210,8 @@ func publicPlatoon(engine *xorm.Engine, uid, recommendUid int, userPublicPlatoon userPublicPlatoonRelation.Level = int(level) userPublicPlatoonRelation.Position = position userPublicPlatoonRelation.UniqueIdentifier = uniqueIdentifier + userPublicPlatoonRelation.WaitForSettlementDate = now.AddDate(0, 0, 30).Format("2006-01-02") + userPublicPlatoonRelation.JoinAt = now userPublicPlatoonRelation.CreateAt = now userPublicPlatoonRelation.UpdateAt = now _, err := db.UserPublicPlatoonRelationInsert(engine, &userPublicPlatoonRelation) @@ -208,3 +249,174 @@ func makeSearchPid(position int, row int) (pid int) { } } } + +// FindWaitForDealUsers 查询待处理的用户 +func FindWaitForDealUsers(engine *xorm.Engine, page, pageSize int) (err error, resp []int) { + now := time.Now().Format("2006-01-02") + lists, err := db.UserPublicPlatoonRelationFindByParamsByPage(engine, map[string]interface{}{ + "wait_for_settlement_date": now, + }, page, pageSize) + if err != nil { + return + } + for _, list := range *lists { + resp = append(resp, list.Uid) + } + return +} + +// UpdateWaitForSettlementDate 改变 `wait_for_settlement_date` 待结算时间 +func UpdateWaitForSettlementDate(engine *xorm.Engine, userIds []string) (err error) { + //Todo:: 将 user_public_platoon_relation 中 wait_for_settlement_date 设置为 30天后 + sql := "update user_public_platoon_amount set wait_for_settlement_date = ? where uid in (" + strings.Join(userIds, ",") + ")" + waitForSettlementDate := time.Now().AddDate(0, 0, 30).Format("2006-01-02") + _, err = engine.Exec(sql, waitForSettlementDate) + if err != nil { + return + } + return +} + +// DealCommonWealthReward 处理共富奖励 +func DealCommonWealthReward(engine *xorm.Engine, uid int, isCompleteReward bool) (err error, resp []map[string]string) { + session := engine.NewSession() + defer func() { + session.Close() + if err := recover(); err != nil { + _ = zhios_order_relate_logx.Error(err) + } + }() + + //1、查询出 `user_public_platoon_amount` 中相关记录 + params, err := db.UserPublicPlatoonAmountFindByParams(engine, map[string]interface{}{ + "key": "uid", + "value": uid, + }) + if err != nil { + _ = session.Rollback() + return + } + + //2、完成共富奖励(插入 user_public_platoon_settlement_records 记录) && 构造返回数据 + var userPublicPlatoonSettlementRecords []*model.UserPublicPlatoonSettlementRecords + now := time.Now() + for _, param := range *params { + var userPublicPlatoonSettlementRecord = model.UserPublicPlatoonSettlementRecords{ + Uid: param.Uid, + CoinId: param.CoinId, + Amount: param.Amount, + Title: "结算共富奖励", + Date: now.AddDate(0, 0, 30).Format("2006-01-02"), + CreateAt: now, + UpdateAt: now, + } + if isCompleteReward { + userPublicPlatoonSettlementRecord.Kind = 1 + resp = append(resp, map[string]string{ + zhios_order_relate_utils.AnyToString(param.CoinId): param.Amount, + }) + } else { + userPublicPlatoonSettlementRecord.Kind = 2 + } + if zhios_order_relate_utils.StrToFloat64(userPublicPlatoonSettlementRecord.Amount) > 0 { + userPublicPlatoonSettlementRecords = append(userPublicPlatoonSettlementRecords, &userPublicPlatoonSettlementRecord) + } + } + affected, err := db.BatchAddUserPublicPlatoonSettlementRecordss(session, userPublicPlatoonSettlementRecords) + if err != nil { + _ = session.Rollback() + return + } + if affected == 0 { + err = errors.New("插入 user_public_platoon_settlement_records 记录失败") + _ = session.Rollback() + return + } + + //3、将 user_public_platoon_amount 相关记录的 amount 置 0 + sql := "update user_public_platoon_amount set amount = ? where uid = ?" + _, err = session.Exec(sql, 0, uid) + if err != nil { + _ = session.Rollback() + return + } + err = session.Commit() + return +} + +// DealCommonWealthPunish 处理共富处罚 +func DealCommonWealthPunish(engine *xorm.Engine, uid int, 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) + } + }() + //1、查找 `user_public_platoon_setting` 基础设置 + userPublicPlatoonSetting, err := db.UserPublicPlatoonSettingGetOneByParams(engine, map[string]interface{}{ + "key": "is_open", + "value": 1, + }) + if err != nil { + _ = session.Rollback() + return + } + + //2、查询出 `user_public_platoon_relation` 中相关记录 && 将该记录的uid置为 -1 + params, err := db.UserPublicPlatoonRelationGetOneByParams(engine, map[string]interface{}{ + "key": "uid", + "value": uid, + }) + if err != nil { + _ = session.Rollback() + return + } + if params == nil { + err = errors.New("未查询到公排关系记录") + _ = session.Rollback() + } + params.Uid = -1 + updateAffected, err := db.UserPublicPlatoonRelationUpdate(session, params.Id, params) + if err != nil { + _ = session.Rollback() + return + } + if updateAffected == 0 { + err = errors.New("更新 user_public_platoon_relation 记录失败") + _ = session.Rollback() + return + } + + //3、新增一条 `user_public_platoon_relation` 记录 + res, err := publicPlatoon(engine, params.Uid, params.RecommendUid, *userPublicPlatoonSetting) + if err != nil { + _ = session.Rollback() + return + } + + //4、新增一条 `user_public_platoon_system_punish_records` 记录 + now := time.Now() + insertAffected, err := db.UserPublicPlatoonSystemPunishRecordsInsert(session, &model.UserPublicPlatoonSystemPunishRecords{ + Uid: params.Uid, + OldPostion: params.Position, + NewPostion: res.Position, + Date: now.AddDate(0, 0, 30).Format("2006-01-02"), + Title: "共富收益-系统处罚记录", + Reason: reason, + CreateAt: now, + UpdateAt: now, + }) + if err != nil { + _ = session.Rollback() + return + } + if insertAffected == 0 { + err = errors.New("新增 user_public_platoon_system_punish_records 记录失败") + _ = session.Rollback() + return + } + + err = session.Commit() + return +} diff --git a/utils/convert.go b/utils/convert.go index 44a9bb5..28caca4 100644 --- a/utils/convert.go +++ b/utils/convert.go @@ -276,6 +276,15 @@ func Float64ToStr(f float64) string { func Float64ToStrPrec1(f float64) string { return strconv.FormatFloat(f, 'f', 1, 64) } + +func Float64ToStrPrec4(f float64) string { + return strconv.FormatFloat(f, 'f', 4, 64) +} + +func Float64ToStrPrec6(f float64) string { + return strconv.FormatFloat(f, 'f', 6, 64) +} + func Float64ToStrByPrec(f float64, prec int) string { return strconv.FormatFloat(f, 'f', prec, 64) }