order_zip_download_creator.rb

class OrderAssetsZipDownloadCreator

  def self.build(order_id, force = false)
    @order = Order.find(order_id)
    @force = force

    unless @order.download_zip_url.present? #prevent duplicate images from being added to zip.
      reupload_assets_with_tag
      #create_zip
    end
    @order
  end

  def self.build_and_assign_to(order_id, force = false)
    order = Order.find(order_id)
    build(order_id, force)
    order.update_attributes(download_zip_url: nil, #assigned when webook received
                            download_zip_created_at: Time.now)
  end

  private

  def self.reupload_assets_with_tag
    if @order.shopping_baskets.any?
      line_items = @order.shopping_baskets.first.line_items.order(:id)
    else
      line_items = @order.line_items.order(:id)
    end

    line_items.each do |item|
      if item.job
        explicit_job_assets(item)
      else
        explicit_product_assets(item)
      end
    end

    sleep 5.minutes

    line_items.each do |item|
      if item.job
        upload_job_assets(item)
      else
        upload_product_assets(item, line_items)
      end
    end

    upload_order_pdf
    upload_order_packing_slip_with_webhook
  end

  def self.is_last_line_item?(item)
    @order.line_items.last.id == item.id
  end

  def self.create_zip
    # if async and subsequent webhook becomes inconsistent, might need to only do async for orders with large number of line items.
    #Cloudinary::Uploader.multi(order_tag, :format => 'zip', async: true, notification_url: webhook_url('?zip_creation=true'))
  end

  def self.webhook_url(custom_params)
    "#{Website::PROTOCOL}://#{@order.website.subdomain_in_hostname}/site_manager/orders/#{@order.id}/cloudinary_webhook" + custom_params
  end

  def self.upload_order_pdf
    #begin
      Cloudinary::Uploader.upload(order_pdf_url, tags: [order_tag], public_id: "#{@order.number}_order_pdf_#{@order.id}", async: true)
    #rescue CloudinaryException
      # do nothing
    #end
  end

  def self.order_pdf_url
    if Rails.env.development? || Rails.env.test?
      "https://res.cloudinary.com/decosites/image/upload/v1415549444/Test_pdf_cfp8z8.pdf"
    else
      "https://#{@order.website.subdomain_in_hostname}/site_manager/orders/#{@order.id}/edit.pdf"
    end
  end

  def self.upload_order_packing_slip_with_webhook
    #begin
      if ['production', 'staging'].include?(Rails.env)
        sleep 5.minutes
      end
      Cloudinary::Uploader.upload(order_packing_slip_url, tags: [order_tag], public_id: "#{@order.number}_order_ps_#{@order.id}", async: true, notification_url: webhook_url('?packing_slip_uploaded=true'))
    #rescue CloudinaryException
      # do nothing
    #end
  end

  def self.order_packing_slip_url
    if Rails.env.development? || Rails.env.test?
      "https://res.cloudinary.com/decosites/image/upload/v1415549444/Test_pdf_cfp8z8.pdf"
    else
      "#{Website::PROTOCOL}://#{@order.website.subdomain_in_hostname}/site_manager/orders/#{@order.id}/edit.pdf?packing_slip=true"
    end
  end

  def self.explicit_product_assets(item)
    url = download_url(item)
    unless url =~ /fallback/ || url.nil?
      asset = parse_url(url)
      Cloudinary::Uploader.explicit(asset[:public_id], type: asset[:type], eager: {raw_transformation: asset[:transformation]}, eager_async: true)
    end
  end

  def self.explicit_job_assets(item)
    item.job.jobable.job_items.each do |job_item|
      url = download_url(job_item)
      unless url =~ /fallback/ || url.nil?
        asset = parse_url(url)
        Cloudinary::Uploader.explicit(asset[:public_id], type: asset[:type], eager: {raw_transformation: asset[:transformation]}, eager_async: true)
      end
    end
  end

  def self.upload_product_assets(item, line_items)
    url = download_url(item)
    if url =~ /fallback/ || url.nil?
      # do nothing
    else
      if @force == true
        begin
          Cloudinary::Uploader.upload(url, tags: [order_tag], public_id: product_asset_public_id(item, line_items), async: true, resource_type: :auto)  
        rescue
          # do nothing
        end
      else
        Cloudinary::Uploader.upload(url, tags: [order_tag], public_id: product_asset_public_id(item, line_items), async: true, resource_type: :auto)
      end
    end
  end

  def self.upload_job_assets(item)
    item.job.jobable.job_items.each do |job_item|
      url = download_url(job_item)
      unless url =~ /fallback/ || url.nil?
        Cloudinary::Uploader.upload(url, tags: [order_tag], public_id: job_asset_public_id(item, job_item), async: true)
      end
    end
  end

  def self.download_url(asset)
    if asset.class == LineItem
      asset.download_link
    else
      asset.image_datum.cropped? ? CropPresenter.url(asset, true) : asset.image_datum.picture_url
    end
  end

  def self.item_count(item)
    @order.line_items.order(:id).index(item) + 1
  end

  def self.job_item_count(item, job_item)
    item.job.jobable.job_items.order(:id).index(job_item) + 1
  end

  def self.order_tag
    "asf_order_#{@order.number}_#{@order.id}"
  end

  def self.product_asset_public_id(item, line_items)
    id = "#{@order.number}-#{item.id_within_order(line_items)}_#{item.product.name.parameterize}_#{item.quantity}_#{item.attrs['size']}_#{item.medium_name.try(:parameterize)}_#{item.id}"
    if Rails.env.staging?
      id = id + '-staging'
    end
    id
  end

  def self.job_asset_public_id(item, job_item)
    "#{@order.number}-#{item_count(item)}-#{job_item_count(item, job_item)}_#{job_item.picture.my_public_id}_#{job_item.size}_#{job_item.id}"
  end

  def self.parse_url(url)
    no_prefix_regex = /https:\/\/images.discerningassets.com\/image\/upload\//
    no_prefix = url.gsub(no_prefix_regex, "")
    version_regex = /v[0-9]{10}/
    transformation = no_prefix[0,no_prefix.index(version_regex)-1]
    type = url.scan(no_prefix_regex).first.gsub("https://images.discerningassets.com/image/", "")[0...-1]
    file = no_prefix[no_prefix.index(version_regex)+12..-1]
    public_id = file[0,file.index('.')]
    {public_id: public_id, transformation: transformation, type: type}
  end
end