g5_updatable 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bde0a7d86b404b9ac963b31247542ba845666eeb
-  data.tar.gz: d0b7a782024e35fd093883883979078370ef1db6
+  metadata.gz: 3a07cbb7571a2a542b0ee33d002767be1a2a55f7
+  data.tar.gz: 03a45dc270a2144190f1b8d75c9790639e3dfea7
 SHA512:
-  metadata.gz: a8024e7f5fd6aa37805eac7b87e11d4cffd2f7802286de63709761eeac71ff86056ebdf517f4ba13b08b3e18e0e538d7ee819d6f5717013e16db7c1ae28192f8
-  data.tar.gz: 76c110e7d08fa1ea6c1608e081ddb8673ba0743d432d3f89ba7d1596bb0991f8ffcc30a3e40813511d8d5d7704c64a404872081b85a804c314319d1ed00f49cb
+  metadata.gz: 1eddbf5326ca2ed281892b39457f5b9c79b3dccb2689c898aeeca03107dbcbe5cee213f6cebbd922d316640445dba98d0ddcb0612137aee606c212a8450db8b6
+  data.tar.gz: 55b69f64376dae0bc537a0b62f0e17b4ed1e754fac7809eb50fff6f8910a79153e2fcdcb1bf349ead4ff13a9a8ce60b69b984eeb8178a5b993c8fd6b862f5dad

data/README.md

@@ -6,6 +6,10 @@
 G5 Updatable provides a solution for automatic updates of client and location
 data when modified or created in the G5 Hub.
 
+## Requirements
+
+G5 Updatable makes use of PostgrSQL's `json` field type, and so only supports implementing apps that also use PostgreSQL.
+
 ## Installation
 
 1. Add this line to your application's Gemfile:
@@ -19,56 +23,53 @@ data when modified or created in the G5 Hub.
    ```console
    bundle
    ```
-
 3. Run the generator.
 
    ```ruby
    rails g g5_updatable:install
    ```
 
-   This creates an initilizer at config/initializers/g5_updatable.rb,
-   and mounts the engine at `/g5_updatable`.
+   This mounts the engine at `/g5_updatable`.
+
+3. And copy the engine's migrations to your application:
+
+  ```console
+    rake g5_updatable:install:migrations
+  ```
+3. Optional: load all of G5-Hub's data into your database
+
+  ```console
+    rake g5_updatable:load_all
+  ```  
+  Note, all of the G5_AUTH env variables need to be set for this to work.
+
+## Usage
+
+G5 Updatable exposes a POST route at `/g5_updatable/update` that accepts a
+`client_uid` parameter (the URL for the client's detail page within the G5
+Hub). When the route is hit, it will update/create Location and Client.
 
-## Configuration
+See the [G5-Hub](https://github.com/G5/g5-hub/blob/master/lib/webhook_poster.rb) webhook logic for further info.
 
-You can configure options within the generated initializer.
+### Location Association
+
+You will likely have models in your own application that are associated with a Location. A module is available to include in your related models to support this association. Assuming your model has a `location_uid` string field, you can use the module as follows:
 
 ```ruby
-# config/initilizers/g5_updatable.rb
-G5Updatable.setup do |config|
-  # Default is nil. Most likely will be coming in via the hub urn parameter.
-  # dentifier of the client (urn)
-  config.client_identifier = #string
-
-  # Default is ""http://g5-hub.herokuapp.com/clients/". Base path to the G5 Hub
-  config.feed_endpoint = #string
-  
-  # default is true. When set to true, existing locations in your app will be
-  # updated with any changes made to the hub. If set to false, existing locations
-  # will be skipped and only newly added locations will be created.
-  config.update_locations = #boolean
-
-  # default is false. When set to true, client data will update.
-  config.update_client = #boolean
-
-  # default is [:name]. A whitlist of parameters to create/update on the model
-  config.location_parameters = #array of symbols
-
-  # default is [:name]. A whitlist of parameters to update on the model
-  config.client_parameters = #array of symbols
+class Foo < ActiveRecord::Base
+  include G5Updatable::BelongsToLocation
 end
 ```
 
-## Usage
+It provides a `#location` method that will fetch the correct location.
 
-G5 Updatable exposes a POST route at `/g5_updatable/update` that accepts a urn
-parameter (client identifier within the hub). When the route is
-hit, it will update/create Location and Client data based on the configuration.
+### Spec Helpers
 
-G5 Updatable assumes your app has a Location model with a minimum of a urn and
-name column.
+The engine provides a helper files that can be included in your project to bring in some testing support. Currently this is limited to (some factory definitions)[https://github.com/G5/g5_updatable/blob/active-record-up-in-here/lib/g5_updatable/rspec/factories.rb]. In rspec you can add the following line to your `spec/spec_helper.rb`:
 
-See the [G5-Hub](https://github.com/G5/g5_hub/lib/webhook_poster.rb) webhook logic for further info.
+```ruby
+require 'g5_updatable/rspec'
+```
 
 ## Authors
 
@@ -88,6 +89,16 @@ If you find bugs, have feature requests or questions, please
 
 ## Specs
 
+The `database.yml` for the dummy app must be created and modified to match your
+PostgreSQL configuration. If you are using the [G5 Orion
+Vagrant](https://github.com/G5/g5-orion-vagrant) image, the sample file should
+just work. You can copy it into place with:
+```bash
+$ cp spec/dummy/config/database.sample.yml spec/dummy/config/database.yml
+```
+
+Run specs via `rspec` with:
+
 ```bash
 $ rspec spec
 ```

data/app/concerns/g5_updatable/belongs_to_location.rb

@@ -0,0 +1,14 @@
+module G5Updatable::BelongsToLocation
+  extend ActiveSupport::Concern
+
+  def location_uid=(location_uid)
+    @location = nil
+    write_attribute(:location_uid, location_uid)
+  end
+
+  def location
+    @location ||= G5Updatable::Location.find_by_uid!(location_uid)
+  rescue ActiveRecord::RecordNotFound
+    raise ActiveRecord::RecordNotFound.new("Can't find a location for uid '#{location_uid}'")
+  end
+end

data/app/concerns/g5_updatable/first_class_properties.rb

@@ -0,0 +1,25 @@
+module G5Updatable::FirstClassProperties
+  extend ActiveSupport::Concern
+
+  included do
+    after_initialize :define_methods_for_properties
+  end
+
+  def properties=(hash)
+    write_attribute("properties", hash)
+    define_methods_for_properties
+  end
+
+protected
+
+  def define_methods_for_properties
+    return unless properties.present?
+
+    properties.each do |key, value|
+      next if respond_to?(key)
+      define_singleton_method(key) do
+        properties[key.to_s] if properties.present?
+      end
+    end
+  end
+end

data/app/concerns/g5_updatable/urn_as_parameter.rb

@@ -0,0 +1,7 @@
+module G5Updatable::UrnAsParameter
+  extend ActiveSupport::Concern
+
+  def to_param
+    urn
+  end
+end

data/app/controllers/g5_updatable/feed_controller.rb

@@ -3,7 +3,7 @@ class G5Updatable::FeedController < ApplicationController
   skip_before_filter :verify_authenticity_token
 
   def update
-    G5Updatable::ClientFeedProcessor.new(params[:urn]).work
+    G5Updatable::ClientFeedProcessor.new(params[:client_uid]).work
     render json: {}, status: :ok
   end
 end

data/app/models/g5_updatable/client.rb

@@ -0,0 +1,12 @@
+module G5Updatable
+  class Client < ActiveRecord::Base
+    include G5Updatable::FirstClassProperties
+    include G5Updatable::UrnAsParameter
+
+    validates :uid, :urn, presence: true
+
+    def locations
+      G5Updatable::Location.where(client_uid: self.uid)
+    end
+  end
+end

data/app/models/g5_updatable/integration_setting.rb

@@ -0,0 +1,20 @@
+module G5Updatable
+  class IntegrationSetting < ActiveRecord::Base
+    include G5Updatable::FirstClassProperties
+    include G5Updatable::UrnAsParameter
+
+    validates :uid, presence: true
+    validates :location_uid, presence: true
+
+    INVENTORY = 'inventory'
+    LEAD      = 'lead'
+
+    scope :by_vendor_action, -> (vendor_action) { where(vendor_action: vendor_action) }
+    scope :by_inventory, -> { by_vendor_action(INVENTORY) }
+    scope :by_lead, -> { by_vendor_action(LEAD) }
+
+    def location
+      @client ||= G5Updatable::Location.find_by_uid(location_uid)
+    end
+  end
+end

data/app/models/g5_updatable/location.rb

@@ -0,0 +1,16 @@
+module G5Updatable
+  class Location < ActiveRecord::Base
+    include G5Updatable::FirstClassProperties
+    include G5Updatable::UrnAsParameter
+
+    validates :uid, :urn, :client_uid, presence: true
+
+    def client
+      @client ||= G5Updatable::Client.find_by_uid(client_uid)
+    end
+
+    def integration_settings
+      G5Updatable::IntegrationSetting.where(location_uid: self.uid)
+    end
+  end
+end

data/app/serializers/g5_updatable/location_serializer.rb

@@ -0,0 +1,12 @@
+class G5Updatable::LocationSerializer < ActiveModel::Serializer
+  attributes :uid, :urn, :client_uid
+
+  def filter(keys)
+    object.properties.each do |name, value|
+      keys.push(name.to_sym)
+      define_singleton_method(name.to_sym) { value }
+    end
+
+    keys
+  end
+end

data/db/migrate/20140709222005_create_g5_updatable_clients_and_locations.rb

@@ -0,0 +1,24 @@
+class CreateG5UpdatableClientsAndLocations < ActiveRecord::Migration
+  def change
+    create_table :g5_updatable_clients do |t|
+      t.string :uid
+      t.string :urn
+      t.json :properties
+
+      t.timestamps
+    end
+    add_index :g5_updatable_clients, :uid
+    add_index :g5_updatable_clients, :urn
+
+    create_table :g5_updatable_locations do |t|
+      t.string :uid
+      t.string :urn
+      t.string :client_uid
+      t.json :properties
+
+      t.timestamps
+    end
+    add_index :g5_updatable_locations, :uid
+    add_index :g5_updatable_locations, :urn
+  end
+end

data/db/migrate/20141030211945_create_integration_setting.rb

@@ -0,0 +1,18 @@
+class CreateIntegrationSetting < ActiveRecord::Migration
+  def change
+    create_table :g5_updatable_integration_settings do |t|
+      t.string :uid
+      t.string :urn
+      t.string :location_uid
+      t.string :vendor_action
+      t.integer :job_frequency_in_minutes
+      t.json :properties
+      t.timestamps
+    end
+
+    add_index :g5_updatable_integration_settings, :urn
+    add_index :g5_updatable_integration_settings, :uid
+    add_index :g5_updatable_integration_settings, :vendor_action
+    add_index :g5_updatable_integration_settings, [:location_uid, :vendor_action], name: :g5_u_is_loc_action
+  end
+end

data/lib/g5_updatable/client_feed_processor.rb

@@ -1,22 +1,44 @@
-require "g5_updatable/feed_mapper"
-require "g5_updatable/client_updater"
-require "g5_updatable/locations_updater"
-
 class G5Updatable::ClientFeedProcessor
-  def initialize(urn=nil)
-    @urn = urn || G5Updatable.client_identifier
+  attr_reader :client_uid
+
+  def initialize(client_uid=nil)
+    @client_uid = client_uid || ENV["CLIENT_UID"]
+    raise "A client_uid must be either passed in or configured!" if @client_uid.blank?
+  end
+
+  class << self
+    def load_all_clients(clients_url)
+      client_uids = G5FoundationClient::Client.all_client_uids clients_url
+      client_uids.collect { |client_uid| new(client_uid).work }
+    end
   end
 
   def work
-    if @urn
-      G5Updatable::ClientUpdater.new(feed_mapper.client).update
-      G5Updatable::LocationsUpdater.new(feed_mapper.locations).update
+    client = update_client
+    update_locations
+    update_integrations
+
+    client
+  end
+
+  private
+
+  def update_integrations
+    foundation_client.locations.each do |location|
+      G5Updatable::IntegrationSettingsUpdater.new(location.integration_settings).update
     end
   end
 
-private
+  def update_locations
+    G5Updatable::LocationsUpdater.new(foundation_client.locations).update
+  end
+
+  def update_client
+    G5Updatable::ClientUpdater.new(foundation_client).update
+  end
 
-  def feed_mapper
-    @feed_mapper ||= G5Updatable::FeedMapper.new(@urn)
+  def foundation_client
+    @foundation_client ||= G5FoundationClient::Client.find_by_uid(@client_uid)
   end
+
 end

data/lib/g5_updatable/client_updater.rb

@@ -4,22 +4,13 @@ class G5Updatable::ClientUpdater
   end
 
   def update
-    return unless G5Updatable.update_client && client
+    attributes = @g5_client.client_hash.dup
+    attributes.delete(:locations)
+    uid = attributes[:uid]
+    urn = attributes[:urn]
 
-    G5Updatable.client_parameters.each do |parameter|
-      client.send("#{parameter}=", @g5_client.send(parameter))
-    end
-
-    client.save
-  end
-
-private
-
-  def client
-    @client ||= Client.find_by(uid: client_uid) if client_uid
-  end
-
-  def client_uid
-    "#{G5Updatable.feed_endpoint}#{G5Updatable.client_identifier}"
+    G5Updatable::Client.
+        find_or_initialize_by(uid: uid).
+        update_attributes!(urn: urn, properties: attributes)
   end
 end

data/lib/g5_updatable/engine.rb

@@ -2,26 +2,15 @@ module G5Updatable
   class Engine < ::Rails::Engine
     isolate_namespace G5Updatable
 
+    config.autoload_paths << G5Updatable::Engine.root.join("lib")
+
     config.generators do |g|
       g.test_framework :rspec
-      g.fixture_replacement :fabrication, dir: 'spec/fabricators'
       g.assets false
       g.helper false
     end
   end
 
-  class << self
-    mattr_accessor :client_identifier, :feed_endpoint, :location_parameters,
-                   :client_parameters, :update_client, :update_locations
-
-    self.client_identifier   = nil
-    self.feed_endpoint       = "http://g5-hub.herokuapp.com/clients/"
-    self.location_parameters = [:name]
-    self.client_parameters   = [:name]
-    self.update_client       = false
-    self.update_locations    = true
-  end
-
   def self.setup(&block)
     yield self
   end

data/lib/g5_updatable/integration_settings_updater.rb

@@ -0,0 +1,21 @@
+class G5Updatable::IntegrationSettingsUpdater
+  def initialize(g5_integration_settings)
+    @g5_integration_settings = g5_integration_settings
+  end
+
+  def update
+    @g5_integration_settings.each do |g5_integration_setting|
+      attributes = g5_integration_setting.integration_setting_hash.dup
+
+      G5Updatable::IntegrationSetting.
+          find_or_initialize_by(uid: attributes[:uid]).
+          update_attributes!(
+          urn:                      attributes[:urn],
+          location_uid:             attributes[:location_uid],
+          vendor_action:            attributes[:vendor_action],
+          job_frequency_in_minutes: attributes[:job_frequency_in_minutes],
+          properties:               attributes
+      )
+    end
+  end
+end

data/lib/g5_updatable/locations_updater.rb

@@ -1,29 +1,22 @@
 class G5Updatable::LocationsUpdater
-  def initialize(locations)
-    @locations = locations
+  def initialize(g5_locations)
+    @g5_locations = g5_locations
   end
 
   def update
-    @locations.each { |location| process(location) unless skip?(location) }
-  end
-
-private
+    @g5_locations.each do |g5_location|
+      attributes = g5_location.location_hash.dup
+      uid        = attributes[:uid]
+      urn        = attributes[:urn]
+      client_uid = attributes[:client_uid]
 
-  def process(g5_location)
-    location = Location.find_or_initialize_by(urn: urn_for(g5_location))
-
-    G5Updatable.location_parameters.each do |parameter|
-      location.send("#{parameter}=", g5_location.send(parameter))
+      G5Updatable::Location.
+          find_or_initialize_by(uid: uid).
+          update_attributes!(
+          urn:        urn,
+          client_uid: client_uid,
+          properties: attributes
+      )
     end
-
-    location.save
-  end
-
-  def skip?(location)
-    Location.exists?(urn: urn_for(location)) && !G5Updatable.update_locations
-  end
-
-  def urn_for(location)
-    location.uid.to_s.split("/").last
   end
 end