func ConvertBuildsToCicdTasks()

in backend/plugins/jenkins/tasks/build_cicd_convertor.go [45:174]
119 lines of code
12 McCabe index (conditional complexity)

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

	clauses := []dal.Clause{
		dal.From("_tool_jenkins_builds"),
	}

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

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

	converter, err := api.NewDataConverter(api.DataConverterArgs{
		InputRowType: reflect.TypeOf(models.JenkinsBuild{}),
		Input:        cursor,
		RawDataSubTaskArgs: api.RawDataSubTaskArgs{
			Params: JenkinsApiParams{
				ConnectionId: data.Options.ConnectionId,
				FullName:     data.Options.JobFullName,
			},
			Ctx:   taskCtx,
			Table: RAW_BUILD_TABLE,
		},
		Convert: func(inputRow interface{}) ([]interface{}, errors.Error) {
			jenkinsBuild := inputRow.(*models.JenkinsBuild)
			var durationMillis float64
			if jenkinsBuild.Duration > 0 {
				durationMillis = jenkinsBuild.Duration
			} else {
				durationMillis = 0
			}
			durationSec := durationMillis / 1e3

			jenkinsPipelineStatus := devops.GetStatusCommon(&devops.StatusRuleCommon[bool]{
				InProgress: []bool{true},
				Done:       []bool{false},
				Default:    devops.STATUS_OTHER,
			}, jenkinsBuild.Building)
			jenkinsPipelineResult := devops.RESULT_DEFAULT
			if !jenkinsBuild.Building {
				jenkinsPipelineResult = devops.GetResult(&devops.ResultRule{
					Success: []string{SUCCESS},
					Failure: []string{FAILURE, ABORTED},
					Default: devops.RESULT_DEFAULT,
				}, jenkinsBuild.Result)
			}
			var jenkinsPipelineFinishedDate *time.Time
			results := make([]interface{}, 0)

			if jenkinsPipelineStatus == devops.STATUS_DONE {
				finishTime := jenkinsBuild.StartTime.Add(time.Duration(int64(durationMillis) * int64(time.Millisecond)))
				jenkinsPipelineFinishedDate = &finishTime
			}
			jenkinsPipeline := &devops.CICDPipeline{
				DomainEntity: domainlayer.DomainEntity{
					Id: buildIdGen.Generate(jenkinsBuild.ConnectionId, jenkinsBuild.FullName),
				},
				Name:           jenkinsBuild.FullName,
				Result:         jenkinsPipelineResult,
				Status:         jenkinsPipelineStatus,
				OriginalResult: jenkinsBuild.Result,
				OriginalStatus: cast.ToString(jenkinsBuild.Building),
				TaskDatesInfo: devops.TaskDatesInfo{
					CreatedDate:  jenkinsBuild.StartTime,
					StartedDate:  &jenkinsBuild.StartTime,
					FinishedDate: jenkinsPipelineFinishedDate,
				},
				DurationSec: durationSec,
				CicdScopeId: jobIdGen.Generate(jenkinsBuild.ConnectionId, data.Options.JobFullName),
				Type:        data.RegexEnricher.ReturnNameIfMatched(devops.DEPLOYMENT, jenkinsBuild.FullName),
				Environment: data.RegexEnricher.ReturnNameIfOmittedOrMatched(devops.PRODUCTION, jenkinsBuild.FullName),
			}
			jenkinsPipeline.RawDataOrigin = jenkinsBuild.RawDataOrigin
			results = append(results, jenkinsPipeline)

			if !jenkinsBuild.HasStages {
				jenkinsTask := &devops.CICDTask{
					DomainEntity: domainlayer.DomainEntity{
						Id: buildIdGen.Generate(jenkinsBuild.ConnectionId, jenkinsBuild.FullName),
					},
					Name:           data.Options.JobFullName,
					Result:         jenkinsPipelineResult,
					Status:         jenkinsPipelineStatus,
					OriginalResult: jenkinsBuild.Result,
					OriginalStatus: cast.ToString(jenkinsBuild.Building),
					DurationSec:    durationSec,
					TaskDatesInfo: devops.TaskDatesInfo{
						CreatedDate:  jenkinsBuild.StartTime,
						StartedDate:  &jenkinsBuild.StartTime,
						FinishedDate: jenkinsPipelineFinishedDate,
					},
					CicdScopeId: jobIdGen.Generate(jenkinsBuild.ConnectionId, data.Options.JobFullName),
					Type:        data.RegexEnricher.ReturnNameIfMatched(devops.DEPLOYMENT, jenkinsBuild.FullName),
					Environment: data.RegexEnricher.ReturnNameIfOmittedOrMatched(devops.PRODUCTION, jenkinsBuild.FullName),
					PipelineId:  buildIdGen.Generate(jenkinsBuild.ConnectionId, jenkinsBuild.FullName),
				}
				// 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 converter.Execute()
}