github.com/wanlay/gorm-dm8@v1.0.5/mask.go (about)

     1  package dm
     2  
     3  import (
     4  	"database/sql"
     5  	"gorm.io/gorm"
     6  	"gorm.io/gorm/clause"
     7  	"reflect"
     8  	"strings"
     9  )
    10  
    11  type STable struct {
    12  	Conn  *gorm.DB
    13  	Table interface{}
    14  }
    15  
    16  var conn *gorm.DB
    17  
    18  func Table(table ...interface{}) *STable {
    19  	var tb interface{}
    20  	if len(table) == 1 {
    21  		tb = table[0]
    22  	}
    23  	return &STable{Table: tb, Conn: conn}
    24  }
    25  
    26  func TB(db *gorm.DB) {
    27  	conn = db
    28  }
    29  
    30  func (stb *STable) DB() (*sql.DB, error) {
    31  	return stb.Conn.DB()
    32  }
    33  
    34  func (stb *STable) Model() *gorm.DB {
    35  	if reflect.ValueOf(stb.Table).Kind() == reflect.String {
    36  		return stb.Conn.Table(stb.Table.(string))
    37  	}
    38  	return stb.Conn.Model(stb.Table)
    39  }
    40  
    41  func (stb *STable) Create() error {
    42  	return stb.Conn.Create(stb.Table).Error
    43  }
    44  
    45  func (stb *STable) Get(dest interface{}, conds ...interface{}) error {
    46  	return stb.Conn.Where(stb.Table).First(dest, conds...).Error
    47  }
    48  
    49  func (stb *STable) GetWhere(dest interface{}) error {
    50  	return stb.Conn.Model(stb.Table).Where(stb.Table).Find(dest).Error
    51  }
    52  
    53  func (stb *STable) GetAll(dest interface{}) error {
    54  	return stb.Conn.Model(stb.Table).Find(dest).Error
    55  }
    56  
    57  func (stb *STable) ClausesAssignmentColumns(name string, doUpdates []string) error {
    58  	return stb.Conn.Clauses(clause.OnConflict{
    59  		Columns:   []clause.Column{{Name: name}},
    60  		DoUpdates: clause.AssignmentColumns(doUpdates),
    61  	}).Create(stb.Table).Error
    62  }
    63  
    64  func (stb *STable) Delete() error {
    65  	tx := stb.Conn.Begin()
    66  	if err := tx.Where(stb.Table).Delete(stb.Table).Error; err != nil {
    67  		tx.Rollback()
    68  		return err
    69  	}
    70  	return tx.Commit().Error
    71  }
    72  
    73  func (stb *STable) Update(dest interface{}) error {
    74  	tx := stb.Conn.Begin()
    75  	if err := tx.Where(stb.Table).Updates(dest).Error; err != nil {
    76  		tx.Rollback()
    77  		return err
    78  	}
    79  	return tx.Commit().Error
    80  }
    81  
    82  func (stb *STable) AutoMigrate(dst ...interface{}) error {
    83  	return stb.Conn.AutoMigrate(dst...)
    84  }
    85  
    86  func (stb *STable) DropTable(dest ...interface{}) error {
    87  	return stb.Conn.Migrator().DropTable(dest...)
    88  }
    89  
    90  func (stb *STable) HasTable(dest interface{}) bool {
    91  	return stb.Conn.Migrator().HasTable(dest)
    92  }
    93  
    94  func RefClone(inter interface{}) interface{} {
    95  	nInter := reflect.New(reflect.TypeOf(inter).Elem())
    96  
    97  	val := reflect.ValueOf(inter).Elem()
    98  	nVal := nInter.Elem()
    99  	for i := 0; i < val.NumField(); i++ {
   100  		nvField := nVal.Field(i)
   101  		nvField.Set(val.Field(i))
   102  	}
   103  
   104  	return nInter.Interface()
   105  }
   106  
   107  func RefInclude(inter interface{}, inc []string) interface{} {
   108  	v := reflect.ValueOf(inter).Elem()
   109  
   110  	for i := 0; i < v.Type().NumField(); i++ {
   111  		n := v.Type().Field(i).Name
   112  		var ins bool
   113  
   114  		for _, str := range inc {
   115  			if strings.ToLower(n) == strings.ToLower(str) {
   116  				ins = true
   117  			}
   118  		}
   119  
   120  		if !ins {
   121  			v.Field(i).Set(reflect.Zero(v.Field(i).Type()))
   122  		}
   123  	}
   124  
   125  	return inter
   126  }