forked from textileio/go-textile
/
referrals.go
128 lines (115 loc) · 3.07 KB
/
referrals.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
package cafe
import (
"github.com/gin-gonic/gin"
"github.com/globalsign/mgo/bson"
"github.com/textileio/textile-go/cafe/dao"
"github.com/textileio/textile-go/cafe/models"
"math/rand"
"net/http"
"strconv"
"time"
)
func (c *Cafe) createReferral(g *gin.Context) {
// cheap way to lock down this endpoint
if c.ReferralKey != g.GetHeader("X-Referral-Key") {
g.JSON(http.StatusForbidden, gin.H{"error": "forbidden"})
return
}
// how many should we make?
count := 1
// how many times should we be able to use them
limit := 1
// simple reference to who requested the new code
requestedBy := ""
params := g.Request.URL.Query()
if params["count"] != nil && len(params["count"]) > 0 {
tmp, err := strconv.ParseInt(params["count"][0], 10, 64)
if err == nil {
count = int(tmp)
}
}
if params["limit"] != nil {
tmp, err := strconv.ParseInt(params["limit"][0], 10, 64)
if err == nil {
limit = int(tmp)
}
}
if params["requested_by"] != nil {
requestedBy = params["requested_by"][0]
}
// hodl 'em
refs := make([]string, count)
for i := range refs {
code, err := createReferral(limit, requestedBy)
if err != nil {
g.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
refs[i] = code
}
// ship it
g.JSON(http.StatusCreated, gin.H{
"status": http.StatusCreated,
"ref_codes": refs,
})
}
func (c *Cafe) listReferrals(g *gin.Context) {
// cheap way to lock down this endpoint
if c.ReferralKey != g.GetHeader("X-Referral-Key") {
g.JSON(http.StatusForbidden, gin.H{"error": "forbidden"})
return
}
// get 'em
refs, err := dao.Dao.ListUnusedReferrals()
if err != nil {
g.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
codes := make([]string, len(refs))
for i, r := range refs {
codes[i] = r.Code
}
// ship it
g.JSON(http.StatusOK, gin.H{
"status": http.StatusOK,
"ref_codes": codes,
})
}
// https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-golang
var src = rand.NewSource(time.Now().UnixNano())
const letterBytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
letterIdxBits = 6 // 6 bits to represent a letter index
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting in 63 bits
)
func randString(n int) string {
b := make([]byte, n)
// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = src.Int63(), letterIdxMax
}
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i--
}
cache >>= letterIdxBits
remain--
}
return string(b)
}
func createReferral(limit int, requester string) (string, error) {
code := randString(5)
ref := models.Referral{
ID: bson.NewObjectId(),
Code: code,
Created: time.Now(),
Remaining: limit,
Requester: requester,
}
if err := dao.Dao.InsertReferral(ref); err != nil {
return "", err
}
return code, nil
}