629 lines
14 KiB
Go
629 lines
14 KiB
Go
// 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
|
|
}
|