github.com/ngocphuongnb/tetua@v0.0.7-alpha/app/mock/repository/role.go (about)

     1  package mockrepository
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"math"
     7  	"strconv"
     8  	"strings"
     9  
    10  	"github.com/ngocphuongnb/tetua/app/entities"
    11  	"github.com/ngocphuongnb/tetua/app/utils"
    12  )
    13  
    14  type RoleRepository struct {
    15  	*Repository[entities.Role]
    16  }
    17  
    18  func (m *RoleRepository) ByName(ctx context.Context, name string) (*entities.Role, error) {
    19  	if ctx.Value("query_error") != nil {
    20  		return nil, errors.New("ByName error")
    21  	}
    22  
    23  	return getEntityByField(name, m.entities, "Name", name)
    24  }
    25  
    26  func (m *RoleRepository) All(ctx context.Context) ([]*entities.Role, error) {
    27  	if ctx.Value("query_error") != nil {
    28  		return nil, errors.New("Get all roles error")
    29  	}
    30  	return m.entities, nil
    31  }
    32  func (m *RoleRepository) Find(ctx context.Context, filters ...*entities.RoleFilter) ([]*entities.Role, error) {
    33  	if len(filters) == 0 {
    34  		return m.entities, nil
    35  	}
    36  	filter := *filters[0]
    37  	result := make([]*entities.Role, 0)
    38  	if filter.Page < 1 {
    39  		filter.Page = 1
    40  	}
    41  	if filter.Limit < 1 {
    42  		filter.Limit = 10
    43  	}
    44  	offset := (filter.Page - 1) * filter.Limit
    45  
    46  	for index, role := range m.entities {
    47  		if index < offset {
    48  			continue
    49  		}
    50  		if index >= offset+filter.Limit {
    51  			break
    52  		}
    53  
    54  		if filter.Search != "" {
    55  			if !strings.Contains(role.Name, filter.Search) {
    56  				continue
    57  			}
    58  		}
    59  
    60  		if len(filter.ExcludeIDs) > 0 && utils.SliceContains(filter.ExcludeIDs, role.ID) {
    61  			continue
    62  		}
    63  
    64  		result = append(result, role)
    65  	}
    66  
    67  	return result, nil
    68  }
    69  
    70  func (m *RoleRepository) Count(ctx context.Context, filters ...*entities.RoleFilter) (int, error) {
    71  	if len(filters) == 0 {
    72  		return len(m.entities), nil
    73  	}
    74  	filter := *filters[0]
    75  	count := 0
    76  	if filter.Page < 1 {
    77  		filter.Page = 1
    78  	}
    79  	if filter.Limit < 1 {
    80  		filter.Limit = 10
    81  	}
    82  	offset := (filter.Page - 1) * filter.Limit
    83  
    84  	for index, role := range m.entities {
    85  		if index < offset {
    86  			continue
    87  		}
    88  		if index >= offset+filter.Limit {
    89  			break
    90  		}
    91  
    92  		if filter.Search != "" {
    93  			if !strings.Contains(role.Name, filter.Search) {
    94  				continue
    95  			}
    96  		}
    97  
    98  		if len(filter.ExcludeIDs) > 0 && utils.SliceContains(filter.ExcludeIDs, role.ID) {
    99  			continue
   100  		}
   101  
   102  		count++
   103  	}
   104  
   105  	return count, nil
   106  }
   107  
   108  func (m *RoleRepository) Paginate(ctx context.Context, filters ...*entities.RoleFilter) (*entities.Paginate[entities.Role], error) {
   109  	comments, err := m.Find(ctx, filters...)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  
   114  	count, err := m.Count(ctx, filters...)
   115  	if err != nil {
   116  		return nil, err
   117  	}
   118  
   119  	filter := filters[0]
   120  	if filter.Page < 1 {
   121  		filter.Page = 1
   122  	}
   123  	if filter.Limit < 1 {
   124  		filter.Limit = 10
   125  	}
   126  	return &entities.Paginate[entities.Role]{
   127  		Data:        comments,
   128  		PageSize:    filter.Limit,
   129  		PageCurrent: filter.Page,
   130  		Total:       int(math.Ceil(float64(count) / float64(filter.Limit))),
   131  	}, nil
   132  }
   133  
   134  func (m *RoleRepository) SetPermissions(ctx context.Context, id int, permissions []*entities.PermissionValue) error {
   135  	found := false
   136  
   137  	for index, role := range m.entities {
   138  		if role.ID == id {
   139  			found = true
   140  			permissionID := 0
   141  			m.entities[index].Permissions = utils.SliceMap(permissions, func(item *entities.PermissionValue) *entities.Permission {
   142  				permissionID++
   143  				return &entities.Permission{
   144  					ID:     permissionID,
   145  					Action: item.Action,
   146  					Value:  item.Value.String(),
   147  				}
   148  			})
   149  		}
   150  	}
   151  
   152  	if !found {
   153  		return &entities.NotFoundError{Message: "Role not found with id: " + strconv.Itoa(id)}
   154  	}
   155  
   156  	return nil
   157  }