caring-r2flickr 0.1.1.7

data/lib/flickr/photosets.rb

@@ -0,0 +1,102 @@
+require 'flickr/base'
+
+class Flickr::PhotoSets < Flickr::APIBase
+  # photoset can be a PhotoSet or a a photoset id
+  # photo can be a Photo or a photo id
+  def addPhoto(photoset,photo)
+    photo = photo.id if photo.class == Flickr::Photo
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+
+    @flickr.call_method('flickr.photosets.addPhoto',
+                        'photoset_id' => photoset, 'photo_id' => photo)
+  end
+
+  def create(title,primary_photo, description = nil)
+    primary_photo = primary_photo.id if
+    primary_photo.class == Flickr::Photo
+    args = { 'title' => title, 'primary_photo_id' => primary_photo }
+    args['description'] = description if description
+    res = @flickr.call_method('flickr.photosets.create',args)
+    id = res.elements['/photoset'].attributes['id']
+    url = res.elements['/photoset'].attributes['url']
+    set = Flickr::PhotoSet.new(id,@flickr)
+    set.title = title
+    set.url = url
+    @flickr.photoset_cache_store(set)
+    return set
+  end
+
+  def delete(photoset)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    @flickr.call_method('flickr.photosets.delete',
+                        'photoset_id' => photoset)
+  end
+
+  def editMeta(photoset,title,description=nil)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    args = {'photoset_id' => photoset, 'title' => title}
+    args['description' ] = description if description
+    @flickr.call_method('flickr.photosets.editMeta',args)
+  end
+
+  def editPhotos(photoset,primary_photo,photos)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    primary_photo = primary_photo.id if
+    primary_photo.class == Flickr::Photo
+    photos=photos.map{|p| p.id if p.class==Flickr::Photo}.join(',')
+    args = {'photoset_id' => photoset,
+            'primary_photo_id' => primary_photo,
+            'photo_ids' => photos }
+    @flickr.call_method('flickr.photosets.editPhotos',args)
+  end
+
+  def getContext(photo,photoset)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    photo = photo.id if photo.class == Flickr::Photo
+    res = @flickr.call_method('flickr.photosets.getContext',
+                              'photo_id' => photo, 'photoset_id' => photoset)
+    return Flickr::Context.from_xml(res,@flickr)
+  end
+
+  def getList(user=nil)
+    user = user.nsid if user.respond_to?(:nsid)
+    args = {}
+    args['user_id'] = user if user
+    res = @flickr.call_method('flickr.photosets.getList',args)
+    list = []
+    res.elements['/photosets'].each_element do |el|
+      list << Flickr::PhotoSet.from_xml(el,@flickr)
+    end
+    return list
+  end
+
+  def removePhoto(photoset,photo)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    photo = photo.id if photo.class == Flickr::Photo
+    @flickr.call_method('flickr.photosets.removePhoto',
+                        'photo_id' => photo, 'photoset_id' => photoset)
+  end
+
+  def getPhotos(photoset,extras=nil)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    extras = extras.join(',') if extras.class == Array
+    args = { 'photoset_id' => photoset }
+    args['extras'] = extras if extras
+    res = @flickr.call_method('flickr.photosets.getPhotos',args)
+    return Flickr::PhotoSet.from_xml(res.root,@flickr)
+  end
+
+  def getInfo(photoset)
+    photoset = photoset.id if photoset.class == Flickr::PhotoSet
+    res = @flickr.call_method('flickr.photosets.getInfo',
+                              'photoset_id' => photoset)
+    return Flickr::PhotoSet.from_xml(res.root,@flickr)
+  end
+
+  def orderSets(photosets)
+    photosets=photosets.map { |ps|
+      (ps.class==Flickr::PhotoSet) ? ps.id : ps}.join(',')
+      @flickr.call_method('flickr.photosets.orderSets',
+                          'photoset_ids' => photosets)
+  end
+end

data/lib/flickr/pools.rb

@@ -0,0 +1,73 @@
+require 'flickr/groups'
+
+class Flickr::Pools < Flickr::APIBase
+  
+  def initialize(flickr,groups)
+    super(flickr)
+    @groups = groups
+  end
+
+  # photo can be a Photo or photo_id
+  # group can be a Group or group_id
+  def add(photo,group)
+    group = group.nsid if group.class == Flickr::Group
+    photo = photo.id if photo.class == Flickr::Photo
+    @flickr.call_method('flickr.groups.pools.add',
+                        'group_id' => group, 'photo_id' => photo)
+  end
+
+  # photo can be a Photo or photo_id
+  # group can be a Group or group_id
+  def remove(photo,group)
+    group = group.nsid if group.class == Flickr::Group
+    photo = photo.id if photo.class == Flickr::Photo
+    @flickr.call_method('flickr.groups.pools.add',
+                        'group_id' => group, 'photo_id' => photo)
+  end
+
+  # photo can be a Photo or photo_id
+  # group can be a Group or group_id
+  def getContext(photo,group)
+    group = group.nsid if group.class == Flickr::Group
+    photo = photo.id if photo.class == Flickr::Photo
+    res = @flickr.call_method('flickr.groups.pools.getContex',
+                              'group_id' => group, 'photo_id' => photo)
+    return Flickr::Context.from_xml(res)
+  end
+
+  def getGroups
+    res = @flickr.call_method('flickr.groups.pools.getGroups')
+    list = []
+
+    res.elements['/groups'].each_element do |el|
+      att = el.attributes
+      nsid = att['nsid']
+      g = @flickr.group_cache_lookup(nsid) ||
+        Flickr::Group.new(@flickr,nsid,att['name'])
+      g.name = att['name']
+      g.admin = att['admin'].to_i == 1
+      g.privacy = Flickr::Group::PRIVACY[att['privacy'].to_i]
+      g.photo_count = att['photos'].to_i
+      g.iconserver = att['iconserver'].to_i
+
+      @flickr.group_cache_store(g)
+      list << g
+    end
+    
+    return list
+  end
+
+  def getPhotos(group,tags=nil,extras=nil,per_page=nil,page=nil)
+    group = group.nsid if group.class == Flickr::Group
+    group = group.id.to_s if group.class == Flickr::PhotoPool
+    args = { 'group_id' => group }
+    args['tags'] = tags.map{|t| t.clean if t.class ==
+      Flick::Tag}.join(',') if tags
+    args['extras'] = extras.join(',') if extras.class == Array
+    args['per_page'] = per_page if per_page
+    args['page'] = page if page
+
+    res = @flickr.call_method('flickr.groups.pools.getPhotos', args)
+    return Flickr::PhotoList.from_xml(res,@flickr)
+  end
+end

data/lib/flickr/reflection.rb

@@ -0,0 +1,89 @@
+require 'flickr/base'
+
+class Flickr::Method
+  attr_reader :name, :authenticated, :description, :response, :explanation,
+    :arguments, :errors
+
+  def initialize(name,authenticated,description,response,explanation)
+    @name = name
+    @authenticated = authenticated
+    @description = description
+    @response = response
+    @explanation = explanation
+    @arguments = []
+    @errors = []
+  end
+end
+
+class Flickr::MethodArgument
+  attr_reader :name, :optional, :description
+
+  def initialize(name,optional,description)
+    @name = name
+    @optional = optional
+    @description = description
+  end
+end
+
+class Flickr::Reflection < Flickr::APIBase
+  # We don't bother with caching because it's not worth it for the
+  # reflection API.
+  def getMethodInfo(method_name)
+    res = @flickr.call_method('flickr.reflection.getMethodInfo',
+                              'method_name' => method_name)
+    els = res.elements
+    att = res.root.attributes
+    desc = els['/method/description'] ?
+      els['/method/description'].text : nil
+    resp = els['/method/response'] ?
+      els['/method/response'].text : nil
+    expl = els['/method/explanation'] ?
+      els['/method/explanation'].text : nil
+    meth = Flickr::Method.new(att['name'],att['needslogin'].to_i==1,
+                              desc,resp,expl)
+    els['/method/arguments'].each_element do |el|
+      att = el.attributes
+      arg = Flickr::MethodArgument.new(att['name'],
+                                       att['optional'].to_i == 1,el.text)
+      meth.arguments << arg
+    end
+    els['/method/errors'].each_element do |el|
+      att = el.attributes
+      err = XMLRPC::FaultException.new(att['code'].to_i,
+                                       el.text)
+      meth.errors << err
+    end		
+    return meth
+  end
+
+  def getMethods
+    res = @flickr.call_method('flickr.reflection.getMethods')
+    list = []
+    res.elements['/methods'].each_element do |el|
+      list << el.text
+    end
+    return list
+  end
+
+  def missing_methods
+    list = []
+    methods = self.getMethods
+    methods.each do |mname|
+      parts = mname.split('.')
+      parts.shift
+      call = parts.pop
+      obj = @flickr
+      parts.each do |part|
+        if obj.respond_to?(part)
+          obj = obj.method(part).call
+        else
+          obj = nil
+          list << mname
+          break
+        end
+      end
+      list << mname if (obj && !obj.respond_to?(call))
+    end
+    return list
+  end
+end

data/lib/flickr/tags.rb

@@ -0,0 +1,59 @@
+require 'flickr/base'
+
+class Flickr::Tags < Flickr::APIBase
+  def getListPhoto(photo)
+    photo = photo.id if photo.class == Flickr::Photo
+    res = @flickr.call_method('flickr.tags.getListPhoto',
+                        'photo_id'=>photo)
+    xml = res.root
+    phid = xml.attributes['id']
+    photo = (photo.class == Flickr::Photo) ? photo :
+      (@flickr.photo_cache_lookup(phid) ||
+       Flickr::Photo.new(@flickr,phid))
+    if xml.elements['tags']
+      tags = []
+      xml.elements['tags'].each_element do |el|
+        tags << Flickr::Tag.from_xml(el,photo)
+      end
+    end
+    photo.tags = tags
+    return tags
+  end
+
+  def getListUserPopular(user,count = nil)
+    user = user.nsid if user.class == Flickr::Person
+    args = { 'user_id' => user }
+    args['count'] = count if count
+
+    res = @flickr.call_method('flickr.tags.getListUserPopular',args)
+    tags = {}
+    res.elements['/who/tags'].each_element do |tag|
+      att = tag.attributes
+      tags[tag.text]=att['count'].to_i
+    end
+    return tags
+  end
+
+  def getListUser(user)
+    user = user.nsid if user.class == Flickr::Person
+    args = { 'user_id' => user }
+
+    res = @flickr.call_method('flickr.tags.getListUser',args)
+    tags = []
+    res.elements['/who/tags'].each_element do |tag|
+      tags << tag.text
+    end
+    return tags
+  end
+
+  def getRelated(tag)
+    args = { 'tag' => tag }
+
+    res = @flickr.call_method('flickr.tags.getRelated',args)
+    tags = []
+    res.elements['/tags'].each_element do |tag|
+      tags << tag.text
+    end
+    return tags
+  end
+end

data/lib/flickr/test.rb

@@ -0,0 +1,20 @@
+require 'flickr/base'
+
+class Flickr::Test < Flickr::APIBase
+  
+  # This has to be a Hash
+  def echo(args)
+    return @flickr.call_method('flickr.test.echo',args)
+  end
+
+  def login
+    res = @flickr.call_method('flickr.test.login')
+    nsid = res.elements['/user'].attributes['id']
+    name = res.elements['/user/username'].text
+    p = @flickr.person_cache_lookup(nsid) ||
+      Flickr::Person.new(@flickr,nsid,name)
+    p.name = name
+    @flickr.person_cache_store(p)
+    return p
+  end
+end

data/lib/flickr/token_cache.rb

@@ -0,0 +1,33 @@
+require 'flickr/base'
+
+class Flickr::BaseTokenCache < Flickr::APIBase
+
+  def load_token
+    nil
+  end
+
+  def cache_token(token)
+    nil
+  end
+
+end
+
+class Flickr::FileTokenCache < Flickr::BaseTokenCache
+
+  def initialize(filename)
+    @cache_file = filename
+  end
+
+  def load_token
+    token = nil
+    File.open(@cache_file,'r'){ |f| token = f.read }
+    @token = Flickr::Token.from_xml(REXML::Document.new(token))
+  rescue Errno::ENOENT
+    nil
+  end
+
+  def cache_token(token)
+    File.open(@cache_file,'w'){ |f| f.write token.to_xml } if token
+  end
+
+end

data/lib/flickr/transform.rb

@@ -0,0 +1,11 @@
+require 'flickr/base'
+
+class Flickr::Transform < Flickr::APIBase
+  
+  def rotate(photo,degrees)
+    photo = photo.id if photo.class == Flickr::Photo
+    @flickr.call_method('flickr.photos.transform.rotate',
+                        'photo_id' => photo, 'degrees' => degrees)
+  end
+
+end

data/lib/flickr/upload.rb

@@ -0,0 +1,205 @@
+require 'flickr/base'
+require 'mime/types'
+require 'net/http'
+
+class Flickr::Ticket
+
+  attr_reader :id
+  attr_accessor :complete, :invalid, :photoid
+
+  COMPLETE=[:incomplete,:completed,:failed]
+
+  def initialize(id,upload)
+    @id = id
+    @upload = upload
+  end
+
+  def check
+    t = @upload.checkTickets(self)[0]
+    self.complete = t.complete
+    self.invalid = t.invalid
+    self.photoid = t.photoid
+    return t
+  end
+end
+
+class Flickr::FormPart
+  attr_reader :data, :mime_type, :attributes
+
+  def initialize(name,data,mime_type=nil)
+    @attributes = {}
+    @attributes['name'] = name
+    @data = data
+    @mime_type = mime_type
+  end
+
+  def to_s
+    ([ "Content-Disposition: form-data" ] +
+     attributes.map{|k,v| "#{k}=\"#{v}\""}).
+     join('; ') + "\r\n"+
+     (@mime_type ? "Content-Type: #{@mime_type}\r\n" : '')+
+                "\r\n#{data}"
+  end
+end
+
+class Flickr::MultiPartForm
+  attr_accessor :boundary, :parts
+
+  def initialize(boundary=nil)
+    @boundary = boundary ||
+                "----------------------------Ruby#{rand(1000000000000)}"
+    @parts = []
+  end
+
+  def to_s
+    "--#@boundary\r\n" + parts.map{|p| p.to_s}.join("\r\n--#@boundary\r\n") +
+    "\r\n--#@boundary--\r\n"
+  end
+
+end
+
+class Flickr::Upload < Flickr::APIBase
+
+  # TODO: It would probably be better if we wrapped the fault
+  # in something more meaningful. At the very least, a broad
+  # division of errors, such as retryable and fatal. 
+  def error(el)
+    att = el.attributes
+    fe = XMLRPC::FaultException.new(att['code'].to_i,
+                                    att['msg'])
+    $stderr.puts "ERR: #{fe.faultString} (#{fe.faultCode})"
+    raise fe
+  end
+
+  def prepare_parts(data,mimetype,filename,title=nil,description=nil,
+                    tags=nil, is_public=nil,is_friend=nil,is_family=nil,
+                    sig=nil, async=nil)
+    parts = []
+    parts << Flickr::FormPart.new('title',title) if title
+    parts << Flickr::FormPart.new('description',description) if
+    description
+    parts << Flickr::FormPart.new('tags',tags.join(',')) if tags
+    parts << Flickr::FormPart.new('is_public',
+                                  is_public ?  '1' : '0') if is_public != nil
+    parts << Flickr::FormPart.new('is_friend',
+                                  is_friend ?  '1' : '0') if is_friend != nil
+    parts << Flickr::FormPart.new('is_family',
+                                  is_family ?  '1' : '0') if is_family != nil
+    parts << Flickr::FormPart.new('async',
+                                  async ?  '1' : '0') if async != nil
+
+    parts << Flickr::FormPart.new('api_key',@flickr.api_key)
+    parts << Flickr::FormPart.new('auth_token',
+                                  @flickr.auth.token.token)
+    parts << Flickr::FormPart.new('api_sig',sig)
+
+    parts << Flickr::FormPart.new('photo',data,mimetype)
+    parts.last.attributes['filename'] = filename
+    return parts
+  end
+
+  def make_signature(title=nil,description=nil, tags=nil,
+                     is_public=nil,is_friend=nil,is_family=nil,async=nil)
+    args = {'api_key' => @flickr.api_key,
+                        'auth_token' => @flickr.auth.token.token}
+    args['title'] = title if title
+    args['description'] = description if description
+    args['tags'] = tags.join(',') if tags
+    args['is_public'] = (is_public ? '1' : '0') if is_public != nil
+    args['is_friend'] = (is_friend ? '1' : '0') if is_friend != nil
+    args['is_family'] = (is_family ? '1' : '0') if is_family != nil
+    args['async'] = (async ? '1' : '0') if async != nil
+    args['api_sig'] = @flickr.sign(args)
+  end
+
+  def send_form(form)
+    headers = {"Content-Type" => "multipart/form-data; boundary=" + form.boundary}
+
+    http = Net::HTTP.new('www.flickr.com', 80)
+    # http.read_timeout = 900 # 15 minutes max upload time
+    tries = 3
+    begin
+      res=http.post('/services/upload/',form.to_s,headers)
+    rescue Timeout::Error => err
+      tries -= 1
+      $stderr.puts "Timed out, will retry #{tries} more."
+      retry if tries > 0
+      raise err
+    end
+    return res
+  end
+
+  def upload_file_async(filename,title=nil,description=nil,tags=nil,
+                        is_public=nil,is_friend=nil,is_family=nil)
+    mt = MIME::Types.of(filename)
+    f = File.open(filename,'rb')
+    data = f.read
+    f.close
+    return upload_image_async(data,mt,filename,title,description,
+                              tags, is_public,is_friend,is_family)
+  end
+
+
+  def upload_file(filename,title=nil,description=nil,tags=nil,
+                  is_public=nil,is_friend=nil,is_family=nil)
+    mt = MIME::Types.of(filename)
+    f = File.open(filename,'rb')
+    data = f.read
+    f.close
+    return upload_image(data,mt,filename,title,description,tags, 
+                        is_public,is_friend,is_family)
+  end
+
+  def upload_image_async(data,mimetype,filename,title=nil,description=nil,
+                         tags=nil, is_public=nil,is_friend=nil,is_family=nil)
+    form = Flickr::MultiPartForm.new
+
+    sig = make_signature(title,description, tags, is_public,
+                         is_friend, is_family, true)
+    form.parts += prepare_parts(data,mimetype,filename,title,
+                                description, tags, is_public, is_friend,
+                                is_family, sig, true)
+    res = REXML::Document.new(send_form(form).body)
+    error(res.elements['/rsp/err']) if res.elements['/rsp/err']
+    t = Flickr::Ticket.new(res.elements['/rsp/ticketid'].text, self)
+    @flickr.ticket_cache_store(t)
+    return t
+  end
+
+  def upload_image(data,mimetype,filename,title=nil,description=nil,
+                   tags=nil, is_public=nil,is_friend=nil,is_family=nil)
+    form = Flickr::MultiPartForm.new
+
+    sig = make_signature(title,description, tags, is_public,
+                         is_friend, is_family)
+    form.parts += prepare_parts(data,mimetype,filename,title,
+                                description, tags, is_public, is_friend,
+                                is_family, sig)
+    res = REXML::Document.new(send_form(form).body)
+    error(res.elements['/rsp/err']) if res.elements['/rsp/err']
+    val = res.elements['/rsp/photoid'].text
+    return val
+  end
+
+  def checkTickets(tickets)
+    tickets = [tickets] if tickets.class != Array
+    targ = tickets.map{|t|
+      t.id.to_s if t.class == Flickr::Ticket }.join(',')
+      res = @flickr.call_method('flickr.photos.upload.checkTickets',
+                        'tickets' => targ)
+      tickets = []
+      res.elements['/uploader'].each_element('ticket') do |tick|
+        att = tick.attributes
+        tid = att['id']
+        t = @flickr.ticket_cache_lookup(tid) ||
+          Flickr::Ticket.new(tid,self)
+        t.complete = Flickr::Ticket::COMPLETE[att['complete'].to_i]
+        t.photoid = att['photoid']
+        t.invalid = true if (att['invalid'] &&
+                             (att['invalid'].to_i == 1))
+        @flickr.ticket_cache_store(t)
+        tickets << t
+      end
+      return tickets
+  end
+end