func()

in pkg/cli/job_actions.go [194:296]
95 lines of code
17 McCabe index (conditional complexity)

func (c *Client) JobQueryAction(
	labels string,
	respoolPath string,
	keywords string,
	states string,
	owner string,
	name string,
	days uint32,
	limit uint32,
	maxLimit uint32,
	offset uint32,
	sortBy string,
	sortOrder string) error {
	var apiLabels []*peloton.Label
	var err error
	if len(labels) > 0 {
		apiLabels, err = parsePelotonLabels(labels)
		if err != nil {
			return err
		}
	}

	var respoolID *peloton.ResourcePoolID
	if len(respoolPath) > 0 {
		respoolID, err = c.LookupResourcePoolID(respoolPath)
		if err != nil {
			return err
		}
	}

	var apiKeywords []string
	for _, k := range strings.Split(keywords, labelSeparator) {
		if k != "" {
			apiKeywords = append(apiKeywords, k)
		}
	}

	var apiStates []job.JobState
	for _, k := range strings.Split(states, labelSeparator) {
		if k != "" {
			apiStates = append(apiStates, job.JobState(job.JobState_value[k]))
		}
	}

	order := query.OrderBy_DESC
	if sortOrder == "ASC" {
		order = query.OrderBy_ASC
	} else if sortOrder != "DESC" {
		return errors.New("Invalid sort order " + sortOrder)
	}
	var sort []*query.OrderBy
	for _, s := range strings.Split(sortBy, labelSeparator) {
		if s != "" {

			propertyPath := &query.PropertyPath{
				Value: s,
			}
			sort = append(sort, &query.OrderBy{
				Order:    order,
				Property: propertyPath,
			})
		}
	}

	spec := &job.QuerySpec{
		Labels:    apiLabels,
		Keywords:  apiKeywords,
		JobStates: apiStates,
		Owner:     owner,
		Name:      name,
		Pagination: &query.PaginationSpec{
			Limit:    limit,
			Offset:   offset,
			OrderBy:  sort,
			MaxLimit: maxLimit,
		},
	}

	if days > 0 {
		now := time.Now().UTC()
		max, err := ptypes.TimestampProto(now)
		if err != nil {
			return err
		}
		min, err := ptypes.TimestampProto(now.AddDate(0, 0, -int(days)))
		if err != nil {
			return err
		}
		spec.CreationTimeRange = &peloton.TimeRange{Min: min, Max: max}
	}

	var request = &job.QueryRequest{
		RespoolID:   respoolID,
		Spec:        spec,
		SummaryOnly: true,
	}
	response, err := c.jobClient.Query(c.ctx, request)
	if err != nil {
		return err
	}
	printJobQueryResponse(response, c.Debug)
	return nil
}