Jeff Douglas - Technology, Coding and Bears... OH MY! » Code Sample

“Chow Finder” – My Veterans Hackday 2011 App

Jeff Douglas — Tue, 15 Nov 2011 11:53:16 +0000

This is my submission for the LinkedIn Veterans Hackday 2011. CloudSpokes threw in an extra $100 for any member that submitted as an extra incentive. Our members created some pretty cool apps and I’ll be highlighting them shortly.

Chow Finder is a mobile application for services members to easily locate dining facilities, aka “chow halls”, on any military installation. It was inspired by my sons in the Army and Navy who are always looking for their next meal.

The application was written using jQuery Mobile and Ruby on Rails. I used Database.com for the data store and it is hosted on Heroku. All of this for free!

[Show as slideshow]

You can run the Chow Finder here or fork the code at GitHub. I’m still working on some loose ends.

www.youtube.com/watch?v=eCyVbFne12Q

Getting Salesforce Field Metadata the Easy Way

Jeff Douglas — Thu, 20 Oct 2011 18:38:01 +0000

I’m working on some of the Apex REST services for our CloudSpokes org and needed some code to fetch field level metadata using Apex Describe. I poked around and realized that there isn’t really much out there. So I decided to write something up and hopefully people find it useful or instructional. Perhaps it should be part of apex-lang?

If you’ve ever worked with Apex Describe before you’ll quickly realize that it’s not the easiest thing to work with. You’ll want to take a peek at the docs. Don’t get me wrong, it’s power, fast and very handy. But it is rather confusing and cumbersome to work with at first. So I wanted some code that returns the metadata for specific fields in an object so that I could look at field types and lengths and perform “stuff” accordingly.

So here’s what I can up with. You pass the method the DescribeFieldResult for an object and a collection of fields that you want metadata for. The method returns a map where the field names are the keys and the values contain the metadata for the corresponding field. It looks pretty hard but that’s the great thing about utility methods, they encapsulate and hide the complexity of the implementation.

public static Map getFieldMetaData(
  Schema.DescribeSObjectResult dsor, Set fields) {
 
  // the map to be returned with the final data
  Map finalMap = 
    new Map();
  // map of all fields in the object
  Map objectFields = dsor.fields.getMap();
 
  // iterate over the requested fields and get the describe info for each one. 
  // add it to a map with field name as key
  for(String field : fields){
    // skip fields that are not part of the object
    if (objectFields.containsKey(field)) {
      Schema.DescribeFieldResult dr = objectFields.get(field).getDescribe();
      // add the results to the map to be returned
      finalMap.put(field, dr); 
    }
  }
  return finalMap;
}

So now in my code I can call this static method in my Utils class and access the field metadata easily by fetching it from the map by it’s field name:

// field to return -- skips fields not actually part of the sobject
Set fields = new Set{'name','annualrevenue','BADFIELD'};
 
Map finalMap = 
  Utils.getFieldMetaData(Account.getSObjectType().getDescribe(), fields);
 
// only print out the 'good' fields
for (String field : new Set{'name','annualrevenue'}) {
  System.debug(finalMap.get(field).getName()); // field name
  System.debug(finalMap.get(field).getType()); // field type
  System.debug(finalMap.get(field).getLength()); // field length
}

So if you run this, you’ll see something like:

Salesforce Trigger when Rollups Summaries Not Possible

Jeff Douglas — Tue, 23 Aug 2011 11:15:31 +0000

Master-Details relationships in Force.com are very handy but don’t fit every scenario. For instance, it’s not possible to implement a rollup summary on formula field or text fields. Here’s a small trigger that you can use for a starter for these types of situations. The code for each class is available at GitHub for your forking pleasure.

So here’s the (not very useful) use case. Sales Order is the Master object which can have multiple Sales Order Items (detail object). The Sales Order Item has a “primary” Boolean field and a “purchased country” field. Each time Sales Order Items are inserted or updated, if the Sales Order Item is marked as “primary” then the value of “purchased country” is written into the “primary country” field on the Sales Order. I’m assuming that there can only be one Sales Order Item per Sales Order that is marked as primary. Essentially this is just a quick reference on the Sales Order to see which country is primary on any of the multiple Sales Order Items. Not very useful but illustrative.

The code is broken down into a Trigger and an Apex “handler” class that implements the actual functionality. It’s best practice to only have one trigger for each object and to avoid complex logic in triggers. To simplify testing and resuse, triggers should delegate to Apex classes which contain the actual execution logic. See Mike Leach’s excellent trigger template for more info.

SalesOrderItemTrigger (source on GitHub) - Implements trigger functionality for Sales Order Items. Delegates responsibility to SalesOrderItemTriggerHandler.

trigger SalesOrderItemTrigger on Sales_Order_Item__c (after insert, after update) {
 
  SalesOrderItemTriggerHandler handler = new SalesOrderItemTriggerHandler();
 
  if(Trigger.isInsert && Trigger.isAfter) {
    handler.OnAfterInsert(Trigger.new);
 
  } else if(Trigger.isUpdate && Trigger.isAfter) { 
    handler.OnAfterUpdate(Trigger.old, Trigger.new, Trigger.oldMap, Trigger.newMap);
 
  }
 
}

SalesOrderItemTriggerHandler (source on GitHub) - Implements the functionality for the sales order item trigger after insert and after update. Looks at each sales order item and if it is marked as primary_item__c then moves the primary_country__c value from the sales order item to the associated sales order’s primary_country__c field.

public with sharing class SalesOrderItemTriggerHandler {
 
  // update the primary country when new records are inserted from trigger
  public void OnAfterInsert(List newRecords){
    updatePrimaryCountry(newRecords); 
  }
 
  // update the primary country when records are updated from trigger  
  public void OnAfterUpdate(List oldRecords, 
      List updatedRecords,  Map oldMap, 
      Map newMap){
    updatePrimaryCountry(updatedRecords); 
  }
 
  // updates the sales order with the primary purchased country for the item
  private void updatePrimaryCountry(List newRecords) {
 
    // create a new map to hold the sales order id / country values
    Map salesOrderCountryMap = new Map();
 
    // if an item is marked as primary, add the purchased country
    // to the map where the sales order id is the key 
    for (Sales_Order_Item__c soi : newRecords) {
      if (soi.Primary_Item__c)
        salesOrderCountryMap.put(soi.Sales_Order__c,soi.Purchased_Country__c);
    } 
 
    // query for the sale orders in the context to update
    List orders = [select id, Primary_Country__c from Sales_Order__c 
      where id IN :salesOrderCountryMap.keyset()];
 
    // add the primary country to the sales order. find it in the map
    // using the sales order's id as the key
    for (Sales_Order__c so : orders)
      so.Primary_Country__c = salesOrderCountryMap.get(so.id);
 
    // commit the records 
    update orders;
 
  }
 
}

Test_SalesOrderItemTriggerHandler (source on GitHub) - Test class for SalesOrderItemTrigger and SalesOrderItemTriggerHandler. Achieves 100% code coverage.

@isTest
private class Test_SalesOrderItemTriggerHandler {
 
  private static Sales_Order__c so1;
  private static Sales_Order__c so2;
 
  // set up our data for each test method
  static {
 
  	Contact c = new Contact(firstname='test',lastname='test',email='no@email.com');
  	insert c;
 
    so1 = new Sales_Order__c(name='test1',Delivery_Name__c=c.id);
    so2 = new Sales_Order__c(name='test2',Delivery_Name__c=c.id);
 
    insert new List{so1,so2};
 
  }
 
  static testMethod void testNewRecords() {
 
    Sales_Order_Item__c soi1 = new Sales_Order_Item__c();
    soi1.Sales_Order__c = so1.id;
    soi1.Quantity__c = 1;
    soi1.Description__c = 'test';
    soi1.Purchased_Country__c = 'Germany';
 
    Sales_Order_Item__c soi2 = new Sales_Order_Item__c();
    soi2.Sales_Order__c = so1.id;
    soi2.Quantity__c = 1;
    soi2.Description__c = 'test';
    soi2.Purchased_Country__c = 'France';
    soi2.Primary_Item__c = true;
 
    Sales_Order_Item__c soi3 = new Sales_Order_Item__c();
    soi3.Sales_Order__c = so2.id;
    soi3.Quantity__c = 1;
    soi3.Description__c = 'test';
    soi3.Purchased_Country__c = 'Germany';
    soi3.Primary_Item__c = true;
 
    Sales_Order_Item__c soi4 = new Sales_Order_Item__c();
    soi4.Sales_Order__c = so2.id;
    soi4.Quantity__c = 1;
    soi4.Description__c = 'test';
    soi4.Purchased_Country__c = 'Germany';
 
    Sales_Order_Item__c soi5 = new Sales_Order_Item__c();
    soi5.Sales_Order__c = so2.id;
    soi5.Quantity__c = 1;
    soi5.Description__c = 'test';
    soi5.Purchased_Country__c = 'Italy';
 
    insert new List{soi1,soi2,soi3,soi4,soi5}; 
 
    System.assertEquals(2,[select count() from Sales_Order_Item__c where Sales_Order__c = :so1.id]);
    System.assertEquals(3,[select count() from Sales_Order_Item__c where Sales_Order__c = :so2.id]); 
 
    System.assertEquals('France',[select primary_country__c from Sales_Order__c where id = :so1.id].primary_country__c);
    System.assertEquals('Germany',[select primary_country__c from Sales_Order__c where id = :so2.id].primary_country__c);
 
  }
 
  static testMethod void testUpdatedRecords() {
 
    Sales_Order_Item__c soi1 = new Sales_Order_Item__c();
    soi1.Sales_Order__c = so1.id;
    soi1.Quantity__c = 1;
    soi1.Description__c = 'test';
    soi1.Purchased_Country__c = 'Germany';
 
    Sales_Order_Item__c soi2 = new Sales_Order_Item__c();
    soi2.Sales_Order__c = so1.id;
    soi2.Quantity__c = 1;
    soi2.Description__c = 'test';
    soi2.Purchased_Country__c = 'France';
    soi2.Primary_Item__c = true;
 
    insert new List{soi1,soi2}; 
 
    // assert that the country = France
    System.assertEquals('France',[select primary_country__c from Sales_Order__c where id = :so1.id].primary_country__c);
 
    List items = [select id, purchased_country__c from Sales_Order_Item__c 
      where Sales_Order__c = :so1.id and primary_item__c = true];
    // change the primary country on the sales order item. should trigger update
    items.get(0).purchased_country__c = 'Denmark';
 
    update items;
    // assert that the country was successfully changed to Denmark
    System.assertEquals('Denmark',[select primary_country__c from Sales_Order__c where id = :so1.id].primary_country__c);
 
  }
 
}

Demo App – Ruby, Rails & Force.com REST API on Heroku

Jeff Douglas — Tue, 31 May 2011 17:30:30 +0000

So continuing with my learning Ruby series, I finally finished my sample app using the Force.com REST API. I ran into a few issues and fortunately Quinton Wall and Heroku support came to my rescue. Apparently require ‘Accounts’ and require ‘accounts’ aren’t the same when running on Heroku. Go figure.

This is a demo Rails app running on Ruby 1.9.2 and Rails 3.0.5 hosted on Heroku. It uses OAuth2 via OmniAuth to authorize access to a salesforce.com org. It uses the Force.com REST API to query for records, retreive records to display, create new records and update existing ones. It should be good sample app to get noobs (like me) up and running.

I forked Quinton Wall’s (excellent) omniauth-rails3-forcedotcom project to get started. One of the things you have to do when using the Force.com REST API is to configure your server to run under SSL using WEBrick. I found some excellent instruction for OS X here.

You can run the app for yourself here.

All of the code for this app is hosted at github so feel free to fork it. I’ve pulled out some of the more important parts of the app for discussion after the video.

www.youtube.com/watch?v=fRAaodh9jxQ

app/controllers/accounts_controller.rb

The account controller delegates authority to accounts.rb for integration with Force.com and then packages up the returns for the views.

require 'accounts'
 
class AccountsController < ApplicationController
  def index
  end
 
  def search
    @json = Accounts.search(params[:accountName])
  end
 
  def show
    @account = Accounts.retrieve(params[:id])
    @opportunities = Accounts.opportunities(params[:id])    
  end
 
  def create
     @account = Accounts.create
  end
 
  def edit
     @account = Accounts.retrieve(params[:id])
  end
 
  def save
    Accounts.save(params)
    redirect_to :action => :show, :id => params[:id]
  end  
 
  def new_opp 
    @account = Accounts.retrieve(params[:id])
  end
 
  def save_opp
    Accounts.create_opp(params)
    redirect_to :action => :show, :id => params[:id]
  end
 
end

lib/accounts.rb

Accounts.rb does most of the heavy lifting for the app. It prepares the requests to Force.com with the correct headers and makes the actual calls to Force.com with the REST API.

require 'rubygems'
require 'httparty'
 
class Accounts
  include HTTParty
  #doesn't seem to pick up env variable correctly if I set it here
  #headers 'Authorization' => "OAuth #{ENV['sfdc_token']}"
  format :json
  # debug_output $stderr
 
  def self.set_headers
    headers 'Authorization' => "OAuth #{ENV['sfdc_token']}"
  end
 
  def self.root_url
    @root_url = ENV['sfdc_instance_url']+"/services/data/v"+ENV['sfdc_api_version']
  end
 
  def self.search(keyword)
    Accounts.set_headers
    soql = "SELECT Id, Name, BillingCity, BillingState, Phone from Account Where Name = \'#{keyword}\'"
    get(Accounts.root_url+"/query/?q=#{CGI::escape(soql)}")
  end
 
  def self.create()
    Accounts.set_headers
    headers 'Content-Type' => "application/json"
 
    options = {
      :body => {
          :Name => "1234"
      }.to_json
    }
    response = post(Accounts.root_url+"/sobjects/Account/", options)
    # puts response.body, response.code, response.message
  end
 
  def self.save(params)
    Accounts.set_headers
    headers 'Content-Type' => "application/json"
 
    options = {
      :body => {
          :billingcity => params[:BillingCity]
      }.to_json
    }
    p options
    response = post(Accounts.root_url+"/sobjects/Account/#{params[:id]}?_HttpMethod=PATCH", options)
    # 201 response.body equals success
    # puts response.body, response.code, response.message
  end
 
  def self.retrieve(id)
    Accounts.set_headers
    get(Accounts.root_url+"/sobjects/Account/#{id}?fields=Id,Name,BillingCity,BillingState,Phone,Website") 
  end
 
  def self.opportunities(accountId)
    Accounts.set_headers
    soql = "SELECT Id, Name, Amount, StageName, Probability, CloseDate from Opportunity where AccountId = \'#{accountId}\'"
    get(Accounts.root_url+"/query/?q=#{CGI::escape(soql)}")
  end
 
  def self.create_opp(params)
    Accounts.set_headers
    headers 'Content-Type' => "application/json"
 
    options = {
      :body => {
          :name => params[:name],
          :amount => params[:amount],
          :accountId => params[:id],
          :amount => params[:amount],
          :closeDate => params[:closeDate],
          :stageName => params[:stageName]
      }.to_json
    }
    response = post(Accounts.root_url+"/sobjects/Opportunity/", options)
    # 201 response.body equals success
    # puts response.body, response.code, response.message
  end
 
end

app/views/search.html.erb

The search view allows the user to search for an account and display the results.

Welcome to the ACME Telesales Application (RoR on Heroku)
This demo shows you how to query, retrieve, create and edit records in salesforce.com.
Search for an Account to view all of its Opportunities or to create a new one.


  Search by Account Name:
  <%= params[:accountName] %>" style="width: 300px"/>
  


 
<%= @json["records"].length %> accounts matching your search criteria:
 

<%@json["records"].eachdo|record|%><%end%>

  Name
  City
  State
  Phone

    
  
    <%= record["Id"]%>"><%= record["Name"] %>
    <%= record["BillingCity"] %>
    <%= record["BillingState"] %>
    <%= record["Phone"] %>

OpportunityAccessLevel Not Writable

Jeff Douglas — Thu, 17 Mar 2011 10:40:44 +0000

I was working on a project the other day where I needed to dynamically add users to an opportunity’s Sales Team (OpportunityTeamMember object) so that users who do not normally have access to an opportunity based upon Org-wide security settings can work on the opportunity with other team members. One of the advantages of Sales Teams is that you can specify the level of access that each team member has for the opportunity. Some team members may need read/write access while others may just need read-only access.

From the opportunity page layout you can add a new team member and specify their access level and role.

However, by default when you create a new team member via Apex, the platform grants them read-only access. So I tried to specify grant “Edit” (read/write) access with the following code.

OpportunityTeamMember member = new OpportunityTeamMember();
member.OpportunityId = SomeOpp.Id;
member.UserId = SomeUser.Id;
mmember.TeamMemberRole = 'Sales Rep';
member.OpportunityAccessLevel = 'Edit';

Specifying the OpportunityAccessLevel threw the following error when saving my class:

Save error: Field is not writable: OpportunityTeamMember.OpportunityAccessLevel

To be fair, the docs state that OpportunityAccessLevel is not creatable but it used to be with earlier versions of the API so I really wanted this to work and it was screwing up my day.

So here’s the solution that I can up with in case anyone is looking for a answers. You need to add the team members to the opportunity and then update the sharing access to the opportunity for these users.

OpportunityTeamMember member = new OpportunityTeamMember();
member.OpportunityId = SomeOpp.Id;
member.UserId = SomeUser.Id;
mmember.TeamMemberRole = 'Sales Rep';
 
insert member;
 
// get all of the team members' sharing records
List shares = [select Id, OpportunityAccessLevel, 
  RowCause from OpportunityShare where OpportunityId IN :SomeSetOfOpptyIds 
  and RowCause = 'Team'];
 
// set all team members access to read/write
for (OpportunityShare share : shares) 
  share.OpportunityAccessLevel = 'Edit';
 
update shares;

Dynamically Group & Display Query Results

Jeff Douglas — Wed, 02 Mar 2011 10:55:14 +0000

I was working on a Visualforce page that displays the results of a query in separate PageBlock sections based upon a value in the query results. I ran into a small issue which took about an hour or so to solve, so I thought it might make descent blog fodder.

The requirement for the page was to query for records and then display them grouped in sections in a Visualforce page based upon whatever values (in this case BillingState) are returned in the results. If additional states were added, then the Visualforce page should be able to add those new sections without changes to the code. Here’s a screenshot of the sample solution that I came up with but you can also run this sample on my Developer Site:

Here’s the code for the Visualforce page. I’ve made it as bare as possible but you can see that it iterates over the array of states to display the pageBlock sections and then displays the record if the state matches the current blockSection’s state.


  
 
  
 
    
 
       
 
        
        {!account.Name} - {!account.BillingState}

The Controller exposes two collections to the Visualforce page: the list of Accounts and the array of States. Here’s the issue that I ran into. Since I wanted to have a collection of unique state names, I originally added each state to a Set and simply returned the Set to the Visualforce page (instead of the array) to display the pageBlock sections. However, returning the Set gave me a compile error at line 11 in the Visualforce page:

Save error: Incorrect parameter for operator ‘=’. Expected Text, received Object

The problem is that even though the Set is a collection of Strings, it is actually an object underneath the covers and throws a comparison error. Therefore you have to return the states as an array of strings for the code to compile and run properly.

public with sharing class DisplaySectionsController {
 
  public List accounts {get;set;}  
  public String[] states {get;set;}
 
  public void load() {
 
    // for demo purposes limit the states  
    accounts = [Select ID, Name, BillingState From Account 
      Where BillingState IN ('CA','NY','FL')];
 
    // dynamically create set of unique states from query
    Set stateSet = new Set();
    for (Account a : accounts)
      stateSet.add(a.BillingState);
 
    // convert the set into a string array  
    states = new String[stateSet.size()];
    Integer i = 0;
    for (String state : stateSet) { 
      states[i] = state;
      i++;
    }
 
  }
 
}

Find My Salesforce Users by Role Hierarchy

Jeff Douglas — Tue, 15 Feb 2011 19:28:28 +0000

This is a cool little script that finds “everyone who works beneath me in the role hierarchy”. So you pass the utility class a User ID and it chugs through all of the level beneath that User in the role hierarchy and returns the IDs of all of the users in those roles. Comes in handy if you need to find all of the uses that report to a particular Sales Manager, for instance.

public with sharing class RoleUtils {
 
  public static Set getRoleSubordinateUsers(Id userId) {
 
    // get requested user's role
    Id roleId = [select UserRoleId from User where Id = :userId].UserRoleId;
    // get all of the roles underneath the user
    Set allSubRoleIds = getAllSubRoleIds(new Set{roleId});
    // get all of the ids for the users in those roles
    Map users = new Map([Select Id, Name From User where 
      UserRoleId IN :allSubRoleIds]);
    // return the ids as a set so you can do what you want with them
    return users.keySet();
 
  }
 
  private static Set getAllSubRoleIds(Set roleIds) {
 
    Set currentRoleIds = new Set();
 
    // get all of the roles underneath the passed roles
    for(UserRole userRole :[select Id from UserRole where ParentRoleId 
      IN :roleIds AND ParentRoleID != null])
    currentRoleIds.add(userRole.Id);
 
    // go fetch some more rolls!
    if(currentRoleIds.size() > 0)
      currentRoleIds.addAll(getAllSubRoleIds(currentRoleIds));
 
    return currentRoleIds;
 
  }
 
}

Learning Ruby for Force.com Developers – Part 3

Jeff Douglas — Thu, 03 Feb 2011 11:41:43 +0000

This is part #3 of my adventures of learning Ruby for Force.com developers. If you missed parts #1 and #2 you might want to take a look at those just to get up to speed. Again, these are my goals for this series:

Learn Ruby
Develop an app locally using Ruby on Rails and the default SQLite database (this is where we are at right now)
Modify the app to use Database.com and the Force.com Toolkit for Ruby instead of the SQLite database
Deploy the app to Heroku
Modify the app to use Database.com and the REST API

In this post we’ll get started building a web app using Ruby on Rails and SQLite. In a nutshell we’ll be building a shopping cart app with a little twist. I do a lot of work for Medisend International, which is a non-profit that ships medical supplies to developing countries (among other things). They have an (old) international aid self-service portal that allows aid recipients (typically hospital administrators or local NGOs) to create a shipment and select medical supplies to be shipped to their country. We’ll be building a replacement with Ruby on Rails.

Before you get started you might want to go through Get Started with Rails which has a lot of great stuff. I’m only using a subset of the functionality outlined in this guide so you’ll definitely want to go through this entire article. I’ll zip up all of the code for this part so you can download it and pick it apart.

The first thing we’ll want to do is install our software needed for Rails. I had some issues during some of the installations but unfortunately I can’t help out much so hopefully things go well for you. First, open Terminal and run the following lines:

sudo gem update –system
sudo gem install rails
sudo bundle install
sudo gem update rake
sudo gem update sqlite3-ruby

Now that all of your software is (hopefully) installed let’s start building the app using SQLite to store data. Open Terminal and change to the directory where you want to store your files (~/Documents/Programming/Ruby in my case) and run the following command to create the application:

rails new mediaid-sqlite

This will create a Rails application called MediaidSqlite in a directory called mediaid-sqlite. Now switch to this new directory:

cd mediaid-sqlite

Rails created an entire directory structure for us with all of the files we need to begin building out the app. Feel free to take a look. We’ll mainly be working in the app directory. Since we’ll be using SQLite, run the following command to create an empty database:

rake db:create

This will create both a development and test SQLite databases inside the db/ folder. You now have a fully functional Rails application. To see it in action, fire up the web server on your local development machine by running:

rails server

If all goes well, when you point your browser to http://localhost:3000 you should see the following:

To stop the web server, simply hit Ctrl+C in the same Terminal window. I typically have at least two Terminal tabs open; one for the server and one for running commands. When running in development mode, Rails does not generally require you to bounce the server when changes are made; changes and files will be automatically picked up by the server.

For the required “Hello World” for the home page, you need to create at minimum a controller and a view. Fortunately, you can do that in a single command. Run the following command in Terminal:

rails generate controller home index

Now we need to delete the default page from your application so Rails will not load it by default. We need to do this as Rails will deliver any static file in the public directory in preference to any dynamic contact we generate from the controllers:

rm public/index.html

Now, you have to tell Rails where the new home page is located. Open the file config/routes.rb in Textmate or your favorite editor. This is your application’s routing file which holds entries in a special DSL that tells Rails how to route incoming requests to your controllers and actions. This file contains many commented out sample routes, and one of them actually shows you how to connect the root of your site to a specific controller and action. Find the line beginning with :root to towards the end of the file, uncomment it so that is looks like the following:

root :to => “home#index”

One of the cool thing about Rails is the scaffolding. Rails scaffolding is a quick and easy way to generate some of the major pieces of an application such as models, views, and controllers for a new resource. It provides the basic functionality and UI to CRUD records. We can create the scaffolding for Shipment and InventoryItem with just a few easy commands. The command below creates the scaffolding for the Shipment resource and specifies the fields for the model:

rails generate scaffold Shipment name:string country:string shipmentType:string status:string shipDate:date items:integer selected:integer reserved:integer

One of the outputs of the rails generate scaffold command is a database migration script. Migrations are Ruby classes that are designed to make it simple to create and modify database tables. Rails uses rake commands to run migrations, and it’s possible to undo a migration after it’s been applied to your database. Migration filenames include a timestamp to ensure that they’re processed in the order that they were created. Now use the following rake command to run the migration:

rake db:migrate

Now we need the InventoryItems to add to our Shipments. Run the following rails generated scaffold command to create the InventoryItems scaffolding:

rails generate scaffold InventoryItem name:string itemNumber:string category:string status:string shipment:integer

Now run the rake command to perform the database migration for InventoryItems:

rake db:migrate

So now we have our database setup and the basic functionality generated for us by Rails. Some people don’t like the scaffolding and prefer to code from scratch but I’m going to simply modify the code generated by the scaffolding. The application consists of essentially 6 view and one controller. We’ll look at the views first and then dig into the controller.

Home Page

The home page displays a summary of the available shipments and allows the user to select a shipment to process. There are also links at the bottom to access the auto-generated UI to CRUD records for both shipments and inventory items.

Welcome to MediSend's MediAid!
MediAid is an international aid, self-service portal for 
  inventory selection, processing and information centralization.
 
The following shipments are available for your aid case:
 

<% @shipments.each do |shipment| %>

<% end %>


  Shipment
  Type
  Status

  <%= link_to shipment.name, shipment %>
  <%= shipment.shipmentType %>
  <%= shipment.status %>

 

The following options are also available:
 

  <%= link_to "Maintain Shipments", shipments_path %>
  <%= link_to "Maintain Inventory Items", inventory_items_path %>

Shipment Display

This page is where most of the work is done for a shipment. It provides the relevant info on the shipment and allows the users to manage the shipment’s contents.

<%= notice %>
 

 
Shipment <%= @shipment.name %>
 

Status: <%= @shipment.status %>

Type: <%= @shipment.shipmentType %>

Country: <%= @shipment.country %>

Items: <%= @shipment.items %>

Selected: <%= @shipment.selected %>

Reserved: <%= @shipment.reserved %>

 
Available options for this shipment:

  <%= link_to 'View items in this shipment', items_shipment_path(@shipment) %>
  <%= link_to 'Add items by product category to this shipment', additems_shipment_path(@shipment) %>
  Mark all items as "reserved" for this shipment
  Remove all items from this shipment
  <%= link_to 'View this shipment\'s manifest', manifest_shipment_path(@shipment) %>


 
<%= link_to 'Edit', edit_shipment_path(@shipment) %> |
<%= link_to 'Back', shipments_path %>

Add Inventory Items

The add items pages displays the number of available inventory items by category and if there is at least one available, provides the user with a link to add all of the available items. Clicking the link runs the addAll route to add the items to the shipment and then redirect the user back to the shipment display page.

Add Inventory by Category
 


  Category
  Available
  Add All


  Surgical Gloves
  <%= @gloves %>
  <% if @gloves > 0 %><%= @shipment.id %>/addAll?category=Gloves">Add All<% else %>Add All<% end %>


  Nebulizer Accessory Kits
  <%= @nebulizer %>
  <% if @nebulizer > 0 %><%= @shipment.id %>/addAll?category=Nebulizer">Add All<% else %>Add All<% end %>


  Hyperinflation Systems
  <%= @hyperinflation %>
  <% if @hyperinflation > 0 %><%= @shipment.id %>/addAll?category=Hyperinflation">Add All<% else %>Add All<% end %>


  Breathing Circuits
  <%= @circuit %>
  <% if @circuit > 0 %><%= @shipment.id %>/addAll?category=Circuits">Add All<% else %>Add All<% end %>


  Armboards
  <%= @armboard %>
  <% if @armboard > 0 %><%= @shipment.id %>/addAll?category=Armboards">Add All<% else %>Add All<% end %>


 

<%= link_to 'Back', shipment_path(@shipment) %>

View Shipment Inventory Items

The page simply displays the inventory items currently assigned to this shipment.

Items for Shipment <%= @shipment.name %>
 
<%@items.eachdo|item|%><%end%>

  Item
  Name
  Category
  Status

    

  <%= item.itemNumber %>
  <%= item.name %>
  <%= item.category %>
  <%= item.status %>

  

 

<%= link_to 'Back', shipment_path(@shipment) %>

Mark Items as Reserved

Items that have been added to the shipment need to be marked as reserved so that they can be processed for shipping. Clicking “OK” runs the reserve route to mark the items in the shipment as reserved and then redirect the user back to the shipment display page.

Remove Items from Shipment

Users may want to remove all of the items from their shipment and begin the process anew. Clicking “OK” runs the remove route which removes all of the items from the shipment, making them available again, and then redirects the user back to the shipment display page.

Routes

To process the flow of our application we need to modify app/routes.rb to include our new pages. Here’s a snippet from the beginning of the file:

resources :inventory_items
 
resources :shipments do
  member do
    get 'additems' # /shipments/1/additems
    get 'addAll'   # /shipments/1/addAll
    get 'items'    # /shipments/1/items
    get 'remove'   # /shipments/1/remove
    get 'reserve'  # /shipments/1/reserve
    get 'manifest' # /shipments/1/manifest
  end
end  
 
get "home/index"

ShipmentController

Last but not least is the ShipmentController. Controllers provide the “glue” between models and views. In Rails, controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation. Take a look at the following code which should explain quite a bit. Since the controller contains code both generated by Rails and added by me, I’ve annotated it for your viewing ease.

class ShipmentsController < ApplicationController
  # GET /shipments
  # GET /shipments.xml
  def index
    @shipments = Shipment.all
 
    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @shipments }
    end
  end
 
  # GET /shipments/1
  # GET /shipments/1.xml
  def show
    @shipment = Shipment.find(params[:id])
 
    respond_to do |format|
      format.html # show.html.erb
      format.xml  { render :xml => @shipment }
    end
  end
 
  # GET /shipments/new
  # GET /shipments/new.xml
  def new
    @shipment = Shipment.new
 
    respond_to do |format|
      format.html # new.html.erb
      format.xml  { render :xml => @shipment }
    end
  end
 
  # GET /shipments/1/edit
  def edit
    @shipment = Shipment.find(params[:id])
  end
 
  # CUSTOM
  # GET /shipments/1/additems
  def additems
    @shipment = Shipment.find(params[:id])
 
    # get a a count of the available inventory by category
    @gloves = InventoryItem.where(:category => 'Gloves', :status => 'Available').count
    @nebulizer = InventoryItem.where(:category => 'Nebulizer', :status => 'Available').count
    @hyperinflation = InventoryItem.where(:category => 'Hyperinflation', :status => 'Available').count
    @circuit = InventoryItem.where(:category => 'Circuits', :status => 'Available').count
    @armboard = InventoryItem.where(:category => 'Armboards', :status => 'Available').count
  end
 
  # CUSTOM
  # GET /shipments/1/addAll
  def addAll
    @shipment = Shipment.find(params[:id])
 
    # add all of the avaiilable items for the category to the shipment as 'selected'
    InventoryItem.where(:category => params[:category], :status => 'Available').each do |item| 
      # assign the item to the shipment
      item.shipment = @shipment.id
      # set the status as 'selected'
      item.status = 'Selected'
      item.save
    end
    # update the shipment with total number of items on it
    @shipment.items = InventoryItem.where(:shipment => @shipment.id).count
    # update the shipment with the total number of 'selected' items
    @shipment.selected = InventoryItem.where(:shipment => @shipment.id, :status => 'Selected').count
    @shipment.save
    respond_to do |format|
      format.html { redirect_to(@shipment, :notice => 'Items have been successfully added.') }
      format.xml  { head :ok }
    end
  end
 
  # CUSTOM
  # GET /shipments/1/items
  def items
    @shipment = Shipment.find(params[:id])
 
    # fetch all of the items on the shipment regardless of status
    @items = InventoryItem.where(:shipment => @shipment.id).order(:name)
  end
 
  # CUSTOM
  # GET /shipments/1/manifest
  def manifest
    @shipment = Shipment.find(params[:id])
 
    # fetch all of the items on the shipment regardless of status
    @items = InventoryItem.where(:shipment => @shipment.id).order(:name)
  end    
 
  # CUSTOM
  # GET /shipments/1/remove
  def remove
    @shipment = Shipment.find(params[:id])
 
    # remove all items on the shipment
    InventoryItem.where(:shipment => @shipment.id).each do |item| 
      # remove it from the shipment
      item.shipment = nil
      # mark the item as available
      item.status = 'Available'
      item.save
    end
 
    # update the shipment with the correct counts
    @shipment.items = 0
    @shipment.reserved = 0
    @shipment.selected = 0
    @shipment.save
    respond_to do |format|
      format.html { redirect_to(@shipment, :notice => 'All items removed from the shipment.') }
      format.xml  { head :ok }
    end
  end
 
  # CUSTOM
  # GET /shipments/1/reserve
  def reserve
    @shipment = Shipment.find(params[:id])
 
    # mark all items on the shipment as reserved
    InventoryItem.where(:shipment => @shipment.id).each do |item| 
      item.status = 'Reserved'
      item.save
    end
 
    # get a count of the number of reserved items on the shipment
    @shipment.reserved = InventoryItem.where(:shipment => @shipment.id).count
    @shipment.save
    respond_to do |format|
      format.html { redirect_to(@shipment, :notice => 'All items were successfully marked as reserved.') }
      format.xml  { head :ok }
    end
  end
 
  # POST /shipments
  # POST /shipments.xml
  def create
    @shipment = Shipment.new(params[:shipment])
 
    respond_to do |format|
      if @shipment.save
        format.html { redirect_to(@shipment, :notice => 'Shipment was successfully created.') }
        format.xml  { render :xml => @shipment, :status => :created, :location => @shipment }
      else
        format.html { render :action => "new" }
        format.xml  { render :xml => @shipment.errors, :status => :unprocessable_entity }
      end
    end
  end
 
  # PUT /shipments/1
  # PUT /shipments/1.xml
  def update
    @shipment = Shipment.find(params[:id])
 
    respond_to do |format|
      if @shipment.update_attributes(params[:shipment])
        format.html { redirect_to(@shipment, :notice => 'Shipment was successfully updated.') }
        format.xml  { head :ok }
      else
        format.html { render :action => "edit" }
        format.xml  { render :xml => @shipment.errors, :status => :unprocessable_entity }
      end
    end
  end
 
  # DELETE /shipments/1
  # DELETE /shipments/1.xml
  def destroy
    @shipment = Shipment.find(params[:id])
    @shipment.destroy
 
    respond_to do |format|
      format.html { redirect_to(shipments_url) }
      format.xml  { head :ok }
    end
  end
end

Summary

That’s our application in a nutshell. You can download a zip of the entire project from here. In the next part of the series we’ll dive into the Force.com Toolkit for Ruby and really start to integrate with the platform.

Related Posts:

Passing Values to JavaScript from Apex Controller Method

Jeff Douglas — Tue, 18 Jan 2011 03:28:50 +0000

I’m working on a port of an existing Java app to Salesforce.com and I ran into a Visualforce page that gave me some problems. The current JSP page allows the user to fill out a form, submit a new record to the database and then pop-up a new window to show some results while keeping the users on the same page with the form.

This is actually somewhat difficult to do with Apex and Visualforce. I searched the message boards but couldn’t find anything comparable. Luckily Wes Nolte came to the rescue with his mad JavaScript skillz to point me in the right direction.

Typically you save a record with a commandButton that invokes a method in the Controller specified by the action attribute. However, this method returns a PageReference which, if not null, will redirect the user to a new page. However, I wanted the Controller method to notify the Visualforce page that the insert was successful and then pop open a new window via JavaScript that loaded another page.

Here’s something similar to what I came up with. You can run this example on my developer site.

ActionFunctionDemoController

The Controller exposes a public ‘message’ attribute that is used by the Visualforce page to display the results of the submission. The save() method inserts the record and set the value of the ‘message’ attribute if no error. If an error occurred, it set the error message to the ‘message’ attribute instead.

public with sharing class ActionFunctionDemoController {
 
  public Cat3__c cat {get;set;}
  public String message {get;set;}
 
  public ActionFunctionDemoController() {
    cat = new Cat3__c(name='Some Value',Cat2__c='a0B70000002PuK2EAK');
    message = 'Try again!!'; // initial message.
  }
 
  public PageReference save() { 
    try {
      insert cat;
      message = 'Insert successful! -- ' + cat.id;
    } catch (Exception e) {
      ApexPages.addMessages(e);
      message = 'Whoops! An error occurred -- ' + e.getMessage();      
    }
    return null;
  }
 
}

ActionFunctionDemo

The Visualforce page has a number of interesting aspects. First it defines an actionFunction which allows us to invoke a controller action method from JavaScript. The component’s name is doControllerSave and it calls the save() method in the Controller. Instead of using the action attribute, the commandButton component instead uses the onclick method to call the doControllerSave JavaScript method (which in turn calls save() action method in the Controller) and then specifies that the onControllerReturn JavaScript method should be called when the Ajax request completes on the client. The magic here is that we wrap the entire onControllerReturn function in an outputPanel which is rerendered by the ActionFunction. Without the outputPanel this entire operation doesn’t work at all.


 
 
  
 
   
  
  
 
  
 
  
 
  
    
  
  
 
  
      
      
  
 
  
  
 
  Submit the form to successfully create a record. To generate an error, 
  remove the value for 'Cat2' and save.

Learning Ruby for Force.com Developers – Part 2

Jeff Douglas — Tue, 11 Jan 2011 18:26:13 +0000

This is part #2 from my adventures of learning Ruby. If you missed part #1 you might want to take a look at it just to get up to speed. Again, these are my goals for this series:

Learn Ruby
Develop an app locally using Ruby on Rails and the default SQLite database
Modify the app to use Database.com and the Force.com Toolkit for Ruby
Deploy the app to Heroku
Modify the app to use Database.com and the REST API

I’ve spent the last week or so digging into the Ruby language and have found Ruby Essentials, Ruby Programming and Ruby Tutorial to be especially useful. I’m not an expert, but I do have a feel for it. I’m not going to write a Ruby tutorial (see the links above for that) but I will try to incorporate as much as possible to demonstrate things that I found useful, different or cool.

Write an App in Ruby

The best way to really learn a language is to actually write an app. So that’s what I’m going to do. I expect that my approach and/or assumptions may need to be tweaked once I get further down the road but we’ll see. I’m going to rewrite my Dreamforce 2010 VMforce app in Ruby and Rails. In a nutshell this is a shopping cart app with a little twist. I do a lot of work for Medisend International, which is a non-profit that ships medical supplies to developing countries (among other things). They have an (old) international aid self-service portal that allows aid recipients (typically hospital administrators or local NGOs) to create a shipment and select medical supplies to be shipped to their country. If all goes well I may build the app out and put it into production on Heroku.

So let’s get started by looking at the domain objects for the app. We’ll need a Shipment object (of course) to manage our multiple shipments and an InventoryItem object which will represent the medical items that will be added to the shipment. These are modeled as Custom Object in my development org.

Before we start building out the objects, let’s step back and take a look at how Ruby works with objects. Apex isn’t exactly Java but it’s somewhat similar and a lot of Force.com developers come from a Java background. So it might help to compare Ruby and Java.

As with Java, you’ll find the following similar to Ruby:

Memory is managed for you via a garbage collector.
Objects are strongly typed.
There are public, private, and protected methods.
There are embedded doc tools (Ruby’s is called RDoc). The docs generated by rdoc look very similar to those generated by javadoc.

Unlike Java, you’ll find the following different in Ruby:

You don’t need to compile your code. You just run it directly.
There are different GUI toolkits. Ruby users can try WxRuby, FXRuby, Ruby-GNOME2, or the bundled-in Ruby Tk for example.
You use the end keyword after defining things like classes, instead of having to put braces around blocks of code.
You have require instead of import.
All member variables are private. From the outside, you access everything via methods.
Parentheses in method calls are usually optional and often omitted.
Everything is an object, including numbers like 2 and 3.14159.
There’s no static type checking.
Variable names are just labels. They don’t have a type associated with them.
There are no type declarations. You just assign to new variable names as-needed and they just “spring up” (i.e. a = [1,2,3] rather than int[] a = {1,2,3};).
There’s no casting. Just call the methods. Your unit tests should tell you before you even run the code if you’re going to see an exception.
It’s foo = Foo.new( “hi”) instead of Foo foo = new Foo( “hi” ).
The constructor is always named “initialize” instead of the name of the class.
You have “mixin’s” instead of interfaces.
YAML tends to be favored over XML.
It’s nil instead of null.
== and equals() are handled differently in Ruby. Use == when you want to test equivalence in Ruby (equals() is Java). Use equal?() when you want to know if two objects are the same (== in Java).

Shipment Class

The basic Shipment class looks like the following. It has two instance variables (name and country) and a getter and setter for each one.

class Shipment
  def name
    @name
  end
 
  def name=(value)
    @name = value
  end
 
  def country
    @country
  end
 
  def country=(value)
    @country = value
  end
 
  def initialize()
    puts 'Hello Shipment!!'
  end
end

The following script creates a new instance of the Shipment class, populates the instance variables and display them.

require './Shipment' # similar to Java import
s = Shipment.new # create a new instance
s.name = 'ANG0903-COH1'
s.country = 'Angola'
puts s.name
puts s.country

Create a new directory called ‘RubyDemo’ (or whatever you’d like), switch to that new directory and create a file called Shipment.rb. Paste the contents of the Shipment class above into it. Create another file in that new directory called testshipment.rb and paste the test code above into it. Now open Terminal and switch to this new directory and run ruby testshipment.rb. You should see the following:

So now that we have our Shipment object we need to create our InventoryItem objects to add it. Here’s the class for our InventoryItem:

# base class for all items
class InventoryItem
  attr_accessor :name, :itemNumber, :category, :status, :type
  def initialize(name, itemNumber, category, type)
    @name, @itemNumber, @category, @type = name, itemNumber, category, type
    @status = 'Available'
  end
 
  # override the 'to string' method
  def to_s
    puts 'Item: ' + itemNumber + ', Name: ' + name + ', Category: ' + category
  end
end

You’ll notice that this class is a little different than the Shipment class. Instead of manually creating getter and setter methods, I used “attr_accessor” followed by the names of all of the instance variables for my class. With this command, Ruby will generate basic getters and setters automatically for me. I could have used “attr_reader” to generate only the getter methods and “attr_writer” to generate the setters.

The initialize method is a standard Ruby class method and is the method which gets called first after an object based on this class has completed initialization. Four arguments are passed into this method and they are used to set instance variable for the object. You’ll also notice that @status is set to ‘Available’ by default each time a new object is created. The to_s method overrides the standard to_s (“to string”) method and displays some information about the item.

Ruby Inheritance

Unfortunately Medisend doesn’t ship just “inventory items”; they ship supplies, equipment and biomedical items. Each one of these types of items is similar but also slightly different. All items have a name, unique item number, category and status however supplies also have expiration dates and quantities of items in the box while equipment has a weight attribute. So instead of making classes for each type of InventoryItem with the same attributes we can use InventoryItem as a base class for each type of item and inherit the shared attributes and functionality from the this base class. (BTW… in salesforce.com there is a Custom Object called InventoryItem__c and Supply, Equipment and Biomed are the types of recordtypes.)

So here’s the SupplyItem that extends the InventoryItem class. The initialize method has 4 arguments; three of which are used to construct the InventoryItem class via the super() call and one that sets the instance variable @quantity. The method also sets a default expiration date just for fun.

require 'date'
require './InventoryItem'
 
class SupplyItem < InventoryItem
  attr_accessor :quantity, :condition, :expirationDate
  def initialize(name, itemNumber, category, quantity)
    super(name, itemNumber, category, 'Supply')
    @quantity = quantity
    @expirationDate = Date.new(2012, 01, 01)
  end
end

The EquipmentItem class also extends InventoryItem but has it’s own to_s method allowing for a more detailed representation of item.

require './InventoryItem'
 
class EquipmentItem < InventoryItem
  attr_accessor :weight
  def initialize(name, itemNumber, category, weight)
    super(name, itemNumber, category, 'Equipment')
    @weight = weight
  end
 
  # provide a custom 'to string' method for equipment only
  def to_s
    puts 'Item: ' + itemNumber + ', Name: ' + name + ', Category: ' + category + ', Weight: ' + weight.to_s + ' lbs'
  end
end

The BiomedItem class is very similar to the SupplyItem class but adds its own weight and condition instance variables.

require './InventoryItem'
 
class BiomedItem < InventoryItem
  attr_accessor :weight, :condition
  def initialize(name, itemNumber, category, weight)
    super(name, itemNumber, category, 'Biomed')
    @weight = weight
    @condition = 'Unknown'
  end
end

Shipment Functionality

With all of the inventory items complete we need to turn our attention back to the Shipment class. The Shipment class should maintain a collection of InventoryItems that are assigned to it and also provide public methods to add and remove items. It should also give some kind of display of the shipment contents. Take a look at the code below along with the comments.

class Shipment
  # class (static) variable 
  @@totalShipmentItems = 0
  # constant
  MAX_ITEMS = 10
  # provides getters and setters for instance variables
  attr_accessor :name, :country, :type, :status, :items
 
  # init the object & set instance variables
  def initialize(name, country, type)
    @name, @country, @type = name, country, type
    @status = 'Not Shipped'
    @items = Hash.new
  end
 
  # adds an item to the Hash of shipment items
  def addItem(item)
    items[item.itemNumber] = item # item number is the key
    @@totalShipmentItems += 1 # increment total items
  end
 
  # deletes an item from the Hash of shipment items
  def deleteItem(itemNumber)
    items.delete(itemNumber) # deleted by key
    @@totalShipmentItems -= 1 # decrements total items
  end
 
  # displays item number and name of each item in shipment
  def displayItems()
    puts 'These are the items in the shipment:'
    items.each {|key, value| puts " #{key} -- #{value.name}" }
  end
 
  # displays item number of each item in shipment
  def displayItemNumbers()
    puts 'These are the item numbers in the shipment:'
    puts items.keys
  end
 
  # displays number of items for this plus all shipments
  def numberOfItems()
    puts 'Number of items in the shipment: ' + items.length.to_s
    puts 'Total items for all shipments: ' + @@totalShipmentItems.to_s
    puts 'Max items: ' + MAX_ITEMS.to_s
  end
end

Now for the fun part. Let’s write a script that utilizes all of our new classes. The following script will do the following:

Prompt the user to type in the name of a new shipment
Create and display a new supply item
Create and display a new equipment item
Create and display a new biomed item
Create a new shipment with the name that the user entered
Add the supply, equipment and biomed items to the shipment
Display the shipment’s instance members as well as information about the items
Remove the equipment item
Display the information about the items

Save the following code in a new file called test.rb.

require './Shipment'
require './SupplyItem'
require './EquipmentItem'
require './BiomedItem'
 
puts "Enter a new shipment name: "  
STDOUT.flush  
shipmentName = gets.chomp  
 
s = SupplyItem.new('Surgical Gloves - Size 7', 'LP10001', 'Gloves', 500)
puts '=== Sample Supply Item =='
puts 'Name: ' + s.name
puts 'Item #: ' + s.itemNumber
puts 'Category: ' + s.category
puts 'Status: ' + s.status
puts 'Quantity: ' + s.quantity.to_s
puts 'Expiration Date: ' + s.expirationDate.to_s
puts s.to_s
 
e = EquipmentItem.new('Crutches', 'LP50879', 'Mobility', 2.5)
puts '=== Sample Equipment Item =='
puts 'Name: ' + e.name
puts 'Item #: ' + e.itemNumber
puts 'Category: ' + e.category
puts 'Status: ' + e.status
puts 'Weight: ' + e.weight.to_s
puts e.to_s
 
b = BiomedItem.new('Clinical Laboratory - Thermostat; w/ stirrer', 'LP25473', 'Clinical Laboratory', 15)
puts '=== Sample Biomed Item =='
puts 'Name: ' + b.name
puts 'Item #: ' + b.itemNumber
puts 'Category: ' + b.category
puts 'Status: ' + b.status
puts 'Weight: ' + b.weight.to_s
puts 'Condition: ' + b.condition
puts b.to_s
 
ship = Shipment.new(shipmentName,'Albania','40ft Container')
# add items to the shipment
ship.addItem(s)
ship.addItem(e)
ship.addItem(b)
puts '=== Sample Shipment =='
puts 'Name: ' + ship.name
puts 'Country: ' + ship.country
puts 'Type: ' + ship.type
puts 'Status: ' + ship.status
ship.numberOfItems()
ship.displayItems()
ship.displayItemNumbers()
puts '=== Deleting an Inventory Item =='
ship.deleteItem(e.itemNumber)
ship.numberOfItems()
ship.displayItems()
ship.displayItemNumbers()

Open Terminal again and type ruby tests.rb and you should see the following:

OK, so that’s a good overview of what we’ll be building. The next step is getting Rails up and running and beginning work on the web aspect. Any and all comments are welcome!