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")
}
}
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
}
}
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")
}
}
}
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)
}
}
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)
}
}
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)
}
}
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
}
}
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)
}
}
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)
}
}
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)
}
}
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)
}
}
}
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)
}
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)
}
}
}
}
func checkPrivatePageApiKey(w traffic.ResponseWriter, r *traffic.Request) {
if r.Param("private_api_key") != "bar" {
w.WriteHeader(http.StatusUnauthorized)
w.WriteText("Not authorized\n")
}
}
func customNotFoundHandler(w traffic.ResponseWriter, r *traffic.Request) {
w.WriteHeader(http.StatusNotFound)
w.WriteText("Page not found: %s\n", r.URL.Path)
}
func RecordingNotFoundHandler(w traffic.ResponseWriter, r *traffic.Request) {
w.WriteHeader(http.StatusNotFound)
json.NewEncoder(w).Encode(map[string]string{
"error": "recording not found",
})
}
func checkApiKey(w traffic.ResponseWriter, r *traffic.Request) {
if r.Param("api_key") != "foo" {
w.WriteHeader(http.StatusUnauthorized)
w.WriteText("Not authorized\n")
}
}
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)
}