Ruby on rails problema con il Paperclip durante il caricamento a s3

Question

Ho un modello di registrazione e di controllo:

require 'open-uri' 
class Record < ActiveRecord::Base 

    has_attached_file :record, 
        :s3_protocol => :https, 
        :url => ':s3_domain_url', 
        :path => '/record/latest/:basename.:extension' 

    has_attached_file :archive_record, 
        :s3_protocol => :https, 
        :url => ':s3_domain_url', 
        :path => '/record/archive/:basename.:extension' 
end 


class RecordsController < ApplicationController 
    def upload_record 
    @error = nil 
    previous_record = Record.where(:is_archive => false).first 
    @new_record = Record.new(record_params) 
    if @new_record.save 
     unless previous_record.blank? 
     if create_archive(previous_record) 
      previous_record.destroy 
     end 
     end 
     @success = I18n.t('record.success.record_uploaded') 
    else 
     @error = find_error(@new_record) 
    end 

    respond_to do |format| 
     format.js { 
     render :layout => false 
     } 
    end 
    end 

    def change_record 
    previous_record = Record.where(:is_archive => false).first 
    archive_record = Record.where(:id => params[:id]).first 
    if create_archive(previous_record) && create_current(archive_record) 
     previous_record.destroy 
     archive_record.destroy 
    end 
    end 

    private 

    def record_params 
    params.require(:record).permit(:record_type, :record, :version, :release_date) 
    end 

    def create_archive(previous_record) 
    archive = Record.new 
    archive.archive_record = URI.parse(previous_record.record.url) 
    archive.version = previous_record.version 
    archive.record_file_name = previous_record.record_file_name 
    archive.record_content_type = previous_record.record_content_type 
    archive.is_archive = true 
    @archive_record_remote_url = previous_record.record.url 
    archive.save(:validate => false) 
    end 

    def create_current(archive_record) 
    latest = Record.new 
    latest.record = URI.parse(archive_record.archive_record.url) 
    latest.version = archive_record.version 
    latest.record_file_name = archive_record.record_file_name 
    latest.record_content_type = archive_record.record_content_type 
    latest.is_archive = false 
    @archive_record_remote_url = archive_record.archive_record.url 
    latest.save(:validate => false) 
    end 
end 

ci sono due file allegati: l'ultimo record e l'archivio.

Il metodo upload_record carica un record e verifica se sono presenti altri record nell'ultimo record (l'ultimo record può essere solo un record e l'archivio può avere molti). Quando c'è un record esistente in ultima o possiamo dire se c'è un record corrente, viene chiamato il metodo create_archive che converte il record più recente in un record di archivio e lo salva nella cartella di archivio in s3. Il record appena caricato diventa l'attuale record.

C'è un metodo change_record che viene chiamato quando si fa clic su un pulsante "Crea corrente" su uno qualsiasi degli archivi. Nel metodo change_record trasformo l'ultimo record in un archivio e l'archivio cliccato nell'ultimo record utilizzando i due metodi create_archive e create_current.

Quando converto qualsiasi record a un archive_record è successo facendo e sono in grado in grado di vedere il record viene salvato in /record/archive/ in S3 ma quando si converte il disco archivio al record corrente il record non è sempre salvato in /record/latest/ in S3.

Grazie per aver letto questo lungo problema. Qualcuno mi può aiutare?

Answer 1

Ho fatto un po 'di clonazione profonda del record di graffette nel mio progetto e ho anche affrontato problemi con URI.parse, ho semplicemente scaricato il record di paperclip esistente e ha funzionato bene. Ebbene nel tuo caso, questo dovrebbe funzionare bene

def create_archive(previous_record) 
    archive = Record.new 
    archive.archive_record = previous_record.record 
    archive.version = previous_record.version 
    archive.is_archive = true 
    @archive_record_remote_url = previous_record.record.url 
    archive.save(:validate => false) 
end 

def create_current(archive_record) 
    latest = Record.new 
    latest.record = archive_record.archive_record 
    latest.version = archive_record.version 
    latest.is_archive = false 
    @archive_record_remote_url = archive_record.archive_record.url 
    latest.save(:validate => false) 
end 

Answer 2

Ho provato la stessa cosa usando graffetta, ma era po 'complicato.

Così ho preferito utilizzando i binari stesso per caricare file e recuperarlo,

Esso può essere fatto,

<%= f.file_field :file_name %> 
<div class="actions"> 
<%= f.submit "Upload" %> 
</div> 

Può essere recuperato,

File.open(Rails.root.join('app/assets/images/', memory.original_filename), 'wb') do |file| 
    file.write(memory.read) 
end