create or update def from yaml to DB

src/model/domain.go

 package model
 
+import "time"
+
 type ClsBase struct {
 	Title   string `yaml:"title"`
 	Desc    string `yaml:"desc"`
@@ -156,6 +158,7 @@ type ResFile struct {
 	Title string `json:"title"`
 	Desc   string `json:"desc"`
 	ResType string `json:"resType"`
+	UpdatedAt time.Time `json:"updatedAt"`
 }
 type ResField struct {
 	Index int `json:"index"`

src/model/model.go

@@ -19,7 +19,7 @@ type ZdDef struct {
 
 	Yaml   string `gorm:"yaml" json:"yaml"`
 	Path   string `gorm:"column:path" json:"path" yaml:"-"`
-	Folder string `gorm:"folder" json:"folder" yaml:"-"`
+	Folder string `gorm:"column:folder" json:"folder" yaml:"-"`
 }
 func (*ZdDef) TableName() string {
 	return constant.TablePrefix + "def"

src/server/repo/config.go

@@ -10,6 +10,11 @@ type ConfigRepo struct {
 	db *gorm.DB
 }
 
+func (r *ConfigRepo) ListAll() (models []*model.ZdConfig) {
+	r.db.Find(&models)
+	return
+}
+
 func (r *ConfigRepo) List(keywords string, page int) (models []*model.ZdConfig, total int, err error) {
 	query := r.db.Select("id,title,folder,path").Order("id ASC")
 	if keywords != "" {

src/server/repo/def.go

@@ -10,6 +10,11 @@ type DefRepo struct {
 	db *gorm.DB
 }
 
+func (r *DefRepo) ListAll() (models []*model.ZdDef) {
+	r.db.Find(&models)
+	return
+}
+
 func (r *DefRepo) List(keywords string, page int) (models []*model.ZdDef, total int, err error) {
 	query := r.db.Select("id,title,folder,path").Order("id ASC")
 	if keywords != "" {

src/server/repo/excel.go

@@ -10,6 +10,11 @@ type ExcelRepo struct {
 	db *gorm.DB
 }
 
+func (r *ExcelRepo) ListAll() (models []*model.ZdExcel) {
+	r.db.Find(&models)
+	return
+}
+
 func (r *ExcelRepo) List(keywords string, page int) (models []*model.ZdExcel, total int, err error) {
 	query := r.db.Select("id,title,folder,path").Order("id ASC")
 	if keywords != "" {

src/server/repo/instances.go

@@ -10,6 +10,11 @@ type InstancesRepo struct {
 	db *gorm.DB
 }
 
+func (r *InstancesRepo) ListAll() (models []*model.ZdInstances) {
+	r.db.Find(&models)
+	return
+}
+
 func (r *InstancesRepo) List(keywords string, page int) (models []*model.ZdInstances, total int, err error) {
 	query := r.db.Select("id,title,folder,path").Order("id ASC")
 	if keywords != "" {

src/server/repo/ranges.go

@@ -10,6 +10,11 @@ type RangesRepo struct {
 	db *gorm.DB
 }
 
+func (r *RangesRepo) ListAll() (models []*model.ZdRanges) {
+	r.db.Find(&models)
+	return
+}
+
 func (r *RangesRepo) List(keywords string, page int) (models []*model.ZdRanges, total int, err error) {
 	query := r.db.Select("id,title,folder,path").Order("id ASC")
 	if keywords != "" {

src/server/repo/text.go

@@ -10,6 +10,11 @@ type TextRepo struct {
 	db *gorm.DB
 }
 
+func (r *TextRepo) ListAll() (models []*model.ZdText) {
+	r.db.Find(&models)
+	return
+}
+
 func (r *TextRepo) List(keywords string, page int) (models []*model.ZdText, total int, err error) {
 	query := r.db.Select("id,title,folder,path").Order("id ASC")
 	if keywords != "" {

src/server/service/def.go

@@ -22,12 +22,7 @@ type DefService struct {
 }
 
 func (s *DefService) List(keywords string, page int) (list []*model.ZdDef, total int) {
-	defs := s.resService.LoadRes("yaml")
-	list, _, _ = s.defRepo.List("", -1)
-	s.saveDataToDB(defs, list)
-
 	list, total, _ = s.defRepo.List(strings.TrimSpace(keywords), page)
-
 	return
 }
 
@@ -124,33 +119,21 @@ func (s *DefService) dataToYaml(def *model.ZdDef) (str string) {
 	return
 }
 
-func (s *DefService) saveDataToDB(defs []model.ResFile, list []*model.ZdDef) (err error) {
-	names := make([]string, 0)
-	for _, item := range list {
-		names = append(names, item.Path)
+func (s *DefService) Sync(files []model.ResFile) (err error) {
+	defList := s.defRepo.ListAll()
+
+	defMap := map[string]*model.ZdDef{}
+	for _, item := range defList {
+		defMap[item.Path] = item
 	}
 
-	for _, def := range defs {
-		if !stringUtils.FindInArrBool(def.Path, names) {
-			content, _ := ioutil.ReadFile(def.Path)
-			yamlContent := stringUtils.ReplaceSpecialChars(content)
-			defPo := model.ZdDef{}
-			err = yaml.Unmarshal(yamlContent, &defPo)
-			defPo.Title = def.Title
-			defPo.Type = def.ResType
-			defPo.Desc = def.Desc
-			defPo.Path = def.Path
-			defPo.Folder = serverUtils.GetRelativePath(defPo.Path)
-			defPo.Yaml = string(content)
-
-			s.defRepo.Create(&defPo)
-
-			rootField, _ := s.fieldRepo.CreateTreeNode(defPo.ID, 0, "字段", "root")
-			s.referRepo.CreateDefault(rootField.ID, constant.ResTypeDef)
-			for i, field := range defPo.Fields {
-				field.Ord = i + 1
-				s.saveFieldToDB(&field, rootField.ID, defPo.ID)
-			}
+	for _, fi := range files {
+		_, found := defMap[fi.Path]
+		if found {
+			s.defRepo.Remove(defMap[fi.Path].ID)
+		}
+		if !found || fi.UpdatedAt.Unix() > defMap[fi.Path].UpdatedAt.Unix() {
+			s.SyncToDB(fi)
 		}
 	}
 
@@ -166,6 +149,34 @@ func (s *DefService) saveFieldToDB(item *model.ZdField, parentID, defID uint) {
 	}
 }
 
+func (s *DefService) SyncToDB(fi model.ResFile) (err error) {
+	content, _ := ioutil.ReadFile(fi.Path)
+	yamlContent := stringUtils.ReplaceSpecialChars(content)
+	defPo := model.ZdDef{}
+	err = yaml.Unmarshal(yamlContent, &defPo)
+	defPo.Title = fi.Title
+	defPo.Type = fi.ResType
+	defPo.Desc = fi.Desc
+	defPo.Path = fi.Path
+	defPo.Folder = serverUtils.GetRelativePath(defPo.Path)
+	defPo.Yaml = string(content)
+
+	s.defRepo.Create(&defPo)
+
+	rootField, _ := s.fieldRepo.CreateTreeNode(defPo.ID, 0, "字段", "root")
+	s.referRepo.CreateDefault(rootField.ID, constant.ResTypeDef)
+	for i, field := range defPo.Fields {
+		field.Ord = i + 1
+		s.saveFieldToDB(&field, rootField.ID, defPo.ID)
+	}
+
+	return
+}
+func (s *DefService) SyncFromDB(files []model.ResFile) (err error) {
+
+	return
+}
+
 func NewDefService(defRepo *serverRepo.DefRepo, fieldRepo *serverRepo.FieldRepo,
 	referRepo *serverRepo.ReferRepo) *DefService {
 	return &DefService{defRepo: defRepo, fieldRepo: fieldRepo, referRepo: referRepo}

src/server/service/res.go

@@ -45,17 +45,17 @@ func (s *ResService) LoadRes(resType string) (ret []model.ResFile) {
 
 func (s *ResService) ListReferForSelection(resType string) (ret interface{}) {
 	if resType == "ranges" {
-		ret, _, _ = s.rangesRepo.List("",-1)
+		ret = s.rangesRepo.ListAll()
 	} else if resType == "instances" {
-		ret, _, _ = s.instancesRepo.List("",-1)
+		ret = s.instancesRepo.ListAll()
 	} else if resType == "config" {
-		ret, _, _ = s.configRepo.List("",-1)
+		ret = s.configRepo.ListAll()
 	} else if resType == "yaml" {
-		ret, _, _ = s.defRepo.List("",-1)
+		ret = s.defRepo.ListAll()
 	} else if resType == "excel" {
-		ret, _, _ = s.excelRepo.List("",-1)
+		ret = s.excelRepo.ListAll()
 	} else if resType == "text" {
-		ret, _, _ = s.textRepo.List("",-1)
+		ret = s.textRepo.ListAll()
 	}
 
 	return

src/server/service/sync.go

+package serverService
+
+import "github.com/easysoft/zendata/src/model"
+
+type SyncService struct {
+	defService *DefService
+	fieldService *FieldService
+	rangesService *RangesService
+	instancesService *InstancesService
+	configService *ConfigService
+	excelService *ExcelService
+	textService *TextService
+	referService *ReferService
+	resService *ResService
+}
+
+func (s *SyncService) SyncData(mode string) { // TODO: overwrite or not
+	files := s.resService.LoadRes("")
+
+	fileMap := map[string][]model.ResFile{}
+	for _, fi := range files {
+		if fileMap[fi.ResType] == nil {
+			fileMap[fi.ResType] = make([]model.ResFile, 0)
+		}
+		fileMap[fi.ResType] = append(fileMap[fi.ResType], fi)
+	}
+
+	defs := fileMap["yaml"]
+
+	s.defService.Sync(defs)
+}
+
+func NewSyncService(
+	defService *DefService,
+	fieldService *FieldService,
+	rangesService *RangesService,
+	instancesService *InstancesService,
+	configService *ConfigService,
+	excelService *ExcelService,
+	textService *TextService,
+	referService *ReferService,
+	resService *ResService) *SyncService {
+	return &SyncService{
+		defService: defService,
+		fieldService: fieldService,
+		rangesService: rangesService,
+		instancesService: instancesService,
+		configService: configService,
+		excelService: excelService,
+		textService: textService,
+		referService: referService,
+		resService: resService,
+	}
+}

src/zd.go

@@ -279,6 +279,7 @@ type Server struct {
 	sectionService *serverService.SectionService
 	referService *serverService.ReferService
 	resService *serverService.ResService
+	syncService *serverService.SyncService
 
 	rangesService *serverService.RangesService
 	instancesService *serverService.InstancesService
@@ -305,8 +306,6 @@ func Init() (err error) {
 	defService := serverService.NewDefService(defRepo, fieldRepo, referRepo)
 	fieldService := serverService.NewFieldService(defRepo, fieldRepo, referRepo)
 	sectionService := serverService.NewSectionService(fieldRepo, sectionRepo)
-	referService := serverService.NewReferService(fieldRepo, referRepo)
-
 	rangesService := serverService.NewRangesService(rangesRepo)
 	instancesService := serverService.NewInstancesService(instancesRepo, referRepo)
 	textService := serverService.NewTextService(textRepo)
@@ -315,8 +314,13 @@ func Init() (err error) {
 	resService := serverService.NewResService(rangesRepo, instancesRepo,
 		configRepo, excelRepo, textRepo, defRepo)
 
+	referService := serverService.NewReferService(fieldRepo, referRepo)
+	syncService := serverService.NewSyncService(defService,
+		fieldService, rangesService, instancesService, configService, excelService, textService,
+		referService, resService)
+
 	server := NewServer(config, defService, fieldService, sectionService, referService,
-		rangesService, instancesService, textService, excelService, configService, resService)
+		rangesService, instancesService, textService, excelService, configService, resService, syncService)
 	server.Run()
 
 	return
@@ -358,6 +362,8 @@ func (s *Server) admin(writer http.ResponseWriter, req *http.Request) {
 	ret := model.ResData{ Code: 1, Msg: "success"}
 	switch reqData.Action {
 	// def
+	case "syncData":
+		s.syncService.SyncData(reqData.Mode)
 	case "listDef":
 		ret.Data, ret.Total = s.defService.List(reqData.Keywords, reqData.Page)
 	case "getDef":
@@ -533,7 +539,7 @@ func NewServer(config *serverConfig.Config, defService *serverService.DefService
 	referService *serverService.ReferService, rangesService *serverService.RangesService,
 	instancesService *serverService.InstancesService, textService *serverService.TextService,
 	excelService *serverService.ExcelService, configService *serverService.ConfigService,
-	resService *serverService.ResService) *Server {
+	resService *serverService.ResService, syncService *serverService.SyncService) *Server {
 	return &Server{
 		config:        config,
 		defService: defService,
@@ -546,6 +552,7 @@ func NewServer(config *serverConfig.Config, defService *serverService.DefService
 		excelService: excelService,
 		configService: configService,
 		resService: resService,
+		syncService: syncService,
 	}
 }
 

ui/src/api/manage.js

@@ -378,3 +378,13 @@ export function removeExcel (id) {
     data: data
   })
 }
+
+export function syncData () {
+  const data = {'action': 'syncData', mode: ''}
+
+  return request({
+    url: api.admin,
+    method: 'post',
+    data: data
+  })
+}

ui/src/layout/ColLayout.vue

@@ -14,6 +14,7 @@
 
 <script>
 import Menu from "./Menu";
+import {syncData} from "../api/manage";
 
 export default {
   name: 'ColLayout',
@@ -33,6 +34,9 @@ export default {
   methods: {
     syncData() {
       console.log("syncData")
+      syncData().then(json => {
+        console.log('syncData', json)
+      })
     }
   }
 }