增加SOResult相关结构体

cheliequan

2023-02-10 5d483655e888dbb97a1011c45f890669b7a74cc5

增加SOResult相关结构体

 dataprocess.pb.go

@@ -8,7 +8,6 @@
    proto "github.com/golang/protobuf/proto"
    io "io"
    math "math"
    math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -20,7 +19,7 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type TaskBasicInfo struct {
    CamId                string   `protobuf:"bytes,1,opt,name=CamId,proto3" json:"CamId,omitempty"`
@@ -51,7 +50,7 @@
        return xxx_messageInfo_TaskBasicInfo.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalToSizedBuffer(b)
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
@@ -133,6 +132,291 @@
    return ""
}

type RuleParams struct {
    SdkArgAlias          string   `protobuf:"bytes,1,opt,name=SdkArgAlias,proto3" json:"SdkArgAlias,omitempty"`
    Operator             string   `protobuf:"bytes,2,opt,name=Operator,proto3" json:"Operator,omitempty"`
    OperatorType         string   `protobuf:"bytes,3,opt,name=OperatorType,proto3" json:"OperatorType,omitempty"`
    SdkArgValue          string   `protobuf:"bytes,4,opt,name=SdkArgValue,proto3" json:"SdkArgValue,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *RuleParams) Reset()         { *m = RuleParams{} }
func (m *RuleParams) String() string { return proto.CompactTextString(m) }
func (*RuleParams) ProtoMessage()    {}
func (*RuleParams) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{1}
}
func (m *RuleParams) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *RuleParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_RuleParams.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *RuleParams) XXX_Merge(src proto.Message) {
    xxx_messageInfo_RuleParams.Merge(m, src)
}
func (m *RuleParams) XXX_Size() int {
    return m.Size()
}
func (m *RuleParams) XXX_DiscardUnknown() {
    xxx_messageInfo_RuleParams.DiscardUnknown(m)
}

var xxx_messageInfo_RuleParams proto.InternalMessageInfo

func (m *RuleParams) GetSdkArgAlias() string {
    if m != nil {
        return m.SdkArgAlias
    }
    return ""
}

func (m *RuleParams) GetOperator() string {
    if m != nil {
        return m.Operator
    }
    return ""
}

func (m *RuleParams) GetOperatorType() string {
    if m != nil {
        return m.OperatorType
    }
    return ""
}

func (m *RuleParams) GetSdkArgValue() string {
    if m != nil {
        return m.SdkArgValue
    }
    return ""
}

type SoRule struct {
    Id                   string        `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
    CameraId             string        `protobuf:"bytes,2,opt,name=CameraId,proto3" json:"CameraId,omitempty"`
    PolygonId            string        `protobuf:"bytes,3,opt,name=PolygonId,proto3" json:"PolygonId,omitempty"`
    SdkId                string        `protobuf:"bytes,4,opt,name=SdkId,proto3" json:"SdkId,omitempty"`
    Sort                 int32         `protobuf:"varint,5,opt,name=Sort,proto3" json:"Sort,omitempty"`
    RuleWithPre          string        `protobuf:"bytes,6,opt,name=RuleWithPre,proto3" json:"RuleWithPre,omitempty"`
    IsSaveAnyhow         bool          `protobuf:"varint,7,opt,name=IsSaveAnyhow,proto3" json:"IsSaveAnyhow,omitempty"`
    GroupId              string        `protobuf:"bytes,8,opt,name=GroupId,proto3" json:"GroupId,omitempty"`
    Params               []*RuleParams `protobuf:"bytes,9,rep,name=Params,proto3" json:"Params,omitempty"`
    XXX_NoUnkeyedLiteral struct{}      `json:"-"`
    XXX_unrecognized     []byte        `json:"-"`
    XXX_sizecache        int32         `json:"-"`
}

func (m *SoRule) Reset()         { *m = SoRule{} }
func (m *SoRule) String() string { return proto.CompactTextString(m) }
func (*SoRule) ProtoMessage()    {}
func (*SoRule) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{2}
}
func (m *SoRule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *SoRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SoRule.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *SoRule) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SoRule.Merge(m, src)
}
func (m *SoRule) XXX_Size() int {
    return m.Size()
}
func (m *SoRule) XXX_DiscardUnknown() {
    xxx_messageInfo_SoRule.DiscardUnknown(m)
}

var xxx_messageInfo_SoRule proto.InternalMessageInfo

func (m *SoRule) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *SoRule) GetCameraId() string {
    if m != nil {
        return m.CameraId
    }
    return ""
}

func (m *SoRule) GetPolygonId() string {
    if m != nil {
        return m.PolygonId
    }
    return ""
}

func (m *SoRule) GetSdkId() string {
    if m != nil {
        return m.SdkId
    }
    return ""
}

func (m *SoRule) GetSort() int32 {
    if m != nil {
        return m.Sort
    }
    return 0
}

func (m *SoRule) GetRuleWithPre() string {
    if m != nil {
        return m.RuleWithPre
    }
    return ""
}

func (m *SoRule) GetIsSaveAnyhow() bool {
    if m != nil {
        return m.IsSaveAnyhow
    }
    return false
}

func (m *SoRule) GetGroupId() string {
    if m != nil {
        return m.GroupId
    }
    return ""
}

func (m *SoRule) GetParams() []*RuleParams {
    if m != nil {
        return m.Params
    }
    return nil
}

type SOResult struct {
    IsEvent              bool        `protobuf:"varint,1,opt,name=IsEvent,proto3" json:"IsEvent,omitempty"`
    IsEndRecord          bool        `protobuf:"varint,2,opt,name=IsEndRecord,proto3" json:"IsEndRecord,omitempty"`
    Targets              []*SoTarget `protobuf:"bytes,3,rep,name=Targets,proto3" json:"Targets,omitempty"`
    FirstImage           *Image      `protobuf:"bytes,4,opt,name=FirstImage,proto3" json:"FirstImage,omitempty"`
    CacheImage           *Image      `protobuf:"bytes,5,opt,name=CacheImage,proto3" json:"CacheImage,omitempty"`
    SoRule               *SoRule     `protobuf:"bytes,6,opt,name=SoRule,proto3" json:"SoRule,omitempty"`
    GroupRule            *GroupRule  `protobuf:"bytes,7,opt,name=GroupRule,proto3" json:"GroupRule,omitempty"`
    SoType               string      `protobuf:"bytes,8,opt,name=SoType,proto3" json:"SoType,omitempty"`
    XXX_NoUnkeyedLiteral struct{}    `json:"-"`
    XXX_unrecognized     []byte      `json:"-"`
    XXX_sizecache        int32       `json:"-"`
}

func (m *SOResult) Reset()         { *m = SOResult{} }
func (m *SOResult) String() string { return proto.CompactTextString(m) }
func (*SOResult) ProtoMessage()    {}
func (*SOResult) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{3}
}
func (m *SOResult) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *SOResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SOResult.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *SOResult) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SOResult.Merge(m, src)
}
func (m *SOResult) XXX_Size() int {
    return m.Size()
}
func (m *SOResult) XXX_DiscardUnknown() {
    xxx_messageInfo_SOResult.DiscardUnknown(m)
}

var xxx_messageInfo_SOResult proto.InternalMessageInfo

func (m *SOResult) GetIsEvent() bool {
    if m != nil {
        return m.IsEvent
    }
    return false
}

func (m *SOResult) GetIsEndRecord() bool {
    if m != nil {
        return m.IsEndRecord
    }
    return false
}

func (m *SOResult) GetTargets() []*SoTarget {
    if m != nil {
        return m.Targets
    }
    return nil
}

func (m *SOResult) GetFirstImage() *Image {
    if m != nil {
        return m.FirstImage
    }
    return nil
}

func (m *SOResult) GetCacheImage() *Image {
    if m != nil {
        return m.CacheImage
    }
    return nil
}

func (m *SOResult) GetSoRule() *SoRule {
    if m != nil {
        return m.SoRule
    }
    return nil
}

func (m *SOResult) GetGroupRule() *GroupRule {
    if m != nil {
        return m.GroupRule
    }
    return nil
}

func (m *SOResult) GetSoType() string {
    if m != nil {
        return m.SoType
    }
    return ""
}

type SoTarget struct {
    SrcTarget            *Target                `protobuf:"bytes,1,opt,name=SrcTarget,proto3" json:"SrcTarget,omitempty"`
    AreaId               string                 `protobuf:"bytes,2,opt,name=AreaId,proto3" json:"AreaId,omitempty"`
@@ -149,7 +433,7 @@
func (m *SoTarget) String() string { return proto.CompactTextString(m) }
func (*SoTarget) ProtoMessage()    {}
func (*SoTarget) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{1}
    return fileDescriptor_02f614a9207041cc, []int{4}
}
func (m *SoTarget) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -159,7 +443,7 @@
        return xxx_messageInfo_SoTarget.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalToSizedBuffer(b)
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
@@ -233,7 +517,7 @@
func (m *EventCache) String() string { return proto.CompactTextString(m) }
func (*EventCache) ProtoMessage()    {}
func (*EventCache) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{2}
    return fileDescriptor_02f614a9207041cc, []int{5}
}
func (m *EventCache) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -243,7 +527,7 @@
        return xxx_messageInfo_EventCache.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalToSizedBuffer(b)
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
@@ -296,7 +580,7 @@
func (m *TargetCache) String() string { return proto.CompactTextString(m) }
func (*TargetCache) ProtoMessage()    {}
func (*TargetCache) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{3}
    return fileDescriptor_02f614a9207041cc, []int{6}
}
func (m *TargetCache) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -306,7 +590,7 @@
        return xxx_messageInfo_TargetCache.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalToSizedBuffer(b)
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
@@ -359,7 +643,7 @@
func (m *FilterResult) String() string { return proto.CompactTextString(m) }
func (*FilterResult) ProtoMessage()    {}
func (*FilterResult) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{4}
    return fileDescriptor_02f614a9207041cc, []int{7}
}
func (m *FilterResult) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -369,7 +653,7 @@
        return xxx_messageInfo_FilterResult.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalToSizedBuffer(b)
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
@@ -411,6 +695,9 @@

func init() {
    proto.RegisterType((*TaskBasicInfo)(nil), "protomsg.TaskBasicInfo")
    proto.RegisterType((*RuleParams)(nil), "protomsg.RuleParams")
    proto.RegisterType((*SoRule)(nil), "protomsg.SoRule")
    proto.RegisterType((*SOResult)(nil), "protomsg.SOResult")
    proto.RegisterType((*SoTarget)(nil), "protomsg.SoTarget")
    proto.RegisterType((*EventCache)(nil), "protomsg.EventCache")
    proto.RegisterMapType((map[int64]*Image)(nil), "protomsg.EventCache.ImagesEntry")
@@ -426,55 +713,71 @@
func init() { proto.RegisterFile("dataprocess.proto", fileDescriptor_02f614a9207041cc) }

var fileDescriptor_02f614a9207041cc = []byte{
    // 665 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0xcd, 0x6e, 0xd3, 0x40,
    0x10, 0xc7, 0x71, 0xdc, 0xa4, 0xc9, 0xb8, 0xd0, 0xb2, 0x14, 0xb0, 0x22, 0x1a, 0x19, 0x43, 0x25,
    0x53, 0xa4, 0x20, 0xb5, 0x97, 0xaa, 0x55, 0x0f, 0xe4, 0xa3, 0x60, 0x0e, 0x45, 0x6c, 0x7b, 0xe2,
    0xb6, 0x8d, 0x97, 0x10, 0xd5, 0x1f, 0x91, 0xd7, 0xa9, 0xd4, 0x07, 0xe0, 0x1d, 0x78, 0x15, 0xde,
    0x80, 0x23, 0x8f, 0x80, 0xc2, 0x13, 0x70, 0xe6, 0x82, 0x76, 0xd6, 0x8e, 0x37, 0x95, 0x23, 0x4e,
    0x9c, 0xb2, 0x33, 0x9e, 0xff, 0x6f, 0x67, 0xe7, 0x23, 0x70, 0x3f, 0x60, 0x19, 0x9b, 0xa6, 0xc9,
    0x88, 0x0b, 0xd1, 0x9d, 0xa6, 0x49, 0x96, 0x90, 0x26, 0xfe, 0x44, 0x62, 0xdc, 0x6e, 0x89, 0xe0,
    0x4a, 0x39, 0xdb, 0x90, 0xce, 0x42, 0x9e, 0x9f, 0xef, 0x15, 0x01, 0xca, 0x76, 0xbf, 0xd4, 0xe0,
    0xee, 0x05, 0x13, 0x57, 0x3d, 0x26, 0x26, 0x23, 0x3f, 0xfe, 0x94, 0x90, 0x6d, 0xa8, 0xf7, 0x59,
    0xe4, 0x07, 0xb6, 0xe1, 0x18, 0x5e, 0x8b, 0x2a, 0x83, 0xd8, 0xb0, 0xde, 0x67, 0xd1, 0x19, 0x8b,
    0xb8, 0x5d, 0x43, 0x7f, 0x61, 0x92, 0x47, 0xd0, 0x90, 0x00, 0x7f, 0x60, 0x9b, 0xf8, 0x21, 0xb7,
    0x48, 0x1b, 0x9a, 0xf2, 0x84, 0x92, 0x35, 0xfc, 0xb2, 0xb0, 0x49, 0x07, 0xe0, 0x2d, 0x8b, 0x83,
    0x90, 0x5f, 0x4c, 0x22, 0x6e, 0xd7, 0xf1, 0xab, 0xe6, 0x91, 0xb7, 0xf9, 0x11, 0x1b, 0x73, 0x3f,
    0xb0, 0x1b, 0x8e, 0xe1, 0x99, 0xb4, 0x30, 0xc9, 0x13, 0x68, 0xe1, 0x11, 0x85, 0xeb, 0x28, 0x2c,
    0x1d, 0xc4, 0x01, 0xcb, 0x17, 0xc3, 0x38, 0xa0, 0x7c, 0x94, 0xa4, 0x81, 0xdd, 0x74, 0x0c, 0xaf,
    0x49, 0x75, 0x97, 0xcc, 0xf6, 0x74, 0x12, 0x4a, 0x70, 0x4b, 0x65, 0xab, 0x2c, 0xf7, 0xb7, 0x01,
    0xcd, 0xf3, 0xe4, 0x82, 0xa5, 0x63, 0x9e, 0x91, 0x2e, 0xb4, 0xce, 0xd3, 0x91, 0x32, 0xb0, 0x0c,
    0xd6, 0xfe, 0x56, 0x77, 0x51, 0x38, 0xe5, 0xa7, 0x65, 0x88, 0x84, 0xbe, 0x4e, 0x39, 0xf3, 0x83,
    0xbc, 0x36, 0xb9, 0x25, 0x4b, 0x20, 0x4f, 0x58, 0x02, 0x55, 0x9c, 0x85, 0x4d, 0x3c, 0xd8, 0xec,
    0xf1, 0x30, 0x89, 0xc7, 0x42, 0x41, 0xfc, 0x41, 0x5e, 0xa5, 0xdb, 0x6e, 0x72, 0x02, 0xd0, 0x4f,
    0xa2, 0xe9, 0xe0, 0x52, 0xb6, 0xc7, 0xae, 0x3b, 0xa6, 0x67, 0xed, 0xef, 0x94, 0xe9, 0xd0, 0x59,
    0xc8, 0x7b, 0x4c, 0x70, 0x19, 0xc3, 0x52, 0x2e, 0x83, 0xa8, 0x26, 0x58, 0x5d, 0x4b, 0xf7, 0x9b,
    0x09, 0x30, 0xbc, 0xe6, 0x71, 0xd6, 0x67, 0xa3, 0xcf, 0x9c, 0x1c, 0xc3, 0xba, 0xba, 0x53, 0xd8,
    0x06, 0x5e, 0xf2, 0xb4, 0xbc, 0xa4, 0x0c, 0xcb, 0x9f, 0x2f, 0x86, 0x71, 0x96, 0xde, 0xd0, 0x42,
    0x41, 0x06, 0x00, 0x32, 0x91, 0x37, 0x69, 0x32, 0x9b, 0x0a, 0xbb, 0x86, 0xfa, 0xe7, 0x95, 0xfa,
    0x32, 0x4c, 0x21, 0x34, 0x1d, 0x39, 0x84, 0x06, 0x26, 0x27, 0x6c, 0x13, 0x09, 0x4e, 0x25, 0x41,
    0x85, 0x28, 0x75, 0x1e, 0xdf, 0x3e, 0x83, 0x0d, 0x3d, 0x31, 0xb2, 0x05, 0xe6, 0x15, 0xbf, 0xc1,
    0xe6, 0xad, 0x51, 0x79, 0x24, 0x1e, 0xd4, 0xaf, 0x59, 0x38, 0x53, 0xf3, 0x6b, 0xed, 0x93, 0x12,
    0x5d, 0xf4, 0x9d, 0xaa, 0x80, 0xa3, 0xda, 0xa1, 0xd1, 0xa6, 0xb0, 0x79, 0x2b, 0x51, 0x1d, 0xd9,
    0x52, 0xc8, 0x17, 0xcb, 0xc8, 0x07, 0x25, 0x12, 0x75, 0x12, 0xa0, 0x33, 0xdf, 0x81, 0xa5, 0xa5,
    0xae, 0xf3, 0x4c, 0xc5, 0xdb, 0x5d, 0xe6, 0x6d, 0x96, 0x3c, 0xd4, 0x69, 0x2c, 0xf7, 0x8f, 0x01,
    0x96, 0xca, 0x5a, 0x35, 0x6f, 0x4f, 0x6e, 0x61, 0x3e, 0xaf, 0xe6, 0x8a, 0xe7, 0xe5, 0x11, 0x64,
    0x58, 0xd1, 0xab, 0xdd, 0xdb, 0xf3, 0xfd, 0xef, 0x66, 0xed, 0x42, 0x1d, 0xd3, 0xc2, 0xd1, 0xae,
    0xca, 0x16, 0x7f, 0xfe, 0x47, 0x25, 0xdd, 0x79, 0x0d, 0x36, 0x4e, 0x27, 0x61, 0xc6, 0x53, 0xca,
    0xc5, 0x2c, 0xcc, 0xc8, 0x01, 0x34, 0xe5, 0x0e, 0xe0, 0x86, 0xa8, 0x85, 0x7d, 0xac, 0x3f, 0x48,
    0xfb, 0x7f, 0xa3, 0x8b, 0x40, 0x72, 0x04, 0x0d, 0x9c, 0xaa, 0xa2, 0x06, 0x6e, 0x29, 0xd1, 0xe1,
    0x6a, 0xf4, 0x8a, 0x79, 0x53, 0x06, 0x39, 0x29, 0x97, 0x45, 0x8d, 0xea, 0xb3, 0x15, 0xe2, 0xca,
    0x75, 0x69, 0xbf, 0x07, 0x4b, 0xa3, 0x56, 0x14, 0x64, 0x6f, 0xb9, 0x20, 0xdb, 0x55, 0x8b, 0xa0,
    0xcf, 0xd6, 0x87, 0xd5, 0xf3, 0x9f, 0x13, 0x5f, 0x2e, 0x13, 0x1f, 0x56, 0x36, 0x5c, 0x43, 0xf6,
    0x76, 0xbe, 0xcf, 0x3b, 0xc6, 0x8f, 0x79, 0xc7, 0xf8, 0x39, 0xef, 0x18, 0x5f, 0x7f, 0x75, 0xee,
    0x7c, 0xb4, 0xba, 0xaf, 0x8e, 0x0b, 0xd5, 0x65, 0x03, 0x4f, 0x07, 0x7f, 0x03, 0x00, 0x00, 0xff,
    0xff, 0x48, 0x0f, 0xda, 0x74, 0x86, 0x06, 0x00, 0x00,
    // 924 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xc1, 0x6e, 0x23, 0x45,
    0x10, 0x65, 0xc6, 0xb1, 0x33, 0x53, 0x0e, 0x9b, 0xd0, 0x04, 0x18, 0x59, 0x10, 0x99, 0x81, 0x48,
    0x66, 0x59, 0x05, 0x91, 0xbd, 0xac, 0x16, 0xed, 0x21, 0x71, 0x12, 0x18, 0x0e, 0x9b, 0xd0, 0x13,
    0xc1, 0xb9, 0xd7, 0xd3, 0x38, 0x96, 0x67, 0x3c, 0x56, 0xf7, 0x38, 0xc8, 0x1f, 0xc0, 0x85, 0x13,
    0x47, 0x7e, 0x85, 0x3f, 0x40, 0xe2, 0xc2, 0x27, 0xa0, 0xf0, 0x05, 0x9c, 0xb9, 0xa0, 0xae, 0xee,
    0x71, 0xb7, 0xbd, 0x63, 0x71, 0xe2, 0xe4, 0xae, 0x9a, 0xaa, 0x57, 0xd5, 0xaf, 0x5e, 0xb5, 0xe1,
    0xad, 0x8c, 0x55, 0x6c, 0x2e, 0xca, 0x11, 0x97, 0xf2, 0x64, 0x2e, 0xca, 0xaa, 0x24, 0x01, 0xfe,
    0x14, 0x72, 0xdc, 0x0b, 0x65, 0x36, 0xd5, 0xce, 0x1e, 0x88, 0x45, 0xce, 0xcd, 0xf9, 0x51, 0x1d,
    0xa0, 0xed, 0xf8, 0x47, 0x1f, 0xde, 0xbc, 0x65, 0x72, 0x7a, 0xce, 0xe4, 0x64, 0x94, 0xcc, 0xbe,
    0x2f, 0xc9, 0x21, 0xb4, 0x87, 0xac, 0x48, 0xb2, 0xc8, 0xeb, 0x7b, 0x83, 0x90, 0x6a, 0x83, 0x44,
    0xb0, 0x3b, 0x64, 0xc5, 0x4b, 0x56, 0xf0, 0xc8, 0x47, 0x7f, 0x6d, 0x92, 0x77, 0xa1, 0xa3, 0x00,
    0x92, 0x8b, 0xa8, 0x85, 0x1f, 0x8c, 0x45, 0x7a, 0x10, 0xa8, 0x13, 0xa6, 0xec, 0xe0, 0x97, 0x95,
    0x4d, 0x8e, 0x00, 0xbe, 0x62, 0xb3, 0x2c, 0xe7, 0xb7, 0x93, 0x82, 0x47, 0x6d, 0xfc, 0xea, 0x78,
    0x54, 0xb5, 0xa4, 0x60, 0x63, 0x9e, 0x64, 0x51, 0xa7, 0xef, 0x0d, 0x5a, 0xb4, 0x36, 0xc9, 0xfb,
    0x10, 0xe2, 0x11, 0x13, 0x77, 0x31, 0xd1, 0x3a, 0x48, 0x1f, 0xba, 0x89, 0xbc, 0x9c, 0x65, 0x94,
    0x8f, 0x4a, 0x91, 0x45, 0x41, 0xdf, 0x1b, 0x04, 0xd4, 0x75, 0xa9, 0x6e, 0xaf, 0x26, 0xb9, 0x02,
    0x0e, 0x75, 0xb7, 0xda, 0x8a, 0x7f, 0xf6, 0x00, 0xe8, 0x22, 0xe7, 0x37, 0x4c, 0xb0, 0x42, 0x2a,
    0xa0, 0x34, 0x9b, 0x9e, 0x89, 0xf1, 0x59, 0x3e, 0x61, 0xd2, 0x50, 0xe1, 0xba, 0xd4, 0xf5, 0xae,
    0xe7, 0x5c, 0xb0, 0xaa, 0x14, 0x86, 0x91, 0x95, 0x4d, 0x62, 0xd8, 0xab, 0xcf, 0xb7, 0xcb, 0x39,
    0x37, 0xc4, 0xac, 0xf9, 0x6c, 0x85, 0x6f, 0x59, 0xbe, 0xa8, 0x19, 0x72, 0x5d, 0xf1, 0x4f, 0x3e,
    0x74, 0xd2, 0x52, 0x35, 0x45, 0x1e, 0x81, 0xbf, 0x1a, 0x88, 0x9f, 0x64, 0xaa, 0xf8, 0x90, 0x15,
    0x5c, 0xb0, 0x24, 0xab, 0x8b, 0xd7, 0xb6, 0x62, 0xe8, 0xa6, 0xcc, 0x97, 0xe3, 0x72, 0x96, 0x64,
    0xa6, 0xb2, 0x75, 0xa8, 0xe9, 0xa6, 0xd9, 0x34, 0xc9, 0x4c, 0x41, 0x6d, 0x10, 0x02, 0x3b, 0x69,
    0x29, 0x2a, 0x9c, 0x44, 0x9b, 0xe2, 0x59, 0x35, 0xa8, 0x6a, 0x7f, 0x37, 0xa9, 0xee, 0x6e, 0x04,
    0xc7, 0x39, 0x84, 0xd4, 0x75, 0xa9, 0x6b, 0x26, 0x32, 0x65, 0xf7, 0xfc, 0x6c, 0xb6, 0xbc, 0x2b,
    0x7f, 0xc0, 0x71, 0x04, 0x74, 0xcd, 0xa7, 0x26, 0xf9, 0xa5, 0x28, 0x17, 0xf3, 0x44, 0x4f, 0x23,
    0xa4, 0xb5, 0x49, 0x9e, 0x40, 0x47, 0x93, 0x1d, 0x85, 0xfd, 0xd6, 0xa0, 0x7b, 0x7a, 0x78, 0xb2,
    0x92, 0xa6, 0x1d, 0x04, 0x35, 0x31, 0xf1, 0xef, 0x3e, 0x04, 0xe9, 0x35, 0xe5, 0x72, 0x91, 0x57,
    0x28, 0x0f, 0x79, 0x79, 0xcf, 0x67, 0x15, 0x72, 0x12, 0xd0, 0xda, 0xdc, 0x14, 0x80, 0xff, 0xba,
    0x00, 0x9e, 0xc0, 0xee, 0x2d, 0x13, 0x63, 0x5e, 0xc9, 0xa8, 0x85, 0x75, 0x89, 0xad, 0x9b, 0x96,
    0xfa, 0x13, 0xad, 0x43, 0xc8, 0x67, 0x00, 0x57, 0x13, 0x21, 0x2b, 0x94, 0x18, 0x72, 0xd6, 0x3d,
    0xdd, 0xb7, 0x09, 0xe8, 0xa6, 0x4e, 0x88, 0x4a, 0x18, 0xb2, 0xd1, 0x1d, 0xd7, 0x09, 0xed, 0x2d,
    0x09, 0x36, 0x84, 0x0c, 0xea, 0x21, 0x23, 0xc3, 0xdd, 0xd3, 0x03, 0xb7, 0x1d, 0xe5, 0xa7, 0xb5,
    0x08, 0x3e, 0x87, 0x10, 0xb9, 0xc3, 0xe0, 0x5d, 0x0c, 0x7e, 0xdb, 0x06, 0xaf, 0x3e, 0x51, 0x1b,
    0xa5, 0xd4, 0x9e, 0x96, 0x28, 0x41, 0x4d, 0xbe, 0xb1, 0xe2, 0xbf, 0x3d, 0x08, 0xea, 0xcb, 0x92,
    0x13, 0x08, 0x53, 0x31, 0xd2, 0x06, 0xf2, 0xb9, 0xd6, 0x84, 0x61, 0xc4, 0x86, 0x28, 0xd0, 0x33,
    0xc1, 0xad, 0xf4, 0x8c, 0xa5, 0x44, 0xa9, 0x4e, 0xb8, 0xf0, 0x5a, 0x77, 0x2b, 0x9b, 0x0c, 0x60,
    0xff, 0x9c, 0xe7, 0xe5, 0x6c, 0x2c, 0x35, 0x48, 0x72, 0x61, 0x04, 0xb8, 0xe9, 0x26, 0x2f, 0x00,
    0x86, 0x65, 0x31, 0xbf, 0x78, 0xa5, 0x1e, 0xa3, 0xa8, 0x8d, 0x23, 0xfa, 0x60, 0x5d, 0x1a, 0xe7,
    0x4c, 0x72, 0x15, 0xc3, 0x04, 0x57, 0x41, 0xd4, 0x49, 0xd8, 0xfe, 0x72, 0xc4, 0xbf, 0xb6, 0x00,
    0x50, 0x24, 0x48, 0x3e, 0xf9, 0xc2, 0xea, 0xc0, 0xc3, 0x22, 0x1f, 0xda, 0x22, 0x36, 0xcc, 0x5c,
    0x5f, 0x5e, 0xce, 0x2a, 0xb1, 0xb4, 0xb2, 0xb8, 0xd0, 0x8f, 0x05, 0x12, 0x2d, 0x23, 0x1f, 0xf3,
    0x3f, 0x6e, 0xcc, 0xb7, 0x61, 0x1a, 0xc2, 0xc9, 0x23, 0xcf, 0xa0, 0x83, 0xcd, 0xd5, 0x4a, 0xec,
    0x37, 0x22, 0xe8, 0x10, 0x9d, 0x6d, 0xe2, 0x7b, 0x2f, 0x61, 0xcf, 0x6d, 0x8c, 0x1c, 0x40, 0x6b,
    0xca, 0x97, 0x38, 0xbc, 0x1d, 0xaa, 0x8e, 0x64, 0x00, 0xed, 0x7b, 0x7c, 0x58, 0x7c, 0x1c, 0x68,
    0x93, 0xc8, 0x75, 0xc0, 0x73, 0xff, 0x99, 0xd7, 0xa3, 0xb0, 0xbf, 0xd1, 0xa8, 0x0b, 0x19, 0x6a,
    0xc8, 0x4f, 0xd6, 0x21, 0x1b, 0xb5, 0xe7, 0x60, 0x7e, 0x0d, 0x5d, 0xa7, 0x75, 0x17, 0xaf, 0xa5,
    0xf1, 0x8e, 0xd7, 0xf1, 0x5e, 0xdb, 0x12, 0x8b, 0x15, 0xff, 0xe3, 0x41, 0x57, 0x77, 0xad, 0x87,
    0xf7, 0x58, 0xfd, 0xe7, 0x18, 0xbd, 0x6e, 0xdb, 0x61, 0x13, 0x41, 0x2e, 0x1b, 0x66, 0x75, 0xbc,
    0xa9, 0xef, 0xff, 0x1e, 0xd6, 0x31, 0xb4, 0xf5, 0x4e, 0xb7, 0xb6, 0x74, 0x8b, 0x3f, 0xff, 0x07,
    0x93, 0xf1, 0x83, 0x0f, 0x7b, 0x57, 0x93, 0xbc, 0xe2, 0xc2, 0xbc, 0x7f, 0x4f, 0x21, 0x50, 0x3b,
    0x80, 0x1b, 0xa2, 0x17, 0xf6, 0x3d, 0xf7, 0x42, 0xce, 0xbf, 0x39, 0x5d, 0x05, 0x92, 0xe7, 0xd0,
    0x41, 0x55, 0xd5, 0x1c, 0xc4, 0x36, 0xc5, 0x05, 0xd7, 0xd2, 0xab, 0xf5, 0xa6, 0x0d, 0xf2, 0x62,
    0xf3, 0xd1, 0xfc, 0x68, 0x4b, 0x72, 0xe3, 0xba, 0xf4, 0xae, 0xa1, 0xeb, 0xa0, 0x36, 0x10, 0xf2,
    0x78, 0x9d, 0x90, 0xc3, 0xa6, 0x45, 0x70, 0xb5, 0xf5, 0xcd, 0x76, 0xfd, 0x1b, 0xc4, 0x4f, 0xd7,
    0x11, 0xdf, 0x69, 0x1c, 0xb8, 0x03, 0x79, 0x7e, 0xf0, 0xdb, 0xc3, 0x91, 0xf7, 0xc7, 0xc3, 0x91,
    0xf7, 0xe7, 0xc3, 0x91, 0xf7, 0xcb, 0x5f, 0x47, 0x6f, 0xbc, 0xea, 0x60, 0xca, 0xd3, 0x7f, 0x03,
    0x00, 0x00, 0xff, 0xff, 0x90, 0x61, 0xc4, 0xa9, 0x67, 0x09, 0x00, 0x00,
}

func (m *TaskBasicInfo) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalToSizedBuffer(dAtA[:size])
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
@@ -482,90 +785,305 @@
}

func (m *TaskBasicInfo) MarshalTo(dAtA []byte) (int, error) {
    size := m.Size()
    return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TaskBasicInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    var i int
    _ = i
    var l int
    _ = l
    if m.XXX_unrecognized != nil {
        i -= len(m.XXX_unrecognized)
        copy(dAtA[i:], m.XXX_unrecognized)
    if len(m.CamId) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamId)))
        i += copy(dAtA[i:], m.CamId)
    }
    if len(m.FileId) > 0 {
        i -= len(m.FileId)
        copy(dAtA[i:], m.FileId)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.FileId)))
        i--
        dAtA[i] = 0x4a
    if len(m.CamName) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamName)))
        i += copy(dAtA[i:], m.CamName)
    }
    if len(m.TaskID) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskID)))
        i += copy(dAtA[i:], m.TaskID)
    }
    if len(m.TaskName) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskName)))
        i += copy(dAtA[i:], m.TaskName)
    }
    if len(m.HandleTime) > 0 {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.HandleTime)))
        i += copy(dAtA[i:], m.HandleTime)
    }
    if m.ImageId != 0 {
        dAtA[i] = 0x30
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
    }
    if len(m.ImageTime) > 0 {
        dAtA[i] = 0x3a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.ImageTime)))
        i += copy(dAtA[i:], m.ImageTime)
    }
    if m.IsEndRecord {
        i--
        dAtA[i] = 0x40
        i++
        if m.IsEndRecord {
            dAtA[i] = 1
        } else {
            dAtA[i] = 0
        }
        i--
        dAtA[i] = 0x40
        i++
    }
    if len(m.ImageTime) > 0 {
        i -= len(m.ImageTime)
        copy(dAtA[i:], m.ImageTime)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.ImageTime)))
        i--
        dAtA[i] = 0x3a
    if len(m.FileId) > 0 {
        dAtA[i] = 0x4a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.FileId)))
        i += copy(dAtA[i:], m.FileId)
    }
    if m.ImageId != 0 {
        i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
        i--
        dAtA[i] = 0x30
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    if len(m.HandleTime) > 0 {
        i -= len(m.HandleTime)
        copy(dAtA[i:], m.HandleTime)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.HandleTime)))
        i--
        dAtA[i] = 0x2a
    return i, nil
}

func (m *RuleParams) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    if len(m.TaskName) > 0 {
        i -= len(m.TaskName)
        copy(dAtA[i:], m.TaskName)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskName)))
        i--
        dAtA[i] = 0x22
    }
    if len(m.TaskID) > 0 {
        i -= len(m.TaskID)
        copy(dAtA[i:], m.TaskID)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskID)))
        i--
        dAtA[i] = 0x1a
    }
    if len(m.CamName) > 0 {
        i -= len(m.CamName)
        copy(dAtA[i:], m.CamName)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamName)))
        i--
        dAtA[i] = 0x12
    }
    if len(m.CamId) > 0 {
        i -= len(m.CamId)
        copy(dAtA[i:], m.CamId)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamId)))
        i--
    return dAtA[:n], nil
}

func (m *RuleParams) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.SdkArgAlias) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkArgAlias)))
        i += copy(dAtA[i:], m.SdkArgAlias)
    }
    return len(dAtA) - i, nil
    if len(m.Operator) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.Operator)))
        i += copy(dAtA[i:], m.Operator)
    }
    if len(m.OperatorType) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.OperatorType)))
        i += copy(dAtA[i:], m.OperatorType)
    }
    if len(m.SdkArgValue) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkArgValue)))
        i += copy(dAtA[i:], m.SdkArgValue)
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *SoRule) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *SoRule) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Id) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.Id)))
        i += copy(dAtA[i:], m.Id)
    }
    if len(m.CameraId) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CameraId)))
        i += copy(dAtA[i:], m.CameraId)
    }
    if len(m.PolygonId) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.PolygonId)))
        i += copy(dAtA[i:], m.PolygonId)
    }
    if len(m.SdkId) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkId)))
        i += copy(dAtA[i:], m.SdkId)
    }
    if m.Sort != 0 {
        dAtA[i] = 0x28
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.Sort))
    }
    if len(m.RuleWithPre) > 0 {
        dAtA[i] = 0x32
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.RuleWithPre)))
        i += copy(dAtA[i:], m.RuleWithPre)
    }
    if m.IsSaveAnyhow {
        dAtA[i] = 0x38
        i++
        if m.IsSaveAnyhow {
            dAtA[i] = 1
        } else {
            dAtA[i] = 0
        }
        i++
    }
    if len(m.GroupId) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.GroupId)))
        i += copy(dAtA[i:], m.GroupId)
    }
    if len(m.Params) > 0 {
        for _, msg := range m.Params {
            dAtA[i] = 0x4a
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *SOResult) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *SOResult) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.IsEvent {
        dAtA[i] = 0x8
        i++
        if m.IsEvent {
            dAtA[i] = 1
        } else {
            dAtA[i] = 0
        }
        i++
    }
    if m.IsEndRecord {
        dAtA[i] = 0x10
        i++
        if m.IsEndRecord {
            dAtA[i] = 1
        } else {
            dAtA[i] = 0
        }
        i++
    }
    if len(m.Targets) > 0 {
        for _, msg := range m.Targets {
            dAtA[i] = 0x1a
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.FirstImage != nil {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.FirstImage.Size()))
        n1, err1 := m.FirstImage.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        }
        i += n1
    }
    if m.CacheImage != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.CacheImage.Size()))
        n2, err2 := m.CacheImage.MarshalTo(dAtA[i:])
        if err2 != nil {
            return 0, err2
        }
        i += n2
    }
    if m.SoRule != nil {
        dAtA[i] = 0x32
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size()))
        n3, err3 := m.SoRule.MarshalTo(dAtA[i:])
        if err3 != nil {
            return 0, err3
        }
        i += n3
    }
    if m.GroupRule != nil {
        dAtA[i] = 0x3a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size()))
        n4, err4 := m.GroupRule.MarshalTo(dAtA[i:])
        if err4 != nil {
            return 0, err4
        }
        i += n4
    }
    if len(m.SoType) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SoType)))
        i += copy(dAtA[i:], m.SoType)
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *SoTarget) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalToSizedBuffer(dAtA[:size])
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
@@ -573,78 +1091,65 @@
}

func (m *SoTarget) MarshalTo(dAtA []byte) (int, error) {
    size := m.Size()
    return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SoTarget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    var i int
    _ = i
    var l int
    _ = l
    if m.XXX_unrecognized != nil {
        i -= len(m.XXX_unrecognized)
        copy(dAtA[i:], m.XXX_unrecognized)
    }
    if m.ImageId != 0 {
        i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
        i--
        dAtA[i] = 0x30
    }
    if len(m.CompDbInfo) > 0 {
        for iNdEx := len(m.CompDbInfo) - 1; iNdEx >= 0; iNdEx-- {
            {
                size, err := m.CompDbInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                    return 0, err
                }
                i -= size
                i = encodeVarintDataprocess(dAtA, i, uint64(size))
            }
            i--
            dAtA[i] = 0x2a
    if m.SrcTarget != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.SrcTarget.Size()))
        n5, err5 := m.SrcTarget.MarshalTo(dAtA[i:])
        if err5 != nil {
            return 0, err5
        }
    }
    if len(m.BelongsTargetID) > 0 {
        i -= len(m.BelongsTargetID)
        copy(dAtA[i:], m.BelongsTargetID)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
        i--
        dAtA[i] = 0x22
    }
    if len(m.AreaName) > 0 {
        i -= len(m.AreaName)
        copy(dAtA[i:], m.AreaName)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
        i--
        dAtA[i] = 0x1a
        i += n5
    }
    if len(m.AreaId) > 0 {
        i -= len(m.AreaId)
        copy(dAtA[i:], m.AreaId)
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
        i--
        dAtA[i] = 0x12
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
        i += copy(dAtA[i:], m.AreaId)
    }
    if m.SrcTarget != nil {
        {
            size, err := m.SrcTarget.MarshalToSizedBuffer(dAtA[:i])
    if len(m.AreaName) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
        i += copy(dAtA[i:], m.AreaName)
    }
    if len(m.BelongsTargetID) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
        i += copy(dAtA[i:], m.BelongsTargetID)
    }
    if len(m.CompDbInfo) > 0 {
        for _, msg := range m.CompDbInfo {
            dAtA[i] = 0x2a
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i -= size
            i = encodeVarintDataprocess(dAtA, i, uint64(size))
            i += n
        }
        i--
        dAtA[i] = 0xa
    }
    return len(dAtA) - i, nil
    if m.ImageId != 0 {
        dAtA[i] = 0x30
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *EventCache) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalToSizedBuffer(dAtA[:size])
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
@@ -652,100 +1157,102 @@
}

func (m *EventCache) MarshalTo(dAtA []byte) (int, error) {
    size := m.Size()
    return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventCache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    var i int
    _ = i
    var l int
    _ = l
    if m.XXX_unrecognized != nil {
        i -= len(m.XXX_unrecognized)
        copy(dAtA[i:], m.XXX_unrecognized)
    }
    if len(m.Images) > 0 {
        for k := range m.Images {
            v := m.Images[k]
            baseI := i
    if len(m.Targets) > 0 {
        for k, _ := range m.Targets {
            dAtA[i] = 0xa
            i++
            v := m.Targets[k]
            msgSize := 0
            if v != nil {
                {
                    size, err := v.MarshalToSizedBuffer(dAtA[:i])
                    if err != nil {
                        return 0, err
                    }
                    i -= size
                    i = encodeVarintDataprocess(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x12
                msgSize = v.Size()
                msgSize += 1 + sovDataprocess(uint64(msgSize))
            }
            i = encodeVarintDataprocess(dAtA, i, uint64(k))
            i--
            mapSize := 1 + sovDataprocess(uint64(k)) + msgSize
            i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
            dAtA[i] = 0x8
            i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
            i--
            dAtA[i] = 0x1a
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(k))
            if v != nil {
                dAtA[i] = 0x12
                i++
                i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
                n6, err6 := v.MarshalTo(dAtA[i:])
                if err6 != nil {
                    return 0, err6
                }
                i += n6
            }
        }
    }
    if len(m.RuleGroups) > 0 {
        for k := range m.RuleGroups {
            v := m.RuleGroups[k]
            baseI := i
            if v != nil {
                {
                    size, err := v.MarshalToSizedBuffer(dAtA[:i])
                    if err != nil {
                        return 0, err
                    }
                    i -= size
                    i = encodeVarintDataprocess(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x12
            }
            i -= len(k)
            copy(dAtA[i:], k)
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i--
            dAtA[i] = 0xa
            i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
            i--
        for k, _ := range m.RuleGroups {
            dAtA[i] = 0x12
        }
    }
    if len(m.Targets) > 0 {
        for k := range m.Targets {
            v := m.Targets[k]
            baseI := i
            i++
            v := m.RuleGroups[k]
            msgSize := 0
            if v != nil {
                {
                    size, err := v.MarshalToSizedBuffer(dAtA[:i])
                    if err != nil {
                        return 0, err
                    }
                    i -= size
                    i = encodeVarintDataprocess(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x12
                msgSize = v.Size()
                msgSize += 1 + sovDataprocess(uint64(msgSize))
            }
            i = encodeVarintDataprocess(dAtA, i, uint64(k))
            i--
            dAtA[i] = 0x8
            i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
            i--
            mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
            i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
            dAtA[i] = 0xa
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i += copy(dAtA[i:], k)
            if v != nil {
                dAtA[i] = 0x12
                i++
                i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
                n7, err7 := v.MarshalTo(dAtA[i:])
                if err7 != nil {
                    return 0, err7
                }
                i += n7
            }
        }
    }
    return len(dAtA) - i, nil
    if len(m.Images) > 0 {
        for k, _ := range m.Images {
            dAtA[i] = 0x1a
            i++
            v := m.Images[k]
            msgSize := 0
            if v != nil {
                msgSize = v.Size()
                msgSize += 1 + sovDataprocess(uint64(msgSize))
            }
            mapSize := 1 + sovDataprocess(uint64(k)) + msgSize
            i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
            dAtA[i] = 0x8
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(k))
            if v != nil {
                dAtA[i] = 0x12
                i++
                i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
                n8, err8 := v.MarshalTo(dAtA[i:])
                if err8 != nil {
                    return 0, err8
                }
                i += n8
            }
        }
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *TargetCache) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalToSizedBuffer(dAtA[:size])
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
@@ -753,78 +1260,70 @@
}

func (m *TargetCache) MarshalTo(dAtA []byte) (int, error) {
    size := m.Size()
    return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TargetCache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    var i int
    _ = i
    var l int
    _ = l
    if m.XXX_unrecognized != nil {
        i -= len(m.XXX_unrecognized)
        copy(dAtA[i:], m.XXX_unrecognized)
    }
    if m.Image != nil {
        {
            size, err := m.Image.MarshalToSizedBuffer(dAtA[:i])
    if len(m.Target) > 0 {
        for _, msg := range m.Target {
            dAtA[i] = 0xa
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i -= size
            i = encodeVarintDataprocess(dAtA, i, uint64(size))
            i += n
        }
        i--
        dAtA[i] = 0x1a
    }
    if len(m.RuleGroups) > 0 {
        for k := range m.RuleGroups {
            v := m.RuleGroups[k]
            baseI := i
            if v != nil {
                {
                    size, err := v.MarshalToSizedBuffer(dAtA[:i])
                    if err != nil {
                        return 0, err
                    }
                    i -= size
                    i = encodeVarintDataprocess(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x12
            }
            i -= len(k)
            copy(dAtA[i:], k)
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i--
            dAtA[i] = 0xa
            i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
            i--
        for k, _ := range m.RuleGroups {
            dAtA[i] = 0x12
        }
    }
    if len(m.Target) > 0 {
        for iNdEx := len(m.Target) - 1; iNdEx >= 0; iNdEx-- {
            {
                size, err := m.Target[iNdEx].MarshalToSizedBuffer(dAtA[:i])
                if err != nil {
                    return 0, err
                }
                i -= size
                i = encodeVarintDataprocess(dAtA, i, uint64(size))
            i++
            v := m.RuleGroups[k]
            msgSize := 0
            if v != nil {
                msgSize = v.Size()
                msgSize += 1 + sovDataprocess(uint64(msgSize))
            }
            i--
            mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
            i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
            dAtA[i] = 0xa
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i += copy(dAtA[i:], k)
            if v != nil {
                dAtA[i] = 0x12
                i++
                i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
                n9, err9 := v.MarshalTo(dAtA[i:])
                if err9 != nil {
                    return 0, err9
                }
                i += n9
            }
        }
    }
    return len(dAtA) - i, nil
    if m.Image != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.Image.Size()))
        n10, err10 := m.Image.MarshalTo(dAtA[i:])
        if err10 != nil {
            return 0, err10
        }
        i += n10
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *FilterResult) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalToSizedBuffer(dAtA[:size])
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
@@ -832,96 +1331,90 @@
}

func (m *FilterResult) MarshalTo(dAtA []byte) (int, error) {
    size := m.Size()
    return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FilterResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    var i int
    _ = i
    var l int
    _ = l
    if m.XXX_unrecognized != nil {
        i -= len(m.XXX_unrecognized)
        copy(dAtA[i:], m.XXX_unrecognized)
    }
    if len(m.Targets) > 0 {
        for k := range m.Targets {
            v := m.Targets[k]
            baseI := i
            if v != nil {
                {
                    size, err := v.MarshalToSizedBuffer(dAtA[:i])
                    if err != nil {
                        return 0, err
                    }
                    i -= size
                    i = encodeVarintDataprocess(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x12
            }
            i -= len(k)
            copy(dAtA[i:], k)
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i--
            dAtA[i] = 0xa
            i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
            i--
            dAtA[i] = 0x1a
    if m.BaseInfo != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.BaseInfo.Size()))
        n11, err11 := m.BaseInfo.MarshalTo(dAtA[i:])
        if err11 != nil {
            return 0, err11
        }
        i += n11
    }
    if len(m.Events) > 0 {
        for k := range m.Events {
            v := m.Events[k]
            baseI := i
            if v != nil {
                {
                    size, err := v.MarshalToSizedBuffer(dAtA[:i])
                    if err != nil {
                        return 0, err
                    }
                    i -= size
                    i = encodeVarintDataprocess(dAtA, i, uint64(size))
                }
                i--
                dAtA[i] = 0x12
            }
            i -= len(k)
            copy(dAtA[i:], k)
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i--
            dAtA[i] = 0xa
            i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
            i--
        for k, _ := range m.Events {
            dAtA[i] = 0x12
        }
    }
    if m.BaseInfo != nil {
        {
            size, err := m.BaseInfo.MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
                return 0, err
            i++
            v := m.Events[k]
            msgSize := 0
            if v != nil {
                msgSize = v.Size()
                msgSize += 1 + sovDataprocess(uint64(msgSize))
            }
            i -= size
            i = encodeVarintDataprocess(dAtA, i, uint64(size))
            mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
            i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
            dAtA[i] = 0xa
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i += copy(dAtA[i:], k)
            if v != nil {
                dAtA[i] = 0x12
                i++
                i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
                n12, err12 := v.MarshalTo(dAtA[i:])
                if err12 != nil {
                    return 0, err12
                }
                i += n12
            }
        }
        i--
        dAtA[i] = 0xa
    }
    return len(dAtA) - i, nil
    if len(m.Targets) > 0 {
        for k, _ := range m.Targets {
            dAtA[i] = 0x1a
            i++
            v := m.Targets[k]
            msgSize := 0
            if v != nil {
                msgSize = v.Size()
                msgSize += 1 + sovDataprocess(uint64(msgSize))
            }
            mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
            i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
            dAtA[i] = 0xa
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
            i += copy(dAtA[i:], k)
            if v != nil {
                dAtA[i] = 0x12
                i++
                i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
                n13, err13 := v.MarshalTo(dAtA[i:])
                if err13 != nil {
                    return 0, err13
                }
                i += n13
            }
        }
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func encodeVarintDataprocess(dAtA []byte, offset int, v uint64) int {
    offset -= sovDataprocess(v)
    base := offset
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
        v >>= 7
        offset++
    }
    dAtA[offset] = uint8(v)
    return base
    return offset + 1
}
func (m *TaskBasicInfo) Size() (n int) {
    if m == nil {
@@ -960,6 +1453,126 @@
        n += 2
    }
    l = len(m.FileId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *RuleParams) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.SdkArgAlias)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.Operator)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.OperatorType)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.SdkArgValue)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *SoRule) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Id)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.CameraId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.PolygonId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.SdkId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.Sort != 0 {
        n += 1 + sovDataprocess(uint64(m.Sort))
    }
    l = len(m.RuleWithPre)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.IsSaveAnyhow {
        n += 2
    }
    l = len(m.GroupId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if len(m.Params) > 0 {
        for _, e := range m.Params {
            l = e.Size()
            n += 1 + l + sovDataprocess(uint64(l))
        }
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *SOResult) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.IsEvent {
        n += 2
    }
    if m.IsEndRecord {
        n += 2
    }
    if len(m.Targets) > 0 {
        for _, e := range m.Targets {
            l = e.Size()
            n += 1 + l + sovDataprocess(uint64(l))
        }
    }
    if m.FirstImage != nil {
        l = m.FirstImage.Size()
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.CacheImage != nil {
        l = m.CacheImage.Size()
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.SoRule != nil {
        l = m.SoRule.Size()
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.GroupRule != nil {
        l = m.GroupRule.Size()
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.SoType)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
@@ -1135,7 +1748,14 @@
}

func sovDataprocess(x uint64) (n int) {
    return (math_bits.Len64(x|1) + 6) / 7
    for {
        n++
        x >>= 7
        if x == 0 {
            break
        }
    }
    return n
}
func sozDataprocess(x uint64) (n int) {
    return sovDataprocess(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -1438,7 +2058,815 @@
            if err != nil {
                return err
            }
            if (skippy < 0) || (iNdEx+skippy) < 0 {
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *RuleParams) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: RuleParams: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: RuleParams: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkArgAlias", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.SdkArgAlias = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Operator = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field OperatorType", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.OperatorType = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkArgValue", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.SdkArgValue = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipDataprocess(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *SoRule) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: SoRule: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SoRule: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Id = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.CameraId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PolygonId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.PolygonId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.SdkId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 5:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
            }
            m.Sort = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Sort |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.RuleWithPre = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 7:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field IsSaveAnyhow", wireType)
            }
            var v int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                v |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            m.IsSaveAnyhow = bool(v != 0)
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.GroupId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 9:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Params = append(m.Params, &RuleParams{})
            if err := m.Params[len(m.Params)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipDataprocess(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *SOResult) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: SOResult: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SOResult: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field IsEvent", wireType)
            }
            var v int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                v |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            m.IsEvent = bool(v != 0)
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field IsEndRecord", wireType)
            }
            var v int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                v |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            m.IsEndRecord = bool(v != 0)
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Targets", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Targets = append(m.Targets, &SoTarget{})
            if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field FirstImage", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.FirstImage == nil {
                m.FirstImage = &Image{}
            }
            if err := m.FirstImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CacheImage", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.CacheImage == nil {
                m.CacheImage = &Image{}
            }
            if err := m.CacheImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SoRule", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.SoRule == nil {
                m.SoRule = &SoRule{}
            }
            if err := m.SoRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 7:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field GroupRule", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.GroupRule == nil {
                m.GroupRule = &GroupRule{}
            }
            if err := m.GroupRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SoType", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.SoType = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipDataprocess(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
@@ -1674,7 +3102,10 @@
            if err != nil {
                return err
            }
            if (skippy < 0) || (iNdEx+skippy) < 0 {
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
@@ -1823,7 +3254,7 @@
                    if err != nil {
                        return err
                    }
                    if (skippy < 0) || (iNdEx+skippy) < 0 {
                    if skippy < 0 {
                        return ErrInvalidLengthDataprocess
                    }
                    if (iNdEx + skippy) > postIndex {
@@ -1952,7 +3383,7 @@
                    if err != nil {
                        return err
                    }
                    if (skippy < 0) || (iNdEx+skippy) < 0 {
                    if skippy < 0 {
                        return ErrInvalidLengthDataprocess
                    }
                    if (iNdEx + skippy) > postIndex {
@@ -2067,7 +3498,7 @@
                    if err != nil {
                        return err
                    }
                    if (skippy < 0) || (iNdEx+skippy) < 0 {
                    if skippy < 0 {
                        return ErrInvalidLengthDataprocess
                    }
                    if (iNdEx + skippy) > postIndex {
@@ -2084,7 +3515,10 @@
            if err != nil {
                return err
            }
            if (skippy < 0) || (iNdEx+skippy) < 0 {
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
@@ -2281,7 +3715,7 @@
                    if err != nil {
                        return err
                    }
                    if (skippy < 0) || (iNdEx+skippy) < 0 {
                    if skippy < 0 {
                        return ErrInvalidLengthDataprocess
                    }
                    if (iNdEx + skippy) > postIndex {
@@ -2334,7 +3768,10 @@
            if err != nil {
                return err
            }
            if (skippy < 0) || (iNdEx+skippy) < 0 {
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
@@ -2533,7 +3970,7 @@
                    if err != nil {
                        return err
                    }
                    if (skippy < 0) || (iNdEx+skippy) < 0 {
                    if skippy < 0 {
                        return ErrInvalidLengthDataprocess
                    }
                    if (iNdEx + skippy) > postIndex {
@@ -2662,7 +4099,7 @@
                    if err != nil {
                        return err
                    }
                    if (skippy < 0) || (iNdEx+skippy) < 0 {
                    if skippy < 0 {
                        return ErrInvalidLengthDataprocess
                    }
                    if (iNdEx + skippy) > postIndex {
@@ -2679,7 +4116,10 @@
            if err != nil {
                return err
            }
            if (skippy < 0) || (iNdEx+skippy) < 0 {
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
@@ -2698,7 +4138,6 @@
func skipDataprocess(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0
    depth := 0
    for iNdEx < l {
        var wire uint64
        for shift := uint(0); ; shift += 7 {
@@ -2730,8 +4169,10 @@
                    break
                }
            }
            return iNdEx, nil
        case 1:
            iNdEx += 8
            return iNdEx, nil
        case 2:
            var length int
            for shift := uint(0); ; shift += 7 {
@@ -2752,30 +4193,55 @@
                return 0, ErrInvalidLengthDataprocess
            }
            iNdEx += length
        case 3:
            depth++
        case 4:
            if depth == 0 {
                return 0, ErrUnexpectedEndOfGroupDataprocess
            if iNdEx < 0 {
                return 0, ErrInvalidLengthDataprocess
            }
            depth--
            return iNdEx, nil
        case 3:
            for {
                var innerWire uint64
                var start int = iNdEx
                for shift := uint(0); ; shift += 7 {
                    if shift >= 64 {
                        return 0, ErrIntOverflowDataprocess
                    }
                    if iNdEx >= l {
                        return 0, io.ErrUnexpectedEOF
                    }
                    b := dAtA[iNdEx]
                    iNdEx++
                    innerWire |= (uint64(b) & 0x7F) << shift
                    if b < 0x80 {
                        break
                    }
                }
                innerWireType := int(innerWire & 0x7)
                if innerWireType == 4 {
                    break
                }
                next, err := skipDataprocess(dAtA[start:])
                if err != nil {
                    return 0, err
                }
                iNdEx = start + next
                if iNdEx < 0 {
                    return 0, ErrInvalidLengthDataprocess
                }
            }
            return iNdEx, nil
        case 4:
            return iNdEx, nil
        case 5:
            iNdEx += 4
            return iNdEx, nil
        default:
            return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
        }
        if iNdEx < 0 {
            return 0, ErrInvalidLengthDataprocess
        }
        if depth == 0 {
            return iNdEx, nil
        }
    }
    return 0, io.ErrUnexpectedEOF
    panic("unreachable")
}

var (
    ErrInvalidLengthDataprocess        = fmt.Errorf("proto: negative length found during unmarshaling")
    ErrIntOverflowDataprocess          = fmt.Errorf("proto: integer overflow")
    ErrUnexpectedEndOfGroupDataprocess = fmt.Errorf("proto: unexpected end of group")
    ErrInvalidLengthDataprocess = fmt.Errorf("proto: negative length found during unmarshaling")
    ErrIntOverflowDataprocess   = fmt.Errorf("proto: integer overflow")
)

 dataprocess.proto

@@ -17,13 +17,43 @@
    string  FileId = 9;      // 数据栈中的文件id
}

message RuleParams {
    string SdkArgAlias = 1; 
    string Operator = 2;    
    string OperatorType = 3;  
    string SdkArgValue = 4; 
}

message SoRule {
    string Id = 1;          
    string CameraId = 2;     
    string PolygonId = 3;   
    string SdkId = 4;        
    int32 Sort = 5;        
    string RuleWithPre = 6;  
    bool IsSaveAnyhow =7; 
    string GroupId = 8;     
    repeated RuleParams Params = 9;
}

message SOResult {
    bool IsEvent = 1;    
    bool IsEndRecord = 2;
    repeated SoTarget Targets = 3;
    Image FirstImage = 4;
    Image CacheImage = 5;
    SoRule SoRule = 6;
    GroupRule GroupRule = 7;
    string SoType = 8;
}

message SoTarget {
    Target SrcTarget = 1;       
    string AreaId    = 2;      
    string AreaName  = 3;      
    string AreaId = 2;      
    string AreaName = 3;      
    string BelongsTargetID = 4;
    repeated RuleBaseCompareInfo CompDbInfo = 5;
    int64 ImageId   = 6;      
    int64 ImageId = 6;      
}

message EventCache {