+
+
+
+
+
+
diff --git a/readme.md b/readme.md
index 44ba47e..ee23d8f 100644
--- a/readme.md
+++ b/readme.md
@@ -14,6 +14,13 @@
- Lazy load with pagination (frontend and backend)
- Add live voice chat? (This will be fun, maybe a separate app)
### Mid Priority
-- Add actual logging instead of ip based usernames, have messages tied to the logged in user not an ip (db changes)
+- NEW LOGIN STUFF
+ - IN PROGRESS: Add actual logging instead of ip based usernames, have messages tied to the logged in user not an ip (db changes)
+ * Fix editing messages
+ * Fix deleting messages
+ * Fix changing username
+ * Fix CSS for signin page
+ * Add logout button to settings, should touch go, js all that, logout request
+ * Fix CSS for login page
### Low Priority
- Nothing yet
diff --git a/srv/handle.go b/srv/handle.go
index 94daa9e..b912589 100644
--- a/srv/handle.go
+++ b/srv/handle.go
@@ -4,9 +4,21 @@ import (
tu "chat/tu"
"encoding/json"
"fmt"
+ "math/rand"
"net/http"
)
+func generateName() string {
+ adjectives := []string{"Unrelenting", "Mystical", "Radiant", "Curious", "Peaceful", "Ancient", "Wandering", "Silent", "Celestial", "Dancing", "Eternal", "Resolute", "Whispering", "Serene", "Wild"}
+ colors := []string{"Purple", "Azure", "Crimson", "Golden", "Emerald", "Sapphire", "Obsidian", "Silver", "Amber", "Jade", "Indigo", "Violet", "Cerulean", "Copper", "Pearl"}
+ nouns := []string{"Elephant", "Phoenix", "Dragon", "Warrior", "Spirit", "Tiger", "Raven", "Mountain", "River", "Storm", "Falcon", "Wolf", "Ocean", "Star", "Moon"}
+
+ return fmt.Sprintf("%s-%s-%s",
+ adjectives[rand.Intn(len(adjectives))],
+ colors[rand.Intn(len(colors))],
+ nouns[rand.Intn(len(nouns))])
+}
+
func (s *Server) handlePing(w http.ResponseWriter, r *http.Request) {
clientIP := getClientIP(r)
s.updateActivity(clientIP)
@@ -33,35 +45,32 @@ func (s *Server) handleUsername(w http.ResponseWriter, r *http.Request) {
return
}
- s.mu.Lock()
-
if len(req.Username) > s.Config.Options.NameMaxLength {
http.Error(w, fmt.Sprintf(`{"error": "Username too long (%v out of %v characters maximum)"}`, len(req.Username), s.Config.Options.NameMaxLength), http.StatusRequestEntityTooLarge)
- s.mu.Unlock()
return
}
if !validUsername(req.Username) {
http.Error(w, fmt.Sprintf(`{"error": "Username must only contain alphanumeric characters and/or underscores"}`), http.StatusBadRequest)
- s.mu.Unlock()
return
}
if s.Database.UserNameExists(req.Username) {
http.Error(w, fmt.Sprintf(`{"error": "Username already exists"}`), http.StatusConflict)
- s.mu.Unlock()
return
}
- if s.Database.UserExists(clientIP) {
- s.Database.UserNameChange(clientIP, req.Username)
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ if username, ok := s.LoggedIn[clientIP]; ok {
+ s.LogUserOut(username)
+ s.Database.UserNameChange(username, req.Username)
+ s.LogUserIn(clientIP, req.Username)
+ json.NewEncoder(w).Encode(map[string]string{"status": "Username changed"})
} else {
- s.Database.UserAdd(clientIP, req.Username)
+ http.Error(w, `{"error": "Failure to change username"}`, http.StatusUnauthorized)
}
- s.mu.Unlock()
-
- json.NewEncoder(w).Encode(map[string]string{"status": "Username registered"})
}
func (s *Server) handleMessages(w http.ResponseWriter, r *http.Request) {
@@ -97,7 +106,11 @@ func (s *Server) handleMessages(w http.ResponseWriter, r *http.Request) {
messages := s.Database.MessagesGet()
for _, msg := range messages {
clientIP := getClientIP(r)
- timeZone := s.Database.UserGetTimezone(clientIP)
+ username, ok := s.LoggedIn[clientIP]
+ timeZone := "UTC"
+ if ok {
+ timeZone = s.Database.UserGetTimezone(username)
+ }
timeLocal := tu.TimeStringToTimeInLocation(msg.Timestamp, timeZone)
edited := ""
if msg.Edited {
@@ -111,22 +124,9 @@ func (s *Server) handleMessages(w http.ResponseWriter, r *http.Request) {
case http.MethodPut:
w.Header().Set("Content-Type", "application/json")
- // Get client's IP
- clientIP := getClientIP(r)
-
- s.mu.Lock()
- exists := s.Database.UserExists(clientIP)
- username := s.Database.UserNameGet(clientIP)
- s.mu.Unlock()
-
- if !exists {
- errorFmt := fmt.Sprintf(`{"error": "IP %s not registered with username"}`, clientIP)
- http.Error(w, errorFmt, http.StatusUnauthorized)
- return
- }
-
var msg struct {
- Message string `json:"message"`
+ Username string `json:"username"`
+ Message string `json:"message"`
}
if err := json.NewDecoder(r.Body).Decode(&msg); err != nil {
@@ -134,12 +134,19 @@ func (s *Server) handleMessages(w http.ResponseWriter, r *http.Request) {
return
}
- s.Database.MessageAdd(clientIP, msg.Message)
+ clientIP := getClientIP(r)
+ if username, ok := s.LoggedIn[clientIP]; ok {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ s.Database.MessageAdd(username, msg.Message)
+ json.NewEncoder(w).Encode(map[string]string{
+ "status": "Message received",
+ "from": username,
+ })
+ } else {
+ http.Error(w, `{"error": "Unauthorized"}`, http.StatusUnauthorized)
+ }
- json.NewEncoder(w).Encode(map[string]string{
- "status": "Message received",
- "from": username,
- })
case http.MethodDelete:
w.Header().Set("Content-Type", "application/json")
@@ -171,21 +178,16 @@ func (s *Server) handleMessages(w http.ResponseWriter, r *http.Request) {
}
func (s *Server) handleUsernameStatus(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodGet {
- http.Error(w, `{"error": "Method not allowed"}`, http.StatusMethodNotAllowed)
- return
- }
+ // if r.Method != http.MethodGet {
+ // http.Error(w, `{"error": "Method not allowed"}`, http.StatusMethodNotAllowed)
+ // return
+ // }
+ clientIP := getClientIP(r)
+ username, ok := s.LoggedIn[clientIP]
w.Header().Set("Content-Type", "application/json")
- clientIP := getClientIP(r)
-
- s.mu.Lock()
- exists := s.Database.UserExists(clientIP)
- username := s.Database.UserNameGet(clientIP)
- s.mu.Unlock()
-
json.NewEncoder(w).Encode(map[string]interface{}{
- "hasUsername": exists,
+ "hasUsername": ok,
"username": username,
})
}
@@ -202,12 +204,14 @@ func (s *Server) handleUsers(w http.ResponseWriter, r *http.Request) {
s.updateActivity(clientIP)
s.cleanupActivity()
s.mu.Lock()
+ defer s.mu.Unlock()
var users []string
for ip := range s.Connected {
// for all connected, get their usernames
- users = append(users, s.Database.UserNameGet(ip))
+ if username, ok := s.LoggedIn[ip]; ok {
+ users = append(users, username)
+ }
}
- s.mu.Unlock()
json.NewEncoder(w).Encode(map[string]interface{}{
"users": users,
@@ -233,18 +237,15 @@ func (s *Server) handleTimezone(w http.ResponseWriter, r *http.Request) {
}
s.mu.Lock()
-
- if !s.Database.UserExists(clientIP) {
+ defer s.mu.Unlock()
+ if username, ok := s.LoggedIn[clientIP]; ok {
+ s.Database.UserTimezoneSet(username, req.Timezone)
+ json.NewEncoder(w).Encode(map[string]string{
+ "status": "success",
+ })
+ } else {
http.Error(w, `{"error": "User not registered"}`, http.StatusUnauthorized)
- s.mu.Unlock()
- return
}
-
- s.Database.UserTimezoneSet(clientIP, req.Timezone)
- s.mu.Unlock()
- json.NewEncoder(w).Encode(map[string]string{
- "status": "success",
- })
}
func (s *Server) handleRoot(w http.ResponseWriter, r *http.Request) {
@@ -283,3 +284,90 @@ func (s *Server) handleMessagesLength(w http.ResponseWriter, r *http.Request) {
"length": len(messages),
})
}
+
+func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
+ switch r.Method {
+ case http.MethodGet:
+ w.Header().Set("Content-Type", "text/html")
+ file := readFile(s.Config.Paths.LoginHtmlPath)
+ w.Write(file)
+ return
+ case http.MethodPost:
+ w.Header().Set("Content-Type", "application/json")
+ var req struct {
+ Username string `json:"username"`
+ Password string `json:"password"`
+ }
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, `{"error": "Invalid JSON"}`, http.StatusBadRequest)
+ return
+ }
+
+ validLogin := s.Database.UserPasswordCheck(req.Username, req.Password)
+ if !validLogin {
+ http.Error(w, `{"error": "Invalid username or password"}`, http.StatusUnauthorized)
+ return
+ } else {
+ clientIP := getClientIP(r)
+ s.LogUserIn(clientIP, req.Username)
+ json.NewEncoder(w).Encode(map[string]string{
+ "status": "Logged in",
+ })
+ }
+ }
+}
+
+func (s *Server) handleSignup(w http.ResponseWriter, r *http.Request) {
+ switch r.Method {
+ case http.MethodGet:
+ w.Header().Set("Content-Type", "text/html")
+ file := readFile(s.Config.Paths.SignupHtmlPath)
+ w.Write(file)
+ return
+ case http.MethodPost:
+ w.Header().Set("Content-Type", "application/json")
+ var req struct {
+ Username string `json:"username"`
+ Password string `json:"password"`
+ }
+
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, `{"error": "Invalid JSON"}`, http.StatusBadRequest)
+ return
+ }
+
+ // validate username length
+ if len(req.Username) > s.Config.Options.NameMaxLength {
+ http.Error(w, fmt.Sprintf(`{"error": "Username too long (%v out of %v characters maximum)"}`, len(req.Username), s.Config.Options.NameMaxLength), http.StatusRequestEntityTooLarge)
+ return
+ }
+
+ // validate username
+ if !validUsername(req.Username) {
+ http.Error(w, fmt.Sprintf(`{"error": "Username must only contain alphanumeric characters and/or underscores"}`), http.StatusBadRequest)
+ return
+ }
+
+ // validate user doesnt already exist
+ if s.Database.UserNameExists(req.Username) {
+ http.Error(w, fmt.Sprintf(`{"error": "Username already exists"}`), http.StatusConflict)
+ return
+ }
+
+ // add user to database with hashedpassword
+ err := s.Database.UserAddWithPassword(req.Username, req.Password)
+ if err != nil {
+ fmt.Println("Database error while signing up a new user")
+ http.Error(w, fmt.Sprintf(`{"error": "%v"}`, err), http.StatusInternalServerError)
+ return
+ }
+
+ // log user in
+ clientIP := getClientIP(r)
+ s.LogUserIn(clientIP, req.Username)
+
+ json.NewEncoder(w).Encode(map[string]string{
+ "status": "User created",
+ })
+ }
+}
diff --git a/srv/srv.go b/srv/srv.go
index 6226f98..437fd51 100644
--- a/srv/srv.go
+++ b/srv/srv.go
@@ -21,15 +21,17 @@ type Config struct {
Port int `json:"port"`
} `json:"server"`
Paths struct {
- DatabasePath string `json:"databasePath"`
- IndexJsPath string `json:"indexJsPath"`
- IndexCssPath string `json:"indexCssPath"`
- IndexHtmlPath string `json:"indexHtmlPath"`
- MessagesHtmlPath string `json:"messagesHtmlPath"`
+ DatabasePath string `json:"databasePath"`
+ IndexJsPath string `json:"indexJsPath"`
+ IndexCssPath string `json:"indexCssPath"`
+ IndexHtmlPath string `json:"indexHtmlPath"`
+ SignupHtmlPath string `json:"signupHtmlPath"`
+ LoginHtmlPath string `json:"loginHtmlPath"`
} `json:"paths"`
Options struct {
- MessageMaxAge int `json:"messageMaxAge"`
- NameMaxLength int `json:"nameMaxLength"`
+ MessageMaxAge int `json:"messageMaxAge"`
+ NameMaxLength int `json:"nameMaxLength"`
+ MessagePerPage int `json:"messagePerPage"`
} `json:"options"`
}
@@ -40,7 +42,8 @@ func LoadConfig(filepath string) Config {
config.Paths.IndexHtmlPath = pathMaker(config.Paths.IndexHtmlPath)
config.Paths.IndexJsPath = pathMaker(config.Paths.IndexJsPath)
config.Paths.IndexCssPath = pathMaker(config.Paths.IndexCssPath)
- config.Paths.MessagesHtmlPath = pathMaker(config.Paths.MessagesHtmlPath)
+ config.Paths.SignupHtmlPath = pathMaker(config.Paths.SignupHtmlPath)
+ config.Paths.LoginHtmlPath = pathMaker(config.Paths.LoginHtmlPath)
config.Paths.DatabasePath = pathMaker(config.Paths.DatabasePath)
if err != nil {
fmt.Println("Error parsing config file: ", err)
@@ -118,6 +121,7 @@ func validUsername(username string) bool {
}
type Server struct {
+ LoggedIn map[string]string // Map Username -> IP
Connected map[string]time.Time // Map IP -> Last activity time
Database *db.Database
Config Config
@@ -127,6 +131,7 @@ type Server struct {
func NewServer(config Config) *Server {
return &Server{
+ LoggedIn: make(map[string]string),
Connected: make(map[string]time.Time),
Database: db.OpenDatabase(config.Paths.DatabasePath),
Config: config,
@@ -138,6 +143,23 @@ func (s *Server) AddMessage(userip string, contents string) {
s.Database.MessageAdd(userip, contents)
}
+func (s *Server) LogUserIn(ip, username string) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ s.LoggedIn[ip] = username
+}
+
+func (s *Server) LogUserOut(username string) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ for ip, u := range s.LoggedIn {
+ if u == username {
+ delete(s.LoggedIn, ip)
+ }
+ }
+ delete(s.LoggedIn, username)
+}
+
func (s *Server) updateActivity(ip string) {
s.mu.Lock()
defer s.mu.Unlock()
@@ -150,6 +172,7 @@ func (s *Server) cleanupActivity() {
for ip, lastActivity := range s.Connected {
if time.Since(lastActivity) > 10*time.Second {
delete(s.Connected, ip)
+ s.LogUserOut(s.LoggedIn[ip])
}
}
}
@@ -169,6 +192,8 @@ func (s *Server) Run() {
handler.HandleFunc("/users", s.handleUsers)
handler.HandleFunc("/username", s.handleUsername)
handler.HandleFunc("/messages", s.handleMessages)
+ handler.HandleFunc("/signup", s.handleSignup)
+ handler.HandleFunc("/login", s.handleLogin)
fmt.Printf("Server starting on %s:%d\n", s.Config.Server.IpAddress, s.Config.Server.Port)
defer s.Stop()
if err := http.ListenAndServe(fmt.Sprintf("%s:%d", s.Config.Server.IpAddress, s.Config.Server.Port), GzipMiddleware(handler)); err != nil {