func ExtractApiPullRequests()

in backend/plugins/bitbucket_server/tasks/pr_extractor.go [81:162]
74 lines of code
19 McCabe index (conditional complexity)

func ExtractApiPullRequests(taskCtx plugin.SubTaskContext) errors.Error {
	data := taskCtx.GetData().(*BitbucketServerTaskData)
	config := data.Options.BitbucketServerScopeConfig
	var prTypeRegex *regexp.Regexp
	var prComponentRegex *regexp.Regexp
	var err errors.Error

	if config != nil {
		if len(config.PrType) > 0 {
			prTypeRegex, err = errors.Convert01(regexp.Compile(config.PrType))
			if err != nil {
				return errors.Default.Wrap(err, "regexp Compile prType failed")
			}
		}

		if len(config.PrComponent) > 0 {
			prComponentRegex, err = errors.Convert01(regexp.Compile(config.PrComponent))
			if err != nil {
				return errors.Default.Wrap(err, "regexp Compile prComponent failed")
			}
		}
	}

	rawDataSubTaskArgs, data := CreateRawDataSubTaskArgs(taskCtx, RAW_PULL_REQUEST_TABLE)
	extractor, err := api.NewApiExtractor(api.ApiExtractorArgs{
		RawDataSubTaskArgs: *rawDataSubTaskArgs,
		Extract: func(row *api.RawData) ([]interface{}, errors.Error) {
			rawL := &ApiPrResponse{}
			err := errors.Convert(json.Unmarshal(row.Data, rawL))
			if err != nil {
				return nil, err
			}
			// need to extract 2 kinds of entities here
			results := make([]interface{}, 0, 1)
			if rawL.BitbucketId == 0 {
				return nil, nil
			}

			bitbucketPr, err := convertBitbucketPullRequest(rawL, data.Options.ConnectionId, data.Options.FullName)
			if err != nil {
				return nil, err
			}
			if rawL.Author != nil {
				bitbucketUser, err := convertUser(rawL.Author.User, data.Options.ConnectionId)
				if err != nil {
					return nil, err
				}
				results = append(results, bitbucketUser)
				bitbucketPr.AuthorName = bitbucketUser.DisplayName
				bitbucketPr.AuthorId = bitbucketUser.BitbucketId
			}
			if rawL.MergeCommit != nil {
				bitbucketPr.MergeCommitSha = rawL.MergeCommit.Hash
				bitbucketPr.MergedAt = rawL.MergeCommit.Date.ToNullableTime()
			} else if rawL.State == code.MERGED && rawL.BitbucketClosedAt != nil {
				mergedAt := time.UnixMilli(*rawL.BitbucketClosedAt)
				bitbucketPr.MergedAt = &mergedAt
			}

			if prTypeRegex != nil {
				prTypes := prTypeRegex.FindStringSubmatch(rawL.Title)
				if len(prTypes) > 0 {
					bitbucketPr.Type = prTypes[0]
				}
			}
			if prComponentRegex != nil {
				prComponents := prComponentRegex.FindStringSubmatch(rawL.Description)
				if len(prComponents) > 0 {
					bitbucketPr.Component = prComponents[0]
				}
			}

			results = append(results, bitbucketPr)

			return results, nil
		},
	})
	if err != nil {
		return err
	}
	return extractor.Execute()
}