github.com/easysoft/zendata@v0.0.0-20240513203326-705bd5a7fd67/internal/server/repo/field.go (about)

     1  package serverRepo
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/easysoft/zendata/internal/pkg/model"
     7  	"gorm.io/gorm"
     8  )
     9  
    10  type FieldRepo struct {
    11  	DB *gorm.DB `inject:""`
    12  }
    13  
    14  func (r *FieldRepo) GetDefFieldTree(defId uint) (root *model.ZdField, err error) {
    15  	fields, err := r.ListByDef(defId)
    16  
    17  	if err != nil {
    18  		return nil, err
    19  	}
    20  	if len(fields) == 0 {
    21  		return nil, fmt.Errorf("no fields")
    22  	}
    23  
    24  	root = fields[0]
    25  	children := make([]*model.ZdField, 0)
    26  	if len(fields) > 1 {
    27  		children = fields[1:]
    28  	}
    29  
    30  	r.makeTree(children, root)
    31  	return
    32  }
    33  
    34  func (r *FieldRepo) CreateTreeNode(defId, targetId uint, name string, mode string) (field *model.ZdField, err error) {
    35  	field = &model.ZdField{DefID: defId}
    36  	field.Field = name
    37  	if mode == "root" {
    38  		field.DefID = defId
    39  		field.ParentID = 0
    40  	} else {
    41  		var target model.ZdField
    42  
    43  		err = r.DB.Where("id=?", targetId).First(&target).Error
    44  		field.DefID = target.DefID
    45  
    46  		if mode == "child" {
    47  			field.ParentID = target.ID
    48  		} else {
    49  			field.ParentID = target.ParentID
    50  		}
    51  		field.Ord = r.GetMaxOrder(field.ParentID)
    52  	}
    53  
    54  	err = r.DB.Save(field).Error
    55  	return
    56  }
    57  
    58  func (r *FieldRepo) GetMaxOrder(parentId uint) (ord int) {
    59  	var preChild model.ZdField
    60  	err := r.DB.
    61  		Where("parentID=?", parentId).
    62  		Order("ord DESC").Limit(1).
    63  		First(&preChild).Error
    64  
    65  	if err != nil {
    66  		ord = 1
    67  	}
    68  	ord = preChild.Ord + 1
    69  
    70  	return
    71  }
    72  
    73  func (r *FieldRepo) ListByDef(defId uint) (fields []*model.ZdField, err error) {
    74  	err = r.DB.Where("defID=?", defId).Order("parentID ASC ,ord ASC").Find(&fields).Error
    75  	return
    76  }
    77  
    78  func (r *FieldRepo) Get(fieldId uint) (field model.ZdField, err error) {
    79  	err = r.DB.Where("id=?", fieldId).First(&field).Error
    80  	return
    81  }
    82  
    83  func (r *FieldRepo) Save(field *model.ZdField) (err error) {
    84  	err = r.DB.Save(field).Error
    85  	return
    86  }
    87  func (r *FieldRepo) UpdateRange(rang string, id uint) (err error) {
    88  	err = r.DB.Model(&model.ZdField{}).Where("id=?", id).Update("range", rang).Error
    89  
    90  	return
    91  }
    92  
    93  func (r *FieldRepo) makeTree(Data []*model.ZdField, node *model.ZdField) { //参数为父节点，添加父节点的子节点指针切片
    94  	children, _ := r.haveChild(Data, node) //判断节点是否有子节点并返回
    95  	if children != nil {
    96  		node.Fields = append(node.Fields, children[0:]...) //添加子节点
    97  		for _, v := range children {                       //查询子节点的子节点，并添加到子节点
    98  			_, has := r.haveChild(Data, v)
    99  			if has {
   100  				r.makeTree(Data, v) //递归添加节点
   101  			}
   102  		}
   103  	}
   104  }
   105  
   106  func (r *FieldRepo) haveChild(Data []*model.ZdField, node *model.ZdField) (child []*model.ZdField, yes bool) {
   107  	for _, v := range Data {
   108  		if v.ParentID == node.ID {
   109  			child = append(child, v)
   110  		}
   111  	}
   112  	if child != nil {
   113  		yes = true
   114  	}
   115  	return
   116  }
   117  
   118  func (r *FieldRepo) Remove(id uint) (err error) {
   119  	field := model.ZdField{}
   120  	field.ID = id
   121  	err = r.DB.Delete(field).Error
   122  
   123  	return
   124  }
   125  
   126  func (r *FieldRepo) GetChildren(defId, fieldId uint) (children []*model.ZdField, err error) {
   127  	err = r.DB.Where("defID=? AND parentID=?", defId, fieldId).Find(&children).Error
   128  	return
   129  }
   130  
   131  func (r *FieldRepo) SetIsRange(fieldId uint, b bool) (err error) {
   132  	err = r.DB.Model(&model.ZdField{}).
   133  		Where("id = ?", fieldId).Update("isRange", b).Error
   134  
   135  	return
   136  }
   137  
   138  func (r *FieldRepo) AddOrderForTargetAndNextCases(srcID uint, targetOrder int, targetParentID uint) (err error) {
   139  	sql := fmt.Sprintf(`update %s set ord = ord + 1 where ord >= %d and parentID = %d and id!=%d`,
   140  		(&model.ZdField{}).TableName(), targetOrder, targetParentID, srcID)
   141  	err = r.DB.Exec(sql).Error
   142  
   143  	return
   144  }
   145  
   146  func (r *FieldRepo) AddOrderForNextCases(srcID uint, targetOrder int, targetParentID uint) (err error) {
   147  	sql := fmt.Sprintf(`update %s set ord = ord + 1 where ord > %d and parentID = %d and id!=%d`,
   148  		(&model.ZdField{}).TableName(), targetOrder, targetParentID, srcID)
   149  	err = r.DB.Exec(sql).Error
   150  
   151  	return
   152  }
   153  
   154  func (r *FieldRepo) UpdateOrdAndParent(field model.ZdField) (err error) {
   155  	err = r.DB.Model(&field).UpdateColumns(model.ZdField{Ord: field.Ord, ParentID: field.ParentID}).Error
   156  
   157  	return
   158  }
   159  
   160  func NewFieldRepo(db *gorm.DB) *FieldRepo {
   161  	return &FieldRepo{DB: db}
   162  }