ci-sdk-n-v10
Version:
SDKN Datafono Modulo
1,213 lines (1,083 loc) • 71.7 kB
JavaScript
/**
* SerialPort = Variable para requerir funcionalidad de modulo de SerialPort.
*/
var SerialPort = require("serialport");
/**
* frames = Variable requerida para obtener funcionalidad y recursos del archivo y codigo frames.js
*/
var frames = require("./frames");
/**
* header = Variable requerida para obtener funcionalidad y recursos del archivo y codigo headersframes.js
*/
var header = require('./headersframe');
/**
* port = Variable para la utilizacion de la funcionalidad del puerto serial.
*/
var port;
/**
* portName = Variable establecidad para requerir paso de datos entre variable en funcionalidad del puerto serial,
* una vez que se guarda en esta varible el puerto, no es necesario establecerlo de nuevo en cada funcionalidad.
* @type {string}
*/
var portName = "";
/**
* buffer = Variable para el manejo y ocupacion del buffer, cuando se reciben los datos del serial se guardan en esta variable.
* @type {Array}
*/
var buffer=[];
/**
* BytesAux = Variable utilizada en funciones parametrizar datos de entrada o respuesta segun se requiera, esto para que las funciones lo puedan leer.
*/
var BytesAux;
/**
* bufferRead = Estado booleano utilizado para determinar la lectura de datos en el buffer.
* @type {boolean}
*/
//----------------------------------------------------------------------------------------------------------------------
var BytesAux2;
//----------------------------------------------------------------------------------------------------------------------
var bufferRead=true;
/**
* waitForBuffer = Variable booleana utilizada como estado para esperar respuesta del buffer.
* @type {boolean}
*/
var waitForBuffer=false;
/**
* EventEmitter = Variable que requiere un modulo para la emision de eventos.
*/
var EventEmitter = require ('events').EventEmitter;
/**
* util = Variable utilizada para requerir modulo "util".
* @type {*}
*/
var util = require('util');
/**
* frameManager = Funcion para la emision de eventos y comunicacion de funcionalidades con los archivos requeridos antes establecidos en frames y headers.
*/
var frameManager = function () {
};
util.inherits(frameManager , EventEmitter);
var BytesAuxInit = [];
var self = "";
var log = require("@ci24/ci-logmodule")
//----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------Metodos serial port----------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
/**
* OnSerialClosed = Funcion para establecer el puerto serial cerrado.
* @constructor
*/
OnSerialClosed = function (){
log.write("Puerto serial cerrado: " + port.path);
}
/**
* WriteResponse = Funcion con la que se responde un error de escritura en el puerto serial.
* @param err
* @constructor
*/
WriteResponse = function (err) {
if (err) {
log.write('Error on write: ', err.message);
}
}
/**
* OnSerialDataReceived = Funcion para la Recepcion de "DATA"
* @param data
* @constructor
*/
OnSerialDataReceived = function (data) {
IsDataAvalaible = true;
//------------------------------------------------------------------------------------------------------------------
// Funcionalidad de almacenamiento de "data" en el buffer.----------------------------------------------------------
for (var i = 0; i < data.length; i++) {
buffer.push(data[i]);}
log.write("Buffer : "+ buffer);
//------------------------------------------------------------------------------------------------------------------
// Condicional si el buffer puede leer o esta esperando ejecuta-----------------------------------------------------
if(bufferRead | !waitForBuffer) {
for (var j = 0; j < buffer.length; j++) {
if (buffer[j] == header.SendFrame.BeginFrame[0]) {
waitForBuffer=true;
var bcd =[buffer[j+1], buffer[j+2]];
var bcdh =[];
/* Condicional que al empezar por trama de inicio (02), paso siguiente determina la longitud y aqui ----
espera hasta que reciba la trama de datos---------------------------------------------------------*/
if(!isNaN(buffer[j+1]) & !isNaN(buffer[j+2])){
for(i=0;i<bcd.length;i++){
bcdh[i]=bcd[i].toString(16);}
}
var length = (100*parseInt(bcdh[0], 10))+parseInt(bcdh[1], 10);
log.write("Begin frame found : " + buffer[j]);
var initIndex = j;
log.write("Largo trama : " + length);
for (var h = j+length; h < buffer.length; h++) {
log.write("buffer[h] : "+ buffer[h]);
// Condicional de varias posibilidades para ejecucion ----------------------------------------------
/**
* BytesAux = Variable donde queda guardada toda la respuesta y el buffer elimina lo que ya no es requerido.
*/
if (buffer[h] == header.SendFrame.EndFrame[0]) {
BytesAux = buffer.slice(j, h + 2);
buffer = [];
log.write("BytesAux other frame " + BytesAux);
bufferRead=false;
waitForBuffer=false;
break;
}
}
//Recepcion de parametros de finalizacion de transaccion ACK o NACK-------------------------------------
} else if ((buffer[j] == header.SendFrame.ACK[0] | buffer[j] == header.SendFrame.NACK[0]) & !waitForBuffer) {
BytesAux = buffer[j];
log.write("BytesAux ACK,NACK: " + BytesAux);
buffer = [];
bufferRead=false;
// Dato Asterisco --------------------------------------------------------------------------------------
}else if(buffer[j] == header.SendFrame.Asterisk[0]){
BytesAux = buffer[j-1];
buffer = [];
bufferRead=false;
// Dato Cancelacion-------------------------------------------------------------------------------------
}else if(buffer[j] == header.SendFrame.Cancel[0]){
BytesAux = buffer[j];
buffer = [];
bufferRead=false;
}
}
}
}
/**
* sendSerial = Funcion para escribir en el puerto Serial.
* @param buffer_data
*/
sendSerial = function(buffer_data){
setTimeout(function(){
// Condicional para verificar que se encuentre establecida conexion con el puerto.------------------------------
if (portName != "") {
// Condicional para cuando no esta establecido, que busque informacion.-------------------------------------
if (port.isOpen()) {
port.flush(function () {});
bufferRead=true;
log.write("Buffer send : "+buffer_data);
// Escritura en el puerto con Data.---------------------------------------------------------------------
port.write(buffer_data, WriteResponse);
}
}
}, 500);
}
//----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------Lectura de Serial------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
/**
* WaitForReadyRead = Funcion para esperar una respuesta.
* @param msec
* @param cb
* @constructor
*/
WaitForReadyRead = function(msec, cb) {
var count = 0;
BytesAux = [];
IsDataAvalaible = false;
//------------------------------------------------------------------------------------------------------------------
//Funcion TimeOut para esperar una respuesta------------------------------------------------------------------------
var TimerOutRequest = setInterval(function() {
if (count == msec) {
clearInterval(TimerOutRequest);
cb(false);
}
else {
if (IsDataAvalaible) {
clearInterval(TimerOutRequest);
IsDataAvalaible = false;
setTimeout(function () {
cb(true);
},300);
}
else {
count ++;
}
}
},1);
}
/**
* PortListener = Funcion para abrir el puerto Serial
* @param PortName
* @param cb
* @constructor
*/
PortListener = function(PortName , cb) {
if (PortName != '/dev/ttyS0') {//ttyS0 Version que dejo DavidH --------- '/dev/ttyAMA0' Nueva Verison Montada
//Definicion de parametros para abrir el Puerto Serial y establecer comunicacion con el mismo-------------------
port = new SerialPort(PortName, {
baudRate: 9600, //115200 - 9600
parity: 'none',
dataBits: 8,
stopBits: 1,
lock: false,
autoOpen: false,
});
//--------------------------------------------------------------------------------------------------------------
// Condicional para abrir el puerto Serial----------------------------------------------------------------------
if (!port.isOpen()) {
port.open();
port.on('open', function () {
log.write("Port opened");
portName=PortName;
cb(true);
});
//----------------------------------------------------------------------------------------------------------
// Error en puerto Serial-----------------------------------------------------------------------------------
port.on('error', function (err) {
log.write('Error en Puerto Serial',err);
cb(false);
});
//----------------------------------------------------------------------------------------------------------
// Puerto Serial Cerrado------------------------------------------------------------------------------------
port.on('close', OnSerialClosed);
//port.on('close',port.path);
log.write('Cerrando Puerto');
port.on('data', OnSerialDataReceived);
}else {
cb(true);
log.write("Port already open");
}
}
else{
cb(false);
}
}
//----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------Funciones Auxiliares---------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
/**
* Lugar para funciones auxiliares.
* @param port_name
* @param cb
* @constructor
*/
//----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------Funciones Locales------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
/**
* CheckDevice = Funcion para asignar un puerto Serial al Datafono por identificacion.
* @param port_name
* @param cb
* @constructor
*/
CheckDevice = function(port_name, cb){
PortListener(port_name, function (Check) {
if (Check) {
log.write("Searching Dataphone in port: " + port_name);
StateDataphone(function (response) {
log.write("Dataphone Status : " , response);
//------------------------------------------------------------------------------------------------------
// Ubicacion del Datafono en un puerto Serial ----------------------------------------------------------
if (response) {
log.write("Dataphone port name: " + port.path);
cb(true);
}
else {
if (port.isOpen()) {
log.write("Close Port Name: " + port.path);
port.close();
}
cb(false);
}
});
}
//--------------------------------------------------------------------------------------------------------------
// Respuesta si no hay conexion con Datafono en el puerto Serial -----------------------------------------------
else{
log.write("Dataphone is not in port: " + port_name);
cb(false);
}
});
}
/**
* PrepareDataphone = Funcion para la preparacion de conexion con el Datafono.
* @param cb
* @constructor
*/
PrepareDataphone = function(cb) {
//------------------------------------------------------------------------------------------------------------------
// Envio de Trama de Preparacion de Conexion------------------------------------------------------------------------
log.write("Sending frame prepare dataphone");
sendSerial(header.SendFrame.PrepareDataphone);
WaitForReadyRead(5000, function (Check){
if (Check){
log.write("BytesAux : "+BytesAux);
log.write("header.SendFrame.ACK : "+ header.SendFrame.ACK)
if(BytesAux == header.SendFrame.ACK){
cb(true);
}else{
cb(false);
}
}else {
cb(false);
}
});
}
/**
* StateDataphone = Funcion para comprobar el estado del Datafono, si se encuentra funcional o no hay respuesta.
* @param cb
* @constructor
*/
StateDataphone = function(cb) {
log.write("Sending frame prepare dataphone");
//------------------------------------------------------------------------------------------------------------------
// Envio de la trama del estado del Datafono------------------------------------------------------------------------
sendSerial(header.SendFrame.StateDataphone);
//------------------------------------------------------------------------------------------------------------------
// Espera un byte de la Trama "ACK" y devolvemos el mismo para continuar con el proceso-----------------------------
WaitForReadyRead(5000, function (Check){
if (Check){
log.write("BytesAux : "+BytesAux);
log.write("header.SendFrame.StateResponse : "+ header.SendFrame.StateResponse);
if(BytesAux == header.SendFrame.ACK) {
sendSerial(header.SendFrame.ACK);
cb(true);
}
}else {
cb(false);
}
});
}
/**
* Close = Funcion para cierre de transacciones de Datafono..
* @param cb
* @constructor
*/
Close = function(cb) {
//Se realiza el envio de la trama de cierre-------------------------------------------------------------------------
log.write("Sending frame close dataphone");
sendSerial(header.SendFrame.Close);
// Espera de un ACK-------------------------------------------------------------------------------------------------
WaitForReadyRead(5000, function (Check){
if (Check){
log.write("BytesAux : "+BytesAux);
log.write("header.SendFrame.ACK : "+ header.SendFrame.ACK)
if(BytesAux == header.SendFrame.ACK){
cb(true);
}else{
cb(false);
}
}else {
cb(false);
}
});
}
/**
* lastTransactionAprov = Funcion para comprobacion de que la ultima transaccion fue aprovada.
* @param cb
*/
lastTransactionAprov = function(cb) {
log.write("Sending frame aproved last transaction");
setTimeout(function(){
sendSerial(header.SendFrame.LastTransactionAproved);
}, 500);
WaitForReadyRead(5000, function (Check){
if (Check){
log.write("BytesAux Screen : "+BytesAux);
log.write("header.SendFrame.ACK Screen : "+ header.SendFrame.ACK);
if(BytesAux == header.SendFrame.ACK){
cb(true);
}else{
cb(false);
}
}else {
cb(false);
}
});
}
/**
* payDebit = Funcion para la ejecucion de pago debito.
* @param data
* @param cb
*/
payDebit = function(data, cb) {
log.write("Sending frame pay : " + header.SendFrame.PayExample);
//log.write("Sending frame pay : "+data);
sendSerial(data);
WaitForReadyRead(2000, function (Check){
if (Check){
log.write("BytesAux : "+BytesAux);
log.write("header.SendFrame.Pin : "+ header.SendFrame.Pin);
//----------------------------------------------------------------------------------------------------------
// Esperando respuesta de insertar el PIN ------------------------------------------------------------------
frames.packageFrame.ProcesarTrama(BytesAux, function (status, response)
{
switch(status) {
case 0:
for(var key in response)
{
var item = response[key];
//_global.log.write("presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo))
log.write("desarmarTrama:presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo));
}
var dato = response.find(r => r.campo === "87");
if ( typeof dato !== 'undefined')
{
cb(true);
}
else
{
cb(false);
log.write('Salio Desarmado.........')
}
break;
default:
//Error
break;
}
}
);
}else {
sendSerial(header.SendFrame.ACK);
log.write('Envio ACK Transaccion Fallida Debito');
cb(false);
}
});
}
/**
* payCredit = Funcion para la ejecucion de pago credito.
* @param data
* @param cb
*/
payCredit = function(data, cb) {
log.write("Sending frame pay");
sendSerial(data);
WaitForReadyRead(10000, function (Check){
if (Check){
log.write("BytesAux : " + BytesAux);
log.write("header.SendFrame.ConfirmBuy : "+ header.SendFrame.ConfirmBuy);
/**
* desncrypt = Variable con la informacion de pago.
*/
var desncrypt = frames.packageFrame.desarmarTrama(BytesAux);
//----------------------------------------------------------------------------------------------------------
// Verificacion de codigo de respuesta ---------------------------------------------------------------------
if(desncrypt["ResponseCode"]=="00"){
sendSerial(header.SendFrame.ACK);
log.write("Transaction credit completed");
cb(desncrypt);
//self.emit('CARD_TAKE_OUT_DATAFONO_EVENT'); //Emicion de evento para prueba opcional-------------------
}else if(desncrypt["ResponseCode"]!="00"){
log.write('Envio ACK Transaccion Fallida Credito');
sendSerial(header.SendFrame.ACK);
cb(desncrypt);
//cb(false);
}
}else {
//log.write('Envio ACK Transaccion Fallida Credito');
//sendSerial(header.SendFrame.ACK);
cb(false);
}
});
}
/**
* waitPin = Funcion para verificar el ingreso del PIN en el pago de la tarjeta debito, emitir eventos de confirmacion
* de cada numero caracter de PIN, evento de tecla enter, y evento de salida de tarjeta, cancelacion de transaccion. Pin
* no detectado.
* @param self
* @param cb
*/
waitPin = function(self ,cb){
log.write("Wait for pin");
WaitForReadyRead(30000, function (Check){
bufferRead=true;
if(Check){
log.write("waitPin:BytesAux:{0}:length:{1}".format(BytesAux, BytesAux.length));
switch (BytesAux){
case 0x01:
log.write("First pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 1});
cb(false);
break;
case 0x02:
log.write("Second pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 2});
cb(false);
break;
case 0x03:
log.write("Third pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 3});
cb(false);
break;
case 0x04:
log.write("Fourth pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 4});
cb(false);
break;
case 0x05:
self.emit('COMPLETE_PIN_CONFIRMATION_DATAFONO_EVENT');
log.write("Enter pin inserted");
WaitForReadyRead(25000, function (Check){
if (Check){
var desncrypt =frames.packageFrame.desarmarTrama(BytesAux);
sendSerial(header.SendFrame.ACK);
log.write("Transaction completed, card inserted");
/**
* desncrypt = Respuesta de la Funcion
*/
cb(desncrypt);
outCard(self,outCardCb);
}else{
log.write("Time out confirm buy");
cb(true);
}
});
break;
case 0x06:
log.write("Transaction completed Debit");
self.emit('CARD_TAKE_OUT_DATAFONO_EVENT');
cb(false);
break;
case 0x0ff:
log.write("Cancel transaction, card inserted");
self.emit('CANCEL_TRANSACTION_DATAFONO_EVENT');
cb(true);
break;
}
/*
if(BytesAux == 0x01){
log.write("First pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 1});
cb(false);
if(BytesAux == 0x05){
self.emit('COMPLETE_PIN_CONFIRMATION_DATAFONO_EVENT');
log.write("Enter pin inserted");
WaitForReadyRead(25000, function (Check){
if (Check){
var desncrypt =frames.packageFrame.desarmarTrama(BytesAux);
sendSerial(header.SendFrame.ACK);
log.write("Transaction completed, card inserted");
/!**
* desncrypt = Respuesta de la Funcion
*!/
cb(desncrypt);
outCard(self,outCardCb);
}else{
log.write("Time out confirm buy");
cb(true);
}
});
}
}else if(BytesAux == 0x02){
log.write("Second pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 2});
cb(false);
if(BytesAux == 0x05){
self.emit('COMPLETE_PIN_CONFIRMATION_DATAFONO_EVENT');
log.write("Enter pin inserted");
WaitForReadyRead(25000, function (Check){
if (Check){
var desncrypt =frames.packageFrame.desarmarTrama(BytesAux);
sendSerial(header.SendFrame.ACK);
log.write("Transaction completed, card inserted");
/!**
* desncrypt = Respuesta de la Funcion
*!/
cb(desncrypt);
outCard(self,outCardCb);
}else{
log.write("Time out confirm buy");
cb(true);
}
});
}
}else if(BytesAux == 0x03){
log.write("Third pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 3});
cb(false);
if(BytesAux == 0x05){
self.emit('COMPLETE_PIN_CONFIRMATION_DATAFONO_EVENT');
log.write("Enter pin inserted");
WaitForReadyRead(25000, function (Check){
if (Check){
var desncrypt =frames.packageFrame.desarmarTrama(BytesAux);
sendSerial(header.SendFrame.ACK);
log.write("Transaction completed, card inserted");
/!**
* desncrypt = Respuesta de la Funcion
*!/
cb(desncrypt);
outCard(self,outCardCb);
}else{
log.write("Time out confirm buy");
cb(true);
}
});
}
}else if(BytesAux == 0x04){
log.write("Fourth pin inserted");
self.emit('PIN_DATAFONO_EVENT', {"NumberPin": 4});
cb(false);
if(BytesAux == 0x05){
self.emit('COMPLETE_PIN_CONFIRMATION_DATAFONO_EVENT');
log.write("Enter pin inserted");
WaitForReadyRead(25000, function (Check){
if (Check){
var desncrypt =frames.packageFrame.desarmarTrama(BytesAux);
sendSerial(header.SendFrame.ACK);
log.write("Transaction completed, card inserted");
/!**
* desncrypt = Respuesta de la Funcion
*!/
cb(desncrypt);
outCard(self,outCardCb);
}else{
log.write("Time out confirm buy");
cb(true);
}
});
}
}else if(BytesAux == 0x06){
log.write("Transaction completed Debit");
self.emit('CARD_TAKE_OUT_DATAFONO_EVENT');
cb(false);
}else if(BytesAux == 0x05){
self.emit('COMPLETE_PIN_CONFIRMATION_DATAFONO_EVENT');
log.write("Enter pin inserted");
WaitForReadyRead(25000, function (Check){
if (Check){
var desncrypt =frames.packageFrame.desarmarTrama(BytesAux);
sendSerial(header.SendFrame.ACK);
log.write("Transaction completed, card inserted");
/!**
* desncrypt = Respuesta de la Funcion
*!/
cb(desncrypt);
outCard(self,outCardCb);
}else{
log.write("Time out confirm buy");
cb(true);
}
});
}else if(BytesAux == 0xFF){
log.write("Cancel transaction, card inserted");
self.emit('CANCEL_TRANSACTION_DATAFONO_EVENT');
cb(true);
}
*/
}else{
log.write("No pin detected");
cb(true);
}
});
}
/**
* waitClose = Funcion donde se leen todas las tramas.
* @param cb
*/
waitClose = function(cb){
WaitForReadyRead(15000, function (Check){
if (Check){
var transaction =frames.packageFrame.desarmarTrama(BytesAux);
if(transaction["ResponseCode"]=="00"){
sendSerial(header.SendFrame.ACK);
cb(transaction);
}else{
log.write('WaitCloseElse1');
cb(false);
}
}else{
log.write('WaitCloseElse2');
cb(false);
}
});
}
/**
* CheckPort = Funcion en la cual se verifica la lista de los puertos seriales que existen.
* @param PortName
* @param cb
* @constructor
*/
CheckPort = function(PortName, cb){
var PortList = [];
var iter = 0;
/**
* SerialPort.list = Funcion para entregar la lista de los puertos seriales.
*/
SerialPort.list(function (err, ports) {
//------------------------------------Configuracion para Prueba Local-------------------------------------------
if (PortName == "") {
ports.forEach(function (_port) {
PortList.push(_port.comName);
log.write('Validacion de Puerto Serial +1',_port.comName);
});
}else{
PortList.push(PortName);
log.write('Validacion de Puerto Serial -1', PortName);
}
//---------------------------------------------------------------------------------------------------------------
//-----------------------------Configuracion para RaspBerry con SDK en Qt---------------------------------------
//PortList.push("/dev/ttyDatafono");
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
log.write("Puertos disponibles : ", PortList.length);
iter = 0;
if (PortList.length == 0){
cb(false);
}
else {
CheckDevice(PortList[iter], CheckDeviceCb);
}
function CheckDeviceCb(Check) {
if (Check){
portName = port.path;
cb(true);
}
else{
iter ++;
if (iter == PortList.length ){
portName = "";
iter = 0;
cb(false);
}else {
CheckDevice(PortList[iter], CheckDeviceCb);
}
}
}
});
}
/**
* getDateTime = Funcion para entregar la hora del sistema.
* @returns {number}
*/
function getDateTime() {
var date = new Date();
var hour = date.getHours();
hour = (hour < 10 ? "0" : "") + hour;
var min = date.getMinutes();
min = (min < 10 ? "0" : "") + min;
var sec = date.getSeconds();
sec = (sec < 10 ? "0" : "") + sec;
var msec = date.getMilliseconds();
var year = date.getFullYear();
var month = date.getMonth() + 1;
month = (month < 10 ? "0" : "") + month;
var day = date.getDate();
day = (day < 10 ? "0" : "") + day;
return year+ month + day+ hour + min;
}
lastTransactionAprovRv = function(cb) {
log.write("Sending frame aproved last transaction");
setTimeout(function(){
sendSerial(header.SendFrame.LastTransactionRefused);
}, 500);
WaitForReadyRead(5000, function (Check){
if (Check){
log.write("BytesAux Screen : "+BytesAux);
log.write("header.SendFrame.ACK Screen : "+ header.SendFrame.ACK);
if(BytesAux == header.SendFrame.ACK){
cb(true);
}else{
cb(false);
}
}else {
cb(false);
}
});
}
timetransactioncancel = function () {
}
//----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------Funciones Externas-----------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
/**
* CheckDataphone = Funcion para hacer Check al Datafono.
* @param PortName
* @param cb
* @constructor
*/
frameManager.prototype.CheckDataphone = function(PortName, cb) {
/*if (portName != '') { // Condicional para prueba de escritorio, donde se verifica si el PuertoSerial esta asignado.
log.write("Datafono conectado !!!!!!!!");
cb(true);
} else {*/
var self = this;
CheckPort(PortName, function (Check) {
if (Check) {
BytesAux = [];
WaitForReadyRead(4000, function (Check) {
if (Check) {
bufferRead = true;
OnSerialDataReceived('');
log.write("BytesAux : " + BytesAux);
log.write("header.SendFrame.LastTransacion : " + header.SendFrame.LastTransacion);
/**
* desncrypt = Variable utilizada para asignar la funcion de desarmaTrama dentro de la variable BytesAux.
*/
var desncrypt = frames.packageFrame.desarmarTrama(BytesAux);
log.write("desncrypt[ResponseCode]" + desncrypt["ResponseCode"]);
//----------------------------------------------------------------------------------------------
/**
* CI = Estado de Datafono en el cual se encuentra Card Inserted.
*/
if (desncrypt["ResponseCode"] == "CI") {
cb(true);
outCard(self,outCardCb);
} else if (desncrypt["ResponseCode"] == " ") {
cb(true);
}
} else {
log.write("Not answer from last transaction send");
cb(false);
}
});
} else {
log.write("Dataphone didnt found");
cb(false);
}
});
//}
}
/**
* StatusDataphone = Funcion para verificar el estado del Datafono
* @param cb
* @constructor
*/
frameManager.prototype.StatusDataphone = function(cb){
/**
* self = Instancia del objeto que inicializa una clase.
* @type {frameManager}
*/
var self = this;
//------------------------------------------------------------------------------------------------------------------
// Condicional para prueba de escritorio, donde se verifica si el PuertoSerial esta asignado.
if(portName == ''){
cb(false);
}else {
log.write("Estado del datafono ....");
StateDataphone(function (Check) {
WaitForReadyRead(3000, function (Check){
if(Check){
//--------------------------------------------------------------------------------------------------
// Lee trama del Estado del Datafono----------------------------------------------------------------
bufferRead = true;
OnSerialDataReceived('');
/**
* desncrypt = Variable utilizada para asignar la funcion de desarmaTrama dentro de la variable BytesAux.
*/
var desncrypt = frames.packageFrame.desarmarTrama(BytesAux);
log.write("BytesAux estado : " + BytesAux);
/**
* json = Variable donde se cargara la respuesta.
* @type {{}}
*/
var json={};
log.write("desncrypt[ResponseCode] "+ desncrypt["ResponseCode"]);
/**
* OK = Estado de Datafono en el cual se encuentra OK
*/
if(desncrypt["ResponseCode"]==" "){
json={"Status": "OK"};
}else if(desncrypt["ResponseCode"]=="CI"){
/**
* CI = Estado de Datafono en el cual se encuentra Card Inserted.
*/
json={"Status": "CI"};
self.emit('INSERT_CARD_DATAFONO_EVENT');
}
cb(json);
}else{
/**
* NR = Estado de Datafono en el cual se encuentra No Responde.
*/
cb(json={"Status": "NR"});
}
});
});
}
}
//----------------------------------------------------------------------------------------------------------------------
/**
* readInitDataphone = Funcion para leer el dato o codigo para determinar si hay reverso.
* @param cb
*/
frameManager.prototype.readInitDataphone = function (cb) {
var self = this;
PrepareDataphone(function (Check) {
if (Check) {
BytesAux = [];
sendSerial(header.SendFrame.ACK);
WaitForReadyRead(2000, function (Check) {
if (Check) {
bufferRead = true;
OnSerialDataReceived('');
log.write("BytesAux : " + BytesAux);
log.write('------------------------DESARMANDO INICIO--------------------------------------------');
var desncrypt = frames.packageFrame.desarmarTrama(BytesAux);
frames.packageFrame.ProcesarTrama(BytesAux, function (status, response)
{
switch(status) {
case 0:
for(var key in response)
{
var item = response[key];
//_global.log.write("presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo))
log.write("desarmarTrama:presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo));
}
var dato = response.find(r => r.campo === "43");
if ( typeof dato !== 'undefined')
{
cb(dato.strInfo);
}
else
{
cb(" ");
log.write('Salio Desarmado.........')
//_global.log.write("Convenio no encontrado:id:{0}".format(array[index]), _global.log.level.WARNING);
}
//var desncrypt = 001;
/* log.write(desncrypt);
cb(desncrypt);
BytesAuxInit = BytesAux;
log.write('BytesInit------------------------------');
log.write(BytesAuxInit);
log.write('-----------------------TERMINADO DESARMADO INICIO------------------------------------');*/
break;
default:
//Error
break;
}
}
);
}else {
log.write("Not answer from last transaction send");
cb(false);
}
});
}else {
cb(false);
}
});
}
/*frameManager.prototype.defreadInitDataphone = function (cb) {
var self = this;
var statusinit = false;
if(statusinit == true){
frameManager.prototype.InitDataphoneRv(function (cb) {
log.write('Entrando a Reverso...');
log.write(cb);
/!* var desncrypt = 001;
log.write('Entrando a Reverso :'+desncrypt);
cb(desncrypt);*!/
});
}else{
this.__proto__.InitDataphone(function () {
log.write('Entrando a Aprobado...');
});
}
}*///------------------------Funcion Alterna Posible para toma de decisiones de Reverso.----------------------------
/**
* InitDataphone = Funcion para iniciar Datafono.
* @param cb
* @constructor
*/
frameManager.prototype.InitDataphone = function(cb){
log.write('Inicio Aprobado.....................................................................................');
var self = this;
/* if(portName == ''){
cb(false);
}else {*/
//--------------------------------------------------------------------------------------------------------------
// Preparacion de Conexion -------------------------------------------------------------------------------------
//PrepareDataphone(function (Check) {
//if (Check) {
BytesAux = [];
//sendSerial(header.SendFrame.ACK);
// WaitForReadyRead(2000, function (Check) {
//if (Check) {
bufferRead = true;
//OnSerialDataReceived('');
//var desncrypt = frames.packageFrame.desarmarTrama(BytesAux);
log.write("BytesAux : " + BytesAux);
log.write("header.SendFrame.LastTransacion : " + header.SendFrame.LastTransacion);
log.write('Extraccion Extraccion-------------------------------');
log.write(BytesAux.toString().substr(0, 70));
//if (BytesAux.toString().substr(0, 70) == header.SendFrame.LastTransacion.toString()) {
log.write("Last transaction received");
lastTransactionAprov(function (response) {
WaitForReadyRead(2000, function (Check) {
bufferRead = true;
OnSerialDataReceived('');
log.write("Last transaction aproved send");
log.write("BytesAux : " + BytesAux);
log.write("header.SendFrame.AnswerLastTransaction : " + header.SendFrame.AnswerLastTransaction);
self.emit('INSERT_CARD_DATAFONO_EVENT');
frames.packageFrame.ProcesarTrama(BytesAux, function (status, response)
{
switch(status) {
case 0:
for(var key in response)
{
var item = response[key];
//_global.log.write("presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo))
log.write("desarmarTrama:presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo));
}
var dato = response.find(r => r.campo === "87");
if ( typeof dato !== 'undefined')
{
sendSerial(header.SendFrame.ACK);
log.write("Last transaction aproved received");
//------------------------------------------------------------------------------
// Esperamos trama confirmacion de cambio de pantalla a insertar tarjeta--------
WaitForReadyRead(50000, function (Check) {
if (Check) {
log.write("BytesAux : " + BytesAux);
log.write("header.SendFrame.AnswerLastTransaction : " + header.SendFrame.Canceltransaction);
log.write("header.SendFrame.InsertCard : " + header.SendFrame.InsertCard);
sendSerial(header.SendFrame.ACK);
///------------TimeOut esperando Tarjeta-----------
log.write('Esto '+ BytesAux.toString().substr(0, 60));
frames.packageFrame.ProcesarTrama(BytesAux, function (status, response)
{
switch(status) {
case 0:
for(var key in response)
{
var item = response[key];
//_global.log.write("presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo))
log.write("desarmarTrama:presentation:{0}:campo:{1}:strInfo:{2}".format(item.presentation, item.campo, item.strInfo));
}
var dato = response.find(r => r.campo === "88");
if ( typeof dato !== 'undefined')
{
log.write("Card inserted");
self.emit('CARD_INSERTED_DATAFONO_EVENT');
self.emit('ALERT_PIN_DATAFONO_EVENT');
cb(dato.strInfo);
/*var desncrypt = frames.packageFrame.desarmarTrama(BytesAux);
log.write('------------------Descrynt Tipo de Tarjeta---------------------------------------');
log.write(desncrypt);
//----------------------------------------------------------------------
// Verificacion de accion de Datafono-----------------------------------
// Activacion de Time Out-----------------------------------------------
if (BytesAux.toString() == header.SendFrame.Canceltransaction.toString()) {
log.write("Time out insert card");
cb(false);
// Activacion por Tarjeta insertada---------------------------------
} else if (BytesAux.toString().substr(0, 60) == header.SendFrame.InsertCard.toString()) {
log.write("Card inserted");
self.emit('CARD_INSERTED_DATAFONO_EVENT');
self.emit('ALERT_PIN_DATAFONO_EVENT');
/!**
* jsonTypeCard = Variable para asignar dato de tipo de Tarjeta.
*!/
var jsonTypeCard = frames.packageFrame.tipoTarjeta(BytesAux);
log.write(jsonTypeCard);
cb(jsonTypeCard);
}*/
}
else
{
cb(false);
log.write('Salio Desarmado.........')
//_global.log.write("Convenio no encontrado:id:{0}".format(array[index]), _global.log.level.WARNING);
}
break;
default:
cb(false);
break;
}
}