merge

import.go (3481B)

---

 package main
 
 import (
 	"github.com/360EntSecGroup-Skylar/excelize"
 	"log"
 	"strings"
 	"path/filepath"
 	"os"
 	"encoding/csv"
 	"fmt"
 	"runtime"
 )
 
 // Dataset holds all of the variables and their data
 type Dataset struct {
 	data   map[string][]string // maps terms to ordered data (columns)
 	terms  []string            // ordered list of terms
 	name   string              // name of the dataset
 	height int                 // height of the XLSX file (including the first row of terms)
 }
 
 func ImportDataset(name string, rows [][]string) *Dataset {
 	// Initialize Dataset
 	var d Dataset
 	d.data = make(map[string][]string)
 
 	d.height = len(rows)
 
 	d.terms = rows[0]
 	d.name = name
 
 	// Create blank column for each term
 	for _, term := range d.terms {
 		d.data[term] = make([]string, d.height-1) // specimens start on the second row
 	}
 
 	// Fill in columns
 	for j, row := range rows[1:d.height] {
 		for i, value := range row {
 			d.data[d.terms[i]][j] = value
 		}
 	}
 	//	d.removeUnusedTerms()
 	return &d
 }
 
 // removeUnusedTerms clears unused terms from the term list
 func (d *Dataset) removeUnusedTerms() {
 	// find unused terms
 	var termsToRemove []string
 	for _, term := range d.terms {
 		if !notAllSame(d.data[term]) {
 			termsToRemove = append(termsToRemove, term)
 		}
 	}
 
 	// clear them
 	for _, term := range termsToRemove {
 		if Include(d.terms, term) {
 			d.terms = Remove(d.terms, term)
 		}
 	}
 }
 
 // func ImportDatasets(paths []string) map[string]*Dataset {
 // 	datasets := make(map[string]*Dataset)
 
 // 	for _, file := range paths {
 // 		// fmt.Println(file)
 // 		datasets[file] = ImportXLSX(file)
 // 	}
 // 	return datasets
 // }
 
 // chooses which export function to call based on file extension
 func exportDataset(d *Dataset, filename string) {
 	ext := strings.ToLower(filepath.Ext(filename))
 	fmt.Println(ext)
 	switch  ext {
 	case ".csv":
 		exportDatasetToCsv(d, filename)
 		break;
 	default:
 		exportDatasetToExcel(d, filename)
 	}
 }
 
 func exportDatasetToExcel(d *Dataset, filepath string) {
 	f := excelize.NewFile()
 	sheetName := f.GetSheetMap()[1]
 
 	for i, name := range d.terms {
 		// write the term
 		coord, err := excelize.CoordinatesToCellName(i+1,1 )
 		if err != nil {
 			log.Fatal("Trouble getting coaordinates:", err)
 		}
 		f.SetCellStr(sheetName,coord, name)
 
 		// write the rest of the column
 		for j, value := range d.data[name] {
 			coord, err := excelize.CoordinatesToCellName(i+1, j+2)
 			if err != nil {
 				log.Fatal("Trouble getting coaordinates:", err)
 			}
 			f.SetCellStr(sheetName, coord, value)
 		}
 	}
 
 	err := f.SaveAs(filepath)
 	if err != nil {
 		log.Fatal("Unable to save file", err)
 	}
 
 }
 
 func exportDatasetToCsv(d *Dataset, filepath string) {
 
 	err := os.RemoveAll(filepath)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	f, err := os.Create(filepath)
 	if err != nil {
 		log.Fatal("Cannot open '%s': %s\n", filepath, err.Error())
 		os.Exit(1)
 	}
 	defer f.Close()
 
 	w := csv.NewWriter(f)
 	// fix windows line endings
 	if runtime.GOOS == "windows" {
 		w.UseCRLF = true
 	}
 	w.Write(d.terms)                            // first line contains the terms in order
 	for i := range d.data[d.terms[0]] { // use the length of the first column as the number of rows
 		var row []string
 		for _, value := range d.terms { // for each term
 			row = append(row, d.data[value][i]) // add the value of the term for the current row
 		}
 
 		if err := w.Write(row); err != nil { // write the row
 			log.Fatal("error writing record to csv:", err)
 		}
 	}
 	w.Flush()
 	f.Sync()
 
 }