Example #1
0
func NewSheet(s string, o osfile.OsFile) Sheet {
	name, err1 := NewFilename(s)
	if err1 != nil {
		log.WithFields(log.Fields{
			"path":     o.Dir,
			"filename": name.String(),
			"err":      err1,
		}).Error(asset.Tr("error_file_csv_unmarshal"))
	}

	r := o.NewReader(name.String())
	defer r.Close()

	rcsv := csv.NewReader(r)
	out, err2 := rcsv.ReadAll()

	if err2 != nil {
		log.WithFields(log.Fields{
			"path":     o.Dir,
			"filename": name.String(),
			"view":     out,
			"err":      err2,
		}).Error(asset.Tr("error_file_csv_unmarshal"))
	}

	tab := strtab.NewT(out[0], out[1:]...)

	return Sheet{name, tab, nil}
}
Example #2
0
func NewFilename(s string) (Filename, error) {
	var status string
	args := strings.Split(s, sep)

	if l := len(args); l != 5 && l != 6 {
		return Filename{}, fmt.Errorf(asset.Tr("filename_number_argument_error"), s)
	}

	if len(args) == 6 {
		status = args[0]
		args = args[1:]
	}

	date, err := time.Parse(timeFormat, args[0]+sep+args[1]+sep+args[2])
	if err != nil {
		return Filename{}, fmt.Errorf(asset.Tr("filename_date_parse_error"), s)
	}

	return Filename{status, date, strings.TrimPrefix(args[3], numberPrefix), args[4], ""}, nil
}
Example #3
0
func (o OsFile) NewWriter(name string) io.WriteCloser {
	w, err := os.Create(o.Dir + name + extension)

	if err != nil {
		log.WithFields(log.Fields{
			"filepath": o.Dir + name + extension,
			"err":      err,
		}).Error(asset.Tr("create_file_error"))
	}

	return w

}
Example #4
0
func (o OsFile) NewReader(name string) io.ReadCloser {

	r, err := os.OpenFile(o.Dir+name+extension, os.O_CREATE, 0666)

	if err != nil {
		log.WithFields(log.Fields{
			"filepath": o.Dir + name + extension,
			"err":      err,
		}).Error(asset.Tr("error_file_open"))
	}

	return r
}
Example #5
0
func AllSheets(o osfile.OsFile) []string {
	var fs []string
	list := o.GetAll()
	for _, s := range list {
		if strings.HasPrefix(s, generatedPrefix) ||
			strings.HasPrefix(s, asset.Tr("file_prefix_draft")) {
			continue
		}

		fs = append(fs, s)
	}
	return fs
}
Example #6
0
func (s Sheet) Put(o osfile.OsFile) {

	w := o.NewWriter(s.Name.String())
	defer w.Close()

	wcsv := csv.NewWriter(w)
	wcsv.WriteAll(s.Render(s.Table))

	if wcsv.Error() != nil {
		log.WithFields(log.Fields{
			"path":     o.Dir,
			"filename": s.Name.String(),
			"view":     s.Table,
			"err":      wcsv.Error(),
		}).Error(asset.Tr("error_file_csv_view_to"))
	}
}
Example #7
0
func (o OsFile) GetAll() []string {

	var out []string
	files, err := ioutil.ReadDir(o.Dir)

	if err != nil {
		log.WithFields(log.Fields{
			"err": err,
			"dir": o.Dir,
		}).Error(asset.Tr("error_dir_read"))
	}

	for _, file := range files {

		if !strings.HasSuffix(file.Name(), extension) {
			continue
		}

		out = append(out, strings.TrimSuffix(file.Name(), extension))
	}

	return out
}
Example #8
0
func main() {

	prodValHeader = []string{asset.Tr("csv_header_item_product"),
		asset.Tr("csv_header_item_value", 1), asset.Tr("csv_header_item_unit", 1),
		asset.Tr("csv_header_item_value", 2), asset.Tr("csv_header_item_unit", 2),
		asset.Tr("csv_header_item_value", 3), asset.Tr("csv_header_item_unit", 3),
		asset.Tr("csv_header_item_value", 4), asset.Tr("csv_header_item_unit", 4),
	}

	// LOGGING
	logfile := loggingPrefix + asset.Tr("file_name_log")
	f, err1 := os.OpenFile(logfile,
		os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err1 != nil {
		log.WithFields(log.Fields{
			"filename": logfile,
			"err":      err1,
		}).Error(asset.Tr("error_file_open"))
	}
	defer f.Close()

	log.SetOutput(f)
	log.SetFormatter(&log.JSONFormatter{})
	log.SetLevel(log.ErrorLevel)

	// UPDATE
	all := sheet.AllSheets(files)

	for _, name := range all {
		s := sheet.NewSheet(name, files)
		its := items.FromStringTable(s.Table.GetContentWithRowHeader())
		var cmd skelet.Ider

		switch s.Name.Act {
		case asset.Tr("file_name_stock_in"):
			cmd = stock.InCmd{stockId, its, s.Name.Time()}
		case asset.Tr("file_name_stock_out"):
			cmd = stock.OutCmd{stockId, its, s.Name.Time()}
		case asset.Tr("file_name_inventory"):
			cmd = stock.InventoryCmd{stockId, its, s.Name.Time()}
		default:
			log.Error(asset.Tr("no_action_for_filename_error"))
		}
		skelet.ExecuteCommand(skelet.Cmd{T: cmd, Route: stockRoute}, stockCmd.Chain)
	}

	// POPULATE VIEW
	stockInt, err4 := endPt.Db.Get("main")
	iStock := stockInt.(*stock.Stock).Items
	if err4 != nil {
		log.WithFields(log.Fields{
			"err": err4,
		}).Error(asset.Tr("error_query_stock"))
	}

	prodValRender := func(tab *strtab.T) [][]string {
		return tab.GetContentWithHeaders(false)
	}
	prodEvolRender := func(tab *strtab.T) [][]string {
		return tab.GetContentWithHeaders(true)
	}

	sheet.Sheet{
		sheet.NewBasicFilename(asset.Tr("file_name_stock")),
		strtab.NewT(prodValHeader, iStock.StringSlice()...).Sort(),
		prodValRender}.Put(files)

	sheet.Sheet{
		sheet.NewDraftFilename(3, asset.Tr("file_name_inventory")),
		strtab.NewT(prodValHeader, iStock.StringSlice()...).Sort(),
		prodValRender}.Put(files)

	sheet.Sheet{
		sheet.NewDraftFilename(1, asset.Tr("file_name_stock_in")),
		strtab.NewT(prodValHeader, iStock.Empty().StringSlice()...).Sort(),
		prodValRender}.Put(files)

	sheet.Sheet{
		sheet.NewDraftFilename(2, asset.Tr("file_name_stock_out")),
		strtab.NewT(prodValHeader, iStock.Empty().StringSlice()...).Sort(),
		prodValRender}.Put(files)

	sheet.Sheet{
		sheet.NewBasicFilename(asset.Tr("file_name_product")),
		strtab.NewTfromMap(items.ItemsMapToStringMapTable(
			endPt.ProdValEvol("main"))).Sort().Transpose().Sort(),
		prodEvolRender}.Put(files)
}
Example #9
0
func NewDraftFilename(id int, act string) Filename {
	return Filename{asset.Tr("file_prefix_draft"), time.Now(), strconv.Itoa(id), act, ""}
}