func RequireValidImageParameters(w traffic.ResponseWriter, r *traffic.Request) {

	width, err := strconv.Atoi(r.Param("width"))
	if err != nil {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	height, err := strconv.Atoi(r.Param("height"))
	if err != nil {
		height = width
	}

	if (width <= 2560 && width > 0) && (height <= 2560 && height > 0) {

		w.SetVar("width", width)
		w.SetVar("height", height)

		// log latest greatest creation
		if err := ioutil.WriteFile(filepath.Join(cache_folder, "/latest"), []byte(fmt.Sprintf("%d/%d", width, height)), 0644); err != nil {
			// panic is trapped by Traffic and show us a nice stack trace in the browser
			// a proper error handling should be provided, but in this simple example
			// it's used to remind you to always check for errors
			panic(err)
		}

	} else {
		// bad request
		w.WriteHeader(http.StatusBadRequest)
		w.Render("400")
	}

}
Beispiel #2
0
func CheckReleaseFilter(w traffic.ResponseWriter, r *traffic.Request) {
	artistId := r.URL.Query().Get("artist_id")
	releaseId := r.URL.Query().Get("release_id")

	if releaseId == "" {
		return
	}

	if !models.IsValidUUID(releaseId) {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	if artistId != "" {
		if !models.IsValidUUID(artistId) {
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		if artist.HasRelease(artistId, releaseId) {
			return
		}

		ReleaseNotFoundHandler(w, r)
		return
	}

	if !release.Exists(releaseId) {
		ReleaseNotFoundHandler(w, r)
		return
	}
}
Beispiel #3
0
func CheckForDdosString(w traffic.ResponseWriter, r *traffic.Request) {
	for k, _ := range uriFragments {
		fmt.Printf("Searching for %s in %s", k, r.RequestURI)
		if strings.Contains(r.RequestURI, k) {
			fmt.Printf("Found %s", k)
			w.WriteHeader(http.StatusGatewayTimeout)
			w.WriteText("connection timed out")
		}
	}
}
Beispiel #4
0
func (api *ImgServerApi) deleteHandler(w traffic.ResponseWriter, r *traffic.Request) {

	filename := r.URL.Query().Get("image")
	err := api.imageDir.DeleteFile(filename)
	api.imageCache.Remove(api.imageCache.FindKeys(filename))

	if err != nil {
		traffic.Logger().Print(err.Error())
		w.WriteHeader(http.StatusNotFound)
	} else {
		w.WriteHeader(http.StatusOK)
	}
}
Beispiel #5
0
func ArtistHandler(w traffic.ResponseWriter, r *traffic.Request) {
	id := r.URL.Query().Get("id")
	Artist, err := artist.ById(id)

	if err == nil {
		json.NewEncoder(w).Encode(Artist)
	} else if err == sql.ErrNoRows {
		ArtistNotFoundHandler(w, r)
	} else if _, ok := err.(models.InvalidUUID); ok {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		panic(err)
	}
}
Beispiel #6
0
func (api *ImgServerApi) listHandler(w traffic.ResponseWriter, r *traffic.Request) {

	age, err := strconv.Atoi(r.Param("age"))
	if err != nil {
		age = 0
	}

	files, err := api.imageDir.ListFiles(time.Duration(age) * time.Second)
	if err != nil {
		traffic.Logger().Print(err.Error())
		w.WriteHeader(http.StatusInternalServerError)
	} else {
		w.WriteJSON(files)
	}
}
func ReleaseGroupsHandler(w traffic.ResponseWriter, r *traffic.Request) {
	artistId := r.URL.Query().Get("artist_id")

	ReleaseGroups, err := releasegroup.AllByArtistId(artistId)

	if err == nil {
		json.NewEncoder(w).Encode(ReleaseGroups)
	} else if err == sql.ErrNoRows {
		w.WriteHeader(http.StatusNotFound)
	} else if _, ok := err.(models.InvalidUUID); ok {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		panic(err)
	}
}
Beispiel #8
0
func CheckArtistFilter(w traffic.ResponseWriter, r *traffic.Request) {
	artistId := r.URL.Query().Get("artist_id")
	if artistId == "" {
		return
	}

	if !models.IsValidUUID(artistId) {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	if !artist.Exists(artistId) {
		ArtistNotFoundHandler(w, r)
		return
	}
}
Beispiel #9
0
func RecordingsHandler(w traffic.ResponseWriter, r *traffic.Request) {
	releaseId := r.URL.Query().Get("release_id")

	var recordings []*models.Recording
	var err error

	recordings, err = recording.AllByReleaseId(releaseId)

	if err == nil {
		json.NewEncoder(w).Encode(recordings)
	} else if err == sql.ErrNoRows {
		w.WriteHeader(http.StatusNotFound)
	} else if _, ok := err.(models.InvalidUUID); ok {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		panic(err)
	}
}
func ReleaseGroupHandler(w traffic.ResponseWriter, r *traffic.Request) {
	artistId := r.URL.Query().Get("artist_id")
	id := r.URL.Query().Get("id")

	var ReleaseGroup *models.ReleaseGroup
	var err error

	if artistId != "" {
		ReleaseGroup, err = releasegroup.ByArtistIdAndId(artistId, id)
	} else {
		ReleaseGroup, err = releasegroup.ById(id)
	}

	if err == nil {
		json.NewEncoder(w).Encode(ReleaseGroup)
	} else if err == sql.ErrNoRows {
		ReleaseGroupNotFoundHandler(w, r)
	} else if _, ok := err.(models.InvalidUUID); ok {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		panic(err)
	}
}
Beispiel #11
0
func RecordingHandler(w traffic.ResponseWriter, r *traffic.Request) {
	releaseId := r.URL.Query().Get("release_id")
	id := r.URL.Query().Get("id")

	var Recording *models.Recording
	var err error

	if releaseId != "" {
		Recording, err = recording.ByReleaseIdAndId(releaseId, id)
	} else {
		Recording, err = recording.ById(id)
	}

	if err == nil {
		json.NewEncoder(w).Encode(Recording)
	} else if err == sql.ErrNoRows {
		RecordingNotFoundHandler(w, r)
	} else if _, ok := err.(models.InvalidUUID); ok {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		panic(err)
	}
}
Beispiel #12
0
func ReleasesHandler(w traffic.ResponseWriter, r *traffic.Request) {
	artistId := r.URL.Query().Get("artist_id")
	releaseGroupId := r.URL.Query().Get("release_group_id")

	var releases []*models.Release
	var err error

	if releaseGroupId == "" {
		releases, err = release.AllByArtistId(artistId)
	} else {
		releases, err = release.AllByReleaseGroupId(releaseGroupId)
	}

	if err == nil {
		json.NewEncoder(w).Encode(releases)
	} else if err == sql.ErrNoRows {
		ReleaseNotFoundHandler(w, r)
	} else if _, ok := err.(models.InvalidUUID); ok {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		panic(err)
	}
}
Beispiel #13
0
func (api *ImgServerApi) uploadHandler(w traffic.ResponseWriter, r *traffic.Request) {

	filename := r.URL.Query().Get("image")
	uploadedImage, _, err := image.Decode(r.Body)

	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		img := drawOnWhite(uploadedImage.Bounds().Size(), image.Pt(0, 0), image.Pt(0, 0), uploadedImage)
		err = api.imageDir.WriteImage(filename, img, 100)
		if err != nil {
			traffic.Logger().Print(err.Error())
			w.WriteHeader(http.StatusInternalServerError)
		} else {
			w.WriteHeader(http.StatusOK)
		}
	}
}
Beispiel #14
0
func (api *ImgServerApi) copyHandler(w traffic.ResponseWriter, r *traffic.Request) {

	src := r.URL.Query().Get("src")
	dst := r.URL.Query().Get("dst")

	data, err := api.imageDir.ReadFile(src)
	if err != nil {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	err = api.imageDir.WriteFile(dst, data)
	if err != nil {
		traffic.Logger().Print(err.Error())
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
}
Beispiel #15
0
func (api *ImgServerApi) imageHandler(w traffic.ResponseWriter, r *traffic.Request) {

	params := r.URL.Query()
	width := toInt(params.Get("width"), 0)
	height := toInt(params.Get("height"), 0)
	imagefile := params.Get("image")
	cacheKey := imagefile + string(width) + string(height)

	modTime := api.imageDir.ModTime(imagefile)
	if modTime == nil {
		api.imageCache.Remove(api.imageCache.FindKeys(imagefile))
		w.WriteHeader(http.StatusNotFound)
		return
	}

	if cachedImage := api.imageCache.Get(cacheKey, *modTime); cachedImage != nil {
		sendJpeg(w, cachedImage)
	} else {
		origImage, err := api.imageDir.ReadImage(imagefile)
		if err != nil {
			traffic.Logger().Print(err.Error())
			w.WriteHeader(http.StatusNotFound)
		} else {
			semaphore <- struct{}{}
			buffer := new(bytes.Buffer)
			sizedImage := resizeImage(origImage, width, height, api.faceDetection)
			err = jpeg.Encode(buffer, sizedImage, &jpeg.Options{95})
			<-semaphore
			if err != nil {
				traffic.Logger().Print(err.Error())
				w.WriteHeader(http.StatusInternalServerError)
			} else {
				data := make([]byte, buffer.Len())
				buffer.Read(data)
				api.imageCache.Put(cacheKey, data, *modTime)
				sendJpeg(w, data)
			}
		}
	}
}
Beispiel #16
0
func checkPrivatePageApiKey(w traffic.ResponseWriter, r *traffic.Request) {
	if r.Param("private_api_key") != "bar" {
		w.WriteHeader(http.StatusUnauthorized)
		w.WriteText("Not authorized\n")
	}
}
Beispiel #17
0
func customNotFoundHandler(w traffic.ResponseWriter, r *traffic.Request) {
	w.WriteHeader(http.StatusNotFound)
	w.WriteText("Page not found: %s\n", r.URL.Path)
}
Beispiel #18
0
func RecordingNotFoundHandler(w traffic.ResponseWriter, r *traffic.Request) {
	w.WriteHeader(http.StatusNotFound)
	json.NewEncoder(w).Encode(map[string]string{
		"error": "recording not found",
	})
}
Beispiel #19
0
func checkApiKey(w traffic.ResponseWriter, r *traffic.Request) {
	if r.Param("api_key") != "foo" {
		w.WriteHeader(http.StatusUnauthorized)
		w.WriteText("Not authorized\n")
	}
}
Beispiel #20
0
func addLocationHeader(w traffic.ResponseWriter, r *traffic.Request) {
	t := fmt.Sprintf("tel://%s", w.GetVar("phone"))
	w.Header().Add("Location", t)
	w.WriteHeader(http.StatusTemporaryRedirect)
}