class ECpayInvoice::InvoiceVerifyBase

Public Instance Methods

get_all_pattern(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 125
def get_all_pattern(apiname)
    res = {}
    res['Type_idx'] = self.get_param_type(apiname)
    res['Int'] = self.get_int_param_pattern(apiname)
    res['String'] = self.get_str_param_pattern(apiname)
    res['Opt'] = self.get_opt_param_pattern(apiname)
    res['DepOpt'] = self.get_depopt_param_pattern(apiname)
    return res
end
get_basic_params(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 23
def get_basic_params(apiname)
    basic_param = []
    @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters/param[@require=\"1\"]").each do |elem|
        basic_param.push(elem.attributes['name'].value)
    end
    return basic_param
end
get_cond_param(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 31
def get_cond_param(apiname)
    aio_sw_param = []
    conditional_param = {}
    @@param_xml.xpath("/ecpayInvoice/#{apiname}/Config/switchparam/n").each do |elem|
        aio_sw_param.push(elem.text)
    end
    aio_sw_param.each do |pname|
        opt_param = {}
        node = @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param[@name=\"#{pname}\"]")
        node.xpath('./condparam').each do |elem|
            opt = elem.attributes['owner'].value
            params = []
            elem.xpath('./param[@require="1"]').each do |pa|
                params.push(pa.attributes['name'].value)
            end
            opt_param[opt] = params
        end
        conditional_param[pname] = opt_param
    end
    return conditional_param
end
get_depopt_param_pattern(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 104
def get_depopt_param_pattern(apiname)
    pattern = {}

    node = @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param[@type=\"DepOpt\"]")
    node.each do |param_elem|
        parent_n_opts = {}
        sub_opts = {}
        p_name = param_elem.attributes['name'].value
        parent_name = param_elem.attributes['main'].value
        param_elem.xpath('./mainoption').each do |elem|
            k = elem.attributes['name'].value
            opt = []
            elem.element_children.each{|c|opt.push(c.text)}
            sub_opts[k] = opt
        end
        parent_n_opts[parent_name] = sub_opts
        pattern[p_name] = parent_n_opts
    end
    return pattern
end
get_int_param_pattern(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 73
def get_int_param_pattern(apiname)
    pattern = {}
    node = @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param[@type=\"Int\"]")
    node.each do |param_elem|
        mode = param_elem.xpath('./mode').text
        mx = param_elem.xpath('./maximum').text
        mn = param_elem.xpath('./minimal').text
        a = []
        [mode, mx, mn].each{|f|a.push(f)}
        pattern[param_elem.attributes['name'].value] = a
    end
    return pattern
end
get_opt_param_pattern(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 61
def get_opt_param_pattern(apiname)
    pattern = {}
    node = @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param[@type=\"Opt\"]")
    node.each do |param_elem|
        opt_elems = param_elem.xpath('./option')
        opt = []
        opt_elems.each{|oe|opt.push(oe.text)}
        pattern[param_elem.attributes['name'].value] = opt
    end
    return pattern
end
get_param_type(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 53
def get_param_type(apiname)
    param_type = {}
    @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param").each do |elem|
        param_type[elem.attributes['name'].value] = elem.attributes['type'].value
    end
    return param_type
end
get_special_encode_param(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 16
def get_special_encode_param(apiname)
    ret = []
    node = @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param[@urlencode=\"1\"]")
    node.each {|elem| ret.push(elem.attributes['name'].value)}
    return ret
end
get_str_param_pattern(apiname) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 87
def get_str_param_pattern(apiname)
    pattern = {}
    node = @@param_xml.xpath("/ecpayInvoice/#{apiname}/Parameters//param[@type=\"String\"]")
    node.each do |param_elem|
        p_name = param_elem.attributes['name'].value
        pat_elems = param_elem.xpath('./pattern')
        # if pat_elems.length > 1
        #     raise "Only 1 pattern tag is allowed for each parameter (#{p_name}) "
        # elsif pat_elems.length = 0
        #     raise "No pattern tag found for parameter (#{p_name}) "
        # end
        pat = pat_elems.text
        pattern[p_name] = pat
    end
    return pattern
end
get_svc_url(apiname, mode) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 11
def get_svc_url(apiname, mode)
    url = @@param_xml.xpath("/ecpayInvoice/#{apiname}/ServiceAddress/url[@type=\"#{mode}\"]").text
    return url
end
verify_param_by_pattern(params, pattern) click to toggle source
# File lib/ecpay_invoice/verification.rb, line 135
def verify_param_by_pattern(params, pattern)
    type_index = pattern['Type_idx']
    params.keys.each do |p_name|
        p_type = type_index[p_name]
        patt_container = pattern[p_type]
        case
        when p_type == 'String'
            regex_patt = patt_container[p_name]
            mat = /#{regex_patt}/.match(params[p_name])
            if mat.nil?
                raise ECpayInvalidParam, "Wrong format of param #{p_name} or length exceeded."
            end
        when p_type == 'Opt'
            aval_opt = patt_container[p_name]
            mat = aval_opt.include?(params[p_name])
            if mat == false
                raise ECpayInvalidParam, "Unexpected option of param #{p_name} (#{params[p_name]}). Avaliable option: (#{aval_opt})."
            end
        when p_type == 'Int'
            criteria = patt_container[p_name]
            mode = criteria[0]
            max = criteria[1].to_i
            min = criteria[2].to_i
            val = params[p_name].to_i
            case
            when mode == 'BETWEEN'
                if val < min or val > max
                    raise ECpayInvalidParam, "Value of #{p_name} should be between #{min} and #{max} ."
                end
            when mode == 'GE'
                if val < min
                    raise ECpayInvalidParam, "Value of #{p_name} should be greater than or equal to #{min}."
                end
            when mode == 'LE'
                if val > max
                    raise ECpayInvalidParam, "Value of #{p_name} should be less than or equal to #{max}."
                end
            when mode == 'EXCLUDE'
                if val >= min and val <= max
                    raise ECpayInvalidParam, "Value of #{p_name} can NOT be between #{min} and #{max} .."
                end
            else
                raise "Unexpected integer verification mode for parameter #{p_name}: #{mode}. "
            end
        when p_type == 'DepOpt'
            dep_opt = patt_container[p_name]
            parent_param = dep_opt.keys()[0]
            all_dep_opt = dep_opt[parent_param]
            parent_val = params[parent_param]
            aval_opt = all_dep_opt[parent_val]
            if aval_opt.nil? and pattern['Opt'][parent_param].include?(parent_val) == false
                raise  ECpayInvalidParam, "Cannot find avaliable option of [#{p_name}] by related param [#{parent_param}](Value: #{parent_val})."
            elsif aval_opt.is_a?(Array)
                unless aval_opt.include?(params[p_name])
                    raise ECpayInvalidParam, "Unexpected option of param #{p_name} (#{params[p_name]}). Avaliable option: (#{aval_opt})."
                end
            end

        else
            raise "Unexpected type (#{p_type}) for parameter #{p_name}. "

        end
    end
end