add funcs for headers and rows

csv/csv.go

@@ -79,3 +79,86 @@ func (c *CSV) ToXLSX(csvFilePath, xlsxFilePath string) error {
 
 	return nil
 }
+
+func (c *CSV) GetHeaders(csvFilePath string) ([]string, error) {
+	csvFile, err := os.Open(csvFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening CSV file: %w", err)
+	}
+	defer csvFile.Close()
+
+	reader := csv.NewReader(csvFile)
+
+	headers, err := reader.Read()
+	if err != nil {
+		return nil, fmt.Errorf("error reading CSV file: %w", err)
+	}
+
+	return headers, nil
+}
+
+func (c *CSV) GetHeadersFromMap(mapper []map[string]string) ([]string, error) {
+	if len(mapper) == 0 {
+		return nil, fmt.Errorf("mapper is empty")
+	}
+
+	firstRow := mapper[0]
+
+	var headers []string
+	for i := 0; ; i++ {
+		key := fmt.Sprintf("col%d", i)
+		header, ok := firstRow[key]
+		if !ok {
+			break
+		}
+		headers = append(headers, header)
+	}
+
+	return headers, nil
+}
+
+func (c *CSV) GetRows(csvFilePath string) ([][]string, error) {
+	csvFile, err := os.Open(csvFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening CSV file: %w", err)
+	}
+	defer csvFile.Close()
+
+	reader := csv.NewReader(csvFile)
+
+	// Read and discard the header row
+	if _, err := reader.Read(); err != nil {
+		return nil, fmt.Errorf("error reading header from CSV file: %w", err)
+	}
+
+	// Read the rest of the rows
+	rows, err := reader.ReadAll()
+	if err != nil {
+		return nil, fmt.Errorf("error reading CSV file: %w", err)
+	}
+
+	return rows, nil
+}
+
+func (c *CSV) GetRowsFromMap(mapper []map[string]string) ([][]string, error) {
+	if len(mapper) == 0 {
+		return nil, fmt.Errorf("mapper is empty")
+	}
+
+	// Start from the second element to skip the headers.
+	var rows [][]string
+	for _, record := range mapper[1:] { // Skip the first map which contains headers.
+		var row []string
+		for i := 0; ; i++ {
+			key := fmt.Sprintf("col%d", i)
+			value, ok := record[key]
+			if !ok {
+				break
+			}
+			row = append(row, value)
+		}
+		rows = append(rows, row)
+	}
+
+	return rows, nil
+}

csv/csv_test.go

@@ -93,3 +93,103 @@ func TestToXLSX(t *testing.T) {
 		}
 	}
 }
+
+func TestGetHeaders(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "test-*.csv")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	_, err = tmpFile.WriteString("Name,Age,City\nAlice,30,NY\n")
+	if err != nil {
+		t.Fatalf("Failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	c := New()
+
+	headers, err := c.GetHeaders(tmpFile.Name())
+	if err != nil {
+		t.Errorf("GetHeaders() error = %v", err)
+		return
+	}
+
+	expectedHeaders := []string{"Name", "Age", "City"}
+	if !reflect.DeepEqual(headers, expectedHeaders) {
+		t.Errorf("GetHeaders() = %v, want %v", headers, expectedHeaders)
+	}
+}
+
+func TestGetHeadersFromMap(t *testing.T) {
+	c := New()
+
+	mapper := []map[string]string{
+		{"col0": "Name", "col1": "Age", "col2": "City"},
+		{"col0": "John", "col1": "30", "col2": "New York"},
+		{"col0": "Bob", "col1": "35", "col2": "Los Angeles"},
+	}
+
+	headers, err := c.GetHeadersFromMap(mapper)
+	if err != nil {
+		t.Errorf("GetHeadersFromMap() error = %v", err)
+		return
+	}
+
+	expectedHeaders := []string{"Name", "Age", "City"}
+
+	if !reflect.DeepEqual(headers, expectedHeaders) {
+		t.Errorf("GetHeadersFromMap() = %v, want %v", headers, expectedHeaders)
+	}
+}
+
+func TestGetRows(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "test-*.csv")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	_, err = tmpFile.WriteString("Name,Age,City\nJohn,30,New York\n")
+	if err != nil {
+		t.Fatalf("Failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	c := New()
+
+	rows, err := c.GetRows(tmpFile.Name())
+	if err != nil {
+		t.Errorf("GetRows() error = %v", err)
+		return
+	}
+	expectedRows := [][]string{
+		{"John", "30", "New York"},
+	}
+
+	if !reflect.DeepEqual(rows, expectedRows) {
+		t.Errorf("GetRows() = %v, want %v", rows, expectedRows)
+	}
+}
+
+func TestGetRowsFromMap(t *testing.T) {
+	c := New()
+
+	mapper := []map[string]string{
+		{"col0": "Name", "col1": "Age", "col2": "City"},
+		{"col0": "John", "col1": "30", "col2": "New York"},
+	}
+
+	rows, err := c.GetRowsFromMap(mapper)
+	if err != nil {
+		t.Errorf("GetRowsFromMap() error = %v", err)
+		return
+	}
+
+	expectedRows := [][]string{
+		{"John", "30", "New York"},
+	}
+	if !reflect.DeepEqual(rows, expectedRows) {
+		t.Errorf("GetRowsFromMap() = %v, want %v", rows, expectedRows)
+	}
+}

xls/xls.go

@@ -69,3 +69,67 @@ func (x *XLS) ToCSV(xlsxPath, csvPath string) error {
 
 	return nil
 }
+
+func (x *XLS) GetHeadersFromMap(mapper []map[string]string) ([]string, error) {
+	if len(mapper) == 0 {
+		return nil, fmt.Errorf("mapper is empty")
+	}
+
+	firstRow := mapper[0]
+
+	var headers []string
+	for i := 0; ; i++ {
+		key := fmt.Sprintf("col%d", i)
+		header, ok := firstRow[key]
+		if !ok {
+			break
+		}
+		headers = append(headers, header)
+	}
+
+	return headers, nil
+}
+
+func (x *XLS) GetHeaders(xlsxPath string) ([]string, error) {
+	f, err := excelize.OpenFile(xlsxPath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening xlsx file: %w", err)
+	}
+	defer f.Close()
+
+	rows, err := f.GetRows(f.GetSheetList()[0])
+	if err != nil {
+		return nil, fmt.Errorf("error getting rows from xlsx file: %w", err)
+	}
+
+	return rows[0], nil
+}
+
+func (x *XLS) GetRowsFromMap(mapper []map[string]string) ([][]string, error) {
+	var rows [][]string
+	for _, v := range mapper {
+		var row []string
+		for _, vv := range v {
+			row = append(row, vv)
+		}
+
+		rows = append(rows, row)
+	}
+
+	return rows, nil
+}
+
+func (x *XLS) GetRows(xlsxPath string) ([][]string, error) {
+	f, err := excelize.OpenFile(xlsxPath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening xlsx file: %w", err)
+	}
+	defer f.Close()
+
+	rows, err := f.GetRows(f.GetSheetList()[0])
+	if err != nil {
+		return nil, fmt.Errorf("error getting rows from xlsx file: %w", err)
+	}
+
+	return rows, nil
+}

xls/xls_test.go

@@ -7,7 +7,6 @@ import (
 )
 
 func TestToCSV(t *testing.T) {
-
 	fileTemp, err := os.CreateTemp("", "test.*.csv")
 	if err != nil {
 		t.Errorf("ToCSV() error = %v", err)
@@ -50,14 +49,83 @@ func TestParseToMap(t *testing.T) {
 }
 
 func TestParseToMapError(t *testing.T) {
-	// Non-existent file path
 	xlsxPath := "./nonexistent.xlsx"
 
-	// Execute the function to test.
 	x := New()
 
 	_, err := x.ParseToMap(xlsxPath)
 	if err == nil {
 		t.Errorf("ParseToMap() expected error, got nil")
 	}
 }
+
+func TestGetHeadersFromMap(t *testing.T) {
+	x := New()
+
+	mapper := []map[string]string{
+		{"col0": "Name", "col1": "Age", "col2": "City"},
+		{"col0": "Test1", "col1": "20", "col2": "NY"},
+		{"col0": "Test2", "col1": "15", "col2": "NJ"},
+		{"col0": "Test3", "col1": "33", "col2": "CA"},
+	}
+
+	expectedHeaders := []string{"Name", "Age", "City"}
+	headers, err := x.GetHeadersFromMap(mapper)
+	if err != nil {
+		t.Errorf("GetHeadersFromMap returned an error: %v", err)
+	}
+	if !reflect.DeepEqual(headers, expectedHeaders) {
+		t.Errorf("GetHeadersFromMap returned %v, expected %v", headers, expectedHeaders)
+	}
+}
+
+func TestGetHeaders(t *testing.T) {
+	x := New()
+	expectedHeaders := []string{"Name", "Age", "City"} // Replace with actual headers from your test.xlsx
+	headers, err := x.GetHeaders("./data/test.xlsx")
+	if err != nil {
+		t.Errorf("GetHeaders returned an error: %v", err)
+	}
+	if !reflect.DeepEqual(headers, expectedHeaders) {
+		t.Errorf("GetHeaders returned %v, expected %v", headers, expectedHeaders)
+	}
+}
+
+func TestGetRowsFromMap(t *testing.T) {
+	x := New()
+	mapper := []map[string]string{
+		{"col1": "value1", "col2": "value2"},
+		{"col1": "value3", "col2": "value4"},
+	}
+
+	expectedRows := [][]string{
+		{"value1", "value2"},
+		{"value3", "value4"},
+	}
+	rows, err := x.GetRowsFromMap(mapper)
+	if err != nil {
+		t.Errorf("GetRowsFromMap returned an error: %v", err)
+	}
+	if !reflect.DeepEqual(rows, expectedRows) {
+		t.Errorf("GetRowsFromMap returned %v, expected %v", rows, expectedRows)
+	}
+}
+
+func TestGetRows(t *testing.T) {
+	x := New()
+
+	expectedRows := [][]string{
+		{"Name", "Age", "City"},
+		{"Test1", "20", "NY"},
+		{"Test2", "15", "NJ"},
+		{"Test3", "33", "CA"},
+	}
+
+	rows, err := x.GetRows("./data/test.xlsx")
+	if err != nil {
+		t.Errorf("GetRows returned an error: %v", err)
+	}
+	if !reflect.DeepEqual(rows, expectedRows) {
+		t.Errorf("GetRows returned %v, expected %v", rows, expectedRows)
+	}
+}