github.com/condensat/bank-core@v0.1.0/database/query/user.go (about)

     1  // Copyright 2020 Condensat Tech. All rights reserved.
     2  // Use of this source code is governed by a MIT
     3  // license that can be found in the LICENSE file.
     4  
     5  package query
     6  
     7  import (
     8  	"errors"
     9  
    10  	"github.com/condensat/bank-core/database"
    11  	"github.com/condensat/bank-core/database/model"
    12  
    13  	"github.com/jinzhu/gorm"
    14  )
    15  
    16  var (
    17  	ErrInvalidUserID    = errors.New("Invalid UserID")
    18  	ErrInvalidUserName  = errors.New("Invalid User Name")
    19  	ErrInvalidUserEmail = errors.New("Invalid User Email")
    20  )
    21  
    22  func FindOrCreateUser(db database.Context, user model.User) (model.User, error) {
    23  	switch gdb := db.DB().(type) {
    24  	case *gorm.DB:
    25  
    26  		if len(user.Name) == 0 {
    27  			return model.User{}, ErrInvalidUserName
    28  		}
    29  
    30  		if len(user.Email) == 0 {
    31  			return model.User{}, ErrInvalidUserEmail
    32  		}
    33  
    34  		var result model.User
    35  		err := gdb.
    36  			Where(model.User{
    37  				Name:  user.Name,
    38  				Email: user.Email,
    39  			}).
    40  			Assign(user).
    41  			FirstOrCreate(&result).Error
    42  
    43  		return result, err
    44  
    45  	default:
    46  		return model.User{}, database.ErrInvalidDatabase
    47  	}
    48  }
    49  
    50  func UserExists(db database.Context, userID model.UserID) bool {
    51  	entry, err := FindUserById(db, userID)
    52  
    53  	return err == nil && entry.ID > 0
    54  }
    55  
    56  func UserCount(db database.Context) (int, error) {
    57  	switch gdb := db.DB().(type) {
    58  	case *gorm.DB:
    59  
    60  		var result int64
    61  		err := gdb.
    62  			Model(&model.User{}).
    63  			Group("email").
    64  			Count(&result).Error
    65  
    66  		return int(result), err
    67  
    68  	default:
    69  		return 0, database.ErrInvalidDatabase
    70  	}
    71  }
    72  
    73  func UserPagingCount(db database.Context, countByPage int) (int, error) {
    74  	if countByPage <= 0 {
    75  		countByPage = 1
    76  	}
    77  
    78  	switch gdb := db.DB().(type) {
    79  	case *gorm.DB:
    80  
    81  		var result int
    82  		err := gdb.
    83  			Model(&model.User{}).
    84  			Count(&result).Error
    85  		var partialPage int
    86  		if result%countByPage > 0 {
    87  			partialPage = 1
    88  		}
    89  		return result/countByPage + partialPage, err
    90  
    91  	default:
    92  		return 0, database.ErrInvalidDatabase
    93  	}
    94  }
    95  
    96  func UserPage(db database.Context, userID model.UserID, countByPage int) ([]model.User, error) {
    97  	switch gdb := db.DB().(type) {
    98  	case *gorm.DB:
    99  
   100  		if userID < 1 {
   101  			userID = 1
   102  		}
   103  		if countByPage <= 0 {
   104  			countByPage = 1
   105  		}
   106  
   107  		var list []*model.User
   108  		err := gdb.Model(&model.User{}).
   109  			Select("id, email").
   110  			Where("id >= ?", userID).
   111  			Order("id ASC").
   112  			Limit(countByPage).
   113  			Find(&list).Error
   114  
   115  		if err != nil && err != gorm.ErrRecordNotFound {
   116  			return nil, err
   117  		}
   118  
   119  		return convertUser(list), nil
   120  
   121  	default:
   122  		return nil, database.ErrInvalidDatabase
   123  	}
   124  }
   125  
   126  func FindUserById(db database.Context, userID model.UserID) (model.User, error) {
   127  	switch gdb := db.DB().(type) {
   128  	case *gorm.DB:
   129  
   130  		if userID == 0 {
   131  			return model.User{}, ErrInvalidUserID
   132  		}
   133  
   134  		var result model.User
   135  		err := gdb.
   136  			Where(&model.User{ID: userID}).
   137  			First(&result).Error
   138  
   139  		return result, err
   140  
   141  	default:
   142  		return model.User{}, database.ErrInvalidDatabase
   143  	}
   144  }
   145  
   146  func FindUserByEmail(db database.Context, email model.UserEmail) (model.User, error) {
   147  	switch gdb := db.DB().(type) {
   148  	case *gorm.DB:
   149  
   150  		if len(email) == 0 {
   151  			return model.User{}, ErrInvalidUserEmail
   152  		}
   153  
   154  		var result model.User
   155  		err := gdb.
   156  			Where(&model.User{Email: email}).
   157  			First(&result).Error
   158  
   159  		if err != nil && err != gorm.ErrRecordNotFound {
   160  			return model.User{}, err
   161  		}
   162  
   163  		return result, nil
   164  
   165  	default:
   166  		return model.User{}, database.ErrInvalidDatabase
   167  	}
   168  }
   169  
   170  func convertUser(list []*model.User) []model.User {
   171  	var result []model.User
   172  	for _, curr := range list {
   173  		if curr != nil {
   174  			result = append(result, *curr)
   175  		}
   176  	}
   177  
   178  	return result[:]
   179  }