func api(ctx *web.Context, username string) string { user, err := getUser(username) ctx.SetHeader("Content-Type", "application/prs.kevinburke.snapchat-v1+json", true) if err != nil { checkError(err) ctx.NotFound("User not found") return "" } friends, err := getFriendsById(user.Id) checkError(err) var links Links var users []User users = append(users, *user) for i := 0; i < len(friends.Friends); i++ { friend := friends.Friends[i] link := Link{friend.UserId, friend.FriendId, friend.Index} links.Links = append(links.Links, link) user, err := getUserById(friend.UserId) checkError(err) users = append(users, *user) } response := Response{links.Links, users} bytes, err := json.Marshal(response) checkError(err) return string(bytes) }
func (h *RestQueueHandler) Get(ctx *web.Context, val string) { queue := redisq.NewRedisQueue(h.redis, val) if !queue.Exists() { writeError(ctx, 404, QueueNotFound) return } if queue.Empty() { writeError(ctx, 400, EmptyQueue) return } mesg, err := queue.GetNoWait() if err != nil { writeError(ctx, 500, GetError) if Settings.Debug { debug := fmt.Sprintf("Debug: %s", err) ctx.WriteString(debug) } h.logger.Printf("Dequeue from <%s> Error:%s", val, err) return } resp, _ := json.Marshal(mesg) //mesg.(type) is iteface{} //resp.(type) is []byte ctx.SetHeader("Content-Type", "application/json; charset=UTF-8", true) ctx.WriteString(string(resp)) }
func vnstat(ctx *web.Context, iface string, debug string) string { app := "vnstat" arg0 := "-i" arg2 := "--xml" ctx.SetHeader("Content-Type", "application/json", true) rawxml := runcmd(app, arg0, iface, arg2) var q Vnstat xml.Unmarshal([]byte(rawxml), &q) var jsondata []byte var err error if debug == "debug" { jsondata, err = json.MarshalIndent(q, "", " ") } else { jsondata, err = json.Marshal(q) } if err != nil { return "Error" } return string(jsondata) }
func search(ctx *web.Context, collection string) { ctx.ContentType("json") ctx.SetHeader("Access-Control-Allow-Origin", "*", true) query := ctx.Params["query"] var limit, offset int64 var err error if limit, err = strconv.ParseInt(ctx.Params["limit"], 10, 32); err != nil { limit = 10 } if offset, err = strconv.ParseInt(ctx.Params["offset"], 10, 32); err != nil { offset = 0 } results, err := c.Search(collection, query, int(limit), int(offset)) buf := new(bytes.Buffer) encoder := json.NewEncoder(buf) if err != nil { encoder.Encode(err) ctx.WriteHeader(err.(*gorc.OrchestrateError).StatusCode) } else { encoder.Encode(results) } ctx.Write(buf.Bytes()) }
func players(ctx *web.Context) []byte { ctx.SetHeader("Content-Type", "application/json", true) players, err := arena.GetPlayers() checkError(err) jsonPlayers, err := json.Marshal(players) checkError(err) return jsonPlayers }
func (h *RestQueueHandler) List(ctx *web.Context) { var keys []string keys, _ = h.redis.Keys("*") resp, _ := json.Marshal(keys) ctx.SetHeader("Content-Type", "application/json; charset=UTF-8", true) ctx.WriteString(string(resp)) }
func serveCaptchaAudio(ctx *web.Context, id string) { //tell the user's browser not to cache the audio file //(would cause old audio file to be used even if user has reloaded the CAPTCHA) ctx.SetHeader("Cache-Control", "no-cache", true) err := captcha.WriteAudio(ctx, id, "english") if err != nil { logger.Println("Error, could not write CAPTCHA audio") logger.Println(err.Error()) } }
func uploader(ctx *web.Context, key string) { updateRemoteAddr(ctx) if _, ok := uploadRequests[key]; ok { // key exists ctx.Forbidden() return } wait := make(chan string) defer delete(uploadRequests, key) uploadRequests[key] = uploadRequest{ctx.Request, wait} var result string select { case result = <-wait: case <-time.After(WAIT_CLIENT_TIMEOUT): result = "wait client timeout" } if result == "connected" { // wait actual result result = <-wait } var body string if xrw := ctx.Request.Header.Get("X-Requested-With"); xrw == "XMLHttpRequest" { body = "{\"result\": \"" + result + "\"}\n" ctx.SetHeader("Content-Type", "application/json", true) } else { tmpl, err := template.New("uploader").Parse(uploadTemplate) if err != nil { panic(err) } var buf bytes.Buffer tmpl.Execute(&buf, UploadTemplateValue{result}) body = buf.String() } if result == "ok" { ctx.WriteString(body) } else { ctx.Abort(500, body) ctx.Request.Body.Close() } }
func Options(ctx *web.Context, route string) string { ctx.SetHeader("Access-Control-Allow-Origin", "*", false) ctx.SetHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, If-None-Match", false) ctx.SetHeader("Access-control-Allow-Methods", "GET, PUT, POST, DELETE", false) ctx.ContentType("application/json") return "{}" }
/* Serves a CAPTCHA image Parameters: ctx: The context of the http request id: The ID of the captcha to serve */ func serveCaptchaImage(ctx *web.Context, id string) { width, err := strconv.Atoi(ctx.Params["width"]) if err != nil { logger.Printf("Error: could not parse captcha image width of '%v'\n%v\n", ctx.Params["width"], err.Error()) width = captcha.StdWidth } height, err := strconv.Atoi(ctx.Params["height"]) if err != nil { logger.Printf("Error: could not parse captcha image height of '%v'\n%v\n", ctx.Params["height"], err.Error()) height = captcha.StdHeight } //tell the user's browser not to cache the image file ctx.SetHeader("Cache-Control", "no-cache", true) err = captcha.WriteImage(ctx, id, width, height) if err != nil { logger.Println("Error, could not write CAPTCHA image") logger.Println(err.Error()) } }
func downloader(ctx *web.Context, key string) { updateRemoteAddr(ctx) up, ok := uploadRequests[key] if !ok { ctx.NotFound("key doesn't exist") return } up.wait <- "connected" result := "ng" defer func() { up.wait <- result }() mr, err := up.request.MultipartReader() if err != nil { ctx.Abort(500, err.Error()) return } p, err := mr.NextPart() if p.FormName() == "size" { fileSize, err := ioutil.ReadAll(p) if err == nil { fileSize, err := strconv.ParseInt(string(fileSize), 10, 64) if err == nil && fileSize >= 0 { ctx.SetHeader("Content-Length", strconv.FormatInt(fileSize, 10), true) } } } p, err = mr.NextPart() if err != nil { ctx.Abort(500, err.Error()) return } if p.FormName() != "file" { ctx.Abort(500, "invalid POST (upload) request") return } if contentType := p.Header.Get("Content-Type"); contentType != "" { ctx.SetHeader("Content-Type", contentType, true) } ctx.SetHeader("Content-Disposition", "attachment; filename="+p.FileName(), true) _, err = io.Copy(ctx, p) if err == nil { result = "ok" } else { // XXX: may expose too many infomation (such as client IP address) //result = err.Error() } }
func getPaste(ctx *web.Context, uri string) string { c, err := redis.Dial("tcp", "localhost:6379") if err != nil { Log(err) return mustache.Render("Cannot connect to DB \r\n") } defer c.Close() y := "PASTE_DOES_NOT_EXIST" if matched, _ := regexp.MatchString("[a-zA-Z0-9]+", uri); matched { y = "paste_" + uri } x, err := redis.String(c.Do("GET", y)) ctx.SetHeader("Content-Type", "text/plain", true) ctx.SetHeader("X-Powered-By", "web.go", true) ctx.SetHeader("Connection", "close", true) return mustache.Render(x) }
func APIResponse(ctx *web.Context, resp interface{}) string { resp_text, _ := json.Marshal(resp) ctx.SetHeader("Content-Type", "application/json", true) return string(resp_text[:]) }