scmTypes.h

Go to the documentation of this file.

#pragma once

#include <string>
#include <vector>
#include <map>
#include <boost/system/error_code.hpp>

namespace dpySCM {

enum Action
{
    BOOT = 0, 
    ACTIVE = 1, 
    STANDBY = 2, 
    SLEEP = 3, 
    DEEP_SLEEP = 4, 
    HIBERNATE = 5, 
    REBOOT = 6, 
    OFF = 7 
};

enum CardType
{
    DEFAULT_CARD = 0, 
    MIFARE_1K = 1, 
    MIFARE_4K = 2, 
    MIFARE_UL_EV1 = 3, 
    MIFARE_UL_C = 4, 
    MIFARE_DES = 5, 
    MIFARE_MINI = 6, 
    MIFARE_PLUS = 7, 
    FELICA = 8, 
    CALYPSO = 9, 
    CTS512B = 10, 
    CTS256B = 11, 
    SRT_512 = 12, 
    SRI_512 = 13, 
    EMV = 14, 
    SAM = 15 

};

enum KeyType
{
    DEFAULT_KEY = 0, 
    KEY_A = 1, 
    KEY_B = 2, 
};

struct StorageKeys
{
    KeyType keytype = DEFAULT_KEY; 
    std::string keys = ""; 
};

struct ApduRxData
{
    char32_t sw1 = 0; 
    char32_t sw2 = 0; 
    std::string rxData; 
};

struct ApduTxData
{
    char32_t class_instruction = 0; 
    char32_t instruction = 0; 
    char32_t param1 = 0; 
    char32_t param2 = 0; 
    char32_t expectedResponseLen = 0; 
    std::string txData; 
};

enum OperationType
{
    DEFAULT_OP = 0, 
    AUTH = 1, 
    READ = 2, 
    WRITE = 3, 
    APDU = 4, 
    TRANSFER = 5, 
    RESTORE = 6, 
    INCREMENT = 7, 
    DECREMENT = 8, 
    INCREMENT_ONLY = 9, 
    DECREMENT_ONLY = 10 
};

struct Data
{
    char32_t index = 0; 
    [[deprecated("Use priority instead of keyTypeUsed member")]] KeyType keyTypeUsed = DEFAULT_KEY; 
    char32_t priority = -1; 
    std::string buffer = ""; 
    char32_t errorCode = 0; 
};

struct CardOperation
{
    OperationType operationType = DEFAULT_OP; 
    [[deprecated("Use priority instead of keyTypeUsed member")]] KeyType keyType = DEFAULT_KEY; 
    std::string uid = ""; 
    char32_t index = 0; 
    std::string inRawData; 
    std::string outRawData; 
    ApduTxData txData; 
    ApduRxData rxData; 
    std::string timestamp = ""; 
    char32_t errorCode = 0; 
    char32_t priority = -1; 
};

struct DataBlock
{
    char32_t index = 0; 
    [[deprecated("Use priority instead of keyTypeUsed member")]] KeyType keyTypeUsed = DEFAULT_KEY; 
    char32_t priority = -1; 
    char32_t value = 0; 
};

enum Event
{
    ADDED = 0, 
    REMOVED = 1 
};

struct CardInfo
{
    std::string readerName = ""; 
    std::string uid = ""; 
    CardType cardtype = DEFAULT_CARD; 
    bool collision = true; 
    std::string timestamp = ""; 
    std::string atqa = ""; 
    std::string sak = ""; 
    std::string ats = ""; 
};

struct CardEvent
{
    Event event = REMOVED; 
    CardInfo cardinfo; 
};

struct Reader
{
    std::string deviceid = ""; 
    std::string socket = ""; 
    std::string samuid = ""; 
};

struct Device
{
    std::vector<std::string> device; 
    std::string timestamp = ""; 
    std::vector<std::string> address; 
};

struct Key
{
    KeyType keytype = DEFAULT_KEY; 
    char32_t index = 0; 
    std::string keys = ""; 
};

struct KeyGroup
{
    char32_t priority = 0; 
    std::vector<Key> key; 
    std::string timestamp = ""; 
};

struct TransactionDevice
{
    std::string deviceId = ""; 
    std::vector<CardOperation> operation; 
};

struct DeviceReaderList
{
    std::string deviceId = ""; 
    std::vector<Reader> readers; 
    std::string timestamp = ""; 
};

struct DeviceKeys
{
    std::string deviceId = ""; 
    std::vector<KeyGroup> keys; 
};

struct TransferFile
{
    std::string ip = ""; 
    std::string port = ""; 
    std::string filename = ""; 
    std::string timeoutMs = ""; 
    std::string protocol = ""; 
    std::string user = ""; 
    std::string pass = ""; 
};

struct Version
{
    std::string adkVersion = ""; 
    std::string sdkVersion = ""; 
    std::string serialNumber = ""; 
    std::string osVersion = ""; 
    std::string appVersion = ""; 
    std::string paymentAppVersion = ""; 
};

struct DeviceVersion
{
    std::string deviceId = ""; 
    Version version; 
};

struct NetworkConfiguration
{
    std::string localIpAddress = ""; 
    std::string netmask = ""; 
    std::string gateway = ""; 
    std::string dnsServer = ""; 
    std::string dhcp = ""; 
    std::string hostName = ""; 
};

struct DeviceNetworkConfiguration
{
    std::string deviceId = ""; 
    NetworkConfiguration networkConfiguration; 
};

enum WorkMode
{
    NA_MODE = 0, 
    DISABLE_GW = 1, 
    REDSYS_GW = 2 
};

enum AppStatus
{
    NA_STATUS = 0, 
    PA_ENABLE = 1, 
    PA_DISABLE = 2 
};

struct PaymentAppStatus
{
    WorkMode mode = NA_MODE; 
    AppStatus status = NA_STATUS; 
};

// DEVICE
struct DevicePaymentAppStatus
{
    std::string deviceId = ""; 
    PaymentAppStatus paymentAppStatus; 
};

enum FunctionalityIndicator
{
    NA_INDICATOR = 0, 
    IDLE = 1, 
    NOT_AVAILABLE = 2, 
    NOT_INITIALISED = 3, 
    NO_KEYS = 4, 
    TERMINAL_BROKEN = 5, 
    NO_COMMUNICATIONS = 6 
};

struct PaymentAppInfo
{
    WorkMode mode = NA_MODE; 
    FunctionalityIndicator indicator = NA_INDICATOR; 
    std::string protocolVersion = ""; 
    std::string timestamp = ""; 
};

// DEVICE
struct DevicePaymentAppInfo
{
    std::string deviceId = ""; 
    PaymentAppInfo paymentAppInfo; 
};

enum Property
{
    NA_PROPERTY = 0, 
    ACCESS_POINT_CODE = 1, 
    ACCESS_POINT_TYPE = 2, 
    TRANSPORT_OPERATOR_ID = 3, 
    PRICING_PLAN = 4, 
    ONLINE_MODE = 5, 
    OFFLINE_MODE = 6, 
    OFFLINE_BACKUP = 7, 
    PRICE = 8, 
    TRANSACTION_MODE_CONF = 9, 
    END_OF_DAY_TIME = 10, 
    BLACKLIST = 11, 
    BLACK_LIST_UPDATE_TIMER = 12, 
    BLACK_LIST_UPDATE_RETRIES = 13, 
    BLACK_LIST_TIME_WITHOUT_UPDATES = 14, 
    FINANCIAL_BLACK_LIST = 15, 
    WHITE_LIST = 16, 
    ODA_CARDS = 17, 
    PASSBACK_TIMER = 18, 
    PASSBACK_NUMBER = 19, 
    LANGUAGE = 20, 
    DESTINATION_MODE = 21, 
    ROUTE = 22, 
    TRANSPORT_ZONE = 23, 
    STOP = 24, 
    EMPLOYEE_ID = 25, 
    VEHICLE = 26, 
    EXTRA = 27 
};

struct PaymentAppConfiguration
{
    Property property = NA_PROPERTY; 
    std::string value = ""; 
};

struct PaymentAppConfigurations
{
    std::vector<PaymentAppConfiguration> paymentAppProperty; 
};

struct DevicePaymentAppConfiguration
{
    std::string deviceId = ""; 
    PaymentAppConfigurations paymentAppConfigurations; 
};

enum TicketMode
{
    NA_TICKET = 0, 
    DISABLE_TICKET = 1, 
    CLIENT_TICKET = 2, 
    BOTH_TICKETS = 3 
};

struct RequestCharge
{
    std::string uid = ""; 
    std::string price = ""; 
    TicketMode mode = NA_TICKET; 
};

struct DeviceRequestCharge
{
    std::string deviceId = ""; 
    RequestCharge requestCharge; 
};

enum SolutionCode
{
    NA_SOLUTION = 0, 
    TRANSACTION_AUTHORIZED = 1, 
    TRANSACTION_DENIED = 2, 
    UNKOWN_SOLUTION = 3 
};

enum RequestType
{
    NA_REQUEST = 0, 
    SALE = 1, 
    FULL_OVERVIEW = 2, 
    COUNTABLE_CLOSING = 4, 
    GENERAL_OPERATION_DETAIL = 5, 
    PARTICULAR_OPERATION_DETAIL = 6, 
    PRINT_LOCAL_COPY = 7, 
    PRINT_LAST_ONLINE_COPY = 8, 
    PRINT_AN_ONLINE_COPY = 9, 
    TRADE_ALLOCATION = 10, 
    ECO_QUERY = 11 
};

enum ProductTypeId
{
    NA_PRODUCT = 0, 
    DEBIT = 1, 
    CREDIT = 2, 
    COMMERCIAL = 3, 
    PREPAID = 4, 
    PRIVATE = 5, 
    UNKONW_PRODUCT = 6 
};

enum TechTypeId
{
    NA_TECH = 0, 
    CONTACTLESS_EMV_CARD = 1, 
    CONTACTLESS_EMV_NFC = 2, 
    CONTACTLESS_BAND = 3, 
    CONTACTLESS_BAND_NFC = 4, 
    CONTACT_EMV = 5, 
    MAGNETIC_BAND = 6, 
    UNKOWN_TECH = 7 
};

struct ChargeResult
{
    std::string uid = ""; 
    boost::system::error_code errorCode; 
    SolutionCode solutionCode = NA_SOLUTION; 
    RequestType type = NA_REQUEST; 
    std::string PAN = ""; 
    std::string operationId = ""; 
    ProductTypeId productTypeId = NA_PRODUCT; 
    TechTypeId techTypeId = NA_TECH; 
    std::string appId = ""; 
    std::string countryId = ""; 
    std::string timestamp = ""; 
};

struct DeviceChargeResult
{
    std::string deviceId = ""; 
    ChargeResult chargeResult; 
};

struct ForceConnection
{
    std::string deviceId = ""; 
};

struct ChargeConfirmation
{
    std::string uid = ""; 
    bool abort = false; 
};

struct DeviceChargeConfirmation
{
    std::string deviceId = ""; 
    ChargeConfirmation chargeConfirmation; 
};

struct PlayProfile
{
    std::string readerId = ""; 
    std::string mediaProfileId; 
};

struct DevicePlayProfile
{
    std::string deviceId = ""; 
    PlayProfile playProfile; 
};

struct DevicePciRebootTime
{
    std::string deviceId = ""; 
    unsigned int hour = 0; 
    unsigned int minute = 0; 
    unsigned int sec = 0; 
};

enum State
{
    IDLE_STATE = 0, 
    DOWNLOADING_UPDATES = 1, 
    UPDATE_DOWNLOADED = 2, 
    PREPARED_TO_INSTALL = 3, 
    INSTALLING = 4, 
    UPDATE_INSTALLED = 5, 
    INSTALLING_ROLLBACK_PACKAGE = 6, 
    ROLLBACK_DONE = 7 
};

enum UpdateState
{
    STATE_IDLE = 0, 
    STATE_UPDATING = 1, 
    STATE_WAIT_ROLLBACK = 2, 
    STATE_TRANSFERRING = 3, 
    STATE_ROLLING_BACK = 4, 
    STATE_INSTALLING = 5, 
    STATE_FINISHING = 6 
};

struct DeviceUpgradeStatus
{
    std::string deviceId = ""; 
    State state; 
};

struct Sound
{
    unsigned int tone_hz = 0; 
    unsigned int duration_ms = 0; 
};

enum LedId
{
    NA_LED = 0, 
    LED1 = 1, 
    LED2 = 2, 
    LED3 = 3, 
    LED4 = 4, 
    LED5 = 5, 
    LED6 = 6, 
    LED7 = 7, 
    LED8 = 8, 
    LED9 = 9, 
    LED10 = 10, 
    LEDLOGO1 = 11, 
};

enum LedColor
{
    NA_COLOR = 0, 
    WHITE = 1, 
    RED = 2, 
    BLUE = 3, 
    GREEN = 4, 
    MAGENTA = 5, 
    YELLOW = 6, 
    CYAN = 7, 
};

struct Led
{
    LedId id = NA_LED; 
    LedColor color = NA_COLOR; 
};

struct LedGroupState
{
    std::vector<Led> leds; 
    unsigned int duration_ms = 0; 
};

struct MediaProfile
{
    std::string profileId = ""; 
    std::vector<Sound> sounds; 
    std::vector<LedGroupState> ledGroups; 

};

struct DeviceMediaProfiles
{
    std::string deviceId = ""; 
    std::vector<MediaProfile> mediaProfiles; 
};

struct Command
{
    std::string inRawData; 
    std::string outRawData; 
    char32_t errorCode = 0; 
};

struct PassThrough
{
    std::string readerId = ""; 
    std::string uid = ""; 
    std::vector<Command> commands; 
};

struct DevicePassThrough
{
    std::string deviceId = ""; 
    PassThrough passThrough; 
};

struct UltraLightCounter
{
    std::string uid = ""; 
    std::uint8_t counter = 0; 
    unsigned int value = 0; 
};

struct DeviceDateTime
{
    std::string deviceId; 
    std::uint32_t seconds; 
    std::uint32_t minutes; 
    std::uint32_t hours; 
    std::uint32_t day; 
    std::uint32_t month; 
    std::uint32_t year; 
};

enum RebootType
{
    SOFT = 0, 
    HARD = 1 
};

struct DeviceNetworkConnectivity
{
    std::string deviceId; 
    std::string address; 
};

struct DeviceNetworkStatus
{
    std::string deviceId; 
    std::string address; 
    unsigned int time_ms; 
};

enum Component
{
    NONE = 0, 
    ALL = 1, 
    CONFIGURATION = 2, 
    LIBPAP_EMV = 3, 
    TRANSPORT_NFC = 4, 
    SAM_READER = 5, 
    SYSTEM = 6, 
    UPDATES = 7, 
    SERVER = 8 
};

enum LogLevel
{
    DEBUG = 0, 
    INFO = 1, 
    WARN = 2, 
    ERROR = 3 
};

struct LoggingConfiguration
{
    Component component = Component::NONE; 
    LogLevel logLevel = LogLevel::DEBUG; 
    std::string address = ""; 
    unsigned int port = 0; 
    unsigned int rebootsUntilLoggingDisabled = 0; 
};

enum SamSlot
{
    ALL_SAMS = 0, 
    FIRST  = 1, 
    SECOND  = 2, 
    THIRD  = 3, 
    FOURTH   = 4 
};

enum ArtifactType 
{
    DEFAULT_ARTIFACT = 0, 
    PLUGIN = 1, 
    FILE = 2 
};

struct ArtifactInfo
{
    std::string name = ""; 
    std::string filename = ""; 
    ArtifactType type; 
    std::string md5 = ""; 
    std::uint32_t size; 
    std::string version = ""; 
};

struct DeviceArtifacts
{
    std::string deviceId = ""; 
    std::vector<ArtifactInfo> artifacts; 
    std::string timestamp = ""; 
};

struct DevicePluginData
{
    std::string deviceId = ""; 
    std::string plugin_name = ""; 
    std::map<std::string, std::string> data; 
};

}