Class: RazorRisk::Cassini::Applications::RouteVerbAdaptors::Trades::CollectionGet

Inherits:

RESTFramework::VerbHandler

• Object
• RESTFramework::VerbHandler
• RazorRisk::Cassini::Applications::RouteVerbAdaptors::Trades::CollectionGet

Includes:

Pantheios, Utilities::CollectionGetHelper, RazorRisk::Core::Diagnostics::Logger, Razor::Connectivity::EntityConnectors::Exceptions, Razor::Connectivity::Razor3::EntityConnectors, Razor::Connectivity::Search::Parsers

Defined in:

lib/razor_risk/cassini/applications/route_verb_adaptors/trades/collection_get.rb

Overview

########################################################################## classes

Constant Summary

HTTP_VERB =

:get

HTTP_ACCEPTS =

%w{ application/xml application/json text/xml }

QUERY_PARAMETERS =

%w{

    field-search

    filter-name

    page-base
    page-extent

    result-form

    sort-field
    sort-direction

    linked-to-portfolio
}

Instance Method Summary

• #handle(env, params, request, response) ⇒ Object

Instance Method Details

#handle(env, params, request, response) ⇒ Object

# File 'lib/razor_risk/cassini/applications/route_verb_adaptors/trades/collection_get.rb', line 77

def handle env, params, request, response

    trace ParamNames[ :env, :params, :request, :response ], env, params, request, response

    # params

    validate_exclusive_search_parameters params, 'filter-name', 'field-search', message_scope: 'invalid search specifier'

    field_srch          =   params['field-search'].to_s.strip
    field_srch          =   nil if field_srch.empty?
    filter_name         =   params['filter-name'].to_s.strip
    filter_name         =   nil if filter_name.empty?
    page_base           =   ::Xqsr3::Conversion::IntegerParser.to_integer(params['page-base'] || 0) { |x, arg| halt *[ 422, {}, "invalid page specifier: 'page-base'=#{arg}" ] }
    page_extent         =   ::Xqsr3::Conversion::IntegerParser.to_integer(params['page-extent'] || 1000) { |x, arg| halt *[ 422, {}, "invalid page specifier: 'page-extent'=#{arg}" ] }
    sort_field          =   params['sort-field'].to_s.strip
    sort_field          =   nil if sort_field.empty?
    sort_direction      =   params['sort-direction'].to_s.strip
    sort_direction      =   nil if sort_direction.empty?
    linked_to_portfolio =   params['linked-to-portfolio']
    linked_to_portfolio =   ::Xqsr3::Conversion::IntegerParser.to_integer(params['linked-to-portfolio']) { |x, arg| halt *[ 422, {}, "invalid Trade ID: 'linked-to-portfolio'=#{arg}" ] } unless linked_to_portfolio.nil?

    rf  =   case rf = (params['result-form'] || '').to_s
            when '', 'default'
                :body
            when 'children'
                :array
            else
                log(:warning) { "unrecognised result-form '#{rf}'" }
                :body
            end

    if page_base < 0 || page_extent < 1

        halt *[ 416, {}, "invalid page specifier: 'page-base'=#{page_base}; 'page-extent'=#{page_extent}" ]
    end

    unless sort_direction.nil? || sort_direction  =~ /ascending|descending/i

        halt *[ 422, {}, "sort-direction must be 'ascending' or 'descending'" ]
    end

    if field_srch
        begin
            cp = MultiValueConjunctionParser.new
            field_srch = cp.parse_conjunction_list field_srch
            unless field_srch.keys.all? { |k| k.is_a? ::String }
                halt 422, {'Content-Type' => 'text/plain'}, 'Field Search does not support key paths'
            end
        rescue MultiValueConjunctionParser::SyntaxError => x
            halt 422, {'Content-Type' => 'text/plain'}, x.message
        end
    end

    rq_opts     =   {

        :field_search => field_srch,
        :filter_name => filter_name,
        :page_base => page_base,
        :page_extent => page_extent,
        :sort_field => sort_field,
        :sort_direction => sort_direction,
        :linked_to_portfolio => linked_to_portfolio,
    }

    # get credentials

    cr  =   get_required_credentials

    # get requester

    rr  =   settings.razor_requester

    # get connector

    ec  =   TradesConnector.new(rr, credentials: cr, **rq_opts)

    # issue request

    begin

        qr  =   ec.get_trades indicate_result_by: :qualified_result, result_form: rf
    rescue EntityConnectorInternalStepException => x

        log :failure, "exception (#{x.class}): #{x}"

        headers =   {

            'Content-Type'  =>  'text/plain',
        }

        code    =   500
        msg     =   x.message

        halt(code, headers, msg)
    end

    log :debug1, "qr(#{qr.class})='#{qr}'"

    unless qr.succeeded?

        if false

            ;
        elsif :no_such_filter == qr.result

            log :debug1, "failed to retrieve trades: no such filter '#{filter_name}'"

            halt *[ 422, {}, "no such filter '#{filter_name}'" ]
        elsif r = qr.failure_qualifier.reasons.lookup?('RZ0011')

            log :debug1, 'failed to retrieve trades'

            halt *[ 404, {}, "#{r.message}: #{r.details}" ]
        else

            log :warning, 'failed to retrieve trades'

            halt *[ 500, {}, qr.failure_qualifier.reasons.join("\n") ]
        end
    end

    r   =   case rf
            when :array

                xml_doc     =   ::Nokogiri.XML('<body/>')
                root_node   =   xml_doc.children.first

                qr.result.each do |pf_element|

                    root_node.add_child pf_element.to_s
                end

                xml_doc.to_s
            else

                qr.result.to_s
            end

    # return result

    status 200

    if false
    elsif request.accept?('application/xml')

        log :debug1, 'application/xml'

        content_type 'application/xml'

        r
    elsif request.accept?('application/json')

        log :debug1, 'application/json'

        content_type 'application/json'

        #resp_hash   =   Hash.from_xml r
			resp_hash   =   XmlHasher.parse(r)
			
        resp_json   =   resp_hash

        JSON.generate resp_json
    elsif request.accept?('text/xml')

        log :debug1, 'text/xml'

        content_type 'text/xml'

        r
    else

        log :violation, "unexpected failure to match given 'Accept' header '#{request.accept}'"

        status 500
    end
end