Module: FileFolder::ClassMethods

Defined in:
lib/file_folder.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#file_field ⇒ Object

Returns the value of attribute file_field.



10
11
12
 
# File 'lib/file_folder.rb', line 10

def file_field
  @file_field
end

#file_folder_repository ⇒ Object

Returns the value of attribute file_folder_repository.



11
12
13
 
# File 'lib/file_folder.rb', line 11

def file_folder_repository
  @file_folder_repository
end

#file_formats ⇒ Object

Returns the value of attribute file_formats.



12
13
14
 
# File 'lib/file_folder.rb', line 12

def file_formats
  @file_formats
end

#filefield_flag ⇒ Object

Returns the value of attribute filefield_flag.



9
10
11
 
# File 'lib/file_folder.rb', line 9

def filefield_flag
  @filefield_flag
end

Instance Method Details

#file_folder_enabled? ⇒ Boolean

Getter to check if model is enabled with file_folder

Returns:

  • (Boolean) 


15
16
17
 
# File 'lib/file_folder.rb', line 15

def file_folder_enabled?
  @filefield_flag.nil? ? false : @filefield_flag
end

#file_folder_field(file_field, options = {}) ⇒ Object

Generates file field from file_field arguments and provides methods like if file_field is “assignment” then it provides methods on top of it as



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/file_folder.rb', line 21

def file_folder_field(file_field, options = {})
  if options.is_a?(Hash)
    @file_formats ||= {}
    @file_formats[file_field] = options[:formats].is_a?(Array) ? options[:formats].collect { |x| x.starts_with?(".") ? x : ".#{x}" } : [".txt", ".docx", ".jpeg", ".pdf"]
  else
    raise "InvalidArguments"
  end
  @file_field ||=[]
  @file_field << file_field
  send(:after_save, "#{file_field}_store!")
  send(:after_destroy, "#{file_field}_destroy!")

  define_method "#{file_field}" do
    @ff_file_buffer.nil? ? (send("#{file_field}_persisted?") ? File.read(send("#{file_field}_path")) : nil) : @ff_file_buffer
  end

  define_method "#{file_field}?" do
    send("#{file_field}").nil? ? false : true
  end

  define_method "#{file_field}=" do |file_upload|
    if file_upload.class == ActionDispatch::Http::UploadedFile
      return false unless self.class.file_formats[file_field].include?(File.extname(file_upload.original_filename).downcase)
      @ff_file_buffer = File.read(file_upload.path)
      @ff_file_ofn = File.basename(file_upload.original_filename).gsub(/[^a-zA-Z0-9\-\._]+/, '_')
    elsif file_upload.class == File
      return false unless self.class.file_formats[file_field].include?(File.extname(file_upload.path).downcase)
      @ff_file_buffer = file_upload.read
      @ff_file_ofn = File.basename(file_upload.path).gsub(/[^a-zA-Z0-9\-\._]+/, '_')
    elsif file_upload.class == String
      #return false unless self.class.file_formats.include?(File.extname(file_upload).downcase)
      @ff_file_buffer = file_upload
      #@ff_file_ofn = File.basename(file_upload.path) #As there is nothing like original_file_name for a string :)
    end
  end

  define_method "#{file_field}_path" do
    FileUtils.mkdir_p File.join(self.class.file_folder_repository, [id.to_s, self.class.name.underscore].join('_'), "#{self.version}_version")
  end

  define_method "#{file_field}_path_to_write" do
    #directoy_path = FileUtils.mkdir_p File.join(self.class.file_folder_repository, self.id.to_s, file_field.to_s)
    File.join(send("#{file_field}_path"), "#{self.version}V_" + @ff_file_ofn)
  end

  define_method "#{file_field}_persisted?" do
    (@ff_file_buffer.nil? and File.file?(send("#{file_field}_path")))
  end

  define_method "#{file_field}_store!" do
    return unless self.class.file_folder_enabled?
    unless @ff_file_buffer.nil?
      _path_to_write = send("#{file_field}_path_to_write")
      File.delete(_path_to_write) if File.exist?(_path_to_write) #Clearing any existing existence
      File.open(_path_to_write, "wb+") { |f| f.puts(@ff_file_buffer) }
      @ff_file_buffer = nil
      @ff_file_ofn = nil
      send("#{file_field}_url=", _path_to_write)
      self.try(:save_update)
    end
  end

  define_method "#{file_field}_destroy!" do
    return unless self.class.file_folder_enabled?
    @ff_file_buffer = nil
    # File.delete(send("#{file_field}_path")) if File.exist?(send("#{file_field}_path"))
  end

  @filefield_flag = true
end