entpb_pet_service.go

// Code generated by protoc-gen-entgrpc. DO NOT EDIT.
package entpb

import (
	context "context"
	base64 "encoding/base64"
	sqlgraph "entgo.io/ent/dialect/sql/sqlgraph"
	fmt "fmt"
	uuid "github.com/google/uuid"
	entproto "github.com/tilau2328/entcontrib/entproto"
	ent "github.com/tilau2328/entcontrib/entproto/internal/todo/ent"
	attachment "github.com/tilau2328/entcontrib/entproto/internal/todo/ent/attachment"
	pet "github.com/tilau2328/entcontrib/entproto/internal/todo/ent/pet"
	user "github.com/tilau2328/entcontrib/entproto/internal/todo/ent/user"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	strconv "strconv"
)

// PetService implements PetServiceServer
type PetService struct {
	client *ent.Client
	UnimplementedPetServiceServer
}

// NewPetService returns a new PetService
func NewPetService(client *ent.Client) *PetService {
	return &PetService{
		client: client,
	}
}

// toProtoPet transforms the ent type to the pb type
func toProtoPet(e *ent.Pet) (*Pet, error) {
	v := &Pet{}
	id := int64(e.ID)
	v.Id = id
	for _, edg := range e.Edges.Attachment {
		id, err := edg.ID.MarshalBinary()
		if err != nil {
			return nil, err
		}
		v.Attachment = append(v.Attachment, &Attachment{
			Id: id,
		})
	}
	if edg := e.Edges.Owner; edg != nil {
		id := edg.ID
		v.Owner = &User{
			Id: id,
		}
	}
	return v, nil
}

// toProtoPetList transforms a list of ent type to a list of pb type
func toProtoPetList(e []*ent.Pet) ([]*Pet, error) {
	var pbList []*Pet
	for _, entEntity := range e {
		pbEntity, err := toProtoPet(entEntity)
		if err != nil {
			return nil, status.Errorf(codes.Internal, "internal error: %s", err)
		}
		pbList = append(pbList, pbEntity)
	}
	return pbList, nil
}

// Create implements PetServiceServer.Create
func (svc *PetService) Create(ctx context.Context, req *CreatePetRequest) (*Pet, error) {
	pet := req.GetPet()
	m, err := svc.createBuilder(pet)
	if err != nil {
		return nil, err
	}
	res, err := m.Save(ctx)
	switch {
	case err == nil:
		proto, err := toProtoPet(res)
		if err != nil {
			return nil, status.Errorf(codes.Internal, "internal error: %s", err)
		}
		return proto, nil
	case sqlgraph.IsUniqueConstraintError(err):
		return nil, status.Errorf(codes.AlreadyExists, "already exists: %s", err)
	case ent.IsConstraintError(err):
		return nil, status.Errorf(codes.InvalidArgument, "invalid argument: %s", err)
	default:
		return nil, status.Errorf(codes.Internal, "internal error: %s", err)
	}

}

// Get implements PetServiceServer.Get
func (svc *PetService) Get(ctx context.Context, req *GetPetRequest) (*Pet, error) {
	var (
		err error
		get *ent.Pet
	)
	id := int(req.GetId())
	switch req.GetView() {
	case GetPetRequest_VIEW_UNSPECIFIED, GetPetRequest_BASIC:
		get, err = svc.client.Pet.Get(ctx, id)
	case GetPetRequest_WITH_EDGE_IDS:
		get, err = svc.client.Pet.Query().
			Where(pet.ID(id)).
			WithAttachment(func(query *ent.AttachmentQuery) {
				query.Select(attachment.FieldID)
			}).
			WithOwner(func(query *ent.UserQuery) {
				query.Select(user.FieldID)
			}).
			Only(ctx)
	default:
		return nil, status.Error(codes.InvalidArgument, "invalid argument: unknown view")
	}
	switch {
	case err == nil:
		return toProtoPet(get)
	case ent.IsNotFound(err):
		return nil, status.Errorf(codes.NotFound, "not found: %s", err)
	default:
		return nil, status.Errorf(codes.Internal, "internal error: %s", err)
	}

}

// Update implements PetServiceServer.Update
func (svc *PetService) Update(ctx context.Context, req *UpdatePetRequest) (*Pet, error) {
	pet := req.GetPet()
	petID := int(pet.GetId())
	m := svc.client.Pet.UpdateOneID(petID)
	for _, item := range pet.GetAttachment() {
		var attachment uuid.UUID
		if err := (&attachment).UnmarshalBinary(item.GetId()); err != nil {
			return nil, status.Errorf(codes.InvalidArgument, "invalid argument: %s", err)
		}
		m.AddAttachmentIDs(attachment)
	}
	if pet.GetOwner() != nil {
		petOwner := uint32(pet.GetOwner().GetId())
		m.SetOwnerID(petOwner)
	}

	res, err := m.Save(ctx)
	switch {
	case err == nil:
		proto, err := toProtoPet(res)
		if err != nil {
			return nil, status.Errorf(codes.Internal, "internal error: %s", err)
		}
		return proto, nil
	case sqlgraph.IsUniqueConstraintError(err):
		return nil, status.Errorf(codes.AlreadyExists, "already exists: %s", err)
	case ent.IsConstraintError(err):
		return nil, status.Errorf(codes.InvalidArgument, "invalid argument: %s", err)
	default:
		return nil, status.Errorf(codes.Internal, "internal error: %s", err)
	}

}

// Delete implements PetServiceServer.Delete
func (svc *PetService) Delete(ctx context.Context, req *DeletePetRequest) (*emptypb.Empty, error) {
	var err error
	id := int(req.GetId())
	err = svc.client.Pet.DeleteOneID(id).Exec(ctx)
	switch {
	case err == nil:
		return &emptypb.Empty{}, nil
	case ent.IsNotFound(err):
		return nil, status.Errorf(codes.NotFound, "not found: %s", err)
	default:
		return nil, status.Errorf(codes.Internal, "internal error: %s", err)
	}

}

// List implements PetServiceServer.List
func (svc *PetService) List(ctx context.Context, req *ListPetRequest) (*ListPetResponse, error) {
	var (
		err      error
		entList  []*ent.Pet
		pageSize int
	)
	pageSize = int(req.GetPageSize())
	switch {
	case pageSize < 0:
		return nil, status.Errorf(codes.InvalidArgument, "page size cannot be less than zero")
	case pageSize == 0 || pageSize > entproto.MaxPageSize:
		pageSize = entproto.MaxPageSize
	}
	listQuery := svc.client.Pet.Query().
		Order(ent.Desc(pet.FieldID)).
		Limit(pageSize + 1)
	if req.GetPageToken() != "" {
		bytes, err := base64.StdEncoding.DecodeString(req.PageToken)
		if err != nil {
			return nil, status.Errorf(codes.InvalidArgument, "page token is invalid")
		}
		token, err := strconv.ParseInt(string(bytes), 10, 32)
		if err != nil {
			return nil, status.Errorf(codes.InvalidArgument, "page token is invalid")
		}
		pageToken := int(token)
		listQuery = listQuery.
			Where(pet.IDLTE(pageToken))
	}
	switch req.GetView() {
	case ListPetRequest_VIEW_UNSPECIFIED, ListPetRequest_BASIC:
		entList, err = listQuery.All(ctx)
	case ListPetRequest_WITH_EDGE_IDS:
		entList, err = listQuery.
			WithAttachment(func(query *ent.AttachmentQuery) {
				query.Select(attachment.FieldID)
			}).
			WithOwner(func(query *ent.UserQuery) {
				query.Select(user.FieldID)
			}).
			All(ctx)
	}
	switch {
	case err == nil:
		var nextPageToken string
		if len(entList) == pageSize+1 {
			nextPageToken = base64.StdEncoding.EncodeToString(
				[]byte(fmt.Sprintf("%v", entList[len(entList)-1].ID)))
			entList = entList[:len(entList)-1]
		}
		protoList, err := toProtoPetList(entList)
		if err != nil {
			return nil, status.Errorf(codes.Internal, "internal error: %s", err)
		}
		return &ListPetResponse{
			PetList:       protoList,
			NextPageToken: nextPageToken,
		}, nil
	default:
		return nil, status.Errorf(codes.Internal, "internal error: %s", err)
	}

}

// BatchCreate implements PetServiceServer.BatchCreate
func (svc *PetService) BatchCreate(ctx context.Context, req *BatchCreatePetsRequest) (*BatchCreatePetsResponse, error) {
	requests := req.GetRequests()
	if len(requests) > entproto.MaxBatchCreateSize {
		return nil, status.Errorf(codes.InvalidArgument, "batch size cannot be greater than %d", entproto.MaxBatchCreateSize)
	}
	bulk := make([]*ent.PetCreate, len(requests))
	for i, req := range requests {
		pet := req.GetPet()
		var err error
		bulk[i], err = svc.createBuilder(pet)
		if err != nil {
			return nil, err
		}
	}
	res, err := svc.client.Pet.CreateBulk(bulk...).Save(ctx)
	switch {
	case err == nil:
		protoList, err := toProtoPetList(res)
		if err != nil {
			return nil, status.Errorf(codes.Internal, "internal error: %s", err)
		}
		return &BatchCreatePetsResponse{
			Pets: protoList,
		}, nil
	case sqlgraph.IsUniqueConstraintError(err):
		return nil, status.Errorf(codes.AlreadyExists, "already exists: %s", err)
	case ent.IsConstraintError(err):
		return nil, status.Errorf(codes.InvalidArgument, "invalid argument: %s", err)
	default:
		return nil, status.Errorf(codes.Internal, "internal error: %s", err)
	}

}

func (svc *PetService) createBuilder(pet *Pet) (*ent.PetCreate, error) {
	m := svc.client.Pet.Create()
	for _, item := range pet.GetAttachment() {
		var attachment uuid.UUID
		if err := (&attachment).UnmarshalBinary(item.GetId()); err != nil {
			return nil, status.Errorf(codes.InvalidArgument, "invalid argument: %s", err)
		}
		m.AddAttachmentIDs(attachment)
	}
	if pet.GetOwner() != nil {
		petOwner := uint32(pet.GetOwner().GetId())
		m.SetOwnerID(petOwner)
	}
	return m, nil
}