// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"mingyang-admin-pay/rpc/ent/app"
	"mingyang-admin-pay/rpc/ent/paychannel"
	"mingyang-admin-pay/rpc/ent/paynotifylog"
	"mingyang-admin-pay/rpc/ent/paynotifytask"
	"mingyang-admin-pay/rpc/ent/payorder"
	"mingyang-admin-pay/rpc/ent/payorderextension"
	"mingyang-admin-pay/rpc/ent/payrefund"
)

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 AppPager struct {
	Order  app.OrderOption
	Filter func(*AppQuery) (*AppQuery, error)
}

// AppPaginateOption enables pagination customization.
type AppPaginateOption func(*AppPager)

// DefaultAppOrder is the default ordering of App.
var DefaultAppOrder = Desc(app.FieldID)

func newAppPager(opts []AppPaginateOption) (*AppPager, error) {
	pager := &AppPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultAppOrder
	}
	return pager, nil
}

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

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

func (_m *AppQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...AppPaginateOption,
) (*AppPageList, error) {

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

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

	ret := &AppPageList{}

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

	_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 PayChannelPager struct {
	Order  paychannel.OrderOption
	Filter func(*PayChannelQuery) (*PayChannelQuery, error)
}

// PayChannelPaginateOption enables pagination customization.
type PayChannelPaginateOption func(*PayChannelPager)

// DefaultPayChannelOrder is the default ordering of PayChannel.
var DefaultPayChannelOrder = Desc(paychannel.FieldID)

func newPayChannelPager(opts []PayChannelPaginateOption) (*PayChannelPager, error) {
	pager := &PayChannelPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultPayChannelOrder
	}
	return pager, nil
}

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

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

func (_m *PayChannelQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...PayChannelPaginateOption,
) (*PayChannelPageList, error) {

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

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

	ret := &PayChannelPageList{}

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

	_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 PayNotifyLogPager struct {
	Order  paynotifylog.OrderOption
	Filter func(*PayNotifyLogQuery) (*PayNotifyLogQuery, error)
}

// PayNotifyLogPaginateOption enables pagination customization.
type PayNotifyLogPaginateOption func(*PayNotifyLogPager)

// DefaultPayNotifyLogOrder is the default ordering of PayNotifyLog.
var DefaultPayNotifyLogOrder = Desc(paynotifylog.FieldID)

func newPayNotifyLogPager(opts []PayNotifyLogPaginateOption) (*PayNotifyLogPager, error) {
	pager := &PayNotifyLogPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultPayNotifyLogOrder
	}
	return pager, nil
}

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

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

func (_m *PayNotifyLogQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...PayNotifyLogPaginateOption,
) (*PayNotifyLogPageList, error) {

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

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

	ret := &PayNotifyLogPageList{}

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

	_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 PayNotifyTaskPager struct {
	Order  paynotifytask.OrderOption
	Filter func(*PayNotifyTaskQuery) (*PayNotifyTaskQuery, error)
}

// PayNotifyTaskPaginateOption enables pagination customization.
type PayNotifyTaskPaginateOption func(*PayNotifyTaskPager)

// DefaultPayNotifyTaskOrder is the default ordering of PayNotifyTask.
var DefaultPayNotifyTaskOrder = Desc(paynotifytask.FieldID)

func newPayNotifyTaskPager(opts []PayNotifyTaskPaginateOption) (*PayNotifyTaskPager, error) {
	pager := &PayNotifyTaskPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultPayNotifyTaskOrder
	}
	return pager, nil
}

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

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

func (_m *PayNotifyTaskQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...PayNotifyTaskPaginateOption,
) (*PayNotifyTaskPageList, error) {

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

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

	ret := &PayNotifyTaskPageList{}

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

	_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 PayOrderPager struct {
	Order  payorder.OrderOption
	Filter func(*PayOrderQuery) (*PayOrderQuery, error)
}

// PayOrderPaginateOption enables pagination customization.
type PayOrderPaginateOption func(*PayOrderPager)

// DefaultPayOrderOrder is the default ordering of PayOrder.
var DefaultPayOrderOrder = Desc(payorder.FieldID)

func newPayOrderPager(opts []PayOrderPaginateOption) (*PayOrderPager, error) {
	pager := &PayOrderPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultPayOrderOrder
	}
	return pager, nil
}

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

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

func (_m *PayOrderQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...PayOrderPaginateOption,
) (*PayOrderPageList, error) {

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

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

	ret := &PayOrderPageList{}

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

	_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 PayOrderExtensionPager struct {
	Order  payorderextension.OrderOption
	Filter func(*PayOrderExtensionQuery) (*PayOrderExtensionQuery, error)
}

// PayOrderExtensionPaginateOption enables pagination customization.
type PayOrderExtensionPaginateOption func(*PayOrderExtensionPager)

// DefaultPayOrderExtensionOrder is the default ordering of PayOrderExtension.
var DefaultPayOrderExtensionOrder = Desc(payorderextension.FieldID)

func newPayOrderExtensionPager(opts []PayOrderExtensionPaginateOption) (*PayOrderExtensionPager, error) {
	pager := &PayOrderExtensionPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultPayOrderExtensionOrder
	}
	return pager, nil
}

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

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

func (_m *PayOrderExtensionQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...PayOrderExtensionPaginateOption,
) (*PayOrderExtensionPageList, error) {

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

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

	ret := &PayOrderExtensionPageList{}

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

	_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 PayRefundPager struct {
	Order  payrefund.OrderOption
	Filter func(*PayRefundQuery) (*PayRefundQuery, error)
}

// PayRefundPaginateOption enables pagination customization.
type PayRefundPaginateOption func(*PayRefundPager)

// DefaultPayRefundOrder is the default ordering of PayRefund.
var DefaultPayRefundOrder = Desc(payrefund.FieldID)

func newPayRefundPager(opts []PayRefundPaginateOption) (*PayRefundPager, error) {
	pager := &PayRefundPager{}
	for _, opt := range opts {
		opt(pager)
	}
	if pager.Order == nil {
		pager.Order = DefaultPayRefundOrder
	}
	return pager, nil
}

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

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

func (_m *PayRefundQuery) Page(
	ctx context.Context, pageNum uint64, pageSize uint64, opts ...PayRefundPaginateOption,
) (*PayRefundPageList, error) {

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

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

	ret := &PayRefundPageList{}

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

	_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
}