mingyang-admin-iot-app/rpc/ent/pagination.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"mingyang-admin-app-rpc/ent/user"
	"mingyang-admin-app-rpc/ent/userloginlog"
	"mingyang-admin-app-rpc/ent/userthirdauth"
)

const errInvalidPage = "INVALID_PAGE"

const (
	listField     = "list"
	pageNumField  = "pageNum"
	pageSizeField = "pageSize"
)

type PageDetails struct {
	Page  uint64 `json:"page"`
	Size  uint64 `json:"size"`
	Total uint64 `json:"total"`
}

// OrderDirection defines the directions in which to order a list of items.
type OrderDirection string

const (
	// OrderDirectionAsc specifies an ascending order.
	OrderDirectionAsc OrderDirection = "ASC"
	// OrderDirectionDesc specifies a descending order.
	OrderDirectionDesc OrderDirection = "DESC"
)

// Validate the order direction value.
func (o OrderDirection) Validate() error {
	if o != OrderDirectionAsc && o != OrderDirectionDesc {
		return fmt.Errorf("%s is not a valid OrderDirection", o)
	}
	return nil
}

// String implements fmt.Stringer interface.
func (o OrderDirection) String() string {
	return string(o)
}

func (o OrderDirection) reverse() OrderDirection {
	if o == OrderDirectionDesc {
		return OrderDirectionAsc
	}
	return OrderDirectionDesc
}

const errInvalidPagination = "INVALID_PAGINATION"

type UserPager struct {
	Order  user.OrderOption
	Filter func(*UserQuery) (*UserQuery, error)
}

// UserPaginateOption enables pagination customization.
type UserPaginateOption func(*UserPager)

// DefaultUserOrder is the default ordering of User.
var DefaultUserOrder = Desc(user.FieldID)

func newUserPager(opts []UserPaginateOption) (*UserPager, error) {
	pager := &UserPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultUserOrder
	}
	return pager, nil
}

func (p *UserPager) ApplyFilter(query *UserQuery) (*UserQuery, error) {
	if p.Filter != nil {
		return p.Filter(query)
	}
	return query, nil
}

// UserPageList is User PageList result.
type UserPageList struct {
	List        []*User      `json:"list"`
	PageDetails *PageDetails `json:"pageDetails"`
}

func (_m *UserQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...UserPaginateOption,
) (*UserPageList, error) {

	pager, err := newUserPager(opts)
	if err != nil {
		return nil, err
	}

	if _m, err = pager.ApplyFilter(_m); err != nil {
		return nil, err
	}

	ret := &UserPageList{}

	ret.PageDetails = &PageDetails{
		Page: pageNum,
		Size: pageSize,
	}

	query := _m.Clone()
	query.ctx.Fields = nil
	count, err := query.Count(ctx)

	if err != nil {
		return nil, err
	}

	ret.PageDetails.Total = uint64(count)

	if pager.Order != nil {
		_m = _m.Order(pager.Order)
	} else {
		_m = _m.Order(DefaultUserOrder)
	}

	_m = _m.Offset(int((pageNum - 1) * pageSize)).Limit(int(pageSize))
	list, err := _m.All(ctx)
	if err != nil {
		return nil, err
	}
	ret.List = list

	return ret, nil
}

type UserLoginLogPager struct {
	Order  userloginlog.OrderOption
	Filter func(*UserLoginLogQuery) (*UserLoginLogQuery, error)
}

// UserLoginLogPaginateOption enables pagination customization.
type UserLoginLogPaginateOption func(*UserLoginLogPager)

// DefaultUserLoginLogOrder is the default ordering of UserLoginLog.
var DefaultUserLoginLogOrder = Desc(userloginlog.FieldID)

func newUserLoginLogPager(opts []UserLoginLogPaginateOption) (*UserLoginLogPager, error) {
	pager := &UserLoginLogPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultUserLoginLogOrder
	}
	return pager, nil
}

func (p *UserLoginLogPager) ApplyFilter(query *UserLoginLogQuery) (*UserLoginLogQuery, error) {
	if p.Filter != nil {
		return p.Filter(query)
	}
	return query, nil
}

// UserLoginLogPageList is UserLoginLog PageList result.
type UserLoginLogPageList struct {
	List        []*UserLoginLog `json:"list"`
	PageDetails *PageDetails    `json:"pageDetails"`
}

func (_m *UserLoginLogQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...UserLoginLogPaginateOption,
) (*UserLoginLogPageList, error) {

	pager, err := newUserLoginLogPager(opts)
	if err != nil {
		return nil, err
	}

	if _m, err = pager.ApplyFilter(_m); err != nil {
		return nil, err
	}

	ret := &UserLoginLogPageList{}

	ret.PageDetails = &PageDetails{
		Page: pageNum,
		Size: pageSize,
	}

	query := _m.Clone()
	query.ctx.Fields = nil
	count, err := query.Count(ctx)

	if err != nil {
		return nil, err
	}

	ret.PageDetails.Total = uint64(count)

	if pager.Order != nil {
		_m = _m.Order(pager.Order)
	} else {
		_m = _m.Order(DefaultUserLoginLogOrder)
	}

	_m = _m.Offset(int((pageNum - 1) * pageSize)).Limit(int(pageSize))
	list, err := _m.All(ctx)
	if err != nil {
		return nil, err
	}
	ret.List = list

	return ret, nil
}

type UserThirdAuthPager struct {
	Order  userthirdauth.OrderOption
	Filter func(*UserThirdAuthQuery) (*UserThirdAuthQuery, error)
}

// UserThirdAuthPaginateOption enables pagination customization.
type UserThirdAuthPaginateOption func(*UserThirdAuthPager)

// DefaultUserThirdAuthOrder is the default ordering of UserThirdAuth.
var DefaultUserThirdAuthOrder = Desc(userthirdauth.FieldID)

func newUserThirdAuthPager(opts []UserThirdAuthPaginateOption) (*UserThirdAuthPager, error) {
	pager := &UserThirdAuthPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultUserThirdAuthOrder
	}
	return pager, nil
}

func (p *UserThirdAuthPager) ApplyFilter(query *UserThirdAuthQuery) (*UserThirdAuthQuery, error) {
	if p.Filter != nil {
		return p.Filter(query)
	}
	return query, nil
}

// UserThirdAuthPageList is UserThirdAuth PageList result.
type UserThirdAuthPageList struct {
	List        []*UserThirdAuth `json:"list"`
	PageDetails *PageDetails     `json:"pageDetails"`
}

func (_m *UserThirdAuthQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...UserThirdAuthPaginateOption,
) (*UserThirdAuthPageList, error) {

	pager, err := newUserThirdAuthPager(opts)
	if err != nil {
		return nil, err
	}

	if _m, err = pager.ApplyFilter(_m); err != nil {
		return nil, err
	}

	ret := &UserThirdAuthPageList{}

	ret.PageDetails = &PageDetails{
		Page: pageNum,
		Size: pageSize,
	}

	query := _m.Clone()
	query.ctx.Fields = nil
	count, err := query.Count(ctx)

	if err != nil {
		return nil, err
	}

	ret.PageDetails.Total = uint64(count)

	if pager.Order != nil {
		_m = _m.Order(pager.Order)
	} else {
		_m = _m.Order(DefaultUserThirdAuthOrder)
	}

	_m = _m.Offset(int((pageNum - 1) * pageSize)).Limit(int(pageSize))
	list, err := _m.All(ctx)
	if err != nil {
		return nil, err
	}
	ret.List = list

	return ret, nil
}