Module: ActsAsElibriProduct

Extended by:
ActiveSupport::Concern
Defined in:
lib/acts_as_elibri_product.rb,
lib/acts_as_elibri_product/version.rb

Defined Under Namespace

Modules: ClassMethods

Constant Summary collapse

VERSION = 
"0.2.7"

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.set_objects_from_array(elibri_object_name, db_object_name, object_traverse_vector, elibri_objects, db_product) ⇒ Object 



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/acts_as_elibri_product.rb', line 189

def self.set_objects_from_array(elibri_object_name, db_object_name, object_traverse_vector, elibri_objects, db_product)
  if elibri_objects.is_a?(Array)
    elibri_objects.each do |elibri_object|
      db_product.send(db_object_name).build.tap do |inner_object|
    #    db_product.send
        object_traverse_vector.each_pair do |k, v|
          if v.is_a?(Hash)
            #TODO
           # set_objects_from_array(object.send(v.keys.first), v.values.first, product, k)
          else
            inner_object.send(:write_attribute, v, elibri_object.send(k))
          end
        end
      end
    end
  else
    if elibri_objects.respond_to?(:eid) && db_object_name.to_s.camelize.constantize.where(:id => elibri_objects.eid).first
      inner_object = db_object_name.to_s.camelize.constantize.where(:id => elibri_objects.eid).first #na czyms musimy polega jako na persystencji tutaj
      object_traverse_vector.each_pair do |k, v|
        if v.is_a?(Hash)
          #TODO
         # set_objects_from_array(object.send(v.keys.first), v.values.first, product, k)
        else
          inner_object.send(:write_attribute, v, elibri_objects.send(k))
        end
      end
      inner_object.save
    else
      db_product.send("build_#{db_object_name}").tap do |inner_object|
    #    db_product.send
        object_traverse_vector.each_pair do |k, v|
          if v.is_a?(Hash)
            #TODO
           # set_objects_from_array(object.send(v.keys.first), v.values.first, product, k)
          else
            inner_object.send(:write_attribute, v, elibri_objects.send(k))
          end
        end
        inner_object.save
      end
    end
  end
end

Instance Method Details

#check_policy_chain(product, object, attribute, pre, post) ⇒ Object 



185
186
187
 
# File 'lib/acts_as_elibri_product.rb', line 185

def check_policy_chain(product, object, attribute, pre, post)
  product.class.policy_chain.all? { |policy| policy.call(object, attribute, pre, post) }
end

#traverse_vector ⇒ Object 



181
182
183
 
# File 'lib/acts_as_elibri_product.rb', line 181

def traverse_vector
  ActsAsElibriProduct::ClassMethods.traverse_vector
end

#update_product_from_elibri(new_xml, tracing_object = nil) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
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
178
179
 
# File 'lib/acts_as_elibri_product.rb', line 90

def update_product_from_elibri(new_xml, tracing_object = nil)
    if (read_attribute :old_xml).blank?
      raise "Empty old_xml column on product"
    end
    product = Elibri::ONIX::Release_3_0::ONIXMessage.new(read_attribute :old_xml).products.first
    product_updated = Elibri::ONIX::Release_3_0::ONIXMessage.new(new_xml).products.first
    tracing_object.register_xml_comparission(product, product_updated) if tracing_object

    elibri_xml_versions = Elibri::XmlVersions.new(product, product_updated)
    details = elibri_xml_versions.diff
    details[:changes].each do |change|
      if change.is_a?(Symbol) && traverse_vector[change]
        if traverse_vector[change].is_a?(Array)
          if !traverse_vector[change][0].nil?
            next unless check_policy_chain(self, :product, traverse_vector[change], self.send(traverse_vector[change][0]), product_updated.send(change))
          end
          if traverse_vector[change][0].nil?
            traverse_vector[change][1].call(self, product_updated.send(change))
          else
            write_attribute(traverse_vector[change][0], traverse_vector[change][1].call(self, product_updated.send(change)))
          end
        else
          next unless check_policy_chain(self, :product, traverse_vector[change], self.send(traverse_vector[change]), product_updated.send(change))
          write_attribute(traverse_vector[change], product_updated.send(change))
        end
      elsif change.is_a?(Hash) && traverse_vector[change.keys.first]        
        change.values.first.each do |elibri_attrib|
          if elibri_attrib.is_a? Hash
            elibri_attrib.each_pair do |k,v|
              db_attrib = traverse_vector[change.keys.first].values.first[v]
              if db_attrib #found in mapping
                object = self.send(traverse_vector[change.keys.first].keys.first).find { |x| x.import_id == k }
                elibri_object = product_updated.send(change.keys.first).find { |x| x.id == k }
                if v.is_a?(Array)
                  next unless check_policy_chain(self, traverse_vector[change.keys.first].keys.first, db_attrib, object.send(db_attrib), elibri_object.send(v[0]))
                  if v[0].nil?
                    v[1].call(self, elibri_object.send(v[0]))
                  else
                    object.send(:write_attribute, db_attrib, v[1].call(self, elibri_object.send(v[0])))
                  end
                else
                  next unless check_policy_chain(self, traverse_vector[change.keys.first].keys.first, db_attrib, object.send(db_attrib), elibri_object.send(v))
                  object.send(:write_attribute, db_attrib, elibri_object.send(v))
                end
              end
            end
          else
            if traverse_vector[change.keys.first].is_a?(Array)                      #X                                                   X
              next if product.nil? || product_updated.nil? || product.send(change.keys.first).nil?
              next unless check_policy_chain(self, change.keys.first, elibri_attrib, product.send(change.keys.first).send(elibri_attrib), product_updated.send(change.keys.first).send(elibri_attrib))
              if traverse_vector[change.keys.first][0].nil?
                traverse_vector[change.keys.first][1].call(self, product_updated.send(change.keys.first))
              else
                ### TO BE IMPLEMENTED - not quite sure if this situation may and should happen
              end
            else
              db_attrib = traverse_vector[change.keys.first].values.first[elibri_attrib]
              object = self.send(traverse_vector[change.keys.first].keys.first)
              elibri_object = product_updated.send(change.keys.first)
              next unless check_policy_chain(self, traverse_vector[change.keys.first].keys.first, db_attrib, object.send(db_attrib), elibri_object.send(elibri_attrib))            
              object.send(:write_attribute, db_attrib, elibri_object.send(elibri_attrib))
            end
          end
        end
    #    read_attribute(traverse_vector[change.keys.first]).send("#{traverse_vector[change[keys.first]]}=", product_updated.send(change.keys.first).send(change[keys.first]))
      else
        #nieistotne :)
      end
    details[:deleted].each do |deleted|
      if traverse_vector[deleted.keys.first] && traverse_vector[deleted.keys.first].keys.first       
        deleted.each_pair do |dele_key, dele|
          dele.each do |del|
            self.send(traverse_vector[dele_key].keys.first).each { |x| x if x.send(traverse_vector[dele_key].values.first[:id]) == del.id }.compact.each(&:delete)
          end
        end
      end
    end
    details[:added].each do |added|
      if traverse_vector[added.keys.first] && traverse_vector[added.keys.first].keys.first
        ActsAsElibriProduct.set_objects_from_array(traverse_vector[added.keys.first], traverse_vector[added.keys.first].keys.first, traverse_vector[added.keys.first].values.first, added.values.first, self)
 #       object = self.send(traverse_vector[added.keys.first].keys.first)
#        ActsAsElibriProduct.set_objects_from_array(traverse_vector[added.keys.first].keys.fir, v.keys.first, v.values.first, product.send(k), db_product)
      end
    end
    write_attribute(:old_xml, new_xml)
    self.save
  
  end
  
end