moki_ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56759e3cd228fdbed3145ceca240cc9e1f56ff76
-  data.tar.gz: ba4779f759632df8cdb2152a718e9b14c7f39ef7
+  metadata.gz: c0a94a38cb0b659e29af3ca6bc390e3b9cb78dd4
+  data.tar.gz: 0209ee2b6262b17e228d0ba671672c92400af57a
 SHA512:
-  metadata.gz: 465c74e207e8e012121c3c2c984cf6b61bb58c370657334abfa6e04811dfe1876d208c5fe889b38ac578fe3bb54d96882c8e12084ed2d987ffd5803faaa10fa1
-  data.tar.gz: a85a20ee50bfa5e2bcd0be308afd21c75b9402f0be01523b8e85ce6a611b369d52e1ab3a99c60249b361194e9cd7c8c8393e23f7e198395d8e9962ae275efcd8
+  metadata.gz: 82bc152c026cfe0a9fe5333c2a7b58da1ff675d73c787c84ea2a48b4eb7afabff579797057fdf51db81b07b38df11b9e57306602b5850b4cb01a016ab167dd7e
+  data.tar.gz: ca891aa084ef3673b5b34275228ac2b8424550d3dca0112468ef2e2f3197de0514b1d448f87e8802fd039df15dc2378296a8c679479225c93aed6fbed44fad2a

data/README.md

@@ -1,6 +1,7 @@
 # MokiRuby
 
-[![travis-status](https://travis-ci.org/bellycard/moki_ruby.svg)](https://travis-ci.org/bellycard/moki_ruby)
+[![travis-status](https://travis-ci.org/bellycard/moki_ruby.svg)](https://travis-ci.org/bellycard/moki_ruby) [![Gem
+Version](https://badge.fury.io/rb/moki_ruby.svg)](http://badge.fury.io/rb/moki_ruby)
 
 A ruby gem for interacting with the Moki API, as a part of Moki Total
 Control and Moki Management.
@@ -19,8 +20,6 @@ Or install it yourself as:
 
     $ gem install moki_ruby
 
-## Usage
-
 Make sure to set the following environment variables:
 
 ```
@@ -29,13 +28,46 @@ ENV['MOKI_TENANT_ID']
 ENV['MOKI_API_KEY']
 ```
 
+## Usage
+
+Device management can be done at the Tenant Level (across all devices)
+or at the individual device level.
+
+### Tenant Methods
+
 The following methods have been built out:
 
-- `MokiRuby.ios_profiles` asks for all current profiles associated with this tenant.
-- `MokiRuby.device_profiles(device_id)` asks for all profiles installed
-  on the provided device. `device_id` must be a UDID or a serial number.
-- `MokiRuby.device_managed_apps(device_id)` asks for all managed apps on
-  a specific device, provided in a simplified list.
+- `MokiRuby.ios_profiles` asks for all current profiles associated with this
+  tenant. This will return an array of `IOSProfile` objects.
+- `MokiRuby.tenant_managed_apps` asks for all apps associaited with this
+  tenant. This will return an array of `TenantManagedApp` objects.
+
+### Device Methods
+
+First, create a device through one of the following approaches:
+
+```
+MokiRuby::Device.new(serial_number)
+MokiRuby::Device.new(udid)
+```
+
+Using this device, there are several methods available:
+
+- `device.profiles` returns all profiles currently installed on a
+  device. This will return an array of `IOSProfile` objects.
+- `device.managed_apps` returns all managed applications installed on a
+  device. This will return an array of `DeviceManagedApp` objects.
+- `device.install_app(app)` takes in a `TenantManagedApp` object, and
+  will install the given application on the device. Returns an
+  `Action` object, for tracking in the future.
+- `device.add_profile(profile)` takes in an `IOSProfile` object, and
+  will install the given profile on the device. Returns an `Action`
+  object, for tracking in the future.
+- `device.remove_profile(profile)` take in an `IOSProfile` object, and
+  will remove the given profile from the device. Returns an `Action`
+  object, for tracking in the future.
+- `device.get_action(action_id)` will take in an `id` from an `Action`
+  object, and return an updated `Action` object.
 
 ## Contributing
 

data/lib/moki_api.rb

@@ -3,7 +3,6 @@ require 'faraday_middleware'
 require 'celluloid/io'
 require 'future_wrapper'
 require 'hashie'
-require 'moki_ruby/device_identifier'
 
 class MokiAPI
   include Celluloid::IO
@@ -14,23 +13,23 @@ class MokiAPI
   end
 
   def self.device_profile_list(device_id)
-    if DeviceIdentifier.is_udid?(device_id)
-      issue_request(:get, full_url("/devices/#{ device_id }/profiles"), {})
-    elsif DeviceIdentifier.is_serial?(device_id)
-      issue_request(:get, full_url("/devices/sn-!-#{ device_id }/profiles"), {})
-    else
-      raise "Must pass a serial number or UDID to get device profile list"
-    end
+    issue_request(:get, full_url("/devices/#{ device_id }/profiles"), {})
+  end
+
+  def self.tenant_managed_app_list
+    issue_request(:get, full_url('/iosmanagedapps'), {})
   end
 
   def self.device_managed_app_list(device_id)
-    if DeviceIdentifier.is_udid?(device_id)
-      issue_request(:get, full_url("/devices/#{ device_id }/managedapps"), {})
-    elsif DeviceIdentifier.is_serial?(device_id)
-      issue_request(:get, full_url("/devices/sn-!-#{ device_id }/managedapps"), {})
-    else
-      raise "Must pass a serial number or UDID to get device profile list"
-    end
+    issue_request(:get, full_url("/devices/#{ device_id }/managedapps"), {})
+  end
+
+  def self.perform_action(device_id, body_hash)
+    issue_request(:put, full_url("/devices/#{ device_id }/actions"), body_hash)
+  end
+
+  def self.action(device_id, action_id)
+    issue_request(:get, full_url("/devices/#{ device_id }/actions/#{ action_id }"), {})
   end
 
   def self.full_url(path)
@@ -74,7 +73,7 @@ private
         status: response.status,
         headers: response.headers
       })
-    rescue => e
+    rescue
       response
     end
   end

data/lib/moki_ruby.rb

@@ -6,13 +6,8 @@ module MokiRuby
     data.body.map { |profile| IOSProfile.from_hash(profile) }
   end
 
-  def self.device_profiles(device_id)
-    data = MokiAPI.device_profile_list(device_id).value
-    data.body.map { |profile| IOSProfile.from_hash(profile) }
-  end
-
-  def self.device_managed_apps(device_id)
-    data = MokiAPI.device_managed_app_list(device_id).value
-    data.body.map { |app| DeviceManagedApp.from_hash(app) }
+  def self.tenant_managed_apps
+    data = MokiAPI.tenant_managed_app_list.value
+    data.body.map { |profile| TenantManagedApp.from_hash(profile) }
   end
 end

data/lib/moki_ruby/action.rb

@@ -0,0 +1,33 @@
+class Action
+  attr_accessor :id, :last_seen, :action, :status, :client_name, :item_name, :third_party_user, :payload, :note
+
+  def self.from_hash(input_hash)
+    new_action = self.new
+
+    new_action.id = input_hash["id"]
+    new_action.last_seen = input_hash["lastSeen"]
+    new_action.action = input_hash["action"]
+    new_action.status = input_hash["status"]
+    new_action.client_name = input_hash["clientName"]
+    new_action.item_name = input_hash["itemName"]
+    new_action.third_party_user = input_hash["thirdPartyUser"]
+    new_action.payload = input_hash["payload"]
+    new_action.note = input_hash["note"]
+
+    new_action
+  end
+
+  def to_hash
+    {
+      "id" => self.id,
+      "lastSeen" => self.last_seen,
+      "action" => self.action,
+      "status" => self.status,
+      "clientName" => self.client_name,
+      "itemName" => self.item_name,
+      "thirdPartyUser" => self.third_party_user,
+      "payload" => self.payload,
+      "note" => self.note
+    }
+  end
+end

data/lib/moki_ruby/device.rb

@@ -0,0 +1,70 @@
+module MokiRuby
+  class Device
+    attr :id, :identifier_type
+
+    def initialize(identifier)
+      if is_serial?(identifier)
+        @identifier_type = :serial
+      elsif is_udid?(identifier)
+        @identifier_type = :udid
+      else
+        raise "Valid UDID or Serial Number required"
+      end
+      @id = identifier
+    end
+
+    def profiles
+      data = MokiAPI.device_profile_list(device_id_param).value
+      data.body.map { |profile| IOSProfile.from_hash(profile) }
+    end
+
+    def managed_apps
+      data = MokiAPI.device_managed_app_list(device_id_param).value
+      data.body.map { |app| DeviceManagedApp.from_hash(app) }
+    end
+
+    def install_app(tenant_managed_app)
+      raise "Tenant Managed App required" unless tenant_managed_app && tenant_managed_app.kind_of?(TenantManagedApp)
+
+      data = MokiAPI.perform_action(device_id_param, tenant_managed_app.install_hash).value
+      Action.from_hash(data.body)
+    end
+
+    def add_profile(profile)
+      raise "IOSProfile required" unless profile && profile.is_a?(IOSProfile)
+
+      data = MokiAPI.perform_action(device_id_param, profile.install_hash).value
+      Action.from_hash(data.body)
+    end
+
+    def remove_profile(profile)
+      raise "IOSProfile required" unless profile && profile.is_a?(IOSProfile)
+
+      data = MokiAPI.perform_action(device_id_param, profile.removal_hash).value
+      Action.from_hash(data.body)
+    end
+
+    def get_action(action_id)
+      data = MokiAPI.action(device_id_param, action_id).value
+      Action.from_hash(data.body)
+    end
+
+    def device_id_param
+      if identifier_type == :serial
+        "sn-!-#{ id }"
+      else
+        id
+      end
+    end
+
+    private
+
+    def is_serial?(id)
+      (!id.nil? && id.length == 12)
+    end
+
+    def is_udid?(id)
+      !(/\A[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\Z/.match(id)).nil?
+    end
+  end
+end

data/lib/moki_ruby/device_managed_app.rb

@@ -2,12 +2,12 @@ class DeviceManagedApp
   attr_accessor :status, :app_identifier, :management_flags
 
   def self.from_hash(input_hash)
-    new_profile = self.new
-    new_profile.status = input_hash['Status']
-    new_profile.app_identifier = input_hash['appIdentifier']
-    new_profile.management_flags = input_hash['ManagementFlags']
+    new_app = self.new
+    new_app.status = input_hash['Status']
+    new_app.app_identifier = input_hash['appIdentifier']
+    new_app.management_flags = input_hash['ManagementFlags']
 
-    new_profile
+    new_app
   end
 
   def to_hash

data/lib/moki_ruby/iosprofile.rb

@@ -1,20 +1,46 @@
 class IOSProfile
-  attr_accessor :id, :lastSeen, :name, :displayName, :description, :identifier
+  attr_accessor :id, :last_seen, :name, :display_name, :description, :identifier
 
   def self.from_hash(input_hash)
     new_profile = self.new
-    %w(id lastSeen name displayName description identifier).each do |attr|
-      new_profile.send("#{ attr }=", input_hash[attr])
-    end
+    new_profile.id = input_hash["id"]
+    new_profile.last_seen = input_hash["lastSeen"]
+    new_profile.name = input_hash["name"]
+    new_profile.display_name = input_hash["displayName"]
+    new_profile.description = input_hash["description"]
+    new_profile.identifier = input_hash["identifier"]
 
     new_profile
   end
 
   def to_hash
-    {}.tap do |hash|
-      self.instance_variables.each do |var|
-        hash[var.to_s.delete("@")] = instance_variable_get(var)
-      end
-    end
+    {
+      "id" => self.id,
+      "lastSeen" => self.last_seen,
+      "name" => self.name,
+      "displayName" => self.display_name,
+      "description" => self.description,
+      "identifier" => self.identifier
+    }
+  end
+
+  def install_hash
+    actionable_hash.merge({ "action" => "installprofile",
+                            "payload" => "{#{ self.id }}" })
+  end
+
+  def removal_hash
+    actionable_hash.merge({ "action" => "removeprofile",
+                            "payload" => "{#{ self.identifier }}" })
+  end
+
+private
+  def actionable_hash
+    {
+      "thirdPartyUser" => "moki_ruby",
+      "clientName" => "MokiRuby",
+      "itemName" => self.name,
+      "notify" => true
+    }
   end
 end

data/lib/moki_ruby/tenant_managed_app.rb

@@ -0,0 +1,56 @@
+class TenantManagedApp
+  attr_accessor :id, :last_seen, :name, :identifier, :version,
+                :management_flags, :itunes_store_id, :manifest_url
+
+  def self.from_hash(input_hash)
+    new_app = self.new
+    new_app.id = input_hash["id"]
+    new_app.last_seen = input_hash["lastSeen"]
+    new_app.name = input_hash["name"]
+    new_app.identifier = input_hash["identifier"]
+    new_app.version = input_hash["version"]
+    new_app.management_flags = input_hash["ManagementFlags"]
+    new_app.itunes_store_id = input_hash["iTunesStoreID"]
+    new_app.manifest_url = input_hash["ManifestURL"]
+
+    new_app
+  end
+
+  def to_hash
+    { "id" => self.id,
+      "lastSeen" => self.last_seen,
+      "name" => self.name,
+      "identifier" => self.identifier,
+      "version" => self.version,
+      "ManagementFlags" => self.management_flags,
+      "iTunesStoreID" => self.itunes_store_id,
+      "ManifestURL" => self.manifest_url }
+  end
+
+  def install_hash
+    {
+      "action" => "install_app",
+      "thirdPartyUser" => "moki_ruby",
+      "clientName" => "MokiRuby",
+      "itemName" => self.name,
+      "notify" => true,
+      "payload" => {
+                     "ManagementFlags" => self.management_flag,
+                     "identifier" => self.identifier,
+                     "version" => self.version
+                   }.merge(self.external_locator_hash)
+    }
+  end
+
+  def management_flag
+    (!manifest_url.nil? && manifest_url != "") ? 1 : 0
+  end
+
+  def external_locator_hash
+    if manifest_url && manifest_url != ""
+      { "ManifestURL" => manifest_url }
+    else
+      { "iTunesStoreID" => itunes_store_id }
+    end
+  end
+end

data/lib/moki_ruby/version.rb

@@ -1,3 +1,3 @@
 module MokiRuby
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/lib/action_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'moki_ruby/action'
+
+describe Action do
+  let(:response_hash) {
+    { 
+      "id" => "b4d71a15­183b­4971­a3bd­d139754a40fe",
+      "lastSeen" => 1420583405416,
+      "action" => "removeprofile",
+      "status" => "completed",
+      "clientName" => "Web",
+      "itemName" => "Profile Name",
+      "thirdPartyUser" => "itsmebro",
+      "payload" => "{profile Identifier}",
+      "note" => "test"
+    }
+  }
+
+  it "will load from a hash with string keys" do
+    action = Action.from_hash(response_hash)
+
+    expect(action.id).to eq response_hash["id"]
+    expect(action.last_seen).to eq response_hash["lastSeen"]
+    expect(action.action).to eq response_hash["action"]
+    expect(action.status).to eq response_hash["status"]
+    expect(action.client_name).to eq response_hash["clientName"]
+    expect(action.item_name).to eq response_hash["itemName"]
+    expect(action.third_party_user).to eq response_hash["thirdPartyUser"]
+    expect(action.payload).to eq response_hash["payload"]
+    expect(action.note).to eq response_hash["note"]
+  end
+
+  it "will convert the response to a hash" do
+    action = Action.new
+
+    action.id = response_hash["id"]
+    action.last_seen = response_hash["lastSeen"]
+    action.action = response_hash["action"]
+    action.status = response_hash["status"]
+    action.client_name = response_hash["clientName"]
+    action.item_name = response_hash["itemName"]
+    action.third_party_user = response_hash["thirdPartyUser"]
+    action.payload = response_hash["payload"]
+    action.note = response_hash["note"]
+
+    expect(action.to_hash).to eq(response_hash)
+  end
+end

data/spec/lib/device_managed_app_spec.rb

@@ -6,8 +6,6 @@ describe DeviceManagedApp do
                           "appIdentifier" => "com.belly.gem.moki.enterprise",
                           "ManagementFlags" => 0 } }
 
-  let(:attrs) { %w(Status appIdentifier ManagementFlags) }
-
   it "will load from a hash with string keys" do
     profile = DeviceManagedApp.from_hash(response_hash)
     expect(profile.status).to eq(response_hash["Status"])
@@ -17,11 +15,10 @@ describe DeviceManagedApp do
 
   it "will convert the response to a hash" do
     profile = DeviceManagedApp.new
-    attrs.each do |attribute|
-      profile.status = "Managed"
-      profile.app_identifier = "com.belly.gem.moki.enterprise"
-      profile.management_flags = 0
-    end
+    profile.status = "Managed"
+    profile.app_identifier = "com.belly.gem.moki.enterprise"
+    profile.management_flags = 0
+
     expect(profile.to_hash).to eq(response_hash)
   end
 end

data/spec/lib/device_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'moki_ruby/device'
+
+describe MokiRuby::Device do
+  let(:sn) { "ABCDEFGHIJ12" }
+  let(:udid) { "abcd1234-1234-1234-1234-abcdef123456" }
+  let(:device) { MokiRuby::Device.new(udid) }
+
+  describe 'initialization' do
+    context "with serial number" do
+      it "is valid" do
+        device = MokiRuby::Device.new(sn)
+        expect(device.id).to eq sn
+        expect(device.identifier_type).to eq :serial
+      end
+    end
+
+    context "with UDID" do
+      it "is valid" do
+        device = MokiRuby::Device.new(udid)
+        expect(device.id).to eq udid
+      end
+    end
+
+    context "with invalid identifier" do
+      it "is invalid" do
+        expect{ MokiRuby::Device.new() }.to raise_error
+      end
+    end
+  end
+
+  describe "#device_id_param" do
+    describe "Serial Number" do
+      it "prepends serial number data" do
+        device = MokiRuby::Device.new(sn)
+        expect(device.device_id_param).to eq "sn-!-#{ sn }"
+      end
+    end
+
+    describe "UDID" do
+      it "prepends serial number data" do
+        device = MokiRuby::Device.new(udid)
+        expect(device.device_id_param).to eq udid
+      end
+    end
+  end
+
+  describe "#profiles" do
+    it "calls MokiAPI.device_profile_list with correct params" do
+      expect(MokiAPI).to receive_message_chain(:device_profile_list, :value).and_return(Hashie::Mash.new({ body: [] }))
+      device.profiles
+    end
+
+    it "returns an array of device profiles" do
+      load_good_stubs
+      profiles = device.profiles
+      expect(profiles.map { |p| p.class }.uniq).to eq [IOSProfile]
+    end
+  end
+
+  describe "#add_profile" do
+    it "requires an IOSProfile" do
+      expect { device.add_profile('erm') }.to raise_error
+    end
+
+    it "calls MokiAPI.perform with the profile's install parameters" do
+      load_good_stubs
+
+      iosprofile = IOSProfile.from_hash(@iosprofiles_stub_response.first)
+
+      expect(MokiAPI).to receive(:perform_action).with(udid, iosprofile.install_hash)
+                                                 .and_return(Hashie::Mash.new(value: { body: @action_stub_response }))
+
+      device.add_profile(iosprofile)
+    end
+  end
+
+  describe "#remove_profile" do
+    it "requires an IOSProfile" do
+      expect { device.remove_profile('erm') }.to raise_error
+    end
+
+    it "calls MokiAPI.perform with the profile's install parameters" do
+      load_good_stubs
+
+      iosprofile = IOSProfile.from_hash(@iosprofiles_stub_response.first)
+
+      expect(MokiAPI).to receive(:perform_action).with(udid, iosprofile.removal_hash)
+                                                 .and_return(Hashie::Mash.new(value: { body: @action_stub_response }))
+
+      device.remove_profile(iosprofile)
+    end
+  end
+
+  describe "#install_app" do
+    it "requires a TenantManagedApp" do
+      expect { device.install_app('foo') }.to raise_error
+    end
+
+    it "calls MokiAPI.perform with store app parameters" do
+      load_good_stubs
+
+      tenant_managed_app = TenantManagedApp.from_hash({ "name" => "MokiTouch 2.0",
+                                                        "identifier" => "com.mokimobility.mokitouch2",
+                                                        "version" => "1.1.1",
+                                                        "ManagementFlags" => 0,
+                                                        "ManifestURL" => "some url" })
+
+      expect(MokiAPI).to receive(:perform_action).with(udid, tenant_managed_app.install_hash)
+                                                 .and_return(Hashie::Mash.new(value: { body: @action_stub_response }))
+      device.install_app(tenant_managed_app)
+    end
+  end
+
+  describe "#managed_apps" do
+    it "calls MokiAPI.device_managed_app_list" do
+      response = []
+      expect(MokiAPI).to receive_message_chain(:device_managed_app_list, :value).and_return(Hashie::Mash.new({ body: response, status: 200, headers: {} }))
+      device.managed_apps
+    end
+
+    it "returns an array of managed_apps" do
+      load_good_stubs
+      apps = device.managed_apps
+      expect(apps.map { |app| app.class }.uniq).to eq [DeviceManagedApp]
+    end
+  end
+
+  describe "#get_action" do
+    let(:action_id) { "b4d71a15­183b­4971­a3bd­d139754a40fe" }
+
+    it "calls MokiAPI.action" do
+      expect(MokiAPI).to receive_message_chain(:action, :value).and_return(Hashie::Mash.new({ body: {}, status: 200, headers: {} }))
+      device.get_action(action_id)
+    end
+
+    it "returns an Action object" do
+      load_good_stubs
+      action = device.get_action(action_id)
+      expect(action).to be_kind_of(Action)
+    end
+  end
+end

data/spec/lib/iosprofile_spec.rb

@@ -9,20 +9,46 @@ describe IOSProfile do
                           "description" => "Profile Description",
                           "identifier" => "abcdef12345-abc-123-ffeea.test" } }
 
-  let(:attrs) { %w(id lastSeen name displayName description identifier) }
-
   it "will load from a hash with string keys" do
     profile = IOSProfile.from_hash(response_hash)
-    attrs.each do |attribute|
-      expect(profile.send(attribute)).to eq(response_hash[attribute])
-    end
+
+    expect(profile.id).to eq(response_hash["id"])
+    expect(profile.last_seen).to eq(response_hash["lastSeen"])
+    expect(profile.name).to eq(response_hash["name"])
+    expect(profile.display_name).to eq(response_hash["displayName"])
+    expect(profile.description).to eq(response_hash["description"])
+    expect(profile.identifier).to eq(response_hash["identifier"])
   end
 
   it "will convert the response to a hash" do
     profile = IOSProfile.new
-    attrs.each do |attribute|
-      profile.send("#{ attribute }=", response_hash[attribute])
-    end
+    profile.id = response_hash["id"]
+    profile.last_seen = response_hash["lastSeen"]
+    profile.name = response_hash["name"]
+    profile.display_name = response_hash["displayName"]
+    profile.description = response_hash["description"]
+    profile.identifier = response_hash["identifier"]
+
     expect(profile.to_hash).to eq(response_hash)
   end
+
+  it "will return a hash for installing" do
+    profile = IOSProfile.from_hash(response_hash)
+    expect(profile.install_hash).to eq({ "action" => "installprofile",
+                                         "thirdPartyUser" => "moki_ruby",
+                                         "clientName" => "MokiRuby",
+                                         "itemName" => "Profile Name",
+                                         "notify" => true,
+                                         "payload" => "{01234699-5767-8abc-d123-ffffffffffff}" })
+  end
+
+  it "will return a hash for removal" do
+    profile = IOSProfile.from_hash(response_hash)
+    expect(profile.removal_hash).to eq({ "action" => "removeprofile",
+                                         "thirdPartyUser" => "moki_ruby",
+                                         "clientName" => "MokiRuby",
+                                         "itemName" => "Profile Name",
+                                         "notify" => true,
+                                         "payload" => "{abcdef12345-abc-123-ffeea.test}" })
+  end
 end

data/spec/lib/moki_api_spec.rb

@@ -41,24 +41,13 @@ describe MokiAPI do
     end
 
     describe "device profile list" do
-      it 'hits the endpoint correctly with a UDID' do
-        expect(MokiAPI).to receive(:issue_request) { |method, url, options|
-          expect(method).to eq(:get)
-          expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/devices/abcd1234-1234-1234-1234-abcdef123456/profiles")
-        }.and_return('{}')
-        MokiAPI.device_profile_list("abcd1234-1234-1234-1234-abcdef123456")
-      end
-
-      it 'hits the endpoint correctly with a serial number' do
+      it 'issues a get request using device parameter' do
+        param = "sn-!-ABCDEFGHIJ12" 
         expect(MokiAPI).to receive(:issue_request) { |method, url, options|
           expect(method).to eq(:get)
-          expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/devices/sn-!-ABCDEFGHIJ12/profiles")
+          expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/devices/#{ param }/profiles")
         }.and_return('{}')
-        MokiAPI.device_profile_list("ABCDEFGHIJ12")
-      end
-
-      it 'raises an error if not given a serial or udid' do
-        expect { MokiAPI.device_profile_list("ermishness-nope") }.to raise_error
+        MokiAPI.device_profile_list(param)
       end
     end
 
@@ -70,17 +59,38 @@ describe MokiAPI do
         }.and_return('{}')
         MokiAPI.device_managed_app_list("abcd1234-1234-1234-1234-abcdef123456")
       end
+    end
+
+    describe "action" do
+      let(:action_id) { "b4d71a15­183b­4971­a3bd­d139754a40fe" }
 
-      it 'hits the endpoint correctly with a serial number' do
+      it 'hits the endpoint correctly with a Device ID and Action id' do
         expect(MokiAPI).to receive(:issue_request) { |method, url, options|
           expect(method).to eq(:get)
-          expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/devices/sn-!-ABCDEFGHIJ12/managedapps")
+          expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/devices/abcd1234-1234-1234-1234-abcdef123456/actions/#{action_id}")
         }.and_return('{}')
-        MokiAPI.device_managed_app_list("ABCDEFGHIJ12")
+        MokiAPI.action("abcd1234-1234-1234-1234-abcdef123456", "b4d71a15­183b­4971­a3bd­d139754a40fe")
       end
+    end
+
+    it 'hits the iosprofiles endpoint correctly' do
+      expect(MokiAPI).to receive(:issue_request) { |method, url, options|
+        expect(method).to eq(:get)
+        expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/iosmanagedapps")
+      }.and_return('{}')
+      MokiAPI.tenant_managed_app_list
+    end
+
+    describe "perform action" do
+      it 'performs put request to action endpoint with provided parameters' do
+        body_hash = { foo: 'bar' }
+        expect(MokiAPI).to receive(:issue_request) { |method, url, options|
+          expect(method).to eq(:put)
+          expect(url).to eq("http://localhost:9292/rest/v1/api/tenants/#{ ENV['MOKI_TENANT_ID'] }/devices/abcd1234-1234-1234-1234-abcdef123456/actions")
+          expect(options).to eq body_hash
+        }.and_return('{}')
 
-      it 'raises an error if not given a serial or udid' do
-        expect { MokiAPI.device_managed_app_list("ermishness-nope") }.to raise_error
+        MokiAPI.perform_action('abcd1234-1234-1234-1234-abcdef123456', body_hash)
       end
     end
   end

data/spec/lib/tenant_managed_app_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'moki_ruby/tenant_managed_app'
+
+describe TenantManagedApp do
+  let(:response_hash) { { "id" => "30dedb70­62a9­41b8­b5f0­c960d7d8f79a",
+                          "lastSeen" => 1384278494336,
+                          "name" => "MokiTouch 2.0",
+                          "identifier" => "com.mokimobility.mokitouch2",
+                          "version" => "1.1.1",
+                          "ManagementFlags" => 0,
+                          "iTunesStoreID" => "733151730",
+                          "ManifestURL" => "http://www.mokimanage.com/app" } }
+
+  it "will load from a hash with string keys" do
+    app = TenantManagedApp.from_hash(response_hash)
+    expect(app.id).to eq(response_hash["id"])
+    expect(app.last_seen).to eq(response_hash["lastSeen"])
+    expect(app.name).to eq(response_hash["name"])
+    expect(app.identifier).to eq(response_hash["identifier"])
+    expect(app.version).to eq(response_hash["version"])
+    expect(app.management_flags).to eq(response_hash["ManagementFlags"])
+    expect(app.itunes_store_id).to eq(response_hash["iTunesStoreID"])
+    expect(app.manifest_url).to eq(response_hash["ManifestURL"])
+  end
+
+  it "will convert the response to a hash" do
+    app = TenantManagedApp.new
+    app.id = "30dedb70­62a9­41b8­b5f0­c960d7d8f79a"
+    app.last_seen = 1384278494336
+    app.name = "MokiTouch 2.0"
+    app.identifier = "com.mokimobility.mokitouch2"
+    app.version = "1.1.1"
+    app.management_flags = 0
+    app.itunes_store_id = "733151730"
+    app.manifest_url = "http://www.mokimanage.com/app"
+
+    expect(app.to_hash).to eq(response_hash)
+  end
+
+  describe "management_flag" do
+    it "returns 1 if the device has a manifest url" do
+      app = TenantManagedApp.from_hash({"ManifestURL" => "https://www.mokimanage.com"})
+      expect(app.management_flag).to eq(1)
+    end
+
+    it "returns 0 if the device has an iTunesStoreID" do
+      app = TenantManagedApp.from_hash({"iTunesStoreID" => "733151730"})
+      expect(app.management_flag).to eq(0)
+    end
+  end
+
+  describe "external_locator_hash" do
+    it "returns a hash with the manifest url if it has one" do
+      app = TenantManagedApp.from_hash({"ManifestURL" => "https://www.mokimanage.com"})
+      expect(app.external_locator_hash).to eq({"ManifestURL" => "https://www.mokimanage.com"})
+    end
+
+    it "returns a hash with the itunes store id if it does not have a manifest url" do
+      app = TenantManagedApp.from_hash({"iTunesStoreID" => "733151730"})
+      expect(app.external_locator_hash).to eq({"iTunesStoreID" => "733151730"})
+    end
+  end
+
+  describe "install_hash" do
+    it "returns a specially crafted action hash for installing the app" do
+      app = TenantManagedApp.from_hash(response_hash)
+      expect(app.install_hash).to eq({ "action" => "install_app",
+                                       "thirdPartyUser" => "moki_ruby",
+                                       "clientName" => "MokiRuby",
+                                       "itemName" => "MokiTouch 2.0",
+                                       "notify" => true,
+                                       "payload" => {
+                                         "ManagementFlags" => 1,
+                                         "identifier" => "com.mokimobility.mokitouch2",
+                                         "version" => "1.1.1",
+                                         "ManifestURL" => "http://www.mokimanage.com/app" }})
+    end
+
+    it "will send the itunes store id if missing the manifest url" do
+      response_hash.delete("ManifestURL")
+      app = TenantManagedApp.from_hash(response_hash)
+      expect(app.install_hash["payload"]["ManifestURL"]).to be_nil
+      expect(app.install_hash["payload"]["iTunesStoreID"]).to eq(response_hash["iTunesStoreID"])
+    end
+  end
+end

data/spec/moki_ruby_spec.rb

@@ -28,13 +28,13 @@ describe MokiRuby do
     end
   end
 
-  describe ".device_profiles" do
+  describe ".tenant_managed_apps" do
     it "raises an error if no tenant ID is provided" do
       ENV['MOKI_API_URL'] = 'http://localhost:9292'
       ENV['MOKI_TENANT_ID'] = ''
       ENV['MOKI_API_KEY'] = 'secret-key'
 
-      expect { MokiRuby.device_profiles('ABC123DEF456') }.to raise_error
+      expect { MokiRuby.tenant_managed_apps }.to raise_error
     end
 
     it "raises an error if no API key is provided" do
@@ -42,59 +42,15 @@ describe MokiRuby do
       ENV['MOKI_TENANT_ID'] = 'abcd123-test'
       ENV['MOKI_API_KEY'] = ''
 
-      expect { MokiRuby.device_profiles('ABC123DEF456') }.to raise_error
-    end
-
-    it "raises an error if the device id is bad" do
-      ENV['MOKI_API_URL'] = 'http://localhost:9292'
-      ENV['MOKI_TENANT_ID'] = 'abcd123-test'
-      ENV['MOKI_API_KEY'] = 'secret-key'
-
-      expect(MokiAPI).to_not receive(:issue_request)
-      expect { MokiRuby.device_profiles('BADSERIAL') }.to raise_error
-    end
-
-    it "retuns an array of IOSProfile objects" do
-      load_good_stubs
-      data = MokiRuby.device_profiles('ABC123DEF456')
-      expect(data.count).to eq(4)
-      expect(data.first).to be_kind_of(IOSProfile)
-      expect(data.first.name).to eq("Test Profile 1")
-    end
-  end
-
-  describe ".device_managed_apps" do
-    it "raises an error if no tenant ID is provided" do
-      ENV['MOKI_API_URL'] = 'http://localhost:9292'
-      ENV['MOKI_TENANT_ID'] = ''
-      ENV['MOKI_API_KEY'] = 'secret-key'
-
-      expect { MokiRuby.device_managed_apps('ABC123DEF456') }.to raise_error
-    end
-
-    it "raises an error if no API key is provided" do
-      ENV['MOKI_API_URL'] = 'http://localhost:9292'
-      ENV['MOKI_TENANT_ID'] = 'abcd123-test'
-      ENV['MOKI_API_KEY'] = ''
-
-      expect { MokiRuby.device_managed_apps('ABC123DEF456') }.to raise_error
-    end
-
-    it "raises an error if the device id is bad" do
-      ENV['MOKI_API_URL'] = 'http://localhost:9292'
-      ENV['MOKI_TENANT_ID'] = 'abcd123-test'
-      ENV['MOKI_API_KEY'] = 'secret-key'
-
-      expect(MokiAPI).to_not receive(:issue_request)
-      expect { MokiRuby.device_managed_apps('BADSERIAL') }.to raise_error
+      expect { MokiRuby.tenant_managed_apps }.to raise_error
     end
 
     it "retuns an array of IOSProfile objects" do
       load_good_stubs
-      data = MokiRuby.device_managed_apps('ABC123456DEF')
+      data = MokiRuby.tenant_managed_apps
       expect(data.count).to eq(2)
-      expect(data.first).to be_kind_of(DeviceManagedApp)
-      expect(data.first.status).to eq("Managed")
+      expect(data.first).to be_kind_of(TenantManagedApp)
+      expect(data.first.name).to eq("MokiTouch 2.0")
     end
   end
 end

data/spec/support/common_stubs.rb

@@ -7,6 +7,13 @@ def load_good_stubs
   @device_managed_app_stub_response = [{ "Status" => "Managed", "appIdentifier" => "com.belly.moki.gem.enterprise", "ManagementFlags" => 1 },
                                        { "Status" => "Managed", "appIdentifier" => "com.belly.flop.html.enterprise", "ManagementFlags" => 0 }]
 
+  @tenant_managed_app_stub_response = [{ "id" => "30dedb70­62a9­41b8­b5f0­c960d7d8f79a", "lastSeen" => 1384278494336, "name" => "MokiTouch 2.0", "identifier" => "com.mokimobility.mokitouch2", "version" => "1.1.1", "ManagementFlags" => 0, "iTunesStoreID" => "733151730" },
+                                       { "id" => "30dedb71­62b9­41b8­b5f0­c960d7d8f79a", "lastSeen" => 1423524426266, "name" => "Belly Merchant App", "identifier" => "com.belly.flop.html.enterprise", "version" => "3.0", "ManagementFlags" => 1, "ManifestURL" => "https://www.bellycard.com/" }]
+
+  @action_stub_response = { "id" => "b4d71a15­183b­4971­a3bd­d139754a40fe", "lastSeen" => 1420583405416,
+                            "action" => "removeprofile", "status" => "completed", "clientName" => "Web", "itemName" => "Profile Name",
+                            "thirdPartyUser" => "itsmebro", "payload" => "{profile Identifier}", "note" => "test" }
+
   allow(MokiAPI).to receive_message_chain(:ios_profiles, :value).
                  and_return(Hashie::Mash.new({ body: @iosprofiles_stub_response,
                                                status: 200,
@@ -21,4 +28,14 @@ def load_good_stubs
                  and_return(Hashie::Mash.new({ body: @device_managed_app_stub_response,
                                                status: 200,
                                                headers: {}}))
+
+  allow(MokiAPI).to receive_message_chain(:tenant_managed_app_list, :value).
+                 and_return(Hashie::Mash.new({ body: @tenant_managed_app_stub_response,
+                                               status: 200,
+                                               headers: {}}))
+
+  allow(MokiAPI).to receive_message_chain(:action, :value).
+                 and_return(Hashie::Mash.new({ body: @action_stub_response,
+                                               status: 200,
+                                               headers: {}}))
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moki_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Trey Springer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-17 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -154,15 +154,19 @@ files:
 - lib/future_wrapper.rb
 - lib/moki_api.rb
 - lib/moki_ruby.rb
-- lib/moki_ruby/device_identifier.rb
+- lib/moki_ruby/action.rb
+- lib/moki_ruby/device.rb
 - lib/moki_ruby/device_managed_app.rb
 - lib/moki_ruby/iosprofile.rb
+- lib/moki_ruby/tenant_managed_app.rb
 - lib/moki_ruby/version.rb
 - moki_ruby.gemspec
-- spec/lib/device_identifier_spec.rb
+- spec/lib/action_spec.rb
 - spec/lib/device_managed_app_spec.rb
+- spec/lib/device_spec.rb
 - spec/lib/iosprofile_spec.rb
 - spec/lib/moki_api_spec.rb
+- spec/lib/tenant_managed_app_spec.rb
 - spec/moki_ruby_spec.rb
 - spec/spec_helper.rb
 - spec/support/common_stubs.rb
@@ -191,10 +195,12 @@ signing_key:
 specification_version: 4
 summary: A gem for interacting with the Moki Total Control API.
 test_files:
-- spec/lib/device_identifier_spec.rb
+- spec/lib/action_spec.rb
 - spec/lib/device_managed_app_spec.rb
+- spec/lib/device_spec.rb
 - spec/lib/iosprofile_spec.rb
 - spec/lib/moki_api_spec.rb
+- spec/lib/tenant_managed_app_spec.rb
 - spec/moki_ruby_spec.rb
 - spec/spec_helper.rb
 - spec/support/common_stubs.rb

data/lib/moki_ruby/device_identifier.rb

@@ -1,9 +0,0 @@
-module DeviceIdentifier
-  def self.is_serial?(id)
-    (!id.nil? && id.length == 12)
-  end
-
-  def self.is_udid?(id)
-    !(/\A[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\Z/.match(id)).nil?
-  end
-end

data/spec/lib/device_identifier_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'moki_ruby/device_identifier'
-
-describe DeviceIdentifier do
-  it "picks out a serial number as a 12-character string" do
-    expect(DeviceIdentifier.is_serial?("ABC123DEF456")).to eq(true)
-    expect(DeviceIdentifier.is_serial?("123456789012")).to eq(true)
-    expect(DeviceIdentifier.is_serial?("F55VM3KK9G5F")).to eq(true)
-    expect(DeviceIdentifier.is_serial?("ABC123DE56")).to eq(false)
-    expect(DeviceIdentifier.is_serial?("123456789012123")).to eq(false)
-  end
-
-  it "identifies a UDID" do
-    expect(DeviceIdentifier.is_udid?("ABC123DEF456")).to eq(false)
-    expect(DeviceIdentifier.is_udid?("abc12345-de12-abd5-7777-abcdefghijkl")).to eq(false)
-    expect(DeviceIdentifier.is_udid?("abc12345-de12-abd5-1234-abcdef123456")).to eq(true)
-    expect(DeviceIdentifier.is_udid?("abc1235-def125-hjm-erm")).to eq(false)
-  end
-end