Class: Spree::Import

Inherits:
Object
  • Object
show all
Includes:
NumberAsParam, NumberIdentifier
Defined in:
app/models/spree/import.rb

Direct Known Subclasses

Spree::Imports::Products

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.available_models ⇒ Array<Class>

Returns the available models for the import

Returns:

  • (Array<Class>) 


232
233
234
 
# File 'app/models/spree/import.rb', line 232

def available_models
  available_types.map(&:model_class)
end

.available_types ⇒ Array<Class>

Returns the available types for the import

Returns:

  • (Array<Class>) 


226
227
228
 
# File 'app/models/spree/import.rb', line 226

def available_types
  Spree.import_types
end

.model_class ⇒ Object

eg. Spree::Imports::Orders => Spree::Order

Raises:

  • (NameError) 


243
244
245
246
247
248
249
 
# File 'app/models/spree/import.rb', line 243

def model_class
  klass = "Spree::#{to_s.demodulize.singularize}".safe_constantize

  raise NameError, "Missing model class for #{to_s}" unless klass

  klass
end

.type_for_model(model) ⇒ Class

Returns the type for the model

Returns:

  • (Class) 


238
239
240
 
# File 'app/models/spree/import.rb', line 238

def type_for_model(model)
  available_types.find { |type| type.model_class.to_s == model.to_s }
end

Instance Method Details

#attachment_file_content ⇒ String

Returns the content of the attachment file

Returns:

  • (String) 


179
180
181
 
# File 'app/models/spree/import.rb', line 179

def attachment_file_content
  @attachment_file_content ||= attachment.attached? ? attachment.blob.download&.force_encoding('UTF-8') : nil
end

#complete? ⇒ Boolean

Returns true if the import is complete

Returns:

  • (Boolean) 


86
87
88
 
# File 'app/models/spree/import.rb', line 86

def complete?
  status == 'completed'
end

#create_mappings ⇒ Object

Creates mappings from the schema fields TODO: get mappings from the previous import if it exists, so user won’t have to map the same columns again



185
186
187
188
189
190
191
 
# File 'app/models/spree/import.rb', line 185

def create_mappings
  schema_fields.each do |schema_field|
    mapping = mappings.find_or_create_by!(schema_field: schema_field[:name])
    mapping.try_to_auto_assign_file_column(csv_headers)
    mapping.save!
  end
end

#create_rows_async ⇒ void

This method returns an undefined value.

Creates rows asynchronously



195
196
197
 
# File 'app/models/spree/import.rb', line 195

def create_rows_async
  Spree::Imports::CreateRowsJob.set(wait: 2.seconds).perform_later(id)
end

#csv_headers ⇒ Array<String>

Returns the headers of the csv file

Returns:

  • (Array<String>) 


168
169
170
171
172
173
174
175
 
# File 'app/models/spree/import.rb', line 168

def csv_headers
  return [] if attachment_file_content.blank?

  @csv_headers ||= ::CSV.parse_line(
    attachment_file_content,
    col_sep: preferred_delimiter
  )
end

#current_ability ⇒ Spree::Ability

Returns the current ability for the import

Returns:



219
220
221
 
# File 'app/models/spree/import.rb', line 219

def current_ability
  @current_ability ||= Spree::Dependencies.ability_class.constantize.new(user, { store: store })
end

#display_name ⇒ String

Returns the display name for the import

Returns:

  • (String) 


158
159
160
 
# File 'app/models/spree/import.rb', line 158

def display_name
  "#{Spree.t(type.demodulize.pluralize.downcase)} #{number}"
end

#import_schema ⇒ Spree::ImportSchema

Returns the import schema for the import

Returns:



102
103
104
 
# File 'app/models/spree/import.rb', line 102

def import_schema
  "Spree::ImportSchemas::#{type.demodulize}".safe_constantize.new
end

#mapped_fields ⇒ Array<String>

Returns the mapped fields for the import schema

Returns:

  • (Array<String>) 


146
147
148
 
# File 'app/models/spree/import.rb', line 146

def mapped_fields
  @mapped_fields ||= mappings.mapped.where(schema_field: required_fields)
end

#mapping? ⇒ Boolean

Returns true if the import is in mapping state

Returns:

  • (Boolean) 


74
75
76
 
# File 'app/models/spree/import.rb', line 74

def mapping?
  status == 'mapping'
end

#mapping_done? ⇒ Boolean

Returns true if the mapping is done

Returns:

  • (Boolean) 


152
153
154
 
# File 'app/models/spree/import.rb', line 152

def mapping_done?
  mapped_fields.count == required_fields.count
end

#model_class ⇒ Class

Returns the model class for the import

Returns:

  • (Class) 


92
93
94
95
96
97
98
 
# File 'app/models/spree/import.rb', line 92

def model_class
  if type == 'Spree::Imports::Customers'
    Spree.user_class
  else
    "Spree::#{type.demodulize.singularize}".safe_constantize
  end
end

#process_rows_async ⇒ void

This method returns an undefined value.

Processes rows asynchronously



201
202
203
 
# File 'app/models/spree/import.rb', line 201

def process_rows_async
  Spree::Imports::ProcessRowsJob.perform_later(id)
end

#processing? ⇒ Boolean

Returns true if the import is processing or completed mapping

Returns:

  • (Boolean) 


80
81
82
 
# File 'app/models/spree/import.rb', line 80

def processing?
  ['processing', 'completed_mapping'].include?(status)
end

#required_fields ⇒ Array<String>

Returns the required fields for the import schema

Returns:

  • (Array<String>) 


140
141
142
 
# File 'app/models/spree/import.rb', line 140

def required_fields
  import_schema.required_fields
end

#row_processor_class ⇒ Class

Returns the row processor class for the import

Returns:

  • (Class) 


108
109
110
 
# File 'app/models/spree/import.rb', line 108

def row_processor_class
  "Spree::ImportRowProcessors::#{type.demodulize.singularize}".safe_constantize
end

#schema_fields ⇒ Array<Hash>

Returns the fields for the import schema If model supports metafields, it will include the metafield definitions for this model

Returns:

  • (Array<Hash>) 


115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'app/models/spree/import.rb', line 115

def schema_fields
  base_fields = import_schema.fields

  # Dynamically add metafield definitions if the model supports metafields
  if model_class_supports_metafields?
    metafield_fields = metafield_definitions_for_model.map do |definition|
      {
        name: definition.csv_header_name,
        label: definition.name
      }
    end
    base_fields + metafield_fields
  else
    base_fields
  end
end

#send_import_completed_email ⇒ Object 



162
163
164
 
# File 'app/models/spree/import.rb', line 162

def send_import_completed_email
  # Spree::ImportMailer.import_done(self).deliver_later
end

#store ⇒ Spree::Store

Returns the store for the import

Returns:



207
208
209
 
# File 'app/models/spree/import.rb', line 207

def store
  owner.is_a?(Spree::Store) ? owner : owner.respond_to?(:store) ? owner.store : Spree::Store.default
end

#unmapped_file_columns ⇒ Array<String>

Returns the file columns that are not mapped

Returns:

  • (Array<String>) 


134
135
136
 
# File 'app/models/spree/import.rb', line 134

def unmapped_file_columns
  csv_headers.reject { |header| mappings.mapped.exists?(file_column: header) }
end

#update_loader_in_import_view ⇒ Object 



211
212
213
214
215
 
# File 'app/models/spree/import.rb', line 211

def update_loader_in_import_view
  return unless defined?(broadcast_update_to)

  broadcast_update_to "import_#{id}_loader", target: 'loader', partial: 'spree/admin/imports/loader', locals: { import: self }
end