ExampleGrpcService.java 12.6 KB
package com.tianting.infoloop.service.grpc;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tianting.infoloop.grpc.exampleservice.BatchCreateTestExampleDbRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.BatchCreateTestExampleDbRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.BatchUpdateTestExampleDbRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.BatchUpdateTestExampleDbRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.CreateTestExampleDbRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.CreateTestExampleDbRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.DeleteTestExampleDbByIdsRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.DeleteTestExampleDbRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.ExampleServiceRpcGrpc;
import com.tianting.infoloop.grpc.exampleservice.GetAllTestExampleDbRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.GetAllTestExampleDbRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.GetTestExampleDbByIdRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.GetTestExampleDbByIdRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.GetTestExampleDbByIdsRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.GetTestExampleDbByIdsRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.QueryTestExampleDbByConditionRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.QueryTestExampleDbByConditionRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.QueryTestExampleDbByPaginationRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.QueryTestExampleDbByPaginationRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.SingleTestExampleDbRpcResponse;
import com.tianting.infoloop.grpc.exampleservice.UpdateTestExampleDbRpcRequest;
import com.tianting.infoloop.grpc.exampleservice.UpdateTestExampleDbRpcResponse;
import com.tianting.infoloop.model.db.TestExampleDb;
import com.tianting.infoloop.service.TestExampleDbService;
import com.tianting.infoloop.utils.ProtoBeanUtil;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.stream.Collectors;

import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_MASTER;
import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_SLAVE;

@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ExampleGrpcService extends ExampleServiceRpcGrpc.ExampleServiceRpcImplBase
{

    private final TestExampleDbService testExampleDbService;

    @Override
    @DS(DATA_SOURCE_SLAVE)
    public void getTestExampleDbById(final GetTestExampleDbByIdRpcRequest request,
                                     final StreamObserver<GetTestExampleDbByIdRpcResponse> responseObserver) {
        final var builder = GetTestExampleDbByIdRpcResponse.newBuilder();
        try {
            final var data = testExampleDbService.getById(request.getId());
            if (data != null) {
                builder.setResponse(ProtoBeanUtil.beanToProto(data, SingleTestExampleDbRpcResponse.class));
            }
        } catch (final Exception e) {
            log.error("getTestExampleDbById error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_SLAVE)
    public void getTestExampleDbByIds(final GetTestExampleDbByIdsRpcRequest request,
                                      final StreamObserver<GetTestExampleDbByIdsRpcResponse> responseObserver) {
        final var builder = GetTestExampleDbByIdsRpcResponse.newBuilder();
        try {
            if (request.getIdsList().isEmpty()) {
                responseObserver.onNext(builder.build());
                responseObserver.onCompleted();
                return;
            }
            final var list = testExampleDbService.listByIds(request.getIdsList());
            if (!list.isEmpty()) {
                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleTestExampleDbRpcResponse.class));
            }
        } catch (final Exception e) {
            log.error("getTestExampleDbByIds error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_SLAVE)
    public void getAllTestExampleDb(final GetAllTestExampleDbRpcRequest request,
                                    final StreamObserver<GetAllTestExampleDbRpcResponse> responseObserver) {
        final var builder = GetAllTestExampleDbRpcResponse.newBuilder();
        try {
            final var list = testExampleDbService.list();
            if (!list.isEmpty()) {
                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleTestExampleDbRpcResponse.class));
            }
        } catch (final Exception e) {
            log.error("getAllTestExampleDb error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_SLAVE)
    public void queryTestExampleDbByCondition(final QueryTestExampleDbByConditionRpcRequest request,
                                              final StreamObserver<QueryTestExampleDbByConditionRpcResponse> responseObserver) {
        final var builder = QueryTestExampleDbByConditionRpcResponse.newBuilder();
        try {
            LambdaQueryWrapper<TestExampleDb> queryWrapper = Wrappers.lambdaQuery();
            if (request.hasName()) {
                queryWrapper.like(TestExampleDb::getName, request.getName());
            }
            if (request.hasStatus()) {
                queryWrapper.eq(TestExampleDb::getStatus, request.getStatusValue());
            }
            final var list = testExampleDbService.list(queryWrapper);
            if (!list.isEmpty()) {
                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleTestExampleDbRpcResponse.class));
            }
        } catch (final Exception e) {
            log.error("queryTestExampleDbByCondition error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_SLAVE)
    public void queryTestExampleDbByPagination(final QueryTestExampleDbByPaginationRpcRequest request,
                                              final StreamObserver<QueryTestExampleDbByPaginationRpcResponse> responseObserver) {
        final var builder = QueryTestExampleDbByPaginationRpcResponse.newBuilder();
        try {
            IPage<TestExampleDb> page = new Page<>(request.getPageNo(), request.getPageSize());
            LambdaQueryWrapper<TestExampleDb> queryWrapper = Wrappers.lambdaQuery();
            if (request.hasName()) {
                queryWrapper.like(TestExampleDb::getName, request.getName());
            }
            if (request.hasStatus()) {
                queryWrapper.eq(TestExampleDb::getStatus, request.getStatusValue());
            }
            final var result = testExampleDbService.page(page, queryWrapper);
            builder.setTotal(result.getTotal());
            builder.setPages(result.getPages());
            if (!result.getRecords().isEmpty()) {
                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(result.getRecords(), SingleTestExampleDbRpcResponse.class));
            }
        } catch (final Exception e) {
            log.error("queryTestExampleDbByCondition error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_MASTER)
    public void createTestExampleDb(final CreateTestExampleDbRpcRequest request,
                                    final StreamObserver<CreateTestExampleDbRpcResponse> responseObserver) {
        final var builder = CreateTestExampleDbRpcResponse.newBuilder();
        builder.setIsCreated(false);
        try {
            final var data = testExampleDbService.createTestExampleDb(request.getCreation());
            builder.setIsCreated(data != null).setId(data == null ? 0 : data.getId());
        } catch (final Exception e) {
            log.error("createTestExampleDb error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_MASTER)
    public void batchCreateTestExampleDb(final BatchCreateTestExampleDbRpcRequest request,
                                         final StreamObserver<BatchCreateTestExampleDbRpcResponse> responseObserver) {
        final var builder = BatchCreateTestExampleDbRpcResponse.newBuilder();
        builder.setIsCreated(false);
        try {
            final var list = testExampleDbService.batchCreateTestExampleDb(request.getCreationsList());
            builder.setIsCreated(list.size() == request.getCreationsCount()).addAllIds(list.stream().map(TestExampleDb::getId).collect(Collectors.toList()));
        } catch (final Exception e) {
            log.error("batchCreateTestExampleDb error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_MASTER)
    public void updateTestExampleDb(final UpdateTestExampleDbRpcRequest request,
                                    final StreamObserver<UpdateTestExampleDbRpcResponse> responseObserver) {
        final var builder = UpdateTestExampleDbRpcResponse.newBuilder();
        builder.setIsUpdated(false);
        try {
            builder.setIsUpdated(testExampleDbService.updateTestExampleDb(request.getModification()));
        } catch (final Exception e) {
            log.error("updateTestExampleDb error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_MASTER)
    public void batchUpdateTestExampleDb(final BatchUpdateTestExampleDbRpcRequest request,
                                         final StreamObserver<BatchUpdateTestExampleDbRpcResponse> responseObserver) {
        final var builder = BatchUpdateTestExampleDbRpcResponse.newBuilder();
        builder.setIsUpdated(false);
        try {
            builder.setIsUpdated(testExampleDbService.batchUpdateTestExampleDb(request.getModificationsList()));
        } catch (final Exception e) {
            log.error("batchUpdateTestExampleDb error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    @DS(DATA_SOURCE_MASTER)
    public void deleteTestExampleDbByIds(final DeleteTestExampleDbByIdsRpcRequest request,
                                         final StreamObserver<DeleteTestExampleDbRpcResponse> responseObserver) {
        final var builder = DeleteTestExampleDbRpcResponse.newBuilder();
        builder.setIsDeleted(false);
        try {
            if (request.getIdsList().isEmpty()) {
                responseObserver.onNext(builder.build());
                responseObserver.onCompleted();
                return;
            }
            builder.setIsDeleted(testExampleDbService.removeBatchByIds(request.getIdsList()));
        } catch (final Exception e) {
            log.error("deleteTestExampleDbByIds error;", e);
            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

}