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

     1  package mockrepository
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"math"
     7  	"strings"
     8  
     9  	"github.com/ngocphuongnb/tetua/app/entities"
    10  	"github.com/ngocphuongnb/tetua/app/utils"
    11  )
    12  
    13  type TopicRepository struct {
    14  	*Repository[entities.Topic]
    15  }
    16  
    17  func (m *TopicRepository) ByName(ctx context.Context, name string) (*entities.Topic, error) {
    18  	return getEntityByField(name, m.entities, "Name", name)
    19  }
    20  
    21  func (m *TopicRepository) All(ctx context.Context) ([]*entities.Topic, error) {
    22  	if ctx.Value("query_error") != nil {
    23  		return nil, errors.New("Get all topics error")
    24  	}
    25  	return m.entities, nil
    26  }
    27  func (m *TopicRepository) Find(ctx context.Context, filters ...*entities.TopicFilter) ([]*entities.Topic, error) {
    28  	if len(filters) == 0 {
    29  		return m.entities, nil
    30  	}
    31  	filter := *filters[0]
    32  	result := make([]*entities.Topic, 0)
    33  	if filter.Page < 1 {
    34  		filter.Page = 1
    35  	}
    36  	if filter.Limit < 1 {
    37  		filter.Limit = 10
    38  	}
    39  	offset := (filter.Page - 1) * filter.Limit
    40  
    41  	for index, topic := range m.entities {
    42  		if index < offset {
    43  			continue
    44  		}
    45  		if index >= offset+filter.Limit {
    46  			break
    47  		}
    48  
    49  		if filter.Search != "" {
    50  			if !strings.Contains(topic.Name, filter.Search) {
    51  				continue
    52  			}
    53  		}
    54  
    55  		if len(filter.ExcludeIDs) > 0 && utils.SliceContains(filter.ExcludeIDs, topic.ID) {
    56  			continue
    57  		}
    58  
    59  		result = append(result, topic)
    60  	}
    61  
    62  	return result, nil
    63  }
    64  
    65  func (m *TopicRepository) Count(ctx context.Context, filters ...*entities.TopicFilter) (int, error) {
    66  	if len(filters) == 0 {
    67  		return len(m.entities), nil
    68  	}
    69  	filter := *filters[0]
    70  	count := 0
    71  	if filter.Page < 1 {
    72  		filter.Page = 1
    73  	}
    74  	if filter.Limit < 1 {
    75  		filter.Limit = 10
    76  	}
    77  	offset := (filter.Page - 1) * filter.Limit
    78  
    79  	for index, topic := range m.entities {
    80  		if index < offset {
    81  			continue
    82  		}
    83  		if index >= offset+filter.Limit {
    84  			break
    85  		}
    86  
    87  		if filter.Search != "" {
    88  			if !strings.Contains(topic.Name, filter.Search) {
    89  				continue
    90  			}
    91  		}
    92  
    93  		if len(filter.ExcludeIDs) > 0 && utils.SliceContains(filter.ExcludeIDs, topic.ID) {
    94  			continue
    95  		}
    96  
    97  		count++
    98  	}
    99  
   100  	return count, nil
   101  }
   102  
   103  func (m *TopicRepository) Paginate(ctx context.Context, filters ...*entities.TopicFilter) (*entities.Paginate[entities.Topic], error) {
   104  	topics, err := m.Find(ctx, filters...)
   105  	if err != nil {
   106  		return nil, err
   107  	}
   108  
   109  	count, err := m.Count(ctx, filters...)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  
   114  	filter := filters[0]
   115  	if filter.Page < 1 {
   116  		filter.Page = 1
   117  	}
   118  	if filter.Limit < 1 {
   119  		filter.Limit = 10
   120  	}
   121  	return &entities.Paginate[entities.Topic]{
   122  		Data:        topics,
   123  		PageSize:    filter.Limit,
   124  		PageCurrent: filter.Page,
   125  		Total:       int(math.Ceil(float64(count) / float64(filter.Limit))),
   126  	}, nil
   127  }