wechat-api/ent/pagination.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"wechat-api/ent/contact"
	"wechat-api/ent/label"
	"wechat-api/ent/labelrelationship"
	"wechat-api/ent/message"
	"wechat-api/ent/server"
	"wechat-api/ent/wx"
)

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 ContactPager struct {
	Order  contact.OrderOption
	Filter func(*ContactQuery) (*ContactQuery, error)
}

// ContactPaginateOption enables pagination customization.
type ContactPaginateOption func(*ContactPager)

// DefaultContactOrder is the default ordering of Contact.
var DefaultContactOrder = Desc(contact.FieldID)

func newContactPager(opts []ContactPaginateOption) (*ContactPager, error) {
	pager := &ContactPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultContactOrder
	}
	return pager, nil
}

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

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

func (c *ContactQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...ContactPaginateOption,
) (*ContactPageList, error) {

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

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

	ret := &ContactPageList{}

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

	query := c.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 {
		c = c.Order(pager.Order)
	} else {
		c = c.Order(DefaultContactOrder)
	}

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

	return ret, nil
}

type LabelPager struct {
	Order  label.OrderOption
	Filter func(*LabelQuery) (*LabelQuery, error)
}

// LabelPaginateOption enables pagination customization.
type LabelPaginateOption func(*LabelPager)

// DefaultLabelOrder is the default ordering of Label.
var DefaultLabelOrder = Desc(label.FieldID)

func newLabelPager(opts []LabelPaginateOption) (*LabelPager, error) {
	pager := &LabelPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultLabelOrder
	}
	return pager, nil
}

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

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

func (l *LabelQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...LabelPaginateOption,
) (*LabelPageList, error) {

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

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

	ret := &LabelPageList{}

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

	query := l.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 {
		l = l.Order(pager.Order)
	} else {
		l = l.Order(DefaultLabelOrder)
	}

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

	return ret, nil
}

type LabelRelationshipPager struct {
	Order  labelrelationship.OrderOption
	Filter func(*LabelRelationshipQuery) (*LabelRelationshipQuery, error)
}

// LabelRelationshipPaginateOption enables pagination customization.
type LabelRelationshipPaginateOption func(*LabelRelationshipPager)

// DefaultLabelRelationshipOrder is the default ordering of LabelRelationship.
var DefaultLabelRelationshipOrder = Desc(labelrelationship.FieldID)

func newLabelRelationshipPager(opts []LabelRelationshipPaginateOption) (*LabelRelationshipPager, error) {
	pager := &LabelRelationshipPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultLabelRelationshipOrder
	}
	return pager, nil
}

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

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

func (lr *LabelRelationshipQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...LabelRelationshipPaginateOption,
) (*LabelRelationshipPageList, error) {

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

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

	ret := &LabelRelationshipPageList{}

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

	query := lr.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 {
		lr = lr.Order(pager.Order)
	} else {
		lr = lr.Order(DefaultLabelRelationshipOrder)
	}

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

	return ret, nil
}

type MessagePager struct {
	Order  message.OrderOption
	Filter func(*MessageQuery) (*MessageQuery, error)
}

// MessagePaginateOption enables pagination customization.
type MessagePaginateOption func(*MessagePager)

// DefaultMessageOrder is the default ordering of Message.
var DefaultMessageOrder = Desc(message.FieldID)

func newMessagePager(opts []MessagePaginateOption) (*MessagePager, error) {
	pager := &MessagePager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultMessageOrder
	}
	return pager, nil
}

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

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

func (m *MessageQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...MessagePaginateOption,
) (*MessagePageList, error) {

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

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

	ret := &MessagePageList{}

	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(DefaultMessageOrder)
	}

	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 ServerPager struct {
	Order  server.OrderOption
	Filter func(*ServerQuery) (*ServerQuery, error)
}

// ServerPaginateOption enables pagination customization.
type ServerPaginateOption func(*ServerPager)

// DefaultServerOrder is the default ordering of Server.
var DefaultServerOrder = Desc(server.FieldID)

func newServerPager(opts []ServerPaginateOption) (*ServerPager, error) {
	pager := &ServerPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultServerOrder
	}
	return pager, nil
}

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

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

func (s *ServerQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...ServerPaginateOption,
) (*ServerPageList, error) {

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

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

	ret := &ServerPageList{}

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

	query := s.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 {
		s = s.Order(pager.Order)
	} else {
		s = s.Order(DefaultServerOrder)
	}

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

	return ret, nil
}

type WxPager struct {
	Order  wx.OrderOption
	Filter func(*WxQuery) (*WxQuery, error)
}

// WxPaginateOption enables pagination customization.
type WxPaginateOption func(*WxPager)

// DefaultWxOrder is the default ordering of Wx.
var DefaultWxOrder = Desc(wx.FieldID)

func newWxPager(opts []WxPaginateOption) (*WxPager, error) {
	pager := &WxPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultWxOrder
	}
	return pager, nil
}

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

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

func (w *WxQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...WxPaginateOption,
) (*WxPageList, error) {

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

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

	ret := &WxPageList{}

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

	query := w.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 {
		w = w.Order(pager.Order)
	} else {
		w = w.Order(DefaultWxOrder)
	}

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

	return ret, nil
}