18 |
19 | | |
20 |
21 |
22 |
23 | {{block "content" .}}{{end}}
24 |
25 |
26 | |
27 | |
28 |
29 |
30 |
31 |
32 | {{end}}
33 |
--------------------------------------------------------------------------------
/templates/resetPassword.html:
--------------------------------------------------------------------------------
1 | {{template "base" .}} {{define "content"}}
2 |
3 |
4 |
5 |
6 |
7 |
8 | |
9 | Hi {{ .FirstName}},
10 |
11 | Forgot password? Send a PATCH request to with your password and
12 | passwordConfirm to {{.URL}}
13 |
14 |
21 |
22 |
23 | |
24 |
40 | |
41 |
42 |
43 |
44 | If you didn't forget your password, please ignore this email
45 | Good luck! Codevo CEO.
46 | |
47 |
48 |
49 | |
50 |
51 |
52 |
53 |
54 | {{end}}
55 |
--------------------------------------------------------------------------------
/templates/styles.html:
--------------------------------------------------------------------------------
1 | {{define "styles"}}
2 |
331 | {{end}}
332 |
--------------------------------------------------------------------------------
/templates/verificationCode.html:
--------------------------------------------------------------------------------
1 | {{template "base" .}} {{define "content"}}
2 |
3 |
4 |
5 |
6 |
7 |
8 | |
9 | Hi {{ .FirstName}},
10 | Please verify your account to be able to login
11 |
18 |
19 |
20 | |
21 |
37 | |
38 |
39 |
40 |
41 | Good luck! Codevo CEO.
42 | |
43 |
44 |
45 | |
46 |
47 |
48 |
49 |
50 | {{end}}
51 |
--------------------------------------------------------------------------------
/utils/email.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "bytes"
5 | "crypto/tls"
6 | "fmt"
7 | "log"
8 | "os"
9 | "path/filepath"
10 | "text/template"
11 |
12 | "github.com/k3a/html2text"
13 | "github.com/wpcodevo/golang-mongodb/config"
14 | "github.com/wpcodevo/golang-mongodb/models"
15 | "gopkg.in/gomail.v2"
16 | )
17 |
18 | type EmailData struct {
19 | URL string
20 | FirstName string
21 | Subject string
22 | }
23 |
24 | // 👇 Email template parser
25 |
26 | func ParseTemplateDir(dir string) (*template.Template, error) {
27 | var paths []string
28 | err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
29 | if err != nil {
30 | return err
31 | }
32 | if !info.IsDir() {
33 | paths = append(paths, path)
34 | }
35 | return nil
36 | })
37 |
38 | fmt.Println("Am parsing templates...")
39 |
40 | if err != nil {
41 | return nil, err
42 | }
43 |
44 | return template.ParseFiles(paths...)
45 | }
46 |
47 | func SendEmail(user *models.DBResponse, data *EmailData, templateName string) error {
48 | config, err := config.LoadConfig(".")
49 |
50 | if err != nil {
51 | log.Fatal("could not load config", err)
52 | }
53 |
54 | // Sender data.
55 | from := config.EmailFrom
56 | smtpPass := config.SMTPPass
57 | smtpUser := config.SMTPUser
58 | to := user.Email
59 | smtpHost := config.SMTPHost
60 | smtpPort := config.SMTPPort
61 |
62 | var body bytes.Buffer
63 |
64 | template, err := ParseTemplateDir("templates")
65 | if err != nil {
66 | log.Fatal("Could not parse template", err)
67 | }
68 |
69 | template = template.Lookup(templateName)
70 | template.Execute(&body, &data)
71 | fmt.Println(template.Name())
72 |
73 | m := gomail.NewMessage()
74 |
75 | m.SetHeader("From", from)
76 | m.SetHeader("To", to)
77 | m.SetHeader("Subject", data.Subject)
78 | m.SetBody("text/html", body.String())
79 | m.AddAlternative("text/plain", html2text.HTML2Text(body.String()))
80 |
81 | d := gomail.NewDialer(smtpHost, smtpPort, smtpUser, smtpPass)
82 | d.TLSConfig = &tls.Config{InsecureSkipVerify: true}
83 |
84 | // Send Email
85 | if err := d.DialAndSend(m); err != nil {
86 | return err
87 | }
88 | return nil
89 | }
90 |
--------------------------------------------------------------------------------
/utils/encode.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import "encoding/base64"
4 |
5 | func Encode(s string) string {
6 | data := base64.StdEncoding.EncodeToString([]byte(s))
7 | return string(data)
8 | }
9 |
10 | func Decode(s string) (string, error) {
11 | data, err := base64.StdEncoding.DecodeString(s)
12 | if err != nil {
13 | return "", err
14 | }
15 |
16 | return string(data), nil
17 | }
18 |
--------------------------------------------------------------------------------
/utils/helper.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import "go.mongodb.org/mongo-driver/bson"
4 |
5 | func ToDoc(v interface{}) (doc *bson.D, err error) {
6 | data, err := bson.Marshal(v)
7 | if err != nil {
8 | return
9 | }
10 |
11 | err = bson.Unmarshal(data, &doc)
12 | return
13 | }
14 |
--------------------------------------------------------------------------------
/utils/password.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "fmt"
5 |
6 | "golang.org/x/crypto/bcrypt"
7 | )
8 |
9 | func HashPassword(password string) (string, error) {
10 | hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
11 |
12 | if err != nil {
13 | return "", fmt.Errorf("could not hash password %w", err)
14 | }
15 | return string(hashedPassword), nil
16 | }
17 |
18 | func VerifyPassword(hashedPassword string, candidatePassword string) error {
19 | return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(candidatePassword))
20 | }
21 |
--------------------------------------------------------------------------------
/utils/token.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "encoding/base64"
5 | "fmt"
6 | "time"
7 |
8 | "github.com/golang-jwt/jwt"
9 | )
10 |
11 | func CreateToken(ttl time.Duration, payload interface{}, privateKey string) (string, error) {
12 | decodedPrivateKey, err := base64.StdEncoding.DecodeString(privateKey)
13 | if err != nil {
14 | return "", fmt.Errorf("could not decode key: %w", err)
15 | }
16 | key, err := jwt.ParseRSAPrivateKeyFromPEM(decodedPrivateKey)
17 |
18 | if err != nil {
19 | return "", fmt.Errorf("create: parse key: %w", err)
20 | }
21 |
22 | now := time.Now().UTC()
23 |
24 | claims := make(jwt.MapClaims)
25 | claims["sub"] = payload
26 | claims["exp"] = now.Add(ttl).Unix()
27 | claims["iat"] = now.Unix()
28 | claims["nbf"] = now.Unix()
29 |
30 | token, err := jwt.NewWithClaims(jwt.SigningMethodRS256, claims).SignedString(key)
31 |
32 | if err != nil {
33 | return "", fmt.Errorf("create: sign token: %w", err)
34 | }
35 |
36 | return token, nil
37 | }
38 |
39 | func ValidateToken(token string, publicKey string) (interface{}, error) {
40 | decodedPublicKey, err := base64.StdEncoding.DecodeString(publicKey)
41 | if err != nil {
42 | return nil, fmt.Errorf("could not decode: %w", err)
43 | }
44 |
45 | key, err := jwt.ParseRSAPublicKeyFromPEM(decodedPublicKey)
46 |
47 | if err != nil {
48 | return "", fmt.Errorf("validate: parse key: %w", err)
49 | }
50 |
51 | parsedToken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
52 | if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
53 | return nil, fmt.Errorf("unexpected method: %s", t.Header["alg"])
54 | }
55 | return key, nil
56 | })
57 |
58 | if err != nil {
59 | return nil, fmt.Errorf("validate: %w", err)
60 | }
61 |
62 | claims, ok := parsedToken.Claims.(jwt.MapClaims)
63 | if !ok || !parsedToken.Valid {
64 | return nil, fmt.Errorf("validate: invalid token")
65 | }
66 |
67 | return claims["sub"], nil
68 | }
69 |
--------------------------------------------------------------------------------