engine

var DefaultVulnerabilityBuilder = func(ctx context.Context, qCtx *QueryContext,
	tracker Tracker,
	v interface{},
	detector *dec.DetectLine,
	useOldSeverities bool,
	kicsComputeNewSimID bool,
	queryDuration time.Duration) (*model.Vulnerability, error) {
	contextLogger := logger.FromContext(ctx)
	vObj, ok := v.(map[string]interface{})
	if !ok {
		return &model.Vulnerability{}, ErrInvalidResult
	}

	vObj = mergeWithMetadata(vObj, qCtx.Query.Metadata.Metadata)

	var err error
	var output []byte

	output, err = json.Marshal(vObj)
	if err != nil {
		return &model.Vulnerability{}, errors.Wrap(err, "failed to marshall query output")
	}

	var fileID *string

	fileID, err = mapKeyToString(ctx, vObj, "documentId", false)
	if err != nil {
		return &model.Vulnerability{}, errors.Wrap(err, "failed to recognize file id")
	}

	file, ok := qCtx.Files[*fileID]
	if !ok {
		return &model.Vulnerability{}, errors.New("failed to find file from query response")
	}

	logWithFields := contextLogger.With().
		Str("scanID", qCtx.scanID).
		Str("fileName", file.FilePath).
		Str("queryName", qCtx.Query.Metadata.Query).
		Logger()

	detector.SetupLogs(&logWithFields)

	linesVulne := model.VulnerabilityLines{
		Line:                  -1,
		VulnLines:             &[]model.CodeLine{},
		LineWithVulnerability: "",
	}

	similarityIDLineInfo := ""
	searchKey := ""
	if s, ok := vObj["searchKey"]; ok {
		searchKey = s.(string)
		similarityIDLineInfo = searchKey
		intDoc := file.LineInfoDocument
		vulsSplit := strings.Split(searchKey, ".")

		if file.Kind == model.KindINI {
			vulsSplit, searchKey = sanitizeINIKey(vulsSplit)
		}

		if strings.Contains(vulsSplit[len(vulsSplit)-1], "RefMetadata") {
			return &model.Vulnerability{}, ErrNoResult
		}

		searchKey, _ = modifyVulSearchKeyReference(intDoc, searchKey, vulsSplit)
		vObj["searchKey"] = searchKey
		linesVulne = detector.DetectLine(ctx, &file, searchKey)
	} else {
		logWithFields.Error().Msg("Saving result. failed to detect line")
	}

	lineNumber := 0
	var similarityIDLineInfoOld = similarityIDLineInfo

	if !slices.Contains([]model.FileKind{model.KindHELM, model.KindTerraform}, file.Kind) && len(file.ResolvedFiles) == 0 {
		searchLineCalc := &searchLineCalculator{
			lineNr:               -1,
			vObj:                 vObj,
			file:                 file,
			detector:             detector,
			similarityIDLineInfo: similarityIDLineInfo,
			linesVulne:           linesVulne,
		}

		lineNumber, similarityIDLineInfoOld, linesVulne = calculeSearchLine(ctx, searchLineCalc)
	}

	if linesVulne.Line == -1 {
		logWithFields.Warn().Msgf("Failed to detect line, query response %s", searchKey)
		linesVulne.Line = 1
	}

	searchValue := ""
	if s, ok := vObj["searchValue"]; ok {
		searchValue = s.(string)
	}

	overrideKey := ""
	if s, ok := vObj["overrideKey"]; ok {
		overrideKey = s.(string)
	}

	platform := getStringFromMap(ctx, "platform", "", overrideKey, vObj, &logWithFields)
	resourceType := PtrStringToString(mustMapKeyToString(ctx, vObj, "resourceType"))
	if strings.EqualFold(platform, "ansible") {
		resourceType = utils.NormalizeAnsibleResourceType(resourceType)
	}

	queryID := getStringFromMap(ctx, "id", DefaultQueryID, overrideKey, vObj, &logWithFields)

	severity := getResolvedSeverity(ctx, vObj, &logWithFields, overrideKey, useOldSeverities)

	issueType := DefaultIssueType
	if v := mustMapKeyToString(ctx, vObj, "issueType"); v != nil {
		issueType = model.IssueType(*v)
	}

	similarityID, oldSimilarityID := generateSimilaritiesID(ctx, qCtx, linesVulne.ResolvedFile, queryID, similarityIDLineInfo, searchValue,
		searchKey, similarityIDLineInfoOld, kicsComputeNewSimID, &logWithFields, tracker)

	return &model.Vulnerability{
		ID:              0,
		SimilarityID:    PtrStringToString(similarityID),
		OldSimilarityID: PtrStringToString(oldSimilarityID),
		ScanID:          qCtx.scanID,
		FileID:          file.ID,
		FileName:        linesVulne.ResolvedFile,
		QueryName:       getStringFromMap(ctx, "queryName", DefaultQueryName, overrideKey, vObj, &logWithFields),
		QueryID:         queryID,
		Experimental:    getBoolFromMap(ctx, "experimental", DefaultExperimental, overrideKey, vObj, &logWithFields),
		QueryURI:        getStringFromMap(ctx, "descriptionUrl", DefaultQueryURI, overrideKey, vObj, &logWithFields),
		Category:        getStringFromMap(ctx, "category", "", overrideKey, vObj, &logWithFields),
		Description:     getStringFromMap(ctx, "descriptionText", "", overrideKey, vObj, &logWithFields),
		DescriptionID:   getStringFromMap(ctx, "descriptionID", DefaultQueryDescriptionID, overrideKey, vObj, &logWithFields),
		Severity:        severity,
		Platform:        platform,
		CWE:             getStringFromMap(ctx, "cwe", "", overrideKey, vObj, &logWithFields),
		Line:            linesVulne.Line,
		VulnerabilityLocation: model.ResourceLocation{
			Start: linesVulne.VulnerablilityLocation.Start,
			End:   linesVulne.VulnerablilityLocation.End,
		},
		RemediationLocation: model.ResourceLocation{
			Start: linesVulne.RemediationLocation.Start,
			End:   linesVulne.RemediationLocation.End,
		},
		VulnLines:             linesVulne.VulnLines,
		ResourceType:          resourceType,
		ResourceName:          PtrStringToString(mustMapKeyToString(ctx, vObj, "resourceName")),
		IssueType:             issueType,
		SearchKey:             searchKey,
		SearchLine:            lineNumber,
		SearchValue:           searchValue,
		KeyExpectedValue:      PtrStringToString(mustMapKeyToString(ctx, vObj, "keyExpectedValue")),
		KeyActualValue:        PtrStringToString(mustMapKeyToString(ctx, vObj, "keyActualValue")),
		Value:                 mustMapKeyToString(ctx, vObj, "value"),
		Output:                string(output),
		CloudProvider:         getCloudProvider(ctx, overrideKey, vObj, &logWithFields),
		Remediation:           PtrStringToString(mustMapKeyToString(ctx, vObj, "remediation")),
		RemediationType:       PtrStringToString(mustMapKeyToString(ctx, vObj, "remediationType")),
		QueryDuration:         queryDuration,
		LineWithVulnerability: linesVulne.LineWithVulnerability,
		ResourceSource:        linesVulne.ResourceSource,
		FileSource:            linesVulne.FileSource,
		BlockLocation:         linesVulne.BlockLocation,
		Frameworks: append(extractDefaultFrameworks(ctx, qCtx.Query.Metadata.Metadata, qCtx.FlagEvaluator),
			extractCustomFrameworks(ctx, qCtx.Query.Metadata.Metadata, qCtx.FlagEvaluator)...),
	}, nil
}

var ErrInvalidResult = errors.New("query: invalid result format")

var ErrNoResult = errors.New("query: not result")