/
textSaver.go
155 lines (137 loc) · 3.88 KB
/
textSaver.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package mongodb
import (
"context"
"time"
"github.com/airenas/go-app/pkg/goapp"
"github.com/airenas/tts-line/internal/pkg/utils"
"github.com/pkg/errors"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
)
// TextSaver saves text to mongo DB
type TextSaver struct {
SessionProvider *SessionProvider
}
//NewTextSaver creates TextSaver instance
func NewTextSaver(sessionProvider *SessionProvider) (*TextSaver, error) {
if sessionProvider == nil {
return nil, errors.New("no session provider")
}
f := TextSaver{SessionProvider: sessionProvider}
return &f, nil
}
// Save text to DB
func (ss *TextSaver) Save(req, text string, reqType utils.RequestTypeEnum, tags []string) error {
goapp.Log.Infof("Saving ID %s", req)
ctx, cancel := mongoContext()
defer cancel()
session, err := ss.SessionProvider.NewSession()
if err != nil {
return err
}
defer session.EndSession(context.Background())
c := session.Client().Database(textTable).Collection(textTable)
res := toRecord(req, text, reqType, tags)
_, err = c.InsertOne(ctx, res)
return err
}
// All loads all records
func (ss *TextSaver) All() ([]*TextRecord, error) {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) // increase to retrieve all records
defer cancel()
session, err := ss.SessionProvider.NewSession()
if err != nil {
return nil, err
}
defer session.EndSession(context.Background())
c := session.Client().Database(textTable).Collection(textTable)
cursor, err := c.Find(ctx, bson.M{})
if err != nil {
return nil, errors.Wrap(err, "can't get data")
}
defer cursor.Close(ctx)
res := make([]*TextRecord, 0)
for cursor.Next(ctx) {
var key TextRecord
if err = cursor.Decode(&key); err != nil {
return nil, errors.Wrap(err, "can't get key")
}
res = append(res, &key)
}
if err := cursor.Err(); err != nil {
return nil, errors.Wrap(err, "cursor error")
}
return res, nil
}
// Delete deletes records from db
func (ss *TextSaver) Delete(ID string) (int, error) {
ctx, cancel := mongoContext()
defer cancel()
session, err := ss.SessionProvider.NewSession()
if err != nil {
return 0, err
}
defer session.EndSession(context.Background())
c := session.Client().Database(textTable).Collection(textTable)
info, err := c.DeleteMany(ctx, bson.M{"id": sanitize(ID)})
if err != nil {
return 0, err
}
return int(info.DeletedCount), nil
}
// LoadText by ID and type
func (ss *TextSaver) LoadText(requestID string, reqType utils.RequestTypeEnum) (string, error) {
ctx, cancel := mongoContext()
defer cancel()
session, err := ss.SessionProvider.NewSession()
if err != nil {
return "", err
}
defer session.EndSession(context.Background())
c := session.Client().Database(textTable).Collection(textTable)
var res TextRecord
err = c.FindOne(ctx, bson.M{
"$and": []bson.M{
{"id": sanitize(requestID)},
{"type": int(reqType)},
}}).Decode(&res)
if err != nil {
if err == mongo.ErrNoDocuments {
return "", utils.ErrNoRecord
}
return "", errors.Wrap(err, "can't get data")
}
return res.Text, nil
}
// GetCount by ID and type
func (ss *TextSaver) GetCount(requestID string, reqType utils.RequestTypeEnum) (int64, error) {
ctx, cancel := mongoContext()
defer cancel()
session, err := ss.SessionProvider.NewSession()
if err != nil {
return 0, err
}
defer session.EndSession(context.Background())
c := session.Client().Database(textTable).Collection(textTable)
res, err := c.CountDocuments(ctx, bson.M{
"$and": []bson.M{
{"id": sanitize(requestID)},
{"type": int(reqType)},
}})
if err != nil {
if err == mongo.ErrNoDocuments {
return 0, utils.ErrNoRecord
}
return 0, errors.Wrap(err, "can't get count")
}
return res, nil
}
func toRecord(req, text string, reqType utils.RequestTypeEnum, tags []string) *TextRecord {
res := &TextRecord{}
res.ID = req
res.Text = text
res.Type = int(reqType)
res.Created = time.Now()
res.Tags = tags
return res
}