app/models/original_picture.rb

   1 class OriginalPicture < Peta::Content
   2   load_manifest
   3   belongs_to :artist
   4   belongs_to :original_picture_license_group
   5   has_one :resource_picture
   6   has_many :pictures
   7   has_many :resource_picture_pictures
   8
   9   validates :ext, :presence => true, :length => {:maximum => 4}, :inclusion => {:in => ['png', 'jpeg', 'gif']}
  10   validates :width, :presence => true, :numericality => true, :natural_number => true
  11   validates :height, :presence => true, :numericality => true, :natural_number => true
  12   validates :filesize, :presence => true, :numericality => {:greater_than => 0, :less_than_or_equal_to => 2000000}, :natural_number => true
  13   validates :artist_id, :presence => true, :numericality => true, :existence => {:both => false}
  14   validates :md5, :presence => true, :length => {:minimum => 32, :maximum => 32}
  15
  16   def supply_default
  17     self.artist_id = nil
  18   end
  19
  20   def overwrite operators
  21     self.uploaded_at = Time.now
  22     return unless operators.artist
  23     self.artist_id = operators.artist.id
  24   end
  25
  26   def visible? operators
  27     self.own? operators
  28   end
  29   def filename
  30     "#{self.id}.#{self.ext}"
  31   end
  32
  33   def mime_type
  34     "image/#{self.ext}"
  35   end
  36
  37   def url
  38     '/original_pictures/' + filename
  39   end
  40
  41   def opt_img_tag
  42     {:src => self.url, :width => self.width, :height => self.height}
  43   end
  44
  45   def tmb_opt_img_tag
  46     tw, th = PettanImager.thumbnail_size(self.width, self.height)
  47     {:src => self.url, :width => tw, :height => th}
  48   end
  49
  50   def symbol_option
  51     self.tmb_opt_img_tag
  52   end
  53
  54   def filer_caption
  55     self.revision
  56   end
  57
  58   def revision
  59     head = self.history.first
  60     head ? head.revision : 'unpublished'
  61   end
  62
  63   def unpublished?
  64     self.published_at == nil and self.stopped_at == nil
  65   end
  66
  67   def stopped?
  68     self.stopped_at != nil
  69   end
  70
  71   def unlicensed?
  72     dt = self.published_at || self.stopped_at
  73     return false unless dt
  74     self.uploaded_at > dt
  75   end
  76
  77   def published?
  78     self.published_at != nil
  79   end
  80
  81   def history
  82     Picture.find(:all, {:conditions => ['pictures.original_picture_id = ?', self.id], :order => 'pictures.revision desc'} )
  83   end
  84
  85   def self.show_opt
  86     {:include => {:resource_picture => {}, :pictures => {}}}
  87   end
  88
  89   def store(imager)
  90     unless imager
  91       self.errors.add :base, I18n.t('errors.invalid_image')
  92       return false
  93     end
  94     res = false
  95     self.attributes = {:ext => imager.ext, :width => imager.width, :height => imager.height, :filesize => imager.filesize, :md5 => imager.md5}
  96     OriginalPicture.transaction do
  97       if res = self.save
  98         begin
  99           res = PictureIO.original_picture_io.put(imager.binary, self.filename)
 100         rescue PictureIO::Error
 101           res = false
 102           self.errors.add :base, I18n.t('picture_io.error')
 103           raise ActiveRecord::Rollback
 104         end
 105       end
 106     end
 107     res
 108   end
 109
 110   def restore(subdir = nil)
 111     PictureIO.original_picture_io.get self.filename, subdir
 112   end
 113
 114   def self.export(dt = nil)
 115     opt = {}
 116     cond = if dt
 117       ['artists.author_id is not null and original_pictures.updated_at >= ?', dt]
 118     else
 119       'artists.author_id is not null'
 120     end
 121     opt.merge!({:conditions => cond})
 122     opt.merge!({:include => {:resource_picture => {}, :artist => {}}, :order => 'original_pictures.id'})
 123     OriginalPicture.find(:all, opt)
 124   end
 125
 126   def list_as_json_with_resource_picture
 127     self.to_json({:include => {:resource_picture => {:methods => :picture_data}}})
 128   end
 129
 130   def self.list_as_json_text ary
 131     '[' + ary.map {|i| i.list_as_json_with_resource_picture }.join(',') + ']'
 132   end
 133
 134   def destroy_with_resource_picture
 135     res = false
 136     OriginalPicture.transaction do
 137       begin
 138         PictureIO.original_picture_io.delete(self.filename) if PictureIO.original_picture_io.exist?(self.filename)
 139       rescue PictureIO::Error
 140         res = false
 141         raise ActiveRecord::Rollback
 142       end
 143       if self.resource_picture
 144         res = self.resource_picture.unpublish
 145         raise ActiveRecord::Rollback unless res
 146       end
 147       self.pictures.each do |picture|
 148         res = picture.unpublish
 149         raise ActiveRecord::Rollback unless res
 150         if picture.resource_picture_picture
 151           picture.resource_picture_picture.original_picture_id = nil
 152           picture.resource_picture_picture.resource_picture_id = nil
 153           raise ActiveRecord::Rollback unless picture.resource_picture_picture.save
 154         end
 155       end
 156       res = self.destroy
 157       raise ActiveRecord::Rollback unless res
 158     end
 159     res
 160   end
 161
 162   def self.publish oid, lsname, attr
 163     l = License.find_by_name lsname
 164     op = OriginalPicture.find oid
 165     lg = l.license_group
 166     attr[:license_id] = l.id
 167
 168     ctl = lg.module_name.pluralize + '::Attribute'
 169     le = ctl.constantize.new attr
 170
 171     rp = ResourcePicture.new
 172     rp.attributes = le.resource_picture_attributes op
 173     rp.overwrite op
 174
 175     imager = PettanImager.load op.restore
 176     rp.store imager
 177   end
 178
 179   def self.upload fn, auth
 180     b = Base64.encode64(File.open(fn, 'rb').read)
 181     u = 'http://localhost:3000/original_pictures'
 182     r = RestClient.post(u,
 183       {:original_picture => {:file  => b}, :auth_token => auth}.to_json,
 184       :content_type => :json, :accept => :json
 185     )
 186     o = JSON.parse r
 187     oid = o['id']
 188     oid
 189   end
 190
 191   def self.auto_publish dirname, auth
 192     Dir.glob File.expand_path(dirname) + '/*' do |filename|
 193       if File.directory?(filename)
 194         img = nil
 195         lsname = nil
 196         attr  = nil
 197         Dir.glob(filename + '/*') do |fn|
 198           ext = File.extname(fn).downcase
 199           case ext
 200           when '.json'
 201             json = JSON.parse(File.open(fn).read)
 202             lsname = json["license_name"]
 203             attr = json["attributes"]
 204           when '.png', '.gif', '.jpeg'
 205             img = fn
 206           end
 207         end
 208         oid = OriginalPicture.upload img, auth
 209         OriginalPicture.publish oid, lsname, attr
 210       end
 211     end
 212   end
 213
 214 end