Integración de Ruby on Rails con WordPress

7 minutos de lectura

Tengo un cliente que me ha pedido que le construya un sitio web con una forma muy fácil de usar para actualizar el contenido. Han expresado su familiaridad con wordpress y expresaron interés en poder usar el front-end de wordpress para actualizar su contenido.

Originalmente, tenía la intención de crearles una página de administración simple, donde puedan crear publicaciones o agregar otros tipos de contenido… pero parece que wordpress ya tiene la mayor parte de la funcionalidad.

El principal problema es que soy un desarrollador de RoR. Prefiero usar haml para cada cosa que hago, y tengo un control total del 100% sobre cómo funciona el sitio.

Así que esperaba que alguien tuviera una idea de cómo podría construir el sitio usando Rails y Haml, pero aún así permitir que mi cliente actualice usando WordPress. Pensé que tal vez podría acceder a la API de wordpress, y simplemente extraer el contenido y mostrarlo de la manera que quiero. o tal vez debería ir con otro CMS… como Refinería?

Honestamente, realmente no quiero tener que tocar PHP, y preferiblemente usar haml, en lugar de html. o_o

  • Por favor, no improvisar algo tratando de combinar lo que me gusta con lo que tu cliente quiereque algún pobre futuro mantenedor va a tener que descifrar…

    –Michael Berkowski

    14 de febrero de 2012 a las 13:27

  • Usa WordPress. No tiene sentido reinventar la rueda. El tiempo libre te permitirá retomar otros proyectos en los que PUEDES trabajar en tu entorno preferido.

    – MunkiPhD

    14 de febrero de 2012 a las 13:52

  • Eres un martillo, y esto no es un clavo. Hay momentos en los que tienes que decirles a los clientes “No soy el tipo adecuado para este trabajo”. Todavía podría estar involucrado en el proyecto mientras los ayuda a desarrollar los requisitos para el proyecto, y podría ayudarlos a encontrar un tipo de PHP competente. Sin embargo, la idea de improvisar un horrible sitio Frankenstiniano RoR/Wordpress me hace estremecer.

    –Marc Talbot

    14 de febrero de 2012 a las 13:58

Esto parece estar funcionando para mí (lo estoy cargando desde WordPress como base de datos secundaria, de ahí el establish_connection() llamadas y anulación table_name. Esto debería completar la mayor parte del camino, brindándole acceso a los datos de WordPress como objetos ActiveRecord. Todavía no he escrito el envoltorio de las Publicaciones (WPPost) para hacerlos un poco más fáciles de usar desde la perspectiva de la API, pero esto debería funcionar bien para la visualización de datos de WordPress basada en Rails.

class Term < ActiveRecord::Base
   establish_connection "wordpress-#{Rails.env}"
   self.table_name = "wp_terms"

   has_one :term_taxonomy
end


class TermTaxonomy < ActiveRecord::Base
   establish_connection "wordpress-#{Rails.env}"
   self.table_name = "wp_term_taxonomy"

   belongs_to :term
   has_many :term_relationship
end

class TermRelationship < ActiveRecord::Base
   establish_connection "wordpress-#{Rails.env}"
   self.table_name = "wp_term_relationships"

   belongs_to :post, :foreign_key => "object_id"
   belongs_to :term_taxonomy
   has_one :term, :through => :term_taxonomy
end

class Post < ActiveRecord::Base
   establish_connection "wordpress-#{Rails.env}"
   self.table_name = "wp_posts"

   has_many :term, :through => :term_relationship
   has_many :term_relationship, :foreign_key => "object_id"
   has_one  :postmeta

   # we only care about published posts for notifications
   default_scope where("post_type="post" and post_status="publish"")
end

class Postmeta < ActiveRecord::Base
   establish_connection "wordpress-#{Rails.env}"
   self.table_name = "wp_postmeta"

   belongs_to :post
end

Luego envuelvo la categoría en un objeto ruby ​​simple que facilita el acceso a los datos:

class WPCategory
   attr_accessor :id
   attr_accessor :name
   attr_accessor :description
   attr_accessor :term

   def self.categories()
      categories = Term.all()
      categories = categories.select{|term| term.term_taxonomy.taxonomy == "category"}
      return categories.map{|term| WPCategory.new(term)}
   end

   def self.category(id=nil)
      if id
         term = Term.find(id)
         if term.term_taxonomy.taxonomy == "category"
            return WPCategory.new(term)
         end
      end
      return nil
   end

   def initialize(term)
      @id = term.term_id
      @name = term.name
      @description = term.term_taxonomy.description
      @term = term
   end

   def to_s
      return "Wordpress Category: '#{@name}' (id=#{@id})"
   end

end

Aquí está mi base de datos.yml (asegúrese de que su usuario de base de datos tenga acceso de solo lectura a la base de datos de wordpress para evitar contratiempos de ActiveRecord):

test:
        adapter: mysql2
        encoding: utf8
        database: test-rails
        pool: 5
        username: test
        password: XXXXXX
        socket: /var/lib/mysql/mysql.sock

wordpress-test:
        adapter: mysql2
        encoding: utf8
        database: test-wordpress
        pool: 5
        username: test
        password: XXXXXXX
        socket: /var/lib/mysql/mysql.sock

wordpress-development:
        adapter: mysql2
        encoding: utf8
        database: wordpress
        pool: 5
        username: dev
        password: XXXXXX
        socket: /var/lib/mysql/mysql.sock

development:
        adapter: mysql2
        encoding: utf8
        database: dev
        pool: 5
        username: dev
        password: XXXXXX
        socket: /var/lib/mysql/mysql.sock

  • Wow, ¿tienes una guía detallada en alguna parte sobre esto? Gracias.

    – demonio místico

    2 de agosto de 2018 a las 8:10

El Museo de Arte Moderno tenía un complemento API JSON de WordPress creado exactamente para este propósito: https://github.com/dphiffer/wp-json-api

Esto les permitió construir una capa de front-end basada en RoR mientras mantenían una capa de back-end impulsada por WordPress.

Las respuestas anteriores ya no son relevantes. WordPress ahora proporciona una API Rest a la que se puede acceder aquí:
https://developer.wordpress.org/rest-api/

1) Probablemente querrá integrar todo el enrutamiento (tomando el “slug” de los artículos) en su aplicación Rails para servir los artículos correctamente y presentarlos con una buena vista de “espectáculo”.

2) Si desea almacenar datos en el sistema de rieles (por ejemplo, para enrutamiento y para aumentar la velocidad), puede crear una tabla de base de datos llamada wp_articles, simplemente lea la lista completa de artículos o actualice los artículos relevantes, luego preséntelos de manera similar a su código normal.

Miré la gema MOMA no mantenida (ya no se requiere, no se mantiene), verifiqué la respuesta anterior con acceso directo a la base de datos (gran esfuerzo, más lento, desactualizado) y leí sobre una solución directa basada en javascript un poco compleja aquí (http://marydickson.com/how-to-use-the-wordpress-rest-api-in-rails/), pero creo que simplemente copiar la información relevante en su sistema y luego presentarla con el proceso MVC normal es la forma más fácil.

Desventajas: algunos complementos de WP adicionales brindan más campos de base de datos y otra información y no está claro si siempre puede acceder a ellos a través de la API. Por lo tanto, es posible que tenga una funcionalidad ligeramente limitada.

  • Muchas gracias por ayudar a mantener esta pregunta actualizada.

    – Banana Neil

    6 de junio de 2017 a las 0:11


  • ¿Es este enfoque mejor que acceder a la base de datos de WP directamente y crear los modelos/controladores para ellos? ¿O eso ya no es posible?

    – Fahmin

    15 de septiembre de 2020 a las 8:45

  • Probablemente tendría una solución más limpia si accede directamente a la base de datos de WP, si eso es lo único que está haciendo su aplicación. En mi caso, se mezcló con un proyecto diferente y quería mantener las cosas separadas. Buena suerte.

    – Michael Schmitz

    16 de septiembre de 2020 a las 11:54

Puede instalar WordPress y luego reproducir la base de datos de wordpress como Models y agregue las asociaciones como las usa wordpress. Luego, podrá acceder a los datos utilizando los rieles que se ingresaron en la interfaz de wordpress. Hice algo como esto en el pasado, pero no como una solución permanente, sino como una fuente de datos para la migración a otra solución. Es posible, no es agradable, pero funciona.

Pero una pregunta: ¿Por qué estás usando wordpress para algo que no es lo suficientemente poderoso? Es un CMS, no un marco para tareas desafiantes. Si no se ajusta a las necesidades del cliente, simplemente no es lo correcto. Preferiría construir una GUI similar usando rieles y luego jugar con wordpress.

Con respecto a HAML, aún puede escribir sus puntos de vista en haml y luego usar haml input.haml output.html en la línea de comando. Un poco aburrido, pero no tienes que escribir html.

avatar de usuario
nana

usa MAMP e instala wordpress. abra la página en su localhost. luego puede usar la herramienta firefox para ver el código html.

¿Ha sido útil esta solución?