468 lines
15 KiB
Go
468 lines
15 KiB
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)
|
|
case "talks":
|
|
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
|
|
}
|