Module: Fclay::Attachment

Extended by:
ActiveSupport::Concern
Defined in:
lib/fclay/attachment.rb

Constant Summary collapse

CALLBACKS = 
[:process,:upload,:delete]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#file ⇒ Object

Returns the value of attribute file.



28
29
30
 
# File 'lib/fclay/attachment.rb', line 28

def file
  @file
end

Class Method Details

.resolve_file_url(navigation_complex_id, type, file_name, style = nil) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/fclay/attachment.rb', line 221

def self.resolve_file_url navigation_complex_id,type,file_name,style=nil
  
  return "" if file_name.nil? || type.nil?
  
  path = "http://s3.amazonaws.com/#{Fclay.remote_storage.bucket_name}"
  path += "/navigation_complex/#{navigation_complex_id}" if navigation_complex_id
  path += "/#{type}"
  path += "/#{style.to_s}" if style
  path += "/#{file_name}"
  path
end

.upload(type, id) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/fclay/attachment.rb', line 55

def self.upload type,id

   type = type.safe_constantize
   return unless type
   uploading_object = type.find_by_id(id)
   return if !uploading_object || !uploading_object.need_upload
   content_type  = uploading_object.try(:content_type)
   bucket = Fclay.remote_storage.bucket_object
   
   (uploading_object.class.fclay_options[:styles] || [nil]).each do |style|
     obj = bucket.object(uploading_object.remote_file_path(style))
     obj.put({
       body: File.read(uploading_object.local_file_path(style)),
       acl: "public-read",
       content_type: uploading_object.class.fclay_options[:content_type]
     })
   end
  
  uploading_object.update_attributes(:file_status => 'idle', :file_location => Fclay.remote_storage.name)
  uploading_object.delete_local_files
  uploading_object.try(:uploaded)

end

Instance Method Details

#create_dirs ⇒ Object 



141
142
143
144
145
146
147
 
# File 'lib/fclay/attachment.rb', line 141

def create_dirs

 (self.class.fclay_options[:styles] || [nil]).each do |style|
   FileUtils.mkdir_p(local_file_dir(style))
 end

end

#delete_files ⇒ Object 



30
31
32
33
34
35
36
37
38
39
 
# File 'lib/fclay/attachment.rb', line 30

def delete_files
  
  case self.file_location 
    when 's3'
      delete_remote_files
    when 'local'
      delete_local_files
  end

end

#delete_local_files ⇒ Object 



197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/fclay/attachment.rb', line 197

def delete_local_files 

   begin
      (self.class.fclay_options[:styles] || [nil]).each do |style|
        FileUtils.rm(local_file_path(style),{:force => true})
      end
   rescue
      Rails.logger.info "Deleting Media #{id} sync file not found"
   end
   true
   
end

#delete_remote_files ⇒ Object 



210
211
212
213
214
215
 
# File 'lib/fclay/attachment.rb', line 210

def delete_remote_files
  
  (self.class.fclay_options[:styles] || [nil]).each do |style|
    Fclay.remote_storage.bucket_object.object(remote_file_path(style)).delete
  end
end

#delete_tmp_file ⇒ Object 



136
137
138
139
 
# File 'lib/fclay/attachment.rb', line 136

def delete_tmp_file 
   FileUtils.rm(@file.try(:path) || @file[:path],{:force => true}) if @file
   @file = nil
end

#fclay_attachment_presence ⇒ Object 



79
80
81
 
# File 'lib/fclay/attachment.rb', line 79

def fclay_attachment_presence
 errors.add(:file, 'must be present') if id.blank? && !@file
end

#fetch_extension ⇒ Object 



190
191
192
193
194
195
 
# File 'lib/fclay/attachment.rb', line 190

def fetch_extension
  ext = self.class.fclay_options[:extension]
  return nil if ext == false
  return ext.to_s if ext 
  @file.original_filename.split(".").try(:last) if @file.try(:original_filename)
end

#fetch_file_name ⇒ Object 



179
180
181
182
183
184
185
186
187
188
 
# File 'lib/fclay/attachment.rb', line 179

def fetch_file_name
  
  return if self.file_name.present?
  ext = fetch_extension

  self.file_name = try(:fclay_attachment_filename)
  self.file_name = SecureRandom.hex unless self.file_name
  self.file_name += ".#{ext}" if ext
  
end

#file_size_mb ⇒ Object 



83
84
85
86
87
 
# File 'lib/fclay/attachment.rb', line 83

def file_size_mb 

  "#{((self.file_size >> 10).to_f / 1024).round(2)} Mb" if self.file_size 

end

#file_url(style = nil) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
 
# File 'lib/fclay/attachment.rb', line 89

def file_url(style=nil)
  case self.file_location
    when "external_link"
      self.file_name
    when "local"
      local_file_url(style)
    else
      remote_file_url(style)
    end
end

#local_file_dir(style = nil) ⇒ Object 



122
123
124
125
126
 
# File 'lib/fclay/attachment.rb', line 122

def local_file_dir(style=nil) 
 dir = "#{Rails.root.to_s + Fclay.configuration.local_folder}/#{self.class.name.tableize}"
 dir += "/#{style.to_s}" if style   
 dir
end

#local_file_path(style = nil) ⇒ Object 



104
105
106
107
108
 
# File 'lib/fclay/attachment.rb', line 104

def local_file_path(style=nil)

   local_file_dir(style) + "/" + file_name

end

#local_file_url(style = nil) ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/fclay/attachment.rb', line 110

def local_file_url(style=nil)
  url = Fclay.configuration.local_storage_host 
  url += "#{Fclay.configuration.local_url}/#{self.class.name.tableize}"
  url += "/#{style.to_s}" if style
  url += "/#{file_name}"
  url
end

#need_upload ⇒ Object 



41
42
43
 
# File 'lib/fclay/attachment.rb', line 41

def need_upload
  Fclay.configuration.storage_policy != :local && self.file_location == "local"
end

#process_file ⇒ Object 



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/fclay/attachment.rb', line 149

def process_file
    
  return unless @file

  delete_files

  path = @file.try(:path) || @file[:path]
  return unless path
  
  if path[0..3] == "http"
    self.file_status = 'idle'
    self.file_location = 'external_link'
    self.file_name = path
  else                
    create_dirs
    fetch_file_name

    (self.class.fclay_options[:styles] || [nil]).each do |style|  
      FileUtils.cp(path,local_file_path(style))
      `chmod 0755 #{local_file_path(style)}`
    end
    

    delete_tmp_file
    set_file_size self.class.fclay_options[:styles].try(:first)
    self.file_location = 'local'
    self.file_status = need_upload ? "processing" : "idle"
  end
end

#remote_file_path(style = nil) ⇒ Object 



128
129
130
131
132
133
134
 
# File 'lib/fclay/attachment.rb', line 128

def remote_file_path(style=nil)
  path = ""
  path += "#{self.class.name.tableize}"
  path += "/#{style.to_s}" if style
  path += "/#{file_name}"
  path    
end

#remote_file_url(style = nil) ⇒ Object 



100
101
102
 
# File 'lib/fclay/attachment.rb', line 100

def remote_file_url(style=nil)
  "http://#{Fclay.remote_storage.bucket_name}.s3.amazonaws.com/#{remote_file_path(style)}"
end

#set_file_size(style = nil) ⇒ Object 



217
218
219
 
# File 'lib/fclay/attachment.rb', line 217

def set_file_size style=nil
  self.file_size = File.size local_file_path(style)
end

#short_local_file_url(style = nil) ⇒ Object 



118
119
120
 
# File 'lib/fclay/attachment.rb', line 118

def short_local_file_url(style=nil)
  
end

#upload ⇒ Object 



51
52
53
 
# File 'lib/fclay/attachment.rb', line 51

def upload
  Fclay::Attachment.upload self.class.name,self.id
end

#upload_later ⇒ Object 



45
46
47
48
49
 
# File 'lib/fclay/attachment.rb', line 45

def upload_later
  self.try(:log,"upload_later handler")
  try(:log,"upload_later handler")
  Fclay::UploadJob.perform_later(self.class.name,self.id) if need_upload
end