rtml 1.2.2

data/app_generators/rtml/templates/rtml/app/controllers/rtml/rtml_app_controller.rb

@@ -0,0 +1,252 @@
+class Rtml::RtmlAppController < Rtml::TmlAppController
+  include Rtml::Helpers::ControllerHelpers::MenuHelpers
+  
+  prepend_before_filter :force_rtml, :only => :uml
+  before_render :render_tml
+  around_filter :process_action_with_view_paths
+  hide_action :rtml_interface, :tml_document, :rtml_document, :tml_document=, :rtml_document=
+  
+  # For creating UML diagrams of TML screens for the given action. Must be in this same controller.
+  def uml
+    helper = response.template
+    
+    include_view_paths_for params[:id]
+    self.rtml_interface.fire_action(params[:id], self)
+    @screens = tml_document.screens
+    url = []
+    @screens.each do |scr|
+      map = {}
+      left = nil
+      scr.every_possible_variant do |cond, dest|
+        left = helper.uml_for_screen(scr)
+        right = helper.uml_for_screen(@screens.find(dest) || helper.format_for_uml(dest))
+        if cond == :default and not map[right] then cond = ""
+        else
+          cond = unless cond =~ /key=/ then cond.to_s.gsub(/(^|\s)..=['"]([^'"]*)['"]/, '\1\2')
+          else cond.to_s.gsub(/['"]/, '').gsub(/key=/, 'on key ')
+          end
+        end
+        if map[right] then map[right] << " | #{cond}"
+        else map[right] = cond
+        end
+      end
+      # we use the map to merge multiple conditions in order to point to a destination only once
+      map.each { |right, cond| url << "[#{left}]-#{cond}>[#{right}]" }
+    end
+    tml_document.reset!
+    
+    data = helper.get_uml_image_data(url)
+    send_data data, :disposition => 'inline', :type => 'image/png', :file_name => "#{params[:id]}.png"
+  end
+  
+  def self.inherited(base) #:nodoc:
+    super
+    # TODO: It may be important to leave base.controller_path in the view paths in order to
+    # handle overriding the tml_app views. Need to figure out if this is necessary or not.
+    # base.append_view_path(File.join("vendor", "plugins", "rtml", "app/views", base.controller_path))
+    base.send :include, "#{base.controller_path}_tml_helpers".camelize.constantize rescue nil
+  end
+  
+  def self.rtml_interface #:nodoc:
+    if self.superclass.respond_to? :rtml_interface
+      @rtml_interface ||= Class.new(self.superclass.rtml_interface.class).new
+    else
+      @rtml_interface ||= Class.new(Rtml::Proxying::RtmlInterface).new
+    end
+    @rtml_interface
+  end
+  
+  def self.add_rtml_actions(*actions) #:nodoc:
+    actions.flatten.each do |action|
+      raise ArgumentError.new("Action must be Symbol or String") unless action.kind_of? Symbol or action.kind_of? String
+      line = __LINE__ + 1
+      eval %Q`
+        def #{action}
+          set_rtml unless template_exists?(default_template_name)
+          if request.format == :rtml
+            self.rtml_interface.fire_action(#{action.inspect}, self)
+          end
+        end
+      `, binding, __FILE__, line
+    end
+  end
+  
+  def rtml_interface #:nodoc:
+    self.class.rtml_interface
+  end
+  
+  # Returns the TML document that is being constructed for this request.
+  def tml_document
+    @tml_document ||= Rtml::Core::TMLDocument.new(response.template)
+  end
+  
+  # Overwrites the TML document, if any, with the specified target.
+  # The specified target document becomes the "active" target, and will
+  # be rendered in place of this one.
+  def tml_document=(target)
+    @tml_document = target
+  end
+  
+  alias rtml_document= tml_document=
+  alias rtml_document tml_document
+  
+  protected
+  include Rtml
+  include Rtml::Core
+  extend Rtml::TmlAppHelper
+  extend Rtml::Helpers::ControllerHelpers
+  
+  # Adds the specified action's view paths to this action's view paths,
+  # which would allow you to render views and partials from the specified
+  # action. Note that if two actions specify the same view, the view path
+  # that is encountered first takes precedence. (This should be the current
+  # action, which is ideal, BUT it's Rails core functionality that I'm not
+  # going to vouch for. Basically, keep the names unique or use at your own
+  # risk.)
+  def include_view_paths_for(action)
+    add_instance_view_paths(action)
+  end
+  
+  # Used for modifying the template files to be found in
+  # controller/action/screen_name.erb (instead of the Rails default
+  # controller/action.erb).
+  def default_template_name(action_name = self.action_name,
+                            ext         = response.template.template_format,
+                            klass       = self.class) #:nodoc:
+    s = super
+    return s if s
+    if action_name =~ /\//
+      return s
+    else
+      return super("#{params[:action]}/#{action_name}", ext, klass)
+    end
+  end
+  
+  # We need the default rescue_action functionality, but we first
+  # need to reset the TML document that's being generated, or else
+  # we'll end up with a TML document that half represents what the
+  # user was constructing, half represents the error being reported,
+  # and is completely invalid TML!
+  def rescue_action(*a)
+    tml_document.reset!
+    super
+  end
+
+  
+  private
+  # Adds default action-specific view paths to this controller, then
+  # calls the action, and finally removes the view paths.
+  def process_action_with_view_paths
+    include_view_paths_for params[:action]
+    yield
+    remove_instance_view_paths
+  end
+  
+  # Adds all registered view paths for the specified action to the
+  # controller for this action. This is called by the around_filter
+  # before the action is called.
+  def add_instance_view_paths(action)
+    controller = self
+    @paths_to_delete = []
+    (controller.class.view_paths_for_actions.select do |a|
+      a[0].to_s.length == 0 || a[0].to_s == action.to_s
+    end).each do |a|
+      path = a[1]
+      add_instance_view_path path
+    end
+  end
+  
+  # Adds the specified view path to the controller's view paths
+  # and also adds it to the list of paths to be deleted at the end
+  # of this action (so that they are not permanent in production).
+  def add_instance_view_path(path)
+    unless controller.class.view_paths.include? path
+      @paths_to_delete << path
+      controller.prepend_view_path path
+    end
+  end
+  
+  # Removes all view paths that were not a part of the action-unspecific
+  # (global) array for this controller. This is called by the around_filter
+  # after content has been rendered.
+  def remove_instance_view_paths
+    controller = self
+    @paths_to_delete.each do |path|
+      controller.view_paths.delete path
+    end
+  end
+
+  def render_tml
+    headers_filter
+    return unless tml_document.modified? and not performed? and response.redirected_to.nil? 
+
+    # The reason I don't check against request.format here is because I want to handle things like respond_to,
+    # which might look something like
+    #  respond_to do |format|
+    #    format.rtml
+    #    format.html
+    #    format.json { render :json => obj.to_json }
+    #    format.xml  { render :xml => obj.to_xml }
+    #  end
+    #
+    # respond_to does not set request.format; it sets response.template.template_format. So that's what I need
+    # to check. Note that pretty much everywhere else, request.format should be checked, because pretty much
+    # everywhere else we want to know what the client is ASKING for.
+    #
+    if response.template.template_format == :rtml
+      tml = tml_document.to_tml
+      ### HACK!
+      # Having problems with the browser restarting the app when the visiting the full link with an anchor.
+      # Strange, it only happens once. But this should work around it.
+      tml.gsub!(/(["'])#{Regexp::escape url_for(:action => params[:action], :only_path => true)}\#/, '\1#')
+      logger.debug tml if self.class.rtml_debug_config[:dump_tml]
+      render_without_before_render_filter :text => tml
+    end
+  end
+    
+  # Another method for forcing the user into an RTML format. See Rtml::TmlAppController#force_format
+  # and use with care. What this does, essentially, is check to see whether there are any RTML
+  # templates available, and if so, forces the user into RTML format. Only used in very rare
+  # circumstances, obviously, because this will ignore things like what browser is actually
+  # requesting the document. If you call this method, and the user is using Firefox or IE,
+  # tough luck: an RTML template exists, you've told RTML to use it unconditionally.
+  # No effect if no RTML ERB template exists. So for instance, if you are building a TML document
+  # via the tml_helpers, none of the above will happen.
+  def set_rtml
+    if self.class.action_methods.include? params[:action]
+      unless template_exists? default_template_name(params[:action]) and not tml_document.screen_defined? params[:action]
+        force_format :rtml
+      end
+    end
+  end
+  
+  def force_rtml #:nodoc:
+    force_format :rtml
+  end
+  
+  # Declare the specified action to require the specified path. This is used
+  # in the around_filter when constructing the default view paths for an action.
+  #
+  # If action is nil, this path will be added to all actions. (This may be useful
+  # if you want to add a view path to all instances of this controller without
+  # affecting the view paths of any other controllers.)
+  def self.append_view_path_for_action(action, path)
+    view_paths_for_actions << [ action.to_s, path ]
+  end
+  
+  # Return the array of default paths. First argument is action name; second 
+  # argument is the path itself.
+  def self.view_paths_for_actions
+    if @view_paths_for_actions.nil?
+      if self.superclass.respond_to? :view_paths_for_actions
+        @view_paths_for_actions = self.superclass.view_paths_for_actions.collect { |arr| arr.dup }
+      else
+        @view_paths_for_actions = []
+      end
+    end
+    @view_paths_for_actions
+  end
+  
+  public
+  tml_helper :all
+end

data/app_generators/rtml/templates/rtml/app/controllers/rtml/tml_app_controller.rb

@@ -0,0 +1,418 @@
+module Rtml
+  class TmlAppController < ApplicationController
+    include Rtml::Helpers::RenderHelper
+    include Rtml::Helpers::TerminalHelpers
+
+    #It's sad, but we have to skip the authenticity token, because OEGW doesn't support cookies
+    # and therefore has no clue what a Session object is. The Session is used to make sure
+    # authenticity tokens are valid and to generate new ones -- so what happens is, since
+    # the terminal doesn't maintain a session cookie, every request is considered a new "session"
+    # and the previous "session" token is invalidated. So POST data can't be processed because
+    # Rails thinks it's all fake! Until OpenEstate supports session cookies, it has to be disabled.
+    # FIXME: When session cookies are supported, re-enable authenticity verification. Or override
+    # Rails authenticity checking with something a little more TML-friendly...
+    skip_before_filter :verify_authenticity_token
+    
+    before_filter :format_filter
+    #before_filter :headers_filter
+    before_filter :load_state
+    
+    hide_action :embedded_app, :url_for
+    
+    # 080609:
+    # save_state changed to a before_render filter because the user is more likely to change it
+    # in the TML helper than they are in the View, and after much research I had to take sides
+    # (RTML documents do a lot of render_or_redirect-ing, which halts the filter chain).
+    before_render :save_state
+    #after_filter  :save_state
+    
+    append_view_path File.join(PLUGIN_BASE, "app", "views", "rtml", "tml_app")
+    
+    # Action reserved for retrieving TML state data. See
+    # app/views/rtml/tml_app/get_terminal_info.rtml.erb for customization.
+    # You can also override this view within your controller's views, if needed.
+    #
+    # Note that this file should be either a straight TML template (using ERB of course)
+    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
+    # generation in the View). If you don't know what any of that means, then don't touch it.
+    def get_terminal_info
+    end
+  
+    # Action reserved for redirect_to directives. This functionality will be removed
+    # when Incendo supports HTTP redirects, but until then, the only way to do it
+    # is in the terminal-side TML. See app/views/rtml/tml_app/do_tml_redirect.rtml.erb
+    # for customization.
+    # You can also override this view within your controller's views, if needed.
+    #
+    # Note that this file should be either a straight TML template (using ERB of course)
+    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
+    # generation in the View). If you don't know what any of that means, then don't touch it.
+    def do_tml_redirect
+    end
+    
+    def url_for(options = {})
+      super(options.reverse_merge(:format => params[:format]))
+    end
+    
+    class << self
+      # Allows you to provide an expiration timeout. This must be done with a block so that it
+      # can be evaluated only when the expiration headers are being sent.
+      #
+      # Example:
+      #   expires_at { 7.days.from_now }
+      #   expires_at { |controller| controller.current_user.id == 1 ? Time.now : 3.days.from_now }
+      #
+      def expires_at(&block)
+        @expires_at_block = block if block_given?
+        return @expires_at_block
+      end
+      public :expires_at
+    end
+
+    # Allows you to provide an expiration timeout. This must be done with a block so that it
+    # can be evaluated only when the expiration headers are being sent.
+    #
+    # Example:
+    #   expires_at { 7.days.from_now }
+    #   expires_at { |controller| controller.current_user.id == 1 ? Time.now : 3.days.from_now }
+    #
+    def expires_at(&block)
+      @expires_at_block ||= self.class.expires_at
+      @expires_at_block = block if block_given?
+      return @expires_at_block
+    end
+
+    protected
+    # Overrides the set of defaults for when a Web browser (as opposed to a terminal browser)
+    # connects and requests this RTML resource.
+    #
+    # Example:
+    #   class MyAppController < Rtml::RtmlAppController
+    #     rtml_debug do |config|
+    #       config[:model] = 5100
+    #     end
+    #   end
+    #
+    def self.rtml_debug(&blk)
+      yield self.rtml_debug_config
+    end
+    
+    # Returns the hash of RTML debug options, for use when a Web browser (and not a terminal
+    # browser) requests this RTML resource.
+    def self.rtml_debug_config
+      @rtml_debug_config ||= HashWithIndifferentAccess.new({
+        :datetime_start => Date.parse('2006/01/01'),
+        :os => '03.27',
+        :itid => '111111111',
+        :model => 8550,
+        :datetime => Time.now,
+        :part_number => 'I8550_BROWSER',
+        :dump_tml => false
+      })
+    end
+    
+    # Provides a tml_redirect method because Incendo won't understand the "Location"
+    # header that redirect_to produces. (Groupe has agreed to implement this missing
+    # functionality in an upcoming release.) This new redirect_to method will render the
+    # do_tml_redirect action instead, which results in a TML-based redirect.
+    # This is only done for the MicroBrowser. Any other browser gets the standard
+    # Rails functionality unless it passed in the .rtml extension to this request.
+    def redirect_to(a,&b)
+      if request.is_terminal? or params[:format] == 'rtml'
+        if a.kind_of? Hash
+          @redirect_to = url_for(a.merge(:only_path => true))
+        else
+          @redirect_to = url_for(:action => a)
+        end
+        render :action => 'do_tml_redirect'
+      else
+        super
+      end
+    end
+    
+    # Forces the user to use the specified format, regardless of what was requested by the
+    # browser or detected by RTML. You should be very careful with this, because it can have
+    # unintended consequences such as feeding TML to a browser expecting HTML. In fact, it's
+    # generally better to leave the format handling for the RTML Core to worry about. You
+    # have been warned.
+    def force_format(fmt)
+      fmt = params[:format] || 'html' if fmt.nil?
+      request.format = fmt
+      format_filter
+      #headers_filter
+    end
+    
+    # Allows you to toggle whether or not form data sent from a terminal via TMLPOST data should
+    # be available directly via the params object, or whether it should be isolated in params[:tml].
+    # For example, the "user_name" parameter would be stored in params[:user_name] if collect_params
+    # is false, or params[:tml][:user_name] if collect_params is true. By default, params are
+    # stored directly in the params hash (in other words, the default is "false") -- but if you
+    # call this method with no arguments, it will be set to TRUE.
+    #
+    # Example:
+    #   class MyTmlController < Rtml::TmlAppController
+    #     collect_params  # => true
+    #     collect_params false
+    #     collect_params true
+    #     . . .
+    #   end
+    def self.collect_params(tf = true)
+      self.class_eval { def collect_params?; tf; end }
+    end
+    
+    # Returns the terminal state hash. Raises an error if the state is not available (but this
+    # shouldn't happen unless you forgot to run rake rtml:setup). Note that you only need to run
+    # rake rtml:setup if you plan to actually make use of the state hash.
+    def state
+      @terminal_state.nil? ? (raise "State not available; run rake rtml:setup to enable it") :
+                             @terminal_state#.state
+    end
+
+    # If true, TML params will be segregated into params[:tml]
+    # If false, default functionality is assumed, and params will be stored directly within the
+    # params hash. While you can override this if you wish, you're probably better off using
+    # the #collect_params method within your controller.
+    def collect_params?(); false; end
+
+    # This method is responsible for making view inheritance possible.
+    def default_template_name(action_name = self.action_name,
+                              ext         = response.template.template_format,
+                              klass       = self.class) #:nodoc:
+      if action_name && klass == self.class
+        action_name = action_name.to_s
+        if action_name.include?('/') && template_path_includes_controller?(action_name)
+          action_name = strip_out_controller(action_name)
+        end
+      end
+      if !klass.superclass.method_defined?(:controller_path)
+        return "#{self.controller_path}/#{action_name}"
+      end
+      template_name = "#{klass.controller_path}/#{action_name}"
+      if template_exists? template_name, ext
+        return template_name
+      else
+        return default_template_name(action_name, ext, klass.superclass)
+      end
+    end
+    
+    # Checks to see if a template with the specified name and optional format exists.
+    unless ActionController::Base.private_instance_methods.include? 'template_exists?'
+      def template_exists?(template_name, fmt = response.template.template_format) #:nodoc:
+        self.view_paths.find_template(template_name, fmt)
+      rescue ActionView::MissingTemplate, Errno::ENOENT
+        false
+      end
+    end
+
+    # If a catastrophic error would otherwise result in a 500 Internal Server Error
+    # and the application server is running in PRODUCTION mode,
+    # this method will be called instead, and the terminal user will instead see a
+    # pretty error message. It's something generic like "Contact an administrator",
+    # and it can be overridden by creating a "rescue_action_in_public.rtml.erb" file
+    # somewhere in your view path. You can find the original at
+    # app/views/rtml/tml_app/rescue_action_in_public.rtml.erb.
+    #
+    # Note that this file should be either a straight TML template (using ERB of course)
+    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
+    # generation in the View).
+    def rescue_action_in_public(exception) #:nodoc:
+      if request.is_terminal? or params[:error_mode] == 'rtml'
+        @exception = exception
+        render :action => 'rescue_action_in_public'
+      else
+        super
+      end
+    end
+    
+    # If a catastrophic error would otherwise result in a 500 Internal Server Error
+    # and the application server is running in DEVELOPMENT mode,
+    # this method will be called instead, and the terminal user will instead see a
+    # detailed error report like the default ones that Rails generates for your
+    # Web browser.
+    # If you need to tweak the message, it can be overridden by creating a
+    # "rescue_action_locally.rtml.erb" file
+    # somewhere in your view path. You can find the original at
+    # app/views/rtml/tml_app/rescue_action_locally.rtml.erb.
+    #
+    # Note that this file should be either a straight TML template (using ERB of course)
+    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
+    # generation in the View).
+    def rescue_action_locally(exception) #:nodoc:
+      if request.is_terminal? or params[:error_mode] == 'rtml'
+        @exception = exception
+        #if self.respond_to? :rtml_interface and rtml_interface
+          #rtml_interface.instance_variable_set("@exception", exception)
+        #end
+        render :action => 'rescue_action_locally'
+      else
+        super
+      end
+    end
+    
+    
+    private
+    # If params[:format] is specified as 'tml', it is changed to 'rtml' and the method returns.
+    # If it is set to any
+    # other non-nil value, nothing happens. If it is nil, then the following happens:
+    #   If a template of the requested format exists, the method returns as no further action is
+    #     necessary. (The matching template will be rendered unless you intervene.)
+    #   If the requested format is 'tml', or the client is a terminal, the format is forced to 'rtml'.
+    #   If the client is not a terminal and the requested format is not 'tml', nothing happens.
+    #
+    # This method also defines a singleton method for the request object called is_terminal? which
+    # returns true if the client for this request is a terminal (as opposed to a browser). Note that
+    # the is_terminal? method always tells the "truth" -- even if the browser is emulating a terminal
+    # for this request, it will still return false for a browser.
+    def format_filter
+      def request.is_terminal?
+        self.user_agent and (self.user_agent['OE MicroBrowser'] || self.user_agent['IO Browser'])
+      end
+      
+      params[:format] = 'rtml' if params[:format] == 'tml'
+      return if params[:format] # Client-specified formats trump anything automatically assigned
+      return if template_exists? default_template_name(action_name, request.format)
+      
+      fmt = request.format#response.template.template_format.to_s
+      fmt = 'rtml' if fmt == 'tml' or request.is_terminal?
+      request.format = fmt
+#      response.template.template_format = fmt # params[:format] = fmt
+    end
+    
+    # Sets the content-type to XML instead of TML for anything but OEGW. This makes it viewable
+    # in a user's browser as an XML document. Also rebuilds the ETag header to be compatible with
+    # OpenEstate/Incendo Online. (Default Rails ETags are 1 character too long. Painful debugging,
+    # that.)
+    def headers_filter
+      if [:rtml, :tml].include? request.format.to_sym
+        headers['content-type'] = 'text/xml' unless request.is_terminal?
+        headers['content-type'] = 'text/tml' if request.is_terminal?
+        headers['Cache-Control'] = 'no-cache ' # trailing space is important!
+        headers['ETag'] = "W/\"329-#{Time.now.to_i}#{rand(9999)}\" "
+        headers['Expires'] =
+          if expires_at
+            expires_at.call(self)
+          else
+            Time.at(0) # always expired
+          end.strftime("%a, %d %b %Y %H:%M:%S GMT")
+      end
+    end
+    
+    # Loads the terminal's (or browser's) state hash from the database.
+    # TODO: Use Rails.cache for the state whenever possible.
+    def load_state
+      if params[:tml]
+        term_params = params[:tml][:terminal]
+      else
+        term_params = params[:terminal]
+      end
+      fail = false # if true, the get_terminal_info TML page will be rendered.
+      repost = false # if true, the terminal data is out of date and needs to be refreshed.
+      
+      headers = request.headers
+      unless request.is_terminal?
+        # Build some fake data if the user is viewing with a browser, for debugging
+        # Otherwise, user would just always see get_terminal_info. Epic debugfail.
+        p = params[:browser] || {}
+        headers = Rtml::Debug::BrowserEmulator.new(headers.merge(self.class.rtml_debug_config.merge(p)))
+        repost = true # always use current browser details. This enables debug configuration override.
+      end
+      
+      itid = headers['ITID'] || headers['HTTP_ITID']
+      itsn = headers['ITSN'] || headers['HTTP_ITSN']
+      itpn = headers['ITPN'] || headers['HTTP_ITPN']
+      
+      if itid && itsn && itpn or not request.is_terminal?
+        signature = "#{itsn}:#{itpn}:#{itid}"
+        @terminal_state = Rtml::State.find_by_signature(signature)
+        if @terminal_state.nil?
+          logger.debug "Terminal state for signature '#{signature}' not found; creating"
+          @terminal_state = Rtml::State.new(:signature => signature,
+                                           :terminal => Terminal.new(:itid => itid))
+          @terminal_state.state ||= HashWithIndifferentAccess.new
+          logger.debug "Saving empty state"
+          @terminal_state.save!
+        end
+
+        if @terminal_state.state.empty?
+          logger.debug "Terminal state needs populated."
+          repost = true
+        elsif @terminal_state.created_at < 1.day.ago
+          logger.debug "Terminal state is outdated (#{@terminal_state.created_at} < #{1.day.ago}) and will be repopulated."
+          repost = true
+        end
+        
+        if repost
+          p = term_params
+          p = headers if headers.kind_of? Rtml::Debug::BrowserEmulator
+          
+          if p
+            logger.debug "Found terminal information in headers."
+            @terminal_state.state.merge! p
+            @terminal_state.state[:signature] = @terminal_state.signature
+            @terminal_state.created_at = Time.now
+            # State is saved as a part of the before_render filter.
+#            @terminal_state.save!
+            
+            if term_params
+              # FIXME: First I need to remember what this was designed to do (dumb me and no comments),
+              # and then I need to make it work. Whatever it was, it was causing an infinite loop when
+              # redirect_to resulted in reposting state data.
+              #
+              #params.delete :terminal
+              #params[:tml].delete :terminal if params[:tml]
+              #redirect_to params
+            end
+            return true
+          else
+            logger.debug "Could not find terminal information in headers; triggering a data post"
+            logger.debug "term_params: #{term_params.inspect}"
+            logger.debug "params: #{params.inspect}"
+            fail = true
+          end
+        end
+      else
+        raise "Could not find TID header!" unless itid
+        raise "Could not find SN header!" unless itsn
+        raise "Could not find PN header!" unless itpn
+        raise "Unknown error -- something to do with the TID/SN/PN headers!"
+      end
+      return true unless fail
+
+      unless request.post? # don't want to interfere with POSTing
+        force_format :rtml
+        # FIXME: It may be preferable to use redirect_to instead of render
+        # because if the terminal hits an error in get_terminal_info (or
+        # more likely, after it posts the data get_terminal_info is asking
+        # for), the user is going to be somewhat confused by an error message
+        # blaming HIS action, not the get_terminal_info action.
+        # However, also need to be sure that when the user hits get_terminal_info,
+        # he'll be sent back to the current action.
+        #redirect_to :action => 'get_terminal_info'
+
+        render :action => 'get_terminal_info'
+        headers_filter
+        return false
+      end
+      
+    # If we get an ActiveRecord error, it's probably because RTML state has not been initialized.
+    # Fail silently. Then, if the user tries to access state, they'll get the "rake first"
+    # error via the #rtml_state method (above).
+    rescue ActiveRecord::StatementInvalid
+      true
+    end
+    
+    # Saves the terminal's (or browser's) state hash to the database.
+    # TODO: Use Rails.cache for the state (as opposed to the database) whenever possible.
+    def save_state
+      if @terminal_state
+        begin
+          @terminal_state.save
+        rescue #save_state
+          logger.error $!
+          logger.error $!.backtrace.join("\n\t")
+        end
+      end
+      true
+    end
+  end
+end