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
|
package meilisearch
import (
"bytes"
"context"
"encoding/csv"
"encoding/json"
"fmt"
"net/url"
"regexp"
"strconv"
"strings"
"time"
)
func IsValidUUID(uuid string) bool {
r := regexp.MustCompile("^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-4[a-fA-F0-9]{3}-[8|9|aA|bB][a-fA-F0-9]{3}-[a-fA-F0-9]{12}$")
return r.MatchString(uuid)
}
// This function allows the user to create a Key with an ExpiresAt in time.Time
// and transform the Key structure into a KeyParsed structure to send the time format
// managed by meilisearch
func convertKeyToParsedKey(key Key) (resp KeyParsed) {
resp = KeyParsed{
Name: key.Name,
Description: key.Description,
UID: key.UID,
Actions: key.Actions,
Indexes: key.Indexes,
}
// Convert time.Time to *string to feat the exact ISO-8601
// format of meilisearch
if !key.ExpiresAt.IsZero() {
resp.ExpiresAt = formatDate(key.ExpiresAt, true)
}
return resp
}
func encodeTasksQuery(param *TasksQuery, req *internalRequest) {
if param.Limit != 0 {
req.withQueryParams["limit"] = strconv.FormatInt(param.Limit, 10)
}
if param.From != 0 {
req.withQueryParams["from"] = strconv.FormatInt(param.From, 10)
}
if len(param.Statuses) != 0 {
var statuses []string
for _, status := range param.Statuses {
statuses = append(statuses, string(status))
}
req.withQueryParams["statuses"] = strings.Join(statuses, ",")
}
if len(param.Types) != 0 {
var types []string
for _, t := range param.Types {
types = append(types, string(t))
}
req.withQueryParams["types"] = strings.Join(types, ",")
}
if len(param.IndexUIDS) != 0 {
req.withQueryParams["indexUids"] = strings.Join(param.IndexUIDS, ",")
}
if len(param.UIDS) != 0 {
req.withQueryParams["uids"] = strings.Trim(strings.Join(strings.Fields(fmt.Sprint(param.UIDS)), ","), "[]")
}
if len(param.CanceledBy) != 0 {
req.withQueryParams["canceledBy"] = strings.Trim(strings.Join(strings.Fields(fmt.Sprint(param.CanceledBy)), ","), "[]")
}
if !param.BeforeEnqueuedAt.IsZero() {
req.withQueryParams["beforeEnqueuedAt"] = *formatDate(param.BeforeEnqueuedAt, false)
}
if !param.AfterEnqueuedAt.IsZero() {
req.withQueryParams["afterEnqueuedAt"] = *formatDate(param.AfterEnqueuedAt, false)
}
if !param.BeforeStartedAt.IsZero() {
req.withQueryParams["beforeStartedAt"] = *formatDate(param.BeforeStartedAt, false)
}
if !param.AfterStartedAt.IsZero() {
req.withQueryParams["afterStartedAt"] = *formatDate(param.AfterStartedAt, false)
}
if !param.BeforeFinishedAt.IsZero() {
req.withQueryParams["beforeFinishedAt"] = *formatDate(param.BeforeFinishedAt, false)
}
if !param.AfterFinishedAt.IsZero() {
req.withQueryParams["afterFinishedAt"] = *formatDate(param.AfterFinishedAt, false)
}
}
func formatDate(date time.Time, _ bool) *string {
const format = "2006-01-02T15:04:05Z"
timeParsedToString := date.Format(format)
return &timeParsedToString
}
func transformStringVariadicToMap(primaryKey ...string) (options map[string]string) {
if primaryKey != nil {
return map[string]string{
"primaryKey": primaryKey[0],
}
}
return nil
}
func transformCsvDocumentsQueryToMap(options *CsvDocumentsQuery) map[string]string {
var optionsMap map[string]string
data, _ := json.Marshal(options)
_ = json.Unmarshal(data, &optionsMap)
return optionsMap
}
func generateQueryForOptions(options map[string]string) (urlQuery string) {
q := url.Values{}
for key, val := range options {
q.Add(key, val)
}
return q.Encode()
}
func sendCsvRecords(ctx context.Context, documentsCsvFunc func(ctx context.Context, recs []byte, op *CsvDocumentsQuery) (resp *TaskInfo, err error), records [][]string, options *CsvDocumentsQuery) (*TaskInfo, error) {
b := new(bytes.Buffer)
w := csv.NewWriter(b)
w.UseCRLF = true
err := w.WriteAll(records)
if err != nil {
return nil, fmt.Errorf("could not write CSV records: %w", err)
}
resp, err := documentsCsvFunc(ctx, b.Bytes(), options)
if err != nil {
return nil, err
}
return resp, nil
}
|
