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 
};
 
enum ArtifactInstallationType
{
    NO_RESTART_APPS = 0, 
    RESTART_APPS = 1 
};
 
struct ArtifactInfo
{
    std::string name = ""; 
    std::string filename = ""; 
    ArtifactType type; 
    std::string md5 = ""; 
    std::uint32_t size; 
    std::string version = ""; 
    ArtifactInstallationType installType = ArtifactInstallationType::NO_RESTART_APPS; 
    bool active = false; 
};
 
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; 
};
 
enum DeviceModel 
{
    DEFAULT_MODEL = 0,
    UX410 = 1, 
    UX412 = 2, 
    CVEND_I = 3, 
    CVEND_II = 4 
};
 
enum DeviceType 
{
    DEFAULT_TYPE = 0,
    DEVELOPMENT = 1, 
    PRODUCTION = 2 
};
 
struct DeviceInfo {
    DeviceModel model = DeviceModel::DEFAULT_MODEL;
    DeviceType type = DeviceType::DEFAULT_TYPE;
};
 
}