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>) 


241
242
243
 
# File 'app/models/spree/import.rb', line 241

def available_models
  available_types.map(&:model_class)
end

.available_types ⇒ Array<Class>

Returns the available types for the import

Returns:

  • (Array<Class>) 


235
236
237
 
# File 'app/models/spree/import.rb', line 235

def available_types
  Spree.import_types
end

.model_class ⇒ Object

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

Raises:

  • (NameError) 


252
253
254
255
256
257
258
 
# File 'app/models/spree/import.rb', line 252

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

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

  klass
end

.type_for_model(model) ⇒ Class

Returns the type for the model

Returns:

  • (Class) 


247
248
249
 
# File 'app/models/spree/import.rb', line 247

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) 


186
187
188
 
# File 'app/models/spree/import.rb', line 186

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) 


93
94
95
 
# File 'app/models/spree/import.rb', line 93

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



192
193
194
195
196
197
198
 
# File 'app/models/spree/import.rb', line 192

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



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

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>) 


175
176
177
178
179
180
181
182
 
# File 'app/models/spree/import.rb', line 175

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:



224
225
226
 
# File 'app/models/spree/import.rb', line 224

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

#display_name ⇒ String

Returns the display name for the import

Returns:

  • (String) 


165
166
167
 
# File 'app/models/spree/import.rb', line 165

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

#event_serializer_class ⇒ Object 



228
229
230
 
# File 'app/models/spree/import.rb', line 228

def event_serializer_class
  Spree::Events::ImportSerializer
end

#import_schema ⇒ Spree::ImportSchema

Returns the import schema for the import

Returns:



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

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>) 


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

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) 


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

def mapping?
  status == 'mapping'
end

#mapping_done? ⇒ Boolean

Returns true if the mapping is done

Returns:

  • (Boolean) 


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

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

#model_class ⇒ Class

Returns the model class for the import

Returns:

  • (Class) 


99
100
101
102
103
104
105
 
# File 'app/models/spree/import.rb', line 99

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



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

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) 


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

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

#publish_import_completed_event ⇒ Object 



169
170
171
 
# File 'app/models/spree/import.rb', line 169

def publish_import_completed_event
  publish_event('import.completed')
end

#required_fields ⇒ Array<String>

Returns the required fields for the import schema

Returns:

  • (Array<String>) 


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

def required_fields
  import_schema.required_fields
end

#row_processor_class ⇒ Class

Returns the row processor class for the import

Returns:

  • (Class) 


115
116
117
 
# File 'app/models/spree/import.rb', line 115

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>) 


122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'app/models/spree/import.rb', line 122

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

#store ⇒ Spree::Store

Returns the store for the import

Returns:



214
215
216
217
218
219
220
 
# File 'app/models/spree/import.rb', line 214

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

#unmapped_file_columns ⇒ Array<String>

Returns the file columns that are not mapped

Returns:

  • (Array<String>) 


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

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