commit

rpc/integral.proto

@@ -23,11 +23,15 @@ service Integral {
    //新增积分
   rpc  addFlow(addReq) returns(addResp);
    //调整结存
-  rpc  updateBalance(addReq) return(addResp);
+  rpc  updateBalance(addReq) returns(addResp);
    //调整余额
-  rpc  updateTotal(addReq) return(addResp);
-
-  rpc update(addReq) returns(addResp);
-  rpc select(checkReq) returns(checkResp);
+  rpc  updateTotal(addReq) returns(addResp);
+
+  //消耗积分
+  rpc  integralConsume(addReq) returns(addResp);
+  //积分守护
+  rpc  integralGuard(addReq) returns(addResp);
+  //到期积分查询
+  rpc  integralCheck(addReq) returns(addResp);
 }
 

rpc/integral/integral.pb.go

@@ -241,16 +241,27 @@ var file_integral_proto_rawDesc = []byte{
 	0x73, 0x65, 0x72, 0x49, 0x64, 0x22, 0x2d, 0x0a, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65,
 	0x73, 0x70, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74,
 	0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f,
-	0x69, 0x6e, 0x74, 0x73, 0x32, 0x98, 0x01, 0x0a, 0x08, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61,
-	0x6c, 0x12, 0x2a, 0x0a, 0x03, 0x61, 0x64, 0x64, 0x12, 0x10, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67,
-	0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x69, 0x6e, 0x74,
-	0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2d, 0x0a,
-	0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x10, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72,
-	0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x69, 0x6e, 0x74, 0x65,
-	0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x31, 0x0a, 0x06,
-	0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x12, 0x12, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61,
-	0x6c, 0x2e, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x1a, 0x13, 0x2e, 0x69, 0x6e, 0x74,
-	0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x62,
+	0x69, 0x6e, 0x74, 0x73, 0x32, 0xc8, 0x02, 0x0a, 0x08, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61,
+	0x6c, 0x12, 0x2e, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x10, 0x2e, 0x69,
+	0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11,
+	0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73,
+	0x70, 0x12, 0x34, 0x0a, 0x0d, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e,
+	0x63, 0x65, 0x12, 0x10, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64,
+	0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e,
+	0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x32, 0x0a, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x10, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61,
+	0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67,
+	0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x36, 0x0a, 0x0f, 0x69,
+	0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x12, 0x10,
+	0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x71,
+	0x1a, 0x11, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52,
+	0x65, 0x73, 0x70, 0x12, 0x34, 0x0a, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x47,
+	0x75, 0x61, 0x72, 0x64, 0x12, 0x10, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e,
+	0x61, 0x64, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61,
+	0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x34, 0x0a, 0x0d, 0x69, 0x6e, 0x74,
+	0x65, 0x67, 0x72, 0x61, 0x6c, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x12, 0x10, 0x2e, 0x69, 0x6e, 0x74,
+	0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x69,
+	0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x2e, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x62,
 	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
@@ -274,14 +285,20 @@ var file_integral_proto_goTypes = []interface{}{
 	(*CheckResp)(nil), // 3: integral.checkResp
 }
 var file_integral_proto_depIdxs = []int32{
-	0, // 0: integral.Integral.add:input_type -> integral.addReq
-	0, // 1: integral.Integral.update:input_type -> integral.addReq
-	2, // 2: integral.Integral.select:input_type -> integral.checkReq
-	1, // 3: integral.Integral.add:output_type -> integral.addResp
-	1, // 4: integral.Integral.update:output_type -> integral.addResp
-	3, // 5: integral.Integral.select:output_type -> integral.checkResp
-	3, // [3:6] is the sub-list for method output_type
-	0, // [0:3] is the sub-list for method input_type
+	0, // 0: integral.Integral.addFlow:input_type -> integral.addReq
+	0, // 1: integral.Integral.updateBalance:input_type -> integral.addReq
+	0, // 2: integral.Integral.updateTotal:input_type -> integral.addReq
+	0, // 3: integral.Integral.integralConsume:input_type -> integral.addReq
+	0, // 4: integral.Integral.integralGuard:input_type -> integral.addReq
+	0, // 5: integral.Integral.integralCheck:input_type -> integral.addReq
+	1, // 6: integral.Integral.addFlow:output_type -> integral.addResp
+	1, // 7: integral.Integral.updateBalance:output_type -> integral.addResp
+	1, // 8: integral.Integral.updateTotal:output_type -> integral.addResp
+	1, // 9: integral.Integral.integralConsume:output_type -> integral.addResp
+	1, // 10: integral.Integral.integralGuard:output_type -> integral.addResp
+	1, // 11: integral.Integral.integralCheck:output_type -> integral.addResp
+	6, // [6:12] is the sub-list for method output_type
+	0, // [0:6] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name
@@ -374,9 +391,18 @@ const _ = grpc.SupportPackageIsVersion6
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type IntegralClient interface {
-	Add(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
-	Update(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
-	Select(ctx context.Context, in *CheckReq, opts ...grpc.CallOption) (*CheckResp, error)
+	//新增积分
+	AddFlow(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
+	//调整结存
+	UpdateBalance(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
+	//调整余额
+	UpdateTotal(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
+	//消耗积分
+	IntegralConsume(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
+	//积分守护
+	IntegralGuard(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
+	//到期积分查询
+	IntegralCheck(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error)
 }
 
 type integralClient struct {
@@ -387,27 +413,54 @@ func NewIntegralClient(cc grpc.ClientConnInterface) IntegralClient {
 	return &integralClient{cc}
 }
 
-func (c *integralClient) Add(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
+func (c *integralClient) AddFlow(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
 	out := new(AddResp)
-	err := c.cc.Invoke(ctx, "/integral.Integral/add", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/integral.Integral/addFlow", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *integralClient) Update(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
+func (c *integralClient) UpdateBalance(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
 	out := new(AddResp)
-	err := c.cc.Invoke(ctx, "/integral.Integral/update", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/integral.Integral/updateBalance", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *integralClient) Select(ctx context.Context, in *CheckReq, opts ...grpc.CallOption) (*CheckResp, error) {
-	out := new(CheckResp)
-	err := c.cc.Invoke(ctx, "/integral.Integral/select", in, out, opts...)
+func (c *integralClient) UpdateTotal(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
+	out := new(AddResp)
+	err := c.cc.Invoke(ctx, "/integral.Integral/updateTotal", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *integralClient) IntegralConsume(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
+	out := new(AddResp)
+	err := c.cc.Invoke(ctx, "/integral.Integral/integralConsume", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *integralClient) IntegralGuard(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
+	out := new(AddResp)
+	err := c.cc.Invoke(ctx, "/integral.Integral/integralGuard", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *integralClient) IntegralCheck(ctx context.Context, in *AddReq, opts ...grpc.CallOption) (*AddResp, error) {
+	out := new(AddResp)
+	err := c.cc.Invoke(ctx, "/integral.Integral/integralCheck", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -416,79 +469,151 @@ func (c *integralClient) Select(ctx context.Context, in *CheckReq, opts ...grpc.
 
 // IntegralServer is the server API for Integral service.
 type IntegralServer interface {
-	Add(context.Context, *AddReq) (*AddResp, error)
-	Update(context.Context, *AddReq) (*AddResp, error)
-	Select(context.Context, *CheckReq) (*CheckResp, error)
+	//新增积分
+	AddFlow(context.Context, *AddReq) (*AddResp, error)
+	//调整结存
+	UpdateBalance(context.Context, *AddReq) (*AddResp, error)
+	//调整余额
+	UpdateTotal(context.Context, *AddReq) (*AddResp, error)
+	//消耗积分
+	IntegralConsume(context.Context, *AddReq) (*AddResp, error)
+	//积分守护
+	IntegralGuard(context.Context, *AddReq) (*AddResp, error)
+	//到期积分查询
+	IntegralCheck(context.Context, *AddReq) (*AddResp, error)
 }
 
 // UnimplementedIntegralServer can be embedded to have forward compatible implementations.
 type UnimplementedIntegralServer struct {
 }
 
-func (*UnimplementedIntegralServer) Add(context.Context, *AddReq) (*AddResp, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Add not implemented")
+func (*UnimplementedIntegralServer) AddFlow(context.Context, *AddReq) (*AddResp, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AddFlow not implemented")
+}
+func (*UnimplementedIntegralServer) UpdateBalance(context.Context, *AddReq) (*AddResp, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateBalance not implemented")
+}
+func (*UnimplementedIntegralServer) UpdateTotal(context.Context, *AddReq) (*AddResp, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateTotal not implemented")
 }
-func (*UnimplementedIntegralServer) Update(context.Context, *AddReq) (*AddResp, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
+func (*UnimplementedIntegralServer) IntegralConsume(context.Context, *AddReq) (*AddResp, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method IntegralConsume not implemented")
 }
-func (*UnimplementedIntegralServer) Select(context.Context, *CheckReq) (*CheckResp, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Select not implemented")
+func (*UnimplementedIntegralServer) IntegralGuard(context.Context, *AddReq) (*AddResp, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method IntegralGuard not implemented")
+}
+func (*UnimplementedIntegralServer) IntegralCheck(context.Context, *AddReq) (*AddResp, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method IntegralCheck not implemented")
 }
 
 func RegisterIntegralServer(s *grpc.Server, srv IntegralServer) {
 	s.RegisterService(&_Integral_serviceDesc, srv)
 }
 
-func _Integral_Add_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Integral_AddFlow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IntegralServer).AddFlow(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/integral.Integral/AddFlow",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IntegralServer).AddFlow(ctx, req.(*AddReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Integral_UpdateBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(AddReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(IntegralServer).Add(ctx, in)
+		return srv.(IntegralServer).UpdateBalance(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/integral.Integral/Add",
+		FullMethod: "/integral.Integral/UpdateBalance",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(IntegralServer).Add(ctx, req.(*AddReq))
+		return srv.(IntegralServer).UpdateBalance(ctx, req.(*AddReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Integral_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Integral_UpdateTotal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(AddReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(IntegralServer).Update(ctx, in)
+		return srv.(IntegralServer).UpdateTotal(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/integral.Integral/Update",
+		FullMethod: "/integral.Integral/UpdateTotal",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(IntegralServer).Update(ctx, req.(*AddReq))
+		return srv.(IntegralServer).UpdateTotal(ctx, req.(*AddReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Integral_Select_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CheckReq)
+func _Integral_IntegralConsume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(IntegralServer).Select(ctx, in)
+		return srv.(IntegralServer).IntegralConsume(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/integral.Integral/Select",
+		FullMethod: "/integral.Integral/IntegralConsume",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(IntegralServer).Select(ctx, req.(*CheckReq))
+		return srv.(IntegralServer).IntegralConsume(ctx, req.(*AddReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Integral_IntegralGuard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IntegralServer).IntegralGuard(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/integral.Integral/IntegralGuard",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IntegralServer).IntegralGuard(ctx, req.(*AddReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Integral_IntegralCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IntegralServer).IntegralCheck(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/integral.Integral/IntegralCheck",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IntegralServer).IntegralCheck(ctx, req.(*AddReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -498,16 +623,28 @@ var _Integral_serviceDesc = grpc.ServiceDesc{
 	HandlerType: (*IntegralServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
-			MethodName: "add",
-			Handler:    _Integral_Add_Handler,
+			MethodName: "addFlow",
+			Handler:    _Integral_AddFlow_Handler,
+		},
+		{
+			MethodName: "updateBalance",
+			Handler:    _Integral_UpdateBalance_Handler,
+		},
+		{
+			MethodName: "updateTotal",
+			Handler:    _Integral_UpdateTotal_Handler,
+		},
+		{
+			MethodName: "integralConsume",
+			Handler:    _Integral_IntegralConsume_Handler,
 		},
 		{
-			MethodName: "update",
-			Handler:    _Integral_Update_Handler,
+			MethodName: "integralGuard",
+			Handler:    _Integral_IntegralGuard_Handler,
 		},
 		{
-			MethodName: "select",
-			Handler:    _Integral_Select_Handler,
+			MethodName: "integralCheck",
+			Handler:    _Integral_IntegralCheck_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},

rpc/integralclient/integral.go

@@ -14,15 +14,24 @@ import (
 )
 
 type (
-	AddReq    = integral.AddReq
-	AddResp   = integral.AddResp
 	CheckReq  = integral.CheckReq
 	CheckResp = integral.CheckResp
+	AddReq    = integral.AddReq
+	AddResp   = integral.AddResp
 
 	Integral interface {
-		Add(ctx context.Context, in *AddReq) (*AddResp, error)
-		Update(ctx context.Context, in *AddReq) (*AddResp, error)
-		Select(ctx context.Context, in *CheckReq) (*CheckResp, error)
+		// 新增积分
+		AddFlow(ctx context.Context, in *AddReq) (*AddResp, error)
+		// 调整结存
+		UpdateBalance(ctx context.Context, in *AddReq) (*AddResp, error)
+		// 调整余额
+		UpdateTotal(ctx context.Context, in *AddReq) (*AddResp, error)
+		// 消耗积分
+		IntegralConsume(ctx context.Context, in *AddReq) (*AddResp, error)
+		// 积分守护
+		IntegralGuard(ctx context.Context, in *AddReq) (*AddResp, error)
+		// 到期积分查询
+		IntegralCheck(ctx context.Context, in *AddReq) (*AddResp, error)
 	}
 
 	defaultIntegral struct {
@@ -36,17 +45,38 @@ func NewIntegral(cli zrpc.Client) Integral {
 	}
 }
 
-func (m *defaultIntegral) Add(ctx context.Context, in *AddReq) (*AddResp, error) {
+// 新增积分
+func (m *defaultIntegral) AddFlow(ctx context.Context, in *AddReq) (*AddResp, error) {
+	client := integral.NewIntegralClient(m.cli.Conn())
+	return client.AddFlow(ctx, in)
+}
+
+// 调整结存
+func (m *defaultIntegral) UpdateBalance(ctx context.Context, in *AddReq) (*AddResp, error) {
+	client := integral.NewIntegralClient(m.cli.Conn())
+	return client.UpdateBalance(ctx, in)
+}
+
+// 调整余额
+func (m *defaultIntegral) UpdateTotal(ctx context.Context, in *AddReq) (*AddResp, error) {
+	client := integral.NewIntegralClient(m.cli.Conn())
+	return client.UpdateTotal(ctx, in)
+}
+
+// 消耗积分
+func (m *defaultIntegral) IntegralConsume(ctx context.Context, in *AddReq) (*AddResp, error) {
 	client := integral.NewIntegralClient(m.cli.Conn())
-	return client.Add(ctx, in)
+	return client.IntegralConsume(ctx, in)
 }
 
-func (m *defaultIntegral) Update(ctx context.Context, in *AddReq) (*AddResp, error) {
+// 积分守护
+func (m *defaultIntegral) IntegralGuard(ctx context.Context, in *AddReq) (*AddResp, error) {
 	client := integral.NewIntegralClient(m.cli.Conn())
-	return client.Update(ctx, in)
+	return client.IntegralGuard(ctx, in)
 }
 
-func (m *defaultIntegral) Select(ctx context.Context, in *CheckReq) (*CheckResp, error) {
+// 到期积分查询
+func (m *defaultIntegral) IntegralCheck(ctx context.Context, in *AddReq) (*AddResp, error) {
 	client := integral.NewIntegralClient(m.cli.Conn())
-	return client.Select(ctx, in)
+	return client.IntegralCheck(ctx, in)
 }

rpc/internal/logic/addflowlogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"points_service/rpc/integral"
+	"points_service/rpc/internal/svc"
+
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+type AddFlowLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewAddFlowLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddFlowLogic {
+	return &AddFlowLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// 新增积分
+func (l *AddFlowLogic) AddFlow(in *integral.AddReq) (*integral.AddResp, error) {
+	// todo: add your logic here and delete this line
+
+	return &integral.AddResp{}, nil
+}

rpc/internal/logic/integralchecklogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"points_service/rpc/integral"
+	"points_service/rpc/internal/svc"
+
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+type IntegralCheckLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewIntegralCheckLogic(ctx context.Context, svcCtx *svc.ServiceContext) *IntegralCheckLogic {
+	return &IntegralCheckLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// 到期积分查询
+func (l *IntegralCheckLogic) IntegralCheck(in *integral.AddReq) (*integral.AddResp, error) {
+	// todo: add your logic here and delete this line
+
+	return &integral.AddResp{}, nil
+}

rpc/internal/logic/integralconsumelogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"points_service/rpc/integral"
+	"points_service/rpc/internal/svc"
+
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+type IntegralConsumeLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewIntegralConsumeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *IntegralConsumeLogic {
+	return &IntegralConsumeLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// 消耗积分
+func (l *IntegralConsumeLogic) IntegralConsume(in *integral.AddReq) (*integral.AddResp, error) {
+	// todo: add your logic here and delete this line
+
+	return &integral.AddResp{}, nil
+}

rpc/internal/logic/integralguardlogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"points_service/rpc/integral"
+	"points_service/rpc/internal/svc"
+
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+type IntegralGuardLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewIntegralGuardLogic(ctx context.Context, svcCtx *svc.ServiceContext) *IntegralGuardLogic {
+	return &IntegralGuardLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// 积分守护
+func (l *IntegralGuardLogic) IntegralGuard(in *integral.AddReq) (*integral.AddResp, error) {
+	// todo: add your logic here and delete this line
+
+	return &integral.AddResp{}, nil
+}

rpc/internal/logic/updatebalancelogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"points_service/rpc/integral"
+	"points_service/rpc/internal/svc"
+
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+type UpdateBalanceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewUpdateBalanceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateBalanceLogic {
+	return &UpdateBalanceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// 调整结存
+func (l *UpdateBalanceLogic) UpdateBalance(in *integral.AddReq) (*integral.AddResp, error) {
+	// todo: add your logic here and delete this line
+
+	return &integral.AddResp{}, nil
+}

rpc/internal/logic/updatetotallogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"points_service/rpc/integral"
+	"points_service/rpc/internal/svc"
+
+	"github.com/tal-tech/go-zero/core/logx"
+)
+
+type UpdateTotalLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewUpdateTotalLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateTotalLogic {
+	return &UpdateTotalLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// 调整余额
+func (l *UpdateTotalLogic) UpdateTotal(in *integral.AddReq) (*integral.AddResp, error) {
+	// todo: add your logic here and delete this line
+
+	return &integral.AddResp{}, nil
+}

rpc/internal/server/integralserver.go

@@ -21,17 +21,38 @@ func NewIntegralServer(svcCtx *svc.ServiceContext) *IntegralServer {
 	}
 }
 
-func (s *IntegralServer) Add(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
-	l := logic.NewAddLogic(ctx, s.svcCtx)
-	return l.Add(in)
+// 新增积分
+func (s *IntegralServer) AddFlow(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
+	l := logic.NewAddFlowLogic(ctx, s.svcCtx)
+	return l.AddFlow(in)
 }
 
-func (s *IntegralServer) Update(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
-	l := logic.NewUpdateLogic(ctx, s.svcCtx)
-	return l.Update(in)
+// 调整结存
+func (s *IntegralServer) UpdateBalance(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
+	l := logic.NewUpdateBalanceLogic(ctx, s.svcCtx)
+	return l.UpdateBalance(in)
 }
 
-func (s *IntegralServer) Select(ctx context.Context, in *integral.CheckReq) (*integral.CheckResp, error) {
-	l := logic.NewSelectLogic(ctx, s.svcCtx)
-	return l.Select(in)
+// 调整余额
+func (s *IntegralServer) UpdateTotal(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
+	l := logic.NewUpdateTotalLogic(ctx, s.svcCtx)
+	return l.UpdateTotal(in)
+}
+
+// 消耗积分
+func (s *IntegralServer) IntegralConsume(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
+	l := logic.NewIntegralConsumeLogic(ctx, s.svcCtx)
+	return l.IntegralConsume(in)
+}
+
+// 积分守护
+func (s *IntegralServer) IntegralGuard(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
+	l := logic.NewIntegralGuardLogic(ctx, s.svcCtx)
+	return l.IntegralGuard(in)
+}
+
+// 到期积分查询
+func (s *IntegralServer) IntegralCheck(ctx context.Context, in *integral.AddReq) (*integral.AddResp, error) {
+	l := logic.NewIntegralCheckLogic(ctx, s.svcCtx)
+	return l.IntegralCheck(in)
 }