X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=app%2Fmodels%2Foriginal_picture.rb;h=020bc56b1d37da0dac61d7b30375155728e628d3;hb=0174862d186425888ff64ffe1fa52c6266708049;hp=90679f44cc4f1b7c3d07f4ab795339007f2814a5;hpb=3f0ce2cf0fdb97034e05ce91dfbc6bf818c7ea89;p=pettanr%2Fpettanr.git diff --git a/app/models/original_picture.rb b/app/models/original_picture.rb index 90679f44..020bc56b 100644 --- a/app/models/original_picture.rb +++ b/app/models/original_picture.rb @@ -1,97 +1,118 @@ -class OriginalPicture < ActiveRecord::Base +class OriginalPicture < Peta::Content + load_manifest belongs_to :artist - belongs_to :license + belongs_to :original_picture_license_group has_one :resource_picture + has_many :pictures - before_destroy :destroy_with_file + validates :ext, :presence => true, :length => {:maximum => 4}, :inclusion => {:in => ['png', 'jpeg', 'gif']} + validates :width, :presence => true, :numericality => true, :natural_number => true + validates :height, :presence => true, :numericality => true, :natural_number => true + validates :filesize, :presence => true, :numericality => {:greater_than => 0, :less_than_or_equal_to => 2000000}, :natural_number => true + validates :artist_id, :presence => true, :numericality => true, :existence => {:both => false} + validates :md5, :presence => true, :length => {:minimum => 32, :maximum => 32} - def validate - errors.add(:filesize, 'size over(1MB)') if self.filesize > 1000000 + def supply_default end - def supply_default art - self.license_id = art.default_license_id if self.license_id.blank? + def overwrite operators + self.uploaded_at = Time.now + return unless operators.artist + self.artist_id = operators.artist.id end - def self.default_page_size - 25 + def visible? operators + self.own? operators + end + def filename + "#{self.id}.#{self.ext}" end - def self.max_page_size - 100 + def mime_type + "image/#{self.ext}" end - def self.page prm = nil - page = prm.to_i - page = 1 if page < 1 - page + def url + '/original_pictures/' + filename end - def self.page_size prm = self.default_page_size - page_size = prm.to_i - page_size = self.max_page_size if page_size > self.max_page_size - page_size = self.default_page_size if page_size < 1 - page_size + def opt_img_tag + {:src => self.url, :width => self.width, :height => self.height} end - def self.list artist_id, opt = {}, page = 1, page_size = self.default_page_size - opt.merge!(self.list_opt) unless opt[:include] - opt.merge!({:conditions => ['artist_id = ?', artist_id], - :order => 'updated_at desc', :limit => page_size, :offset => (page -1) * page_size} - ) - OriginalPicture.find(:all, opt) + def tmb_opt_img_tag + tw, th = PettanImager.thumbnail_size(self.width, self.height) + {:src => self.url, :width => tw, :height => th} end - def self.list_opt - {:include => [:artist, :license, :resource_picture]} + def symbol_option + self.tmb_opt_img_tag end - def self.list_json_opt - {:include => [:resource_picture, :artist, :license]} + def revision + head = self.history.first + head ? head.revision : 'unpublished' end - def self.show cid, opt = {} - Comic.find(cid, :include => self.show_include_opt(opt)) + def unpublished? + self.published_at == nil and self.stopped_at == nil end - def self.show_include_opt opt = {} - res = [:author] - res.push(opt[:include]) if opt[:include] - res + def stopped? + self.stopped_at != nil end - def self.show_json_include_opt - {:include => :author} + def unlicensed? + dt = self.published_at || self.stopped_at + return false unless dt + self.uploaded_at > dt end - def destroy_with_file - PictureIO.original_picture_io.delete self.filename - self.resource_picture.destroy + def published? + self.published_at != nil end - def dext - self.ext.downcase + def self.list_order + 'original_pictures.updated_at desc' end - def filename - "#{self.id}.#{self.dext}" + def self.list_opt + {:resource_picture => {}, :pictures => {} } end - def mime_type - "image/#{self.dext}" + def self.list_json_opt + {:include => {:resource_picture => {}, :pictures => {}}} end - def url - '/original_pictures/' + filename + def history + Picture.find(:all, {:conditions => ['pictures.original_picture_id = ?', self.id], :order => 'pictures.revision desc'} ) end - def store(rimg) - bindata = rimg.to_blob - PictureIO.original_picture_io.put bindata, self.filename - res = if self.resource_picture - self.resource_picture.store rimg - else - ResourcePicture.store(rimg, self) + def self.show_opt + {:include => {:resource_picture => {}, :pictures => {}}} + end + + def self.show_json_opt + {:include => {:resource_picture => {}, :pictures => {}}} + end + + def store(imager) + unless imager + self.errors.add :base, I18n.t('errors.invalid_image') + return false + end + res = false + self.attributes = {:ext => imager.ext, :width => imager.width, :height => imager.height, :filesize => imager.filesize, :md5 => imager.md5} + OriginalPicture.transaction do + if res = self.save + begin + res = PictureIO.original_picture_io.put(imager.binary, self.filename) + rescue PictureIO::Error + res = false + self.errors.add :base, I18n.t('picture_io.error') + raise ActiveRecord::Rollback + end + end end res end @@ -100,10 +121,99 @@ class OriginalPicture < ActiveRecord::Base PictureIO.original_picture_io.get self.filename, subdir end - def own? author - return false unless author - return false unless author.artist? - self.artist_id == author.artist.id + def self.export(dt = nil) + opt = {} + cond = if dt + ['artists.author_id is not null and original_pictures.updated_at >= ?', dt] + else + 'artists.author_id is not null' + end + opt.merge!({:conditions => cond}) + opt.merge!({:include => {:resource_picture => {}, :artist => {}}, :order => 'original_pictures.id'}) + OriginalPicture.find(:all, opt) + end + + def list_as_json_with_resource_picture + self.to_json({:include => {:resource_picture => {:methods => :picture_data}}}) + end + + def self.list_as_json_text ary + '[' + ary.map {|i| i.list_as_json_with_resource_picture }.join(',') + ']' + end + + def destroy_with_resource_picture + res = false + OriginalPicture.transaction do + begin + PictureIO.original_picture_io.delete(self.filename) if PictureIO.original_picture_io.exist?(self.filename) + rescue PictureIO::Error + res = false + raise ActiveRecord::Rollback + end + if self.resource_picture + res = self.resource_picture.unpublish + raise ActiveRecord::Rollback unless res + end + self.pictures.each do |picture| + res = picture.unpublish + raise ActiveRecord::Rollback unless res + end + res = self.destroy + raise ActiveRecord::Rollback unless res + end + res + end + + def self.publish oid, lsname, attr + l = License.find_by_name lsname + op = OriginalPicture.find oid + lg = l.license_group + attr[:license_id] = l.id + + ctl = lg.classname.pluralize + '::Attribute' + le = ctl.constantize.new attr + + rp = ResourcePicture.new + rp.attributes = le.resource_picture_attributes op + rp.overwrite op + + imager = PettanImager.load op.restore + rp.store imager + end + + def self.upload fn, auth + b = Base64.encode64(File.open(fn, 'rb').read) + u = 'http://localhost:3000/original_pictures' + r = RestClient.post(u, + {:original_picture => {:file => b}, :auth_token => auth}.to_json, + :content_type => :json, :accept => :json + ) + o = JSON.parse r + oid = o['id'] + oid + end + + def self.auto_publish dirname, auth + Dir.glob File.expand_path(dirname) + '/*' do |filename| + if File.directory?(filename) + img = nil + lsname = nil + attr = nil + Dir.glob(filename + '/*') do |fn| + ext = File.extname(fn).downcase + case ext + when '.json' + json = JSON.parse(File.open(fn).read) + lsname = json["license_name"] + attr = json["attributes"] + when '.png', '.gif', '.jpeg' + img = fn + end + end + oid = OriginalPicture.upload img, auth + OriginalPicture.publish oid, lsname, attr + end + end end end