func PostAccessTokensEnabled(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
tokenID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
at := dal.NewAccessToken(db)
accessTokenRow, err := at.GetByID(nil, tokenID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
data := make(map[string]interface{})
data["enabled"] = !accessTokenRow.Enabled
_, err = at.UpdateById(nil, data, tokenID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/clusters", 301)
}
func PostSavedQueries(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUser := session.Values["user"].(*rm_dal.UserRow)
accessTokenRow, err := rm_dal.NewAccessToken(db).GetByUserID(nil, currentUser.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
savedQuery := r.FormValue("SavedQuery")
_, err = rm_dal.NewSavedQuery(db).CreateOrUpdate(nil, accessTokenRow, savedQuery)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/?q="+savedQuery, 301)
}
func PostAccessTokens(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUser := session.Values["user"].(*dal.UserRow)
clusterID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
level := r.FormValue("Level")
_, err = dal.NewAccessToken(db).Create(nil, currentUser.ID, clusterID, level)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/clusters", 301)
}
func PostApiHosts(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
db := context.Get(r, "db").(*sqlx.DB)
accessTokenRow := context.Get(r, "accessTokenRow").(*dal.AccessTokenRow)
dataJson, err := ioutil.ReadAll(r.Body)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
hostRow, err := dal.NewHost(db).CreateOrUpdate(nil, accessTokenRow, dataJson)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
hostRowJson, err := json.Marshal(hostRow)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
w.Write(hostRowJson)
}
// PostLogin performs login.
func PostLogin(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
email := r.FormValue("Email")
password := r.FormValue("Password")
u := rm_dal.NewUser(db)
user, err := u.GetUserByEmailAndPassword(nil, email, password)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
session, _ := cookieStore.Get(r, "resourcedmaster-session")
session.Values["user"] = user
err = session.Save(r, w)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/", 301)
}
func PostApiMetadataKey(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
db := context.Get(r, "db").(*sqlx.DB)
accessTokenRow := context.Get(r, "accessTokenRow").(*dal.AccessTokenRow)
dataJson, err := ioutil.ReadAll(r.Body)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
vars := mux.Vars(r)
key := vars["key"]
metadataRow, err := dal.NewMetadata(db).CreateOrUpdate(nil, accessTokenRow.ClusterID, key, dataJson)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
metadataRowJson, err := json.Marshal(metadataRow)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
w.Write(metadataRowJson)
}
func DeleteSavedQueriesID(w http.ResponseWriter, r *http.Request) {
savedQueryID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUser := session.Values["user"].(*rm_dal.UserRow)
sq := rm_dal.NewSavedQuery(db)
savedQueryRow, err := sq.GetByID(nil, savedQueryID)
if currentUser.ID != savedQueryRow.UserID {
err := errors.New("Modifying other user's saved query is not allowed.")
libhttp.HandleErrorJson(w, err)
return
}
err = sq.DeleteByID(nil, savedQueryID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/", 301)
}
// SetClusters sets clusters data in context based on logged in user ID.
func SetClusters(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
userRowInterface := session.Values["user"]
if userRowInterface == nil {
http.Redirect(w, r, "/login", 301)
return
}
userRow := userRowInterface.(*dal.UserRow)
db := context.Get(r, "db").(*sqlx.DB)
clusterRows, err := dal.NewCluster(db).AllClustersByUserID(nil, userRow.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
context.Set(r, "clusters", clusterRows)
// Set currentCluster if not previously set.
if len(clusterRows) > 0 {
currentClusterInterface := session.Values["currentCluster"]
if currentClusterInterface == nil {
session.Values["currentCluster"] = clusterRows[0]
err := session.Save(r, w)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
}
}
// Set currentClusterJson
currentClusterInterface := session.Values["currentCluster"]
if currentClusterInterface != nil {
currentClusterRow := currentClusterInterface.(*dal.ClusterRow)
currentClusterJson, err := json.Marshal(currentClusterRow)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
context.Set(r, "currentClusterJson", currentClusterJson)
} else {
context.Set(r, "currentClusterJson", []byte("{}"))
}
next.ServeHTTP(w, r)
})
}
func GetMetadata(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUserRow, ok := session.Values["user"].(*dal.UserRow)
if !ok {
http.Redirect(w, r, "/logout", 301)
return
}
currentClusterInterface := session.Values["currentCluster"]
if currentClusterInterface == nil {
http.Redirect(w, r, "/", 301)
return
}
currentCluster := currentClusterInterface.(*dal.ClusterRow)
db := context.Get(r, "db").(*sqlx.DB)
metadataRows, err := dal.NewMetadata(db).AllByClusterID(nil, currentCluster.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
data := struct {
CurrentUser *dal.UserRow
Clusters []*dal.ClusterRow
CurrentClusterJson string
MetadataRows []*dal.MetadataRow
}{
currentUserRow,
context.Get(r, "clusters").([]*dal.ClusterRow),
string(context.Get(r, "currentClusterJson").([]byte)),
metadataRows,
}
tmpl, err := template.ParseFiles("templates/dashboard.html.tmpl", "templates/metadata/list.html.tmpl")
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
tmpl.Execute(w, data)
}
func PostClustersCurrent(w http.ResponseWriter, r *http.Request) {
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
redirectPath := "/"
recentRequestPathInterface := session.Values["recentRequestPath"]
if recentRequestPathInterface != nil {
redirectPath = recentRequestPathInterface.(string)
}
clusterIDString := r.FormValue("ClusterID")
clusterID, err := strconv.ParseInt(clusterIDString, 10, 64)
if err != nil {
http.Redirect(w, r, redirectPath, 301)
return
}
clusterRows := context.Get(r, "clusters").([]*dal.ClusterRow)
for _, clusterRow := range clusterRows {
if clusterRow.ID == clusterID {
session.Values["currentCluster"] = clusterRow
err := session.Save(r, w)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
break
}
}
http.Redirect(w, r, redirectPath, 301)
}
func PostMetadata(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentClusterInterface := session.Values["currentCluster"]
if currentClusterInterface == nil {
http.Redirect(w, r, "/", 301)
return
}
currentCluster := currentClusterInterface.(*dal.ClusterRow)
key := r.FormValue("Key")
data := r.FormValue("Data")
db := context.Get(r, "db").(*sqlx.DB)
_, err := dal.NewMetadata(db).CreateOrUpdate(nil, currentCluster.ID, key, []byte(data))
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/metadata", 301)
}
func PutUsersID(w http.ResponseWriter, r *http.Request) {
userId, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUser := session.Values["user"].(*rm_dal.UserRow)
if currentUser.ID != userId {
err := errors.New("Modifying other user is not allowed.")
libhttp.HandleErrorJson(w, err)
return
}
email := r.FormValue("Email")
password := r.FormValue("Password")
passwordAgain := r.FormValue("PasswordAgain")
u := rm_dal.NewUser(db)
currentUser, err = u.UpdateEmailAndPasswordById(nil, currentUser.ID, email, password, passwordAgain)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
// Update currentUser stored in session.
session.Values["user"] = currentUser
err = session.Save(r, w)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/", 301)
}
func GetLoginWithoutSession(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
tmpl, err := template.ParseFiles("templates/users/login-signup-parent.html.tmpl", "templates/users/login.html.tmpl")
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
tmpl.Execute(w, nil)
}
func GetApiMetadata(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
db := context.Get(r, "db").(*sqlx.DB)
accessTokenRow := context.Get(r, "accessTokenRow").(*dal.AccessTokenRow)
metadataRows, err := dal.NewMetadata(db).AllByClusterID(nil, accessTokenRow.ClusterID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
metadataRowsJson, err := json.Marshal(metadataRows)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
w.Write(metadataRowsJson)
}
func PostAccessTokensLevel(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
tokenID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
level := r.FormValue("Level")
data := make(map[string]interface{})
data["level"] = level
_, err = dal.NewAccessToken(db).UpdateById(nil, data, tokenID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/clusters", 301)
}
func GetApiHosts(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
db := context.Get(r, "db").(*sqlx.DB)
accessTokenRow := context.Get(r, "accessTokenRow").(*dal.AccessTokenRow)
query := r.URL.Query().Get("q")
hosts, err := dal.NewHost(db).AllByClusterIDAndQuery(nil, accessTokenRow.ID, query)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
hostRowsJson, err := json.Marshal(hosts)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
w.Write(hostRowsJson)
}
func DeleteApiMetadataKey(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
db := context.Get(r, "db").(*sqlx.DB)
accessTokenRow := context.Get(r, "accessTokenRow").(*dal.AccessTokenRow)
vars := mux.Vars(r)
key := vars["key"]
metadataRow, err := dal.NewMetadata(db).DeleteByClusterIDAndKey(nil, accessTokenRow.ClusterID, key)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
metadataRowJson, err := json.Marshal(metadataRow)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
w.Write(metadataRowJson)
}
func PostSignup(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
db := context.Get(r, "db").(*sqlx.DB)
email := r.FormValue("Email")
password := r.FormValue("Password")
passwordAgain := r.FormValue("PasswordAgain")
_, err := rm_dal.NewUser(db).Signup(nil, email, password, passwordAgain)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
// Perform login
PostLogin(w, r)
}
func GetHosts(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUserRow, ok := session.Values["user"].(*dal.UserRow)
if !ok {
http.Redirect(w, r, "/logout", 301)
return
}
currentClusterInterface := session.Values["currentCluster"]
if currentClusterInterface == nil {
http.Redirect(w, r, "/", 301)
return
}
currentCluster := currentClusterInterface.(*dal.ClusterRow)
db := context.Get(r, "db").(*sqlx.DB)
query := r.URL.Query().Get("q")
hosts, err := dal.NewHost(db).AllByClusterIDAndQuery(nil, currentCluster.ID, query)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
savedQueries, err := dal.NewSavedQuery(db).AllByClusterID(nil, currentCluster.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
accessTokenRow, err := dal.NewAccessToken(db).GetByUserID(nil, currentUserRow.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
data := struct {
Addr string
CurrentUser *dal.UserRow
AccessToken *dal.AccessTokenRow
Clusters []*dal.ClusterRow
CurrentClusterJson string
Hosts []*dal.HostRow
SavedQueries []*dal.SavedQueryRow
}{
context.Get(r, "addr").(string),
currentUserRow,
accessTokenRow,
context.Get(r, "clusters").([]*dal.ClusterRow),
string(context.Get(r, "currentClusterJson").([]byte)),
hosts,
savedQueries,
}
tmpl, err := template.ParseFiles("templates/dashboard.html.tmpl", "templates/hosts/list.html.tmpl")
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
tmpl.Execute(w, data)
}
func DeleteUsersID(w http.ResponseWriter, r *http.Request) {
err := errors.New("DELETE method is not implemented.")
libhttp.HandleErrorJson(w, err)
return
}
func PutSavedQueriesID(w http.ResponseWriter, r *http.Request) {
err := errors.New("PUT method is not implemented.")
libhttp.HandleErrorJson(w, err)
return
}