Merge branch 'api-proto'

Conflicts:
	server/server.go

diff --git a/frontend/main.js b/frontend/main.js
index 7d6aa1b29d846226432b94a9e7ef4f2f56e0d994..61be7f63c3abf5ed243b18a2311298f576b001cf 100644 (file)
--- a/frontend/main.js
+++ b/frontend/main.js
@@ -39,12 +39,17 @@ armadillo.App = function() {
  * @return {jqXHR} The jQuery XHR object.
  */
 armadillo.App.prototype.sendRequest = function(action, data, callback) {
-  data.action = action;
   return $.ajax({
-      url: 'service',
+      url: 'service/' + action,
       type: 'POST',
       data: data,
-      success: callback
+      success: callback,
+      error: function(xhr, status, error) {
+        app.showError(xhr.responseText);
+        console.log(xhr);
+        console.log(status);
+        console.log(error);
+      }
   });
 };
 

diff --git a/server/server.go b/server/server.go
index da47cc738fcbbc113a4a6c18a6627132a4c6764d..31701135beaf60fb52776f408b4e4768a9308df3 100644 (file)
--- a/server/server.go
+++ b/server/server.go
@@ -35,7 +35,7 @@ func init() {
        kFrontEndFiles = path.Join(path.Dir(path.Dir(thisFile)), "frontend")
 }
 
-func indexHandler(response http.ResponseWriter, request *http.Request) {
+func indexHandler(rw http.ResponseWriter, request *http.Request) {
        fd, err := os.Open(path.Join(kFrontEndFiles, "index.html"))
        if err != nil {
                fmt.Print("Error opening file ", err.Error(), "\n")
@@ -43,73 +43,90 @@ func indexHandler(response http.ResponseWriter, request *http.Request) {
        }
        defer fd.Close()
 
-       response.Header().Set("Content-Type", "text/html")
-       io.Copy(response, fd)
+       rw.Header().Set("Content-Type", "text/html")
+       io.Copy(rw, fd)
 }
 
-func serviceHandler(response http.ResponseWriter, request *http.Request) {
-       if request.Method != "POST" {
-               io.WriteString(response, "Error: Not a POST request")
+func listService(rw http.ResponseWriter, req *http.Request) {
+       if !requestIsPOST(rw, req) {
                return
        }
 
-       switch request.FormValue("action") {
-       case "list":
-               files, err := ListPath(request.FormValue("path"))
-               if err != nil {
-                       errorResponse(response, err.Error())
-               } else {
-                       okResponse(response, files)
-               }
-       case "remove":
-               err := RemovePath(request.FormValue("path"))
-               if err != nil {
-                       errorResponse(response, err.Error())
-               } else {
-                       data := map[string]int{
-                               "error": 0,
-                       }
-                       okResponse(response, data)
+       files, err := ListPath(req.FormValue("path"))
+       if err != nil {
+               httpError(rw, err.Error(), http.StatusNotFound)
+       } else {
+               okResponse(rw, files)
+       }
+}
+
+func removeService(rw http.ResponseWriter, req *http.Request) {
+       if !requestIsPOST(rw, req) {
+               return
+       }
+
+       err := RemovePath(req.FormValue("path"))
+       if err != nil {
+               httpError(rw, err.Error(), http.StatusNotFound)
+       } else {
+               data := map[string]int{
+                       "error": 0,
                }
-       case "move":
-               source := request.FormValue("source")
-               target := request.FormValue("target")
-               err := MovePath(source, target)
-               if err != nil {
-                       errorResponse(response, err.Error())
-               } else {
-                       data := map[string]interface{}{
-                               "path":  target,
-                               "error": 0,
-                       }
-                       okResponse(response, data)
+               okResponse(rw, data)
+       }
+}
+
+func moveService(rw http.ResponseWriter, req *http.Request) {
+       if !requestIsPOST(rw, req) {
+               return
+       }
+
+       source := req.FormValue("source")
+       target := req.FormValue("target")
+       err := MovePath(source, target)
+       if err != nil {
+               httpError(rw, err.Error(), http.StatusNotFound)
+       } else {
+               data := map[string]interface{}{
+                       "path":  target,
+                       "error": 0,
                }
-       case "mkdir":
-               path := request.FormValue("path")
-               err := MakeDir(path)
-               if err != nil {
-                       errorResponse(response, err.Error())
-               } else {
-                       data := map[string]interface{}{
-                               "path":  path,
-                               "error": 0,
-                       }
-                       okResponse(response, data)
+               okResponse(rw, data)
+       }
+}
+
+func mkdirService(rw http.ResponseWriter, req *http.Request) {
+       if !requestIsPOST(rw, req) {
+               return
+       }
+
+       path := req.FormValue("path")
+       err := MakeDir(path)
+       if err != nil {
+               httpError(rw, err.Error(), http.StatusUnauthorized)
+       } else {
+               data := map[string]interface{}{
+                       "path":  path,
+                       "error": 0,
                }
-       case "tv_rename":
-               newPath, err := RenameTVEpisode(request.FormValue("path"))
-               if err != nil {
-                       errorResponse(response, err.Error())
-               } else {
-                       data := map[string]interface{}{
-                               "path":  newPath,
-                               "error": 0,
-                       }
-                       okResponse(response, data)
+               okResponse(rw, data)
+       }
+}
+
+func tvRenameService(rw http.ResponseWriter, req *http.Request) {
+       if !requestIsPOST(rw, req) {
+               return
+       }
+
+       newPath, err := RenameTVEpisode(req.FormValue("path"))
+       if err != nil {
+               httpError(rw, err.Error(), http.StatusBadRequest)
+       } else {
+               data := map[string]interface{}{
+                       "path":  newPath,
+                       "error": 0,
                }
-       default:
-               fmt.Printf("Invalid action: '%s'\n", request.FormValue("action"))
-               errorResponse(response, "Unhandled action")
+               okResponse(rw, data)
        }
 }
 
@@ -127,30 +144,29 @@ func downloadHandler(response http.ResponseWriter, request *http.Request) {
        }
 }
 
-func errorResponse(response http.ResponseWriter, message string) {
+func httpError(rw http.ResponseWriter, message string, code int) {
        message = strings.Replace(message, gConfig.JailRoot, "/", -1)
-       data := map[string]interface{}{
-               "error":   -1,
-               "message": message,
-       }
-       json_data, err := json.Marshal(data)
+       rw.WriteHeader(code)
+       rw.Header().Set("Content-Type", "text/plain")
+       fmt.Fprint(rw, message)
+}
 
-       response.Header().Set("Content-Type", "text/json")
+func okResponse(rw http.ResponseWriter, data interface{}) {
+       rw.Header().Set("Content-Type", "application/json")
+       jsonData, err := json.Marshal(data)
        if err != nil {
-               io.WriteString(response, "{\"error\":\"-9\",\"message\":\"Internal encoding error\"}")
+               httpError(rw, "Internal error: " + err.Error(), 500)
        } else {
-               response.Write(json_data)
+               rw.Write(jsonData)
        }
 }
 
-func okResponse(response http.ResponseWriter, data interface{}) {
-       response.Header().Set("Content-Type", "text/json")
-       json_data, err := json.Marshal(data)
-       if err != nil {
-               errorResponse(response, "Internal encoding error")
-       } else {
-               response.Write(json_data)
+func requestIsPOST(rw http.ResponseWriter, req *http.Request) bool {
+       if req.Method != "POST" {
+               httpError(rw, "Service requests must be sent via POST", http.StatusMethodNotAllowed)
+               return false
        }
+       return true
 }
 
 func RunBackEnd(c *config.Configuration) {
@@ -159,7 +175,11 @@ func RunBackEnd(c *config.Configuration) {
        mux := http.NewServeMux()
        mux.HandleFunc("/", indexHandler)
        mux.Handle("/fe/", http.StripPrefix("/fe/", http.FileServer(http.Dir(kFrontEndFiles))))
-       mux.HandleFunc("/service", serviceHandler)
+       mux.HandleFunc("/service/list", listService)
+       mux.HandleFunc("/service/move", moveService)
+       mux.HandleFunc("/service/remove", removeService)
+       mux.HandleFunc("/service/mkdir", mkdirService)
+       mux.HandleFunc("/service/tv_rename", tvRenameService)
        mux.HandleFunc("/download", downloadHandler)
 
        error := http.ListenAndServe(fmt.Sprintf(":%d", gConfig.Port), mux)