rtml 1.2.2

data/app_generators/rtml/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/app_generators/rtml/rtml_generator.rb

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'rubigen'
+require 'rubigen/scripts/generate'
+
+class RtmlGenerator < RubiGen::Base
+
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    src = File.join(File.dirname(__FILE__), "templates/rtml")
+    dst = "vendor/plugins/rtml"
+    record do |m|
+      Dir[File.join(File.dirname(__FILE__), "templates/rtml/**/*")].each do |source|
+        destination = File.join(dst, source.sub(/^#{Regexp::escape src}/, ''))
+        if File.directory?(source)
+          m.directory destination
+        elsif File.file?(source)
+          m.file File.join('rtml', source.sub(/^#{Regexp::escape src}/, '')), destination
+        end
+      end
+
+      m.file "rails_template.rb", "rails_template.rb"
+
+#      m.dependency "install_rubigen_scripts", [destination_root, 'rtml'],
+#        :shebang => options[:shebang], :collision => :force
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |o| options[:author] = o }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      lib
+      log
+      script
+      test
+      tmp
+    )
+end

data/app_generators/rtml/templates/rails_template.rb

@@ -0,0 +1,36 @@
+def win_env?
+  RUBY_PLATFORM=~ /(win32|mingw)/
+end
+
+def rake(command, options = {})
+  env = options[:env] || 'development'
+  log 'rake', "#{command} in #{env} "
+  sudo = win_env? ? '' : (options[:sudo] ? 'sudo' : '')
+  rake_cmd = win_env? ? "rake.bat" : 'rake'
+  in_root { run("#{sudo} #{rake_cmd} #{command} RAILS_ENV=#{env}", false) }
+end
+
+inside("vendor/plugins/rtml") do
+  run "ruby install.rb"
+end
+run "rm public/index.html"
+gem "hpricot"
+rake "gems:install"
+rake 'rtml:setup'
+rake 'db:migrate'
+rake 'db:test:load'
+
+controller_name = ask("Controller name [skip]: ").chomp
+if controller_name.length > 0
+  controller_name.gsub!(/_./) { |i| i[1].chr.upcase }
+  actions = ask("Actions (separate with space) [index]: ").chomp.split(/\s/)
+  actions = [ 'index' ] if actions.length == 0
+  default_action = ((actions.include? "index") ? "index" : actions.first)
+end
+
+if controller_name.length > 0
+  run "ruby script/generate rtml_controller #{controller_name} #{actions.join(" ")}"
+  route "map.connect_rtml :controller => '#{controller_name}', :action => '#{default_action}'"
+else
+  route 'map.connect_rtml'
+end

data/app_generators/rtml/templates/rtml/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Colin MacKenzie IV
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/app_generators/rtml/templates/rtml/README

@@ -0,0 +1,109 @@
+RTML (RubyTML) is a TML syntax for Ruby. (Redundant, huh?)
+
+RTML hails from very humble beginnings. Originally, it was designed to
+help new TML programmers understand just how the TML is being processed.
+TML has its similarities to HTML, except that it's about 10 times harder
+for a newbie to figure out what it means. My aim was to keep the language
+as simple as possible to understand, while keeping to an identical work
+flow, so that anyone learning the RTML would be able to take that directly
+into TML when the time came. (Ruby on Rails was considered an unlikely
+candidate for a production TML server at the time, so people had to be able
+to take what they learned from this into Java or PHP -- which means typing
+a lot of raw TML.)
+
+I think I did too good a job on the work flow thing, though, because I found
+myself writing code over and over again, just like TML. Sure, it was easier to
+read than raw TML would have been, but it was so wordy! I had a bit of a
+lightbulb moment, realizing that basic TML flies in the face of the DRY (Don't
+Repeat Yourself) principle, which is a cornerstone of Rails development,
+and I also realized that I could get so much more accomplished if I took the
+Rails principles and applied them to TML. It was just a collection of helper
+methods, really.
+
+Then, after the basic functionality was there, I had another lightbulb
+moment. I looked at the Rails framework and what it had become, and thought,
+why not do for TML what Rails has done for HTML? So I started writing
+supporting classes for it -- the TMLAppController, some helpers, Widgets,
+some generators and rake tasks... The list goes on. RTML has come a long
+way since its inception.
+
+RTML makes a concerted effort to make the application read like
+a human language. This is why Ruby was chosen as the base language of choice:
+because Ruby is already pretty easy to read, as programming languages go.
+It's not perfect, of course, but it's getting close.
+
+
+
+What RTML is NOT:
+
+RTML is not a complete substitute for standard Terminal Markup Language (TML).
+It reformats Ruby-style code into its TML counterpart, which is then sent to
+the terminal browser.
+
+RTML is not an IDE. RTML can even be written in Notepad, if you have the
+stomach for it. It is simply a Ruby interface into the TML world.
+
+RTML is not a replacement for the TML logic flow. That is, RTML will not
+replace the entire TML development process. TML, in its simplest form, looks
+something like:
+
+  Idle prompt -> User Input -> Screen -> User Input -> [Send data, receive data]
+  						-> Completion / back to Idle Prompt.
+  						
+This flow is exactly the same whether you design an application using RTML or
+standard TML.
+
+
+
+Here is an example of the GMA event processing code found on page 34
+of the TML Application Development Guidelines for Incendo, rewritten as an
+RTML action:
+
+	Rtml::actions_for MyTMLApplication do
+		on :menu => :initialscr, :cancel => :initialscr
+		includes '/btmlpa/tmlapp.tml'
+		includes '/magcard/magcard.tml'
+		includes '/iccemv/iccemv.tml'
+		
+		screen :initialscr, :next => :initialscr1 do
+			next_screen '/magcard/magcard.tml', :if => "tmlvar:gma.event.occured == mag"
+			next_screen '/iccemv/iccemv.tml',   :if => "tmlvar:gma.event.occured == icc"
+		end
+	
+		screen :initialscr1 do
+			on :cancel => :initialscr1
+			display # The actual display code is segregated into a Rails view. See below.
+		end
+	
+		screen :gma_subscr, :next => :initialscr1 do
+			set 'gma.event.subscribed' => 'anykey;mag;icc'
+		end
+	
+		screen :gma_unsubscr, :next => :initialscr1 do
+			set 'gma.event.subscribed' => ''
+		end
+	end
+
+Notice the :initialscr1 screen has "display" in it. This tells RTML to
+render the View for that screen. Display can be called with an argument,
+too, to override this behavior: A String will be assigned directly, or 
+a Block can be added to facilitate additional functionality.
+
+For this example, the View looks like this:
+
+		<h1>OE Examples:</h1>
+		<%=link_to "BTMLPA", "/btmlpa/tmlapp.tml"%><br/>
+		<%=link_to "MAGCARD", "/magcard/magcard.tml"%><br/>
+		<%=link_to "ICCEMV", "/iccemv/iccemv.tml"%><br/>
+		<%=link_to "Subscribe to GMA events", :anchor => "#gma_subscr"%><br/>
+		<%=link_to "Unsubscribe from GMA events", :anchor => "#gma_unsubscr"%><br/>
+		<%=link_to "Terminal Config", embedded_app%><br/>
+		<%=link_to "Exit OEBR", "exit"%>
+
+As you can see, RTML is embedded within an ERB document just like
+any other Embedded Ruby.
+
+
+Copyright (c) 2009
+Written by Colin MacKenzie IV
+Released under the MIT license.

data/app_generators/rtml/templates/rtml/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+#require File.join(File.dirname(__FILE__), "lib", "rtml", "version")
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+task "test" do |t|
+  Rake::Task['test:all'].invoke
+end
+
+namespace "test" do |t|
+  desc 'Test the rtml plugin.'
+
+  [:all, :core, :validation, :functional].each do |s|
+    desc "Test rtml (#{s})"
+    Rake::TestTask.new(s) do |t|
+      case s
+        when :all then t.pattern = "test/**/*.rb"
+        else t.pattern = "test/#{s}/**/*.rb"
+      end
+
+      #t.libs << 'lib'
+      t.test_files = ["test/rtml_test_helper.rb"]
+      t.verbose = true
+    end
+  end
+end
+
+desc 'Generate documentation for the rtml plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rtml'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

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

@@ -0,0 +1,70 @@
+class BerylController < Rtml::RtmlAppController
+  tml_helper :all, :plugin_path => true # see app/helpers/beryl_tml_helpers/*.rb
+  include Rtml::Features
+  hide_action :authorize
+  
+  configure_features do |config|
+    config.common.menu = false
+  end
+
+  rtml_debug do |config|
+    config[:dump_tml] = false
+  end
+  
+  def authorize(transaction)
+    logger.warn "You should override BerylController#authorize(transaction)"
+    logger.warn "Default implementation always sends a fake approval."
+    logger.debug "Transaction information:"
+    logger.debug transaction.to_yaml
+    
+    transaction.message = "APPROVED"
+    transaction.auth_code = Time.now.to_i + rand(99999)
+    transaction.state = :approved
+  end
+  
+  def sale
+    auth Rtml::Transaction.from(params)
+  end
+  
+  def sale_return
+    auth Rtml::Transaction.from(params)
+  end
+  
+  def force_sale
+    auth Rtml::Transaction.from(params)
+  end
+  
+  def void
+    auth Rtml::Transaction.from(params)
+  end
+
+  private
+  def auth(transaction)
+    valid_states = (Rtml::Beryl::Constants::States - [:new])
+
+    started_at = Time.now
+    begin
+      transaction.card.input_type = :keyed if params[:manual_entry].to_s == '1'
+      authorize transaction
+      unless valid_states.include? transaction.state
+        raise "Set transaction.state to one of #{valid_states.inspect}"
+      end
+      transaction.message ||= case transaction.state
+        when :approved then "Transaction approved"
+        when :declined then "Transaction declined"
+        when :failed   then "Transaction failed"
+        when :reversed then "Transaction reversed"
+        when :canceled then "Transaction canceled"
+      end
+    rescue #auth
+      transaction.state = :declined if transaction.state == :new
+      raise
+      #raise "Error in transaction data: \"#{$!}\""
+    end
+    transaction.duration = Time.now.to_f - started_at.to_f
+    transaction.save!
+    
+    @transaction = transaction
+    render :rtml => :auth_result unless performed?
+  end
+end

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

@@ -0,0 +1,9 @@
+class Rtml::MagcardDemoController < Rtml::RtmlAppController
+  tml_helper :all, :plugin_path => true # see app/helpers/magcard_demo_tml_helpers/*.rb
+  
+  def authorize
+    logger.debug params.to_yaml
+    @auth_code = Time.now.to_i
+    render :rtml => :authorized
+  end
+end

data/app_generators/rtml/templates/rtml/app/controllers/rtml/oe/btmlpa_controller.rb

@@ -0,0 +1,158 @@
+class Rtml::Oe::BtmlpaController < Rtml::RtmlAppController
+#    $RTML_WIREDUMP_DEV = STDOUT
+#  caches_action :index, :receipt, :icc
+  
+  tml_helper :all, :plugin_path => true
+  include Rtml::Oe
+  include Rtml::Oe::BtmlpaConstants
+  
+  before_filter :find_terminal, :only => [ :auth, :reverse ]
+  
+  public
+  def rescue_action_test
+    raise "Error"
+  end
+  
+  def reverse
+    txn = Rtml::Transaction.find_by_txn_id(params[:transid], :conditions => { :terminal_id => @terminal.id })
+    if txn.nil?
+      raise "Reversal failed: Invalid transaction ID"
+    else
+      case txn.state
+        when State::APPROVED
+          t = txn.txn_type
+          txn.txn_type = TxnType::REVERSAL
+          authorize! txn # Application.getInstance().reverseTransaction(txn)
+          raise "Reversal failed: #{txn.message}" if txn.auth_code.nil?
+          txn.state = State::REVERSED
+          txn.txn_type = t
+          txn.save!
+        when State::NEW
+          txn.state = State::CANCELED
+          txn.save!
+        else
+          puts "FAIL ON GET < #{txn.state}"
+          raise "Reversal failed: Invalid transaction state"
+      end
+    end
+    
+    @message = "Reversed."
+    @destination = "receipt"
+    render :rtml => :dynamic
+  end
+
+  def auth
+    puts params.to_yaml
+    started_at = Time.now
+    txn = Rtml::Transaction.find_by_txn_id(params[:transid], :conditions => { :terminal_id => @terminal.id })
+    if txn.nil?
+      txn = transaction_class.new(:state => State::NEW,
+                            :txn_started => started_at,
+                            :terminal => @terminal,
+                            :txn_id => params[:transid],
+                            :post_id => params[:post_id],
+                            :txn_mode => params[:oebr][:submit_mode],
+                            :txn_type => txn_type_to_i(params[:payment][:trans_type]),
+                            :term_txn_date => DateTime.parse((params[:payment][:txn_date] || Time.now).to_s).utc,
+                            :post_txn_date => (params[:date] ? DateTime.parse(params[:date].to_s).utc : nil),
+                            :amount => params[:payment][:amount]
+                           )
+      if txn.txn_type == TxnType::SALE_CASHBACK
+        if params[:payment][:amount_other] == Value::NOT_SPECIFIED
+          raise "Cashback amount should be specified."
+        end
+        txn.amount_other = params[:payment][:amount_other]
+      end
+      txn.currency_code = params[:currency_code]
+      txn.pan = params[:card][:pan]
+      txn.cardholder_name = params[:card][:cardholder_name]
+      txn.card_number = params[:card][:issue_number]
+      txn.input_method = params[:card][:input_type]
+      txn.iso2_track = params[:card][:mag][:iso2_track] if params[:card][:mag]
+      txn.expiry_date = params[:card][:expiry_date]
+      txn.start_date = params[:card][:effective_date]
+      if txn.input_method == InputMethod::ICC
+        txn.icc_app  = params[:card][:emv][:aid]
+        txn.icc_aip  = params[:card][:emv][:aip]
+        txn.icc_auc  = params[:card][:emv][:auc]
+        txn.icc_atc  = params[:card][:emv][:atc]
+        txn.icc_aac  = params[:card][:emv][:aac]
+        txn.icc_tc   = params[:card][:emv][:tc]
+        txn.icc_arqc = params[:card][:emv][:arqc]
+        txn.icc_iad  = params[:card][:emv][:iad].to_s
+        txn.icc_tvr  = params[:card][:emv][:tvr]
+        txn.icc_unumber = params[:card][:emv][:unumber]
+      end
+      
+      txn.save!
+    else
+      txn.post_id = params[:post_id] if params[:post_id]
+#      if txn.post_id != params[:post_id]
+#        raise "Transaction has a duplicate ID."
+#      end
+      txn.txn_mode = "offline"
+      txn.save!
+    end
+    
+    if txn.state == State::NEW
+      begin
+        authorize! txn
+        txn.state = (txn.auth_code ? State::APPROVED : State::DECLINED)
+        puts "SET > #{txn.state}"
+      rescue
+        txn.state = State::DECLINED
+        puts "Error in transaction data: #{$!}"
+        puts $!.backtrace[0..4].join("\n")
+        raise "Error in transaction data: \"#{$!}\""#"Incorrect data."
+      end
+      txn.txn_duration = (Time.now.to_i - started_at.to_i)
+      txn.save!
+    end
+    
+    unless offline?
+      # do stuff w/ auth result stuff
+    end
+    
+    @transaction = txn
+    auth_result
+  end
+  
+  protected
+  # Commence transaction authorization
+  # You should override this in your controller.
+  def authorize!(transaction)
+    raise "Default method Rtml::Oe::BtmlpaController#authorize! is not implemented"
+  end
+  
+  def transaction_class
+    self.class.name.gsub(/Controller/, "Transaction").constantize rescue \
+      self.class.name.gsub(/Controller/, '::Transaction').constantize rescue \
+      Rtml::Transaction
+  end
+  
+  private
+  def find_terminal
+    Rtml::Terminal
+    Rtml::Transaction
+#    Examples::Btmlpa::Terminal
+#    Examples::Btmlpa::Transaction
+    
+    @terminal = Rtml::Terminal.find_by_itid(params[:itid])
+    @terminal = Rtml::Terminal.create!(:itid => params[:itid]) if @terminal.nil?
+    #raise "Terminal ITID not found: #{params[:itid]}" if @terminal.nil?
+  end
+  
+  def txn_type_to_i(type)
+    case type.to_s.downcase
+      when "debit" then return 1
+      when "cashback" then return 2
+      when "credit" then return 3
+      when "reversal" then return 1
+      else raise "Unsupported payment type: #{type}"
+    end
+  end
+  
+  def offline?
+    params[:oebr][:submit_mode].to_s.downcase == "offline"
+  end
+end