586 lines
24 KiB
Swift
Executable File
586 lines
24 KiB
Swift
Executable File
//
|
|
// MandiriEmoneyApi.swift
|
|
// Emoney Info
|
|
//
|
|
// Created by Wira Irawan on 27/07/24.
|
|
//
|
|
|
|
import Foundation
|
|
import CoreNFC
|
|
|
|
public class MandiriEmoneyApi : UnifiedNfcApi {
|
|
var emoney : Emoney = Emoney()
|
|
var riwayatList: [RiwayatCard] = []
|
|
var cardType : Int?
|
|
var mapv1 : String = ""
|
|
var start = 0
|
|
var finish = 256
|
|
var finish2 = 10
|
|
private var historyRetryCount = 0
|
|
private let useMandiriSpecHistoryReader = true
|
|
private let mandiriSpecMaxPage = 4
|
|
private let mandiriSpecEmptyPageStopThreshold = 2
|
|
|
|
public override init() {}
|
|
|
|
private func logMandiri(_ message: String) {
|
|
_ = message
|
|
// print("[Mandiri] \(message)")
|
|
// debugLog("[Mandiri] \(message)")
|
|
}
|
|
|
|
private func logMandiriApdu(_ label: String, command: NFCISO7816APDU) {
|
|
logMandiri("APDU -> \(label) | \(command.toHexString())")
|
|
}
|
|
|
|
private func logMandiriResponse(_ label: String, response: ApduResponse) {
|
|
logMandiri(
|
|
String(
|
|
format: "APDU <- %@ | sw1=%02X sw2=%02X data=%@",
|
|
label,
|
|
response.sw1 ?? 0,
|
|
response.sw2 ?? 0,
|
|
response.getData().hexEncodedString()
|
|
)
|
|
)
|
|
}
|
|
|
|
public func getCardNumber(){
|
|
logMandiriApdu("MANDIRI_APDU01", command: EmoneyApduCommands.MANDIRI_APDU01)
|
|
apduRunner.exchangeApdu(apduCommand: EmoneyApduCommands.MANDIRI_APDU01, completionHandler: {response in
|
|
self.logMandiriResponse("MANDIRI_APDU01", response: response)
|
|
if (response.sw1 == 0x90 && response.sw2 == 0x00){
|
|
let raw = response.getData().hexEncodedString()
|
|
self.emoney.setCardLabel("Mandiri e-Money")
|
|
self.emoney.setCardNumber(raw.subString(from: 0, to: 16))
|
|
self.cardType = raw.subString(from: 36, to: 38).hex2decimal()
|
|
self.logMandiri("Card info raw=\(raw)")
|
|
self.logMandiri("Card parsed | number=\(self.emoney.getCardNumber()) | cardType=\(self.cardType ?? -1)")
|
|
self.getBalance()
|
|
} else {
|
|
self.logMandiri("Card info failed | status=\(response.sw1)-\(response.sw2)")
|
|
self.apduRunner.invalidateSession(msg: "readFailed".localizeString(string: self.langCode!))
|
|
}
|
|
})
|
|
}
|
|
|
|
private func getBalance(){
|
|
logMandiriApdu("MANDIRI_APDU02", command: EmoneyApduCommands.MANDIRI_APDU02)
|
|
apduRunner.exchangeApdu(apduCommand: EmoneyApduCommands.MANDIRI_APDU02, completionHandler: {response in
|
|
self.logMandiriResponse("MANDIRI_APDU02", response: response)
|
|
if (response.sw1 == 0x90 && response.sw2 == 0x00){
|
|
let raw = response.getData().hexEncodedString()
|
|
let balance = raw.subString(from: 0, to: 8)
|
|
self.emoney.setBalance(self.getRealBalance(reverseHexa: balance))
|
|
self.logMandiri("Balance raw=\(raw)")
|
|
self.logMandiri("Balance parsed=\(self.emoney.getBalance())")
|
|
self.resetHistoryState()
|
|
self.historyRetryCount = 0
|
|
self.startHistoryRead()
|
|
} else {
|
|
self.logMandiri("Balance read failed | status=\(response.sw1)-\(response.sw2)")
|
|
self.apduRunner.invalidateSession(msg: "readFailed".localizeString(string: self.langCode!))
|
|
}
|
|
})
|
|
}
|
|
|
|
private func startHistoryRead() {
|
|
resetHistoryState()
|
|
logMandiri("Start history read | retry=\(historyRetryCount) | cardType=\(cardType ?? -1) | useSpec=\(useMandiriSpecHistoryReader)")
|
|
if useMandiriSpecHistoryReader {
|
|
startMandiriSpecHistoryRead()
|
|
return
|
|
}
|
|
if (self.cardType == 131){
|
|
self.getLogStep01(index: self.start)
|
|
} else {
|
|
self.getLogStep02(index: self.start)
|
|
}
|
|
}
|
|
|
|
private func retryHistoryRead(reason: String, retryable: Bool = true) {
|
|
guard retryable else {
|
|
logMandiri("History read not retryable | reason=\(reason)")
|
|
finalizeHistoryResult()
|
|
return
|
|
}
|
|
if historyRetryCount < 1 {
|
|
historyRetryCount += 1
|
|
logMandiri("Retrying history read | reason=\(reason) | retry=\(historyRetryCount)")
|
|
startHistoryRead()
|
|
} else {
|
|
logMandiri("Retry exhausted | reason=\(reason)")
|
|
finalizeHistoryResult()
|
|
}
|
|
}
|
|
|
|
private func finalizeHistoryResult() {
|
|
self.start = 0
|
|
self.finalizeHistory()
|
|
self.emoney.setRiwayatList(self.riwayatList)
|
|
self.emoney.setTampilRiwayat(!self.riwayatList.isEmpty)
|
|
self.logMandiri("Finalize history | count=\(self.riwayatList.count)")
|
|
self.updateScreen()
|
|
self.apduRunner.sessionEx?.alertMessage = "readFinish".localizeString(string: self.langCode!)
|
|
self.apduRunner.invalidateSession()
|
|
}
|
|
|
|
// MARK: - New Mandiri Spec Reader
|
|
// Toggle `useMandiriSpecHistoryReader` to rollback to the legacy implementation.
|
|
|
|
private func startMandiriSpecHistoryRead() {
|
|
logMandiri("Start spec history read | pages=1...\(mandiriSpecMaxPage)")
|
|
readMandiriSpecPage(page: 1, collectedChunks: [], emptyPageStreak: 0)
|
|
}
|
|
|
|
private func readMandiriSpecPage(page: Int, collectedChunks: [String], emptyPageStreak: Int) {
|
|
guard page <= mandiriSpecMaxPage else {
|
|
probeMandiriSpecStop(collectedChunks: collectedChunks)
|
|
return
|
|
}
|
|
|
|
let command = NFCISO7816APDU(
|
|
instructionClass: 0x00,
|
|
instructionCode: 0xD1,
|
|
p1Parameter: UInt8(page & 0xFF),
|
|
p2Parameter: 0x00,
|
|
data: Data(),
|
|
expectedResponseLength: CommonConstants.LE_GET_ALL_RESPONSE_DATA
|
|
)
|
|
logMandiriApdu("MANDIRI_SPEC_PAGE[\(page)]", command: command)
|
|
apduRunner.exchangeApdu(apduCommand: command, completionHandler: { response in
|
|
self.logMandiriResponse("MANDIRI_SPEC_PAGE[\(page)]", response: response)
|
|
if response.sw1 == 0x90 && response.sw2 == 0x00 {
|
|
let chunk = response.getData().hexEncodedString()
|
|
let isEmptyPage = self.isMandiriSpecPageEmpty(chunk)
|
|
self.logMandiri("Spec page chunk | page=\(page) | rawLength=\(chunk.count) | empty=\(isEmptyPage)")
|
|
var nextChunks = collectedChunks
|
|
nextChunks.append(chunk)
|
|
let nextEmptyPageStreak = isEmptyPage ? (emptyPageStreak + 1) : 0
|
|
if nextEmptyPageStreak >= self.mandiriSpecEmptyPageStopThreshold {
|
|
self.logMandiri("Spec page empty streak reached threshold | streak=\(nextEmptyPageStreak) | stopAfterPage=\(page)")
|
|
self.probeMandiriSpecStop(collectedChunks: nextChunks)
|
|
return
|
|
}
|
|
self.readMandiriSpecPage(page: page + 1, collectedChunks: nextChunks, emptyPageStreak: nextEmptyPageStreak)
|
|
} else {
|
|
self.logMandiri("Spec page read failed | page=\(page) | status=\(response.sw1)-\(response.sw2)")
|
|
self.retryHistoryRead(reason: "spec page status \(response.sw1)-\(response.sw2) at page \(page)")
|
|
}
|
|
})
|
|
}
|
|
|
|
private func probeMandiriSpecStop(collectedChunks: [String]) {
|
|
let probePage = mandiriSpecMaxPage + 1
|
|
let command = NFCISO7816APDU(
|
|
instructionClass: 0x00,
|
|
instructionCode: 0xD1,
|
|
p1Parameter: UInt8(probePage & 0xFF),
|
|
p2Parameter: 0x00,
|
|
data: Data(),
|
|
expectedResponseLength: CommonConstants.LE_GET_ALL_RESPONSE_DATA
|
|
)
|
|
logMandiriApdu("MANDIRI_SPEC_PROBE[\(probePage)]", command: command)
|
|
apduRunner.exchangeApdu(apduCommand: command, completionHandler: { response in
|
|
self.logMandiriResponse("MANDIRI_SPEC_PROBE[\(probePage)]", response: response)
|
|
if response.sw1 == 0x69 && response.sw2 == 0x86 {
|
|
self.logMandiri("Spec probe stop confirmed | page=\(probePage)")
|
|
} else {
|
|
self.logMandiri("Spec probe unexpected status | page=\(probePage) | status=\(response.sw1)-\(response.sw2)")
|
|
}
|
|
|
|
self.mapv1 = collectedChunks.joined()
|
|
if self.parseMandiriSpecLog() {
|
|
self.finalizeHistoryResult()
|
|
} else {
|
|
self.retryHistoryRead(reason: "invalid spec history payload", retryable: false)
|
|
}
|
|
})
|
|
}
|
|
|
|
private func parseMandiriSpecLog() -> Bool {
|
|
let logs = self.mapv1.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let recordHexLength = 48
|
|
logMandiri("Parse spec log | rawLength=\(logs.count)")
|
|
|
|
guard logs.count >= recordHexLength, logs.count % recordHexLength == 0 else {
|
|
logMandiri("Parse spec log invalid length | actual=\(logs.count) | recordHexLength=\(recordHexLength)")
|
|
return false
|
|
}
|
|
|
|
let total = logs.count / recordHexLength
|
|
logMandiri("Parse spec log totalRecords=\(total)")
|
|
for i in 0..<total {
|
|
let start = i * recordHexLength
|
|
let end = start + recordHexLength
|
|
let recordHex = logs.subString(from: start, to: end)
|
|
guard let riwayat = parseMandiriSpecRecord(recordHex, index: i) else {
|
|
logMandiri("Skip spec log record | index=\(i) | raw=\(recordHex)")
|
|
continue
|
|
}
|
|
riwayatList.append(riwayat)
|
|
}
|
|
return true
|
|
}
|
|
|
|
private func parseMandiriSpecRecord(_ recordHex: String, index: Int) -> RiwayatCard? {
|
|
guard recordHex.count == 48 else {
|
|
logMandiri("Spec record invalid length | index=\(index) | length=\(recordHex.count)")
|
|
return nil
|
|
}
|
|
|
|
if isMandiriSpecRecordEmpty(recordHex) {
|
|
logMandiri("Spec record empty | index=\(index)")
|
|
return nil
|
|
}
|
|
|
|
let bytes = recordHex.hex2byte().bytes
|
|
guard bytes.count == 24 else {
|
|
logMandiri("Spec record invalid byte count | index=\(index) | bytes=\(bytes.count)")
|
|
return nil
|
|
}
|
|
|
|
guard let time = decodeMandiriSpecTimestamp(bytes, index: index) else {
|
|
logMandiri("Spec record invalid timestamp | index=\(index) | raw=\(recordHex)")
|
|
return nil
|
|
}
|
|
|
|
let transactionType = bytes[15]
|
|
let amount = decodeMandiriLittleEndianUInt32(Array(bytes[16...19]))
|
|
let balanceAfter = decodeMandiriLittleEndianUInt32(Array(bytes[20...23]))
|
|
let terminalData = Array(bytes[7...13]).map { String(format: "%02X", $0) }.joined()
|
|
|
|
let riwayat = RiwayatCard()
|
|
riwayat.setTransactionTime(time)
|
|
riwayat.setAmount(amount)
|
|
riwayat.setDesk("BAL_AFTER=\(balanceAfter)")
|
|
riwayat.setLocationId(terminalData)
|
|
|
|
if transactionType == 0x00 {
|
|
riwayat.setProsesTipe(0)
|
|
riwayat.setTitle("topup".localizeString(string: self.langCode!))
|
|
} else if transactionType == 0x20 {
|
|
riwayat.setProsesTipe(1)
|
|
riwayat.setTitle("payment".localizeString(string: self.langCode!))
|
|
} else {
|
|
riwayat.setProsesTipe(-1)
|
|
riwayat.setTitle("unknown".localizeString(string: self.langCode!))
|
|
}
|
|
|
|
logMandiri(
|
|
String(
|
|
format: "Parsed spec log | index=%d | type=%02X | title=%@ | amount=%d | balanceAfter=%d | terminal=%@ | raw=%@",
|
|
index,
|
|
transactionType,
|
|
riwayat.getTitle() ?? "-",
|
|
amount,
|
|
balanceAfter,
|
|
terminalData,
|
|
recordHex
|
|
)
|
|
)
|
|
return riwayat
|
|
}
|
|
|
|
private func isMandiriSpecPageEmpty(_ pageHex: String) -> Bool {
|
|
guard !pageHex.isEmpty else {
|
|
return true
|
|
}
|
|
return !pageHex.contains { $0 != "0" }
|
|
}
|
|
|
|
private func isMandiriSpecRecordEmpty(_ recordHex: String) -> Bool {
|
|
return !recordHex.contains { $0 != "0" }
|
|
}
|
|
|
|
private func decodeMandiriSpecTimestamp(_ bytes: [UInt8], index: Int) -> Date? {
|
|
guard bytes.count >= 7 else {
|
|
return nil
|
|
}
|
|
|
|
let values = bytes.prefix(7).map { decodeBcd($0) }
|
|
guard values.allSatisfy({ $0 >= 0 }) else {
|
|
logMandiri("BCD decode failed | index=\(index) | bytes=\(bytes.prefix(7).map { String(format: "%02X", $0) }.joined())")
|
|
return nil
|
|
}
|
|
|
|
var components = DateComponents()
|
|
components.calendar = Calendar(identifier: .gregorian)
|
|
components.timeZone = TimeZone(identifier: "Asia/Jakarta") ?? .current
|
|
components.year = 2000 + values[2]
|
|
components.month = values[1]
|
|
components.day = values[0]
|
|
components.hour = values[3]
|
|
components.minute = values[4]
|
|
components.second = values[5]
|
|
components.nanosecond = values[6] * 10_000_000
|
|
return components.date
|
|
}
|
|
|
|
private func decodeBcd(_ value: UInt8) -> Int {
|
|
let high = Int((value & 0xF0) >> 4)
|
|
let low = Int(value & 0x0F)
|
|
guard high < 10, low < 10 else {
|
|
return -1
|
|
}
|
|
return (high * 10) + low
|
|
}
|
|
|
|
private func decodeMandiriLittleEndianUInt32(_ bytes: [UInt8]) -> Int {
|
|
guard bytes.count >= 4 else {
|
|
return 0
|
|
}
|
|
return Int(bytes[0])
|
|
| (Int(bytes[1]) << 8)
|
|
| (Int(bytes[2]) << 16)
|
|
| (Int(bytes[3]) << 24)
|
|
}
|
|
|
|
private func getLogStep01(index : Int){
|
|
//00 d1 00 00 00
|
|
let hex = String(index, radix: 16)
|
|
let p1Parameter = hex.hex2byte().bytes.first ?? 0x00
|
|
let MANDIRI_LOG = NFCISO7816APDU(instructionClass : 0x00, instructionCode : 0xD1, p1Parameter : p1Parameter, p2Parameter : 0x00, data : Data(), expectedResponseLength : CommonConstants.LE_GET_ALL_RESPONSE_DATA)
|
|
logMandiriApdu("MANDIRI_LOG_NEW[\(index)]", command: MANDIRI_LOG)
|
|
apduRunner.exchangeApdu(apduCommand: MANDIRI_LOG, completionHandler: {response in
|
|
self.logMandiriResponse("MANDIRI_LOG_NEW[\(index)]", response: response)
|
|
if (response.sw1 == 0x90 && response.sw2 == 0x00){
|
|
let chunk = response.getData().hexEncodedString()
|
|
self.mapv1.append(chunk)
|
|
self.logMandiri("New log chunk | index=\(index) | rawLength=\(chunk.count) | accumulated=\(self.mapv1.count)")
|
|
self.start+=1
|
|
if (self.start < (self.finish)){
|
|
self.getLogStep01(index: self.start)
|
|
} else {
|
|
if self.parseNewLog() {
|
|
self.finalizeHistoryResult()
|
|
} else {
|
|
self.retryHistoryRead(reason: "invalid new history payload", retryable: false)
|
|
}
|
|
}
|
|
} else {
|
|
self.logMandiri("New log read failed | index=\(index) | status=\(response.sw1)-\(response.sw2)")
|
|
self.retryHistoryRead(reason: "new history status \(response.sw1)-\(response.sw2) at index \(index)")
|
|
}
|
|
})
|
|
}
|
|
|
|
func parseNewLog() -> Bool {
|
|
let logs = self.mapv1.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
logMandiri("Parse new log | rawLength=\(logs.count)")
|
|
if (logs.count % 48 != 0){
|
|
logMandiri("Parse new log invalid length | length=\(logs.count)")
|
|
return false
|
|
}
|
|
let total = logs.count/48
|
|
logMandiri("Parse new log totalRecords=\(total)")
|
|
for i in 0..<total {
|
|
let start = i*48
|
|
let end = start + 48
|
|
let data = logs.subString(from: start, to: end)
|
|
let riwayat = RiwayatCard()
|
|
let time = self.getTransactionTime(formatDate: data.subString(from: 0, to: 6), formatTime: data.subString(from: 6, to: 12))
|
|
guard let time else {
|
|
self.logMandiri("Skip new log record | index=\(i) | reason=invalid_timestamp | raw=\(data)")
|
|
continue
|
|
}
|
|
riwayat.setTransactionTime(time)
|
|
let processType = Int(data.subString(from: 28, to: 32))
|
|
if (processType == 100){
|
|
riwayat.setProsesTipe(0)
|
|
riwayat.setTitle("Top Up")
|
|
} else {
|
|
riwayat.setProsesTipe(1)
|
|
riwayat.setTitle("Payment")
|
|
}
|
|
riwayat.setLocationId(data.subString(from: 12, to: 20))
|
|
let amount = data.subString(from: 32, to: 40)
|
|
riwayat.setAmount(getRealBalance(reverseHexa: amount))
|
|
self.logMandiri("Parsed new log | index=\(i) | title=\(riwayat.getTitle() ?? "-") | processType=\(processType ?? -1) | locationId=\(riwayat.getLocationId() ?? "-") | amount=\(riwayat.getAmount()) | raw=\(data)")
|
|
riwayatList.append(riwayat)
|
|
}
|
|
return true
|
|
}
|
|
|
|
private func getLogStep02(index : Int){
|
|
//00 b2 00 00 1e
|
|
let hex = String(index, radix: 16)
|
|
let p1Parameter = hex.hex2byte().bytes.first ?? 0x00
|
|
let MANDIRI_LOG = NFCISO7816APDU(instructionClass : 0x00, instructionCode : 0xB2, p1Parameter : p1Parameter, p2Parameter : 0x00, data : Data(), expectedResponseLength : 30)
|
|
logMandiriApdu("MANDIRI_LOG_OLD[\(index)]", command: MANDIRI_LOG)
|
|
apduRunner.exchangeApdu(apduCommand: MANDIRI_LOG, completionHandler: {response in
|
|
self.logMandiriResponse("MANDIRI_LOG_OLD[\(index)]", response: response)
|
|
if (response.sw1 == 0x90 && response.sw2 == 0x00){
|
|
let chunk = response.getData().hexEncodedString()
|
|
self.mapv1.append(chunk)
|
|
self.logMandiri("Old log chunk | index=\(index) | rawLength=\(chunk.count) | accumulated=\(self.mapv1.count)")
|
|
self.start+=1
|
|
if (self.start < (self.finish2)){
|
|
self.getLogStep02(index: self.start)
|
|
} else {
|
|
if self.parseOldLog() {
|
|
self.finalizeHistoryResult()
|
|
} else {
|
|
self.retryHistoryRead(reason: "invalid old history payload", retryable: false)
|
|
}
|
|
}
|
|
} else {
|
|
self.logMandiri("Old log read failed | index=\(index) | status=\(response.sw1)-\(response.sw2)")
|
|
self.retryHistoryRead(reason: "old history status \(response.sw1)-\(response.sw2) at index \(index)")
|
|
}
|
|
})
|
|
}
|
|
|
|
func parseOldLog() -> Bool {
|
|
let logs = self.mapv1.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
logMandiri("Parse old log | rawLength=\(logs.count)")
|
|
if (logs.count % 60 != 0){
|
|
logMandiri("Parse old log invalid length | length=\(logs.count)")
|
|
return false
|
|
}
|
|
let total = logs.count/60
|
|
logMandiri("Parse old log totalRecords=\(total)")
|
|
for i in 0..<total {
|
|
let start = i*60
|
|
let end = start + 60
|
|
let data = logs.subString(from: start, to: end)
|
|
if let riwayat = riwayatCard(data.hex2byte().bytes) {
|
|
self.logMandiri("Parsed old log | index=\(i) | title=\(riwayat.getTitle() ?? "-") | amount=\(riwayat.getAmount()) | raw=\(data)")
|
|
riwayatList.append(riwayat)
|
|
} else {
|
|
self.logMandiri("Skip old log record | index=\(i) | raw=\(data)")
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func getTransactionTime(formatDate : String, formatTime : String) -> Date?{
|
|
let dateFormatter2 = DateFormatter()
|
|
dateFormatter2.locale = Locale(identifier: "en_US_POSIX")
|
|
dateFormatter2.dateFormat = "HHmmss"
|
|
guard let date12 = dateFormatter2.date(from: formatTime) else {
|
|
return nil
|
|
}
|
|
|
|
dateFormatter2.dateFormat = "hh:mm a"
|
|
let date22 = dateFormatter2.string(from: date12)
|
|
|
|
let dateFormatter = DateFormatter()
|
|
dateFormatter.locale = Locale(identifier: "en_US_POSIX")
|
|
dateFormatter.dateFormat = "ddMMyy hh:mm a"
|
|
return dateFormatter.date(from:(formatDate + " " + date22))
|
|
}
|
|
|
|
func getRealBalance(reverseHexa: String?) -> Int {
|
|
guard let reverseHexa = reverseHexa?.trimmingCharacters(in: .whitespacesAndNewlines), !reverseHexa.isEmpty else {
|
|
return 0
|
|
}
|
|
|
|
if reverseHexa.count % 2 != 0 {
|
|
return 0
|
|
}
|
|
|
|
var sb = ""
|
|
for l in stride(from: reverseHexa.count / 2, through: 1, by: -1) {
|
|
let index1 = reverseHexa.index(reverseHexa.startIndex, offsetBy: l * 2 - 2)
|
|
let index2 = reverseHexa.index(reverseHexa.startIndex, offsetBy: l * 2 - 1)
|
|
sb.append(reverseHexa[index1])
|
|
sb.append(reverseHexa[index2])
|
|
}
|
|
return sb.hex2decimal()
|
|
}
|
|
|
|
private func updateScreen(){
|
|
if (self.apduRunner.callback != nil){
|
|
self.apduRunner.callback?.complete(emoney: self.emoney)
|
|
}
|
|
}
|
|
|
|
private func resetHistoryState() {
|
|
riwayatList.removeAll()
|
|
mapv1 = ""
|
|
start = 0
|
|
}
|
|
|
|
private func finalizeHistory() {
|
|
riwayatList = riwayatList.sorted { lhs, rhs in
|
|
switch (lhs.getTransationTime(), rhs.getTransationTime()) {
|
|
case let (left?, right?):
|
|
return left.compare(right) == .orderedDescending
|
|
case (_?, nil):
|
|
return true
|
|
case (nil, _?):
|
|
return false
|
|
case (nil, nil):
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
func riwayatCard(_ bArr: [UInt8]) -> RiwayatCard? {
|
|
var str: String
|
|
let riwayatCard = RiwayatCard()
|
|
var wrap = Data(bArr)
|
|
var bArr2 = [UInt8](repeating: 0, count: 6)
|
|
var bArr3 = [UInt8](repeating: 0, count: 16)
|
|
|
|
wrap.copyBytes(to: &bArr2, count: 6)
|
|
wrap.removeFirst(10)
|
|
|
|
let len = wrap.withUnsafeBytes { $0.load(as: Int32.self).bigEndian }
|
|
wrap.removeFirst(4)
|
|
let amount = wrap.withUnsafeBytes { $0.load(as: Int32.self).littleEndian }
|
|
wrap.removeFirst(4)
|
|
let desk = wrap.withUnsafeBytes { $0.load(as: Int32.self).littleEndian }
|
|
wrap.removeFirst(4)
|
|
|
|
do {
|
|
wrap.copyBytes(to: &bArr3, count: 16)
|
|
logMandiri("Old log detail bytes=\(bArr3.map { String(format: "%02X", $0) }.joined())")
|
|
} catch {
|
|
logMandiri("Old log detail error=\(error.localizedDescription)")
|
|
}
|
|
|
|
var type = 0
|
|
if len == 288 {
|
|
str = "payment".localizeString(string: self.langCode!)
|
|
type = 1
|
|
} else if len == 256 || len == 336 {
|
|
type = 3
|
|
str = "topup".localizeString(string: self.langCode!)
|
|
} else {
|
|
type = -1
|
|
str = "unknown".localizeString(string: self.langCode!)
|
|
}
|
|
|
|
|
|
var str2 = ""
|
|
for y in 0..<6 {
|
|
str2 += String(format: "%02X", bArr2[y])
|
|
}
|
|
|
|
guard let transactionTime = self.getTransactionTime(formatDate: str.subString(from: 0, to: 6), formatTime: str.subString(from: 6, to: 12)) else {
|
|
logMandiri("Skip old log record | reason=invalid_timestamp | raw=\(str)")
|
|
return nil
|
|
}
|
|
riwayatCard.setTransactionTime(transactionTime)
|
|
riwayatCard.setAmount(Int(amount))
|
|
|
|
// if str.caseInsensitiveCompare("payment") == .orderedSame {
|
|
// type = 1
|
|
// } else if str.caseInsensitiveCompare("topup") != .orderedSame {
|
|
// type = 3
|
|
// }
|
|
|
|
riwayatCard.setProsesTipe(type)
|
|
riwayatCard.setTitle(str)
|
|
|
|
if type == -1 {
|
|
logMandiri("Skip old log record | reason=unknown_type | len=\(len) | raw=\(str)")
|
|
return nil
|
|
}
|
|
|
|
return riwayatCard
|
|
}
|
|
}
|