func NewFeatureBeDao()

in module/feature_be_dao.go [65:198]
127 lines of code
23 McCabe index (conditional complexity)

func NewFeatureBeDao(config recconf.FeatureDaoConfig) *FeatureBeDao {
	var rtCntWins []int
	if config.FeatureType == Feature_Type_RT_Cnt {
		rtCntWinToks := strings.Split(config.RTCntWins, ",")
		for _, winTok := range rtCntWinToks {
			tWin := utils.ToInt(winTok, -1)
			if tWin <= 0 {
				log.Error(fmt.Sprintf("invalid rtCntWins: %s", winTok))
				return nil
			}
			rtCntWins = append(rtCntWins, tWin)
		}
	}
	var beRTCntFields []RTCntField
	var outRTCntFieldAlias []string
	if config.FeatureType == Feature_Type_RT_Cnt {
		if len(config.BeRTCntFieldInfo) > 0 {
			for fieldId, fieldInfo := range config.BeRTCntFieldInfo {
				tmpToks := fieldInfo.FieldNames
				for tid := range tmpToks {
					tmpToks[tid] = strings.TrimSpace(tmpToks[tid])
				}
				var delimToks []string
				if len(fieldInfo.Delims) > 0 {
					delimToks = fieldInfo.Delims
				} else {
					for i := 0; i < len(tmpToks); i++ {
						delimToks = append(delimToks, "")
					}
				}
				if len(delimToks) != len(tmpToks) {
					log.Error(fmt.Sprintf("len(fieldToks) != len(delimToks): %d vs %d, fieldId=%d, fieldTok=%s, delimStr=%s",
						len(tmpToks), len(delimToks), fieldId,
						strings.Join(fieldInfo.FieldNames, ":"),
						strings.Join(fieldInfo.Delims, ":")))
					return nil
				}
				beRTCntFields = append(beRTCntFields,
					RTCntField{tmpToks, delimToks})
				tmpAlias := strings.TrimSpace(fieldInfo.Alias)
				if len(tmpAlias) == 0 {
					tmpAlias = tmpToks[0]
				}
				outRTCntFieldAlias = append(outRTCntFieldAlias, tmpAlias)
			}
		} else { // [deprecicated], to be compatible with existing config
			rtCntFields := strings.Split(config.BeRTCntFields, ",")
			for _, fieldTok := range rtCntFields {
				tmpToks := strings.Split(fieldTok, ":")
				for tid := range tmpToks {
					tmpToks[tid] = strings.TrimSpace(tmpToks[tid])
				}
				delimToks := make([]string, len(tmpToks))
				beRTCntFields = append(beRTCntFields, RTCntField{tmpToks, delimToks})
			}
			tAliasArr := strings.Split(config.OutRTCntFieldAlias, ",")
			for _, tmpAlias := range tAliasArr {
				outRTCntFieldAlias = append(outRTCntFieldAlias,
					strings.TrimSpace(tmpAlias))
			}
			if len(beRTCntFields) != len(outRTCntFieldAlias) {
				log.Error(fmt.Sprintf("len(beRTCntFields) != len(outRTCntFieldAlias): %d vs %d", len(beRTCntFields), len(outRTCntFieldAlias)))
				return nil
			}
		}
	}

	dao := &FeatureBeDao{
		FeatureBaseDao:            NewFeatureBaseDao(&config),
		bizName:                   config.BizName,
		beRecallName:              "sequence_feature",
		userFeatureKeyName:        config.UserFeatureKeyName,
		itemFeatureKeyName:        config.ItemFeatureKeyName,
		timestampFeatureKeyName:   config.TimestampFeatureKeyName,
		eventFeatureKeyName:       config.EventFeatureKeyName,
		playTimeFeatureKeyName:    config.PlayTimeFeatureKeyName,
		tsFeatureKeyName:          config.TsFeatureKeyName,
		hasPlayTimeField:          true,
		beItemFeatureKeyName:      config.BeItemFeatureKeyName,
		beTimestampFeatureKeyName: config.BeTimestampFeatureKeyName,
		beEventFeatureKeyName:     config.BeEventFeatureKeyName,
		bePlayTimeFeatureKeyName:  config.BePlayTimeFeatureKeyName,

		beIsHomeField: strings.TrimSpace(config.BeIsHomeField),
		beRTCntFields: beRTCntFields,
		beRTTable:     strings.TrimSpace(config.BeRTTable),

		rtCntWins:     rtCntWins,
		rtCntMaxKey:   utils.ToInt(config.RTCntMaxKey, 100),
		rtCntWinDelay: utils.ToInt64(config.RTCntWinDelay, 5),

		outRTCntFeaPattern:     strings.TrimSpace(config.OutRTCntFeaPattern),
		outHomeRTCntFeaPattern: strings.TrimSpace(config.OutHomeRTCntFeaPattern),
		outRTCntWinNames:       strings.Split(config.OutRTCntWinNames, ","),
		outRTCntFieldAlias:     outRTCntFieldAlias,
		outEventName:           strings.TrimSpace(config.OutEventName),
	}
	if config.BeRecallName != "" {
		dao.beRecallName = config.BeRecallName
	}

	if dao.featureType == Feature_Type_RT_Cnt {
		for tid := range dao.outRTCntWinNames {
			dao.outRTCntWinNames[tid] = strings.TrimSpace(
				dao.outRTCntWinNames[tid])
		}

		if len(dao.rtCntWins) != len(dao.outRTCntWinNames) {
			log.Error(fmt.Sprintf("len(rtCntWins)[%d] != len(outRTCntWinNames)[%d]",
				len(dao.rtCntWins), len(dao.outRTCntWinNames)))
			return nil
		}
		if len(dao.beRTCntFields) != len(dao.outRTCntFieldAlias) {
			log.Error(fmt.Sprintf("len(beRTCntFields)[%d] != len(outRTCntFieldAlias)[%d]",
				len(dao.beRTCntFields), len(dao.outRTCntFieldAlias)))
			return nil
		}
		log.Info(fmt.Sprintf("RTCntConfig:beIsHomeField=%s", dao.beIsHomeField))
		log.Info(fmt.Sprintf("RTCntConfig:beRTTable=%s", dao.beRTTable))
		log.Info(fmt.Sprintf("RTCntConfig:rtCntWinDelay=%d", dao.rtCntWinDelay))
		log.Info(fmt.Sprintf("RTCntConfig:rtCntMaxKey=%d", dao.rtCntMaxKey))
	}

	client, err := beengine.GetBeClient(config.BeName)
	if err != nil {
		log.Error(fmt.Sprintf("error=%v", err))
		return nil
	}
	dao.beClient = client.BeClient
	if config.NoUsePlayTimeField {
		dao.hasPlayTimeField = false
	}
	return dao
}