Class: UmfService

Inherits:
Object
  • Object
show all
Defined in:
lib/UmfService.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(merId, privateKeyPath) ⇒ UmfService

构造方法



23
24
25
26
27
28
29
30
31
32
 
# File 'lib/UmfService.rb', line 23

def initialize merId,privateKeyPath
  if merId==nil || merId==''
    return
  end
  if privateKeyPath==nil || privateKeyPath==''
    return
  end
  $merId = $merId.merge({merId=>merId})
  $privateKeyPath = $privateKeyPath.merge(merId=>privateKeyPath)
end

Class Method Details

.addMerPrivateCertMap(merId, privateKeyPath) ⇒ Object

添加私钥



498
499
500
501
 
# File 'lib/UmfService.rb', line 498

def UmfService.addMerPrivateCertMap(merId,privateKeyPath)
  $merId = $merId.merge({merId=>merId})
  $privateKeyPath = $privateKeyPath.merge(merId=>privateKeyPath)
end

Instance Method Details

#activeNewScanPaymentMap(params) ⇒ Object

收款 : 扫码支付 主扫支付



121
122
123
124
125
126
127
 
# File 'lib/UmfService.rb', line 121

def activeNewScanPaymentMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "active_scancode_order_new"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#activeScanPaymentMap(params) ⇒ Object

收款 : 扫码支付 主扫支付



112
113
114
115
116
117
118
 
# File 'lib/UmfService.rb', line 112

def activeScanPaymentMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "active_scancode_order"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#addChildMerInfoMap(params) ⇒ Object

子商户入网–添加子商户方法



533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
 
# File 'lib/UmfService.rb', line 533

def addChildMerInfoMap(params)
  UmfLogger.logInfoMsg("--------------------log start---------------------")
  UmfLogger.logInfoMsg("[UMF SDK 子商户入网]本次请求原始参数 " + params.to_s)
  param = {
      "merId"=>params["merId"],
      "merName"=>UmfRSACryptUtil.new.encrypt(params["merName"]),
      "merType"=>params["merType"],
      "contActsName"=>UmfRSACryptUtil.new.encrypt(params["contActsName"]),
      "mobileNo"=>params["mobileNo"],
      "licenseType"=>params["licenseType"],
      "licenseNo"=>params["licenseNo"],
      "organizationId"=>params["organizationId"],
      "taxPayerNum"=>params["taxPayerNum"],
      "lawyer"=>UmfRSACryptUtil.new.encrypt(params["lawyer"]),
      "cardNo"=>UmfRSACryptUtil.new.encrypt(params["cardNo"]),
      "bankName"=>UmfRSACryptUtil.new.encrypt(params["bankName"]),
      "bankAccount"=>UmfRSACryptUtil.new.encrypt(params["bankAccount"]),
      "province"=>params["province"],
      "areaCode"=>params["areaCode"],
      "merNotifyUrl"=>params["merNotifyUrl"],
      "pubPriFlag"=>params["pubPriFlag"],
      "bankBrhName"=>UmfRSACryptUtil.new.encrypt(params["bankBrhName"]),
  }
  UmfLogger.logInfoMsg("[UMF SDK 子商户入网]本次请求处理后参数 " + param.to_s)
  jsonStr = param.to_json
  signature = UmfRSACryptUtil.new.sign(jsonStr,params["merId"],'sha256')
  headers = {
      "Content-type" => "application/json;charset=utf-8",
      "Signature" => signature,
      "Authorization" => "Bearer"+ getTokenMap
  }
  respObj = UmfHttp.new.httpRequestWithJson(UMF_RESTPAY_ADDCHILDMERINFO,true,jsonStr,headers)
  return respObj
end

#cancelTradeMap(params) ⇒ Object

撤销—撤销方法



236
237
238
239
240
241
242
 
# File 'lib/UmfService.rb', line 236

def cancelTradeMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "mer_cancel"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#changeChildMerInfoMap(params) ⇒ Object

子商户入网–修改子商户信息方法



604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
 
# File 'lib/UmfService.rb', line 604

def changeChildMerInfoMap(params)
  UmfLogger.logInfoMsg("--------------------log start---------------------")
  UmfLogger.logInfoMsg("[UMF SDK 子商户入网]本次请求原始参数 " + params.to_s)
  param = {
      "merId"=>params["merId"],
      "merName"=>UmfRSACryptUtil.new.encrypt(params["merName"]),
      "merType"=>params["merType"],
      "contActsName"=>UmfRSACryptUtil.new.encrypt(params["contActsName"]),
      "mobileNo"=>params["mobileNo"],
      "licenseType"=>params["licenseType"],
      "licenseNo"=>params["licenseNo"],
      "organizationId"=>params["organizationId"],
      "taxPayerNum"=>params["taxPayerNum"],
      "lawyer"=>UmfRSACryptUtil.new.encrypt(params["lawyer"]),
      "cardNo"=>UmfRSACryptUtil.new.encrypt(params["cardNo"]),
      "bankName"=>UmfRSACryptUtil.new.encrypt(params["bankName"]),
      "bankAccount"=>UmfRSACryptUtil.new.encrypt(params["bankAccount"]),
      "province"=>params["province"],
      "areaCode"=>params["areaCode"],
      "merNotifyUrl"=>params["merNotifyUrl"],
      "pubPriFlag"=>params["pubPriFlag"],
      "bankBrhName"=>UmfRSACryptUtil.new.encrypt(params["bankBrhName"]),
  }
  UmfLogger.logInfoMsg("[UMF SDK 子商户入网]本次请求处理后参数 " + param.to_s)
  jsonStr = param.to_s
  signature = UmfRSACryptUtil.new.sign(jsonStr,params["merId"],'sha256')
  headers = {
      "Content-type" => "application/json;charset=utf-8",
      "Signature" => signature,
      "Authorization" => "Bearer" + getTokenMap
  }
  respObj = UmfHttp.new.httpRequestWithJson(UMF_RESTPAY_CHANGECHILDREBUT,true,jsonStr,headers)
  return respObj
end

#creditCardAuthenticationMap(params) ⇒ Object

鉴权—借记卡实名认证



348
349
350
351
352
353
354
355
 
# File 'lib/UmfService.rb', line 348

def creditCardAuthenticationMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "comm_auth"}
  param = param.merge service
  param["version"] = "1.0"
  return plainSortByAndPost(param)
end

#creditDirectMap(params) ⇒ Object

收款—信用卡直连



102
103
104
105
106
107
108
 
# File 'lib/UmfService.rb', line 102

def creditDirectMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "credit_direct_pay" , "pay_type" => "CREDITCARD"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#debitCardAuthenticationMap(params) ⇒ Object

鉴权—借记卡实名认证



336
337
338
339
340
341
342
343
 
# File 'lib/UmfService.rb', line 336

def debitCardAuthenticationMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "comm_auth"}
  param = param.merge service
  param["version"] = "1.0"
  return plainSortByAndPost(param)
end

#debitDirectMap(params) ⇒ Object

收款 : 借记卡直连



92
93
94
95
96
97
98
 
# File 'lib/UmfService.rb', line 92

def debitDirectMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service"=>"debit_direct_pay" , "pay_type"=>"DEBITCARD"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#epaymentOrderMap(params) ⇒ Object

E秒付



316
317
318
319
320
321
322
 
# File 'lib/UmfService.rb', line 316

def epaymentOrderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "epay_direct_req"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#generalRefundMap(params) ⇒ Object

退款—普通退款方法



246
247
248
249
250
251
252
 
# File 'lib/UmfService.rb', line 246

def generalRefundMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "mer_refund"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#generateSign(params) ⇒ Object

传入请求参数,成sign字段



481
482
483
484
485
 
# File 'lib/UmfService.rb', line 481

def generateSign(params)
  plain = UmfStringUtil.new.getPlainSortByAndWithoutSignType(params)
  sign = UmfRSACryptUtil.new.sign(plain,params['mer_id'],'sha1')
  return sign
end

#getTokenMap ⇒ Object

子商户入网部分

子商户入网–获取token方法



509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/UmfService.rb', line 509

def getTokenMap
  # token在有效期内
  if $spayRestPayAccessTokenTime+$spayRestPayExpiresIn >= Time.new.to_i
    return $spayRestPayAccessToken
  end

  params = {
      "grant_type"=>"client_credentials",
      "client_id"=>UmfConfig.umf_mer_client_id ,
      "client_secret"=>UmfConfig.umf_mer_client_secret
  }
  UmfLogger.logInfoMsg("--------------------log start---------------------")
  UmfLogger.logInfoMsg("[UMF SDK 子商户入网]本次请求原始参数 " + params.to_s)
  jsonStr = params.to_json
  headers = {'Content-Type' => 'application/json'}
  respObj = UmfHttp.new.httpRequestWithJson(UMF_RESTPAY_AUTHORIZE,true,jsonStr,headers)
  $spayRestPayAccessToken = respObj['access_token']
  $spayRestPayAccessTokenTime = Time.new.to_i # 1970年到指定日期的秒数 当前的秒数
  $spayRestPayExpiresIn = respObj['expires_in'].to_i # 字符串转整数
  return respObj['access_token']
end

#H5AutoConnectMap(params) ⇒ Object

H5直连-范围URL地址



131
132
133
134
135
136
137
138
139
140
 
# File 'lib/UmfService.rb', line 131

def H5AutoConnectMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service"=>"active_scancode_order_new" , "auto_pay" => "TRUE"}
  param = param.merge service
  reqDataGet = UmfMerToPlat.new.makeRequestDataByGet(param)
  get_url = reqDataGet.getUrl
  UmfLogger.logInfoMsg("[UMF SDK] 公众号支付 请求 service = active_scancode_order_new 生成的getUrl = " + get_url)
  return get_url
end

#H5ConnectMap(params) ⇒ Object

H5直连-返回请求参数



144
145
146
147
148
149
150
 
# File 'lib/UmfService.rb', line 144

def H5ConnectMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "active_scancode_order_new"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#H5FrontPageMap(params) ⇒ Object

H5收银台H5收银台—生成get后的请求参数，商户只需要拼接URL进行get请求即可



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/UmfService.rb', line 51

def H5FrontPageMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "pay_req_h5_frontpage"}
  param = param.merge service
  reqDataGet = UmfMerToPlat.new.makeRequestDataByGet(param)
  get_url = reqDataGet.getUrl
  UmfLogger.logInfoMsg("[UMF SDK] H5收银台 请求 service = pay_req_h5_frontpage 生成的getUrl = " + get_url)
  return get_url
end

#identityAuthenticationMap(params) ⇒ Object

鉴权—身份认证



359
360
361
362
363
364
365
366
 
# File 'lib/UmfService.rb', line 359

def identityAuthenticationMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "comm_auth"}
  param = param.merge service
  param["version"] = "1.0"
  return plainSortByAndPost(param)
end

#massTransferRefundMap(params) ⇒ Object

退款—批量转账退费请求



256
257
258
259
260
261
262
 
# File 'lib/UmfService.rb', line 256

def massTransferRefundMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "split_refund_req"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#mobileGenerateSignMap(params) ⇒ Object

APP支付—生成签名



452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
 
# File 'lib/UmfService.rb', line 452

def mobileGenerateSignMap(params)
  if params['merId']==nil || params['merId']==''
    puts '[UMF SDK]签名参数商户号为空,请传入商户号'
    return
  end
  if params['orderId']==nil || params['orderId']==''
    puts '[UMF SDK]签名参数订单号为空,请传入订单号'
    return
  end
  if params['orderDate']==nil ||params['orderDate']==''
    puts '[UMF SDK]签名参数订单日期为空,请传入订单日期'
    return
  end
  if params['amount']==nil || params['amount']==''
    puts '[UMF SDK]签名参数订单金额为空,请传入订单金额'
    return
  end
  # TODO 正则校验
  merId = params['merId']
  orderId = params['orderId']
  orderDate = params['orderDate']
  amount = params['amount']
  plain = merId + orderId + amount + orderDate
  sign = UmfRSACryptUtil.new.mobileGenerateSign(plain,merId,'sha1')
  return sign
end

#mobileOrderMap(params) ⇒ Object

APP支付下单



442
443
444
445
446
447
448
 
# File 'lib/UmfService.rb', line 442

def mobileOrderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "pay_req"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#notifyChildParserMap(notifyChildParamsStr) ⇒ Object

子商户入网异步通知—联动通知商户数据，SDK解析结果



658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
 
# File 'lib/UmfService.rb', line 658

def notifyChildParserMap(notifyChildParamsStr)
  if notifyChildParamsStr.length<0
    return
  end
  notifyParamsArr = notifyChildParamsStr.split('&')
  map = {}
  notifyParamsArr.each { |elem|
    arr = elem.split('=',2)
    map[arr[0]] = arr[1]
  }
  sign = map['sign']
  map.delete('sign')
  plain = UmfStringUtil.new.getPlainSortByAndWithoutSignType(map)

  verifyRet = UmfRSACryptUtil.new.verify(plain,sign,'sha1')
  if verifyRet == true
    puts '[UMF SDK 子商户入网] 平台通知数据验签成功'
    return map
  else
    puts '[UMF SDK 子商户入网] 平台通知数据验签失败'
    exit
  end
end

#notifyDataParserMap(notifyParamsStr) ⇒ Object

异步通知



391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/UmfService.rb', line 391

def notifyDataParserMap(notifyParamsStr)
  if notifyParamsStr.length<0
    return
  end
  # 联动发送异步通知URL地址后的参数
  notifyParamsArr = notifyParamsStr.split('&')
  map = {}
  sign = ''
  notifyParamsArr.each { |elem|
    arr = elem.split('=',2)
    if arr[0]=='sign'
      sign = CGI.unescape(arr[1])
      next
    elsif arr[0]=='sign_type'
      next
    else
      map[arr[0]] = CGI.unescape(arr[1])
    end
  }
  plain = UmfStringUtil.new.getPlainSortByAndWithoutSignType(map)
  verifyRet = UmfRSACryptUtil.new.verify(plain,sign,'sha1')
  if verifyRet
    puts '[UMF SDK] 平台通知数据验签成功'
    map.delete('version')
    return map
  else
    puts '[UMF SDK] 平台通知数据验签失败'
  end
end

#passiveScanPaymentMap(params) ⇒ Object

被扫支付



154
155
156
157
158
159
160
 
# File 'lib/UmfService.rb', line 154

def passiveScanPaymentMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "passive_scancode_pay"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#paymentOrderMap(params) ⇒ Object

付款—下单



286
287
288
289
290
291
292
 
# File 'lib/UmfService.rb', line 286

def paymentOrderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "transfer_direct_req"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#pBankDirectMap(params) ⇒ Object

收款 : 网银直连网银直连SDK提供请求的最终URL生成，商户可以直接加载URL调起对应的支付方式



79
80
81
82
83
84
85
86
87
88
 
# File 'lib/UmfService.rb', line 79

def pBankDirectMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "pay_req_split_direct"}
  param = param.merge service
  reqDataGet = UmfMerToPlat.new.makeRequestDataByGet(param)
  get_url = reqDataGet.getUrl
  UmfLogger.logInfoMsg("[UMF SDK] 网银直连 请求 service = pay_req_split_direct 生成的getUrl = " + get_url)
  return get_url
end

#PublicPaymentMap(params) ⇒ Object

公众号支付公众号支付–生成get后的请求参数，商户只需要拼接URL进行get请求即可



65
66
67
68
69
70
71
72
73
74
 
# File 'lib/UmfService.rb', line 65

def PublicPaymentMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "publicnumber_and_verticalcode"}
  param = param.merge service
  reqDataGet = UmfMerToPlat.new.makeRequestDataByGet(param)
  get_url = reqDataGet.getUrl
  UmfLogger.logInfoMsg("[UMF SDK] 公众号支付 请求 service = publicnumber_and_verticalcode 生成的getUrl = " + get_url)
  return get_url
end

#publicVerticalMap(params) ⇒ Object

立码付API



326
327
328
329
330
331
332
 
# File 'lib/UmfService.rb', line 326

def publicVerticalMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "verticalcode_order"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#queryAccountBalanceMap(params) ⇒ Object

付款—余额查询



306
307
308
309
310
311
312
 
# File 'lib/UmfService.rb', line 306

def queryAccountBalanceMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "query_account_balance"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#queryhistoryOrderMap(params) ⇒ Object

订单查询—查询历史订单方法



215
216
217
218
219
220
221
 
# File 'lib/UmfService.rb', line 215

def queryhistoryOrderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "mer_order_info_query"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#queryMerStateMap(params) ⇒ Object

子商户入网–查询审核状态方法



641
642
643
644
645
646
647
648
649
650
651
652
653
 
# File 'lib/UmfService.rb', line 641

def queryMerStateMap(params)
  UmfLogger.logInfoMsg("--------------------log start---------------------")
  UmfLogger.logInfoMsg("[UMF SDK 子商户入网]本次请求原始参数 " + params.to_s)
  merId = params["merId"]
  licenseNo = params["licenseNo"]
  url = UMF_RESTPAY_SELECTCHILDMERSTATE + "?merId=" + merId + "&licenseNo=" + licenseNo
  headers = {
      "Content-type" => "application/json;charset=utf-8",
      "Authorization" => "Bearer" + getTokenMap
  }
  respObj = UmfHttp.new.httpRequestWithJson(url,false,"",headers)
  return respObj
end

#queryPaymentStatusMap(params) ⇒ Object

付款—付款状态查询



296
297
298
299
300
301
302
 
# File 'lib/UmfService.rb', line 296

def queryPaymentStatusMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "transfer_query"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#queryRefundStateMap(params) ⇒ Object

退款—退款状态查询方法



266
267
268
269
270
271
272
 
# File 'lib/UmfService.rb', line 266

def queryRefundStateMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "mer_refund_query"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#querytodayOrderMap(params) ⇒ Object

订单查询—查询当天订单状态



226
227
228
229
230
231
232
 
# File 'lib/UmfService.rb', line 226

def querytodayOrderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "query_order"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#quickCancelSurrenderMap(params) ⇒ Object

收款—快捷支付解约



204
205
206
207
208
209
210
 
# File 'lib/UmfService.rb', line 204

def quickCancelSurrenderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "unbind_mercust_protocol_shortcut"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#quickGetMessageMap(params) ⇒ Object

收款—快捷支付向平台获取短信验证码方法



174
175
176
177
178
179
180
 
# File 'lib/UmfService.rb', line 174

def quickGetMessageMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "sms_req_shortcut"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#quickPayConfirmMap(params) ⇒ Object

收款—快捷支付确认支付



184
185
186
187
188
189
190
 
# File 'lib/UmfService.rb', line 184

def quickPayConfirmMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "confirm_pay_shortcut"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#quickPayOrderMap(params) ⇒ Object

收款—快捷支付下单方法



164
165
166
167
168
169
170
 
# File 'lib/UmfService.rb', line 164

def quickPayOrderMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "apply_pay_shortcut"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#quickQuerybankSupportMap(params) ⇒ Object

收款—快捷支付获取银行卡列表



194
195
196
197
198
199
200
 
# File 'lib/UmfService.rb', line 194

def quickQuerybankSupportMap(params)
    pubParams = publicParams
    param = pubParams.merge params
    service = {"service" => "query_mer_bank_shortcut"}
    param = param.merge service
    return plainSortByAndPost(param)
end

#reconciliationDownloadMap(params) ⇒ Object

对账



370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/UmfService.rb', line 370

def reconciliationDownloadMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "download_settle_file"}
  param = param.merge service
  reqDataPost = UmfMerToPlat.new.makeRequestDataByPost(param)
  post_url = reqDataPost.getUrl
  mapfield = reqDataPost.getField
  output = UmfHttp.new.httpPost(post_url,mapfield)
  bool = writeSettle(params["mer_id"],params["settle_date"],params["settle_path"],output)
  if bool
    puts "[UMF SDK]对账文件写入本地成功"
    return true
  else
    puts "[UMF SDK]对账文件写入本地失败"
    return false
  end
end

#remedyRefundInformationMap(params) ⇒ Object

退款—退费信息补录方法



276
277
278
279
280
281
282
 
# File 'lib/UmfService.rb', line 276

def remedyRefundInformationMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "refund_info_replenish"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#responseChildNotifyMap(params) ⇒ Object

子商户入网异步通知—商户响应联动通知SDK生成字符串 该字符串拼装在HTML响应中的head中的meta标签CONTENT中



684
685
686
687
688
689
690
691
692
693
 
# File 'lib/UmfService.rb', line 684

def responseChildNotifyMap(params)
  merMap = {}
  merMap["merId"] = params["merId"]
  merMap["licenseNo"] = params["licenseNo"]
  merMap["ret_code"] = "0000"
  merPlain = UmfStringUtil.new.getPlainSortByAndWithoutSignType(merMap)
  merSign = UmfRSACryptUtil.new.sign(merPlain,params["merId"],"sha1")
  mer2UmfPlatStr = merPlain + "&sign=" + merSign
  return mer2UmfPlatStr
end

#responseUMFMap(params) ⇒ Object

异步通知-商户返回联动字符串拼接



423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/UmfService.rb', line 423

def responseUMFMap(params)
  merMap = {}
  merMap['mer_date'] = params['mer_date']
  merMap['mer_id'] = params['mer_id']
  merMap['order_id'] = params['order_id']
  merMap['ret_code'] = '0000'
  merMap['ret_msg'] = 'success'
  merMap['version'] = '4.0'
  merPlain = UmfStringUtil.new.getPlainSortByAndWithoutSignType(merMap)
  merSign = UmfRSACryptUtil.new.sign(merPlain,params['mer_id'],'sha1')
  mer2UmfPlatStr = 'mer_date=' + merMap['mer_date'] + '&' +
      'mer_id=' + merMap['mer_id'] + '&' +
      'order_id=' + merMap['order_id'] + '&' +
      'ret_code=0000&ret_msg=success&sign_type=RSA&version=4.0&sign=' + merSign
  return mer2UmfPlatStr
end

#splitFileDownloadMap(params) ⇒ Object

分账—分账文件下载



727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
 
# File 'lib/UmfService.rb', line 727

def splitFileDownloadMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "download_settle_file"}
  param = param.merge service
  reqDataPost = UmfMerToPlat.new.makeRequestDataByPost(param)
  post_url = reqDataPost.getUrl
  mapfield = reqDataPost.getField
  output = UmfHttp.new.httpPost(post_url,mapfield)
  bool = writeSettle(params["mer_id"],params["settle_date"],params["settle_path"],output)
  if bool
    puts "[UMF SDK]对账文件写入本地成功"
    return true
  else
    puts "[UMF SDK]对账文件写入本地失败"
    return false
  end
end

#splitRefundMap(params) ⇒ Object

分账—分账退费



717
718
719
720
721
722
723
 
# File 'lib/UmfService.rb', line 717

def splitRefundMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "mer_refund"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#splitReqMap(params) ⇒ Object

分账—分账请求针对标准分账的延时分账



697
698
699
700
701
702
703
 
# File 'lib/UmfService.rb', line 697

def splitReqMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "split_req"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#splitStateMap(params) ⇒ Object

分账—分账状态查询



707
708
709
710
711
712
713
 
# File 'lib/UmfService.rb', line 707

def splitStateMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "query_split_order"}
  param = param.merge service
  return plainSortByAndPost(param)
end

#uploadMerFileMap(params, files) ⇒ Object

子商户入网–上传商户资质方法



570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/UmfService.rb', line 570

def uploadMerFileMap(params,files)
  UmfLogger.logInfoMsg('--------------------log start---------------------')
  UmfLogger.logInfoMsg('[UMF SDK 子商户入网]本次请求原始参数 ' + params.to_s)
  UmfLogger.logInfoMsg('[UMF SDK 子商户入网]本次请求上传文件 ' + files.to_s)
  jsonStr = params.to_json
  signature = UmfRSACryptUtil.new.sign(jsonStr,params['merId'],'sha256')
  url = UMF_RESTPAY_UPLOADCHILDFILE + '?data=' + CGI.escape(jsonStr)
  body = ""
  boundary = '---------------------' + Time.new.strftime('%Y%m%d')
  files.each{ |elem|
    if !(File.exist?(elem))
      next
    end
    body = body + "\r\n--" + boundary
    data = File.binread(elem)
    v = elem.split('/').last
    body = body + "\r\n" + 'Content-Disposition: form-data; name="file"; filename="' + v + '"' + "\r\n"+
                           'Content-Type: application/octet-stream' + "\r\n" +
                           '' + "\r\n" +
                           data
  }
  body = body + "\r\n--" + boundary + "--\r\n"
  headers = {
      'Content-Type'=> 'multipart/form-data; boundary=' + boundary,
      'Signature' => signature,
      'Authorization' => 'Bearer' + getTokenMap
  }
  respObj = UmfHttp.new.httpRequestWithJson(url,true,body,headers)
  return respObj
end

#verifySign(plain, sign, algorithmType) ⇒ Object

验签方法

Parameters:

  • string —

    plain 联动返回明文字符串按序拼接(明文串去除sign_type字段和sign字段)

  • string —

    $sign 密文sign字段

Returns:

  • bool



492
493
494
 
# File 'lib/UmfService.rb', line 492

def verifySign(plain,sign,algorithmType)
  return UmfRSACryptUtil.new.verify(plain,sign,algorithmType)
end

#WebFrontPagePayMap(params) ⇒ Object

Web收银台Web收银台—生成get后的请求参数，商户只需要拼接URL进行get请求即可



37
38
39
40
41
42
43
44
45
46
 
# File 'lib/UmfService.rb', line 37

def WebFrontPagePayMap(params)
  pubParams = publicParams
  param = pubParams.merge params
  service = {"service" => "req_front_page_pay"}
  param = param.merge service
  reqDataGet = UmfMerToPlat.new.makeRequestDataByGet(param)
  get_url = reqDataGet.getUrl
  UmfLogger.logInfoMsg("[UMF SDK] Web收银台 请求 service = req_front_page_pay 生成的getUrl = " + get_url)
  return get_url
end

#writeSettle(mer_id, settle_date, settle_path, content) ⇒ Object

对账文件下载后 写入数据到本地



748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
 
# File 'lib/UmfService.rb', line 748

def writeSettle(mer_id,settle_date,settle_path,content)
  if mer_id=='' || settle_date=='' || settle_path=='' || content==''
    mer_id==nil || settle_date==nil || settle_path==nil || content==nil
    return false
  end
  lastChar = settle_path[-1,1]
  if lastChar == "/"
    filepath = settle_path + mer_id + "_" + settle_date + ".txt"
  else
    filepath = settle_path + "/" + mer_id + "_" + settle_date + ".txt"
  end
  settle_content = content.encode('utf-8','gbk')
  bool = File.open(filepath, "w+") { |file|
    file.write(settle_content)
  }
  if bool
    UmfLogger.logInfoMsg("[UMF SDK]对账文件写入成功,路径 " + filepath)
  else
    UmfLogger.logInfoMsg("[UMF SDK]对账文件写入失败,路径 "  + filepath)
  end
  UmfLogger.logInfoMsg("--------------------log end---------------------")
  return bool
end