Aggiunte tante cose relative al profilo utente

2022-06-13 02:36:31 +02:00
parent 39ad130e81
commit 1d61efeda0
11 changed files with 298 additions and 145 deletions
@@ -4,32 +4,44 @@ import "fmt"

 var ErrInvalidSession = fmt.Errorf(`invalid session token`)

-type User interface {
-	GetUsername() string
-	GetName() string
-	GetSurname() string
-	GetFullName() string
+type User struct {
+	Username string `json:"username"`
+	Name     string `json:"name"`
+	Surname  string `json:"surname"`
+	FullName string `json:"fullName"`
+	Email    string `json:"email"`
 }

-type Session interface {
-	GetUsername() string
-	GetToken() string
+func (u User) WithDefaultFullName() User {
+	return User{
+		Username: u.Username,
+		Name:     u.Name,
+		Surname:  u.Surname,
+		Email:    u.Email,
+
+		FullName: u.Username + " " + u.Surname,
+	}
+}
+
+type Session struct {
+	Username string `json:"username"`
+	Token    string `json:"token"`
 }

 type AuthenticatorService interface {
-	GetUser(username string) (User, error)
-	GetUsers() ([]User, error)
-	GetSession(token string) (Session, error)
-	Login(username, password string) (Session, error)
+	GetUser(username string) (*User, error)
+	GetUsers() ([]*User, error)
+	GetSession(token string) (*Session, error)
+	Login(username, password string) (*Session, error)
 }

-func UserForSession(as AuthenticatorService, token string) (User, error) {
+func UserForSession(as AuthenticatorService, token string) (*User, error) {
 	session, err := as.GetSession(token)
 	if err != nil {
 		return nil, err
 	}

-	user, err := as.GetUser(session.GetUsername())
+	user, err := as.GetUser(session.Username)
 	if err != nil {
 		return nil, err
 	}
@@ -7,47 +7,24 @@ import (
 	"log"
 	"net/http"
 	"path"
-	"time"
 )

-type LDAPUser struct {
-	Username  string `json:"username"`
+type ldapUser struct {
+	User
 	NumericId int    `json:"id"`
-	Name      string `json:"name"`
-	Surname   string `json:"surname"`
-	Email     string `json:"email"`
 	Role      string `json:"role"`
 	Gecos     string `json:"gecos"`
 }

-func (u LDAPUser) GetUsername() string {
-	return u.Username
-}
+func (u ldapUser) AsUser() *User {
+	return &User{
+		Username: u.Username,
+		Name:     u.Name,
+		Surname:  u.Surname,
+		Email:    u.Email,

-func (u LDAPUser) GetName() string {
-	return u.Name
-}
-
-func (u LDAPUser) GetSurname() string {
-	return u.Surname
-}
-
-func (u LDAPUser) GetFullName() string {
-	return u.Gecos
-}
-
-type SimpleSession struct {
-	Token     string    `json:"token"`
-	Username  string    `json:"username"`
-	CreatedOn time.Time `json:"createdOn"`
-}
-
-func (s SimpleSession) GetUsername() string {
-	return s.Username
-}
-
-func (s SimpleSession) GetToken() string {
-	return s.Token
+		FullName: u.Gecos,
+	}
 }

 type LDAPAuthService struct {
@@ -99,31 +76,31 @@ func (a *LDAPAuthService) doPostRequest(url string, request interface{}, respons
 	return json.NewDecoder(res.Body).Decode(response)
 }

-func (a *LDAPAuthService) GetUser(username string) (User, error) {
-	var user LDAPUser
+func (a *LDAPAuthService) GetUser(username string) (*User, error) {
+	var user ldapUser
 	if err := a.doGetRequest(fmt.Sprintf("/user/%s", username), &user); err != nil {
 		return nil, err
 	}

-	return &user, nil
+	return user.AsUser(), nil
 }

-func (a *LDAPAuthService) GetUsers() ([]User, error) {
-	ldapUsers := []*LDAPUser{}
+func (a *LDAPAuthService) GetUsers() ([]*User, error) {
+	ldapUsers := []*ldapUser{}
 	if err := a.doGetRequest(fmt.Sprintf("/users"), &ldapUsers); err != nil {
 		return nil, err
 	}

-	users := make([]User, len(ldapUsers))
+	users := make([]*User, len(ldapUsers))
 	for i, u := range ldapUsers {
-		users[i] = u
+		users[i] = u.AsUser()
 	}

 	return users, nil
 }

-func (a *LDAPAuthService) GetSession(token string) (Session, error) {
-	var response SimpleSession
+func (a *LDAPAuthService) GetSession(token string) (*Session, error) {
+	var response Session
 	if err := a.doGetRequest(fmt.Sprintf("/session/%s", token), &response); err != nil {
 		return nil, err
 	}
@@ -131,14 +108,14 @@ func (a *LDAPAuthService) GetSession(token string) (Session, error) {
 	return &response, nil
 }

-func (a *LDAPAuthService) Login(username, password string) (Session, error) {
-	body := map[string]interface{}{
+func (a *LDAPAuthService) Login(username, password string) (*Session, error) {
+	reqBody := map[string]interface{}{
 		"username": username,
 		"password": password,
 	}

-	var response SimpleSession
-	if err := a.doPostRequest(fmt.Sprintf("/login"), body, &response); err != nil {
+	var response Session
+	if err := a.doPostRequest(fmt.Sprintf("/login"), reqBody, &response); err != nil {
 		return nil, err
 	}

@@ -7,108 +7,102 @@ import (
 )

 var exampleMemoryUsers = &Memory{
-	Users: map[string]*MemoryUser{
+	Users: map[string]*memoryUser{
 		"aziis98": {
-			Username: "aziis98",
-			Name:     "Antonio",
-			Surname:  "De Lucreziis",
+			User: User{
+				Username: "aziis98",
+				Name:     "Antonio",
+				Surname:  "De Lucreziis",
+				Email:    "aziis98@example.org",
+			}.WithDefaultFullName(),
 			Password: "123",
 		},
 		"bachoseven": {
-			Username: "bachoseven",
-			Name:     "Francesco",
-			Surname:  "Minnocci",
+			User: User{
+				Username: "bachoseven",
+				Name:     "Francesco",
+				Surname:  "Minnocci",
+				Email:    "bachoseven@example.org",
+			}.WithDefaultFullName(),
 			Password: "234",
 		},
 	},
-	Sessions: map[string]*MemorySession{},
+	Sessions: map[string]*memorySession{},
 }

-type MemoryUser struct {
-	Username string `json:"username"`
-	Name     string `json:"name"`
-	Surname  string `json:"surname"`
-
+type memoryUser struct {
+	User
 	Password string `json:"-"`
 }

-func (u *MemoryUser) GetUsername() string {
-	return u.Username
+func (u memoryUser) AsUser() *User {
+	return &User{
+		Username: u.Username,
+		Name:     u.Name,
+		Surname:  u.Surname,
+		FullName: u.FullName,
+		Email:    u.Email,
+	}
 }

-func (u *MemoryUser) GetName() string {
-	return u.Name
-}
-
-func (u *MemoryUser) GetSurname() string {
-	return u.Surname
-}
-
-func (u *MemoryUser) GetFullName() string {
-	return u.Name + " " + u.Surname
-}
-
-type MemorySession struct {
+type memorySession struct {
 	Username string
 	Token    string
 }

-func (s *MemorySession) GetUsername() string {
-	return s.Username
-}
-
-func (s *MemorySession) GetToken() string {
-	return s.Token
+func (s memorySession) AsSession() *Session {
+	return &Session{
+		Username: s.Username,
+		Token:    s.Token,
+	}
 }

 type Memory struct {
-	Users    map[string]*MemoryUser
-	Sessions map[string]*MemorySession
+	Users    map[string]*memoryUser
+	Sessions map[string]*memorySession
 }

-func (m *Memory) GetUser(username string) (User, error) {
+func (m *Memory) GetUser(username string) (*User, error) {
 	user, ok := m.Users[username]
 	if !ok {
 		return nil, fmt.Errorf(`no user with that username`)
 	}

-	return user, nil
+	return user.AsUser(), nil
 }

-func (m *Memory) GetUsers() ([]User, error) {
-	users := make([]User, len(m.Users))
+func (m *Memory) GetUsers() ([]*User, error) {
+	users := make([]*User, len(m.Users))
 	i := 0
 	for _, u := range m.Users {
-		users[i] = u
+		users[i] = u.AsUser()
 		i++
 	}

 	return users, nil
 }

-func (m *Memory) GetSession(token string) (Session, error) {
+func (m *Memory) GetSession(token string) (*Session, error) {
 	session, ok := m.Sessions[token]
 	if !ok {
 		return nil, ErrInvalidSession
 	}

-	return session, nil
+	return session.AsSession(), nil
 }

-func (m *Memory) Login(username string, password string) (Session, error) {
-	user, err := m.GetUser(username)
-	if err != nil {
-		return nil, err
+func (m *Memory) Login(username string, password string) (*Session, error) {
+	user, ok := m.Users[username]
+	if !ok {
+		return nil, fmt.Errorf(`no user with that username`)
 	}

-	memUser := user.(*MemoryUser)
-
-	if memUser.Password != password {
+	if user.Password != password {
 		return nil, fmt.Errorf(`invalid credentials`)
 	}

-	session := &MemorySession{username, util.GenerateRandomString(15)}
+	session := &memorySession{username, util.GenerateRandomString(15)}
 	m.Sessions[session.Token] = session

-	return session, nil
+	return session.AsSession(), nil
 }