fe 0.0.4 → 1.0.0

data/app/assets/javascripts/fe/rails.extra.js

@@ -1,6 +0,0 @@
-(function($) {
-	// Enable sortable items
-	$(function() {
-		setUpJsHelpers();
-	});			
-})(jQuery);

data/app/controllers/fe/applications_controller.rb

@@ -1,183 +0,0 @@
-module Fe
-  class ApplicationsController < ApplicationController
-    append_before_filter :check_valid_user, :only => [:show, :collated_refs, :no_conf, :no_ref]
-    append_before_filter :setup
-    append_before_filter :set_title
-
-    layout 'fe/application'
-
-    # dashboard
-    def index
-      redirect_to :action => :show_default
-    end
-
-    def show_default
-      @application = get_application
-      setup_view
-
-      render :template => 'fe/answer_sheets/edit'
-    end
-
-    # create app
-    def create
-      @question_sheet = Fe::QuestionSheet.find(params[:question_sheet_id])
-      @application = @person.applications.build
-
-      @application.save!
-      @application.question_sheets << @question_sheet
-      redirect_to fe_application_path(@application)
-    end
-
-    # edit an apply
-    def edit
-      @application = Application.find(params[:id]) unless @application
-
-      if @application.applicant == current_user.person
-        setup_view
-
-        render :template => 'fe/answer_sheets/edit'
-      else 
-        no_access
-      end
-
-    end
-
-    def show
-      @application = Application.find(params[:id]) unless @application
-      @answer_sheets = @application.answer_sheets
-      @show_conf = true
-      @viewing = true
-
-      if @answer_sheets.empty?
-        render :action => :too_old
-        #raise "No applicant sheets in sleeve '#{@application.sleeve.title}'."
-        return
-      end
-      #render :layout => 'admin_application'
-    end
-
-    def no_ref
-      @application = Application.find(params[:id]) unless @application
-      @answer_sheets = [@application]
-      @show_conf = true
-
-      if @answer_sheets.empty?
-        render :action => :too_old
-        #raise "No applicant sheets in sleeve '#{@application.sleeve.title}'."
-        return
-      end
-
-      #render :layout => 'admin_application', :template => 'fe/applys/show'
-      render :template => 'fe/applys/show'
-    end
-
-    def no_conf
-      @application = Application.find(params[:id]) unless @application
-      @answer_sheets = [@application]
-      @show_conf = false
-
-      if @answer_sheets.empty?
-        render :action => :too_old
-        #raise "No applicant sheets in sleeve '#{@application.sleeve.title}'."
-        return
-      end
-
-      #render :layout => 'admin_application', :template => 'fe/applys/show'
-      render :template => 'fe/applys/show'
-    end
-
-    def collated_refs
-      @application = Application.find(params[:id]) unless @application
-      @answer_sheets = @application.references
-
-      if @answer_sheets.empty?
-        render :action => :too_old
-        #raise "No applicant sheets in sleeve '#{@application.sleeve.title}'."
-        return
-      end
-
-      @reference_question_sheet = Fe::QuestionSheet.find(2) #TODO: constant
-
-      setup_reference("staff")
-      setup_reference("discipler")
-      setup_reference("roommate")
-      setup_reference("friend")
-
-      @show_conf = true
-    end
-
-    def setup_reference(type)
-      ref = nil
-      eval("ref = @" + type + "_reference = @application." + type + "_reference")
-      raise type unless ref
-      answer_sheet = ref
-      question_sheet = answer_sheet.question_sheet
-      if question_sheet
-        elements = []
-        question_sheet.pages.order(:number).each do |page|
-          elements << page.elements.where("#{Fe::Element.table_name}.kind not in (?)", %w(Fe::Paragraph)).to_a
-        end
-        elements = elements.flatten
-        elements.reject! {|e| e.is_confidential} if @show_conf == false
-        eval("@" + type + "_elements = Fe::QuestionSet.new(elements, answer_sheet).elements")
-      else
-        eval("@" + type + "_elements = []")
-      end
-
-    end
-
-    def no_access
-      redirect_to '/'
-    end
-
-    protected
-    def setup
-      @person = get_person    # current visitor_id
-    end
-
-    def get_year
-      Application::YEAR  
-    end
-
-    def get_person
-      @person ||= current_person
-      return nil unless @person
-      @person.current_address = ::Fe::Address.new(:address_type =>'current') unless @person.current_address
-      @person.emergency_address1 = ::Fe::Address.new(:address_type =>'emergency1') unless @person.emergency_address1
-      @person.permanent_address = ::Fe::Address.new(:address_type =>'permanent') unless @person.permanent_address
-      return @person
-    end
-
-    def get_application
-      unless @application
-        @person ||= get_person
-        # if this is the user's first visit, we will need to create an apply
-        if @person.application.nil?
-          create_application
-          @application.save!
-          @person.application = @app
-        else
-          @application ||= @person.application
-        end
-      end
-      @application
-    end
-
-    def create_application
-      @application = Fe::Application.create :applicant_id => @person.id
-    end
-
-    def setup_view
-      @answer_sheet = @application
-      # edit the first page
-      @presenter = Fe::AnswerPagesPresenter.new(self, @answer_sheet)
-      @elements = @presenter.questions_for_page(:first).elements
-      @page = @presenter.pages.first
-      @presenter.active_page ||= @page
-    end
-
-    def set_title
-      @title = "Form Engine"
-    end
-  end
-end

data/app/controllers/fe/payments_controller.rb

@@ -1,184 +0,0 @@
-# gather payment information from Applicant
-module Fe
-  class PaymentsController < ApplicationController
-    prepend_before_filter :ssm_login_required, :except => [:edit, :update]
-    prepend_before_filter :cas_filter, :authentication_filter, :only => [:edit, :update]
-    before_filter :setup, :except => [:edit, :update, :approve]
-
-    # Allow applicant to edit payment
-    # /applications/1/payment_page/edit
-    # js: provide a partial to replace the answer_sheets page area
-    def edit
-      @payment = Fe::Payment.find(params[:id])
-      @application = @payment.answer_sheet
-      # if this isn't a staff payment they shouldn't be here for this staff person
-      unless 'Staff' == @payment.payment_type && current_person.isStaff?
-        render('no_access') and return
-      end
-      @payment.status = "Approved" # set the status so a default radio button will be selected
-    end
-
-    def create
-      Fe::Payment.transaction do
-        @payment = @application.payments.new(payment_params)
-        if @application.payments.non_denied.length > 0
-          @payment.errors.add(:base, "You have already submitted a payment for this application.")
-          render :action => "error"
-        else
-          @payment.amount = Fe.cost
-          @payment.status = 'Pending'
-          if @payment.valid?
-            case @payment.payment_type
-            when "Credit Card"
-              card_type = params[:payment][:card_type]
-
-              creditcard = ActiveMerchant::Billing::CreditCard.new(
-                :brand       => card_type,
-                :number     => @payment.card_number,
-                :month      => @payment.expiration_month,
-                :year       => @payment.expiration_year,
-                :verification_value => @payment.security_code,
-                :first_name => @payment.first_name,
-                :last_name  => @payment.last_name
-              )
-
-              if creditcard.valid?
-                response = GATEWAY.purchase(@payment.amount * 100, creditcard)
-
-                if response.success?
-                  @payment.approve!
-                  # TODO: Send notification email
-                else
-                  @payment.errors.add(:base, "Credit card transaction failed: #{response.message}")
-                  #Send email this way instead of raising error in order to still give an error message to user.
-                  # Fe::Notifier.notification('programmers@cojourners.com', # RECIPIENTS
-                  #                     "sp_error@uscm.org", # FROM
-                  #                     "Credit Card Error", # LIQUID TEMPLATE NAME
-                  #                     {'error' => "Credit card transaction failed: #{response.message} \n #{response.inspect} \n #{creditcard.inspect}"}).deliver
-                end
-              else
-                @payment.errors.add(:card_number, "is invalid.  Check the number and/or the expiration date.")
-              end
-            when "Mail"
-              @payment.approve!
-            when "Staff"
-              @payment.save
-              send_staff_payment_request(@payment)
-            end
-          end
-        end
-      end
-    end
-
-    def update
-      @payment = Fe::Payment.includes({:application => :applicant}).find(params[:id])
-      @application = @payment.answer_sheet
-      @person = @application.applicant
-      @payment.status = params[:payment][:status]
-      staff_approval
-      @payment.save!
-      staff_payment_processed_email(@payment)
-      @payment.answer_sheet.complete
-    end
-
-    def approve
-      @payment = Fe::Payment.find(params[:id])
-      @application = @payment.answer_sheet
-      @payment.auth_code = si_user.user.person.account_no
-      case @payment.payment_type
-      when 'Staff'
-        staff_approval
-        staff_payment_processed_email(@payment)
-      when 'Mail'
-        Fe::Notifier.notification(@application.email, # RECIPIENTS
-                                  Fe.from_email, # FROM
-                                  "Check Received", # LIQUID TEMPLATE NAME
-                                  {'name' => @application.applicant.informal_full_name}).deliver
-      end
-      @payment.approve!
-      @payment.application.complete
-    end
-
-    # TODO this be moved to a decorotor or cru_lib as per Josh's instructions not to have Staff code in FE
-    def staff_search
-      #@payment = @application.payments.new(params[:payment].slice(:payment_type, :payment_account_no, :auth_code))
-      @payment = @application.payments.new(staff_search_payment_params)
-      if @payment.staff_first.to_s.strip.empty? || @payment.staff_last.to_s.strip.empty?
-        render; return
-      end
-      @results = Staff.order('"lastName", "firstName"').where("(\"firstName\" like ? OR \"preferredName\" like ?) AND \"lastName\" like ? and \"removedFromPeopleSoft\" <> 'Y'", @payment.staff_first+'%', @payment.staff_first+'%', @payment.staff_last+'%')
-    end
-
-    def destroy
-      @payment = @application.payments.find(params[:id])
-      @payment.destroy
-    end
-
-    protected
-
-    def setup
-      if app_user && app_user.can_su_application?
-        @answer_sheet = @application = Fe.answer_sheet_class.constantize.find(params[:application_id])
-      else
-        @answer_sheet = @application = current_person.applications.find(params[:application_id])
-      end
-    end
-
-    def send_staff_payment_request(payment)
-      @person = @application.applicant
-      staff = Staff.find_by(accountNo: payment.payment_account_no)
-      raise "Invalid staff payment request: " + payment.inspect if staff.nil?
-      Fe::Notifier.notification(staff.email, # RECIPIENTS
-                                Fe.from_email, # FROM
-                                "Staff Payment Request", # LIQUID TEMPLATE NAME
-                                {'staff_full_name' => staff.informal_full_name, # HASH OF VALUES FOR REPLACEMENT IN LIQUID TEMPLATE
-                                  'applicant_full_name' => @person.informal_full_name,
-                                  'applicant_email' => @person.email,
-                                  'applicant_home_phone' => @person.current_address.home_phone,
-                                  'payment_request_url' => url_for(:action => :edit, :application_id => @application.id, :id => @payment.id)},
-                                  {:format => :html}).deliver
-    end
-
-    def staff_approval
-      @payment.auth_code = current_person.account_no
-      if @payment.status == "Other Account"
-        @payment.payment_account_no = params[:other_account]
-        @payment.approve!
-      end
-    end
-
-    def staff_payment_processed_email(payment)
-      # Send appropriate email
-      if payment.approved?
-        # Send receipt to applicant
-        Fe::Notifier.notification(@application.applicant.email, # RECIPIENTS
-                                  Fe.from_email, # FROM
-                                  "Applicant Staff Payment Receipt", # LIQUID TEMPLATE NAME
-                                  {'applicant_full_name' => @application.applicant.informal_full_name}).deliver
-        # Send notice to Tool Owner
-        Fe::Notifier.notification(Fe.from_email, # RECIPIENTS - HARD CODED!
-                                  Fe.from_email, # FROM
-                                  "Tool Owner Payment Confirmation", # LIQUID TEMPLATE NAME
-                                  {'payment_amount' => "$" + @payment.amount.to_s,
-                                    'payment_account_no' => @payment.payment_account_no,
-                                    'payment_auth_code' => @payment.auth_code,
-                                    'payment_id' => @payment.id}).deliver
-      else
-        # Sent notice to applicant that payment was declined
-        Fe::Notifier.notification(@application.email, # RECIPIENTS
-                                  Fe.from_email, # FROM
-                                  "Payment Refusal", # LIQUID TEMPLATE NAME
-                                  {'applicant_full_name' => @application.applicant.informal_full_name}).deliver
-      end
-    end
-
-    def payment_params
-      params.require(:payment).permit(:payment_type, :payment_account_no, :auth_code, :first_name, :last_name, :address,
-                                     :city, :state, :zip, :card_number, :card_type, :expiration_month, :expiration_year, :security_code)
-    end
-
-    def staff_search_payment_params
-      params.require(:payment).permit(:payment_type, :staff_first, :staff_last)
-    end
-  end
-end

data/app/models/fe/payment.rb

@@ -1,77 +0,0 @@
-module Fe
-  class Payment < ActiveRecord::Base
-    self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
-
-    attr_accessor :first_name, :last_name, :address, :city, :state, :zip, :card_number,
-                  :expiration_month, :expiration_year, :security_code, :staff_first, :staff_last, :card_type
-
-    belongs_to :application, class_name: Fe.answer_sheet_class
-
-    scope :non_denied, -> { where("(status <> 'Denied' AND status <> 'Errored') OR status is null") }
-
-    after_save :check_app_complete
-
-    validate :credit_card_validation
-    validate :staff_email_present_if_staff_payment
-
-    def answer_sheet() application; end
-
-    def credit_card_validation
-      if credit?
-        errors.add_on_empty([:first_name, :last_name, :address, :city, :state, :zip, :card_number,
-                             :expiration_month, :expiration_year, :security_code])
-        errors.add(:card_number, "is invalid.") if get_card_type.nil?
-      end
-    end
-
-    # TODO move all staff methods to decorators as per instructions from Josh
-    def staff_email_present_if_staff_payment
-      if staff? && !payment_account_no.include?('/') # Don't try to validate chart fields
-        staff = Staff.find_by(accountNo: payment_account_no)
-        unless staff
-          errors.add(:base, "We couldn't find a staff member with that account number")
-          return false
-        end
-
-        unless staff.email.present?
-          errors.add(:base, "The staff member you've picked doesn't have an address on file for us to send the request to.")
-        end
-      end
-    end
-
-    def to_s
-      "#{payment_type}: #{amount} on #{created_at}"
-    end
-
-    def check_app_complete
-      if self.approved?
-        self.answer_sheet.complete
-      end
-    end
-
-    def credit?
-      self.payment_type == 'Credit Card'
-    end
-
-    def staff?
-      self.payment_type == 'Staff'
-    end
-
-    def approved?
-      self.status == 'Approved'
-    end
-
-    def approve!
-      self.status = 'Approved'
-      self.auth_code ||= card_number[-4..-1] if card_number.present?
-      self.save!
-    end
-
-    def get_card_type
-      card =  ActiveMerchant::Billing::CreditCard.new(:number => card_number)
-      card.valid?
-      card.brand
-    end
-  end
-
-end