tijiao

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/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)
 }

rpc/model/balance.sql

@@ -3,5 +3,6 @@ CREATE TABLE `integral_balance`
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `userId` varchar(255) NOT NULL COMMENT '用户标识',
   `countPoints` int COMMENT '合计',
+  `appId` int(11) NOT NULL DEFAULT 10000 COMMENT '剑鱼标识',
   PRIMARY KEY(`userId`)
 ) ENGINE=InnoDB CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '积分余额表' ROW_FORMAT = DYNAMIC;

rpc/model/integralFlow.sql

@@ -8,5 +8,6 @@ CREATE TABLE `integral_flow`  (
   `point` int(11)  COMMENT '积分',
   `timeStamp` datetime(0) COMMENT '创建时间',
   `endDate` date COMMENT '截止时间',
+  `appId` int(11) NOT NULL DEFAULT 10000 COMMENT '剑鱼标识',
   PRIMARY KEY (`id`)
 ) ENGINE=InnoDB CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '积分流水表' ROW_FORMAT = DYNAMIC;

rpc/model/integralbalancemodel.go

@@ -38,6 +38,8 @@ type (
 		CountPoints int64 `xorm:"countPoints" json:"countPoints" form:"countPoints"`
 		UserId      string `xorm:"userId" json:"userId" form:"userId"`
 		Id          int64  `db:"id"`
+		AppId          int64  `db:"AppId"`
+
 	}
 )
 
@@ -49,8 +51,8 @@ func NewIntegralBalanceModel(conn sqlx.SqlConn, c cache.CacheConf) IntegralBalan
 }
 
 func (m *defaultIntegralBalanceModel) Insert(data IntegralBalance) (sql.Result, error) {
-	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?)", m.table, integralBalanceRowsExpectAutoSet)
-	ret, err := m.ExecNoCache(query, data.CountPoints, data.Id, data.UserId)
+	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?)", m.table, integralBalanceRowsExpectAutoSet)
+	ret, err := m.ExecNoCache(query, data.AppId, data.Id, data.UserId, data.CountPoints)
 
 	return ret, err
 }
@@ -76,7 +78,7 @@ func (m *defaultIntegralBalanceModel) Update(data IntegralBalance) error {
 	integralBalanceUserIdKey := fmt.Sprintf("%s%v", cacheIntegralBalanceUserIdPrefix, data.UserId)
 	_, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
 		query := fmt.Sprintf("update %s set %s where `userId` = ?", m.table, integralBalanceRowsWithPlaceHolder)
-		return conn.Exec(query, data.CountPoints, data.Id, data.UserId)
+		return conn.Exec(query, data.AppId, data.Id, data.CountPoints, data.UserId)
 	}, integralBalanceUserIdKey)
 	return err
 }

rpc/model/integralflowmodel.go

@@ -36,14 +36,15 @@ type (
 	}
 
 	IntegralFlow struct {
-		EndDate        time.Time `db:"endDate"` // 截止时间
+		AppId          int64     `db:"appId"` // 剑鱼标识
 		Id             int64     `db:"id"`
-		UserId         string    `db:"userId"`         // 用户标识
-		PointType      int64     `db:"pointType"`      // 积分类型
 		BusinessTypeId int64     `db:"businessTypeId"` // 业务单据标识
-		BusinessType   string    `db:"businessType"`   // 业务类型
 		Point          int64     `db:"point"`          // 积分
 		TimeStamp      time.Time `db:"timeStamp"`      // 创建时间
+		EndDate        time.Time `db:"endDate"`        // 截止时间
+		UserId         string    `db:"userId"`         // 用户标识
+		PointType      int64     `db:"pointType"`      // 积分类型
+		BusinessType   string    `db:"businessType"`   // 业务类型
 	}
 )
 
@@ -55,8 +56,8 @@ func NewIntegralFlowModel(conn sqlx.SqlConn, c cache.CacheConf) IntegralFlowMode
 }
 
 func (m *defaultIntegralFlowModel) Insert(data IntegralFlow) (sql.Result, error) {
-	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?)", m.table, integralFlowRowsExpectAutoSet)
-	ret, err := m.ExecNoCache(query, data.EndDate, data.UserId, data.PointType, data.BusinessTypeId, data.BusinessType, data.Point, data.TimeStamp)
+	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?)", m.table, integralFlowRowsExpectAutoSet)
+	ret, err := m.ExecNoCache(query, data.AppId, data.BusinessTypeId, data.Point, data.TimeStamp, data.EndDate, data.UserId, data.PointType, data.BusinessType)
 
 	return ret, err
 }
@@ -82,7 +83,7 @@ func (m *defaultIntegralFlowModel) Update(data IntegralFlow) error {
 	integralFlowIdKey := fmt.Sprintf("%s%v", cacheIntegralFlowIdPrefix, data.Id)
 	_, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
 		query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, integralFlowRowsWithPlaceHolder)
-		return conn.Exec(query, data.EndDate, data.UserId, data.PointType, data.BusinessTypeId, data.BusinessType, data.Point, data.TimeStamp, data.Id)
+		return conn.Exec(query, data.AppId, data.BusinessTypeId, data.Point, data.TimeStamp, data.EndDate, data.UserId, data.PointType, data.BusinessType, data.Id)
 	}, integralFlowIdKey)
 	return err
 }

rpc/model/integralsoldemodel.go

@@ -41,6 +41,7 @@ type (
 		TimePoints      int64     `db:"timePoints"`      // 时效积分
 		EndDate         time.Time `db:"endDate"`         // 有效期止
 		CountPoints     int64     `db:"countPoints"`     // 合计
+		AppId           int64     `db:"appId"`           // 剑鱼标识
 	}
 )
 
@@ -52,8 +53,8 @@ func NewIntegralSoldeModel(conn sqlx.SqlConn, c cache.CacheConf) IntegralSoldeMo
 }
 
 func (m *defaultIntegralSoldeModel) Insert(data IntegralSolde) (sql.Result, error) {
-	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?)", m.table, integralSoldeRowsExpectAutoSet)
-	ret, err := m.ExecNoCache(query, data.Id, data.PerManEntPoints, data.TimePoints, data.EndDate, data.CountPoints)
+	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?)", m.table, integralSoldeRowsExpectAutoSet)
+	ret, err := m.ExecNoCache(query, data.Id, data.PerManEntPoints, data.TimePoints, data.EndDate, data.CountPoints, data.AppId)
 
 	return ret, err
 }
@@ -79,7 +80,7 @@ func (m *defaultIntegralSoldeModel) Update(data IntegralSolde) error {
 	integralSoldeEndDateKey := fmt.Sprintf("%s%v", cacheIntegralSoldeEndDatePrefix, data.EndDate)
 	_, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
 		query := fmt.Sprintf("update %s set %s where `endDate` = ?", m.table, integralSoldeRowsWithPlaceHolder)
-		return conn.Exec(query, data.Id, data.PerManEntPoints, data.TimePoints, data.CountPoints, data.EndDate)
+		return conn.Exec(query, data.Id, data.PerManEntPoints, data.TimePoints, data.CountPoints, data.AppId, data.EndDate)
 	}, integralSoldeEndDateKey)
 	return err
 }

rpc/model/solde.sql

@@ -5,5 +5,6 @@ CREATE TABLE `integral_solde`
   `timePoints` int COMMENT '时效积分',
   `endDate` datetime COMMENT '有效期止',
   `countPoints` int COMMENT '合计',
+  `appId` int(11) NOT NULL DEFAULT 10000 COMMENT '剑鱼标识',
   PRIMARY KEY(`endDate`)
 ) ENGINE=InnoDB CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '积分结存表' ROW_FORMAT = DYNAMIC;