api_models 0.1.0

data/lib/models/configuration_group.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+#
+# Hold a collection of app configuration items as a group.
+#
+# Contains the actual key value pairs as well as the rules that
+# apply to this configuration group.
+#
+class ConfigurationGroup
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  #
+  # Fields
+  #
+  field :name, type: String
+  field :active, type: Boolean, default: true
+  field :version, type: Integer, default: 1
+  #
+  # Relationships
+  #
+  belongs_to :app, class_name: 'InternalApp', inverse_of: :configuration_groups
+  has_many :configuration_rules, dependent: :destroy
+  embeds_many 'options'
+  #
+  # Validations
+  #
+  validates_presence_of :name
+  validates_presence_of :version
+  validates_uniqueness_of :name, scope: :app_id, message: 'The configuration group already exists'
+
+  #
+  # Return true if the configuration rules match this agent
+  #
+  def match_agent?(agent)
+    return false unless active?
+
+    match = true
+    configuration_rules.where(active: true).each { |rule| match &&= rule.match_agent?(agent) }
+    match
+  rescue StandardError
+    false
+  end
+
+  #
+  # Return the configuration doc for the agent
+  #
+  def agent_payload
+    { name: name, version: version, items: options.collect(&:agent_payload) }
+  end
+end

data/lib/models/configuration_rule.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+#
+# A rule for a given configuration group
+#
+class ConfigurationRule
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  #
+  # Fields
+  #
+  field :active, type: Boolean, default: false
+  field :option, type: String
+  field :operator, type: String
+  field :platform, type: Array, default: %w[android ios]
+  #
+  # Relationships
+  #
+  belongs_to :app
+  belongs_to :configuration_constraint, optional: true
+  belongs_to :configuration_group
+
+  #
+  # Return true if this rule matches the given agent
+  #
+  def match_agent?(agent)
+    active? && match_platform?(agent) && (platform_rule? || match_constraint_rule?(agent))
+  end
+
+  private
+
+  #
+  # Test if the constraint matches this agent
+  #
+  def match_constraint_rule?(agent)
+    name = configuration_constraint.name
+    value = agent.respond_to?(name) ? agent[name] : agent.device[name]
+    value.send(operator, option)
+  rescue StandardError
+    false
+  end
+
+  #
+  # Is this a global rule, or platform rule
+  #
+  def platform_rule?
+    configuration_constraint.blank?
+  end
+
+  #
+  # If the platform for the device's agent is in the list of platforms
+  #
+  def match_platform?(agent)
+    platform.include?(agent.device.platform.downcase)
+  rescue StandardError
+    false
+  end
+end

data/lib/models/device.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+#
+# Holds a single device, where a device may have many agents (and thus apps)
+# installed on it.
+#
+# 1. Data comes in as device_platform, device_os_version, device_model,
+#    device_manufacture, device_capacity, app_version
+# 2. Raw model id is saved on internal_model if updated from market name
+# 3. Add app ids to app_ids, need to copy over app_id array and delete it
+# 4. Remove identifier
+#
+class Device
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include CheckinAble
+  #
+  # Fields
+  #
+  field :unique_identifier, type: String
+  field :platform, type: String
+  field :name, type: String
+  field :os_version, type: String
+  field :manufacture, type: String
+  field :model, type: String
+  field :internal_model, type: String
+  field :capacity, type: String
+  #
+  # relationships
+  #
+  has_many :agents
+  has_and_belongs_to_many :apps, class_name: 'InternalApp', inverse_of: nil
+  #
+  # Callbacks
+  #
+  set_callback :save, :before, :model_market_name
+  set_callback :find, :after, :migrate_data
+
+  #
+  # Fetch or create a device
+  #
+  def self.fetch(json)
+    device_identifier = json[:device_identifier]
+    raise 'device_id cannot be nil' if device_identifier.nil?
+
+    device = Device.find_or_initialize_by(unique_identifier: device_identifier)
+    device.update_attributes!(json)
+    device
+  end
+
+  #
+  # Safely update attributes from the document
+  #
+  def update_attributes!(attributes = {})
+    super(filter_json(attributes))
+  end
+
+  #
+  # Safely update attributes from the document
+  #
+  def update!(attributes = {})
+    super(filter_json(attributes))
+  end
+
+  #
+  # filter only the json parameters we want to take into the device. The agent
+  # sends up more than we need for the device.
+  #
+  def filter_json(json)
+    filtered_json = {}
+    filtered_json[:platform] = json[:device_platform] if json[:device_platform]
+    filtered_json[:os_version] = json[:device_os_version] if json[:device_os_version]
+    filtered_json[:manufacture] = json[:device_manufacture] if json[:device_manufacture]
+    filtered_json[:capacity] = json[:device_capacity] if json[:device_capacity]
+    filtered_json[:model] = json[:device_model] if json[:device_model]
+    filtered_json[:name] = json[:device_name] if json[:device_name]
+    filtered_json
+  end
+
+  private
+
+  #
+  # clean up old app_id list to add things to app_ids
+  # Also clear out the identifier attribute, should no longer be there.
+  #
+  def migrate_data
+    remove_attribute :identifier
+    migrate_app_ids if self[:app_id].present?
+  end
+
+  #
+  # Transfer the app_id array to app_ids
+  #
+  def migrate_app_ids
+    self[:app_id].each do |app_id|
+      begin
+        apps << InternalApp.find(app_id)
+      rescue StandardError
+        next
+      end
+    end
+    remove_attribute :app_id
+  end
+
+  #
+  # Update the model name based on the market name
+  #
+  def model_market_name
+    return unless changed.include?('model')
+
+    platform_key = "platform::#{platform}"
+    platform_model = App47Cache.get(platform_key)
+    if platform_model.nil?
+      platform_model = Platform.where(name: platform).first
+      App47Cache.set(platform_key, platform_model, 604_800)
+    end
+    return if platform_model.nil? || model.eql?(platform_model.market_name(model))
+
+    self.internal_model = model
+    self.model = platform_model.market_name(model)
+  rescue StandardError
+    App47Cache.delete(platform_key)
+  end
+end

data/lib/models/external_app.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+#
+# An external app is one that is in a public app store, iTunes, Google Play, etc..
+#
+class ExternalApp < App
+  #
+  # Fields
+  # @
+  field :wp8_external_id, type: String
+  field :windows_external_id, type: String
+  field :additional_note, type: String
+  field :windows_external_url, type: String
+  field :external_auto_update, type: Boolean, default: true
+end

data/lib/models/gehc/customer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# Extension of customer specific to GEHC features.
+#
+module Gehc
+  class Customer < User
+    #
+    # Find a user device by safely trying a number of approaches
+    #
+    def find_device_by(device_id)
+      suepr || devices.where(serialNumber: device_id).first
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/models/gehc/customer_device.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Gehc
+  #
+  # GEHC Customer device
+  #
+  class CustomerDevice < UserDevice
+    field :serialNumber, type: String
+
+    #
+    # Find a user device by safely trying a number of approaches
+    # 1. By ID
+    # 2. By unique identifier
+    # 3. By app47 identifier
+    # 4. By token
+    #
+    def self.find_device_by(device_id)
+      super || Gehc::CustomerDevice.where(serialNumber: device_id).first
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/models/group.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+#
+# Holds a collection of users in a group. Also contains a collection of apps
+# that those users will have access to
+#
+class Group
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Searchable
+
+  field :name, type: String
+  field :display_name, type: String
+  field :description, type: String
+
+  validates_presence_of :name
+
+  belongs_to :parent, class_name: 'Group', inverse_of: :children
+  has_many :children, dependent: :destroy, class_name: 'Group', inverse_of: :parent
+
+  # has_and_belongs_to_many :users, dependent: :nullify
+  has_many :user_app_permissions, dependent: :destroy
+  has_and_belongs_to_many :inherited_apps, dependent: :nullify, class_name: 'App'
+  has_and_belongs_to_many :apps, inverse_of: :groups, dependent: :nullify
+  belongs_to :account, inverse_of: :groups
+
+  #
+  # Internal: Which fields to add to search text
+  #
+  # Examples
+  #
+  #   search_fields
+  #   # => ['name']
+  #
+  # Return which fields should be added to
+  #
+  def search_fields
+    %w[name]
+  end
+end

data/lib/models/internal_app.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+#
+# Internal App, the only app that should be talking to the API
+#
+class InternalApp < App
+  include App47AppAnalyzable
+  include App47AppBuildable
+  include App47AppPolicies
+  include App47AppConfigurable
+end

data/lib/models/metric_data_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+#
+# Placeholder, job will be run in WebUI, not in the API
+#
+class MetricDataJob
+  attr_accessor :payload
+
+  def self.perform_later(payload = {})
+    MetricDataJob.new.perform(payload.to_json)
+  end
+
+  def perform(_payload = {}); end
+
+  handle_asynchronously :perform
+end

data/lib/models/option.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+#
+# Holds a single app configuration option, essentially
+# a key value pair within the configuration group
+#
+class Option
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  #
+  # Fields
+  #
+  field :key, type: String
+  field :value_type, type: String
+  field :value, type: String
+  #
+  # Relationships
+  #
+  embedded_in :configuration_group
+  #
+  # Validations
+  #
+  validates_presence_of(:key)
+  validates_presence_of(:value_type)
+  validates_uniqueness_of(:key, scope: :configuration_group)
+
+  #
+  # Return the payload for the agent
+  #
+  def agent_payload
+    { updated_at: (updated_at || Date.new),
+      key: key,
+      value: value,
+      type: value_type,
+      id: id.to_s }
+  end
+end

data/lib/models/pin_code_policy.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+#
+# Pin code policy for this app
+#
+class PinCodePolicy < AppPolicy
+  include Base64
+  #
+  # fields
+  #
+  field :dialog, type: String, default: 'PIN Code'
+  field :unknown_user_message, type: String, default: 'Unable to determine a valid user, please contact support'
+  field :pin_locked_message,
+        type: String,
+        default: 'PIN Code is locked, please return to the App Store to set your PIN Code or contact support'
+  field :lock_after_failures, type: Integer, default: 4
+  field :session_hours, type: Integer, default: 24
+  #
+  # return the policy hash for this agent
+  #
+  def enforce_policy(agent)
+    policy = super.merge(pin_code_required: 0)
+    return policy unless active?
+
+    policy[:pin_code_required] = 1
+    policy[:pin_code_locked] = 0
+    policy[:pin_code_dialog_label] = dialog
+    user = agent.find_user
+    if user.present?
+      if user.pin_code_locked?
+        policy[:pin_code_locked] = 1
+        policy[:pin_code_message] = pin_locked_message
+      elsif user.pin_code.blank?
+        policy[:pin_code_message] = message
+      else
+        policy[:pin_code] = agent.encrypt_data(user.pin_code)
+        policy[:pin_code_message] = pin_locked_message
+        policy[:pin_code_lock_after_failures] = lock_after_failures
+        policy[:pin_code_session_hours] = session_hours
+      end
+    else
+      policy[:pin_code_message] = unknown_user_message
+    end
+    policy
+  rescue StandardError => error
+    log_error("Unable to build pin code policy for agent: #{agent.inspect} - #{inspect}", error)
+    # Return the default policy
+    { require_passcode: 0 }
+  end
+end

data/lib/models/platform.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#
+# Hold available platforms
+#
+class Platform
+  include Mongoid::Document
+  field :name, type: String
+  #
+  # Validations
+  #
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  #
+  # relationships
+  #
+  embeds_many :models, class_name: 'PlatformModel'
+
+  #
+  # return the market name for the given name
+  #
+  def market_name(model_name)
+    market_model = models.where(name: model_name).first
+    market_model.nil? ? model_name : market_model.market_name
+  end
+end

data/lib/models/platform_model.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+#
+# A given model for a platform.
+#
+class PlatformModel
+  include Mongoid::Document
+  field :name, type: String
+  field :market_name, type: String
+  #
+  # Relationships
+  #
+  embedded_in :platform
+end

data/lib/models/product_app.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# Product Apps is a base class for applications used in an Embeeded App Store Implementation such as
+# GEHC and Caterpillar
+#
+# Currently there will be three types of apps extending this class
+# * CommerceAppStore - Although a better name would be AppStoreApp, this already exists and not worth renaming
+# * ProductSupportApp - A supporting app needed for the customer's product to work correctly.
+#
+class ProductApp < App
+  include App47AppAnalyzable
+  include App47AppBuildable
+  include App47AppConfigurable
+  include App47CdnUrl
+  #
+  # Fields
+  #
+  field :restart_required, type: Boolean, default: false
+  field :accept_permissions, type: Boolean, default: false
+  field :return_to_update, type: Boolean, default: false
+end

data/lib/models/product_support_app.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+#
+# A product support app  related to an embedded app store. It's not the App47 app store, but a supporting
+# app that is needed for the overall product
+#
+class ProductSupportApp < ProductApp
+  #
+  # Fields
+  #
+  field :unique_identifier
+
+  #
+  # What is the external name we want to display
+  #
+  def external_type_name
+    'Product Support'
+  end
+end

data/lib/models/queue_manager.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+#
+# Manage the interface with the queue, simplifying the interface for pushing documents.
+#
+class QueueManager
+  class << self
+    #
+    # Push a message onto the queue name.
+    #
+    def push(document, name = ENV['RACK_ENV'])
+      case SystemConfiguration.queue_impl
+      when 'DelayedJob'
+        document[:metric_name] = name
+        document[:created_at] = Time.now.utc.to_s
+        MetricDataJob.perform_later(document)
+      else
+        raise "Unknown queue implementation: #{SystemConfiguration.queue_impl}"
+      end
+    end
+
+    #
+    # Add a timestamp to the document.
+    #
+    def add_ts(document)
+      json = document.is_a?(String) ? JSON.parse(document) : document
+      json[:created_at] = Time.now.utc.to_s
+      json.to_json
+    end
+
+    #
+    # Push to the WebUI Worker
+    #
+    def push_worker(message)
+      push(message)
+    end
+
+    #
+    # Push to the session queue
+    #
+    def push_session(message)
+      push(message, :session_events)
+    end
+
+    #
+    # Push to the timed event queue
+    #
+    def push_timed_event(message)
+      push(message, :timedevents_events)
+    end
+
+    #
+    # Push the generic event queue
+    #
+    def push_generic_event(message)
+      push(message, :generic_events)
+    end
+
+    #
+    # push log event queue
+    #
+    def push_log_event(message)
+      # encoded_doc = message.to_s.force_encoding('UTF-8')
+      push(message, :log_events)
+    end
+  end
+end