13070263183

Committed 31 Jan 2025 09:45AM UTC coverage: 0.0%. Remained the same

Build # 13070263183

Build Type

Pull #5

github

Committed by

Civil

Commit Message

Refactor and improve bot

 * Fixed small bug in forward action
 * package statefulFilters renamed to chains
 * generic badgerdb interface
 * add filter that counts repeated messages
 * add filter that checks if message is a story
 * add filter that checks if message was marked as spam

Pull Request Pull Request #5: some improvements

Run Details

0 of 1422 new or added lines in 20 files covered. (0.0%)

21 existing lines in 3 files now uncovered.

0 of 3756 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/filters/filteringRules/isRepeatedMessage/rule.go

package isRepeatedMessage

import (
        "crypto/sha256"
        "errors"
        "fmt"
        "strings"

        "github.com/dgraph-io/badger/v4"
        "github.com/mymmrac/telego"
        "go.uber.org/zap"
        "google.golang.org/protobuf/proto"

        "github.com/Civil/tg-simple-regex-antispam/filters/interfaces"
        "github.com/Civil/tg-simple-regex-antispam/filters/types/messageWithCounter"
        "github.com/Civil/tg-simple-regex-antispam/filters/types/scoringResult"
        config2 "github.com/Civil/tg-simple-regex-antispam/helper/config"
        "github.com/Civil/tg-simple-regex-antispam/sharedDBs/messages"
)

type Filter struct {
        messageDB *messages.MessageDB
        logger    *zap.Logger
        chainName string
        isFinal   bool
        threshold uint64
}

func New(logger *zap.Logger, config map[string]any, chainName string) (interfaces.FilteringRule, error) {
        logger = logger.With(zap.String("filter", chainName), zap.String("filter_type", "isRepeatedMessage"))
        isFinal, err := config2.GetOptionBoolWithDefault(config, "isFinal", true)
        if err != nil {
                return nil, err
        }

        threshold, err := config2.GetOptionIntWithDefault(config, "n", 1)
        if err != nil {
                return nil, err
        }

        if threshold < 1 {
                return nil, errors.New("threshold should be greater than 1")
        }

        messageDB, err := messages.Get(logger, "repeatedMessages")
        if err != nil {
                return nil, err
        }

        return &Filter{
                logger:    logger,
                chainName: chainName,
                isFinal:   isFinal,
                messageDB: messageDB,

                threshold: uint64(threshold),
        }, nil
}

func Help() string {
        return "isInSpam checks if the message is forwarded"
}

func (r *Filter) Score(_ *telego.Bot, msg *telego.Message) *scoringResult.ScoringResult {
        res := &scoringResult.ScoringResult{
                Score: 0,
        }
        msgByte := []byte(msg.Text)
        msgSha256 := sha256.Sum256(msgByte)
        key := messageWithCounter.Key_builder{
                UserId: msg.From.ID,
                Sha256: msgSha256[:],
        }.Build()
        marshaledKey, err := proto.Marshal(key)
        if err != nil {
                return res
        }
        data, err := r.messageDB.LoadValue(marshaledKey)
        if err != nil {
                if errors.Is(err, badger.ErrKeyNotFound) {
                        msgWithCounter := messageWithCounter.MessageWithCounter_builder{
                                Message: msg.Text,
                                Counter: 1,
                        }.Build()
                        data, err = proto.Marshal(msgWithCounter)
                        if err != nil {
                                return res
                        }
                        err = r.messageDB.StoreValue(marshaledKey, data)
                        if err != nil {
                                return res
                        }
                }
                return res
        }

        msgWithCounter := &messageWithCounter.MessageWithCounter{}
        err = proto.Unmarshal(data, msgWithCounter)
        if err != nil {
                return res
        }

        if strings.Compare(msgWithCounter.GetMessage(), msg.Text) == 0 {
                counter := msgWithCounter.GetCounter() + 1
                msgWithCounter.SetCounter(counter)
                if counter > r.threshold {
                        res.Score = 100
                        res.Reason = fmt.Sprintf("this message was repeated by that user more than %v times",
                                r.threshold)
                }
                data, err = proto.Marshal(msgWithCounter)
                if err != nil {
                        return res
                }
                err = r.messageDB.StoreValue(marshaledKey, data)
                if err != nil {
                        return res
                }
        } else {
                r.logger.Error("key collision found",
                        zap.ByteString("current_message", msgByte),
                        zap.ByteString("collided_with", data),
                )
        }

        return res
}

func (r *Filter) IsStateful() bool {
        return false
}

func (r *Filter) GetName() string {
        return "isRepeatedMessage"
}

func (r *Filter) GetFilterName() string {
        return ""
}

func (r *Filter) IsFinal() bool {
        return r.isFinal
}

func (r *Filter) TGAdminPrefix() string {
        return ""
}

func (r *Filter) HandleTGCommands(_ *zap.Logger, _ *telego.Bot, _ *telego.Message, _ []string) error {
        return nil
}

1	package isRepeatedMessage
2
3	import (
4	"crypto/sha256"
5	"errors"
6	"fmt"
7	"strings"
8
9	"github.com/dgraph-io/badger/v4"
10	"github.com/mymmrac/telego"
11	"go.uber.org/zap"
12	"google.golang.org/protobuf/proto"
13
14	"github.com/Civil/tg-simple-regex-antispam/filters/interfaces"
15	"github.com/Civil/tg-simple-regex-antispam/filters/types/messageWithCounter"
16	"github.com/Civil/tg-simple-regex-antispam/filters/types/scoringResult"
17	config2 "github.com/Civil/tg-simple-regex-antispam/helper/config"
18	"github.com/Civil/tg-simple-regex-antispam/sharedDBs/messages"
19	)
20
21	type Filter struct {
22	messageDB *messages.MessageDB
23	logger *zap.Logger
24	chainName string
25	isFinal bool
26	threshold uint64
27	}
28
NEW 29	func New(logger *zap.Logger, config map[string]any, chainName string) (interfaces.FilteringRule, error) {	×
NEW 30	logger = logger.With(zap.String("filter", chainName), zap.String("filter_type", "isRepeatedMessage"))	×
NEW 31	isFinal, err := config2.GetOptionBoolWithDefault(config, "isFinal", true)	×
NEW 32	if err != nil {	×
NEW 33	return nil, err	×
NEW 34	}	×
35
NEW 36	threshold, err := config2.GetOptionIntWithDefault(config, "n", 1)	×
NEW 37	if err != nil {	×
NEW 38	return nil, err	×
NEW 39	}	×
40
NEW 41	if threshold < 1 {	×
NEW 42	return nil, errors.New("threshold should be greater than 1")	×
NEW 43	}	×
44
NEW 45	messageDB, err := messages.Get(logger, "repeatedMessages")	×
NEW 46	if err != nil {	×
NEW 47	return nil, err	×
NEW 48	}	×
49
NEW 50	return &Filter{	×
NEW 51	logger: logger,	×
NEW 52	chainName: chainName,	×
NEW 53	isFinal: isFinal,	×
NEW 54	messageDB: messageDB,	×
NEW 55		×
NEW 56	threshold: uint64(threshold),	×
NEW 57	}, nil	×
58	}
59
NEW 60	func Help() string {	×
NEW 61	return "isInSpam checks if the message is forwarded"	×
NEW 62	}	×
63
NEW 64	func (r Filter) Score(_ telego.Bot, msg telego.Message) scoringResult.ScoringResult {	×
NEW 65	res := &scoringResult.ScoringResult{	×
NEW 66	Score: 0,	×
NEW 67	}	×
NEW 68	msgByte := []byte(msg.Text)	×
NEW 69	msgSha256 := sha256.Sum256(msgByte)	×
NEW 70	key := messageWithCounter.Key_builder{	×
NEW 71	UserId: msg.From.ID,	×
NEW 72	Sha256: msgSha256[:],	×
NEW 73	}.Build()	×
NEW 74	marshaledKey, err := proto.Marshal(key)	×
NEW 75	if err != nil {	×
NEW 76	return res	×
NEW 77	}	×
NEW 78	data, err := r.messageDB.LoadValue(marshaledKey)	×
NEW 79	if err != nil {	×
NEW 80	if errors.Is(err, badger.ErrKeyNotFound) {	×
NEW 81	msgWithCounter := messageWithCounter.MessageWithCounter_builder{	×
NEW 82	Message: msg.Text,	×
NEW 83	Counter: 1,	×
NEW 84	}.Build()	×
NEW 85	data, err = proto.Marshal(msgWithCounter)	×
NEW 86	if err != nil {	×
NEW 87	return res	×
NEW 88	}	×
NEW 89	err = r.messageDB.StoreValue(marshaledKey, data)	×
NEW 90	if err != nil {	×
NEW 91	return res	×
NEW 92	}	×
93	}
NEW 94	return res	×
95	}
96
NEW 97	msgWithCounter := &messageWithCounter.MessageWithCounter{}	×
NEW 98	err = proto.Unmarshal(data, msgWithCounter)	×
NEW 99	if err != nil {	×
NEW 100	return res	×
NEW 101	}	×
102
NEW 103	if strings.Compare(msgWithCounter.GetMessage(), msg.Text) == 0 {	×
NEW 104	counter := msgWithCounter.GetCounter() + 1	×
NEW 105	msgWithCounter.SetCounter(counter)	×
NEW 106	if counter > r.threshold {	×
NEW 107	res.Score = 100	×
NEW 108	res.Reason = fmt.Sprintf("this message was repeated by that user more than %v times",	×
NEW 109	r.threshold)	×
NEW 110	}	×
NEW 111	data, err = proto.Marshal(msgWithCounter)	×
NEW 112	if err != nil {	×
NEW 113	return res	×
NEW 114	}	×
NEW 115	err = r.messageDB.StoreValue(marshaledKey, data)	×
NEW 116	if err != nil {	×
NEW 117	return res	×
NEW 118	}	×
NEW 119	} else {	×
NEW 120	r.logger.Error("key collision found",	×
NEW 121	zap.ByteString("current_message", msgByte),	×
NEW 122	zap.ByteString("collided_with", data),	×
NEW 123	)	×
NEW 124	}	×
125
NEW 126	return res	×
127	}
128
NEW 129	func (r *Filter) IsStateful() bool {	×
NEW 130	return false	×
NEW 131	}	×
132
NEW 133	func (r *Filter) GetName() string {	×
NEW 134	return "isRepeatedMessage"	×
NEW 135	}	×
136
NEW 137	func (r *Filter) GetFilterName() string {	×
NEW 138	return ""	×
NEW 139	}	×
140
NEW 141	func (r *Filter) IsFinal() bool {	×
NEW 142	return r.isFinal	×
NEW 143	}	×
144
NEW 145	func (r *Filter) TGAdminPrefix() string {	×
NEW 146	return ""	×
NEW 147	}	×
148
NEW 149	func (r Filter) HandleTGCommands(_ zap.Logger, _ telego.Bot, _ telego.Message, _ []string) error {	×
NEW 150	return nil	×
NEW 151	}	×

Civil / tg-simple-regex-antispam / 13070263183

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous