共创用户列表 明细修改

@@ -225,7 +225,7 @@ func (dao *CooperationContractDao) Find(queryOptions map[string]interface{}) (in
 		var cooperationContractRelevantModels []*models.CooperationContractRelevant
 		var cooperationContractRelevantModels []*models.CooperationContractRelevant
 		if cooperationContract, err := transform.TransformToCooperationContractDomainModelFromPgModels(
 		if cooperationContract, err := transform.TransformToCooperationContractDomainModelFromPgModels(
 			cooperationContractModel,
 			cooperationContractModel,
-			&models.CooperationMode{},
+			&models.CooperationMode{CooperationModeNumber: cooperationContractModel.CooperationModeNumber},
 			dividendsIncentivesRuleModels,
 			dividendsIncentivesRuleModels,
 			moneyIncentivesRuleModels,
 			moneyIncentivesRuleModels,
 			cooperationContractRelevantModels,
 			cooperationContractRelevantModels,

@@ -39,6 +39,14 @@ func (repository *CooperationContractUndertakerDao) Find(queryOptions map[string
 			return query, nil
 			return query, nil
 		})
 		})
 	}
 	}
+	if userId, ok := queryOptions["userId"]; ok && userId.(int64) != 0 {
+		query.WhereGroup(func(query *orm.Query) (*orm.Query, error) {
+			query.WhereOr("user_id = ? ", userId)
+			query.WhereOr("referrer->>'userId' = '?' ", userId)
+			query.WhereOr("salesman->>'userId' = '?' ", userId)
+			return query, nil
+		})
+	}
 	offsetLimitFlag := true
 	offsetLimitFlag := true
 	if offsetLimit, ok := queryOptions["offsetLimit"]; ok {
 	if offsetLimit, ok := queryOptions["offsetLimit"]; ok {
 		offsetLimitFlag = offsetLimit.(bool)
 		offsetLimitFlag = offsetLimit.(bool)

@@ -312,12 +312,14 @@ func (ptr *CooperationStatisticsService) CompanyCooperationUsersStatistics(query
 
 
 	userService, _ := NewUserService()
 	userService, _ := NewUserService()
 
 
+	contractUndertakerDao, _ := dao.NewCooperationContractUndertakerDao(ptr.transactionContext)
+	dividendsOrderDao, _ := dao.NewDividendsOrderDao(ptr.transactionContext)
 	var retMap = make([]interface{}, 0)
 	var retMap = make([]interface{}, 0)
 	for i := range responses {
 	for i := range responses {
 		responses[i].CooperationTime = time.Now().Unix() * 1000
 		responses[i].CooperationTime = time.Now().Unix() * 1000
 
 
 		item := map[string]interface{}{
 		item := map[string]interface{}{
-			"dividendsOrderAmount": responses[i].DividendsOrderAmount,
+			"dividendsOrderAmount": 0,
 			"actuallyPaidAmount":   responses[i].ActuallyPaidAmount,
 			"actuallyPaidAmount":   responses[i].ActuallyPaidAmount,
 			"unPaidAmount":         responses[i].UnPaidAmount,
 			"unPaidAmount":         responses[i].UnPaidAmount,
 			"cooperationTime":      time.Now().Unix() * 1000,
 			"cooperationTime":      time.Now().Unix() * 1000,
@@ -337,6 +339,16 @@ func (ptr *CooperationStatisticsService) CompanyCooperationUsersStatistics(query
 				},
 				},
 			}
 			}
 		}
 		}
+		// 订单金额
+		_, contracts, _ := contractUndertakerDao.Find(map[string]interface{}{"orgId": request.OrgId, "userId": responses[i].UserId})
+		var contractsNumbers []string
+		for i := range contracts {
+			contractsNumbers = append(contractsNumbers, contracts[i].CooperationContractNumber)
+		}
+		if len(contractsNumbers) > 0 {
+			item["dividendsOrderAmount"], _ = dividendsOrderDao.CalculateGoodOrderAmount(map[string]interface{}{"orgId": request.OrgId, "cooperationContractNumbers": contractsNumbers})
+		}
+
 		retMap = append(retMap, item)
 		retMap = append(retMap, item)
 	}
 	}
 
 
@@ -367,63 +379,208 @@ func (ptr *CooperationStatisticsService) CooperationUserModeStatistics(queryOpti
 	}
 	}
 	queryOptions = tool_funs.SimpleStructToMap(&request)
 	queryOptions = tool_funs.SimpleStructToMap(&request)
 
 
-	orderGoodDao, _ := dao.NewOrderGoodDao(ptr.transactionContext)
-	modeStatistics, err := orderGoodDao.CooperationUserModeStatistics(queryOptions)
-	if err != nil {
-		return nil, err
+	contractUndertakerDao, _ := dao.NewCooperationContractUndertakerDao(ptr.transactionContext)
+	contractDao, _ := dao.NewCooperationContractDao(ptr.transactionContext)
+	cooperationModeRepository, _ := repository.NewCooperationModeRepository(ptr.transactionContext)
+
+	// 1.查询承接的合约
+	_, contractUndertakers, _ := contractUndertakerDao.Find(map[string]interface{}{"orgId": request.OrgId, "userId": request.UserId})
+	var contractsNumbers []string
+	for i := range contractUndertakers {
+		contractsNumbers = append(contractsNumbers, contractUndertakers[i].CooperationContractNumber)
 	}
 	}
-	if len(modeStatistics) == 0 {
+	if len(contractsNumbers) == 0 {
+		return struct{}{}, nil
+	}
+	_, contracts, _ := contractDao.Find(map[string]interface{}{"orgId": request.OrgId, "cooperationContractNumbers": contractsNumbers})
+	if len(contracts) == 0 {
 		return struct{}{}, nil
 		return struct{}{}, nil
 	}
 	}
 
 
 	var modeNumbers []string
 	var modeNumbers []string
-	var mapModeStatistics = make(map[string]*domain.CooperationModeStatisticsDto)
-	for i := range modeStatistics {
-		mapModeStatistics[modeStatistics[i].CooperationModeNumber] = modeStatistics[i]
-		modeNumbers = append(modeNumbers, modeStatistics[i].CooperationModeNumber)
+	for i := range contracts {
+		modeNumbers = append(modeNumbers, contracts[i].CooperationMode.CooperationModeNumber)
+	}
+	// 2.查询模式
+	_, modes, _ := cooperationModeRepository.Find(map[string]interface{}{"orgId": request.OrgId, "cooperationModeNumbers": modeNumbers})
+	if len(modes) == 0 {
+		return struct{}{}, nil
+	}
+	var mapMode = make(map[string]*domain.CooperationMode)
+	var mapModeContracts = make(map[string][]string)
+	var cooperationTypes []interface{}
+	for i := range modes {
+		mapMode[modes[i].CooperationModeNumber] = modes[i]
+		mapModeContracts[modes[i].CooperationModeNumber] = make([]string, 0)
+		cooperationTypes = append(cooperationTypes, map[string]interface{}{
+			"cooperationModeId":     modes[i].CooperationModeId,
+			"cooperationModeName":   modes[i].CooperationModeName,
+			"cooperationModeNumber": modes[i].CooperationModeNumber,
+		})
+	}
+	for i := range contracts {
+		key := contracts[i].CooperationMode.CooperationModeNumber
+		if _, ok := mapMode[key]; ok {
+			mapModeContracts[key] = append(mapModeContracts[key], contracts[i].CooperationContractNumber)
+		}
 	}
 	}
 
 
-	cooperationModeRepository, _ := repository.NewCooperationModeRepository(ptr.transactionContext)
-	_, cooperModes, err := cooperationModeRepository.Find(map[string]interface{}{"cooperationModeNumbers": modeNumbers, "orgId": request.OrgId})
+	// 3.分红支出
+	dividendsDetails, err := ptr.userModeDividend(request.OrgId, mapMode, mapModeContracts)
+	if err != nil {
+		return nil, err
+	}
+	// 4.成交订单
+	orderDetails, err := ptr.userModeOrder(request.OrgId, mapMode, mapModeContracts)
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
-	var cooperationTypes, dividendsExpenseByTypes, orderAmountByTypes []interface{}
-	var totalOrderAmount float64
-	var totalDividendAmount float64
-	for i := range cooperModes {
-		m := cooperModes[i]
-		if modeStatistics, ok := mapModeStatistics[m.CooperationModeNumber]; ok {
-			totalOrderAmount += modeStatistics.OrderAmount
-			totalDividendAmount += modeStatistics.DividendsEstimate
-			dividendsExpenseByTypes = append(dividendsExpenseByTypes, map[string]interface{}{
-				"dividendsTypeName": m.CooperationModeName + "分红支出",
-				"dividendsExpense":  modeStatistics.DividendsEstimate, //实际已支付金额
-			})
-			orderAmountByTypes = append(orderAmountByTypes, map[string]interface{}{
-				"orderAmount":   modeStatistics.OrderAmount,
-				"orderTypeName": m.CooperationModeName + "成交订单",
-			})
+	return map[string]interface{}{
+		"cooperationTypes": cooperationTypes,
+		"dividendsDetails": dividendsDetails,
+		"orderDetails":     orderDetails,
+	}, nil
+}
+
+// 用户模式分红
+func (ptr *CooperationStatisticsService) userModeDividend(orgId int64, mapMode map[string]*domain.CooperationMode, mapModeContracts map[string][]string) (interface{}, error) {
+	creditAccountDao, _ := dao.NewCreditAccountDao(ptr.transactionContext)
+	var dividends dividendsExpenseByTypes = make([]dividendsExpenseByType, 0)
+	var total float64 = 0
+	for _, v := range mapMode {
+		numbers := mapModeContracts[v.CooperationModeNumber]
+		var dividendsEstimate = &CreditAccountStatisticsResponse{}
+		err := creditAccountDao.DividendsStatistics(map[string]interface{}{"orgId": orgId, "cooperationContractNumbers": numbers}, dividendsEstimate)
+		if err != nil {
+			return nil, err
+		}
+		dividends = append(dividends, dividendsExpenseByType{
+			DividendsTypeName: v.CooperationModeName + "分红支出",
+			DividendsExpense:  dividendsEstimate.Paid, //实际已支付金额
+		})
+		total += dividendsEstimate.Paid
+	}
+	return map[string]interface{}{
+		"dividendsExpense":        total,
+		"dividendsExpenseByTypes": dividends,
+	}, nil
+}
+
+// 用户模式订单
+func (ptr *CooperationStatisticsService) userModeOrder(orgId int64, mapMode map[string]*domain.CooperationMode, mapModeContracts map[string][]string) (interface{}, error) {
+	creditAccountDao, _ := dao.NewDividendsOrderDao(ptr.transactionContext)
+	var dividends orderAmountByTypes = make([]orderAmountByType, 0)
+	var total float64 = 0
+	for _, v := range mapMode {
+		numbers := mapModeContracts[v.CooperationModeNumber]
+		amount, err := creditAccountDao.CalculateGoodOrderAmount(map[string]interface{}{"orgId": orgId, "cooperationContractNumbers": numbers})
+		if err != nil {
+			return nil, err
 		}
 		}
-		cooperationTypes = append(cooperationTypes, map[string]interface{}{
-			"cooperationModeId":     m.CooperationModeId,
-			"cooperationModeName":   m.CooperationModeName,
-			"cooperationModeNumber": m.CooperationModeNumber,
+		dividends = append(dividends, orderAmountByType{
+			OrderAmount:   amount,
+			OrderTypeName: v.CooperationModeName + "成交订单",
 		})
 		})
+		total += amount
 	}
 	}
 	return map[string]interface{}{
 	return map[string]interface{}{
-		"cooperationTypes": cooperationTypes,
-		"dividendsDetails": map[string]interface{}{
-			"dividendsExpense":        totalDividendAmount,
-			"dividendsExpenseByTypes": dividendsExpenseByTypes,
-		},
-		"orderDetails": map[string]interface{}{
-			"orderAmount":        totalOrderAmount,
-			"orderAmountByTypes": orderAmountByTypes,
-		},
+		"orderAmount":        total,
+		"orderAmountByTypes": dividends,
 	}, nil
 	}, nil
 }
 }
 
 
+// 公司 - 共创用户模式统计
+func (ptr *CooperationStatisticsService) CooperationUserModeStatisticsBak(queryOptions map[string]interface{}) (interface{}, error) {
+	// 参数验证
+	//var request = struct {
+	//	UserId int64 `json:"userId" valid:"Required"`
+	//	OrgId  int64 `json:"orgId" valid:"Required"`
+	//}{}
+	//if err := LoadQueryObject(queryOptions, &request); err != nil {
+	//	return nil, err
+	//}
+	//queryOptions = tool_funs.SimpleStructToMap(&request)
+	//
+	//orderGoodDao, _ := dao.NewOrderGoodDao(ptr.transactionContext)
+	//modeStatistics, err := orderGoodDao.CooperationUserModeStatistics(queryOptions)
+	//if err != nil {
+	//	return nil, err
+	//}
+	//if len(modeStatistics) == 0 {
+	//	return struct{}{}, nil
+	//}
+	//
+	//var modeNumbers []string
+	//var mapModeStatistics = make(map[string]*domain.CooperationModeStatisticsDto)
+	//for i := range modeStatistics {
+	//	mapModeStatistics[modeStatistics[i].CooperationModeNumber] = modeStatistics[i]
+	//	modeNumbers = append(modeNumbers, modeStatistics[i].CooperationModeNumber)
+	//}
+	//
+	//cooperationModeRepository, _ := repository.NewCooperationModeRepository(ptr.transactionContext)
+	//_, cooperModes, err := cooperationModeRepository.Find(map[string]interface{}{"cooperationModeNumbers": modeNumbers, "orgId": request.OrgId})
+	//if err != nil {
+	//	return nil, err
+	//}
+	//var cooperationTypes, dividendsExpenseByTypes, orderAmountByTypes []interface{}
+	//var totalOrderAmount float64
+	//var totalDividendAmount float64
+	//for i := range cooperModes {
+	//	m := cooperModes[i]
+	//	if modeStatistics, ok := mapModeStatistics[m.CooperationModeNumber]; ok {
+	//		totalOrderAmount += modeStatistics.OrderAmount
+	//		totalDividendAmount += modeStatistics.DividendsEstimate
+	//		dividendsExpenseByTypes = append(dividendsExpenseByTypes, map[string]interface{}{
+	//			"dividendsTypeName": m.CooperationModeName + "分红支出",
+	//			"dividendsExpense":  modeStatistics.DividendsEstimate, //实际已支付金额
+	//		})
+	//		orderAmountByTypes = append(orderAmountByTypes, map[string]interface{}{
+	//			"orderAmount":   modeStatistics.OrderAmount,
+	//			"orderTypeName": m.CooperationModeName + "成交订单",
+	//		})
+	//	}
+	//	cooperationTypes = append(cooperationTypes, map[string]interface{}{
+	//		"cooperationModeId":     m.CooperationModeId,
+	//		"cooperationModeName":   m.CooperationModeName,
+	//		"cooperationModeNumber": m.CooperationModeNumber,
+	//	})
+	//}
+	//return map[string]interface{}{
+	//	"cooperationTypes": cooperationTypes,
+	//	"dividendsDetails": map[string]interface{}{
+	//		"dividendsExpense":        totalDividendAmount,
+	//		"dividendsExpenseByTypes": dividendsExpenseByTypes,
+	//	},
+	//	"orderDetails": map[string]interface{}{
+	//		"orderAmount":        totalOrderAmount,
+	//		"orderAmountByTypes": orderAmountByTypes,
+	//	},
+	//}, nil
+	return nil, nil
+}
+
+type dividendsExpenseByType struct {
+	DividendsTypeName string  `json:"dividendsTypeName"`
+	DividendsExpense  float64 `json:"dividendsExpense"`
+}
+type orderAmountByType struct {
+	OrderTypeName string  `json:"orderTypeName"`
+	OrderAmount   float64 `json:"orderAmount"`
+}
+type dividendsExpenseByTypes []dividendsExpenseByType
+
+func (s dividendsExpenseByTypes) Len() int { return len(s) }
+func (s dividendsExpenseByTypes) Less(i, j int) bool {
+	return s[i].DividendsExpense < s[j].DividendsExpense
+}
+func (s dividendsExpenseByTypes) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+type orderAmountByTypes []orderAmountByType
+
+func (s orderAmountByTypes) Len() int           { return len(s) }
+func (s orderAmountByTypes) Less(i, j int) bool { return s[i].OrderAmount < s[j].OrderAmount }
+func (s orderAmountByTypes) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
 // 公司 - 共创用户分红支付统计
 // 公司 - 共创用户分红支付统计
 func (ptr *CooperationStatisticsService) CompanyPaymentHistoryStatistics(queryOptions map[string]interface{}) (interface{}, error) {
 func (ptr *CooperationStatisticsService) CompanyPaymentHistoryStatistics(queryOptions map[string]interface{}) (interface{}, error) {
 	// 参数验证
 	// 参数验证