691 grpc account dataset

api/api.go

@@ -6,7 +6,7 @@ import (
 	"net"
 	"net/http"
 
-	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
+	grpcMiddleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	log "github.com/sirupsen/logrus"
 	"github.com/zoobc/zoobc-core/api/handler"
@@ -56,7 +56,7 @@ func startGrpcServer(
 	}
 	grpcServer := grpc.NewServer(
 		grpc.Creds(creds),
-		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
+		grpc.UnaryInterceptor(grpcMiddleware.ChainUnaryServer(
 			interceptor.NewServerRateLimiterInterceptor(constant.MaxAPIRequestPerSecond),
 			interceptor.NewServerInterceptor(
 				logger,
@@ -167,6 +167,14 @@ func startGrpcServer(
 		)})
 	// Set GRPC handler for health check
 	rpcService.RegisterHealthCheckServiceServer(grpcServer, &handler.HealthCheckHandler{})
+
+	// Set GRPC handler for account dataset
+	rpcService.RegisterAccountDatasetServiceServer(grpcServer, &handler.AccountDatasetHandler{
+		Service: service.NewAccountDatasetService(
+			query.NewAccountDatasetsQuery(),
+			queryExecutor,
+		),
+	})
 	// run grpc-gateway handler
 	go func() {
 		if err := grpcServer.Serve(serv); err != nil {
@@ -243,5 +251,6 @@ func runProxy(apiPort, rpcPort int) error {
 	_ = rpcService.RegisterEscrowTransactionServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
 	_ = rpcService.RegisterMultisigServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
 	_ = rpcService.RegisterHealthCheckServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
+	_ = rpcService.RegisterAccountDatasetServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts)
 	return http.ListenAndServe(fmt.Sprintf(":%d", apiPort), mux)
 }

api/client/GetAccountDataset/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+	"github.com/zoobc/zoobc-core/common/model"
+	rpcService "github.com/zoobc/zoobc-core/common/service"
+	"github.com/zoobc/zoobc-core/common/util"
+	"google.golang.org/grpc"
+)
+
+func main() {
+	var apiRPCPort int
+	if err := util.LoadConfig("../../../resource", "config", "toml"); err != nil {
+		logrus.Fatal(err)
+	} else {
+		apiRPCPort = viper.GetInt("apiRPCPort")
+	}
+
+	conn, err := grpc.Dial(fmt.Sprintf(":%d", apiRPCPort), grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %s", err)
+	}
+	defer conn.Close()
+
+	c := rpcService.NewAccountDatasetServiceClient(conn)
+	response, err := c.GetAccountDataset(context.Background(), &model.GetAccountDatasetRequest{
+		RecipientAccountAddress: "H1ftvv3n6CF5NDzdjmZKLRrBg6yPKHXpmatVUhQ5NWYx",
+	})
+	if err != nil {
+		log.Fatalf("error calling grpc GetAccountDatasets: %s", err.Error())
+	}
+	log.Printf("response from remote rpc_service.GetTransactions(): %s", response)
+}

api/client/GetAccountDatasets/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+	"github.com/zoobc/zoobc-core/common/model"
+	rpcService "github.com/zoobc/zoobc-core/common/service"
+	"github.com/zoobc/zoobc-core/common/util"
+	"google.golang.org/grpc"
+)
+
+func main() {
+	var apiRPCPort int
+	if err := util.LoadConfig("../../../resource", "config", "toml"); err != nil {
+		logrus.Fatal(err)
+	} else {
+		apiRPCPort = viper.GetInt("apiRPCPort")
+	}
+
+	conn, err := grpc.Dial(fmt.Sprintf(":%d", apiRPCPort), grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %s", err)
+	}
+	defer conn.Close()
+
+	c := rpcService.NewAccountDatasetServiceClient(conn)
+	response, err := c.GetAccountDatasets(context.Background(), &model.GetAccountDatasetsRequest{
+		SetterAccountAddress:    "HlZLh3VcnNlvByWoAzXOQ2jAlwFOiyO9_njI3oq5Ygha",
+		RecipientAccountAddress: "H1ftvv3n6CF5NDzdjmZKLRrBg6yPKHXpmatVUhQ5NWYx",
+	})
+	if err != nil {
+		log.Fatalf("error calling grpc GetAccountDatasets: %s", err.Error())
+	}
+	log.Printf("response from remote rpc_service.GetTransactions(): %s", response)
+}

api/handler/accountDatasetHandler.go

@@ -0,0 +1,48 @@
+package handler
+
+import (
+	"context"
+
+	"github.com/zoobc/zoobc-core/api/service"
+	"github.com/zoobc/zoobc-core/common/constant"
+	"github.com/zoobc/zoobc-core/common/model"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type AccountDatasetHandler struct {
+	Service service.AccountDatasetServiceInterface
+}
+
+func (adh *AccountDatasetHandler) GetAccountDatasets(
+	_ context.Context,
+	request *model.GetAccountDatasetsRequest,
+) (*model.GetAccountDatasetsResponse, error) {
+
+	pagination := request.GetPagination()
+	if pagination == nil {
+		pagination = &model.Pagination{
+			OrderField: "height",
+			OrderBy:    model.OrderBy_ASC,
+			Page:       0,
+			Limit:      constant.MaxAPILimitPerPage,
+		}
+	}
+	if pagination.GetLimit() > constant.MaxAPILimitPerPage {
+		return nil, status.Errorf(codes.OutOfRange, "Limit exceeded, max. %d", constant.MaxAPILimitPerPage)
+	}
+
+	return adh.Service.GetAccountDatasets(request)
+}
+
+func (adh *AccountDatasetHandler) GetAccountDataset(
+	_ context.Context,
+	request *model.GetAccountDatasetRequest,
+) (*model.AccountDataset, error) {
+
+	if request.GetRecipientAccountAddress() == "" && request.GetProperty() == "" {
+		return nil, status.Error(codes.InvalidArgument, "Request must have Property or RecipientAccountAddress")
+	}
+
+	return adh.Service.GetAccountDataset(request)
+}

api/handler/blockHandler.go

@@ -39,8 +39,8 @@ func (bs *BlockHandler) GetBlock(ctx context.Context, req *model.GetBlockRequest
 
 // GetBlocks handles request to get data of multiple blocks
 func (bs *BlockHandler) GetBlocks(ctx context.Context, req *model.GetBlocksRequest) (*model.GetBlocksResponse, error) {
-	if req.Limit > constant.MaxAPIGetBlocks {
-		return nil, status.Error(codes.OutOfRange, fmt.Sprintf("limit exceeded, max. %d", constant.MaxAPIGetBlocks))
+	if req.Limit > constant.MaxAPILimitPerPage {
+		return nil, status.Error(codes.OutOfRange, fmt.Sprintf("limit exceeded, max. %d", constant.MaxAPILimitPerPage))
 	}
 
 	chainType := chaintype.GetChainType(req.ChainType)

api/service/accountDatasetService.go

@@ -0,0 +1,133 @@
+package service
+
+import (
+	"database/sql"
+
+	"github.com/zoobc/zoobc-core/common/model"
+	"github.com/zoobc/zoobc-core/common/query"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type (
+	// AccountDatasetServiceInterface a methods collection for AccountDataset
+	AccountDatasetServiceInterface interface {
+		GetAccountDatasets(request *model.GetAccountDatasetsRequest) (*model.GetAccountDatasetsResponse, error)
+		GetAccountDataset(request *model.GetAccountDatasetRequest) (*model.AccountDataset, error)
+	}
+	// AccountDatasetService contain fields that needed for AccountDatasetServiceInterface
+	AccountDatasetService struct {
+		AccountDatasetQuery *query.AccountDatasetsQuery
+		QueryExecutor       query.ExecutorInterface
+	}
+)
+
+func NewAccountDatasetService(
+	accountDatasetQuery *query.AccountDatasetsQuery,
+	queryExecutor query.ExecutorInterface,
+) AccountDatasetServiceInterface {
+	return &AccountDatasetService{
+		AccountDatasetQuery: accountDatasetQuery,
+		QueryExecutor:       queryExecutor,
+	}
+}
+
+// GetAccountDatasets a method service that use for GetAccountDatasets Handler
+func (ads *AccountDatasetService) GetAccountDatasets(
+	request *model.GetAccountDatasetsRequest,
+) (*model.GetAccountDatasetsResponse, error) {
+	var (
+		accDatasets []*model.AccountDataset
+		rowCount    *sql.Row
+		caseQ       = query.NewCaseQuery()
+		count       uint64
+		rows        *sql.Rows
+		err         error
+	)
+
+	caseQ.Select(ads.AccountDatasetQuery.TableName, ads.AccountDatasetQuery.GetFields()...)
+	if request.GetProperty() != "" {
+		caseQ.Where(caseQ.Equal("property", request.GetProperty()))
+	}
+	if request.GetValue() != "" {
+		caseQ.Where(caseQ.Equal("value", request.GetValue()))
+	}
+	if request.GetRecipientAccountAddress() != "" {
+		caseQ.Where(caseQ.Equal("recipient_account_address", request.GetRecipientAccountAddress()))
+	}
+	if request.GetSetterAccountAddress() != "" {
+		caseQ.Where(caseQ.Equal("setter_account_address", request.GetSetterAccountAddress()))
+	}
+	if request.GetHeight() > 0 {
+		caseQ.Where(caseQ.Equal("height", request.GetHeight()))
+	}
+	caseQ.And(caseQ.Equal("latest", true))
+
+	countQ, countArgs := caseQ.Build()
+	rowCount, _ = ads.QueryExecutor.ExecuteSelectRow(query.GetTotalRecordOfSelect(countQ), false, countArgs...)
+	if err = rowCount.Scan(&count); err != nil {
+		if err != sql.ErrNoRows {
+			return nil, status.Error(codes.Internal, err.Error())
+		}
+
+		return nil, status.Error(codes.NotFound, "Record not found")
+	}
+
+	pagination := request.GetPagination()
+	if pagination.GetOrderField() != "" {
+		caseQ.OrderBy(pagination.GetOrderField(), pagination.GetOrderBy())
+	} else {
+		caseQ.OrderBy("height", pagination.GetOrderBy())
+	}
+	caseQ.Paginate(pagination.GetLimit(), pagination.GetPage())
+
+	selectQ, args := caseQ.Build()
+	rows, err = ads.QueryExecutor.ExecuteSelect(selectQ, false, args...)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+	defer rows.Close()
+
+	accDatasets, err = ads.AccountDatasetQuery.BuildModel([]*model.AccountDataset{}, rows)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	return &model.GetAccountDatasetsResponse{
+		Total:           count,
+		AccountDatasets: accDatasets,
+	}, nil
+}
+
+func (ads *AccountDatasetService) GetAccountDataset(
+	request *model.GetAccountDatasetRequest,
+) (*model.AccountDataset, error) {
+	var (
+		err        error
+		accDataset model.AccountDataset
+		row        *sql.Row
+		caseQ      = query.NewCaseQuery()
+	)
+
+	caseQ.Select(ads.AccountDatasetQuery.TableName, ads.AccountDatasetQuery.GetFields()...)
+	if request.GetProperty() != "" {
+		caseQ.Where(caseQ.Equal("property", request.GetProperty()))
+	}
+	if request.GetRecipientAccountAddress() != "" {
+		caseQ.Where(caseQ.Equal("recipient_account_address", request.GetRecipientAccountAddress()))
+	}
+	caseQ.And(caseQ.Equal("latest", 1))
+
+	selectQ, args := caseQ.Build()
+	row, _ = ads.QueryExecutor.ExecuteSelectRow(selectQ, false, args...)
+	err = ads.AccountDatasetQuery.Scan(&accDataset, row)
+	if err != nil {
+		if err != sql.ErrNoRows {
+			return nil, status.Error(codes.Internal, err.Error())
+		}
+
+		return nil, status.Error(codes.NotFound, "Record not found")
+	}
+
+	return &accDataset, nil
+}