github.com/easysoft/zendata@v0.0.0-20240513203326-705bd5a7fd67/internal/pkg/service/res.go (about)

     1  package service
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  
     7  	"time"
     8  
     9  	consts "github.com/easysoft/zendata/internal/pkg/const"
    10  	"github.com/easysoft/zendata/internal/pkg/domain"
    11  	"github.com/easysoft/zendata/internal/pkg/helper"
    12  	fileUtils "github.com/easysoft/zendata/pkg/utils/file"
    13  	i118Utils "github.com/easysoft/zendata/pkg/utils/i118"
    14  	logUtils "github.com/easysoft/zendata/pkg/utils/log"
    15  	stringUtils "github.com/easysoft/zendata/pkg/utils/string"
    16  	"github.com/easysoft/zendata/pkg/utils/vari"
    17  	"gopkg.in/yaml.v3"
    18  )
    19  
    20  type ResService struct {
    21  	FieldService        *FieldService        `inject:""`
    22  	ResYamlService      *ResYamlService      `inject:""`
    23  	ResExcelService     *ResExcelService     `inject:""`
    24  	ResRangesService    *ResRangesService    `inject:""`
    25  	ResInstancesService *ResInstancesService `inject:""`
    26  }
    27  
    28  func (s *ResService) LoadResDef(fieldsToExport []string) (res map[string]map[string][]interface{}) {
    29  	vari.GlobalVars.ResData = map[string]map[string][]interface{}{}
    30  
    31  	for index, field := range vari.GlobalVars.DefData.Fields {
    32  		if !stringUtils.StrInArr(field.Field, fieldsToExport) {
    33  			continue
    34  		}
    35  
    36  		if (field.Use != "" || field.Select != "") && field.From == "" {
    37  			field.From = vari.GlobalVars.DefData.From
    38  			vari.GlobalVars.DefData.Fields[index].From = vari.GlobalVars.DefData.From
    39  		}
    40  
    41  		s.loadResForFieldRecursive(&field)
    42  	}
    43  	return
    44  }
    45  
    46  func (s *ResService) loadResForFieldRecursive(field *domain.DefField) {
    47  	if len(field.Fields) > 0 { // child fields
    48  		for _, child := range field.Fields {
    49  			if child.Use != "" && child.From == "" {
    50  				child.From = field.From
    51  			}
    52  
    53  			child.FileDir = field.FileDir
    54  			s.loadResForFieldRecursive(&child)
    55  		}
    56  
    57  	} else if len(field.Froms) > 0 { // multiple from
    58  		for _, child := range field.Froms {
    59  			if child.Use != "" && child.From == "" {
    60  				child.From = field.From
    61  			}
    62  
    63  			child.FileDir = field.FileDir
    64  			s.loadResForFieldRecursive(&child)
    65  		}
    66  
    67  	} else if field.From != "" && field.Type != consts.FieldTypeArticle { // from a res
    68  		var valueMap map[string][]interface{}
    69  		resFile, resType, sheet := fileUtils.GetResProp(field.From, field.FileDir) // relate to current file
    70  
    71  		start := time.Now().Unix()
    72  
    73  		valueMap, _ = s.GetResValueFromExcelOrYaml(resFile, resType, sheet, field)
    74  
    75  		end := time.Now().Unix()
    76  		fmt.Println(end - start)
    77  
    78  		if vari.GlobalVars.ResData[s.GetFromKey(field)] == nil {
    79  			vari.GlobalVars.ResData[s.GetFromKey(field)] = map[string][]interface{}{}
    80  		}
    81  
    82  		for key, val := range valueMap {
    83  			resKey := key
    84  			// avoid article key to be duplicate
    85  			if vari.GlobalVars.DefData.Type == consts.DefTypeArticle {
    86  				resKey = resKey + "_" + field.Field
    87  			}
    88  			vari.GlobalVars.ResData[s.GetFromKey(field)][resKey] = val
    89  		}
    90  
    91  	} else if field.Config != "" { // from a config
    92  		resFile, resType, _ := fileUtils.GetResProp(field.Config, field.FileDir)
    93  		values, _ := s.GetResValueFromExcelOrYaml(resFile, resType, "", field)
    94  		vari.GlobalVars.ResData[field.Config] = values
    95  	}
    96  }
    97  
    98  func (s *ResService) GetResValueFromExcelOrYaml(resFile, resType, sheet string, field *domain.DefField) (map[string][]interface{}, string) {
    99  	resName := ""
   100  	groupedValues := map[string][]interface{}{}
   101  
   102  	if resType == "yaml" {
   103  		groupedValues = s.ResYamlService.GetResFromYaml(resFile)
   104  	} else if resType == "excel" {
   105  		groupedValues = s.ResExcelService.GetResFromExcel(resFile, sheet, field)
   106  	}
   107  
   108  	return groupedValues, resName
   109  }
   110  
   111  func (s *ResService) GetReferencedRangeOrInstant(inst domain.DefField) (referencedRanges domain.ResRanges, referencedInsts domain.ResInstances) {
   112  	resFile, _, _ := fileUtils.GetResProp(inst.From, inst.FileDir)
   113  
   114  	yamlContent, err := os.ReadFile(resFile)
   115  	yamlContent = helper.ReplaceSpecialChars(yamlContent)
   116  	if err != nil {
   117  		logUtils.PrintTo(i118Utils.I118Prt.Sprintf("fail_to_read_file", resFile))
   118  		return
   119  	}
   120  
   121  	err1 := yaml.Unmarshal(yamlContent, &referencedRanges)
   122  	if err1 != nil || referencedRanges.Ranges == nil || len(referencedRanges.Ranges) == 0 { // parse ranges failed
   123  		err2 := yaml.Unmarshal(yamlContent, &referencedInsts)
   124  		if err2 != nil || referencedInsts.Instances == nil || len(referencedInsts.Instances) == 0 { // parse instances failed
   125  			logUtils.PrintTo(i118Utils.I118Prt.Sprintf("fail_to_parse_file", resFile))
   126  			return
   127  		} else { // is instances
   128  			referencedInsts.FileDir = fileUtils.GetAbsDir(resFile)
   129  		}
   130  	} else { // is ranges
   131  		referencedRanges.FileDir = fileUtils.GetAbsDir(resFile)
   132  	}
   133  
   134  	return
   135  }
   136  
   137  func (s *ResService) GetFromKey(field *domain.DefField) string {
   138  	return fmt.Sprintf("%s-%s-%s", field.From, field.Use, field.Select)
   139  }