daengine 0.6.5 → 0.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1307c12bc6d6907c72f5985d9519bca1e532b5c7
-  data.tar.gz: f4b9461b14b518793d2958deebe457d3ae39a4e5
+  metadata.gz: c01b062e993cb4a3d66b78c1d9455434ead7bfae
+  data.tar.gz: 08dbdaa04cd104f02a1640d1e1cac4ea6664d310
 SHA512:
-  metadata.gz: 88cb9262ca2120859e79815145dc52e10dc84a302d2787df20716409cf66e2629c909d7975b9077a9ad53b5f54ef695b5c1daf875f04fa3075af4ef66e6a52f9
-  data.tar.gz: c916597be65b4a725b0a11c2c546c28272ed2cd842795ee4db9c6a20b8c2c59f6784acccf88c2a7e7f8a09d53d2c02f566dee86edbc6afa818704115b0b894ea
+  metadata.gz: f2230266e28c55ca21829cd95f033db67d9357dfe94aa816ff4c7f13ee3bc2ec20066d0384c9124707069b5dea236102a7d6bea52949606c9e9ca459241e67be
+  data.tar.gz: 1875ea1715d7f2959f533567dea207f11312c42f86c4e55dad64168c472969f47ba2516991f2fd8b75ac281c618e747b8f97a177ef5cc2dddca0e30af353c7f2

data/Rakefile

@@ -32,3 +32,5 @@ load "#{spec.gem_dir}/lib/tasks/docs.rake"
 
 Bundler::GemHelper.install_tasks
 
+import 'lib/tasks/daengine_tasks.rake'
+

data/app/controllers/digital_assets_controller.rb

@@ -13,8 +13,10 @@ class DigitalAssetsController < ApplicationController
   #/digital_assets/search/sami_code=92023
   #/digital_assets/search/sami_code=NE00192&title=Fund%20Prospectus&fund_code=20293
   def index
-    @digital_assets = request.query_parameters.present? ? search_da(request.query_parameters) : DigitalAsset.all
-    respond_with(@digital_assets)
+    search_params = params[:search] || request.query_parameters
+    @digital_assets = search_params ? search_da(search_params) : DigitalAsset.all
+    # respond_with(@digital_assets)
+    render json: @digital_assets
   end
   alias :search :index
 

data/app/models/digital_asset.rb

@@ -23,6 +23,8 @@ class DigitalAsset
   field :legacy_path, type: String
   field :doc_changed_at, type: DateTime 
   field :content_type, type: String
+  alias :doctype :content_type
+  alias :doctype_id :content_type
   field :pages, type: Integer, default: 1
   field :size, type: String
   field :mime_type, type: String
@@ -40,13 +42,13 @@ class DigitalAsset
 
 
   #Exclude XBRL documents from all queries
-  # default_scope excludes(:'content_type' => "LDJDCMAIK") #Had to use static value instead of a Constant
+  default_scope excludes(:'content_type' => "LDJDCMAIK") #Had to use static value instead of a Constant
 
   scope :title_is, ->(title) { where(:title => title)}
   scope :business_owner_is, ->(business_owner) { where(:business_owner => business_owner)}
   scope :guid_is, ->(guid) { where(:guid => guid)}
   scope :digital_asset_id_is, ->(id) { where(:digital_asset_id => id)}
-  scope :fund_in, ->(fund_code) {where(:fund_codes.in => fund_code)}
+  scope :fund_in, ->(fund_codes) {where(:fund_codes.in => fund_codes)}
   scope :audience_in, ->(audience_id) {where(:audiences.in => audience_id)}
   scope :audience_investor_approved, -> {where(:audiences.in => [Audience::INVESTOR_APPROVED])}
 
@@ -157,12 +159,9 @@ class DigitalAsset
   #   pid and TaxonomyTerm.term_id_is(pid)[0].try(:fund_code).try(:rjust, 5, '0')
   # end
 
-  def content_type
+  def content_type_label
     TaxonomyTerm.label_for_term(content_type_id)
   end
-  def content_type_id
-   :content_type
-  end
 
   def audience
     TaxonomyTerm.label_for_term(audiences[0])

data/app/models/service_digital_asset.rb

@@ -0,0 +1,112 @@
+require 'time'
+require 'active_record'
+require 'activerecord-tableless'
+
+class ServiceDigitalAsset < ActiveRecord::Base
+  has_no_table
+
+  column :title, :string
+  column :changed_at, :time
+  column :audiences, :array, []
+  column :sami_code, :string
+  column :product_ids, :array, []
+  column :published_at, :time
+  column :unpublished_at, :time
+  column :expires_at, :time
+  column :guid, :string
+  column :business_owner, :string
+  column :summary, :string
+  column :content_organization_ids, :array, []
+  column :program_ids, :array, []
+
+  column :omniture_codes, :array, []
+  column :orderable, :boolean, false
+  # refactor version:
+  column :path, :string
+  column :legacy_path, :string
+  column :doc_changed_at, :time
+  column :content_type, :string
+  column :pages, :integer, 0
+  column :size, :string
+  column :mime_type, :string
+  column :subject, :string
+  column :keywords, :array, []
+  column :author, :string
+  column :finra_path, :string
+  column :fund_codes, :array, []
+  column :display_on_website, :boolean
+  column :digital_asset_id, :string
+
+  validates_presence_of :digital_asset_id, :title, :changed_at, :published_at,
+                        :expires_at, :audiences, :path
+  validate :validate_future_expiration
+
+  def validate_future_expiration
+    errors.add(:expires_at, 'Expiration date must be at least 1 minute from now') unless expires_at and expires_at > 1.minute.from_now
+  end
+
+  def effective?
+    display_on_website  && !expires_at.blank?
+  end
+
+  def expired?
+    expires_at.nil? ||  expires_at < 1.minute.from_now
+  end
+
+  def finra?
+    DigitalAsset::ContentType::FINRA == content_type
+  end
+
+  def manifest_file?
+    path.match('\/manifest\/')
+  end
+
+  def file_name
+    path.split('/').last
+  end
+
+  def delete?
+    !(unpublished_at.nil?) || expired?
+  end
+
+  def mark_for_deletion
+    # not sure why unpublished_at = value didn't work in spec
+    write_attribute(:unpublished_at, DateTime.now)
+  end
+
+  def as_hash
+    hash = attributes
+    # remove the file attribute fields that have default values
+    #   as the service won't update them if they aren't in the data being sent over
+    %w(pages size mime_type subject keywords author).each do |field_name|
+      hash.delete(field_name) if hash[field_name] == ServiceDigitalAsset.default_value(field_name)
+    end
+    # convert the times to strings unless they are nil
+    %w(changed_at published_at unpublished_at expires_at doc_changed_at).each do |field_name|
+      hash[field_name] = hash[field_name].to_s unless hash[field_name].nil?
+    end
+    # service expects 'digital_asset' not 'service_digital_asset'
+    {'digital_asset' => hash}
+  end
+
+  def default_blank_time(time_field)
+    time = send(time_field.to_sym)
+    time.blank? ? 10.years.ago : time
+  end
+
+  def self.boolean_field?(field_name)
+    columns_hash[field_name].sql_type == 'boolean'
+  end
+
+  def self.time_field?(field_name)
+    %w(time datetime).include?(columns_hash[field_name].sql_type)
+  end
+
+  def self.array_field?(field_name)
+    columns_hash[field_name].sql_type == 'array'
+  end
+
+  def self.default_value(field_name)
+    column_defaults[field_name]
+  end
+end

data/app/service/digital_asset_lookup_service.rb

@@ -17,7 +17,7 @@ class DigitalAssetLookupService
   # end
 
   def self.fund_code_from_id(taxonomy_id)
-    TaxonomyTerm.term_id_is(taxonomy_id).try(:term_type).try([], 'FUND_CODE')
+    TaxonomyTerm.term_id_is(taxonomy_id).first.try(:term_type).try(:[], 'FUND_CODE')
   end
 
   # def self.term_id_from_fund_code(code) 
@@ -44,7 +44,7 @@ class DigitalAssetLookupService
   #   query[:product_ids.in] = product_ids if !product_ids.blank?
   #   query[:'documents.content_type'.in] = content_type_ids if !content_type_ids.blank?
   #   query[:audiences.in] = audience_ids if !audience_ids.blank?
-  
+
   #   digital_assets = DigitalAsset.where(query)
   #   digital_assets = digital_assets.select {|d| d.has_finra?} if finra
   #   digital_assets

data/bin/process_assets

@@ -1,15 +1,17 @@
-#!/usr/bin/env ruby
-#
-# This file was generated by Bundler.
-#
-# The application 'process_assets' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'daengine'
-
-config = YAML.load_file(ARGV[0])
-
-t = Daengine.execute(config)
-
-puts t
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'process_assets' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'daengine'
+
+puts "***** #{RUBY_VERSION}"
+
+config = YAML.load_file(ARGV[0])
+
+t = Daengine.execute(config)
+
+puts t

data/config/routes.rb

@@ -3,6 +3,7 @@ Rails.application.routes.draw do
     collection do
       get 'fund_docs'
       get 'search', to: 'digital_assets#search'
+      post 'search', to: 'digital_assets#search'
       post 'updated_time'
     end
   end

data/lib/daengine.rb

@@ -4,7 +4,8 @@ require 'daengine/railtie' if defined?(Rails)
 require File.expand_path('../../app/models/digital_asset',__FILE__)
 require File.expand_path('../../app/models/teamsite_digital_asset_shim',__FILE__)
 require File.expand_path('../../app/models/taxonomy_term',__FILE__)
-require File.expand_path('../../app/models/content_service_resource',__FILE__)
+require File.expand_path('../../app/models/service_digital_asset',__FILE__)
+require File.expand_path('../../app/service/digital_asset_lookup_service',__FILE__)
 require 'mini_exiftool'
 require 'daengine/teamsite_metadata_parser'
 require 'daengine/digital_asset_processor'
@@ -20,7 +21,8 @@ module Daengine
   @config = {
       :assets_path => '/digital-assets',
       :taxonomy_xml_filepath => '/taxonomy.xml',
-      :content_service_url => 'http://ofiwsqa.den.ofi.com/'
+      :content_service_url => 'http://ofiwsqa.den.ofi.com/',
+      :disable_file_check => false
   }
 
   @mongoid_config = {

data/lib/daengine/digital_asset_processor.rb

@@ -1,3 +1,6 @@
+#require File.expand_path("../teamsite_metadata_processor", __FILE__)
+require 'daengine/teamsite_metadata_processor'
+
 module Daengine
   class DigitalAssetProcessor
 
@@ -35,13 +38,16 @@ module Daengine
               file = File.expand_path(filename, path)
               Daengine.log("DigitalAssetProcessor: Processing file #{filename} --- #{File.mtime(file)}", "info")
               open_file = File.open(file, 'rb')
-              Daengine::TeamsiteMetadataParser.parse_tuple_file(open_file, last_run_time)
-              Daengine.log("DigitalAssetProcessor: Finished processing #{filename}", "info")
+              #Daengine::TeamsiteMetadataParser.parse_tuple_file(open_file, last_run_time)
+              #Daengine.log("DigitalAssetProcessor: Finished processing #{filename}", "info")
+              Daengine::TeamsiteMetadataProcessor.process_tuple_file(open_file, last_run_time)
+              Daengine.log("TeamsiteMetadataProcessor: Finished processing #{filename}", "info")
               @@last_read_time = File.mtime(file) + 1.second
               self.save_last_read_time
               Daengine.log("DigitalAssetProcessor: Last process time set to #{@@last_read_time}", "info")
             rescue
               Daengine.log("Unable to process file #{filename}, #{$!.message}", "error")            
+              Daengine.log($!.backtrace.join, "error")
             end
           end
         end

data/lib/daengine/http_client.rb

@@ -0,0 +1,99 @@
+#
+# Lifted from eDist Gateway::HTTP::Client
+#
+require 'httparty'
+
+module Daengine
+  module HTTP
+    module Client
+      SLOW_CALL_THRESHOLD = 5
+      # Available options
+      #   :timeout => Timeout is specified in seconds.
+      #   :headers - contains string hash such has content-type: {'content-type' => 'application/xml'}
+      #   :body => Body to post.
+      #
+      def self.call(path, options = {})
+        begin
+          method = options.delete(:method) || :get
+
+          htoptions = {}
+          htoptions[:timeout] = options.delete(:timeout) || 10
+          headers = options.delete(:headers) || {}
+          headers['rake_task_name'] = (Thread.current[:rake_task_name] || 'unknown').to_s
+          headers['visitor_id'] = (Thread.current[:visitor_id] || 'unknown').to_s
+          headers['uuid'] ||= (Thread.current[:uuid] || 'unknown').to_s
+          htoptions[:headers] = headers
+
+          case method
+            when :get
+              query = options[:query] || options[:parameters] || options
+              htoptions[:query] = query unless query.blank?
+            when :post, :put, :delete
+              htoptions[:query] = options[:query] if options[:query]
+              body = options[:body] || options[:parameters] || options
+              htoptions[:body] = body
+            else
+              raise ArgumentError.new('you must specify a method of either :get, :post, :put, or :delete')
+          end
+
+          start = Time.now
+          resp = HTTParty.send(method.to_sym, path, htoptions)
+          elapsed = Time.now - start
+          Daengine.log("***** Daengine::HTTP::Client.call(#{method}, #{path}, #{htoptions}) TOOK #{elapsed} seconds +++++++++++++++++++++",
+                       elapsed > SLOW_CALL_THRESHOLD ? 'warn' : 'info')
+
+        rescue => ex
+          Daengine.log("Error calling service (#{path}) - #{ex.inspect}\n#{ex.backtrace.join("\n\t")}", 'error')
+          #raise ex
+        end
+        Response.new(resp)
+      end
+    end
+
+    class Response
+      def initialize(response)
+        @resp = response
+      end
+
+      def headers
+        @resp.headers
+      end
+
+      def body
+        @resp.body
+      end
+
+      def status
+        @resp.code
+      end
+
+      def as_hash
+        @resp.parsed_response
+      end
+
+      alias :code :status
+      alias :status_code :status
+
+      def success?
+        !!(status.to_s =~ /^2/)
+      end
+
+      def failed?
+        !success?
+      end
+
+      def server_error?
+        !!(status.to_s =~ /^5/)
+      end
+
+      def client_error?
+        !!(status.to_s =~ /^4/)
+      end
+
+      def redirection?
+        !!(status.to_s =~ /^3/)
+      end
+    end
+
+  end
+end

data/lib/daengine/teamsite_metadata_processor.rb

@@ -0,0 +1,315 @@
+require 'nokogiri'
+require 'mini_exiftool'
+require 'daengine/http_client'
+
+module Daengine
+  module TeamsiteMetadataProcessor
+
+    def self.process_tuple_file(file, last_read = nil)
+      verify_pre_conditions
+
+      time do
+        assets = parse_file(file)
+        assets = select_1_asset_per_id(assets)
+        assets = add_file_attributes(assets, last_read) unless Daengine.config[:disable_file_check]
+        assets = add_fund_codes(assets)
+        summary = call_service(assets)
+        Daengine.log("***** Summary = #{summary.inspect}", 'info')
+      end
+    rescue => ex
+      Daengine.log("Error processing XML file - #{ex.inspect}", 'error')
+      Daengine.log(ex.backtrace.join, 'error')
+    end
+
+    def self.verify_pre_conditions
+      path = Daengine.config[:digital_assets_file_directory]
+      raise "Unable to locate digital assets at #{path}" unless File.directory?(path) || Daengine.config[:disable_file_check]
+
+      service_uri = Daengine.config[:digital_asset_service_url]
+      raise 'No digital asset service URL set' if service_uri.blank?
+    end
+
+    def self.parse_file(file)
+puts "----- Parsing the file -----"
+      document = Document.new
+      Nokogiri::XML::SAX::Parser.new(document).parse(file)
+      Daengine.log("Nokogiri Parser complete...", "info")
+      document.assets
+    end
+
+    def self.select_1_asset_per_id(assets)
+      results = {}
+      assets.each do |key, values|
+puts "----- select_1 #{key} -----"
+        list = values.find_all { |v| v.effective? }
+        asset = most_recent_non_expired(list)
+        asset.finra_path = finra_path(list) unless asset.nil?
+        results[key] = asset unless asset.nil?
+      end
+      results
+    end
+
+    def self.add_file_attributes(assets, last_read)
+      results = {}
+      assets.each do |key, asset|
+        begin
+puts "----- add_file #{key} -----"
+          file_name = asset_file_name(asset)
+          asset.mark_for_deletion unless File.file?(file_name)
+
+          set_asset_file_attributes(file_name, asset, last_read) unless asset.delete?
+
+          results[key] = asset
+        rescue => ex
+          Daengine.log("***** Error processing asset with file name = #{asset.path} - #{ex.inspect}", 'error')
+        end
+      end
+      results
+    end
+
+    def self.add_fund_codes(assets)
+      results = {}
+      assets.each do |key, asset|
+puts "----- add_fund_codes #{key} -----"
+        fund_codes = []
+        asset.product_ids.each do |product_id|
+          fund_code = DigitalAssetLookupService.fund_code_from_id(product_id)
+          fund_codes << fund_code.strip.rjust(5, '0') unless fund_code.blank?
+        end
+        asset.fund_codes = fund_codes unless fund_codes.empty?
+        results[key] = asset
+      end
+      results
+    end
+
+    def self.call_service(assets)
+      results = {:errors => 0, :updated => 0, :deleted => 0}
+      assets.each_value do |asset|
+        begin
+puts "----- call_service #{asset.digital_asset_id} -----"
+          if asset.delete?
+            path = "#{service_uri}/#{asset.digital_asset_id}"
+            options = {:method => :delete, :headers => header}
+            operation = :deleted
+          else
+            path = "#{service_uri}"
+            options = {:method => :post,
+                       :query => asset.as_hash,
+                       :headers => header}
+            operation = :updated
+          end
+
+          response = Daengine::HTTP::Client.call(path, options)
+          results[operation] += 1 if response.success?
+          results[:errors] += 1 unless response.success?
+        rescue => ex
+          Daengine.log("***** Error calling service for #{asset.inspect} - #{ex.inspect}", 'error')
+          results[:errors] += 1
+        end
+      end
+      results
+    end
+
+    def self.time
+      start = Time.now
+      yield
+      Daengine.log("***** Elapsed time was #{Time.now - start}", 'info')
+    end
+
+
+    def self.most_recent_non_expired(list)
+      list.inject do |previous, current|
+        prev_published_at = previous.default_blank_time(:published_at)
+        current_published_at = current.default_blank_time(:published_at)
+        !current.expired? &&
+            !current.manifest_file? &&
+            !current.finra? &&
+            current_published_at >= prev_published_at ? current : previous
+      end
+    end
+
+    def self.finra_path(list)
+      finra = list.find { |value| value.finra? }
+      finra.try(:path)
+    end
+
+    def self.asset_file_name(asset)
+      name = File.join(file_directory, asset.path)
+      name = File.join(file_directory, asset.file_name) unless File.exists?(name)
+      name
+    end
+
+    def self.set_asset_file_attributes(file_name, asset, last_read)
+      if File.mtime(file_name) > last_read
+        update_asset_file_attributes(file_name, asset)
+      end
+    end
+
+    def self.update_asset_file_attributes(file_name, asset)
+      exifdata = ::MiniExiftool.new(file_name)
+      pages = exifdata.pagecount
+      pages = exifdata.pages if pages.blank?
+      pages = exifdata.slides if pages.blank?
+      asset.pages = pages
+      asset.size = exifdata.filesize
+      asset.mime_type = exifdata.mimetype
+      asset.author = exifdata.author
+      if exifdata.keywords.is_a? Enumerable
+        asset.keywords = exifdata.keywords
+      else
+        asset.keywords = exifdata.keywords.gsub(';', ',').gsub(':', ',').split(',') unless exifdata.keywords.nil?
+      end
+      if exifdata.description.is_a? Enumerable
+        asset.subject = exifdata.description.join(' ') unless exifdata.description.nil?
+      else
+        asset.subject = exifdata.description.gsub(':', '') unless exifdata.description.nil?
+      end
+    end
+
+    def self.header
+      {'Accept' => 'application/json',
+       'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+       'User-Agent' => 'Ruby'}
+    end
+
+    def self.service_uri
+      Daengine.config[:digital_asset_service_url]
+    end
+
+    def self.file_directory
+      Daengine.config[:digital_assets_file_directory]
+    end
+  end
+
+
+  class Document < Nokogiri::XML::SAX::Document
+    DATA_TUPLE_ELEMENT = 'data-tuple'
+    TUPLE_FIELD_ELEMENT = 'tuple-field'
+    NAME_ATTRIBUTE = 'name'
+
+    # Teamsite Date example:  Dec 29 2008 12:00:00:000AM
+    TIME_FORMAT = '%b %d %Y %k:%M:%S:%L%p'
+
+    TRANSLATION = {
+        'TeamSite/Metadata/rttTitle' => 'title',
+        'TeamSite/Metadata/enterprise_last_updated_date' => 'changed_at',
+        'TeamSite/Metadata/enterprise_audience_id' => 'audiences',
+        'TeamSite/Metadata/enterprise_sami_desc' => 'sami_code',
+        'TeamSite/Metadata/enterprise_last_publication_date' => 'published_at',
+        'TeamSite/Metadata/enterprise_unpublish_date' => 'unpublished_at',
+        'TeamSite/Metadata/enterprise_expiration_date' => 'expires_at',
+        #'TeamSite/Metadata/enterprise_guid' => 'guid',
+        'TeamSite/Metadata/enterprise_guid' => 'digital_asset_id',
+        'TeamSite/Metadata/shortSynopsis' => 'summary',
+        'TeamSite/Metadata/business_owner' => 'business_owner',
+        'TeamSite/Metadata/enterprise_product_id' => 'product_ids',
+        'TeamSite/Metadata/enterprise_content_organization_id' => 'content_organization_ids',
+        'TeamSite/Metadata/enterprise_program_id' => 'program_ids',
+        'TeamSite/Metadata/omnitureSiteSection_codes' => 'omniture_codes',
+        'TeamSite/Metadata/display_on_website' => 'display_on_website',
+        'path' => 'path',
+        'TeamSite/Metadata/enterprise_last_content_update_date' => 'doc_changed_at',
+        'TeamSite/Metadata/enterprise_content_type_id' => 'content_type'
+    }
+
+    def initialize
+      @asset = nil
+      @field_name = nil
+      @text = ''
+      @assets = {}
+    end
+
+    def assets
+      @assets
+    end
+
+    def start_element(name, attrs = [])
+      case name
+        when DATA_TUPLE_ELEMENT
+          @asset = ::ServiceDigitalAsset.new
+          @field_name = nil
+        when TUPLE_FIELD_ELEMENT
+          @field_name = translate_field_name(name_attr_value(attrs))
+      end
+
+      @text = ''
+    end
+
+    def characters(string)
+      @text << string
+    end
+
+    def end_element(name)
+      case name
+        when DATA_TUPLE_ELEMENT
+          @assets[@asset.digital_asset_id] = [] if @assets[@asset.digital_asset_id].nil?
+          @assets[@asset.digital_asset_id] << @asset
+          @asset = nil
+        when TUPLE_FIELD_ELEMENT
+          unless @field_name.nil?
+            value = convert_value(@field_name, @text)
+            setter_name = "#{@field_name}=".to_sym
+            @asset.send(setter_name, value) if @asset.respond_to?(setter_name)
+          end
+      end
+
+      @field_name, @text = nil, ''
+    end
+
+    def error(string)
+      Daengine.log("***** Parse error - #{string} *****", 'error')
+    end
+
+    def warning(string)
+      Daengine.log("***** Parse warning - #{string} *****", 'warn')
+    end
+
+
+    def convert_value(field_name, string)
+      begin
+        return convert_to_boolean(string) if boolean_field?(field_name)
+        return convert_to_datetime(string) if datetime_field?(field_name)
+        return convert_to_array(string) if array_field?(field_name)
+      rescue => ex
+        Daengine.log("***** convert-value('#{field_name}', '#{string}') - #{ex.inspect}", 'error')
+      end
+
+      string
+    end
+
+    def boolean_field?(field_name)
+      ::ServiceDigitalAsset.boolean_field?(field_name)
+    end
+
+    def datetime_field?(field_name)
+      ::ServiceDigitalAsset.time_field?(field_name)
+    end
+
+    def array_field?(field_name)
+      ::ServiceDigitalAsset.array_field?(field_name)
+    end
+
+    def convert_to_boolean(string)
+      !!(string =~ /Y|1|true/)
+    end
+
+    def convert_to_datetime(string)
+      Time.strptime(string, TIME_FORMAT) unless string.blank?
+    end
+
+    def convert_to_array(string)
+      string.try(:split, ',')
+    end
+
+    def name_attr_value(attrs)
+      unless attrs.nil?
+        hash = Hash[*attrs.flatten]
+        hash[NAME_ATTRIBUTE]
+      end
+    end
+
+    def translate_field_name(name)
+      TRANSLATION[name]
+    end
+  end
+end