Come chiamare l'API interna dalla vista Rails (per lo scopo del prerender di ReactJS)?

Question

Ho già un controller API Rails che restituisce la risposta JSON. Viene utilizzato dal Javascript front-end (così come dall'app mobile) per il rendering dei valori.

Ora, desidero pre-rendering quei valori utilizzando ReactJS:

#app/controllers/api/v1/products_controller.rb 
module API 
    module V1 
     class ProductsController < ApplicationController 
      def index 
       @products = Product.all #this could be acomplex multi-line statements. 
       #rendered in api/v1/products/index.json.jbuilder 
      end 
     end 
    end 
end 

#app/controllers/products_controller.rb 
class ProductsController < ApplicationController 
    def index 
     #How to do this efficiently? 
     @products_json = #Call to internal /api/v1/products/index for prerender purpose. 
     @user_json = #Call to internal /api/v1/user/show for prerender purpose. 
    end 
end 

#app/views/products/index.html.erb 
<%= react_component('ProductsList', @products_json, {prerender: true}) %> 
<%= react_component('UserProfile', @user_json, {prerender: true}) %> 

Come chiamo interno /api/v1/products e /api/v1/user URL in modo efficiente (ad esempio senza fare HTTP GET richiesta al mio server)?

Answer 1

Prova questa:

def index 
    @products = Product.all 
    @products_json render_to_string('/api/v1/products/index', formats: [:json]) 
    # etc... 
end 

Answer 2

Sono d'accordo con il vostro desiderio di riutilizzare il codice API per le vostre opinioni. Ciò renderà l'applicazione molto più gestibile.

Cosa succede se si modifica un po 'lo scope? Invece di chiamare un metodo controller, sposta la logica in una nuova classe Ruby.

Il compito di questa classe è trasformare un oggetto in una stringa JSON, quindi è chiamato "serializzatore". Nella mia app, abbiamo app/serializers/{model_name}/ per l'archiviazione di diverse classi di serializzazione.

Ecco un esempio di serializzazione:

# app/serializers/product/api_serializer.rb 
class Product::APISerializer 
    attr_reader :product, :current_user 

    def initialize(product, current_user) 
    @product = product 
    @current_user = current_user 
    end 

    # Return a hash representation for your object 
    def as_json(options={}) # Rails uses this API 
    { 
     name: product.name, 
     description: product.description, 
     price: localized_price, 
     categories: product.categories.map { |c| serialize_category(c) }, 
     # ... all your JSON values 
    } 
    end 

    private 

    # For example, you can put logic in private methods of this class. 
    def localized_price 
    current_currency = current_user.currency 
    product.price.convert_to(current_currency) 
    end 

    def serialize_category(category) 
    { name: category.name } 
    end 
end 

Quindi, utilizzare questo serializzatore per costruire la vostra risposta API:

class API::V1::ProductsController < ApplicationController 
    def index 
    products = Product.all 
    products_json = products.map do |product| 
     serializer = Product::APISerializer.new(product, current_user) 
     serializer.as_json 
    end 
    render json: products_json 
    end 
end 

Quindi, è possibile utilizzare il serializzatore nuovo nel controller UI:

class ProductsController < ApplicationController 
    def index 
    products = Product.all 
    @products_json = products.map do |product| 
     serializer = Product::APISerializer.new(product, current_user) 
     serializer.as_json 
    end 
    # render view ... 
    end 
end 

Perché hai usato la stessa s erializer in entrambi i casi, la rappresentazione JSON dei prodotti sarà la stessa!

Ci sono alcuni vantaggi di questo approccio:

• Perché il vostro serializzatore è una classe di Ruby pianura, è facile scrivere & prova
• E 'facile condividere la logica JSON tra controllori
• E' molto estendibile: quando hai bisogno di JSON per uno scopo diverso, aggiungi semplicemente un nuovo serializzatore e usalo.

Alcune persone usano ActiveModel Serializers per questo, ma io no. Ho provato AMS un anno fa e non mi piaceva perché sovrascrive lo as_json per tutti gli oggetti nella tua app, il che ha causato cambiamenti improvvisi nel mio caso!