func()

in internal/repo/explore.go [34:134]
91 lines of code
10 McCabe index (conditional complexity)

func (e *Explore) GetPathContents(path string, sortBy SortType) ([]*model.Metadata, error) {
	if path == "" {
		path = "/"
	}

	queryContent := `
		SELECT
			name, 
			LENGTH(name) AS name_length,
			size_standard, 
			size_nearline, 
			size_coldline, 
			size_archive, 
			(size_standard + 
			size_nearline  + 
			size_coldline  + 
			size_archive) AS size, 
			count,
			'' as storage_class,
			parent
		FROM directory
		WHERE
			parent = $1 OR
			name = $1
		UNION ALL
		SELECT 
			name, 
			LENGTH(name) AS name_length,
			0 as size_standard, 
			0 as size_nearline, 
			0 as size_coldline, 
			0 as size_archive, 
			size, 
			0 as count,
			storage_class,
			parent 
		FROM metadata
		WHERE
			parent = $1
	`

	if sortBy != SortByCount && sortBy != SortBySize {
		return nil, errors.New("invalid sort parameter")
	}
	queryContent += fmt.Sprintf(" ORDER BY %s DESC, name_length", sortBy)
	queryContent += " LIMIT 100;"

	type contentRow struct {
		Name         string `db:"name"`
		NameLength   int    `db:"name_length"`
		StorageClass string `db:"storage_class"`
		SizeStandard int64  `db:"size_standard"`
		SizeNearline int64  `db:"size_nearline"`
		SizeColdline int64  `db:"size_coldline"`
		SizeArchive  int64  `db:"size_archive"`
		Size         int64  `db:"size"`
		Count        int64  `db:"count"`
		Parent       string `db:"parent"`
	}

	rows, err := e.DB.Queryx(queryContent, path)
	if err != nil {
		return nil, fmt.Errorf("query error: %w", err)
	}
	defer rows.Close()

	var pathContents []*model.Metadata
	for rows.Next() {
		var row contentRow
		if err := rows.StructScan(&row); err != nil {
			return nil, fmt.Errorf("scan error: %w", err)
		}

		metadata := &model.Metadata{
			Name:         row.Name,
			Size:         row.Size,
			Count:        row.Count,
			StorageClass: row.StorageClass,
			Parent:       row.Parent,
		}

		// Calculate costs of every object and directory
		// defaultLocation is used for all results until storing location from bucket is implemented
		if len(metadata.StorageClass) > 0 { // object
			cost, err := getObjectCost(defaultLocation, StorageClass(metadata.StorageClass), metadata.Size)
			if err != nil {
				return nil, err
			}
			metadata.Cost = cost
		} else { // directory
			totalCost, err := getDirectoryCost(defaultLocation, row.SizeStandard, row.SizeNearline, row.SizeColdline, row.SizeArchive)
			if err != nil {
				return nil, err
			}
			metadata.Cost = totalCost
		}

		pathContents = append(pathContents, metadata)
	}
	return pathContents, nil
}