g5_updatable 0.10.3 → 0.20.3.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3afda87d522137bbbd0e889b22b17ba948be94ff
-  data.tar.gz: f7baac28c58eb4cdcf78ab270a23aeedeb24c46a
+  metadata.gz: fff24c03cbb209168e956147a0266737b9bcfba9
+  data.tar.gz: b459baf96623cb716ed624e606307f1712359d40
 SHA512:
-  metadata.gz: 58b4ce1062ed6e2a9ca0282e9f56307bedcee380600d58959dac5de02bbda2b5f62bd8300c4f63088931d1e2974ca1abd678302f85bca9755ed414be4af4ced6
-  data.tar.gz: 129bb7ea507eb372da5be65b9bae5397cc4a92629cc074e3b4ff76251ab2f13420b324d593db5f53ae95055ec4e44edc234abf7b38e36292abbcd7ecf09c36da
+  metadata.gz: fccf2277a17f67d1c7945ef14c90084b60eb11d42e5937352b4cefe52b45fa79d704f857329593df4bddf78a3571d0987b4b731bf0424d1e30c1e7b1ce35e825
+  data.tar.gz: c550dc2f70ec537c76570849bc2f54b637367b5ad5c9c55bf59dae1bae1d1d2acf99adb11b97ef4d97b70993a50ebd74829106e3e7028056be686db8af4aac0c

data/README.md

@@ -38,9 +38,12 @@ G5 Updatable makes use of PostgrSQL's `json` field type, and so only supports im
   ```
 3. Optional: load all of G5-Hub's data into your database
 
+  **Important:** The entries.js and entries.json endpoint on the hub are deprecated. So, for all versions of g5_updatable before 0.17.0, this task will only load the newest 10 clients. If you would like to load all clients, please specify "~> 0.17.0" or higher in your Gemfile.
+
   ```console
     rake g5_updatable:load_all
-  ```  
+  ```
+
   Note, all of the G5_AUTH env variables need to be set for this to work.
 
 ## Usage
@@ -58,14 +61,42 @@ G5 Updatable also exposes two GET endpoints which return JSON:
 
 ### Hooks
 
+Execute code each time a new client is created:
+
+```ruby
+G5Updatable::ClientUpdater.on_create do |g5_updatable_client|
+  puts "#{g5_updatable_client.name} was just created"
+end
+```
+
 To execute code every time a location is updated:
 
 ```ruby
-G5Updatable::LocationsUpdader.on_update do |g5_updatable_location|
+G5Updatable::LocationsUpdater.on_update do |g5_updatable_location|
+  puts "G5Updatable::Location##{g5_updatable_location.id} was just updated"
+end
+```
+
+Also optionally expect a secondary block argument, receiving the object previous to be updated
+... you know.. For diff reasons.
+```ruby
+G5Updatable::LocationsUpdater.on_update do |g5_updatable_location, before_update_location|
+  puts "G5Updatable::Location##{before_update_location.properties} changed to "
+  puts "G5Updatable::Location##{g5_updatable_location.properties} "
+end
+```
+
+
+or, execute code only when a location is created:
+
+```ruby
+G5Updatable::LocationsUpdater.on_create do |g5_updatable_location|
   puts "G5Updatable::Location##{g5_updatable_location.id} was just updated"
 end
 ```
 
+The `on_create` callback is called right before the `on_update` callback when a new location is created.
+
 ### Associations
 
 You will likely have models in your own application that are associated with a Client or Location. A module is available to include in your related models to support this association. Assuming your model has a `client_uid` or `location_uid` string field respectively, you can do the following:

data/app/concerns/g5_updatable/belongs_to_client.rb

@@ -4,9 +4,9 @@ module G5Updatable::BelongsToClient
 
   included do
     belongs_to(:client, {
-      class_name: "G5Updatable::Client",
-      foreign_key: :client_uid,
-      primary_key: :uid,
+        class_name:  'G5Updatable::Client',
+        foreign_key: :client_urn,
+        primary_key: :urn,
     })
   end
 

data/app/controllers/g5_updatable/feed_controller.rb

@@ -1,6 +1,6 @@
 class G5Updatable::FeedController < G5Updatable::BaseUpdatableController
   def update
-    G5Updatable::ClientFeedProcessor.new(params[:client_uid]).work
+    G5Updatable::ClientFeedProcessor.new(params).work
     render json: {}, status: :ok
   end
 end

data/app/controllers/g5_updatable/locations_controller.rb

@@ -1,6 +1,6 @@
 class G5Updatable::LocationsController < G5Updatable::BaseUpdatableController
   def show
     @location = G5Updatable::Location.find_by_urn(params[:urn])
-    render json: @location
+    render json: { location: @location }
   end
-end
+end

data/app/controllers/g5_updatable/syncs_controller.rb

@@ -4,16 +4,16 @@ class G5Updatable::SyncsController < G5Updatable::BaseUpdatableController
 
   def index
     timestamp = @client.locations.max_updated_at
-    render json: {updated_at: formatted_timestamp(timestamp)}
+    render json: { updated_at: formatted_timestamp(timestamp) }
   end
 
   private
 
   def set_client
     @client = G5Updatable::Client.find_by_urn!(params[:urn])
-  end  
+  end
 
   def formatted_timestamp(timestamp)
     timestamp.in_time_zone.strftime("%I:%M%P on %B %e, %Y") if timestamp
-  end  
+  end
 end

data/app/models/g5_updatable/client.rb

@@ -4,11 +4,11 @@ module G5Updatable
     include G5Updatable::UrnAsParameter
 
     has_many(:locations, {
-      class_name: "G5Updatable::Location",
-      foreign_key: :client_uid,
-      primary_key: :uid,
+        class_name:  'G5Updatable::Location',
+        foreign_key: :client_urn,
+        primary_key: :urn,
     })
 
-    validates :uid, :urn, presence: true
+    validates :uid, :urn, presence: true, uniqueness: true
   end
 end

data/app/models/g5_updatable/hub_amenities_location.rb

@@ -0,0 +1,6 @@
+module G5Updatable
+  class HubAmenitiesLocation < ActiveRecord::Base
+    belongs_to :hub_amenity, foreign_key: :g5_updatable_hub_amenity_id
+    belongs_to :location, foreign_key: :g5_updatable_location_id
+  end
+end

data/app/models/g5_updatable/hub_amenity.rb

@@ -0,0 +1,21 @@
+module G5Updatable
+  class HubAmenity < ActiveRecord::Base
+    validates :external_id, presence: true
+    has_many :hub_amenities_locations, foreign_key: :g5_updatable_hub_amenity_id
+
+    scope :by_client_urn, -> (client_urn) {
+      joins(hub_amenities_locations: { location: :client }).
+          where('g5_updatable_clients.urn = :client_urn', client_urn: client_urn).uniq
+    }
+
+    scope :by_client_urns, -> (client_urns) {
+      joins(hub_amenities_locations: { location: :client }).
+          where('g5_updatable_clients.urn IN (:client_urns)', client_urns: client_urns.join(',')).uniq
+    }
+
+    scope :by_client_uid, -> (client_uid) {
+      joins(hub_amenities_locations: :location).
+          where('g5_updatable_locations.client_uid = :client_uid', client_uid: client_uid).uniq
+    }
+  end
+end

data/app/models/g5_updatable/location.rb

@@ -4,18 +4,91 @@ module G5Updatable
     include G5Updatable::UrnAsParameter
     include BelongsToClient
 
-    validates :uid, :urn, :client_uid, presence: true
+    has_many :hub_amenities_locations, foreign_key: :g5_updatable_location_id, dependent: :destroy
+    has_many :hub_amenities, through: :hub_amenities_locations
+
+    validates :uid, :urn, :client_uid, :client_urn, presence: true
+    validates :urn, uniqueness: true
 
     scope :by_client_uid, -> (client_uid) { where(client_uid: client_uid) }
+    scope :by_client_urn, -> (client_urn) { where(client_urn: client_urn) }
+    scope :by_postal_code, -> (postal_code) { by_property('postal_code', postal_code) }
+    scope :by_city, -> (city) { by_property('city', city) }
+    scope :by_state, -> (state) { by_property('state', state) }
+    scope :in_status, -> (status) { where("g5_updatable_locations.properties ->> 'status' IN (?)", status) }
+    scope :by_neighborhood, -> (neighborhood) {
+      where("g5_updatable_locations.properties ->> 'neighborhood' = :neighborhood OR g5_updatable_locations.properties ->> 'neighborhood_2' = :neighborhood", neighborhood: neighborhood)
+    }
+    scope :by_property, -> (property_name, value) { where("g5_updatable_locations.properties ->> '#{property_name}' = :#{property_name}", property_name.to_sym => value) }
     scope :by_urn, -> (urn) { where(urn: urn) }
     scope :max_updated_at, -> { maximum(:updated_at) }
+    scope :by_amenity_names, -> (*amenity_names) { # there must be a match for every amenity name (AND not OR)
+      results = all
+      [amenity_names].flatten.each do |amenity_name|
+        results = results.where('g5_updatable_locations.flat_amenity_names LIKE :amenity_names',
+                                amenity_names: "%#{amenity_names_to_tokenized_string(amenity_name)}%")
+      end
+      results
+    }
+    before_validation :set_client_urn, :set_client_uid
+
+    def refresh_flat_amenity_names!
+      update_attributes(flat_amenity_names: self.class.amenity_names_to_tokenized_string(hub_amenities.collect(&:name)))
+    end
 
-    delegate :urn, to: :client, prefix: true, allow_nil: true
+    def amenity_names_array=(names_array)
+      self.flat_amenity_names = self.class.amenity_names_to_tokenized_string names_array
+    end
+
+    FLAT_DELIM = '|'
+
+    def self.amenity_names_to_tokenized_string(names_array)
+      return if names_array.blank?
+      "#{FLAT_DELIM}#{[names_array].flatten.compact.sort.join(FLAT_DELIM)}#{FLAT_DELIM}"
+    end
 
     def display_name
       return nil unless properties
       return properties['internal_branded_name'] if properties['internal_branded_name'].present?
       name
     end
+
+    def neighborhoods
+      [properties['neighborhood'], properties['neighborhood_2']].select(&:present?)
+    end
+
+    def live?
+      status?("Live")
+    end
+
+    def no_deploy?
+      status?("No Deploy")
+    end
+
+    def pending?
+      status?("Pending")
+    end
+
+    def deleted?
+      status?("Deleted")
+    end
+
+    def suspended?
+      status?("Suspended")
+    end
+
+    def status?(status)
+      return false unless properties
+      match = properties['status'].to_s.strip =~ /#{status.to_s.strip}/i
+      !!match
+    end
+
+    def set_client_urn
+      self.client_urn ||= self.client_uid.split('/').last if self.client_uid
+    end
+
+    def set_client_uid
+      self.client_uid||= self.client.try(:uid)
+    end
   end
 end

data/app/serializers/g5_updatable/location_serializer.rb

@@ -9,4 +9,12 @@ class G5Updatable::LocationSerializer < ActiveModel::Serializer
 
     keys
   end
+
+  def attributes(requested_attrs = nil, reload = false)
+    data = super requested_attrs, reload
+    object.properties.each do |name, value|
+      data[name.to_sym] = value
+    end
+    data
+  end
 end

data/db/migrate/20151103043916_add_latitude_and_longitude_to_location.rb

@@ -0,0 +1,6 @@
+class AddLatitudeAndLongitudeToLocation < ActiveRecord::Migration
+  def change
+    add_column :g5_updatable_locations, :latitude, :float
+    add_column :g5_updatable_locations, :longitude, :float
+  end
+end

data/db/migrate/20151103050229_copy_lat_long_props_to_lat_long_columns.rb

@@ -0,0 +1,19 @@
+class CopyLatLongPropsToLatLongColumns < ActiveRecord::Migration
+  def up
+    G5Updatable::Location.all.each do |location|
+      location.latitude = location.properties['latitude']
+      location.longitude = location.properties['longitude']
+      location.save
+    end
+  end
+
+  def down
+    G5Updatable::Location.all.each do |location|
+      location.properties['latitude'] = location.latitude
+      location.proper['longitude'] = location.longitude
+      location.latitude = nil
+      location.longitude = nil
+      location.save
+    end
+  end
+end

data/db/migrate/20151106070749_add_latitude_longitude_indexes_to_location.rb

@@ -0,0 +1,6 @@
+class AddLatitudeLongitudeIndexesToLocation < ActiveRecord::Migration
+  def change
+    add_index :g5_updatable_locations, :latitude
+    add_index :g5_updatable_locations, :longitude
+  end
+end

data/db/migrate/20161122070749_add_amenities.rb

@@ -0,0 +1,25 @@
+class AddAmenities < ActiveRecord::Migration
+  def change
+    create_table :g5_updatable_hub_amenities do |t|
+      t.integer :external_id
+      t.string :name
+      t.string :icon
+      t.timestamp :external_updated_at
+      t.timestamp :external_created_at
+      t.timestamps
+    end
+
+    add_index :g5_updatable_hub_amenities, :external_id, unique: true
+
+    create_table :g5_updatable_hub_amenities_locations do |t|
+      t.belongs_to :g5_updatable_hub_amenity
+      t.belongs_to :g5_updatable_location
+    end
+
+    add_index :g5_updatable_hub_amenities_locations, :g5_updatable_hub_amenity_id, name: 'updatable_amenities_loc_amen_id'
+    add_index :g5_updatable_hub_amenities_locations, :g5_updatable_location_id, name: 'updatable_amenities_loc_loc_id'
+
+    # we need this for queries that require a location to have ALL amenities in a list
+    add_column :g5_updatable_locations, :flat_amenity_names, :string
+  end
+end

data/db/migrate/20161209070749_add_client_urn_to_locations.rb

@@ -0,0 +1,6 @@
+class AddClientUrnToLocations < ActiveRecord::Migration
+  def change
+    add_column :g5_updatable_locations, :client_urn, :string
+    add_index :g5_updatable_locations, :client_urn
+  end
+end

data/lib/g5_updatable.rb

@@ -1,6 +1,8 @@
-require "active_model_serializers"
-require "g5_foundation_client"
-require "g5_updatable/engine"
+require 'active_model_serializers'
+require 'g5_authentication_client'
+require 'g5_updatable/engine'
+require 'httparty'
 
 module G5Updatable
+  HUB_URL = ENV.fetch('HUB_URL', 'https://g5-hub.herokuapp.com').freeze
 end

data/lib/g5_updatable/all_client_urns_fetcher.rb

@@ -0,0 +1,17 @@
+module G5Updatable
+  class AllClientUrnsFetcher
+    def self.fetch_uids
+      G5Updatable::Fetcher.get_with_token(url)['clients'].collect do |urn|
+        "#{hub_url}/clients/#{urn['urn']}.json"
+      end
+    end
+
+    def self.url
+      "#{hub_url}/urns.json"
+    end
+
+    def self.hub_url
+      G5Updatable::HUB_URL
+    end
+  end
+end

data/lib/g5_updatable/client_feed_processor.rb

@@ -1,37 +1,49 @@
 class G5Updatable::ClientFeedProcessor
   attr_reader :client_uid
 
-  def initialize(client_uid=nil)
-    @client_uid = client_uid || ENV["CLIENT_UID"]
+  def initialize(params)
+    @client_uid = params[:client_uid] || ENV["CLIENT_UID"]
     raise "A client_uid must be either passed in or configured!" if @client_uid.blank?
+    @location_uid = params[:location_uid]
   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 }
+    def load_all_clients
+      G5Updatable::AllClientUrnsFetcher.fetch_uids.each do |uid|
+        puts "Loading: #{uid}"
+        load_client(uid)
+      end
+    end
+
+    def load_client(client_uid)
+      begin
+        new(client_uid: client_uid).work
+      rescue => e
+        Rails.logger.error e
+        nil
+      end
     end
   end
 
   def work
-    client = update_client
-    update_locations
-
-    client
+    @location_uid ? update_location : update_client
   end
 
   private
 
-  def update_locations
-    G5Updatable::LocationsUpdater.new(foundation_client).update
+  def update_location
+    G5Updatable::LocationsUpdater.new(location_hash).update
   end
 
   def update_client
-    G5Updatable::ClientUpdater.new(foundation_client).update
+    G5Updatable::ClientUpdater.new(client_hash).update
   end
 
-  def foundation_client
-    @foundation_client ||= G5FoundationClient::Client.find_by_uid(@client_uid)
+  def client_hash
+    G5Updatable::Fetcher.get_with_token(@client_uid)['client']
   end
 
+  def location_hash
+    G5Updatable::Fetcher.get_with_token(@location_uid)['location']
+  end
 end