feat: init project

common/error.go

@@ -0,0 +1,72 @@
+package common
+
+import (
+	"errors"
+)
+
+// Code is the error code.
+type Code int
+
+// Application error codes.
+const (
+	// 0 ~ 99 general error.
+	Ok             Code = 0
+	Internal       Code = 1
+	NotAuthorized  Code = 2
+	Invalid        Code = 3
+	NotFound       Code = 4
+	Conflict       Code = 5
+	NotImplemented Code = 6
+)
+
+// Error represents an application-specific error. Application errors can be
+// unwrapped by the caller to extract out the code & message.
+//
+// Any non-application error (such as a disk error) should be reported as an
+// Internal error and the human user should only see "Internal error" as the
+// message. These low-level internal error details should only be logged and
+// reported to the operator of the application (not the end user).
+type Error struct {
+	// Machine-readable error code.
+	Code Code
+
+	// Embedded error.
+	Err error
+}
+
+// Error implements the error interface. Not used by the application otherwise.
+func (e *Error) Error() string {
+	return e.Err.Error()
+}
+
+// ErrorCode unwraps an application error and returns its code.
+// Non-application errors always return EINTERNAL.
+func ErrorCode(err error) Code {
+	var e *Error
+	if err == nil {
+		return Ok
+	} else if errors.As(err, &e) {
+		return e.Code
+	}
+	return Internal
+}
+
+// ErrorMessage unwraps an application error and returns its message.
+// Non-application errors always return "Internal error".
+func ErrorMessage(err error) string {
+	var e *Error
+	if err == nil {
+		return ""
+	} else if errors.As(err, &e) {
+		return e.Err.Error()
+	}
+	return "Internal error."
+}
+
+// Errorf is a helper function to return an Error with a given code and error.
+func Errorf(code Code, err error) *Error {
+	return &Error{
+		Code: code,
+		Err:  err,
+	}
+}

common/util.go

@@ -0,0 +1,30 @@
+package common
+
+import (
+	"net/mail"
+	"strings"
+
+	"github.com/google/uuid"
+)
+
+// HasPrefixes returns true if the string s has any of the given prefixes.
+func HasPrefixes(src string, prefixes ...string) bool {
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(src, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+// ValidateEmail validates the email.
+func ValidateEmail(email string) bool {
+	if _, err := mail.ParseAddress(email); err != nil {
+		return false
+	}
+	return true
+}
+
+func GenUUID() string {
+	return uuid.New().String()
+}

common/util_test.go

@@ -0,0 +1,31 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestValidateEmail(t *testing.T) {
+	tests := []struct {
+		email string
+		want  bool
+	}{
+		{
+			email: "t@gmail.com",
+			want:  true,
+		},
+		{
+			email: "@qq.com",
+			want:  false,
+		},
+		{
+			email: "1@gmail",
+			want:  true,
+		},
+	}
+	for _, test := range tests {
+		result := ValidateEmail(test.email)
+		if result != test.want {
+			t.Errorf("Validate Email %s: got result %v, want %v.", test.email, result, test.want)
+		}
+	}
+}