Week 1 - Exercise

[tpphu]

Unit 1

Convert CSV file to YAML file.

Input:

Data

Output:

Output

Unit 2

Port 5 functions of Lodash to Golang

• IsEmpty
• Last
• Map
• Contains
• Max

[tpphu]

Version 2, để code nhìn rõ ràng hơn.

package convert

import (
	"bufio"
	"errors"
	"os"
	"strconv"
	"strings"
)

type City struct {
	ID        int
	Name      string
	Districts []*District
}

type District struct {
	ID    int
	Name  string
	Wards []Ward
}

type Ward struct {
	ID   int
	Name string
}

var InvalidCSVData = errors.New("Invalid CSV Data")
var InvalidParseIDCity = errors.New("Invalid Parse ID City")
var InvalidParseIDDistrict = errors.New("Invalid Parse ID District")
var InvalidParseIDWard = errors.New("Invalid Parse ID Ward")

var citiMap = map[int]*City{}
var districtMap = map[int]*District{}

func processCity(cities *[]*City, id string, name string) (*City, error) {
	ID, err := strconv.Atoi(id) //int
	if err != nil {
		return nil, InvalidParseIDCity
	}
	city, ok := citiMap[ID]
	if !ok {
		city = &City{
			Name: name,
			ID:   ID,
		}
		citiMap[ID] = city
		*cities = append(*cities, city)
	}
	return city, nil
}

func processDistrict(city *City, id string, name string) (*District, error) {
	ID, err := strconv.Atoi(id) //int
	if err != nil {
		return nil, InvalidParseIDDistrict
	}
	district, ok := districtMap[ID]
	if !ok {
		district = &District{
			Name: name,
			ID:   ID,
		}
		districtMap[ID] = district
		city.Districts = append(city.Districts, district)
	}
	return district, nil
}

func processWard(district *District, id string, name string) error {
	ID, err := strconv.Atoi(id) //int
	if err != nil {
		return InvalidParseIDWard
	}
	ward := Ward{
		Name: name,
		ID:   ID,
	}
	district.Wards = append(district.Wards, ward)
	return nil
}

// Private
func ConvertCSV2Yaml(file string) (cities []*City, err error) {
	inFile, err := os.Open(file)
	if err != nil {
		return cities, err
	}
	// Hoc bua sau
	defer inFile.Close()
	//
	scanner := bufio.NewScanner(inFile)
	isFirstLine := false
	for scanner.Scan() {
		line := scanner.Text()
		if isFirstLine == false {
			isFirstLine = true
			continue
		}
		cells := strings.Split(line, ",")
		if len(cells) < 6 {
			return cities, InvalidCSVData
		}
		// Xu ly cai city
		city, err := processCity(&cities, cells[1], cells[0])
		if err != nil {
			return cities, err
		}
		// Xu ly district
		district, err := processDistrict(city, cells[3], cells[2])
		if err != nil {
			return cities, InvalidParseIDDistrict
		}
		// Xu ly ward
		err = processWard(district, cells[5], cells[4])
		if err != nil {
			return cities, InvalidParseIDWard
		}
	}
	return cities, nil
}

[tpphu]

Version 3, phiên bản tổ chức tốt hơn

package convert

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type City struct {
	ID        int
	Name      string
	Districts []*District
}

type District struct {
	ID    int
	Name  string
	Wards []*Ward
}

type Ward struct {
	ID   int
	Name string
}

type InvalidParserError interface {
	error
	GetTypeData() string
	GetRawData() []string
}

type invalidParserErrorImp struct {
	typeData string
	rawData  []string
}

func (e invalidParserErrorImp) Error() string {
	return fmt.Sprintf("Invalid parser for %s, raw data are: %s",
		e.typeData,
		strings.Join(e.rawData, ","))
}

func (e invalidParserErrorImp) GetTypeData() string {
	return e.typeData
}

func (e invalidParserErrorImp) GetRawData() []string {
	return e.rawData
}

func NewInvalidParserError(typeData string, data ...string) InvalidParserError {
	return invalidParserErrorImp{
		typeData: typeData,
		rawData:  data,
	}
}

var InvalidCSVData = func(data ...string) InvalidParserError {
	return invalidParserErrorImp{
		typeData: "line",
		rawData:  data,
	}
}
var InvalidParseIDCity = func(data ...string) InvalidParserError {
	return invalidParserErrorImp{
		typeData: "city",
		rawData:  data,
	}
}
var InvalidParseIDDistrict = func(data ...string) InvalidParserError {
	return invalidParserErrorImp{
		typeData: "district",
		rawData:  data,
	}
}
var InvalidParseIDWard = func(data ...string) InvalidParserError {
	return invalidParserErrorImp{
		typeData: "ward",
		rawData:  data,
	}
}

type CSVToYaml struct {
	citiMap     map[int]*City
	districtMap map[int]*District
	result      []*City
}

func NewCSVToYamlConverter() CSVToYaml {
	converter := CSVToYaml{
		citiMap:     map[int]*City{},
		districtMap: map[int]*District{},
	}
	return converter
}
func (c *CSVToYaml) ConvertCSV2Yaml(file string) ([]*City, error) {
	inFile, err := os.Open(file)
	if err != nil {
		return c.result, err
	}
	// Hoc bua sau
	defer inFile.Close()
	//
	scanner := bufio.NewScanner(inFile)
	isFirstLine := false
	for scanner.Scan() {
		line := scanner.Text()
		if isFirstLine == false {
			isFirstLine = true
			continue
		}
		err := c.process(line)
		if err != nil {
			return c.result, err
		}
	}
	return c.result, nil
}

func (c *CSVToYaml) process(line string) InvalidParserError {
	cells := strings.Split(line, ",")
	if len(cells) < 6 {
		return InvalidCSVData(cells...)
	}
	// Xu ly cai city
	city, err := c.processCity(cells[1], cells[0])
	if err != nil {
		return err
	}
	// Xu ly district
	district, err := c.processDistrict(city, cells[3], cells[2])
	if err != nil {
		return err
	}
	// Xu ly ward
	_, err = c.processWard(district, cells[5], cells[4])
	return err
}

func (c *CSVToYaml) processCity(id string, name string) (*City, InvalidParserError) {
	ID, err := strconv.Atoi(id) //int
	if err != nil {
		return nil, InvalidParseIDCity(id, name)
	}
	city, ok := c.citiMap[ID]
	if !ok {
		city = &City{
			Name: name,
			ID:   ID,
		}
		c.citiMap[ID] = city
		c.result = append(c.result, city)
	}
	return city, nil
}

func (c *CSVToYaml) processDistrict(city *City, id string, name string) (*District, InvalidParserError) {
	ID, err := strconv.Atoi(id) //int
	if err != nil {
		return nil, InvalidParseIDDistrict(id, name)
	}
	district, ok := c.districtMap[ID]
	if !ok {
		district = &District{
			Name: name,
			ID:   ID,
		}
		c.districtMap[ID] = district
		city.Districts = append(city.Districts, district)
	}
	return district, nil
}

func (c *CSVToYaml) processWard(district *District, id string, name string) (*Ward, InvalidParserError) {
	ID, err := strconv.Atoi(id) //int
	if err != nil {
		return nil, InvalidParseIDWard(id, name)
	}
	ward := &Ward{
		Name: name,
		ID:   ID,
	}
	district.Wards = append(district.Wards, ward)
	return ward, nil
}