lib-cvdata/cv.go

package cvdata

import (
	"encoding/json"
	"fmt"
	"os/exec"
	"path/filepath"

	// "github.com/jesusperez/srvcvgen"
	cfg "github.com/jesusperez/cfgsrv"
	utils "github.com/jesusperez/datautils"
	"gopkg.in/yaml.v3"
)

// type TemplateItem struct {
// 	Path string `yaml:"path"`
// 	Route string `yaml:"route"`
// }
// type Config struct {
// 	UsersPath string `yaml:"usersPath"`
// 	ModelsPath string `yaml:"modelsPath"`
// 	LogOut string `yaml:"logOut"`
// 	RequestOut string `yaml:"RequestOut"`
// 	Host string `yaml:"host"`
// 	Port int `yaml:"port"`
// 	Protocol string `yaml:"protocol"`
// 	KeyPem string `yaml:"keyPem"`
// 	CertPem string `yaml:"certPem"`
// 	AllowOrigin []string `yaml:"allowOrigin"`
// 	UseJWT bool `yaml:"useJWT"`
// 	UseAuthz bool `yaml:"useAuthz"`
//   AauthzModel string `yaml:"rbacModel"`
//   AuthzPolicy string `yaml:"rbacPolicy"`
//   RouteRoot string `yaml:"routeRoot"`
//   RouteGetPage string `yaml:"routeGetPage"`
//   RouteGetPageParam string `yaml:"routeGetPageParam"`
//   RouteGetData string `yaml:"routeGetData"`
//   RouteGetDataParam string `yaml:"routeGetDataParam"`
//   RoutePostData string `yaml:"routePostData"`
//   TemplatesRoot string `yaml:"templatesRoot"`
//   TemplatesExt string `yaml:"templatesExt"`
//   TemplatesIncludes string `yaml:"templatesIncludes"`
//   TemplatesLayouts string `yaml:"templatesLayouts"`
// 	TemplatesFiles map[string]TemplateItem `yaml:"templatesFiles"`
// 	AssetsPath string `yaml:"assetsPath"`
// 	AssetsURL string `yaml:"assetsURL"`
// 	DataDistPath string `yaml:"dataDistPath"`
// 	DataPath string `yaml:"dataPath"`
// 	DataCorePath string `yaml:"dataCorePath"`
// 	DataDflt string `yaml:"dataDflt"`
// 	DataItems []string `yaml:"dataItems"`
// 	MainLang string `yaml:"mainLang"`
// 	Langs []string `yaml:"langs"`
// 	DebugLevel int `yaml:"debugLevel"`
//   UseRepo bool `yaml:"useRepo"`
//   RepoPath string `yaml:"repoPath"`
//   RepoName string `yaml:"repoName"`
//   RepoCommit string `yaml:"repoCommit"`
// 	QuietGit bool `yaml:"quietGit"`
// }

type AuthInfoType struct {
	Editable bool `yaml:"editable" json:"editable"`
	Viewchange bool `yaml:"viewchange" json:"viewchange"`
	Show bool `yaml:"show" json:"show"`
}
type ShowInfoType struct {
	Id string `yaml:"id" json:"id"`
	Ky string `yaml:"ky" json:"ky"`
	Write bool `yaml:"write" json:"write"`
	Change bool `yaml:"change" json:"change"`
	Admin bool `yaml:"admin" json:"admin"`
	// Save bool `yaml:"save" json:"save"`
	Auth AuthInfoType `yaml:"auth" json:"auth"`
	Fullname bool `yaml:"fullname" json:"fullname"`
	Personal bool `yaml:"personal" json:"personal"`
	Title bool `yaml:"title" json:"title"`
	Image bool `yaml:"image" json:"image"`
	Mission bool `yaml:"mission" json:"mission"`
	Mission_how bool `yaml:"mission_how" json:"mission_how"`
	Phone bool `yaml:"phone" json:"phone"`
	Address bool `yaml:"address" json:"address"`
	Status bool `yaml:"status" json:"status"`
	Birthdate bool `yaml:"birthday" json:"birthdate"`
	Sites bool `yaml:"sites" json:"sites"`
	Skills bool `yaml:"skills" json:"skills"`
	Skills_itms bool `yaml:"skills_itms" json:"skills_itms"`
	Soft_Skills bool `yaml:"soft_skills" json:"soft_skills"`
	Soft_Skills_itms bool `yaml:"soft_skills_itms" json:"soft_skills_itms"`
	Infra bool `yaml:"infra" json:"infra"`
	Certs bool `yaml:"certs" json:"certs"`
	Langs bool `yaml:"langs" json:"langs"`
	Profile bool `yaml:"profile" json:"profile"`
	Work_experience_itms bool `yaml:"work_experience_itms" json:"work_experience_itms"`
	Work_experience ShowWorkExperienceType `yaml:"work_experience" json:"work_experience"`
	Projects_itms bool `yaml:"projects_itms" json:"projects_itms"`
	Projects ShowProjectType `yaml:"projects" json:"projects"`
	Education_itms bool `yaml:"education_itms" json:"education_itms"`
	Education ShowEducationType `yaml:"education" json:"education"`
	Talks_itms bool `yaml:"talks_itms" json:"talks_itms"`
	Talks ShowTalksType `yaml:"talks" json:"talks"`
	Teaching_itms bool `yaml:"teaching_itms" json:"teaching_itms"`
	Teaching ShowTeachingType `yaml:"teaching" json:"teaching"`
	Others_itms bool `yaml:"others_itms" json:"others_itms"`
	Others bool `yaml:"others" json:"others"`
}
type ModelType struct {
	Id string `yaml:"id" json:"id"`
	Title string `yaml:"title" json:"title"`
	Path string `yaml:"path" json:"path"`
}
type Models struct {
	Models []ModelType `yaml:"models" json:"models"`
}
type CVData struct {
	Models []ModelType `yaml:"models" json:"models"`
	Showinfo []ShowInfoType `yaml:"showinfo" json:"showinfo"`
	Core DataCoreType `yaml:"core" json:"core"`
	CoreLang DataLangCoreType `yaml:"corelang" json:"corelang"`
	Projects []ProjectType `yaml:"projects" json:"projects"`
	Work_experience []WorkExperienceType `yaml:"work_experience" json:"work_experience"`
	Education []EducationType `yaml:"education" json:"education"`
	Talks []TalksType `yaml:"talks" json:"talks" json:""`
	Teaching []TeachingType `yaml:"teaching" json:"teaching"`
	Others []OtherType `yaml:"others" json:"others"`
}
type CVLangData map[string]CVData
// struct {
// 	lang string `yaml:"lang" json:"lang"`
// 	Data CVData `yaml:"data" json:"data"`
// }
type CVModelData map[string]CVLangData
// type CVModelData struct {
// 	Id string `yaml:"id" json:"id"`
// 	Data CVLangData `yaml:"data" json:"data"`
// }
type DataCVgen struct {
	Data CVLangData `yaml:"data" json:"data"`
	Models []ModelType `yaml:"models" json:"models"`
}
type CVPostData struct {
	U string `yaml:"u" json:"u"`
	Data CVModelData `yaml:"data" json:"data"`
}
func (models *Models)Load(path string) ([]ModelType, error) {
	d,file,errpath := utils.DecoderFromFile(path)
	if errpath != nil {
		return models.Models, errpath
	}
	defer file.Close()
	if err := d.Decode(&models); err != nil {
		fmt.Printf("Decode: %v\n", err)
		return models.Models, err
	}
	return models.Models, nil
}

func (cvdata *CVData)Load(root_path string, lang string, config *cfg.Config) error {
	//err := *new(error)
	var err error
	for _,itm := range config.DataItems {
		itmpath := fmt.Sprintf("%s/%s.yaml",root_path,itm)
		if itm == "showinfo" {
			itmpath = fmt.Sprintf("%s/%s",root_path,itm)
		}
		if !utils.ExistsPath(itmpath) {
			continue
		}
		switch itm {
			case "showinfo":
				cvdata.Showinfo, err = loadShowData(itmpath)
			case "core":
				if lang == "" {
					var datacore DataCore
					cvdata.Core, err = datacore.Load(itmpath)
				} else {
					var datalangcore DataLangCore
					cvdata.CoreLang, err = datalangcore.Load(itmpath)
				}
			case "profile":
				var profile CoreProfile
				cvdata.Core.Profile, err = profile.Load(itmpath)
			case "projects":
				var projects Projects
				cvdata.Projects, err = projects.Load(itmpath)
			case "work_experience":
				var work_experience WorkExperience
				cvdata.Work_experience, err = work_experience.Load(itmpath)
			case "education":
				var education Education
				cvdata.Education, err = education.Load(itmpath)
			case "teaching":
				var teaching Teaching
				cvdata.Teaching, err = teaching.Load(itmpath)
			
				var talks Talks
				cvdata.Talks, err = talks.Load(itmpath)
			case "others":
				var others Others
				cvdata.Others, err = others.Load(itmpath)
			case "models":
				var models Models
				cvdata.Models, err = models.Load(itmpath)
			default:
				fmt.Printf("cvdata: %s not implemented yet\n",itm)
				continue	
		}
		if err != nil && lang == "" {
			fmt.Printf("Error load cv %s: %v\n", itm, err)
		}
	}
	return nil
} 
func (cvdata *CVData)Write(ky string, path string, config *cfg.Config) error {
	for _,itm := range config.DataItems {
		var data []byte
		var err error
		switch itm {
			case "showinfo":
				if cvdata.Showinfo == nil {
					continue
				}
				var showinfodata []ShowInfoType
				showinfodata = cvdata.Showinfo
				for _,showitm := range showinfodata {
					showitmdata := [1]ShowInfoType{showitm}
					data, err := yaml.Marshal(showitmdata)
					if err != nil {
						fmt.Printf("Error Parse cv %s (%s): %v\n", itm, showitm.Id, err)
					} else {
						if err := utils.CheckDirPath(fmt.Sprintf("%s/showinfo",path)) ; err == nil {
							if res := utils.WriteData(string(data),fmt.Sprintf("%s/showinfo/%s.yaml",path,showitm.Id)) ; res != nil {
								fmt.Printf("Error write cv %s: %v\n", itm, err)
							}
						}
					}
				}
				continue
			case "core":
				if ky == "main" {
					if len(cvdata.Core.Title1) > 0  {
						var coredata DataCore
						coredata.Core = cvdata.Core
						data, err = yaml.Marshal(coredata)
					}
				} else {
					if len(cvdata.CoreLang.Title1) > 0  {
						var corelangdata DataLangCore
						corelangdata.Core = cvdata.CoreLang
						data, err = yaml.Marshal(corelangdata)
					}
				}
			case "profile":
				if ky == "main" {
					if cvdata.Core.Profile != nil {
						var profiledata CoreProfile
						profiledata.CoreProfile = cvdata.Core.Profile
						data, err = yaml.Marshal(profiledata)
					}
				} else {
					if cvdata.CoreLang.Profile != nil {
						var profiledata CoreProfile
						profiledata.CoreProfile = cvdata.CoreLang.Profile
						data, err = yaml.Marshal(profiledata)
					}
				}
			case "projects":
				if cvdata.Projects == nil {
					continue
				}
				var projectsdata Projects
				projectsdata.Projects = cvdata.Projects
				data, err = yaml.Marshal(projectsdata)
			case "work_experience":
				if cvdata.Work_experience == nil {
				}
				var experience WorkExperience
				experience.WorkExperience = cvdata.Work_experience
				data, err = yaml.Marshal(experience)
			case "education":
				if cvdata.Education == nil {
					continue
				}
				var educationdata Education
				educationdata.Education = cvdata.Education
				data, err = yaml.Marshal(educationdata)
			case "teaching":
				if cvdata.Teaching == nil {
					continue
				}
				var teachingdata Teaching
				teachingdata.Teaching = cvdata.Teaching
				data, err = yaml.Marshal(teachingdata)
			case "talks":
				if cvdata.Talks == nil {
					continue
				}
				var talksdata Talks
				talksdata.Talks = cvdata.Talks
				data, err = yaml.Marshal(talksdata)
			case "others":
				if cvdata.Others == nil {
					continue
				}
				var othersdata Others
				othersdata.Others = cvdata.Others
				data, err = yaml.Marshal(othersdata)
			case "models":
				if cvdata.Models == nil {
					continue
				}
				var modelsdata Models
				modelsdata.Models = cvdata.Models
				data, err = yaml.Marshal(modelsdata)
			default:
				fmt.Printf("cvdata: %s not implemented yet\n",itm)
				continue
		}
		if len(data) == 0 {
			continue
		}
		if err != nil {
			fmt.Printf("Error Parse cv %s: %v\n", itm, err)
		} else {
			if res := utils.WriteData(string(data),fmt.Sprintf("%s/%s.yaml",path,itm)) ; res != nil {
				fmt.Printf("Error write cv %s: %v\n", itm, err)
			// } else if config.UseRepo && config.RepoPath != "" {
			//   pathfile :=fmt.Sprintf("%s/%s.yaml",strings.Replace(path,fmt.Sprintf("%s/",config.DataPath),"",1),itm) 
			// 	if errgit := gitCommit(config.RepoPath, pathfile, fmt.Sprintf("'%s'",config.RepoCommit),config.RepoName,config.RepoAuthName, config.RepoAuthEmail, time.Now()); errgit != nil {
	   	//     fmt.Printf("Error git commit cv %s: %v\n", pathfile, err)
			// 	}
			}
		}
	}
	return nil
}
func (cvmodel CVModelData)Write(config *cfg.Config) ([]string,error) {
	var keys []string
	root_path := config.DataPath
	for key,mdl := range cvmodel {
		keys = append(keys,fmt.Sprintf("%s:",key))
		// root_path with YAML file exists ? 
		path := fmt.Sprintf("%s/%s",root_path,key)
		//fmt.Printf("path: %+v\n", path)
		if err := utils.CheckDirPath(path) ; err != nil {
			fmt.Printf("Error create %s: %v\n",path, err)
			return keys, err
		}  
		langpath := fmt.Sprintf("%s/langs",path)
		if err := utils.CheckDirPath(langpath) ; err != nil {
			fmt.Printf("Error create %s: %v\n",langpath, err)
			return keys,err
		}
		for kylng,cvdata := range mdl {
			keys = append(keys,kylng)
			if kylng == "main" {
				if res := cvdata.Write(kylng,path,config) ; res != nil {
					fmt.Printf("Error write %s: %v\n",path, res)
					return keys,res 
				}
			}  else {
				langitempath := fmt.Sprintf("%s/%s",langpath,kylng)
				if err := utils.CheckDirPath(langitempath) ; err != nil {
					fmt.Printf("Error create %s: %v\n",langitempath, err)
					return keys,err 
				} 
				if res := cvdata.Write(kylng,langitempath,config); res != nil {
					fmt.Printf("Error write %s: %v\n",langitempath, res)
					return keys,res 
				}
			} 
		}
		if config.GenDist {
			data, err := json.Marshal(cvmodel)
			if err != nil {
				fmt.Printf("Error Parse cv %s: %v\n",key, err)
			} else {
				err := utils.CheckDirPath(fmt.Sprintf("%s",config.DataDistPath)) 
				if err == nil {
					path := fmt.Sprintf("%s/%s.json",config.DataDistPath,key)
					if res := utils.WriteData(string(data),path) ; res != nil {
						fmt.Printf("Error write cv %s: %v\n", key, err)
					} else {
						fmt.Printf("CV %s writed to: %s\n", key,path)
					}
				}
			}
		}
		if config.UseRepo && config.RepoPath != "" {
			var cmd *exec.Cmd
			var errgit error
			if cmd,_,errgit = utils.GitCommit(config.RepoPath,key,config.RepoCommit,config.RepoName,config.BackgGit,config.QuietGit); errgit != nil {
				fmt.Printf("Error git commit cv %s: %v\n", config.RepoPath, errgit)
			}
			if errgit == nil && config.BackgGit {
				if errgit = cmd.Wait(); errgit != nil {
					fmt.Printf("Error pull %s (%s): %v\n", config.RepoPath, config.RepoName,errgit)
				}
			}
		}
	}
	return keys,nil
}
func loadShowInfoItem(path string) (ShowInfoType, error) {
	var showinfo []ShowInfoType
	d,file,errpath := utils.DecoderFromFile(path)
	if errpath != nil {
		return ShowInfoType{}, errpath
	}
	defer file.Close()
	if err := d.Decode(&showinfo); err != nil {
		fmt.Printf("Decode: %v", err)
		return ShowInfoType{},err
	}
	return showinfo[0], nil
}
func loadShowData(path string) ([]ShowInfoType, error) {
	var showData []ShowInfoType
	files, err := filepath.Glob(fmt.Sprintf("%s/*.yaml",path))
	if err != nil {
		fmt.Printf("showinfo: %v", err)
		return showData,err
	}
	for _, file := range files {
		data,err := loadShowInfoItem(file)
		if err == nil {
			showData = append(showData,data)
		}
    // fmt.Println(file)
	}
	return showData,nil
}
func LoadCVData(root_path string, config *cfg.Config, useRepo bool) (DataCVgen, error) {
	var errgit error
	var cmd *exec.Cmd
	if useRepo && config.UseRepo && config.RepoPath != "" {
		if cmd,errgit = utils.GitPull(config.RepoPath,config.RepoName,config.BackgGit,config.QuietGit); errgit != nil {
			fmt.Printf("Error pull %s (%s): %v\n", config.RepoPath, config.RepoName,errgit)
		}
	}
	var datacvgen DataCVgen
	cvlangdata := make(map[string]CVData,2)
	var data CVData
	var models Models	
	mdls, _ := models.Load(fmt.Sprintf("%s/%s",config.DataPath,config.DataModelsRoot))
	datacvgen.Models = mdls
	if err := data.Load(root_path,"",config); err == nil {
		cvlangdata["main"] = data
	}
	for _,lng := range config.Langs {
		if lng != config.MainLang {
			path := fmt.Sprintf("%s/langs/%s",root_path,lng)
			var data CVData
			if err := data.Load(path,lng,config) ; err == nil {
				cvlangdata[lng] = data
			}
		} 
	}
	datacvgen.Data = cvlangdata
	if useRepo && config.UseRepo && config.RepoPath != "" && errgit == nil && config.BackgGit {
		fmt.Printf("End pull %s (%s)\n", config.RepoPath, config.RepoName)
		if errgit = cmd.Wait(); errgit != nil {
			fmt.Printf("Error pull %s (%s): %v\n", config.RepoPath, config.RepoName,errgit)
		}
	}
	return datacvgen, nil
}