flickarr 0.1.0

data/lib/flickarr/client/profile_query.rb

@@ -0,0 +1,19 @@
+module Flickarr
+  class Client
+    class ProfileQuery
+      def initialize flickr:, user_id:, rate_limiter:
+        @flickr       = flickr
+        @rate_limiter = rate_limiter
+        @user_id      = user_id
+      end
+
+      def info
+        @rate_limiter.track { @flickr.people.getInfo(user_id: @user_id) }
+      end
+
+      def profile
+        @rate_limiter.track { @flickr.profile.getProfile(user_id: @user_id) }
+      end
+    end
+  end
+end

data/lib/flickarr/client.rb

@@ -0,0 +1,94 @@
+require 'flickr'
+require_relative 'client/photo_query'
+require_relative 'client/profile_query'
+
+module Flickarr
+  class Client
+    attr_reader :flickr
+
+    def initialize config
+      raise ConfigError, 'api_key is required' if config.api_key.nil? || config.api_key.empty?
+      raise ConfigError, 'shared_secret is required' if config.shared_secret.nil? || config.shared_secret.empty?
+
+      @flickr       = Flickr.new config.api_key, config.shared_secret
+      @rate_limiter = RateLimiter.new
+
+      return unless config.access_token && config.access_secret
+
+      @flickr.access_token  = config.access_token
+      @flickr.access_secret = config.access_secret
+    end
+
+    def collections user_id:
+      @rate_limiter.track do
+        flickr.collections.getTree(user_id: user_id)
+      end
+    end
+
+    def photo id:
+      PhotoQuery.new(flickr: flickr, id: id, rate_limiter: @rate_limiter)
+    end
+
+    PHOTO_EXTRAS = %w[
+      date_taken
+      date_upload
+      description
+      geo
+      icon_server
+      last_update
+      license
+      machine_tags
+      media
+      o_dims
+      original_format
+      owner_name
+      path_alias
+      tags
+      url_c
+      url_l
+      url_m
+      url_n
+      url_o
+      url_q
+      url_s
+      url_sq
+      url_t
+      url_z
+      views
+    ].join(',').freeze
+
+    def photos user_id:, page: 1, per_page: 100
+      @rate_limiter.track do
+        flickr.people.getPhotos(user_id: user_id, page: page, per_page: per_page, extras: PHOTO_EXTRAS)
+      end
+    end
+
+    SET_PHOTO_EXTRAS = %w[
+      date_taken
+      date_upload
+      description
+      media
+      original_format
+      tags
+      url_o
+    ].join(',').freeze
+
+    def set_photos photoset_id:, user_id:, page: 1, per_page: 500
+      @rate_limiter.track do
+        flickr.photosets.getPhotos(
+          photoset_id: photoset_id, user_id: user_id, page: page, per_page: per_page, extras: SET_PHOTO_EXTRAS
+        )
+      end
+    end
+
+    def sets user_id:
+      @rate_limiter.track do
+        flickr.photosets.getList(user_id: user_id, per_page: 500)
+      end
+    end
+
+    def profile user_id:
+      ProfileQuery.new(flickr: flickr, user_id: user_id, rate_limiter: @rate_limiter)
+    end
+  end
+end

data/lib/flickarr/collection.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+require 'json'
+require 'slugify'
+require 'yaml'
+
+module Flickarr
+  class Collection
+    COLLECTION_URL_PATTERN = %r{\Ahttps?://(?:www\.)?flickr\.com/photos/[^/]+/collections/(\d+)}
+
+    def self.id_from_url url
+      match = url.to_s.match COLLECTION_URL_PATTERN
+      match&.captures&.first
+    end
+
+    attr_reader :description,
+                :iconlarge,
+                :iconsmall,
+                :id,
+                :title
+
+    def initialize collection
+      @description = collection.description.to_s
+      @iconlarge   = collection.iconlarge.to_s
+      @iconsmall   = collection.iconsmall.to_s
+      @id          = collection.id
+      @title       = collection.title.to_s
+      @set_refs    = collection.set
+    end
+
+    def dirname
+      [id, slug].compact.join '_'
+    end
+
+    def sets_to_a
+      @set_refs.map do |s|
+        set_slug = s.title.to_s.slugify
+        set_dirname = [s.id, set_slug.empty? ? nil : set_slug].compact.join('_')
+
+        {
+          description: s.description.to_s,
+          id:          s.id,
+          path:        File.join('Sets', set_dirname),
+          title:       s.title.to_s
+        }
+      end
+    end
+
+    def slug
+      s = title.slugify
+      s.empty? ? nil : s
+    end
+
+    def to_h
+      {
+        description: description,
+        iconlarge:   iconlarge,
+        iconsmall:   iconsmall,
+        id:          id,
+        title:       title
+      }
+    end
+
+    def write archive_path:, overwrite: false
+      dir       = collection_dir archive_path
+      json_path = File.join dir, 'collection.json'
+      existed   = File.exist? json_path
+
+      return :skipped if existed && !overwrite
+
+      FileUtils.mkdir_p dir
+      write_collection_files dir: dir
+      write_sets_files dir: dir
+
+      existed ? :overwritten : :created
+    end
+
+    private
+
+    def collection_dir archive_path
+      File.join archive_path, 'Collections', dirname
+    end
+
+    def deep_stringify_keys obj
+      case obj
+      when Hash  then obj.transform_keys(&:to_s).transform_values { deep_stringify_keys it }
+      when Array then obj.map { deep_stringify_keys it }
+      else obj
+      end
+    end
+
+    def write_collection_files dir:
+      File.write File.join(dir, 'collection.json'), JSON.pretty_generate(to_h)
+      File.write File.join(dir, 'collection.yaml'), YAML.dump(to_h.transform_keys(&:to_s))
+    end
+
+    def write_sets_files dir:
+      refs = sets_to_a
+
+      File.write File.join(dir, 'sets.json'), JSON.pretty_generate(refs)
+      File.write File.join(dir, 'sets.yaml'), YAML.dump(deep_stringify_keys(refs))
+    end
+  end
+end

data/lib/flickarr/config.rb

@@ -0,0 +1,88 @@
+require 'fileutils'
+require 'yaml'
+
+module Flickarr
+  class Config
+    DEFAULT_LIBRARY_PATH = File.join(Dir.home, 'Pictures', 'Flickarr').freeze
+
+    attr_accessor :access_secret, :access_token, :api_key, :last_page_photos, :last_page_posts, :last_page_videos,
+                  :library_path, :shared_secret, :total_collections, :total_photos, :total_sets, :total_videos,
+                  :user_nsid, :username
+
+    def initialize
+      @access_secret = nil
+      @access_token = nil
+      @api_key = ENV.fetch('FLICKARR_API_KEY', nil)
+      @last_page_photos = nil
+      @last_page_posts = nil
+      @last_page_videos = nil
+      @library_path = DEFAULT_LIBRARY_PATH
+      @shared_secret = ENV.fetch('FLICKARR_SHARED_SECRET', nil)
+      @total_collections = nil
+      @total_photos = nil
+      @total_sets = nil
+      @total_videos = nil
+      @user_nsid = nil
+      @username = nil
+    end
+
+    def save path
+      hash = to_h.transform_keys(&:to_s)
+      yaml = YAML.dump hash
+      dir  = File.dirname path
+
+      FileUtils.mkdir_p dir
+      File.write path, yaml
+    end
+
+    def archive_path
+      return nil if username.nil? || username.empty?
+
+      File.join library_path, username
+    end
+
+    def to_h
+      {
+        access_secret:     access_secret,
+        access_token:      access_token,
+        api_key:           api_key,
+        last_page_photos:  last_page_photos,
+        last_page_posts:   last_page_posts,
+        last_page_videos:  last_page_videos,
+        library_path:      library_path,
+        shared_secret:     shared_secret,
+        total_collections: total_collections,
+        total_photos:      total_photos,
+        total_sets:        total_sets,
+        total_videos:      total_videos,
+        user_nsid:         user_nsid,
+        username:          username
+      }
+    end
+
+    def self.load path
+      config = new
+      return config unless File.exist?(path)
+
+      yaml = YAML.load_file(path, symbolize_names: true)
+      return config unless yaml.is_a?(Hash)
+
+      config.access_secret     = yaml[:access_secret]     if yaml[:access_secret]
+      config.access_token      = yaml[:access_token]      if yaml[:access_token]
+      config.api_key           = yaml[:api_key]           if yaml[:api_key]
+      config.last_page_photos  = yaml[:last_page_photos]  if yaml[:last_page_photos]
+      config.last_page_posts   = yaml[:last_page_posts]   if yaml[:last_page_posts]
+      config.last_page_videos  = yaml[:last_page_videos]  if yaml[:last_page_videos]
+      config.library_path      = yaml[:library_path]      if yaml[:library_path]
+      config.shared_secret     = yaml[:shared_secret]     if yaml[:shared_secret]
+      config.total_collections = yaml[:total_collections] if yaml[:total_collections]
+      config.total_photos      = yaml[:total_photos]      if yaml[:total_photos]
+      config.total_sets        = yaml[:total_sets]        if yaml[:total_sets]
+      config.total_videos      = yaml[:total_videos]      if yaml[:total_videos]
+      config.user_nsid         = yaml[:user_nsid]         if yaml[:user_nsid]
+      config.username          = yaml[:username]          if yaml[:username]
+
+      config
+    end
+  end
+end

data/lib/flickarr/errors.rb

@@ -0,0 +1,7 @@
+module Flickarr
+  class Error < StandardError; end
+  class AuthError < Error; end
+  class ApiError < Error; end
+  class DownloadError < Error; end
+  class ConfigError < Error; end
+end

data/lib/flickarr/license.rb

@@ -0,0 +1,34 @@
+module Flickarr
+  class License
+    LICENSES = {
+      '0'  => { name: 'All Rights Reserved',                url: nil },
+      '1'  => { name: 'CC BY-NC-SA 2.0',                    url: 'https://creativecommons.org/licenses/by-nc-sa/2.0/' },
+      '2'  => { name: 'CC BY-NC 2.0',                       url: 'https://creativecommons.org/licenses/by-nc/2.0/' },
+      '3'  => { name: 'CC BY-NC-ND 2.0',                    url: 'https://creativecommons.org/licenses/by-nc-nd/2.0/' },
+      '4'  => { name: 'CC BY 2.0',                          url: 'https://creativecommons.org/licenses/by/2.0/' },
+      '5'  => { name: 'CC BY-SA 2.0',                       url: 'https://creativecommons.org/licenses/by-sa/2.0/' },
+      '6'  => { name: 'CC BY-ND 2.0',                       url: 'https://creativecommons.org/licenses/by-nd/2.0/' },
+      '7'  => { name: 'No Known Copyright Restrictions',     url: 'https://www.flickr.com/commons/usage/' },
+      '8'  => { name: 'United States Government Work',       url: 'http://www.usa.gov/copyright.shtml' },
+      '9'  => { name: 'CC0 1.0 Universal', url: 'https://creativecommons.org/publicdomain/zero/1.0/' },
+      '10' => { name: 'Public Domain Mark 1.0', url: 'https://creativecommons.org/publicdomain/mark/1.0/' }
+    }.freeze
+
+    attr_reader :id, :name, :url
+
+    def initialize id
+      @id   = id.to_s
+      entry = LICENSES.fetch(@id, { name: 'Unknown', url: nil })
+      @name = entry[:name]
+      @url  = entry[:url]
+    end
+
+    def to_h
+      {
+        id:   id,
+        name: name,
+        url:  url
+      }
+    end
+  end
+end

data/lib/flickarr/photo.rb

@@ -0,0 +1,23 @@
+module Flickarr
+  class Photo < Post
+    def initialize info:, sizes:, exif: nil
+      super
+      @extension = info.originalformat.to_s
+    end
+
+    def download archive_path:
+      dir  = post_dir archive_path
+      dest = File.join dir, "#{basename}.#{extension}"
+
+      FileUtils.mkdir_p dir
+      Down.download original_url, destination: dest
+    end
+
+    def original_url
+      original = @sizes.find { it.label == 'Original' }
+      size     = original || @sizes.last
+
+      size.source
+    end
+  end
+end

data/lib/flickarr/photo_set.rb

@@ -0,0 +1,139 @@
+require 'fileutils'
+require 'json'
+require 'slugify'
+require 'yaml'
+
+module Flickarr
+  class PhotoSet
+    SET_URL_PATTERN = %r{\Ahttps?://(?:www\.)?flickr\.com/photos/[^/]+/(?:sets|albums)/(\d+)}
+
+    def self.id_from_url url
+      match = url.to_s.match SET_URL_PATTERN
+      match&.captures&.first
+    end
+
+    attr_reader :count_comments,
+                :count_photos,
+                :count_videos,
+                :count_views,
+                :date_create,
+                :date_update,
+                :description,
+                :id,
+                :owner,
+                :primary,
+                :title,
+                :username
+
+    def initialize set:, photo_items:
+      @count_comments = set.count_comments.to_s
+      @count_photos   = set.count_photos.to_i
+      @count_videos   = set.count_videos.to_i
+      @count_views    = set.count_views.to_s
+      @date_create    = set.date_create.to_s
+      @date_update    = set.date_update.to_s
+      @description    = set.description.to_s
+      @id             = set.id
+      @owner          = set.owner.to_s
+      @primary        = set.primary.to_s
+      @title          = set.title.to_s
+      @username       = set.username.to_s
+      @photo_items    = photo_items
+    end
+
+    def dirname
+      [id, slug].compact.join '_'
+    end
+
+    def photos_to_a
+      @photo_items.map do |item|
+        path = relative_photo_path item
+        {
+          datetaken:  item.datetaken.to_s,
+          dateupload: item.dateupload.to_s,
+          id:         item.id,
+          isprimary:  item.isprimary.to_s == '1',
+          media:      item.media.to_s,
+          path:       path,
+          tags:       item.tags.to_s,
+          title:      item.title.to_s
+        }
+      end
+    end
+
+    def slug
+      s = title.slugify
+      s.empty? ? nil : s
+    end
+
+    def to_h
+      {
+        count_comments: count_comments,
+        count_photos:   count_photos,
+        count_videos:   count_videos,
+        count_views:    count_views,
+        date_create:    date_create,
+        date_update:    date_update,
+        description:    description,
+        id:             id,
+        owner:          owner,
+        primary:        primary,
+        title:          title,
+        username:       username
+      }
+    end
+
+    def write archive_path:, overwrite: false
+      dir       = dir_for_set archive_path
+      json_path = File.join dir, 'set.json'
+      existed   = File.exist? json_path
+
+      return :skipped if existed && !overwrite
+
+      FileUtils.mkdir_p dir
+      write_set_files dir: dir
+      write_photos_files dir: dir
+
+      existed ? :overwritten : :created
+    end
+
+    private
+
+    def deep_stringify_keys obj
+      case obj
+      when Hash  then obj.transform_keys(&:to_s).transform_values { deep_stringify_keys it }
+      when Array then obj.map { deep_stringify_keys it }
+      else obj
+      end
+    end
+
+    def relative_photo_path item
+      ext  = item.media.to_s == 'video' ? 'mp4' : item.originalformat.to_s
+      slug = item.title.to_s.slugify
+      base = [item.id, slug.empty? ? nil : slug].compact.join('_')
+      date = if item.datetakenunknown.to_i.zero?
+               Date.parse item.datetaken
+             else
+               Time.at(item.dateupload.to_i).to_date
+             end
+
+      File.join date.strftime('%Y/%m/%d'), "#{base}.#{ext}"
+    end
+
+    def dir_for_set archive_path
+      File.join archive_path, 'Sets', dirname
+    end
+
+    def write_photos_files dir:
+      refs = photos_to_a
+
+      File.write File.join(dir, 'photos.json'), JSON.pretty_generate(refs)
+      File.write File.join(dir, 'photos.yaml'), YAML.dump(deep_stringify_keys(refs))
+    end
+
+    def write_set_files dir:
+      File.write File.join(dir, 'set.json'), JSON.pretty_generate(to_h)
+      File.write File.join(dir, 'set.yaml'), YAML.dump(to_h.transform_keys(&:to_s))
+    end
+  end
+end