109 lines
3.0 KiB
Go
109 lines
3.0 KiB
Go
package auth
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"astraltech.xyz/calendar/v2/caldav"
|
|
"astraltech.xyz/calendar/v2/webserver"
|
|
ics "github.com/arran4/golang-ical"
|
|
"golang.org/x/oauth2"
|
|
)
|
|
|
|
var TestTokenStore TokenStore
|
|
|
|
func SetAuth() {
|
|
TestTokenStore = TokenStore{filePath: "token.json"}
|
|
}
|
|
|
|
func generateState() (string, error) {
|
|
b := make([]byte, 32)
|
|
if _, err := rand.Read(b); err != nil {
|
|
return "", err
|
|
}
|
|
return base64.RawURLEncoding.EncodeToString(b), nil
|
|
}
|
|
|
|
func HandlePasswordAuth(authData webserver.PasswordAuthData) bool {
|
|
calDavData := caldav.GetCalDAVData(authData.Username, authData.Password)
|
|
|
|
fmt.Printf("Users display name: %s\n", calDavData.DisplayName)
|
|
fmt.Printf("Calandar Count: %d\n", len(calDavData.Calandars))
|
|
for i := range len(calDavData.Calandars) {
|
|
calDavData.Calandars[i] = caldav.GetCalendarData(calDavData.Calandars[i], authData.Username, authData.Password)
|
|
|
|
fmt.Printf("Cal %d is named %s\n", i, calDavData.Calandars[i].DisplayName)
|
|
fmt.Printf("\tLink to cal: %s\n", calDavData.Calandars[i].Link)
|
|
fmt.Printf("\tEvent count: %d\n", len(calDavData.Calandars[i].Events))
|
|
for j := range len(calDavData.Calandars[i].Events) {
|
|
cal, err := ics.ParseCalendar(strings.NewReader(calDavData.Calandars[i].Events[j].CalData))
|
|
if err != nil {
|
|
fmt.Print(err.Error())
|
|
}
|
|
events := cal.Events()
|
|
for k := range len(events) {
|
|
name := events[k].GetProperty(ics.ComponentProperty(ics.PropertySummary)).Value
|
|
start, _ := events[k].GetStartAt()
|
|
end, _ := events[k].GetEndAt()
|
|
time := end.Sub(start)
|
|
fmt.Printf("\t\tEvent name: %s\n", name)
|
|
fmt.Printf("\t\t\tEvent start date: %s\n", end.UTC().String())
|
|
fmt.Printf("\t\t\tEvent length date: %s\n", time.String())
|
|
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func HandleOAuth(authData webserver.OAuthAuthData) bool {
|
|
state, err := generateState()
|
|
if err != nil {
|
|
http.Error(*authData.ResponseWriter, "Failed to generate state", http.StatusInternalServerError)
|
|
return false
|
|
}
|
|
verifier := oauth2.GenerateVerifier()
|
|
|
|
http.SetCookie(*authData.ResponseWriter, &http.Cookie{
|
|
Name: "oauth_state",
|
|
Value: state,
|
|
Path: "/",
|
|
MaxAge: 300,
|
|
HttpOnly: true,
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
|
|
http.SetCookie(*authData.ResponseWriter, &http.Cookie{
|
|
Name: "pkce_verifier",
|
|
Value: verifier,
|
|
Path: "/",
|
|
HttpOnly: true,
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
|
|
url := DefaultProvider.Config.AuthCodeURL(
|
|
state,
|
|
oauth2.S256ChallengeOption(verifier),
|
|
)
|
|
http.Redirect(*authData.ResponseWriter, authData.Request, url, http.StatusFound)
|
|
|
|
return false
|
|
}
|
|
|
|
func HandleAuthRequest(authType webserver.AuthStyle, authData webserver.AuthData) bool {
|
|
if authType == webserver.AuthStylePassword {
|
|
passwordAuthData, _ := authData.(webserver.PasswordAuthData)
|
|
return HandlePasswordAuth(passwordAuthData)
|
|
}
|
|
|
|
if authType == webserver.AuthStyleOAuth {
|
|
passwordAuthData, _ := authData.(webserver.OAuthAuthData)
|
|
return HandleOAuth(passwordAuthData)
|
|
}
|
|
|
|
return false
|
|
}
|