func ConvertStages()

in backend/plugins/jenkins/tasks/stage_convertor.go [63:172]
100 lines of code
8 McCabe index (conditional complexity)

func ConvertStages(taskCtx plugin.SubTaskContext) (err errors.Error) {
	db := taskCtx.GetDal()
	data := taskCtx.GetData().(*JenkinsTaskData)

	clauses := []dal.Clause{
		dal.Select(`tjb.connection_id, tjs.build_name, tjs.id, tjs._raw_data_remark, tjs.name,
			tjs._raw_data_id, tjs._raw_data_table, tjs._raw_data_params,
			tjs.status, tjs.start_time_millis, tjs.duration_millis,
			tjs.pause_duration_millis, tjs.type, tjb.result,
			tjb.triggered_by, tjb.building`),
		dal.From("_tool_jenkins_stages tjs"),
		dal.Join("left join _tool_jenkins_builds tjb on tjs.build_name = tjb.full_name"),
	}

	if data.Options.Class == WORKFLOW_MULTI_BRANCH_PROJECT {
		clauses = append(clauses,
			dal.Where(`tjb.connection_id = ? and tjb.full_name like ?`,
				data.Options.ConnectionId, fmt.Sprintf("%s%%", data.Options.JobFullName)))
	} else {
		clauses = append(clauses,
			dal.Where("tjb.connection_id = ? and tjb.job_path = ? and tjb.job_name = ? ",
				data.Options.ConnectionId, data.Options.JobPath, data.Options.JobName))
	}

	cursor, err := db.Cursor(clauses...)
	if err != nil {
		return err
	}
	defer cursor.Close()
	stageIdGen := didgen.NewDomainIdGenerator(&models.JenkinsStage{})
	buildIdGen := didgen.NewDomainIdGenerator(&models.JenkinsBuild{})
	jobIdGen := didgen.NewDomainIdGenerator(&models.JenkinsJob{})

	convertor, err := api.NewDataConverter(api.DataConverterArgs{
		InputRowType: reflect.TypeOf(JenkinsBuildWithRepoStage{}),
		Input:        cursor,
		RawDataSubTaskArgs: api.RawDataSubTaskArgs{
			Params: JenkinsApiParams{
				ConnectionId: data.Options.ConnectionId,
				FullName:     data.Options.JobFullName,
			},
			Ctx:   taskCtx,
			Table: RAW_STAGE_TABLE,
		},
		Convert: func(inputRow interface{}) ([]interface{}, errors.Error) {
			body := inputRow.(*JenkinsBuildWithRepoStage)
			if body.Name == "" {
				return nil, err
			}
			var durationMillis int64
			if body.DurationMillis > 0 {
				durationMillis = int64(body.DurationMillis)
			} else {
				durationMillis = int64(0)
			}
			durationSec := float64(durationMillis / 1e3)
			jenkinsTaskResult := devops.GetResult(&devops.ResultRule{
				Success: []string{SUCCESS},
				Failure: []string{FAILED, FAILURE, ABORTED},
				Default: devops.RESULT_DEFAULT,
			}, body.Result)

			jenkinsTaskStatus := devops.GetStatus(&devops.StatusRule{
				Done:       []string{SUCCESS},
				InProgress: []string{},
				Default:    devops.STATUS_OTHER,
			}, body.Status)

			var jenkinsTaskFinishedDate *time.Time
			results := make([]interface{}, 0)
			finishedDateMillis := body.StartTimeMillis + durationMillis
			finishedDate := time.Unix(finishedDateMillis/1e3, (finishedDateMillis%1e3)*int64(time.Millisecond))
			jenkinsTaskFinishedDate = &finishedDate
			startedDate := time.Unix(body.StartTimeMillis/1e3, 0)

			jenkinsTask := &devops.CICDTask{
				DomainEntity: domainlayer.DomainEntity{
					Id: stageIdGen.Generate(body.ConnectionId, body.BuildName, body.ID),
				},
				Name:        body.Name,
				PipelineId:  buildIdGen.Generate(body.ConnectionId, body.BuildName),
				Result:      jenkinsTaskResult,
				Status:      jenkinsTaskStatus,
				DurationSec: durationSec,
				TaskDatesInfo: devops.TaskDatesInfo{
					CreatedDate:  startedDate,
					StartedDate:  &startedDate,
					FinishedDate: jenkinsTaskFinishedDate,
				},
				OriginalResult: body.Result,
				OriginalStatus: body.Status,
				CicdScopeId:    jobIdGen.Generate(body.ConnectionId, data.Options.JobFullName),
				Type:           data.RegexEnricher.ReturnNameIfMatched(devops.DEPLOYMENT, body.Name),
				Environment:    data.RegexEnricher.ReturnNameIfOmittedOrMatched(devops.PRODUCTION, body.Name),
			}
			// if the task is not executed, set the result to default, so that it will not be calculated in the dora
			if jenkinsTask.OriginalStatus == "NOT_EXECUTED" {
				jenkinsTask.Result = devops.RESULT_DEFAULT
			}
			results = append(results, jenkinsTask)
			return results, nil
		},
	})

	if err != nil {
		return err
	}

	return convertor.Execute()
}