// Vikunja is a to-do list application to facilitate your life. // Copyright 2018-2021 Vikunja and contributors. All rights reserved. // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public Licensee as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public Licensee for more details. // // You should have received a copy of the GNU Affero General Public Licensee // along with this program. If not, see <https://www.gnu.org/licenses/>. package unsplash import ( "bytes" "context" "encoding/json" "net/http" "net/url" "strconv" "strings" "time" "xorm.io/xorm" "code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/log" "code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/modules/background" "code.vikunja.io/api/pkg/modules/keyvalue" "code.vikunja.io/web" ) const ( unsplashAPIURL = `https://api.unsplash.com/` cachePrefix = `unsplash_photo_` ) // Provider represents an unsplash image provider type Provider struct { } // SearchResult is a search result from unsplash's api type SearchResult struct { Total int `json:"total"` TotalPages int `json:"total_pages"` Results []*Photo `json:"results"` } // Photo represents an unpslash photo as returned by their api type Photo struct { ID string `json:"id"` CreatedAt string `json:"created_at"` Width int `json:"width"` Height int `json:"height"` Color string `json:"color"` Description string `json:"description"` User struct { Username string `json:"username"` Name string `json:"name"` } `json:"user"` Urls struct { Raw string `json:"raw"` Full string `json:"full"` Regular string `json:"regular"` Small string `json:"small"` Thumb string `json:"thumb"` } `json:"urls"` Links struct { Self string `json:"self"` HTML string `json:"html"` Download string `json:"download"` DownloadLocation string `json:"download_location"` } `json:"links"` } // We're caching the initial collection to save a few api requests as this is retrieved every time a // user opens the settings page. type initialCollection struct { lastCached time.Time // images contains a slice of images by page they belong to // this allows us to cache individual pages. images map[int64][]*background.Image } var emptySearchResult *initialCollection func doGet(url string, result ...interface{}) (err error) { req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, unsplashAPIURL+url, nil) if err != nil { return } req.Header.Add("Authorization", "Client-ID "+config.BackgroundsUnsplashAccessToken.GetString()) hc := http.Client{} resp, err := hc.Do(req) if err != nil { return } defer resp.Body.Close() if len(result) > 0 { return json.NewDecoder(resp.Body).Decode(result[0]) } return } func getImageID(fullURL string) string { // Unsplash image urls have the form // https://images.unsplash.com/photo-1590622878565-c662a7fd1394?ixlib=rb-1.2.1&q=80&fm=jpg&crop=entropy&cs=tinysrgb&w=200&fit=max&ixid=eyJhcHBfaWQiOjcyODAwfQ // We only need the "photo-*" part of it. return strings.Replace(strings.Split(fullURL, "?")[0], "https://images.unsplash.com/", "", 1) } // Gets an unsplash photo either from cache or directly from the unsplash api func getUnsplashPhotoInfoByID(photoID string) (photo *Photo, err error) { photo = &Photo{} exists, err := keyvalue.GetWithValue(cachePrefix+photoID, photo) if err != nil { return nil, err } if !exists { log.Debugf("Image information for unsplash photo %s not cached, requesting from unsplash...", photoID) photo = &Photo{} err = doGet("photos/"+photoID, photo) if err != nil { return } } return } // Search is the implementation to search on unsplash // @Summary Search for a background from unsplash // @Description Search for a list background from unsplash // @tags list // @Produce json // @Security JWTKeyAuth // @Param s query string false "Search backgrounds from unsplash with this search term." // @Param p query int false "The page number. Used for pagination. If not provided, the first page of results is returned." // @Success 200 {array} background.Image "An array with photos" // @Failure 500 {object} models.Message "Internal error" // @Router /backgrounds/unsplash/search [get] func (p *Provider) Search(s *xorm.Session, search string, page int64) (result []*background.Image, err error) { // If we don't have a search query, return results from the unsplash featured collection if search == "" { var existsForPage bool if emptySearchResult != nil && time.Since(emptySearchResult.lastCached) < time.Hour { _, existsForPage = emptySearchResult.images[page] } if existsForPage { log.Debugf("Serving initial wallpaper topic from unsplash for page %d from cache, last updated at %v", page, emptySearchResult.lastCached) return emptySearchResult.images[page], nil } log.Debugf("Retrieving initial wallpaper topic from unsplash for page %d from unsplash api", page) collectionResult := []*Photo{} err = doGet("topics/wallpapers/photos?page="+strconv.FormatInt(page, 10)+"&per_page=25&order_by=latest", &collectionResult) if err != nil { return } result = []*background.Image{} for _, p := range collectionResult { result = append(result, &background.Image{ ID: p.ID, URL: getImageID(p.Urls.Raw), Info: &models.UnsplashPhoto{ UnsplashID: p.ID, Author: p.User.Username, AuthorName: p.User.Name, }, }) if err := keyvalue.Put(cachePrefix+p.ID, p); err != nil { return nil, err } } // Put the collection in cache if emptySearchResult == nil { emptySearchResult = &initialCollection{ images: make(map[int64][]*background.Image), } } emptySearchResult.lastCached = time.Now() emptySearchResult.images[page] = result return } searchResult := &SearchResult{} err = doGet("search/photos?query="+url.QueryEscape(search)+"&page="+strconv.FormatInt(page, 10)+"&per_page=25", &searchResult) if err != nil { return } result = []*background.Image{} for _, p := range searchResult.Results { result = append(result, &background.Image{ ID: p.ID, URL: getImageID(p.Urls.Raw), Info: &models.UnsplashPhoto{ UnsplashID: p.ID, Author: p.User.Username, AuthorName: p.User.Name, }, }) if err := keyvalue.Put(cachePrefix+p.ID, p); err != nil { return nil, err } } return } // Set sets an unsplash photo as list background // @Summary Set an unsplash photo as list background // @Description Sets a photo from unsplash as list background. // @tags list // @Accept json // @Produce json // @Security JWTKeyAuth // @Param id path int true "List ID" // @Param list body background.Image true "The image you want to set as background" // @Success 200 {object} models.List "The background has been successfully set." // @Failure 400 {object} web.HTTPError "Invalid image object provided." // @Failure 403 {object} web.HTTPError "The user does not have access to the list" // @Failure 500 {object} models.Message "Internal error" // @Router /lists/{id}/backgrounds/unsplash [post] func (p *Provider) Set(s *xorm.Session, image *background.Image, list *models.List, auth web.Auth) (err error) { // Find the photo photo, err := getUnsplashPhotoInfoByID(image.ID) if err != nil { return } // Download the photo from unsplash // The parameters crop the image to a max width of 2560 and a max height of 2048 to save bandwidth and storage. req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, photo.Urls.Raw+"&w=2560&h=2048&q=90", nil) if err != nil { return } resp, err := http.DefaultClient.Do(req) if err != nil { return err } defer resp.Body.Close() if resp.StatusCode > 399 { b := bytes.Buffer{} _, _ = b.ReadFrom(resp.Body) log.Errorf("Error getting unsplash photo %s: Request failed with status %d, message was %s", photo.ID, resp.StatusCode, b.String()) return } log.Debugf("Downloaded unsplash photo %s", image.ID) // Ping the unsplash download endpoint (again, unsplash api guidelines) err = doGet(strings.Replace(photo.Links.DownloadLocation, unsplashAPIURL, "", 1)) if err != nil { return } log.Debugf("Pinged unsplash download endpoint for photo %s", image.ID) // Save it as a file in vikunja file, err := files.Create(resp.Body, "", 0, auth) if err != nil { return } // Remove the old background if one exists if list.BackgroundFileID != 0 { file := files.File{ID: list.BackgroundFileID} if err := file.Delete(); err != nil { return err } if err := models.RemoveUnsplashPhoto(s, list.BackgroundFileID); err != nil { return err } } // Save the relation that we got it from unsplash unsplashPhoto := &models.UnsplashPhoto{ FileID: file.ID, UnsplashID: image.ID, Author: photo.User.Username, AuthorName: photo.User.Name, } err = unsplashPhoto.Save(s) if err != nil { return } log.Debugf("Saved unsplash photo %s as file %d with new entry %d", image.ID, file.ID, unsplashPhoto.ID) // Set the file in the list list.BackgroundFileID = file.ID list.BackgroundInformation = unsplashPhoto // Set it as the list background return models.SetListBackground(s, list.ID, file) } // Pingback pings the unsplash api if an unsplash photo has been accessed. func Pingback(s *xorm.Session, f *files.File) { // Check if the file is actually downloaded from unsplash unsplashPhoto, err := models.GetUnsplashPhotoByFileID(s, f.ID) if err != nil { if files.IsErrFileIsNotUnsplashFile(err) { return } log.Errorf("Unsplash Pingback: %s", err.Error()) } // Do the ping pingbackByPhotoID(unsplashPhoto.UnsplashID) } func pingbackByPhotoID(photoID string) { req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "https://views.unsplash.com/v?app_id="+config.BackgroundsUnsplashApplicationID.GetString()+"&photo_id="+photoID, nil) if err != nil { log.Errorf("Unsplash Pingback Failed: %s", err.Error()) } _, err = http.DefaultClient.Do(req) if err != nil { log.Errorf("Unsplash Pingback Failed: %s", err.Error()) } log.Debugf("Pinged unsplash for photo %s", photoID) }