140 lines
3.2 KiB
Go
140 lines
3.2 KiB
Go
// Copyright 2017 The OpenPitrix Authors. All rights reserved.
|
|
// Use of this source code is governed by a Apache license
|
|
// that can be found in the LICENSE file.
|
|
|
|
package pbutil
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/golang/protobuf/ptypes"
|
|
"github.com/golang/protobuf/ptypes/timestamp"
|
|
"github.com/golang/protobuf/ptypes/wrappers"
|
|
|
|
"openpitrix.io/openpitrix/pkg/db"
|
|
"openpitrix.io/openpitrix/pkg/logger"
|
|
)
|
|
|
|
type RequestHadOffset interface {
|
|
GetOffset() uint32
|
|
}
|
|
|
|
type RequestHadLimit interface {
|
|
GetLimit() uint32
|
|
}
|
|
|
|
const (
|
|
DefaultOffset = uint64(0)
|
|
DefaultLimit = uint64(20)
|
|
)
|
|
|
|
func GetOffsetFromRequest(req RequestHadOffset) uint64 {
|
|
n := req.GetOffset()
|
|
if n == 0 {
|
|
return DefaultOffset
|
|
}
|
|
return db.GetOffset(uint64(n))
|
|
}
|
|
|
|
func GetLimitFromRequest(req RequestHadLimit) uint64 {
|
|
n := req.GetLimit()
|
|
if n == 0 {
|
|
return DefaultLimit
|
|
}
|
|
return db.GetLimit(uint64(n))
|
|
}
|
|
|
|
func GetTime(t *timestamp.Timestamp) (tt time.Time) {
|
|
if t == nil {
|
|
return time.Now()
|
|
} else {
|
|
return FromProtoTimestamp(t)
|
|
}
|
|
}
|
|
|
|
func FromProtoTimestamp(t *timestamp.Timestamp) (tt time.Time) {
|
|
tt, err := ptypes.Timestamp(t)
|
|
if err != nil {
|
|
logger.Critical(nil, "Cannot convert timestamp [T] to time.Time [%+v]: %+v", t, err)
|
|
panic(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func ToProtoTimestamp(t time.Time) (tt *timestamp.Timestamp) {
|
|
if t.IsZero() {
|
|
return nil
|
|
}
|
|
tt, err := ptypes.TimestampProto(t)
|
|
if err != nil {
|
|
logger.Critical(nil, "Cannot convert time.Time [%+v] to ToProtoTimestamp[T]: %+v", t, err)
|
|
panic(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func ToProtoString(str string) *wrappers.StringValue {
|
|
return &wrappers.StringValue{Value: str}
|
|
}
|
|
|
|
func ToProtoUInt32(uint32 uint32) *wrappers.UInt32Value {
|
|
return &wrappers.UInt32Value{Value: uint32}
|
|
}
|
|
|
|
func ToProtoInt32(i int32) *wrappers.Int32Value {
|
|
return &wrappers.Int32Value{Value: i}
|
|
}
|
|
|
|
func ToProtoBool(bool bool) *wrappers.BoolValue {
|
|
return &wrappers.BoolValue{Value: bool}
|
|
}
|
|
|
|
func ToProtoBytes(bytes []byte) *wrappers.BytesValue {
|
|
return &wrappers.BytesValue{Value: bytes}
|
|
}
|
|
|
|
type DescribeResponse interface {
|
|
GetTotalCount() uint32
|
|
}
|
|
|
|
type DescribeApi interface {
|
|
SetRequest(ctx context.Context, req interface{}, limit, offset uint32) error
|
|
Describe(ctx context.Context, req interface{}, advancedParams ...string) (DescribeResponse, error)
|
|
}
|
|
|
|
func DescribeAllResponses(ctx context.Context, describeApi DescribeApi, req interface{}, advancedParams ...string) ([]DescribeResponse, error) {
|
|
limit := uint32(db.DefaultSelectLimit)
|
|
offset := uint32(0)
|
|
var responses []DescribeResponse
|
|
|
|
if err := describeApi.SetRequest(ctx, req, limit, offset); err != nil {
|
|
return nil, err
|
|
}
|
|
response, err := describeApi.Describe(ctx, req, advancedParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
totalCount := response.GetTotalCount()
|
|
|
|
responses = append(responses, response)
|
|
offset = offset + db.DefaultSelectLimit
|
|
for {
|
|
if totalCount > uint32(offset) {
|
|
if err := describeApi.SetRequest(ctx, req, limit, offset); err != nil {
|
|
return nil, err
|
|
}
|
|
response, err = describeApi.Describe(ctx, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
responses = append(responses, response)
|
|
offset = offset + db.DefaultSelectLimit
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
return responses, nil
|
|
}
|