NAV
c cpp java

Начало работы с драйвером

Подключение к проекту

C/C++

Для использования драйвера из проекта, написанного на C/C++, нужно добавить к нему в зависимости библиотеку fiscal_core_driver.dll (в случае Linux: libfiscal_core_driver.so) соответствующей архитектуры и подключить заголовочный файл libfptr10.h. Для C++ можно использовать отдельную обертку.

С++-обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

Поддерживается работа на Windows и Linux.

Java

Для подключения драйвера к Java-проекту необходимо подключить библиотеку libfiscal_core_driver.jar.

При работе на Windows и Linux обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

Поддерживается работа на Windows и Linux.

COM-объект

Для подключения драйвера как COM-объект необходимо зарегистрировать в системе библиотеку fiscal_core_driver_com.dll с помощью команды regsvr32.exe. Библиотека может сама обнаружить установленный через инсталлятор драйвер. Также инсталлятор автоматически регистрирует компонент заданной архитектуры в процессе установки. В проекте необходимо создать объект типа ActiveX (или OLE) класса AddIn.FiscalCore1.

Поддерживается работа только на Windows.

Инициализация драйвера

Инициализация драйвера

#include "libfptr10.h"

libfptr_handle fptr;
libfptr_create(&fptr);


#include "libfptr10.h"

// Можно загрузить обертку с указанием пути к библиотеке драйвера
Fptr fptr_lib("C:\\path\\to\\libraries\\directory\\fiscal_core_driver.dll");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
Fptr fptr_common;


import ru.neva.drivers.fptr.Fptr;
import ru.neva.drivers.fptr.IFptr;

// Можно загрузить обертку с указанием пути к библиотеке драйвера
IFptr fptr_lib = new Fptr("C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
IFptr fptr_dir = new Fptr("C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
IFptr fptr_common = new Fptr();

import ru.atol.drivers10.fptr.Fptr;
import ru.atol.drivers10.fptr.IFptr;

IFptr fptr = new Fptr(getApplicationContext());

Инициализация драйвера с указанием идентификатора (KKT1)

#include "fptr10.h"

libfptr_handle fptr;
libfptr_create_with_id(&fptr, L"KKT1");


#include "fptr10.h"

// Можно загрузить обертку с указанием пути к библиотеке драйвера
Fptr fptr_lib(fptr_id_t(L"KKT1"), L"C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
Fptr fptr_path(fptr_id_t(L"KKT1"), L"C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
Fptr fptr_common(fptr_id_t(L"KKT1"));


import ru.neva.drivers.fptr.Fptr;
import ru.neva.drivers.fptr.IFptr;

// Можно загрузить обертку с указанием пути к библиотеке драйвера
IFptr fptr_lib = new Fptr("KKT1", "C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
IFptr fptr_dir = new Fptr("KKT1", "C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
IFptr fptr_common = new Fptr("KKT1", null);

import ru.atol.drivers10.fptr.Fptr;
import ru.atol.drivers10.fptr.IFptr;

IFptr fptr = new Fptr(getApplicationContext(), "KKT1");

В начале работы необходимо инициализировать рабочий экземпляр драйвера.

Все дальнейшие операции производятся именно над этим экземпляром.

В случае использования варианта с передачей идентификатора все записанные драйвером логи будут разделяться по разным файлам. Строка идентификатора может содержать только строчные и заглавные латинские буквы и цифры, а также символы тире и подчеркивания ([a-zA-Z0-9_-]). Если идентификатор не удовлетворяет требованиям, драйвер вернёт код результата -2, а языковые обертки вернут ошибки/выбросят исключения средствами соответствующего языка. При передаче пустого идентификатора создание объекта отрабатывает аналогично созданию без идентификатора.

Рекомендации по работе с экземпляром драйвера

Запрос версии драйвера

Запрос версии драйвера

char *version = libfptr_get_version_string();

std::string version = fptr.version();

String version = fptr.version();

String version = fptr.version();

Драйвер позволяет получить свою версию в виде строки.

Деинициализация драйвера

Деинициализация драйвера

libfptr_destroy(&fptr);

// Деинициализируется автоматически в деструкторе

fptr.destroy();

fptr.destroy();

Когда работа с ККТ более не требуется, можно уничтожить рабочий экземпляр. При этом автоматически разорвется соединение с ККТ. После выполнения метода дальнейшая работа с данным экземпляром драйвера невозможна.

Настройка драйвера

Настройка драйвера, способ первый

wchar_t settings[1024] = {0};
swprintf(&settings[0], 1024, L"{\"%ls\": %d, \"%ls\": %d, \"%ls\": \"%ls\", \"%ls\": %d}",
    LIBFPTR_SETTING_MODEL, LIBFPTR_MODEL_NEVA_AUTO,
    LIBFPTR_SETTING_PORT, LIBFPTR_PORT_COM,
    LIBFPTR_SETTING_COM_FILE, L"COM5",
    LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
libfptr_set_settings(fptr, settings);

wchar_t settings[1024] = {0};
swprintf(&settings[0], 1024, L"{\"%ls\": %d, \"%ls\": %d, \"%ls\": \"%ls\", \"%ls\": %d}",
    LIBFPTR_SETTING_MODEL, LIBFPTR_MODEL_NEVA_AUTO,
    LIBFPTR_SETTING_PORT, LIBFPTR_PORT_COM,
    LIBFPTR_SETTING_COM_FILE, L"COM5",
    LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

settings = String.format("{\"%s\": %d, \"%s\": %d, \"%s\": \"%s\", \"%s\": %d}",
    IFptr.LIBFPTR_SETTING_MODEL, IFptr.LIBFPTR_MODEL_NEVA_AUTO,
    IFptr.LIBFPTR_SETTING_PORT, IFptr.LIBFPTR_PORT_COM,
    IFptr.LIBFPTR_SETTING_COM_FILE, "COM5",
    IFptr.LIBFPTR_SETTING_BAUDRATE, IFptr.LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

settings = String.format("{\"%s\": %d, \"%s\": %d, \"%s\": \"%s\", \"%s\": %d}",
    IFptr.LIBFPTR_SETTING_MODEL, IFptr.LIBFPTR_MODEL_NEVA_AUTO,
    IFptr.LIBFPTR_SETTING_PORT, IFptr.LIBFPTR_PORT_COM,
    IFptr.LIBFPTR_SETTING_COM_FILE, "COM5",
    IFptr.LIBFPTR_SETTING_BAUDRATE, IFptr.LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

Настройка драйвера, способ второй

libfptr_set_single_setting(fptr, LIBFPTR_SETTING_MODEL, std::to_wstring(LIBFPTR_MODEL_NEVA_AUTO).c_str());
libfptr_set_single_setting(fptr, LIBFPTR_SETTING_PORT, std::to_wstring(LIBFPTR_PORT_COM).c_str());
libfptr_set_single_setting(fptr, LIBFPTR_SETTING_COM_FILE, L"COM5");
libfptr_set_single_setting(fptr, LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
libfptr_apply_single_settings(fptr);

fptr.setSingleSetting(LIBFPTR_SETTING_MODEL, std::to_wstring(LIBFPTR_MODEL_NEVA_AUTO));
fptr.setSingleSetting(LIBFPTR_SETTING_PORT, std::to_wstring(LIBFPTR_PORT_COM));
fptr.setSingleSetting(LIBFPTR_SETTING_COM_FILE, L"COM5");
fptr.setSingleSetting(LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
fptr.applySingleSettings();

fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_MODEL, String.valueOf(IFptr.LIBFPTR_MODEL_NEVA_AUTO));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_PORT, String.valueOf(IFptr.LIBFPTR_PORT_COM));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_COM_FILE, "COM5");
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_BAUDRATE, String.valueOf(IFptr.LIBFPTR_PORT_BR_115200));
fptr.applySingleSettings();

fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_MODEL, String.valueOf(IFptr.LIBFPTR_MODEL_NEVA_AUTO));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_PORT, String.valueOf(IFptr.LIBFPTR_PORT_COM));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_COM_FILE, "COM5");
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_BAUDRATE, String.valueOf(IFptr.LIBFPTR_PORT_BR_115200));
fptr.applySingleSettings();

Настройка через вызов окна настройки

 libfptr_show_properties(fptr, LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);

fptr.showProperties(LIBFPTR_GUI_PARENT_HATIVE, <дескриптор окна>);

fptr.showProperties(IFptr.LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  private static final int REQUEST_SHOW_SETTINGS = 1;
  private IFptr fptr;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // ....
    // Создание объекта драйвера
    fptr = new Fptr(getApplication());

    // Вызываем Activity настройки
    findViewById(R.id.btnShowSettings).setOnClickListener(new View.OnClickListener {
        @Override
        public void onClick(View view) {
          Intent intent = new Intent(getApplication(), SettingsActivity.class);
          // Передаем текущие настройки в SettingsActivity.
          // Если не передать - будет показана SettingsActivity с настройками по умолчанию
          intent.putExtra(SettingsActivity.DEVICE_SETTINGS, fptr.getSettings());
          startActivityForResult(intent, REQUEST_SHOW_SETTINGS);
        }
      }
    );
  }

  public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_SHOW_SETTINGS && resultCode == Activity.RESULT_OK) {
      // Записываем настройки в объект
      fptr.setSettings(data.getStringExtra(SettingsActivity.DEVICE_SETTINGS));
    }
  }
}

Для того, чтобы начать работу с ККТ, требуется настроить соединение с устройством. Есть несколько способов передать в драйвер настройки.

Первый способ - передача всех настроек в виде JSON методом драйвера setSettings(...), аргументом которого является строка с настройками в формате JSON. Способ удобен тем, что настройки в таком виде можно запросить у драйвера, сохранить, и при следующей работе с ККТ передать их в драйвер заново как есть. При передаче настроек драйвер разорвет связь с ККТ, если она установлена, изменит настройки и подключится заново. Если по новым настройкам подключиться не удаётся, то драйвер попробует восстановить связь по старым настройкам и вернёт ошибку. Есть некоторая вероятность, что подключиться по старым настройкам также не удастся. В этом случае будет возвращена ошибка, соединение сброшено, а метод isOpened() будет возвращать false.

Второй способ - передача настроек по одной с их применением в конце. Результат и поведение будут идентичны первому способу. Настройки подаются методом setSingleSetting(...), аргументами которого является идентификатор настройки и сама настройка в строковом представлении. По завершении поданные настройки необходимо применить, подав метод applySingleSettings().

Третий способ - вызов окна настройки связи с ККТ. В случае использования метода showProperties() требуется передать дескриптор родительского окна для отображения модального диалога и указать его тип.

Для передачи дескриптора родительского окна типа QWidget (Qt) требуется указать тип окна LIBFPTR_GUI_PARENT_QT.

Для передачи дескриптора родительского окна типа HWND (WinApi) требуется указать тип окна LIBFPTR_GUI_PARENT_NATIVE. Использование типа окна LIBFPTR_GUI_PARENT_NATIVE на Linux на данный момент не поддерживается.

При передаче нулевого дескриптора диалог настройки будет немодальным.

Метод возвращает следующие значения:

Выгрузка настроек

Первый способ

std::vector<wchar_t> settings(1024);
int size = libfptr_get_settings(fptr, &settings[0], settings.size());
if (size > settings.size())
{
    settings.resize(size);
    libfptr_get_settings(fptr, &settings[0], settings.size());
}

std::wstring settings = fptr.getSettings();

String settings = fptr.getSettings();

String settings = fptr.getSettings();
Выгрузка настроек, способ второй (на примере получения IP-адреса и порта)

String ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT);

Второй способ

std::wstring ipAddress, ipPort;

std::vector<wchar_t> setting(1024);
int size = libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPADDRESS, &setting[0], setting.size());
if (size > settings.size())
{
    setting.resize(size);
    libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPADDRESS, &setting[0], setting.size());
}
ipAddress = std::wstring(&setting[0]);

int size = libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPPORT, &setting[0], setting.size());
if (size > settings.size())
{
    setting.resize(size);
    libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPPORT, &setting[0], setting.size());
}
ipPort = std::wstring(&setting[0]);

std::wstring ipAddress = fptr.getSingleSetting(LIBFPTR_SETTING_IPADDRESS);
std::wstring ipPort = fptr.getSingleSetting(LIBFPTR_SETTING_IPPORT);

String ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT);

Выгрузить настройки также можно двумя способами.

Первый позволяет получить все настройки разом в виде JSON.

Используя второй способ, можно получить отдельно значение каждой настройки.

Список настроек

Все настройки можно поделить на несколько категорий.

К первой относятся общие настройки драйвера, которые отвечают непосредственно за его поведение.

Это следующие настройки:

Ко второй относятся настройки связи с ККТ.

Методы и параметры драйвера

Установка целочисленного параметра

libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);

fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);

Установка дробного параметра

libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 123.45);

fptr.setParam(LIBFPTR_PARAM_PRICE, 123.45);

fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 123.45);

fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 123.45);

Установка строкового параметра

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");

String settings = fptr.getSettings();
Выгрузка настроек, способ второй (на примере получения IP-адреса и порта)

String ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT);

Установка параметра дата / время

time_t t = time(NULL);
struct tm tm = *localtime(&t);
libfptr_set_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);

std::time_t t = time(nullptr);
std::tm tm = *localtime(&t);
fptr.setParam(LIBFPTR_PARAM_DATE_TIME, tm);

Calendar c = Calendar.getInstance();
fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, c.getTime());

String settings = fptr.getSettings();
Выгрузка настроек, способ второй (на примере получения IP-адреса и порта)

String ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT);

Установка массива байтов

uchar command[] = {0x91, 0x13, 0x00, 0x00};
libfptr_set_param_bytearray(fptr, LIBFPTR_PARAM_COMMAND_BUFFER, 
                            &command[0], sizeof(command) / sizeof(command[0]));

fptr.setParam(LIBFPTR_PARAM_COMMAND_BUFFER, {0x91, 0x13, 0x00, 0x00});
fptr.setParam(LIBFPTR_PARAM_COMMAND_BUFFER, std::vector<uchar>{0x91, 0x13, 0x00, 0x00});
uchar command[] = {0x91, 0x13, 0x00, 0x00};
fptr.setParam(LIBFPTR_PARAM_COMMAND_BUFFER, &command[0], sizeof(command) / sizeof(command[0]));

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMAND_BUFFER, new byte[]{0x91, 0x13, 0x00, 0x00});

Получение целочисленного параметра

uint lineLength = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

uint lineLength = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

// На самом деле драйвер возвращает unsigned int, но, из-за отсутствия в Java unsigned-типов, возвращается long
long lineLength = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

Получение дробного параметра

double cashSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

double cashSum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Получение строкового параметра

std::vector<wchar_t> str(64);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    unitVersion.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring unitVersion = std::wstring(&str[0]);

std::wstring unitVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

String unitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

Получение параметра дата / время

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Получение массива байтов

std::vector<uchar> commandAnswer(32);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_ANSWER_BUFFER, 
                                       &commandAnswer[0], commandAnswer.size());
if (size > commandAnswer.size())
{
    commandAnswer.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_ANSWER_BUFFER, 
                                &commandAnswer[0], commandAnswer.size());
}
commandAnswer.resize(size);

std::vector<uchar> commandAnswer = fptr.getParamByteArray(LIBFPTR_PARAM_ANSWER_BUFFER);

byte[] commandAnswer = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_ANSWER_BUFFER);

Работа с ККТ производится с помощью методов и их параметров.

Каждый метод, в зависимости от своих параметров, выполняет определенные операции с устройством. Параметры бывают входные и выходные. Входные параметры влияют на выполняемую операцию, а выходные - это её результат.

Список входных параметров очищается сразу после выполнения метода. Список выходных - перед выполнением следующего.

Каждый метод возвращает 0, если метод выполнился удачно, и -1, если произошла ошибка. Метод showProperties() может вернуть также значение 1. Метод isOpened() не возвращает признак результата, вместо этого он возвращает признак установленного соединения с ККТ.

Параметры бывают следующих типов:

Описания параметров представлены в описании каждого метода.

При работе в JavaScript (Duktape) у методов setParam(), setNonPrintableParam() и setUserParam() добавлен необязательный параметр - флаги. Туда можно передать константу IGNORE_IF_EMPTY, которая отключит передачу параметра в драйвер, если он принимает одно из следующих значений:

Обработка ошибок

Вызов метода

if (libfptr_print_text(fptr) < 0)
{
    int errorCode = libfptr_error_code(fptr);

    std::vector<wchar_t> errorDescription(32);
    int size = libfptr_error_description(fptr, &errorDescription[0], errorDescription.size());
    if (size > errorDescription.size())
    {
        errorDescription.resize(size);
        libfptr_error_description(fptr, &errorDescription[0], errorDescription.size());
    }

    std::wcout << L"Ошибка - " 
               << errorCode 
               << L" [" << std::wstring(&errorDescription[0]) << L"]" 
               << std::endl;
}

if (fptr.printText() < 0) 
{
    std::wcout << L"Ошибка - " 
               << fptr.errorCode() 
               << L" [" << fptr.errorDescription() << L"]" 
               << std::endl;
}

if (fptr.printText() < 0) {
    System.out.println(String.format("%d [%s]", fptr.errorCode(), fptr.errorDescription()));
}

Каждый метод драйвера возвращает индикатор результата выполнения. Этот индикатор может принимать значения 0 и -1.

В случае, если индикатор не равен 0, выполнение метода завершится с ошибкой и есть возможность получить подробности о ней. Для этого у драйвера можно запросить код последней ошибки (метод errorCode()) и её текстовое описание (метод errorDescription()).

Драйвер хранит информацию об ошибке до следующего вызова метода - после него информация об ошибке обновляется. Для явного сброса информации о последней ошибки нужно использовать метод resetError().

Список кодов ошибок приведен в приложении Список кодов ошибок.

Соединение с ККТ

Установка соединения с ККТ

libfptr_open(fptr);

fptr.open();

fptr.open();

fptr.open();

Проверка состояния логического соединения

bool isOpened = (libfptr_is_opened(fptr) != 0);

bool isOpened = fptr.isOpened();

boolean isOpened = fptr.isOpened();

boolean isOpened = fptr.isOpened();

Завершение соединения с ККТ

libfptr_close(fptr);

fptr.close();

fptr.close();

fptr.close();

После настройки рабочего экземпляра можно подключиться к ККТ. Для этого требуется вызвать метод open(). После подключения к ККТ можно выполнять различные операции с ККТ, а также, при соответствующих настройках, драйвер организует для ККТ канал для обмена с ОФД. До вызова данного метода все другие операции с ККТ будет завершаться с ошибкой LIBFPTR_ERROR_CONNECTION_DISABLED.

Чтобы узнать состояние соединения, нужно использовать метод isOpened(). Результат метода не отражает текущее состояние подключения - если с ККТ была разорвана связь, то метод все также будет возвращать true, но методы, выполняющие какие-либо операции над ККТ, будут возвращать ошибку LIBFPTR_ERROR_NO_CONNECTION.

Для завершения соединения с ККТ нужно вызвать метод close(). Драйвер вернется в изначальное состояние, как до вызова open(). Канал с ОФД, установленный с его помощью, будет закрыт и отправка документов в ОФД будет прервана.

Запрос информации о ККТ

Общая информация и статус

Запрос общей информации и статуса ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STATUS);
libfptr_query_data(fptr);

uint operatorID         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_OPERATOR_ID);
uint logicalNumber      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_LOGICAL_NUMBER);
uint shiftState         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_STATE);
uint model              = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MODEL);
uint mode               = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MODE);
uint submode            = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SUBMODE);
uint receiptNumber      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint shiftNumber        = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptType        = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);
uint documentType       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_TYPE);
uint lineLength         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint lineLengthPix      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPT_SUM);

bool isFiscalDevice         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FISCAL) != 0);
bool isFiscalFN             = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_FISCAL) != 0);
bool isFNPresent            = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_PRESENT) != 0);
bool isInvalidFN            = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_INVALID_FN) != 0);
bool isCashDrawerOpened     = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CASHDRAWER_OPENED) != 0);
bool isPaperPresent         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT) != 0);
bool isPaperNearEnd         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PAPER_NEAR_END) != 0);
bool isCoverOpened          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COVER_OPENED) != 0);
bool isPrinterConnectionLost= (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PRINTER_CONNECTION_LOST) != 0);
bool isPrinterError         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PRINTER_ERROR) != 0);
bool isCutError             = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CUT_ERROR) != 0);
bool isPrinterOverheat      = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PRINTER_OVERHEAT) != 0);
bool isDeviceBlocked        = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_BLOCKED) != 0)

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
}
std::wstring serialNumber = std::wstring(&str[0]);

size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
}
std::wstring modelName = std::wstring(&str[0]);

size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring firmwareVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STATUS);
fptr.queryData();

uint operatorID      = fptr.getParamInt(LIBFPTR_PARAM_OPERATOR_ID);
uint logicalNumber   = fptr.getParamInt(LIBFPTR_PARAM_LOGICAL_NUMBER);
uint shiftState      = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_STATE);
uint model           = fptr.getParamInt(LIBFPTR_PARAM_MODEL);
uint mode            = fptr.getParamInt(LIBFPTR_PARAM_MODE);
uint submode         = fptr.getParamInt(LIBFPTR_PARAM_SUBMODE);
uint receiptNumber   = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber  = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint shiftNumber     = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptType     = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_TYPE);
uint documentType    = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_TYPE);
uint lineLength      = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint lineLengthPix   = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(LIBFPTR_PARAM_RECEIPT_SUM);

bool isFiscalDevice          = fptr.getParamBool(LIBFPTR_PARAM_FISCAL);
bool isFiscalFN              = fptr.getParamBool(LIBFPTR_PARAM_FN_FISCAL);
bool isFNPresent             = fptr.getParamBool(LIBFPTR_PARAM_FN_PRESENT);
bool isInvalidFN             = fptr.getParamBool(LIBFPTR_PARAM_INVALID_FN);
bool isCashDrawerOpened      = fptr.getParamBool(LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent          = fptr.getParamBool(LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
bool isPaperNearEnd          = fptr.getParamBool(LIBFPTR_PARAM_PAPER_NEAR_END);
bool isCoverOpened           = fptr.getParamBool(LIBFPTR_PARAM_COVER_OPENED);
bool isPrinterConnectionLost = fptr.getParamBool(LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
bool isPrinterError          = fptr.getParamBool(LIBFPTR_PARAM_PRINTER_ERROR);
bool isCutError              = fptr.getParamBool(LIBFPTR_PARAM_CUT_ERROR);
bool isPrinterOverheat       = fptr.getParamBool(LIBFPTR_PARAM_PRINTER_OVERHEAT);
bool isDeviceBlocked         = fptr.getParamBool(LIBFPTR_PARAM_BLOCKED);

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

std::wstring serialNumber    = fptr.getParamString(LIBFPTR_PARAM_SERIAL_NUMBER);
std::wstring modelName       = fptr.getParamString(LIBFPTR_PARAM_MODEL_NAME);
std::wstring firmwareVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STATUS);
fptr.queryData();

long operatorID      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OPERATOR_ID);
long logicalNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_LOGICAL_NUMBER);
long shiftState      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long model           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
long mode            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODE);
long submode         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SUBMODE);
long receiptNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long shiftNumber     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
long receiptType     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long documentType    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_TYPE);
long lineLength      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long lineLengthPix   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);

boolean isFiscalDevice          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FISCAL);
boolean isFiscalFN              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FISCAL);
boolean isFNPresent             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_PRESENT);
boolean isInvalidFN             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN);
boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);
boolean isPrinterConnectionLost = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
boolean isPrinterError          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_ERROR);
boolean isCutError              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CUT_ERROR);
boolean isPrinterOverheat       = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_OVERHEAT);
boolean isDeviceBlocked         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BLOCKED);

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

String serialNumber    = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STATUS);
fptr.queryData();

long operatorID      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OPERATOR_ID);
long logicalNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_LOGICAL_NUMBER);
long shiftState      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long model           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
long mode            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODE);
long submode         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SUBMODE);
long receiptNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long shiftNumber     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
long receiptType     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long documentType    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_TYPE);
long lineLength      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long lineLengthPix   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);

boolean isFiscalDevice          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FISCAL);
boolean isFiscalFN              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FISCAL);
boolean isFNPresent             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_PRESENT);
boolean isInvalidFN             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN);
boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);
boolean isPrinterConnectionLost = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
boolean isPrinterError          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_ERROR);
boolean isCutError              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CUT_ERROR);
boolean isPrinterOverheat       = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_OVERHEAT);
boolean isDeviceBlocked         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BLOCKED);

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

String serialNumber    = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

Для запроса общей информации и статуса необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_STATUS.

Результатом этого запроса будет следующая информация

Параметр Описание Тип
LIBFPTR_PARAM_OPERATOR_ID Номер кассира int
LIBFPTR_PARAM_LOGICAL_NUMBER Номер ККТ в магазине int
LIBFPTR_PARAM_DATE_TIME Дата и время ККТ datetime
LIBFPTR_PARAM_FISCAL Флаг регистрации ККТ bool
LIBFPTR_PARAM_FN_FISCAL Флаг фискализации ФН bool
LIBFPTR_PARAM_FN_PRESENT Флаг наличия ФН в ККТ bool
LIBFPTR_PARAM_INVALID_FN Флаг корректности ФН bool
LIBFPTR_PARAM_SHIFT_STATE Состояние смены int
LIBFPTR_PARAM_CASHDRAWER_OPENED Денежный ящик открыт bool
LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT Наличие бумаги bool
LIBFPTR_PARAM_PAPER_NEAR_END Бумага скоро закончится. Если датчика скорого окончания бумаги в ККТ нет, то будет всегда возвращаться false bool
LIBFPTR_PARAM_COVER_OPENED Крышка открыта bool
LIBFPTR_PARAM_SERIAL_NUMBER Заводской номер ККТ string
LIBFPTR_PARAM_MODEL Номер модели ККТ int
LIBFPTR_PARAM_MODE Режим ККТ int
LIBFPTR_PARAM_SUBMODE Подрежим ККТ int
LIBFPTR_PARAM_RECEIPT_NUMBER Номер чека (внутренний счетчик ККТ) int
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер документа (внутренний счетчик ККТ) int
LIBFPTR_PARAM_SHIFT_NUMBER Номер открытой смены или номер последней закрытой смены + 1 int
LIBFPTR_PARAM_RECEIPT_TYPE Тип открытого чека int
LIBFPTR_PARAM_DOCUMENT_TYPE Тип открытого документа int
LIBFPTR_PARAM_RECEIPT_SUM Сумма текущего чека double
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH Ширина чековой ленты, симв. int
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX Ширина чековой ленты, пикс. int
LIBFPTR_PARAM_MODEL_NAME Название ККТ string
LIBFPTR_PARAM_UNIT_VERSION Версия ПО ККТ string
LIBFPTR_PARAM_PRINTER_CONNECTION_LOST Потеряно соединение с печатным механизмом bool
LIBFPTR_PARAM_PRINTER_ERROR Невосстановимая ошибка печатного механизма bool
LIBFPTR_PARAM_CUT_ERROR Ошибка отрезчика bool
LIBFPTR_PARAM_PRINTER_OVERHEAT Перегрев печатного механизма bool
LIBFPTR_PARAM_BLOCKED ККТ заблокирована из-за ошибок bool

Значение LIBFPTR_PARAM_CASH_DRAWER_STATUS может быть инвертировано по настройке LIBFPTR_SETTING_INVERT_CASH_DRAWER_STATUS.

Возможные значения для состояния смены (LIBFPTR_PARAM_SHIFT_STATE):

Возможные значения для типа открытого чека (LIBFPTR_PARAM_RECEIPT_TYPE):

Возможные значения для типа открытого документа (LIBFPTR_PARAM_DOCUMENT_TYPE):

Возможные значения для номера модели (LIBFPTR_PARAM_MODEL) представлены в разделе Список настроек.

Короткий запрос статуса ККТ

Короткий запрос статуса ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHORT_STATUS);
libfptr_query_data(fptr);

bool isCashDrawerOpened     = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CASHDRAWER_OPENED) != 0);
bool isPaperPresent         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT) != 0);
bool isPaperNearEnd         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PAPER_NEAR_END) != 0);
bool isCoverOpened          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COVER_OPENED) != 0);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

bool isCashDrawerOpened = fptr.getParamBool(LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent     = fptr.getParamBool(LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
bool isPaperNearEnd     = fptr.getParamBool(LIBFPTR_PARAM_PAPER_NEAR_END);
bool isCoverOpened      = fptr.getParamBool(LIBFPTR_PARAM_COVER_OPENED);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);

Для короткого запроса статуса ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHORT_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_CASHDRAWER_OPENED Денежный ящик открыт bool
LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT Наличие бумаги bool
LIBFPTR_PARAM_PAPER_NEAR_END Бумага скоро закончится. Если датчика скорого окончания бумаги в ККТ нет, то будет всегда возвращаться false bool
LIBFPTR_PARAM_COVER_OPENED Крышка открыта bool

Значение LIBFPTR_PARAM_CASH_DRAWER_STATUS может быть инвертировано по настройке LIBFPTR_SETTING_INVERT_CASH_DRAWER_STATUS.

Сумма наличных в денежном ящике

Запрос суммы наличных в денежном ящике

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASH_SUM);
libfptr_query_data(fptr);

double cashSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса суммы наличности в денежном ящике необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CASH_SUM.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма наличных в ДЯ double

Параметры массива картинок

Запрос параметров картинок

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURES_ARRAY_INFO);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

Для запроса параметров массива картинок необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PICTURES_ARRAY_INFO.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Количество картинок int

Параметры картинки в памяти

Запрос параметров картинки в памяти ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURE_INFO);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PICTURE_NUMBER, 1);
libfptr_query_data(fptr);

int width = libfptr_get_param_int(fptr, LIBFPTR_PARAM_WIDTH);
int height = libfptr_get_param_int(fptr, LIBFPTR_PARAM_HEIGHT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

uint width  = fptr.getParamInt(LIBFPTR_PARAM_WIDTH);
uint height = fptr.getParamInt(LIBFPTR_PARAM_HEIGHT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(IFptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

long width  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_WIDTH);
long height = fptr.getParamInt(IFptr.LIBFPTR_PARAM_HEIGHT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(IFptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

long width  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_WIDTH);
long height = fptr.getParamInt(IFptr.LIBFPTR_PARAM_HEIGHT);

Для запроса параметров картинки из памяти ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PICTURE_INFO и указать номер картинки в параметре LIBFPTR_PARAM_PICTURE_NUMBER.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_WIDTH Ширина картинки, пикс. int
LIBFPTR_PARAM_HEIGHT Высота картинки, пикс. int

Состояние подписки

Запрос состояния подписки

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LICENSE_ACTIVATED);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_LICENSE_NUMBER, 4);
libfptr_query_data(fptr);

bool entered = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_LICENSE_ENTERED) != 0);
int yearFrom, monthFrom, dayFrom;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_LICENSE_VALID_FROM, &yearFrom, &monthFrom, &dayFrom);
int yearUntil, monthUntil, dayUntil;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_LICENSE_VALID_UNTIL, &yearUntil, &monthUntil, &dayUntil);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

bool entered = fptr.getParamBool(LIBFPTR_PARAM_LICENSE_ENTERED);
std::tm dateFrom  = fptr.getParamDateTime(LIBFPTR_PARAM_LICENSE_VALID_FROM);
std::tm dateUntil = fptr.getParamDateTime(LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(IFptr.LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

boolean entered = fptr.getParamBool(IFptr.LIBFPTR_PARAM_LICENSE_ENTERED);
Date dateFrom   = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_FROM);
Date dateUntil  = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(IFptr.LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

boolean entered = fptr.getParamBool(IFptr.LIBFPTR_PARAM_LICENSE_ENTERED);
Date dateFrom   = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_FROM);
Date dateUntil  = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

Для запроса состояния подписки необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LICENSE_ACTIVATED и указать номер кода подписки в параметре LIBFPTR_PARAM_LICENSE_NUMBER. После выполнения метода параметр LIBFPTR_PARAM_LICENSE_ENTERED примет значение true, если подписка введена, и false, если нет.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_LICENSE_ENTERED Лицензия введена bool
LIBFPTR_PARAM_LICENSE_VALID_FROM Дата начала действия подписки datetime
LIBFPTR_PARAM_LICENSE_VALID_UNTIL Дата окончания действия подписки datetime

Если одну из дат получить не удалось, её значение будет равно 1970.01.01 00:00:00 (unixtime(0)).

Счетчики регистраций

Запрос суммы регистраций в чеках прихода (продажи)

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Запрос количества регистраций в чеках расхода (покупки)

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_COUNT);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_BUY);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_BUY);
fptr.queryData();

uint count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_BUY);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_BUY);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

Для запроса суммы регистраций необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_REGISTRATIONS_SUM и указать тип чека в параметре LIBFPTR_PARAM_RECEIPT_TYPE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма регистраций double

Для запроса количества регистраций необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_REGISTRATIONS_COUNT и указать тип чека в параметре LIBFPTR_PARAM_RECEIPT_TYPE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Количество регистраций int

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Счетчики оплат

Запрос суммы наличных платежей в чеках прихода (продажи)

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PAYMENT_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса суммы платежей за смену необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PAYMENT_SUM и указать тип чека в параметре LIBFPTR_PARAM_RECEIPT_TYPE и способ расчета в параметре LIBFPTR_PARAM_PAYMENT_TYPE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма оплат за смену double

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Способ расчета (LIBFPTR_PARAM_PAYMENT_TYPE) может принимать следующие значения:

Счетчики внесений и выплат

Запрос суммы внесений

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_SUM);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Запрос суммы выплат

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_SUM);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Запрос количества внесений

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_COUNT);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData;

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData;

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Запрос количества выплат

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_COUNT);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса суммы внесений или выплат необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CASHIN_SUM (или LIBFPTR_DT_CASHOUT_SUM соответственно).

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма внесений/выплат double

Для запроса количества внесений или выплат необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CASHIN_COUNT (или LIBFPTR_DT_CASHOUT_COUNT соответственно).

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество документов внесений/выплат int

Сумма выручки

Запрос суммы выручки

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REVENUE);
libfptr_query_data(fptr);

double revenue = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса суммы выручки необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_REVENUE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма выручки double

Текущие дата и время ККТ

Запрос текущих даты и времени ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DATE_TIME);
libfptr_query_data(fptr);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DATE_TIME);
fptr.queryData();

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса текущих даты и времени в ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_DATE_TIME.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Текущие дата и время в ККТ datetime

Состояние смены

Запрос состояния смены

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_STATE);
libfptr_query_data(fptr);

int state   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_STATE);
int number  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);
int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

uint state       = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_STATE);
uint number      = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER);
std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

long state       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long number      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
Date dateTime    = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

long state       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long number      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
Date dateTime    = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса состояния смены необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHIFT_STATE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_STATE Состояние смены int
LIBFPTR_PARAM_SHIFT_NUMBER Номер смены int
LIBFPTR_PARAM_DATE_TIME Дата и время истечения текущей смены datetime

Состояние смены (LIBFPTR_PARAM_SHIFT_STATE) может принимать следующие значения:

Значение параметра LIBFPTR_PARAM_SHIFT_NUMBER зависит от состояния смены. Если смена закрыта, то его значением будет номер последней закрытой смены. Если смена открыта или истекла, то его значением будет номер текущей смены.

Параметр LIBFPTR_PARAM_DATE_TIME имеет смысл только при открытой или истекшей смене.

Состояние чека

Запрос состояния чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_STATE);
libfptr_query_data(fptr);

int receiptType     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);
int receiptNumber   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_NUMBER);
int documentNumber  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int sum             = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPT_SUM);
int remainder       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_REMAINDER);
int change          = libfptr_get_param_double(fptr, LIBFPTR_PARAM_CHANGE);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

uint receiptType    = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_TYPE);
uint receiptNumber  = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(LIBFPTR_PARAM_CHANGE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

long receiptType    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long receiptNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CHANGE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

long receiptType    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long receiptNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CHANGE);

Для запроса состояния чека необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_STATE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_TYPE Тип чека int
LIBFPTR_PARAM_RECEIPT_NUMBER Номер чека int
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер документа int
LIBFPTR_PARAM_RECEIPT_SUM Текущая сумма чека double
LIBFPTR_PARAM_REMAINDER Неоплаченный остаток double
LIBFPTR_PARAM_CHANGE Сдача по чеку double

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Значения счетчиков LIBFPTR_PARAM_RECEIPT_NUMBER и LIBFPTR_PARAM_DOCUMENT_NUMBER не относятся к фискальному накопителю и содержат значения внутренних счетчиков ККТ. Данные счетчики могут увеличиваться вместе с печатью нефискальных и служебных документов. Для получения номеров фискальных документов нужно использовать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_LAST_DOCUMENT.

Значения параметров LIBFPTR_PARAM_RECEIPT_SUM, LIBFPTR_PARAM_REMAINDER и LIBFPTR_PARAM_CHANGE актуальны только при открытом чеке.

Заводской номер

Запрос заводского номера

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SERIAL_NUMBER);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
}
std::wstring serialNumber = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

std::wstring serialNumber = fptr.getParamString(LIBFPTR_PARAM_SERIAL_NUMBER);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

String serialNumber = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

String serialNumber = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);

Для запроса заводского номера ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SERIAL_NUMBER.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SERIAL_NUMBER Заводской номер string

Информация о модели ККТ

Запрос информации о модели ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_MODEL_INFO);
libfptr_query_data(fptr);

int model = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MODEL);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
}
std::wstring modelName = std::wstring(&str[0]);

int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring firmwareVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

uint model                   = fptr.getParamInt(LIBFPTR_PARAM_MODEL);
std::wstring modelName       = fptr.getParamString(LIBFPTR_PARAM_MODEL_NAME);
std::wstring firmwareVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

long model             = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

long model             = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

Для запроса информации о модели ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_MODEL_INFO.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_MODEL Номер модели ККТ int
LIBFPTR_PARAM_MODEL_NAME Наименование ККТ string
LIBFPTR_PARAM_UNIT_VERSION Версия ПО ККТ string

Возможные значения для номера модели (LIBFPTR_PARAM_MODEL) представлены в разделе Список настроек.

Ширина чековой ленты

Запрос ширины чековой ленты 

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_LINE_LENGTH);
libfptr_query_data(fptr);

int charLineLength  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
int pixLineLength   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

uint charLineLength = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint pixLineLength  = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

long charLineLength  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long pixLineLength   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

long charLineLength  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long pixLineLength   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

Для запроса ширины чековой ленты необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_LINE_LENGTH.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH Ширина чековой ленты, симв. int
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX Ширина чековой ленты, пикс. int

Сумма налога за смену

Запрос суммы налога НДС 10% за смену для чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_TAX_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса суммы налога за смену необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHIFT_TAX_SUM и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE и тип налога LIBFPTR_PARAM_TAX_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Тип налога (LIBFPTR_PARAM_TAX_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма налога double

Сумма налога за чек

Запрос суммы налога НДС 10% последнего чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_TAX_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса суммы налога за чек необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_TAX_SUM и указать тип налога LIBFPTR_PARAM_TAX_TYPE.

Тип налога (LIBFPTR_PARAM_TAX_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма налога double

Необнуляемая сумма

Запрос необнуляемой суммы по чекам прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Запрос необнуляемой суммы по чекам прихода по оплатам наличными

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса необнуляемой суммы необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_NON_NULLABLE_SUM и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Для запроса необнуляемой суммы по заданному типу оплаты необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Способ расчета (LIBFPTR_PARAM_PAYMENT_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Необнуляемая сумма double

Количество чеков

Запрос количества чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_COUNT);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса количества чеков необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_COUNT и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество чеков int

Количество отмененных чеков

Запрос количества отмененных чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Запрос общего количества отмененных чеков

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT_ALL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT_ALL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT_ALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT_ALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса количества отмененных чеков с заданным типом необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_COUNT и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Для запроса общего количества отмененных чеков необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_COUNT_ALL.

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество чеков int

Сумма отмененных чеков

Запрос суммы отмененных чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Запрос общей суммы отмененных чеков

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM_ALL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса суммы отмененных чеков с заданным типом необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_SUM и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Для запроса общей суммы отмененных чеков необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_SUM_ALL.

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма чеков double

Состояние источника питания

Запрос состояния аккумуляторов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_POWER_SOURCE_STATE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_POWER_SOURCE_TYPE, LIBFPTR_PST_BATTERY);
libfptr_query_data(fptr);

int charge      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage  = libfptr_get_param_double(fptr, LIBFPTR_PARAM_VOLTAGE);
bool useBattery = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_USE_BATTERY) != 0);
bool isCharging = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_BATTERY_CHARGING) != 0);
bool canPrint   = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY) != 0);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(LIBFPTR_PARAM_POWER_SOURCE_TYPE, LIBFPTR_PST_BATTERY);
fptr.queryData();

uint charge      = fptr.getParamInt(LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage   = fptr.getParamDouble(LIBFPTR_PARAM_VOLTAGE);
bool useBattery  = fptr.getParamBool(LIBFPTR_PARAM_USE_BATTERY);
bool isCharging  = fptr.getParamBool(LIBFPTR_PARAM_BATTERY_CHARGING);
bool canPrint    = fptr.getParamBool(LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(IFptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, IFptr.LIBFPTR_PST_BATTERY);
fptr.queryData();

long charge         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_VOLTAGE);
boolean useBattery  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USE_BATTERY);
boolean isCharging  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BATTERY_CHARGING);
boolean canPrint    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(IFptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, IFptr.LIBFPTR_PST_BATTERY);
fptr.queryData();

long charge         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_VOLTAGE);
boolean useBattery  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USE_BATTERY);
boolean isCharging  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BATTERY_CHARGING);
boolean canPrint    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

Для запроса состояния источника питания необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_POWER_SOURCE_STATE и указать тип источника LIBFPTR_PARAM_POWER_SOURCE_TYPE.

Тип источника (LIBFPTR_PARAM_POWER_SOURCE_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_BATTERY_CHARGE Заряд аккумулятора, проценты int
LIBFPTR_PARAM_VOLTAGE Напряжения источника питания, В. double
LIBFPTR_PARAM_USE_BATTERY Работа от аккумулятора bool
LIBFPTR_PARAM_BATTERY_CHARGING Аккумуляторы заряжаются bool
LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY ККТ может печатать при текущем заряде аккумулятора bool

Температура ТПГ

Запрос температуры ТПГ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PRINTER_TEMPERATURE);
libfptr_query_data(fptr);

int temperature = libfptr_get_param_int(fptr, LIBFPTR_PARAM_PRINTER_TEMPERATURE);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

uint temperature = fptr.getParamInt(LIBFPTR_PARAM_PRINTER_TEMPERATURE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

String temperature = fptr.getParamString(IFptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

String temperature = fptr.getParamString(IFptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE);

Для запроса температуры ТПГ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PRINTER_TEMPERATURE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_PRINTER_TEMPERATURE Температура ТПГ, градусы Цельсия int

MAC-адрес Ethernet

Запрос MAC-адреса Ethernet

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_MAC_ADDRESS);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MAC_ADDRESS, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_MAC_ADDRESS, &str[0], str.size());
}
std::wstring mac = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_MAC_ADDRESS);
fptr.queryData();

std::wstring mac = fptr.getParamString(LIBFPTR_PARAM_MAC_ADDRESS);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MAC_ADDRESS);
fptr.queryData();

String mac = fptr.getParamString(IFptr.LIBFPTR_PARAM_MAC_ADDRESS);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MAC_ADDRESS);
fptr.queryData();

String mac = fptr.getParamString(IFptr.LIBFPTR_PARAM_MAC_ADDRESS);

Для запроса MAC-адреса Ethernet необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_MAC_ADDRESS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_MAC_ADDRESS MAC-адрес string

Время работы ККТ

Запрос времени работы ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DEVICE_UPTIME);
libfptr_query_data(fptr);

uint uptime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DEVICE_UPTIME);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DEVICE_UPTIME);
fptr.queryData();

uint uptime = fptr.getParamInt(LIBFPTR_PARAM_DEVICE_UPTIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DEVICE_UPTIME);
fptr.queryData();

long uptime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_UPTIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DEVICE_UPTIME);
fptr.queryData();

long uptime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_UPTIME);

Для запроса времени работы ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_DEVICE_UPTIME.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DEVICE_UPTIME Время работы ККТ, с. int

Суммы скидок и надбавок за смену

Запрос сумм скидок и надбавок за смену

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM);
libfptr_query_data(fptr);

double discountSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SURCHARGE_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM);
fptr.queryData();

double discountSum = fptr.getParamDouble(LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = fptr.getParamDouble(LIBFPTR_PARAM_SURCHARGE_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM);
fptr.queryData();

double discountSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SURCHARGE_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM);
fptr.queryData();

double discountSum  = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SURCHARGE_SUM);

Для сумм скидок и надбавок за смену необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DISCOUNT_SUM Сумма скидок за смену double
LIBFPTR_PARAM_SURCHARGE_SUM Сумма надбавок за смену double

Код привязки к личному кабинету

Запрос кода привязки к ЛК

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LK_USER_CODE);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_LK_USER_CODE, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_LK_USER_CODE, &str[0], str.size());
}
std::wstring codeLK = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LK_USER_CODE);
fptr.queryData();

std::wstring codeLK = fptr.getParamString(LIBFPTR_PARAM_LK_USER_CODE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LK_USER_CODE);
fptr.queryData();

String codeLK = fptr.getParamString(IFptr.LIBFPTR_PARAM_LK_USER_CODE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LK_USER_CODE);
fptr.queryData();

String codeLK = fptr.getParamString(IFptr.LIBFPTR_PARAM_LK_USER_CODE);

Для запроса кода привязки ККТ к ЛК необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LK_USER_CODE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_LK_USER_CODE Код привязки к ЛК string

Дата и время последней успешной отправки документа в ОФД

Запрос даты и времени последней успешной отправки документа в ОФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME);
libfptr_query_data(fptr);

int year, month, day, hour, minute, second;
ibfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME);
fptr.queryData();

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса даты и времени последней успешной отправки документа в ОФД необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Дата и время последней успешной отправки документа в ОФД datetime

Сменный итог

Запрос сменного итога по чекам прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_TOTALS);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_TOTALS);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TOTALS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TOTALS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

Для запроса сменного итога необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHIFT_TOTALS и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма налога double

Параметры шрифта

Запрос параметров шрифта

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_FONT_INFO);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_FONT, 1);
libfptr_query_data(fptr);

int lineLength = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
int fontWidth  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FONT_WIDTH);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_FONT_INFO);
fptr.setParam(LIBFPTR_PARAM_FONT, 1);
fptr.queryData();

uint lineLength = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint fontWidth = fptr.getParamInt(LIBFPTR_PARAM_FONT_WIDTH);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_FONT_INFO);
fptr.setParam(IFptr.LIBFPTR_PARAM_FONT, 1);
fptr.queryData();

long lineLength = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long fontWidth = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FONT_WIDTH);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_FONT_INFO);
fptr.setParam(IFptr.LIBFPTR_PARAM_FONT, 1);
fptr.queryData();

long lineLength = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long fontWidth  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FONT_WIDTH);

Для запроса параметров шрифта необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_FONT_INFO и указать номер шрифта в параметре LIBFPTR_PARAM_FONT.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH Ширина чековой ленты для данного шрифта, симв. int
LIBFPTR_PARAM_FONT_WIDTH Ширина символа данного шрифта, пикс. int

Дата и время последней успешной отправки уведомления в ИСМ

Запрос даты и времени последней успешной отправки уведомления в ИСМ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LAST_SENT_ISM_NOTICE_DATE_TIME);
libfptr_query_data(fptr);

int year, month, day, hour, minute, second;
ibfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LAST_SENT_ISM_NOTICE_DATE_TIME);
fptr.queryData();

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LAST_SENT_ISM_NOTICE_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LAST_SENT_ISM_NOTICE_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса даты и времени последней успешной отправки уведомления в ИСМ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LAST_SENT_ISM_NOTICE_DATE_TIME.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Дата и время последней успешной отправки уведомления в ИСМ datetime

Статус информационного обмена с личным кабинетом

Запрос статуса информационного обмена с личным кабинетом

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LK_EXCHANGE_STATUS);
libfptr_query_data(fptr);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);
int connect_year, connect_month, connect_day, connect_hour, connect_minute, connect_second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_CONNECT_DATE_TIME, &connect_year, &connect_month, &connect_day, &connect_hour, &connect_minute, &connect_second);
int submode = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SUBMODE);
int error = libfptr_get_param_int(fptr, LIBFPTR_PARAM_NETWORK_ERROR);
bool is_connect = libfptr_get_param_bool(fptr, LIBFPTR_PARAM_IS_REQUEST_SENT);
std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_NETWORK_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_NETWORK_ERROR_TEXT, &str[0], str.size());
}
std::wstring error_text = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LK_EXCHANGE_STATUS);
fptr.queryData();

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);
std::tm connect_date_time = fptr.getParamDateTime(LIBFPTR_PARAM_CONNECT_DATE_TIME);
int submode = fptr.getParamInt(LIBFPTR_PARAM_SUBMODE);
int error = fptr.getParamInt(LIBFPTR_PARAM_NETWORK_ERROR);
std::wstring error_text = fptr.getParamString(LIBFPTR_PARAM_NETWORK_ERROR_TEXT);
bool is_connect = fptr.getParamBool(LIBFPTR_PARAM_IS_REQUEST_SENT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LK_EXCHANGE_STATUS);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);
Date connectDateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_CONNECT_DATE_TIME);
long submode = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SUBMODE);
long error = fptr.getParamInt(IFptr.LIBFPTR_PARAM_NETWORK_ERROR);
String error_text = fptr.getParamString(IFptr.LIBFPTR_PARAM_NETWORK_ERROR_TEXT);
Boolean is_connect = fptr.getParamBool(IFptr.LIBFPTR_PARAM_IS_REQUEST_SENT);

Для запроса информации о работе с личным кабинетом и диагностики связи необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LK_EXCHANGE_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Время последней синхронизации datetime
LIBFPTR_PARAM_CONNECT_DATE_TIME Время последней попытки подключения datetime
LIBFPTR_PARAM_SUBMODE Этап работы с личным кабинетом int
LIBFPTR_PARAM_NETWORK_ERROR Код ошибки связи int
LIBFPTR_PARAM_NETWORK_ERROR_TEXT Текстовое описание ошибки связи string
LIBFPTR_PARAM_IS_REQUEST_SENT Результат проверки bool

Тип чека (LIBFPTR_PARAM_SUBMODE) может принимать следующие значения:

Регистрация кассира

Регистрация кассира

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr); 

fptr.setParam(1021, L"Кассир Иванов И.");
fptr.setParam(1203, L"123456789047");
fptr.operatorLogin();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

Для регистрации кассира необходимо вызвать метод operatorLogin().

Операции со сменой

Открыть смену

Открытие смены

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr);

libfptr_open_shift(fptr);

libfptr_check_document_closed();

fptr.setParam(1021, L"Кассир Иванов И.");
fptr.setParam(1203, L"123456789047");
fptr.operatorLogin();

fptr.openShift();

fptr.checkDocumentClosed();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.openShift();

fptr.checkDocumentClosed();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.openShift();

fptr.checkDocumentClosed();
// ...

Для открытия смены необходимо вызвать метод openShift(). Метод возвращает ошибку, если смена уже открыта. Открывать смену необязательно, т.к. она будет открыта первой фискальной операцией автоматически.

На некоторых ККТ возможно отключить печать отчета об открытии смены с помощью установки параметра LIBFPTR_PARAM_REPORT_ELECTRONICALLY в true. Если ККТ не поддерживает такой функционал, параметр будет проигнорирован и отчет будет напечатан.

Закрыть смену

Закрытие смены

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_CLOSE_SHIFT);
libfptr_report(fptr);

libfptr_check_document_closed();

fptr.setParam(1021, L"Кассир Иванов И.");
fptr.setParam(1203, L"123456789047");
fptr.operatorLogin();

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_CLOSE_SHIFT);
fptr.report();

fptr.checkDocumentClosed();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_CLOSE_SHIFT);
fptr.report();

fptr.checkDocumentClosed();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_CLOSE_SHIFT);
fptr.report();

fptr.checkDocumentClosed();
// ...

Для закрытия смены требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_CLOSE_SHIFT Автоматически может напечататься так же и Z-отчет.

На некоторых ККТ возможно отключить печать отчета о закрытии смены с помощью установки параметра LIBFPTR_PARAM_REPORT_ELECTRONICALLY в true. Если ККТ не поддерживает такой функционал, параметр будет проигнорирован и отчет будет напечатан.

Операции с чеком

Общий алгоритм формирования чека

Формирование чека состоит из следующих операций:

Открыть чек

Открытие печатного чека

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr); 

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_open_receipt(fptr);

fptr.setParam(1021, L"Кассир Иванов И.");
fptr.setParam(1203, L"123456789047");
fptr.operatorLogin();

fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.openReceipt();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.openReceipt();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.openReceipt();

Открытие электронного чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_bool(fptr, LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
libfptr_open_receipt(fptr);

fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
fptr.openReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
fptr.openReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
fptr.openReceipt();

Открытие чека коррекции прихода (ФФД 1.05)

libfptr_set_param_datetime(fptr, 1178, 2018, 1, 2, 0, 0, 0);
libfptr_set_param_str(fptr, 1179, L"№1234");
libfptr_util_form_tlv(fptr);

std::vector<uchar> correctionInfo(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                       &correctionInfo[0], correctionInfo.size());
if (size > correctionInfo.size())
{
    correctionInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                &correctionInfo[0], correctionInfo.size());
}
correctionInfo.resize(size);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL_CORRECTION);
libfptr_set_param_int(fptr, 1173, 1);
libfptr_set_param_bytearray(fptr, 1174, &correctionInfo[0], correctionInfo.size());
libfptr_open_receipt(fptr);

fptr.setParam(1178, std::tm{.tm_mday = 2, .tm_mon = 0, .tm_year = 2018 - 1900});
fptr.setParam(1179, L"№1234");
fptr.utilFormTlv();

std::vector<uchar> correctionInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL_CORRECTION);
fptr.setParam(1173, 1);
fptr.setParam(1174, correctionInfo);
fptr.openReceipt()

Calendar c = Calendar.getInstance();
c.set(2018, 1, 2);
fptr.setParam(1178, c.getTime());
fptr.setParam(1179, "№1234");
fptr.utilFormTlv();
byte[] correctionInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL_CORRECTION);
fptr.setParam(1173, 1);
fptr.setParam(1174, correctionInfo);
fptr.openReceipt();

Calendar c = Calendar.getInstance();
c.set(2018, 1, 2);
fptr.setParam(1178, c.getTime());
fptr.setParam(1179, "№1234");
fptr.utilFormTlv();
byte[] correctionInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL_CORRECTION);
fptr.setParam(1173, 1);
fptr.setParam(1174, correctionInfo);
fptr.openReceipt();

Открытие чека со сведениями о покупателе (ФФД 1.2)

libfptr_set_param_str(fptr, 1227, L"Покупатель А");
libfptr_set_param_str(fptr, 1228, L"112233445573");
libfptr_util_form_tlv(fptr);

std::vector<uchar> clientInfo(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                       &clientInfo[0], clientInfo.size());
if (size > clientInfo.size())
{
    clientInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                &clientInfo[0], clientInfo.size());
}
clientInfo.resize(size);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_bytearray(fptr, 1256, &clientInfo[0], clientInfo.size());
libfptr_open_receipt(fptr);

fptr.setParam(1227, L"Покупатель А");
fptr.setParam(1228, L"112233445573");
fptr.utilFormTlv();

std::vector<uchar> clientInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(1256, clientInfo);
fptr.openReceipt();

fptr.setParam(1227, "Покупатель А");
fptr.setParam(1228, "112233445573");
fptr.utilFormTlv();
byte[] clientInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(1256, clientInfo);
fptr.openReceipt();

fptr.setParam(1227, "Покупатель А");
fptr.setParam(1228, "112233445573");
fptr.utilFormTlv();
byte[] clientInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(1256, clientInfo);
fptr.openReceipt();

Открытие чека с отраслевым реквитом чека (тег 1261, ФФД 1.2)

libfptr_set_param_str(fptr, 1262, L"020");
libfptr_set_param_str(fptr, 1263, L"14.12.2018");
libfptr_set_param_str(fptr, 1264, L"1556");
libfptr_set_param_str(fptr, 1265, L"tm=mdlp&sid=00000000105200");
libfptr_util_form_tlv(fptr);

std::vector<uchar> industryInfo(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE,
&industryInfo[0], industryInfo.size());
if (size > industryInfo.size())
{
industryInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE,
    &industryInfo[0], industryInfo.size());
}
industryInfo.resize(size);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_bytearray(fptr, 1261, &industryInfo[0]. industryInfo.size());
libfptr_open_receipt(fptr);

fptr.setParam(1262, L"020");
fptr.setParam(1263, L"14.12.2018");
fptr.setParam(1264, L"1556");
fptr.setParam(1265, L"tm=mdlp&sid=00000000105200");
fptr.utilFormTlv();

std::vector<uchar> industryInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(1261, industryInfo);
fptr.openReceipt();

fptr.setParam(1262, "020");
fptr.setParam(1263, "14.12.2018");
fptr.setParam(1264, "1556");
fptr.setParam(1265, "tm=mdlp&sid=00000000105200");
fptr.utilFormTlv();

byte[] industryInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(1261, industryInfo);
fptr.openReceipt();

fptr.setParam(1262, "020");
fptr.setParam(1263, "14.12.2018");
fptr.setParam(1264, "1556");
fptr.setParam(1265, "tm=mdlp&sid=00000000105200");
fptr.utilFormTlv();

byte[] industryInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(1261, industryInfo);
fptr.openReceipt();

Для открытия чека требуется вызвать метод openReceipt() с указанием типа чека (параметр LIBFPTR_PARAM_RECEIPT_TYPE).

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Чтобы чек не печатался (электронный чек), нужно установить параметру LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY значение true.

Также в данном методе можно передать следующие реквизиты (для всех чеков, кроме чеков коррекции):

Параметр Описание Тип
1008 Электронный адрес / телефон получателя string
1117 Электронный адрес отправителя чека string
1055 Применяемая система налогообложения (СНО) int
1187 Место расчета string
1060 Адрес сайта ФНС string
1084 Дополнительный реквизит пользователя bytearray
1192 Дополнительный реквизит чека (БСО) string
1256 Сведения о покупателе (клиенте) bytearray
1261 Отраслевой реквизит чека bytearray
1270 Операционный реквизит чека bytearray

Реквизит 1256 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1227 Покупатель (клиент) string
1228 ИНН покупателя (клиента) string
1243 Дата рождения покупателя (клиента) string
1244 Гражданство string
1245 Код вида документа, удостоверяющего личность string
1246 Данные документа, удостоверяющего личность string
1254 Адрес покупателя (клиента) string

Реквизит 1261 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1262 Идентификатор ФОИВ string
1263 Дата документа основания datetime
1264 Номер документа основания string
1265 Значение отраслевого реквизита string

Реквизит 1270 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1271 Идентификатор операции int
1272 Данные операции string
1273 Дата и время операции datetime

Реквизит 1084 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1085 Наименование дополнительного реквизита пользователя string
1086 Значение дополнительного реквизита пользователя string

Реквизит 1055 может принимать следующие значения:

Для чеков коррекций допустимы следующие реквизиты:

Реквизит Описание Тип
1055 Применяемая система налогообложения int
1173 Тип коррекции int
1174 Основание для коррекции bytearray

Реквизит 1174 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1178 Дата совершения корректируемого расчета datetime
1179 Номер предписания налогового органа string

Результатом команды будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_AUTO_OPENED true, если при выполнении операции была автоматически открыта смена в ККТ bool

Отменить чек

Отмена чека

libfptr_cancel_receipt(fptr);

fptr.cancelReceipt();

fptr.cancelReceipt();

fptr.cancelReceipt();

Для отмены чека требуется вызвать метод cancelReceipt().

Зарегистрировать позицию

Регистрация позиции без указания суммы налога

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT0);
libfptr_registration(fptr);

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
fptr.setParam(LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT0);
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.registration();

Регистрация позиции с указанием суммы налога

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 51.5);
libfptr_registration(fptr);

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
fptr.setParam(LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.registration();

Регистрация позиции без расчета суммы налога

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
libfptr_registration(fptr);

// ...

libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 78.56);
libfptr_receipt_tax(fptr);

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
fptr.setParam(LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT0);
fptr.setParam(LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
fptr.registration();

// ...

fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(LIBFPTR_PARAM_TAX_SUM, 78.56);
fptr.receiptTax();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.setParam(IFptr.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
fptr.registration();

// ...

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 78.56);
fptr.receiptTax();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.setParam(IFptr.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
fptr.registration();

// ...

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 78.56);
fptr.receiptTax();

Регистрация позиции с кодом маркировки

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 51.5);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT_EGAIS_20);
uchar mark[] = {<массив байт от сканера>};
libfptr_set_param_bytearray(fptr, LIBFPTR_PARAM_MARKING_CODE, &mark[0], sizeof(mark));
libfptr_registration(fptr);

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
fptr.setParam(LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT_EGAIS_20);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE, {<массив байт от сканера>});
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT_EGAIS_20);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, new byte[]{<массив байт от сканера>});
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT_EGAIS_20);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, new byte[]{<массив байт от сканера>});
fptr.registration();

Регистрация позиции с кодом товара (1162)

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 51.5);
uchar code[] = {<массив байт реквизита 1162>};
libfptr_set_param_bytearray(fptr, 1162, &code[0], sizeof(code));
libfptr_registration(fptr);

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
fptr.setParam(LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.setParam(1162, {<массив байт реквизита 1162>});
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.setParam(1162, new byte[]{<массив байт реквизита 1162>});
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.setParam(1162, new byte[]{<массив байт реквизита 1162>});
fptr.registration();

Регистрация позиции с агентом и поставщиком

libfptr_set_param_str(fptr, 1005, L"Улица Свободы, д.1");
libfptr_set_param_str(fptr, 1016, L"123456789047");
libfptr_set_param_str(fptr, 1026, L"ООО Оператор");
libfptr_set_param_str(fptr, 1075, L"+79161234567");
libfptr_set_param_str(fptr, 1075, L"+79169876543");
libfptr_util_form_tlv(fptr);

std::vector<uchar> agentInfo(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                       &agentInfo[0], agentInfo.size());
if (size > agentInfo.size())
{
    agentInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                &agentInfo[0], agentInfo.size());
}
agentInfo.resize(size);

libfptr_set_param_str(fptr, 1171, L"+79113456789");
libfptr_set_param_str(fptr, 1225, L"ООО Поставщик");
libfptr_util_form_tlv(fptr);

std::vector<uchar> suplierInfo;
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                       &suplierInfo[0], suplierInfo.size());
if (size > suplierInfo.size())
{
    suplierInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, 
                                &suplierInfo[0], suplierInfo.size());
}
suplierInfo.resize(size);

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_int(fptr, 1222, LIBFPTR_AT_ANOTHER);
libfptr_set_param_bytearray(fptr, 1223, &agentInfo[0]. agentInfo.size());
libfptr_set_param_str(fptr, 1226, L"123456789047");
libfptr_set_param_bytearray(fptr, 1224, &suplierInfo[0]. suplierInfo.size());
libfptr_registration(fptr);

fptr.setParam(1005, L"Улица Свободы, д.1");
fptr.setParam(1016, L"123456789047");
fptr.setParam(1026, L"ООО Оператор");
fptr.setParam(1075, L"+79161234567");
fptr.setParam(1075, L"+79169876543");
fptr.utilFormTlv();
std::vector<uchar> agentInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1171, L"+79113456789");
fptr.setParam(1225, L"ООО Поставщик");
fptr.utilFormTlv();
std::vector<uchar> suplierInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
fptr.setParam(LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(1222, LIBFPTR_AT_ANOTHER);
fptr.setParam(1223, agentInfo);
fptr.setParam(1226, L"123456789047");
fptr.setParam(1224, suplierInfo);
fptr.registration();

fptr.setParam(1005, "Улица Свободы, д.1");
fptr.setParam(1016, "123456789047");
fptr.setParam(1026, "ООО Оператор");
fptr.setParam(1075, "+79161234567");
fptr.setParam(1075, "+79169876543");
fptr.utilFormTlv();
byte[] agentInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1171, "+79113456789");
fptr.setParam(1225, "ООО Поставщик");
fptr.utilFormTlv();
byte[] suplierInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(1222, IFptr.LIBFPTR_AT_ANOTHER);
fptr.setParam(1223, agentInfo);
fptr.setParam(1226, "123456789047");
fptr.setParam(1224, suplierInfo);
fptr.registration();

fptr.setParam(1005, "Улица Свободы, д.1");
fptr.setParam(1016, "123456789047");
fptr.setParam(1026, "ООО Оператор");
fptr.setParam(1075, "+79161234567");
fptr.setParam(1075, "+79169876543");
fptr.utilFormTlv();
byte[] agentInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1171, "+79113456789");
fptr.setParam(1225, "ООО Поставщик");
fptr.utilFormTlv();
byte[] suplierInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(1222, IFptr.LIBFPTR_AT_ANOTHER);
fptr.setParam(1223, agentInfo);
fptr.setParam(1226, "123456789047");
fptr.setParam(1224, suplierInfo);
fptr.registration();

Регистрация позиции с отраслевым реквизитом предмета расчета (тег 1260, ФФД 1.2)

const wchar_t mark[] = L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
uint status = 2;

libfptr_set_param_str(fptr, 1262, L"020");
libfptr_set_param_str(fptr, 1263, L"14.12.2018");
libfptr_set_param_str(fptr, 1264, L"1556");
libfptr_set_param_str(fptr, 1265, L"tm=mdlp&sid=00000000105200");
libfptr_util_form_tlv(fptr);

std::vector<uchar> industryInfo(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE,
&industryInfo[0], industryInfo.size());
if (size > industryInfo.size())
{
industryInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE,
    &industryInfo[0], industryInfo.size());
}
industryInfo.resize(size);

uint validationResult = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Афобазол");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 450);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 1.000);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MEASUREMENT_UNIT, LIBFPTR_IU_PIECE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_int(fptr, 1212, 33);
libfptr_set_param_int(fptr, 1214, 4);
libfptr_set_param_bytearray(fptr, 1260, &industryInfo[0]. industryInfo.size());
libfptr_set_param_bytearray(fptr, LIBFPTR_PARAM_MARKING_CODE, mark);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT12_AUTO);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
libfptr_registration(fptr);

std::wstring mark = L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
uint status = 2;

fptr.setParam(1262, L"020");
fptr.setParam(1263, L"14.12.2018");
fptr.setParam(1264, L"1556");
fptr.setParam(1265, L"tm=mdlp&sid=00000000105200");
fptr.utilFormTlv();

std::vector<uchar> industryInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);
uint validationResult = fptr.getParamInt(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, L"Афобазол");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 450);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(1212, 33);
fptr.setParam(1214, 4);
fptr.setParam(1260, industryInfo);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT12_AUTO);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.registration();

String mark = "014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
long status = 2;

fptr.setParam(1262, "020");
fptr.setParam(1263, "14.12.2018");
fptr.setParam(1264, "1556");
fptr.setParam(1265, "tm=mdlp&sid=00000000105200");
fptr.utilFormTlv();

byte[] industryInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);
long validationResult = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Афобазол");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 450);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(1212, 33);
fptr.setParam(1214, 4);
fptr.setParam(1260, industryInfo);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT12_AUTO);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.registration();

String mark = "014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
long status = 2;

fptr.setParam(1262, "020");
fptr.setParam(1263, "14.12.2018");
fptr.setParam(1264, "1556");
fptr.setParam(1265, "tm=mdlp&sid=00000000105200");
fptr.utilFormTlv();

byte[] industryInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);
long validationResult = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Афобазол");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 450);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(1212, 33);
fptr.setParam(1214, 4);
fptr.setParam(1260, industryInfo);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT12_AUTO);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.registration();

Регистрация позиции с кодами товаров без указания типа (тег 1163, ФФД 1.2)

...
libfptr_set_param_str(fptr, LIBFPTR_PARAM_PRODUCT_CODE, L"61940017");       //EAN-8
libfptr_set_param_str(fptr, LIBFPTR_PARAM_PRODUCT_CODE, L"6199000000012");  //EAN-13
libfptr_set_param_str(fptr, LIBFPTR_PARAM_PRODUCT_CODE, L"14841234567890"); //ITF-14
libfptr_registration(fptr);

...
fptr.setParam(LIBFPTR_PARAM_PRODUCT_CODE, L"61940017");         //EAN-8
fptr.setParam(LIBFPTR_PARAM_PRODUCT_CODE, L"6199000000012");    //EAN-13
fptr.setParam(LIBFPTR_PARAM_PRODUCT_CODE, L"14841234567890");   //ITF-14
fptr.registration();

...
fptr.setParam(IFptr.LIBFPTR_PARAM_PRODUCT_CODE, "61940017");         //EAN-8
fptr.setParam(IFptr.LIBFPTR_PARAM_PRODUCT_CODE, "6199000000012");    //EAN-13
fptr.setParam(IFptr.LIBFPTR_PARAM_PRODUCT_CODE, "14841234567890");   //ITF-14
fptr.registration();

...
fptr.setParam(IFptr.LIBFPTR_PARAM_PRODUCT_CODE, "61940017");         //EAN-8
fptr.setParam(IFptr.LIBFPTR_PARAM_PRODUCT_CODE, "6199000000012");    //EAN-13
fptr.setParam(IFptr.LIBFPTR_PARAM_PRODUCT_CODE, "14841234567890");   //ITF-14
fptr.registration();

Регистрация позиции с кодами товаров с указанием типа (тег 1163, ФФД 1.2)

...
libfptr_set_param_str(fptr, 1301, L"61940017");       //EAN-8
libfptr_set_param_str(fptr, 1302, L"6199000000012");  //EAN-13
libfptr_set_param_str(fptr, 1303, L"14841234567890"); //ITF-14
libfptr_registration(fptr);

...
fptr.setParam(1301, L"61940017");         //EAN-8
fptr.setParam(1302, L"6199000000012");    //EAN-13
fptr.setParam(1303, L"14841234567890");   //ITF-14
fptr.registration();

...
fptr.setParam(1301, "61940017");         //EAN-8
fptr.setParam(1302, "6199000000012");    //EAN-13
fptr.setParam(1303, "14841234567890");   //ITF-14
fptr.registration();

...
fptr.setParam(1301, "61940017");         //EAN-8
fptr.setParam(1302, "6199000000012");    //EAN-13
fptr.setParam(1303, "14841234567890");   //ITF-14
fptr.registration();

Для регистрации позиции требуется вызвать метод registration().

Обязательными входными параметрами для метода являются:

При передаче только этих параметров будет произведена регистрация товара с расчетом полной суммы позиции и суммы налога на стороне ККТ.

Ниже представлен список дополнительных параметров позиции (могут не поддерживаться в ККТ - в этом случае будет выдана ошибка):

Также в данном методе можно передать следующие реквизиты ФН:

Реквизит Описание Тип
1191 Дополнительный реквизит предмета расчета string
1197 Единицы измерения предмета расчета string
2108 Мера количества предмета расчета int
1212 Признак предмета расчета int
1214 Признак способа расчета int
1222 Признак агента по предмету расчета int
1223 Данные агента bytearray
1224 Данные поставщика bytearray
1226 ИНН поставщика string
1229 Акциз double
1230 Код страны происхождения товара string
1231 Номер таможенной декларации string
1260 Отраслевой реквизит предмета расчета bytearray

Реквизит 1260 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1262 Идентификатор ФОИВ string
1263 Дата документа основания datetime
1264 Номер документа основания string
1265 Значение отраслевого реквизита string

Реквизит 1222 может принимать следующие значения:

Реквизит 1223 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1005 Адрес оператора перевода string
1016 ИНН оператора перевода string
1026 Наименование оператора перевода string
1044 Операция банковского платежного агента string
1073 Телефон платежного агента (может повторяться несколько раз) string
1074 Телефон оператора по приему платежей (может повторяться несколько раз) string
1075 Телефон оператора перевода (может повторяться несколько раз) string

Реквизит 1224 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1171 Телефон поставщика (может повторяться несколько раз) string
1225 Наименование поставщика string

В позицию также можно передать коды товара (реквизит 1163), при этом сам реквизит 1163 формировать не требуется, коды товара подаются одним из следующих способов:

Комбинировать данные способы запрещено! То есть необходимо подать либо все коды товара с заданным типом, либо с автоопределением.

Используемые коды товара описаны ниже:

Реквизит Описание Тип
1300 Нераспознанный код товара string
1301 КТ EAN-8 string
1302 КТ EAN-13 string
1303 КТ ITF-14 string
1304 КТ GS1.0 string
1305 КТ GS1.M string
1306 КТ КМК (короткий маркировочный код) string
1307 КТ МИ (меховые изделия) string
1308 КТ ЕГАИС-2.0 string
1309 КТ ЕГАИС-3.0 string
1320 КТ Ф.1 string
1321 КТ Ф.2 string
1322 КТ Ф.3 string
1323 КТ Ф.4 string
1324 КТ Ф.5 string
1325 КТ Ф.6 string

Зарегистрировать оплату

Оплата чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
libfptr_payment(fptr);

fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
fptr.setParam(LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
fptr.payment();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
fptr.payment();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
fptr.payment();

Для регистрации оплаты чека требуется вызвать метод payment(), передав способ расчета в параметре LIBFPTR_PARAM_PAYMENT_TYPE и сумму расчета в параметре LIBFPTR_PARAM_PAYMENT_SUM.

Способ расчета (LIBFPTR_PARAM_PAYMENT_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_REMAINDER Неоплаченный остаток чека double
LIBFPTR_PARAM_CHANGE Сдача по чеку double

Зарегистрировать налог на чек

Регистрация налога на чек

libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 100.00);
libfptr_receipt_tax(fptr);

fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(LIBFPTR_PARAM_TAX_SUM, 100.00);
fptr.receiptTax();

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 100.00);
fptr.receiptTax();

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 100.00);
fptr.receiptTax();

Для регистрации налога на чек требуется вызвать метод receiptTax(), передав тип налога в параметре LIBFPTR_PARAM_TAX_TYPE и сумму налога в параметре LIBFPTR_PARAM_TAX_SUM.

Тип налога (LIBFPTR_PARAM_TAX_TYPE) может принимать следующие значения:

Закрыть чек

Закрытие частично оплаченного или неоплаченного чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_ELECTRONICALLY);
libfptr_close_receipt(fptr);

fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_ELECTRONICALLY);
fptr.closeReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_ELECTRONICALLY);
fptr.closeReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_ELECTRONICALLY);
fptr.closeReceipt();

Закрытие полностью оплаченного чека

libfptr_close_receipt(fptr);

fptr.closeReceipt();

fptr.closeReceipt();

fptr.closeReceipt();

Для закрытия чека требуется вызвать метод closeReceipt().

Если чек оплачен не полностью или не оплачен совсем (не зарегистрирована ни одна оплата), то чек будет автоматически оплачен / доплачен заданным в параметре LIBFPTR_PARAM_PAYMENT_TYPE типом оплаты и закрыт. Если в этом случае способ расчета не передан, будет использован наличный способ расчета (LIBFPTR_PT_CASH). Если чек уже полностью оплачен, то значение параметра LIBFPTR_PARAM_PAYMENT_TYPE ни на что не влияет.

Проверить закрытие документа

Проверка закрытия документа (на примере закрытия фискального чека)

// Вспомогательная функция для чтения текста ошибки
std::wstring getErrorDescription(libfptr_handle fptr)
{
    std::vector<wchar_t> str(32);
    int size = libfptr_error_description(fptr, &str[0], str.size());
    if (size > str.size())
    {
        str.resize(size);
        libfptr_error_description(fptr, &str[0], str.size());
    }
    return std::wstring(&str[0]);
}

libfptr_close_receipt(fptr);

while (libfptr_check_document_closed(fptr) < 0) {
  // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
  std::wcout << getErrorDescription(fptr) << std::endl;
  continue;
}

if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_DOCUMENT_CLOSED) == 0) {
  // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
  libfptr_cancel_receipt(fptr);
  return;
}

if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_DOCUMENT_PRINTED) == 0) {
  // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
  while (libfptr_continue_print(fptr) < 0) {
    // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
    std::wcout << L"Не удалось напечатать документ (Ошибка \"" << getErrorDescription(fptr) << L"\"). Устраните неполадку и повторите." << std::endl; 
    continue;
  }
}

fptr.closeReceipt();

while (fptr.checkDocumentClosed() < 0)
{
  // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
  std::wcout << fptr.errorDescription(fptr) << std::endl;
  continue;
}

if (!fptr.getParamBool(LIBFPTR_PARAM_DOCUMENT_CLOSED))
{  
  // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
  fptr.cancelReceipt();
  return;
}

if (!fptr.getParamBool(LIBFPTR_PARAM_DOCUMENT_PRINTED))
{
  // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
  while (fptr.continuePrint() < 0)
  {
    // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
    std::wcout << L"Не удалось напечатать документ (Ошибка \"" << fptr.errorDescription() << L"\"). Устраните неполадку и повторите." << std::endl; 
    continue;
  }
}

fptr.closeReceipt();

while (fptr.checkDocumentClosed() < 0) {
    // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
    System.out.println(fptr.errorDescription());
    continue;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_CLOSED)) {
    // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
    fptr.cancelReceipt();
    return;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_PRINTED)) {
    // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
    while (fptr.continuePrint() < 0) {
        // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
        System.out.println(String.format("Не удалось напечатать документ (Ошибка \"%s\"). Устраните неполадку и повторите.", fptr.errorDescription()));
        continue;
    }
}

fptr.closeReceipt();

while (fptr.checkDocumentClosed() < 0) {
    // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
    Log.d(TAG, fptr.errorDescription());
    continue;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_CLOSED)) {
    // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
    fptr.cancelReceipt();
    return;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_PRINTED)) {
    // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
    while (fptr.continuePrint() < 0) {
        // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
        Log.d(TAG, String.format("Не удалось напечатать документ (Ошибка \"%s\"). Устраните неполадку и повторите.", fptr.errorDescription()));
        continue;
    }
}

В ряде ситуаций (окончание бумаги, потеря связи с ККТ в момент регистрации документа) состояние документа остается неизвестным. Он может закрыться в ФН (что является необратимой операцией), но не напечататься на чековой ленте. Данный метод сверяет счетчики ККТ с сохраненными до закрытия документа копиями и вычисляет, закрылся ли он, а также проверяет состояние печати документа.

Метод применим для следующих типов документов:

Если какой-то из документов формируется автоматически (например, открытие смены при формировании первого чека в смене), то метод checkDocumentClosed() его учитывать не будет.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENT_CLOSED Документ закрылся bool
LIBFPTR_PARAM_DOCUMENT_PRINTED Документ допечатался bool

Работа с марками в ФФД 1.2

Дополнительные настройки

В драйвер добавлена дополнительная настройка LIBFPTR_SETTING_VALIDATE_MARK_WITH_FNM_ONLY, позволяющая проводить проверку КМ средствами драйвера.

Проверка КМ

const wchar_t mark[] = L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
uint status = 2;

// Запускаем проверку КМ
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT12_AUTO);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_MARKING_CODE, mark);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 1.000);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MEASUREMENT_UNIT, LIBFPTR_IU_PIECE);
libfptr_set_param_bool(fptr, LIBFPTR_PARAM_MARKING_WAIT_FOR_VALIDATION_RESULT, true);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
libfptr_begin_marking_code_validation(fptr);

// Дожидаемся окончания проверки и запоминаем результат
while (true) {
    libfptr_get_marking_code_validation_status(fptr);
    if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY))
        break;
}
uint validationResult = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);

// Подтверждаем реализацию товара с указанным КМ
libfptr_accept_marking_code(fptr);

// ... Проверяем остальные КМ

// Формируем чек
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_open_receipt(fptr);

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Молоко");
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PRICE, 80);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 1.000);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MEASUREMENT_UNIT, LIBFPTR_IU_PIECE);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_int(fptr, 1212, 1);
libfptr_set_param_int(fptr, 1214, 7);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_MARKING_CODE, mark);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
libfptr_registration(fptr);

// ... Регистрируем остальные позиции

libfptr_set_param_int(fptr, LIBFPTR_PARAM_SUM, 120);
libfptr_receipt_total(fptr);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_SUM, 1000);
libfptr_payment(fptr);

// Перед закрытием проверяем, что все КМ отправились (на случай, если были проверки КМ без ожидания результата
while (true) {
    libfptr_check_marking_code_validations_ready(fptr);
    if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY))
        break;
}

libfptr_close_receipt(fptr);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT12_AUTO);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_MARKING_CODE, L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=");
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_STATUS, 2);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 1.000);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MEASUREMENT_UNIT, fptr.LIBFPTR_IU_PIECE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
libfptr_set_param_str(fptr, LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
libfptr_begin_marking_code_validation(fptr);

std::wstring mark = L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
uint status = 2;

// Запускаем проверку КМ
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT12_AUTO);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(LIBFPTR_PARAM_MEASUREMENT_UNIT, LIBFPTR_IU_PIECE);
fptr.setParam(LIBFPTR_PARAM_MARKING_WAIT_FOR_VALIDATION_RESULT, true);
fptr.setParam(LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.setParam(LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
fptr.beginMarkingCodeValidation();

// Дожидаемся окончания проверки и запоминаем результат
while (true) {
    fptr.getMarkingCodeValidationStatus();
    if (fptr.getParamBool(LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY))
        break;
}
uint validationResult = fptr.getParamInt(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);

// Подтверждаем реализацию товара с указанным КМ
fptr.acceptMarkingCode();

// ... Проверяем остальные КМ

// Формируем чек
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.openReceipt();

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Молоко");
fptr.setParam(LIBFPTR_PARAM_PRICE, 80);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(LIBFPTR_PARAM_MEASUREMENT_UNIT, LIBFPTR_IU_PIECE);
fptr.setParam(LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
fptr.setParam(1212, 33);
fptr.setParam(1214, 4);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
fptr.setParam(LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.registration();

// ... Регистрируем остальные позиции

fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
fptr.setParam(LIBFPTR_PARAM_PAYMENT_SUM, 1000);
fptr.payment();

// Перед закрытием проверяем, что все КМ отправились (на случай, если были проверки КМ без ожидания результата
while (true) {
    fptr.checkMarkingCodeValidationsReady();
    if (fptr.getParamBool(LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY))
        break;
}

fptr.closeReceipt();

fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_TYPE, LIBFPTR_MCT12_AUTO);
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE, L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=");
fptr.setParam(LIBFPTR_PARAM_MARKING_CODE_STATUS, 2);
fptr.setParam(LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(LIBFPTR_PARAM_MEASUREMENT_UNIT, LIBFPTR_IU_PIECE);
fptr.setParam(LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.setParam(LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
fptr.beginMarkingCodeValidation();

String mark = "014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=";
long status = 2;

// Запускаем проверку КМ
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT12_AUTO);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, "1/2");
fptr.beginMarkingCodeValidation();

// Дожидаемся окончания проверки и запоминаем результат
while (true) {
    fptr.getMarkingCodeValidationStatus();
    if (fptr.getParamBool(IFptr.LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY))
        break;
}
long validationResult = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);

// Подтверждаем реализацию товара с указанным КМ
fptr.acceptMarkingCode();

// ... Проверяем остальные КМ

// Формируем чек
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.openReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Молоко");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 80);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, "1/2");
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(1212, 33);
fptr.setParam(1214, 4);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, mark);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, status);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validationResult);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.registration();

// ... Регистрируем остальные позиции

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 120);
fptr.receiptTotal();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, 1000);
fptr.payment();

// Перед закрытием проверяем, что все КМ отправились (на случай, если были проверки КМ без ожидания результата
while (true) {
    fptr.checkMarkingCodeValidationsReady();
    if (fptr.getParamBool(IFptr.LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY))
        break;
}

fptr.closeReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_TYPE, IFptr.LIBFPTR_MCT12_AUTO);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, L"014494550435306821QXYXSALGLMYQQ\u001D91EE06\u001D92YWCXbmK6SN8vvwoxZFk7WAY8WoJNMGGr6Cgtiuja04c=");
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, 2);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 1.000);
fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0);
fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY, L"1/2");
fptr.beginMarkingCodeValidation();

Общий алгоритм

Проверка КМ состоит из нескольких операций, которые должны быть последовательно выполнены для каждого кода маркировки:

Онлайн проверку можно прервать методом cancelMarkingCodeValidation().

Запуск проверки КМ

Входные параметры для метода beginMarkingCodeValidation():

Параметр Описание Тип Обязательность
LIBFPTR_PARAM_MARKING_CODE_TYPE Тип КМ (тег 2100) int
LIBFPTR_PARAM_MARKING_CODE КМ (тег 2000) bytearray +
LIBFPTR_PARAM_MARKING_CODE_STATUS Планируемый статус КМ (тег 2003) int +
LIBFPTR_PARAM_QUANTITY Количество товара (тег 1023) double
LIBFPTR_PARAM_MEASUREMENT_UNIT Мера количества товара (тег 2108) int
LIBFPTR_PARAM_MARKING_PROCESSING_MODE Режим обработки кода товара (тег 2102) int +
LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY Дробное количество товара (тег 1291) string

Значения параметра LIBFPTR_PARAM_MARKING_CODE_TYPE соответствуют значениям реквизита 2100 и могут принимать следующие значения:

Значения параметра LIBFPTR_PARAM_MARKING_CODE_STATUS соответствуют значениям реквизита 2003 и могут принимать следующие значения:

Значения параметра LIBFPTR_PARAM_QUANTITY соответствуют значениям реквизита 1023.

Значения параметра LIBFPTR_PARAM_MEASUREMENT_UNIT соответствуют значениям реквизита 2108 и могут принимать следующие значения:

Значения параметра LIBFPTR_PARAM_MARKING_PROCESSING_MODE соответствуют значениям реквизита 2102.

Значения параметра LIBFPTR_PARAM_MARKING_FRACTIONAL_QUANTITY представляют собой строку, в которой записана дробь в формате "Ц...Ц/Ц...Ц", т.е. два числа, разделённых символом "/" - числитель и знаменатель. Числитель и знаменатель должны быть отличны от нуля, а также дробь должна быть правильная, т.е. числитель строго меньше знаменателя. Данный реквизит соответствует значениям реквизита 1292, реквизит 1291 формируется автоматически на основании значения этого реквизита.

Результатом метода будут параметры, описывающие результат локальной проверки:

Параметр Описание Тип
LIBFPTR_PARAM_MARKING_CODE_VALIDATION_RESULT Результат локальной проверки (тег 2004) int
LIBFPTR_PARAM_MARKING_CODE_OFFLINE_VALIDATION_ERROR Ошибка локальной проверки int

Значения параметра LIBFPTR_PARAM_MARKING_CODE_OFFLINE_VALIDATION_ERROR могут принимать следующие значения:

Ожидание окончания проверки КМ

libfptr_get_marking_code_validation_status(fptr);
bool ready = libfptr_get_param_bool(fptr, LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY);
if (ready) {
    std::vector<wchar_t> str(1024);
    int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR_DESCRIPTION, &str[0], str.size());
    if (size > str.size())
    {
        str.resize(size);
        libfptr_get_param_str(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR_DESCRIPTION, &str[0], str.size());
    }
    std::wstring errorDescription = std::wstring(&str[0]);

    uint result = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
    bool isRequestSent = libfptr_get_param_bool(fptr, LIBFPTR_PARAM_IS_REQUEST_SENT);
    uint error = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR);
    uint info = libfptr_get_param_int(fptr, 2109);
    uint processingResult = libfptr_get_param_int(fptr, 2005);
    uint processingCode = libfptr_get_param_int(fptr, 2105);
    ...
}

fptr.getMarkingCodeValidationStatus();
bool ready = fptr.getParamBool(LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY);
if (ready) {
    uint result = fptr.getParamInt(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
    bool isRequestSent = fptr.getParamBool(LIBFPTR_PARAM_IS_REQUEST_SENT);
    uint error = fptr.getParamInt(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR);
    std::wstring errorDescription = fptr.getParamString(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR_DESCRIPTION);
    uint info = fptr.getParamInt(2109);
    uint processingResult = fptr.getParamInt(2005);
    uint processingCode = fptr.getParamInt(2105);
    ...
}

fptr.getMarkingCodeValidationStatus();
boolean ready = fptr.getParamBool(IFptr.LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY);
if (ready) {
    long result = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);
    boolean isRequestSent = fptr.getParamBool(IFptr.LIBFPTR_PARAM_IS_REQUEST_SENT);
    long error = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR);
    String errorDescription = fptr.getParamString(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR_DESCRIPTION);
    long info = fptr.getParamInt(2109);
    long processingResult = fptr.getParamInt(2005);
    long processingCode = fptr.getParamInt(2105);
    ...
}

Метод getMarkingCodeValidationStatus() нужно вызывать до тех пор, пока параметр LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY не станет равен true.

Входные параметры для метода getMarkingCodeValidationStatus() отсутствуют.

Выходные параметры:

Параметр Описание Тип
LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY Проверка завершена bool
LIBFPTR_PARAM_IS_REQUEST_SENT КМ был отправлен на сервер bool
LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT Результат проверки сведений о товаре (тег 2106) int
LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR Ошибка онлайн проверки int
LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR_DESCRIPTION Описание ошибки онлайн проверки string
LIBFPTR_PARAM_TLV_LIST Список полученных TLV-реквизитов string
2109 Сведения о статусе товара (тег 2109) int
2005 Результаты обработки запроса (тег 2005) int
2105 Код обработки запроса (тег 2105) int
2100 Тип кода маркировки (тег 2100) int
2101 Идентификатор товара (тег 2101) string
2102 Режим обработки кода маркировки (тег 2102) int

В зависимости от данных, которые вернёт сервер ИСМ, некоторые выходные параметры могут отсутствовать (реквизиты с числовыми параметрами 2109, 2005, 2105, 2100, 2101 и 2102). Для определения списка полученных реквизитов необходимо использовать свойство LIBFPTR_PARAM_TLV_LIST, которое содержит список из чисел (номер тега), разделённых символом ";". Например, "2109;2005;2105;2100".

Параметры LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR и LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_ERROR_DESCRIPTION соответствуют коду ошибки драйвера и его описанию в соответствии с документацией. Если вернулась ошибка, отличная от 0, то актуальны только следующие параметры:

Подтверждение и отказ от реализации товара

libfptr_accept_marking_code(fptr);
uint result = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);

fptr.acceptMarkingCode();
uint result = fptr.getParamInt(LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);

fptr.acceptMarkingCode();
long result = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT);

Для подтверждения реализации нужно вызвать метод acceptMarkingCode().

Выходные параметры:

Параметр Описание Тип
LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT Результат проверки сведений о товаре (тег 2106) int 
libfptr_decline_marking_code(fptr);

fptr.declineMarkingCode();

fptr.declineMarkingCode();

Для отказа от реализации нужно вызвать метод declineMarkingCode().

Выходных параметров нет.

Прерывание проверки КМ

libfptr_cancel_marking_code_validation(fptr);

fptr.cancelMarkingCodeValidation();

fptr.cancelMarkingCodeValidation();

Проверку КМ можно прервать с помощью метода cancelMarkingCodeValidation().

Очистка таблицы проверенных КМ

libfptr_clear_marking_code_validation_result(fptr);

fptr.clearMarkingCodeValidationResult();

fptr.clearMarkingCodeValidationResult();

Для очистки таблицы проверенных КМ в ФН требуется вызвать метод clearMarkingCodeValidationResult().

Передать данные уведомления

libfptr_set_param_str(fptr, 1262, L"016");
libfptr_set_param_str(fptr, 1263, L"24.09.2020");
libfptr_set_param_str(fptr, 1264, L"8252");
libfptr_set_param_str(fptr, 1265, L"значение");
libfptr_util_form_tlv(fptr);

std::vector<uchar> industryInfo(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, &industryInfo[0], industryInfo.size());
if (size > industryInfo.size())
{
    industryInfo.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, &industryInfo[0], industryInfo.size());
}
industryInfo.resize(size);

libfptr_set_param_str(fptr, 1228, L"123456789047");
libfptr_set_param_bytearray(fptr, 1261, &industryInfo[0], industryInfo.size());
libfptr_write_sales_notice(fptr);

fptr.setParam(1262, L"016");
fptr.setParam(1263, L"24.09.2020");
fptr.setParam(1264, L"8252");
fptr.setParam(1265, L"значение");
fptr.utilFormTlv();
std::vector<uchar> industryInfo = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1228, L"123456789047");
fptr.setParam(1261, industryInfo);
fptr.writeSalesNotice();

fptr.setParam(1262, "016");
fptr.setParam(1263, "24.09.2020");
fptr.setParam(1264, "8252");
fptr.setParam(1265, "значение");
fptr.utilFormTlv();
byte[] industryInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1228, "123456789047");
fptr.setParam(1261, industryInfo);
fptr.writeSalesNotice();

В уведомление о реализации товара с КМ также можно передать данные о реализации маркированного товара с помощью метода writeSalesNotice(), который принимает параметры:

Регистрация чека

После проверки всех КМ можно начать регистрировать позиции чека. В нужных позициях нужно повторно передать код маркировки, привязанный к товару. Для этого используются параметры:

Также можно передать данные о реализации маркированного товара в уведомление с помощью метода writeSalesNotice() после регистрации всех позиций чека (если среди них есть позиции с КМ). Подробнее в соответствующем разделе Передать данные уведомления.

Перед самым закрытием чека можно дождаться, пока драйвер не отправит все КМ, проверка которых была запущена без ожидания результата. Это можно сделать с помощью метода checkMarkingCodeValidationsReady(), возвращающего признак завершения фоновых проверок LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY. Если этого не сделать, драйвер всё равно дождётся окончания проверок в блокирующем режиме.

Обновление ключей проверки ФН-М

libfptr_update_fnm_keys(fptr);

fptr.updateFnmKeys();

fptr.updateFnmKeys();

Для обновления ключей проверки ФН-М требуется вызвать метод updateFnmKeys().

Входные и выходные параметры отсутствуют.

Проверка сервера ИСМ

// Начать проверку связи с сервером ИСМ
libfptr_ping_marking_server(fptr);

// Ожидание результатов проверки связи с сервером ИСМ
while (true) {
    libfptr_get_marking_server_status(fptr);
    if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CHECK_MARKING_SERVER_READY))
        break;
}

uint errorCode = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_SERVER_ERROR_CODE);
std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MARKING_SERVER_ERROR_DESCRIPTION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_MARKING_SERVER_ERROR_DESCRIPTION, &str[0], str.size());
}
std::wstring errorDescription = std::wstring(&str[0]);

uint responseTime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_SERVER_RESPONSE_TIME);

// Начать проверку связи с сервером ИСМ
fptr.pingMarkingServer();

// Ожидание результатов проверки связи с сервером ИСМ
while (true) {
    fptr.getMarkingServerStatus();
    if (fptr.getParamBool(LIBFPTR_PARAM_CHECK_MARKING_SERVER_READY))
        break;
}

uint errorCode = fptr.getParamInt(LIBFPTR_PARAM_MARKING_SERVER_ERROR_CODE);
std::wstring errorDescription = fptr.getParamString(LIBFPTR_PARAM_MARKING_SERVER_ERROR_DESCRIPTION);
uint responseTime = fptr.getParamInt(LIBFPTR_PARAM_MARKING_SERVER_RESPONSE_TIME);

// Начать проверку связи с сервером ИСМ
fptr.pingMarkingServer();

// Ожидание результатов проверки связи с сервером ИСМ
while (true) {
    fptr.getMarkingServerStatus();
    if (fptr.getParamBool(IFptr.LIBFPTR_PARAM_CHECK_MARKING_SERVER_READY))
        break;
}

long errorCode = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_SERVER_ERROR_CODE);
String errorDescription = fptr.getParamString(IFptr.LIBFPTR_PARAM_MARKING_SERVER_ERROR_DESCRIPTION);
long responseTime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_SERVER_RESPONSE_TIME);

Проверка сервера ИСМ состоит из следующих этапов:

Для метода pingMarkingServer() входные и выходные параметры отсутствуют.

Для метода getMarkingServerStatus() входные параметры отсутствуют. Результатом метода будут параметры, описывающие результат проверки:

Параметр Описание Тип
LIBFPTR_PARAM_CHECK_MARKING_SERVER_READY Проверка завершена bool
LIBFPTR_PARAM_MARKING_SERVER_ERROR_CODE Ошибка проверки int
LIBFPTR_PARAM_MARKING_SERVER_ERROR_DESCRIPTION Описание ошибки string
LIBFPTR_PARAM_MARKING_SERVER_RESPONSE_TIME Время ожидания ответа от сервера, мс int

Значения параметров LIBFPTR_PARAM_MARKING_SERVER_ERROR_CODE и LIBFPTR_PARAM_MARKING_SERVER_ERROR_DESCRIPTION соответствуют коду и описанию ошибки драйвера, см. приложение Список кодов ошибок.

Внесения и выплаты

Внесение

Внесение

libfptr_set_param_double(fptr, LIBFPTR_PARAM_SUM, 100.00);
libfptr_cash_income(fptr);

fptr.setParam(LIBFPTR_PARAM_SUM, 100.00);
fptr.cashIncome();

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashIncome();

Для регистрации внесения требуется вызвать метод cashIncome() и указать сумму внесения в параметре LIBFPTR_PARAM_SUM. Чтобы документ не печатался, нужно установить параметру LIBFPTR_PARAM_DOCUMENT_ELECTRONICALLY значение true.

Результатом команды будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_AUTO_OPENED true, если при выполнении операции была автоматически открыта смена в ККТ bool

Выплата

Выплата

libfptr_set_param_double(fptr, LIBFPTR_PARAM_SUM, 100.00);
libfptr_cash_outcome(fptr);

fptr.setParam(LIBFPTR_PARAM_SUM, 100.00);
fptr.cashOutcome();

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashOutcome();

Для регистрации выплаты требуется вызвать метод cashOutcome() и указать сумму выплаты в параметре LIBFPTR_PARAM_SUM. Чтобы документ не печатался, нужно установить параметру LIBFPTR_PARAM_DOCUMENT_ELECTRONICALLY значение true.

Результатом команды будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_AUTO_OPENED true, если при выполнении операции была автоматически открыта смена в ККТ bool

Печать отчетов

Для печати отчета необходим заполнить тип отчета (параметр LIBFPTR_PARAM_REPORT_TYPE) и дополнительные параметры отчета (если они требуются) и вызвать метод report().

X-отчет

X-отчет

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_X);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_X);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_X);
fptr.report();

Для печати X-отчета требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_X.

Копия последнего документа

Копия последнего документа

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_LAST_DOCUMENT);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_LAST_DOCUMENT);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_LAST_DOCUMENT);
fptr.report();

Для печати копии последнего документа требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_LAST_DOCUMENT.

Отчет о состоянии расчетов

Отчет о состоянии расчетов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OFD_EXCHANGE_STATUS);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OFD_EXCHANGE_STATUS);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_EXCHANGE_STATUS);
fptr.report();

Для печати отчета о состоянии расчетов требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_OFD_EXCHANGE_STATUS.

Печать информации о ККТ

Печать информации о ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_KKT_INFO);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_KKT_INFO);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_INFO);
fptr.report();

Для печати информации о ККТ требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_KKT_INFO.

Тест связи с ОФД

Тест связи с ОФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OFD_TEST);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OFD_TEST);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_TEST);
fptr.report();

Для печати диагностики соединения с ОФД требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_OFD_TEST.

Печать документа из ФН

Печать документа из ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_FN_DOC_BY_NUMBER);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_FN_DOC_BY_NUMBER);
fptr.setParam(LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_FN_DOC_BY_NUMBER);
fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.report();

Для печати документа из архива фискального накопителя требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_FN_DOC_BY_NUMBER.

Для указания номер документа используется параметр LIBFPTR_PARAM_DOCUMENT_NUMBER.

Печать итогов регистрации / перерегистрации

Печать итогов регистрации / перерегистрации

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_FN_REGISTRATIONS);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_FN_REGISTRATIONS);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_FN_REGISTRATIONS);
fptr.report();

Для печати итогов регистрации/перерегистрации требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_FN_REGISTRATIONS.

Печать информации о подписках на ККТ

Печать информации о подписках на ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_LICENSE_INFO);
libfptr_report(fptr);

fptr.setParam(LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_LICENSE_INFO);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_LICENSE_INFO);
fptr.report();

Для печати информации о подписках на ККТ требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_LICENSE_INFO.

Запрос информации из ФН

Значение реквизита регистрации

Запрос значения реквизита регистрации

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_TAG_VALUE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAG_NUMBER, 1018);
libfptr_fn_query_data(fptr);

std::vector<wchar_t> str(32);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_TAG_VALUE, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_TAG_VALUE, &str[0], str.size());
}
std::wstring companyVATIN = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_TAG_VALUE);
fptr.setParam(LIBFPTR_PARAM_TAG_NUMBER, 1018);
fptr.fnQueryData();

std::wstring companyVATIN = fptr.getParamString(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_TAG_VALUE);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAG_NUMBER, 1018);
fptr.fnQueryData();

String companyVATIN = fptr.getParamString(IFptr.LIBFPTR_PARAM_TAG_VALUE);

Для запроса одного из реквизитов регистрации требуется вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_TAG_VALUE и указать номер реквизита LIBFPTR_PARAM_TAG_NUMBER.

После выполнения метода значение реквизита можно прочитать из параметра LIBFPTR_PARAM_TAG_VALUE. Тип параметра зависит от номера реквизита.

Список доступных к запросу реквизитов представлен в описании запроса Регистрационные данные.

В отличие от запроса LIBFPTR_FNDT_REGISTRATION_TLV данные считываются преимущественно из кеша параметров ККТ.

Чтение реквизита регистрации по номеру отчета

Чтение реквизита регистрации

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_REGISTRATION_TLV);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_REGISTRATION_NUMBER, 1);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAG_NUMBER, 1018);
libfptr_fn_query_data(fptr);

uint tagNumber = libfptr_get_param_int(fptr, LIBFPTR_PARAM_TAG_NUMBER);
uint tagType = libfptr_get_param_int(fptr, LIBFPTR_PARAM_TAG_TYPE);

std::vector<wchar_t> str(32);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_TAG_VALUE, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_TAG_VALUE, &str[0], str.size());
}
std::wstring companyVATIN = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_REGISTRATION_TLV);
fptr.setParam(LIBFPTR_PARAM_REGISTRATION_NUMBER, 1);
fptr.setParam(LIBFPTR_PARAM_TAG_NUMBER, 1018);
fptr.fnQueryData();

std::wstring tagName      = fptr.getParamString(LIBFPTR_PARAM_TAG_NAME);
uint tagType              = fptr.getParamInt(LIBFPTR_PARAM_TAG_TYPE);
std::wstring companyVATIN = fptr.getParamString(LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_REGISTRATION_TLV);
fptr.setParam(IFptr.LIBFPTR_PARAM_REGISTRATION_NUMBER, 1);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAG_NUMBER, 1018);
fptr.fnQueryData();

String tagName      = fptr.getParamString(IFptr.LIBFPTR_PARAM_TAG_NAME);
long tagType        = fptr.getParamInt(IFptr.LIBFPTR_PARAM_TAG_TYPE);
String companyVATIN = fptr.getParamString(IFptr.LIBFPTR_PARAM_TAG_VALUE);

Для запроса одного из реквизитов регистрации требуется вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_REGISTRATION_TLV и указать номер реквизита LIBFPTR_PARAM_TAG_NUMBER и порядковый номер регистрации LIBFPTR_PARAM_REGISTRATION_NUMBER.

После выполнения метода доступны следующие выходные параметры:

Параметр Описание Тип
LIBFPTR_PARAM_TAG_VALUE Значение реквизита Зависит от номера реквизита
LIBFPTR_PARAM_TAG_TYPE Тип реквизита int
LIBFPTR_PARAM_TAG_NAME Название реквизита string
LIBFPTR_PARAM_TAG_IS_COMPLEX true, если реквизит составной bool
LIBFPTR_PARAM_TAG_IS_REPEATABLE true, если реквизит может повторяться bool

Реквизит можно сразу считать в удобном для обработки виде. Для этого нужно ориентироваться на значение параметра LIBFPTR_PARAM_TAG_TYPE, и, в зависимости от него, использовать методы для чтения разных типов параметров - getParamInt(), getParamBool(), getParamDouble() и т.п.

В отличие от запроса LIBFPTR_FNDT_TAG_VALUE данные считываются напрямую из ФН. Закешированные значения из ККТ не учитываются.

Регистрационные данные

Запрос реквизитов регистрации ККТ

// Вспомогательная функция для чтения строковых параметров
std::wstring readStringAttribute(libfptr_handle fptr, int paramNumber) {
    std::vector<wchar_t> str(32);
    int size = libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    if (size > str.size()) {
        str.resize(size);
        libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    }
    return std::wstring(&str[0]);
}

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_REG_INFO);
libfptr_fn_query_data(fptr);

int taxationTypes                   = libfptr_get_param_int(fptr, 1062);
int ffdVersion                      = libfptr_get_param_int(fptr, 1209);

bool autoModeSign                   = (libfptr_get_param_bool(fptr, 1001) != 0);
bool offlineModeSign                = (libfptr_get_param_bool(fptr, 1002) != 0);
bool encryptionSign                 = (libfptr_get_param_bool(fptr, 1056) != 0);
bool internetSign                   = (libfptr_get_param_bool(fptr, 1108) != 0);
bool serviceSign                    = (libfptr_get_param_bool(fptr, 1109) != 0);
bool bsoSign                        = (libfptr_get_param_bool(fptr, 1110) != 0);
bool lotterySign                    = (libfptr_get_param_bool(fptr, 1126) != 0);
bool gamblingSign                   = (libfptr_get_param_bool(fptr, 1193) != 0);
bool exciseSign                     = (libfptr_get_param_bool(fptr, 1207) != 0);
bool machineInstallationSign        = (libfptr_get_param_bool(fptr, 1221) != 0);

std::wstring fnsUrl                 = readStringAttribute(fptr, 1060);
std::wstring organizationAddress    = readStringAttribute(fptr, 1009);
std::wstring organizationVATIN      = readStringAttribute(fptr, 1018);
std::wstring organizationName       = readStringAttribute(fptr, 1048);
std::wstring organizationEmail      = readStringAttribute(fptr, 1117);
std::wstring paymentsAddress        = readStringAttribute(fptr, 1187);
std::wstring registrationNumber     = readStringAttribute(fptr, 1037);
std::wstring machineNumber          = readStringAttribute(fptr, 1036);
std::wstring ofdVATIN               = readStringAttribute(fptr, 1017);
std::wstring ofdName                = readStringAttribute(fptr, 1046);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_REG_INFO);
fptr.fnQueryData();

uint taxationTypes = fptr.getParamInt(1062);
uint ffdVersion    = fptr.getParamInt(1209);

bool autoModeSign            = fptr.getParamBool(1001);
bool offlineModeSign         = fptr.getParamBool(1002);
bool encryptionSign          = fptr.getParamBool(1056);
bool internetSign            = fptr.getParamBool(1108);
bool serviceSign             = fptr.getParamBool(1109);
bool bsoSign                 = fptr.getParamBool(1110);
bool lotterySign             = fptr.getParamBool(1126);
bool gamblingSign            = fptr.getParamBool(1193);
bool exciseSign              = fptr.getParamBool(1207);
bool machineInstallationSign = fptr.getParamBool(1221);

std::wstring fnsUrl              = fptr.getParamString(1060);
std::wstring organizationAddress = fptr.getParamString(1009);
std::wstring organizationVATIN   = fptr.getParamString(1018);
std::wstring organizationName    = fptr.getParamString(1048);
std::wstring organizationEmail   = fptr.getParamString(1117);
std::wstring paymentsAddress     = fptr.getParamString(1187);
std::wstring registrationNumber  = fptr.getParamString(1037);
std::wstring machineNumber       = fptr.getParamString(1036);
std::wstring ofdVATIN            = fptr.getParamString(1017);
std::wstring ofdName             = fptr.getParamString(1046);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_REG_INFO);
fptr.fnQueryData();

long taxationTypes               = fptr.getParamInt(1062);
long agentSign                   = fptr.getParamInt(1057);
long ffdVersion                  = fptr.getParamInt(1209);

boolean autoModeSign             = fptr.getParamBool(1001);
boolean offlineModeSign          = fptr.getParamBool(1002);
boolean encryptionSign           = fptr.getParamBool(1056);
boolean internetSign             = fptr.getParamBool(1108);
boolean serviceSign              = fptr.getParamBool(1109);
boolean bsoSign                  = fptr.getParamBool(1110);
boolean lotterySign              = fptr.getParamBool(1126);
boolean gamblingSign             = fptr.getParamBool(1193);
boolean exciseSign               = fptr.getParamBool(1207);
boolean machineInstallationSign  = fptr.getParamBool(1221);

String fnsUrl                    = fptr.getParamString(1060);
String organizationAddress       = fptr.getParamString(1009);
String organizationVATIN         = fptr.getParamString(1018);
String organizationName          = fptr.getParamString(1048);
String organizationEmail         = fptr.getParamString(1117);
String paymentsAddress           = fptr.getParamString(1187);
String registrationNumber        = fptr.getParamString(1037);
String machineNumber             = fptr.getParamString(1036);
String ofdVATIN                  = fptr.getParamString(1017);
String ofdName                   = fptr.getParamString(1046);

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
1060 Адрес сайта ФНС string
1009 Адрес расчетов string
1018 ИНН организации string
1048 Название организации string
1062 Системы налогообложения int
1117 E-mail организации string
1187 Адрес места расчетов string
1037 Регистрационный номер устройства string
1209 Версия ФФД int
1001 Признак автоматического режима bool
1036 Номер автомата string
1002 Признак автономного режима bool
1056 Признак шифрования bool
1108 Признак ККТ для расчетов в сети Интернет bool
1109 Признак расчетов за услуги bool
1110 Признак АС БСО bool
1126 Признак проведения лотерей bool
1193 Признак проведения азартных игр bool
1207 Признак подакцизного товара bool
1221 Признак установки принтера в автомате bool
1017 ИНН ОФД string
1046 Название ОФД string
LIBFPTR_PARAM_TRADE_MARKED_PRODUCTS Признак торговли маркированными товарами bool
LIBFPTR_PARAM_INSURANCE_ACTIVITY Признак осуществления страховой деятельности bool
LIBFPTR_PARAM_PAWN_SHOP_ACTIVITY Признак осуществления ломбардной деятельности bool

Значение реквизита 1062 (системы налогообложения) - битовое поле, значениями которого являются одно или несколько из следующих значений:

Реквизит 1209 (версия ФФД) может принимать следующие значения:

Статус информационного обмена с ОФД

Запрос статуса информационного обмена с ОФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_OFD_EXCHANGE_STATUS);
libfptr_fn_query_data(fptr);

int exchangeStatus      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_OFD_EXCHANGE_STATUS);
int unsentCount         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);
int firstUnsentNumber   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int ofdMessageRead      = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_OFD_MESSAGE_READ) != 0);
int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_OFD_EXCHANGE_STATUS);
fptr.fnQueryData();

uint exchangeStatus         = fptr.getParamInt(LIBFPTR_PARAM_OFD_EXCHANGE_STATUS);
uint unsentCount            = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);
uint firstUnsentNumber      = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
std::wstring ofdMessageRead = fptr.getParamBool(LIBFPTR_PARAM_OFD_MESSAGE_READ);
std::tm dateTime            = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_OFD_EXCHANGE_STATUS);
fptr.fnQueryData();

long exchangeStatus      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OFD_EXCHANGE_STATUS);
long unsentCount         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
long firstUnsentNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
boolean ofdMessageRead   = fptr.getParamBool(IFptr.LIBFPTR_PARAM_OFD_MESSAGE_READ);
Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса cтатуса информационного обмена с ОФД необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_OFD_EXCHANGE_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_OFD_EXCHANGE_STATUS Статус информационного обмена с ОФД int
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество неотправленных документов int
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер первого неотправленного документа int
LIBFPTR_PARAM_DATE_TIME Дата и время первого неотправленного документа datetime
LIBFPTR_PARAM_OFD_MESSAGE_READ Флаг наличия сообщения для ОФД bool

Значение LIBFPTR_PARAM_OFD_EXCHANGE_STATUS представляет собой битовое поле:

Информация о ФН

Запрос информации и статуса ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_FN_INFO);
libfptr_fn_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
}
std::wstring fnSerial = std::wstring(&str[0]);

size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_VERSION, &str[0], str.size());
}
std::wstring fnVersion = std::wstring(&str[0]);

size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_EXECUTION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_EXECUTION, &str[0], str.size());
}
std::wstring fnExecution = std::wstring(&str[0]);

int fnType               = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_TYPE);
int fnState              = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_STATE);
int fnFlags              = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_FLAGS);

bool fnNeedReplacement   = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_NEED_REPLACEMENT) != 0);
bool fnExhausted         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_RESOURCE_EXHAUSTED) != 0);
bool fnMemoryOverflow    = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_MEMORY_OVERFLOW) != 0);
bool fnOfdTimeout        = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_OFD_TIMEOUT) != 0);
bool fnCriticalError     = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_CRITICAL_ERROR) != 0);
bool fnContainsServerUri = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_CONTAINS_KEYS_UPDATER_SERVER_URI) != 0);
if (fnContainsServerUri)
{
    size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_KEYS_UPDATER_SERVER_URI, &str[0], str.size());
    if (size > str.size())
    {
        str.resize(size);
        libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_KEYS_UPDATER_SERVER_URI, &str[0], str.size());
    }
    std::wstring fnKeysUpdaterServerUri = std::wstring(&str[0]);
}

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_FN_INFO);
fptr.fnQueryData();

std::wstring fnSerial       = fptr.getParamString(LIBFPTR_PARAM_SERIAL_NUMBER);
std::wstring fnVersion      = fptr.getParamString(LIBFPTR_PARAM_FN_VERSION);
std::wstring fnExecution    = fptr.getParamString(LIBFPTR_PARAM_FN_EXECUTION);

uint fnType                 = fptr.getParamInt(LIBFPTR_PARAM_FN_TYPE);
uint fnState                = fptr.getParamInt(LIBFPTR_PARAM_FN_STATE);
uint fnFlags                = fptr.getParamInt(LIBFPTR_PARAM_FN_FLAGS);

bool fnNeedReplacement      = fptr.getParamBool(LIBFPTR_PARAM_FN_NEED_REPLACEMENT);
bool fnExhausted            = fptr.getParamBool(LIBFPTR_PARAM_FN_RESOURCE_EXHAUSTED);
bool fnMemoryOverflow       = fptr.getParamBool(LIBFPTR_PARAM_FN_MEMORY_OVERFLOW);
bool fnOfdTimeout           = fptr.getParamBool(LIBFPTR_PARAM_FN_OFD_TIMEOUT);
bool fnCriticalError        = fptr.getParamBool(LIBFPTR_PARAM_FN_CRITICAL_ERROR);
bool fnContainsServerUri    = fptr.getParamBool(LIBFPTR_PARAM_FN_CONTAINS_KEYS_UPDATER_SERVER_URI);
if (fnContainsServerUri)
    std::wstring fnKeysUpdaterServerUri = fptr.getParamString(LIBFPTR_PARAM_FN_KEYS_UPDATER_SERVER_URI);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_FN_INFO);
fptr.fnQueryData();

String fnSerial             = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);
String fnVersion            = fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_VERSION);
String fnExecution          = fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_EXECUTION);

long fnType                 = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_TYPE);
long fnState                = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_STATE);
long fnFlags                = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_FLAGS);

boolean fnNeedReplacement   = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_NEED_REPLACEMENT);
boolean fnExhausted         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_RESOURCE_EXHAUSTED);
boolean fnMemoryOverflow    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_MEMORY_OVERFLOW);
boolean fnOfdTimeout        = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_OFD_TIMEOUT);
boolean fnCriticalError     = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_CRITICAL_ERROR);
boolean fnContainsServerUri = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_CONTAINS_KEYS_UPDATER_SERVER_URI);
if (fnContainsServerUri)
{
    String fnKeysUpdaterServerUri = fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_KEYS_UPDATER_SERVER_URI);
}

Для запроса информации и статуса ФН необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_FN_INFO.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SERIAL_NUMBER Серийный номер ФН string
LIBFPTR_PARAM_FN_VERSION Версия ФН string
LIBFPTR_PARAM_FN_EXECUTION Исполнение ФН (только для ФН-М) string
LIBFPTR_PARAM_FN_TYPE Тип ФН int
LIBFPTR_PARAM_FN_STATE Состояние ФН int
LIBFPTR_PARAM_FN_FLAGS Нерасшифрованный байт флагов ФН int
LIBFPTR_PARAM_FN_NEED_REPLACEMENT Требуется срочная замена ФН bool
LIBFPTR_PARAM_FN_RESOURCE_EXHAUSTED Исчерпан ресурс ФН bool
LIBFPTR_PARAM_FN_MEMORY_OVERFLOW Память ФН переполнена bool
LIBFPTR_PARAM_FN_OFD_TIMEOUT Превышено время ожидания ответа от ОФД bool
LIBFPTR_PARAM_FN_CRITICAL_ERROR Критическая ошибка ФН bool
LIBFPTR_PARAM_FN_CONTAINS_KEYS_UPDATER_SERVER_URI ФН содержит URI сервера ОКП bool

Тип ФН (LIBFPTR_PARAM_FN_TYPE) может принимать следующие значения:

Состояние ФН (LIBFPTR_PARAM_FN_STATE) может принимать следующие значения:

Информация о последней регистрации / перерегистрации

Запрос информации о последней регистрации / перерегистрации

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_LAST_REGISTRATION);
libfptr_fn_query_data(fptr);

int documentNumber      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int registrationsCount  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_REGISTRATIONS_COUNT);
int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_LAST_REGISTRATION);
fptr.fnQueryData();

uint documentNumber     = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint registrationsCount = fptr.getParamInt(LIBFPTR_PARAM_REGISTRATIONS_COUNT);
std::tm dateTime        = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_LAST_REGISTRATION);
fptr.fnQueryData();

long documentNumber      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long registrationsCount  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_REGISTRATIONS_COUNT);
Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса информации о последней регистрации / перерегистрации необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_LAST_REGISTRATION.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер документа int
LIBFPTR_PARAM_REGISTRATIONS_COUNT Номер регистрации / перерегистрации int
LIBFPTR_PARAM_DATE_TIME Дата и время документа datetime

Информация о последнем документе

Запрос информации о последнем фискальном документе

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_LAST_DOCUMENT);
libfptr_fn_query_data(fptr);

int documentNumber      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FISCAL_SIGN, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_FISCAL_SIGN, &str[0], str.size());
}
std::wstring fiscalSign = std::wstring(&str[0]);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_LAST_DOCUMENT);
fptr.fnQueryData();

uint documentNumber     = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);

std::wstring fiscalSign = fptr.getParamString(LIBFPTR_PARAM_FISCAL_SIGN);

std::tm dateTime        = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_LAST_DOCUMENT);
fptr.fnQueryData();

long documentNumber = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);

String fiscalSign   = fptr.getParamString(IFptr.LIBFPTR_PARAM_FISCAL_SIGN);

Date dateTime       = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса информации о последнем чеке в ФН необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_LAST_DOCUMENT.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер документа int
LIBFPTR_PARAM_FISCAL_SIGN Фискальный признак документа string
LIBFPTR_PARAM_DATE_TIME Дата и время документа datetime

Информация о смене

Запрос информации о текущей смене в ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_SHIFT);
libfptr_fn_query_data(fptr);

int receiptNumber   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_NUMBER);
int shiftNumber     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_SHIFT);
fptr.fnQueryData();

uint receiptNumber = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_NUMBER);
uint shiftNumber   = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER)

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_SHIFT);
fptr.fnQueryData();

long receiptNumber      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long shiftNumber        = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);

Для запроса информации о смене в ФН необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_SHIFT.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_NUMBER Количество чеков за смену int
LIBFPTR_PARAM_SHIFT_NUMBER Номер смены int

Количество ФД за смену

Запрос количества ФД за смену

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_DOCUMENTS_COUNT_IN_SHIFT);
libfptr_fn_query_data(fptr);

int documentsCount = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_DOCUMENTS_COUNT_IN_SHIFT);
fptr.fnQueryData();

uint documentsCount = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_DOCUMENTS_COUNT_IN_SHIFT);
fptr.fnQueryData();

long documentsCount = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса количества фискальных документов за смену необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_DOCUMENTS_COUNT_IN_SHIFT.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество ФД за смену int

Версии ФФД

Запрос версий ФФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_FFD_VERSIONS);
libfptr_fn_query_data(fptr);

int deviceFfdVersion   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DEVICE_FFD_VERSION);
int fnFfdVersion       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_FFD_VERSION);
int maxFnFfdVersion    = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_MAX_FFD_VERSION);
int ffdVersion         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FFD_VERSION);
int maxFfdVersion      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DEVICE_MAX_FFD_VERSION);
int minFfdVersion      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DEVICE_MIN_FFD_VERSION);
int versionKKT         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_VERSION);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_FFD_VERSIONS);
fptr.fnQueryData();

uint deviceFfdVersion = fptr.getParamInt(LIBFPTR_PARAM_DEVICE_FFD_VERSION);
uint fnFfdVersion     = fptr.getParamInt(LIBFPTR_PARAM_FN_FFD_VERSION);
uint maxFnFfdVersion  = fptr.getParamInt(LIBFPTR_PARAM_FN_MAX_FFD_VERSION);
uint ffdVersion       = fptr.getParamInt(LIBFPTR_PARAM_FFD_VERSION);
uint maxFfdVersion    = fptr.getParamInt(LIBFPTR_PARAM_DEVICE_MAX_FFD_VERSION);
uint minFfdVersion    = fptr.getParamInt(LIBFPTR_PARAM_DEVICE_MIN_FFD_VERSION);
uint versionKKT       = fptr.getParamInt(LIBFPTR_PARAM_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_FFD_VERSIONS);
fptr.fnQueryData();

long deviceFfdVersion    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_FFD_VERSION);
long fnFfdVersion        = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_FFD_VERSION);
long maxFnFfdVersion     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_MAX_FFD_VERSION);
long ffdVersion          = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FFD_VERSION);
long maxFfdVersion       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_MAX_FFD_VERSION);
long minFfdVersion       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_MIN_FFD_VERSION);
long versionKKT          = fptr.getParamInt(IFptr.LIBFPTR_PARAM_VERSION);

Для запроса информации о версиях ФФД необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_FFD_VERSIONS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DEVICE_FFD_VERSION Версия ФФД ККТ int
LIBFPTR_PARAM_FN_FFD_VERSION Версия ФФД ФН int
LIBFPTR_PARAM_FN_MAX_FFD_VERSION Максимальная версия ФФД ФН int
LIBFPTR_PARAM_FFD_VERSION Версия ФФД int
LIBFPTR_PARAM_DEVICE_MAX_FFD_VERSION Максимальная версия ФФД ККТ int
LIBFPTR_PARAM_DEVICE_MIN_FFD_VERSION Минимальная версия ФФД ККТ int
LIBFPTR_PARAM_VERSION Версия модели ККТ int

Указанные выше версии ФФД принимают следующие значения:

Срок действия ФН

Запрос срока действия ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_VALIDITY);
libfptr_fn_query_data(fptr);

int registrationsRemain = libfptr_get_param_int(fptr, LIBFPTR_PARAM_REGISTRATIONS_REMAIN);
int registrationsCount  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_REGISTRATIONS_COUNT);
int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_VALIDITY);
fptr.fnQueryData();

uint registrationsRemain = fptr.getParamInt(LIBFPTR_PARAM_REGISTRATIONS_REMAIN);
uint registrationsCount  = fptr.getParamInt(LIBFPTR_PARAM_REGISTRATIONS_COUNT);
std::tm dateTime         = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_VALIDITY);
fptr.fnQueryData();

long registrationsRemain = fptr.getParamInt(IFptr.LIBFPTR_PARAM_REGISTRATIONS_REMAIN);
long registrationsCount  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_REGISTRATIONS_COUNT);
Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса срока действия ФН необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_VALIDITY.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Срок действия ФН datetime
LIBFPTR_PARAM_REGISTRATIONS_COUNT Сделано перерегистраций int
LIBFPTR_PARAM_REGISTRATIONS_REMAIN Осталось перерегистраций int

Ошибки обмена с ОФД

Запрос ошибок обмена с ОФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ERRORS);
libfptr_fn_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = 0;

int networkError    = libfptr_get_param_int(fptr, LIBFPTR_PARAM_NETWORK_ERROR);
size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_NETWORK_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_NETWORK_ERROR_TEXT, &str[0], str.size());
}
std::wstring networkErrorText = std::wstring(&str[0]);

int ofdError        = libfptr_get_param_int(fptr, LIBFPTR_PARAM_OFD_ERROR);
size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_OFD_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_OFD_ERROR_TEXT, &str[0], str.size());
}
std::wstring ofdErrorText = std::wstring(&str[0]);

int fnError         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_ERROR);
size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_ERROR_TEXT, &str[0], str.size());
}
std::wstring fnErrorText = std::wstring(&str[0]);

int documentNumber  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int commandCode     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COMMAND_CODE);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ERRORS);
fptr.fnQueryData();

uint networkError             = fptr.getParamInt(LIBFPTR_PARAM_NETWORK_ERROR);
std::wstring networkErrorText = fptr.getParamString(LIBFPTR_PARAM_NETWORK_ERROR_TEXT);

uint ofdError                 = fptr.getParamInt(LIBFPTR_PARAM_OFD_ERROR);
std::wstring nofdErrorText    = fptr.getParamString(LIBFPTR_PARAM_OFD_ERROR_TEXT);

uint fnError                  = fptr.getParamInt(LIBFPTR_PARAM_FN_ERROR);
std::wstring nfnErrorText     = fptr.getParamString(LIBFPTR_PARAM_FN_ERROR_TEXT);

uint documentNumber           = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint commandCode              = fptr.getParamInt(LIBFPTR_PARAM_COMMAND_CODE);

std::tm dateTime              = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_ERRORS);
fptr.fnQueryData();

long networkError           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_NETWORK_ERROR);
String networkErrorText     = fptr.getParamString(IFptr.LIBFPTR_PARAM_NETWORK_ERROR_TEXT);

long ofdError               = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OFD_ERROR);
String ofdErrorText         = fptr.getParamString(IFptr.LIBFPTR_PARAM_OFD_ERROR_TEXT);

long fnError                = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_ERROR);
String fnErrorText          = fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_ERROR_TEXT);

long documentNumber         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long commandCode            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COMMAND_CODE);

Date dateTime               = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса ошибок обмена с ОФД необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_ERRORS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Дата и время последнего успешного соединения с ОФД datetime
LIBFPTR_PARAM_NETWORK_ERROR Код ошибки сети int
LIBFPTR_PARAM_NETWORK_ERROR_TEXT Текст ошибки сети string
LIBFPTR_PARAM_OFD_ERROR Код ошибки ОФД int
LIBFPTR_PARAM_OFD_ERROR_TEXT Текст ошибки ОФД string
LIBFPTR_PARAM_FN_ERROR Код ошибки ФН int
LIBFPTR_PARAM_FN_ERROR_TEXT Текст ошибки ФН string
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер ФД, на котором произошла ошибка int
LIBFPTR_PARAM_COMMAND_CODE Команда ФН, на которой произошла ошибка int

Квитанция ОФД

Запрос квитанции ОФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_TICKET_BY_DOC_NUMBER);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
libfptr_fn_query_data(fptr);

int documentNumber  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

std::vector<uchar> ofdFiscalSign(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_OFD_FISCAL_SIGN, 
                                       &ofdFiscalSign[0], ofdFiscalSign.size());
if (size > ofdFiscalSign.size())
{
    ofdFiscalSign.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_OFD_FISCAL_SIGN, 
                                &ofdFiscalSign[0], ofdFiscalSign.size());
}
ofdFiscalSign.resize(size);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_TICKET_BY_DOC_NUMBER);
fptr.setParam(LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.fnQueryData();

uint documentNumber              = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
std::tm dateTime                 = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);
std::vector<uchar> ofdFiscalSign = fptr.getParamByteArray(LIBFPTR_PARAM_OFD_FISCAL_SIGN);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_TICKET_BY_DOC_NUMBER);
fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.fnQueryData();

long documentNumber      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);
byte[] ofdFiscalSign     = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_OFD_FISCAL_SIGN);

Для запроса квитанции ОФД необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_TICKET_BY_DOC_NUMBER и указать номер документа в параметре LIBFPTR_PARAM_DOCUMENT_NUMBER.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Дата и время из квитанции ОФД (UTC) datetime
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер ФД из квитанции int
LIBFPTR_PARAM_OFD_FISCAL_SIGN Фискальный признак ОФД bytearray

Информация о документе

Запрос информации о документе

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_DOCUMENT_BY_NUMBER);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER, 24);
libfptr_fn_query_data(fptr);

int documentType    = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_DOCUMENT_TYPE);
int documentNumber  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
bool hasOfdTicket   = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_HAS_OFD_TICKET) != 0);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FISCAL_SIGN, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_FISCAL_SIGN, &str[0], str.size());
}
std::wstring fiscalSign = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_DOCUMENT_BY_NUMBER);
fptr.setParam(LIBFPTR_PARAM_DOCUMENT_NUMBER, 24);
fptr.fnQueryData();

uint documentType       = fptr.getParamInt(LIBFPTR_PARAM_FN_DOCUMENT_TYPE);
uint documentNumber     = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
bool hasOfdTicket       = fptr.getParamBool(LIBFPTR_PARAM_HAS_OFD_TICKET);
std::tm dateTime        = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);
std::wstring fiscalSign = fptr.getParamString(LIBFPTR_PARAM_FISCAL_SIGN);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_DOCUMENT_BY_NUMBER);
fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 24);
fptr.fnQueryData();

long documentType        = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_DOCUMENT_TYPE);
long documentNumber      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
boolean hasOfdTicket     = fptr.getParamBool(IFptr.LIBFPTR_PARAM_HAS_OFD_TICKET);
Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);
String fiscalSign        = fptr.getParamString(IFptr.LIBFPTR_PARAM_FISCAL_SIGN);

Для запроса информации о фискальном документе необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_DOCUMENT_BY_NUMBER и указать номер документа в параметре LIBFPTR_PARAM_DOCUMENT_NUMBER.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_FN_DOCUMENT_TYPE Тип документа int
LIBFPTR_PARAM_DATE_TIME Дата и время документа datetime
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер ФД int
LIBFPTR_PARAM_HAS_OFD_TICKET Флаг наличия подтверждения ОФД bool
LIBFPTR_PARAM_FISCAL_SIGN Фискальный признак string

Параметр LIBFPTR_PARAM_FN_DOCUMENT_TYPE может принимать следующие значения:

Дополнительные выходные параметры зависят от значения LIBFPTR_PARAM_FN_DOCUMENT_TYPE.

Выходные параметры для отчета регистрации:

Параметр Описание Тип
1018 ИНН организации string
1037 Регистрационный номер устройства string
1062 Системы налогообложения int
1001 Признак автоматического режима bool
1002 Признак автономного режима bool
1056 Признак шифрования bool
1108 Признак ККТ для расчетов в сети Интернет bool
1109 Признак расчетов за услуги bool
1110 Признак АС БСО bool
1290 Признаки условий применения ККТ int
1017 ИНН ОФД string

Выходные параметры для отчета перерегистрации:

Параметр Описание Тип
1018 ИНН организации string
1037 Регистрационный номер устройства string
1062 Системы налогообложения int
1001 Признак автоматического режима bool
1002 Признак автономного режма bool
1056 Признак шифрования bool
1108 Признак ККТ для расчетов в сети Интернет bool
1109 Признак расчетов за услуги bool
1110 Признак АС БСО bool
1290 Признаки условий применения ККТ int
1017 ИНН ОФД string
1205 Коды причин перерегистрации int

Выходные параметры для отчета о закрытии ФН:

Параметр Описание Тип
1018 ИНН организации string
1037 Регистрационный номер устройства string

Выходные параметры для отчетов об открытии / закрытии смены:

Параметр Описание Тип
1038 или LIBFPTR_PARAM_SHIFT_NUMBER Номер смены int

Выходные параметры для чеков и БСО:

Параметр Описание Тип
1054 Признак расчета int
1020 Сумма расчета double
LIBFPTR_PARAM_HAS_ADDITIONAL_DATA Есть дополнительные данные по чеку.Все реквизиты ниже доступны только в случае, если этот параметр равен true bool
1031 Сумма по чеку (БСО) наличными double
1081 Сумма по чеку (БСО) безналичными double
1215 Сумма по чеку (БСО) предоплатой double
1216 Сумма по чеку (БСО) постоплатой double
1217 Сумма по чеку (БСО) встречным предоставлением double
1102 Сумма НДС чека по ставке 20% double
1103 Сумма НДС чека по ставке 10% double
1104 Сумма расчёта по чеку с НДС по ставке 0% double
1105 Сумма расчёта по чека без НДС double
1106 Сумма НДС чека по расч. ставке 20/120 double
1107 Сумма НДС чека по расч. ставке 10/110 double
1192 Дополнительный реквизит чека (БСО) string
LIBFPTR_PARAM_FISCAL_SIGN_ARCHIVE Фискальный признак сообщения для архива (ФПА) bytearray

Выходные параметры для отчета о состоянии расчетов:

Параметр Описание Тип
1097 Количество непереданных ФД int
1098 Дата первого из непереданных ФД datetime

Значение реквизита 1062 (системы налогообложения) - битовое поле, значениями которого являются одно или несколько из следующих значений:

Возможные значения реквизитов 1101 и 1205 приведены в разделе Перерегистрация ККТ.

Возможные значения для реквизита 1054 (признак расчета):

Детализация ошибки ФН

Запрос детализации ошибки ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ERROR_DETAIL);
libfptr_fn_query_data(fptr);

std::vector<uchar> details(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_FN_ERROR_DATA,
                                       &details[0], details.size());
if (size > details.size())
{
    details.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_FN_ERROR_DATA,
                                &details[0], details.size());
}
details.resize(size);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ERROR_DETAIL);
fptr.fnQueryData();

std::vector<uchar> details = fptr.getParamByteArray(LIBFPTR_PARAM_FN_ERROR_DATA);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_ERROR_DETAIL);
fptr.fnQueryData();

byte[] details = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_FN_ERROR_DATA);

Для запроса детализации ошибки ФН необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_ERROR_DETAIL.

Детализация ошибки будет доступна в выходном параметре LIBFPTR_PARAM_FN_ERROR_DATA.

Ресурс памяти ФН

Запрос ресурса памяти ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_FREE_MEMORY);
libfptr_fn_query_data(fptr);

uint documentsCount = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);
uint freeMemory     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FREE_MEMORY);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_FREE_MEMORY);
fptr.fnQueryData();

uint documentsCount = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);
uint freeMemory     = fptr.getParamInt(LIBFPTR_PARAM_FREE_MEMORY);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_FREE_MEMORY);
fptr.fnQueryData();

long documentsCount = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
long freeMemory     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FREE_MEMORY);

Для запроса ресурса свободной памяти ФН необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_FREE_MEMORY.

Детализация ошибки будет доступна в выходном параметре LIBFPTR_PARAM_FN_ERROR_DATA.

Выходные параметры:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Ресурс данных 5-летнего хранения. Приблизительное количество документов, которое можно создать в ФН int
LIBFPTR_PARAM_FREE_MEMORY Ресурс данных 30-дневного хранения. Размер свободной области (в килобайтах) для записи документов. После 30 дней работы значение может колебаться возле постоянного уровня int

Ошибки обмена с ИСМ

Запрос ошибок обмена с ИСМ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ISM_ERRORS);
libfptr_fn_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = 0;

int networkError    = libfptr_get_param_int(fptr, LIBFPTR_PARAM_NETWORK_ERROR);
size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_NETWORK_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_NETWORK_ERROR_TEXT, &str[0], str.size());
}
std::wstring networkErrorText = std::wstring(&str[0]);

int ismError        = libfptr_get_param_int(fptr, LIBFPTR_PARAM_ISM_ERROR);
size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_ISM_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_ISM_ERROR_TEXT, &str[0], str.size());
}
std::wstring ismErrorText = std::wstring(&str[0]);

int fnError         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_ERROR);
size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_ERROR_TEXT, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_FN_ERROR_TEXT, &str[0], str.size());
}
std::wstring fnErrorText = std::wstring(&str[0]);

int documentNumber  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int commandCode     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COMMAND_CODE);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ISM_ERRORS);
fptr.fnQueryData();

uint networkError             = fptr.getParamInt(LIBFPTR_PARAM_NETWORK_ERROR);
std::wstring networkErrorText = fptr.getParamString(LIBFPTR_PARAM_NETWORK_ERROR_TEXT);

uint ismError                 = fptr.getParamInt(LIBFPTR_PARAM_ISM_ERROR);
std::wstring nismErrorText    = fptr.getParamString(LIBFPTR_PARAM_ISM_ERROR_TEXT);

uint fnError                  = fptr.getParamInt(LIBFPTR_PARAM_FN_ERROR);
std::wstring nfnErrorText     = fptr.getParamString(LIBFPTR_PARAM_FN_ERROR_TEXT);

uint documentNumber           = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint commandCode              = fptr.getParamInt(LIBFPTR_PARAM_COMMAND_CODE);

std::tm dateTime         = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_ISM_ERRORS);
fptr.fnQueryData();

long networkError        = fptr.getParamInt(IFptr.LIBFPTR_PARAM_NETWORK_ERROR);
String networkErrorText  = fptr.getParamString(IFptr.LIBFPTR_PARAM_NETWORK_ERROR_TEXT);

long ismError            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_ISM_ERROR);
String ismErrorText      = fptr.getParamString(IFptr.LIBFPTR_PARAM_ISM_ERROR_TEXT);

long fnError             = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_ERROR);
String fnErrorText       = fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_ERROR_TEXT);

long documentNumber      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long commandCode         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COMMAND_CODE);

Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса ошибок обмена с ИСМ необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_ISM_ERRORS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Дата и время последнего успешного соединения с ИСМ datetime
LIBFPTR_PARAM_NETWORK_ERROR Код ошибки сети int
LIBFPTR_PARAM_NETWORK_ERROR_TEXT Текст ошибки сети string
LIBFPTR_PARAM_ISM_ERROR Код ошибки ИСМ int
LIBFPTR_PARAM_ISM_ERROR_TEXT Текст ошибки ИСМ string
LIBFPTR_PARAM_FN_ERROR Код ошибки ФН int
LIBFPTR_PARAM_FN_ERROR_TEXT Текст ошибки ФН string
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер ФД, на котором произошла ошибка int
LIBFPTR_PARAM_COMMAND_CODE Команда ФН, на которой произошла ошибка int

Статус информационного обмена с ИСМ

Запрос статуса информационного обмена с ИСМ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ISM_EXCHANGE_STATUS);
libfptr_fn_query_data(fptr);

int unsentCount         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);
int firstUnsentNumber   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_ISM_EXCHANGE_STATUS);
fptr.fnQueryData();

uint unsentCount            = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);
uint firstUnsentNumber      = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
std::tm dateTime            = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_ISM_EXCHANGE_STATUS);
fptr.fnQueryData();

long unsentCount         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
long firstUnsentNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
Date dateTime            = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса cтатуса информационного обмена с ИСМ необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_ISM_EXCHANGE_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество непереданных уведомлений int
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер первого непереданного уведомления int
LIBFPTR_PARAM_DATE_TIME Дата и время первого непереданного уведомления datetime

Состояние работы с КМ

Запрос состояния работы с КМ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_MARKING_MODE_STATUS);
libfptr_fn_query_data(fptr);

int markingModeCheckingStatus = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_MODE_CHECKING_STATUS);
int markCheckingCount = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARK_CHECKING_COUNT);
int markSoldCount = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARK_SOLD_COUNT);
bool noticeIsBegin = libfptr_get_param_bool(fptr, LIBFPTR_PARAM_NOTICE_IS_BEGIN);
int noticeFreeMemory = libfptr_get_param_int(fptr, LIBFPTR_PARAM_NOTICE_FREE_MEMORY);
int noticeCount = libfptr_get_param_int(fptr, LIBFPTR_PARAM_NOTICE_COUNT);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_MARKING_MODE_STATUS);
fptr.fnQueryData();

uint markingModeCheckingStatus = fptr.getParamInt(LIBFPTR_PARAM_MARKING_MODE_CHECKING_STATUS);
uint markCheckingCount = fptr.getParamInt(LIBFPTR_PARAM_MARK_CHECKING_COUNT);
uint markSoldCount = fptr.getParamInt(LIBFPTR_PARAM_MARK_SOLD_COUNT);
bool noticeIsBegin = fptr.getParamBool(LIBFPTR_PARAM_NOTICE_IS_BEGIN);
uint noticeFreeMemory = fptr.getParamInt(LIBFPTR_PARAM_NOTICE_FREE_MEMORY);
uint noticeCount = fptr.getParamInt(LIBFPTR_PARAM_NOTICE_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_MARKING_MODE_STATUS);
fptr.fnQueryData();

long markingModeCheckingStatus = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_MODE_CHECKING_STATUS);
long markCheckingCount = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARK_CHECKING_COUNT);
long markSoldCount = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARK_SOLD_COUNT);
boolean noticeIsBegin = fptr.getParamBool(IFptr.LIBFPTR_PARAM_NOTICE_IS_BEGIN);
long noticeFreeMemory = fptr.getParamInt(IFptr.LIBFPTR_PARAM_NOTICE_FREE_MEMORY);
long noticeCount = fptr.getParamInt(IFptr.LIBFPTR_PARAM_NOTICE_COUNT);

Для запроса состояния работы с КМ необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_MARKING_MODE_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_MARKING_MODE_CHECKING_STATUS Состояние проверки КМ в ФН int
LIBFPTR_PARAM_MARK_CHECKING_COUNT Количество проверенных КМ в таблице проверенных КМ int
LIBFPTR_PARAM_MARK_SOLD_COUNT Количество реализованных КМ int
LIBFPTR_PARAM_NOTICE_IS_BEGIN Формирование уведомления bool
LIBFPTR_PARAM_NOTICE_FREE_MEMORY Ресурс области уведомлений int
LIBFPTR_PARAM_NOTICE_COUNT Количество неотправленных уведомлений int
LIBFPTR_PARAM_MARK_CHECKING_STATUS_IN_CASH Статус проверки КМ в ККТ int
LIBFPTR_PARAM_MARK_CHECKING_TYPE_IN_CASH Тип проверки КМ в ККТ int
LIBFPTR_PARAM_MARK_CHECKING_STAGE_IN_CASH Этап проверки КМ в ККТ int

Состояние проверки КМ в ФН (LIBFPTR_PARAM_MARKING_MODE_CHECKING_STATUS) может принимать следующие значения:

Количество проверок КМ (LIBFPTR_PARAM_MARK_CHECKING_COUNT) показывает количество сохраненных результатов проверки КМ.

Количество реализованных КМ (LIBFPTR_PARAM_MARK_SOLD_COUNT) показывает количество КМ включенных в уведомление о реализации

Формирование уведомления (LIBFPTR_PARAM_NOTICE_IS_BEGIN) в случае значения true означает, что формирование уведомления начато, иначе - уведомление не формируется.

Ресурс области уведомлений (LIBFPTR_PARAM_NOTICE_FREE_MEMORY) может принимать следующие значения:

Количество неотправленных уведомлений (LIBFPTR_PARAM_NOTICE_COUNT) показывает количество неподтверждённых или невыгруженных уведомлений о реализации маркированного товара.

Статус проверки КМ в ККТ (LIBFPTR_PARAM_MARK_CHECKING_STATUS_IN_CASH) может принимать следующие значения:

Тип проверки КМ в ККТ (LIBFPTR_PARAM_MARK_CHECKING_TYPE_IN_CASH) может принимать следующие значения:

Этап проверки КМ в ККТ (LIBFPTR_PARAM_MARK_CHECKING_STAGE_IN_CASH) может принимать следующие значения:

Время выполнения проверки КМ

Запрос времени выполнения проверки КМ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_CHECK_MARK_TIME);
libfptr_fn_query_data(fptr);

int fnCheckMarkTime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FN_CHECK_MARK_TIME);
int sendingMarkTime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SENDING_MARK_TIME);
int markingServerExchangeTime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MARKING_SERVER_EXCHANGE_TIME);
int fullSendingMarkTime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_FULL_SENDING_MARK_TIME);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_CHECK_MARK_TIME);
fptr.fnQueryData();

uint fnCheckMarkTime = fptr.getParamInt(LIBFPTR_PARAM_FN_CHECK_MARK_TIME);
uint sendingMarkTime = fptr.getParamInt(LIBFPTR_PARAM_SENDING_MARK_TIME);
uint markingServerExchangeTime = fptr.getParamInt(LIBFPTR_PARAM_MARKING_SERVER_EXCHANGE_TIME);
uint fullSendingMarkTime = fptr.getParamInt(LIBFPTR_PARAM_FULL_SENDING_MARK_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_CHECK_MARK_TIME);
fptr.fnQueryData();

long fnCheckMarkTime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_CHECK_MARK_TIME);
long sendingMarkTime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SENDING_MARK_TIME);
long markingServerExchangeTime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_SERVER_EXCHANGE_TIME);
long fullSendingMarkTime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_FULL_SENDING_MARK_TIME);

Для запроса состояния работы с КМ необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_CHECK_MARK_TIME.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_FN_CHECK_MARK_TIME Время проверки в ФН, мс int
LIBFPTR_PARAM_SENDING_MARK_TIME Время отправки, мс int
LIBFPTR_PARAM_MARKING_SERVER_EXCHANGE_TIME Время обмена с сервером, мс int
LIBFPTR_PARAM_FULL_SENDING_MARK_TIME Полное время проверки, мс int

Параметр LIBFPTR_PARAM_FN_CHECK_MARK_TIME показывает время проверки ФН в мс. Если проверка в ФН еще не была проведена, то равно 0. Включает в себя время на проверку в КМ и получение пакета для обмена с сервером.

Параметр LIBFPTR_PARAM_SENDING_MARK_TIME показывает время открытия соединения и отправки данных в последней попытке в мс. Если ответ не был получен, то равно 0. Если ККТ работает в автономном режиме, то всегда равно 0.

Параметр LIBFPTR_PARAM_MARKING_SERVER_EXCHANGE_TIME показывает время открытия соединения, отправки данных и получения ответа от сервера в последней попытке. Если ответ не был получен, то равно 0. Если ККТ работает в автономном режиме, то всегда равно 0.

Параметр LIBFPTR_PARAM_FULL_SENDING_MARK_TIME показывает полное время проверки, включая повторы. Также к полному времени проверки добавляется время команды ФН на повторное получение пакета для обмена.

Счетчики ФН

В ФН 1.2 доступны следующие счетчики:

Счетчики итогов операций

Чтение счетчиков итогов операций ФН по типу расчета

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_TOTALS);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_COUNTERS_TYPE, LIBFPTR_FNCT_SHIFT);
libfptr_fn_query_data(fptr);

uint receipts         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);
uint corrections      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_CORRECTIONS_COUNT);

double receiptsSum    = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPTS_SUM);
double correctionsSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_CORRECTIONS_SUM);

double cashSum        = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_CASH);
double noncashSum     = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY);
double prepaidSum     = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID);
double creditSum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT);
double barterSum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_OTHER);

double vat20Sum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT20);
double vat10Sum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT10);
double vat120Sum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT120);
double vat110Sum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT110);
double vat0Sum        = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT0);
double vatNoSum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_NO);

fptr.setParam(LIBFPTR_PARAM_FN_DATA_TYPE, LIBFPTR_FNDT_TOTALS);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(LIBFPTR_PARAM_FN_COUNTERS_TYPE, LIBFPTR_FNCT_SHIFT);
fptr.fnQueryData();

uint receipts         = fptr.getParamInt(LIBFPTR_PARAM_RECEIPTS_COUNT);
uint corrections      = fptr.getParamInt(LIBFPTR_PARAM_CORRECTIONS_COUNT);

double receiptsSum    = fptr.getParamDouble(LIBFPTR_PARAM_RECEIPTS_SUM);
double correctionsSum = fptr.getParamDouble(LIBFPTR_PARAM_CORRECTIONS_SUM);

double cashSum        = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_CASH);
double noncashSum     = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY);
double prepaidSum     = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID);
double creditSum      = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT);
double barterSum      = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_OTHER);

double vat20Sum       = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT20);
double vat10Sum       = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT10);
double vat120Sum      = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT120);
double vat110Sum      = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT110);
double vat0Sum        = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT0);
double vatNoSum       = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_NO);

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_TOTALS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_FN_COUNTERS_TYPE, IFptr.LIBFPTR_FNCT_SHIFT);
fptr.fnQueryData();

long receipts         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);
long corrections      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_CORRECTIONS_COUNT);

double receiptsSum    = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPTS_SUM);
double correctionsSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CORRECTIONS_SUM);

double cashSum        = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_CASH);
double noncashSum     = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY);
double prepaidSum     = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID);
double creditSum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT);
double barterSum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_OTHER);

double vat20Sum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT20);
double vat10Sum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT10);
double vat120Sum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT120);
double vat110Sum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT110);
double vat0Sum        = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT0);
double vatNoSum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_NO);

Для запроса счетчиков итогов операций ФН по заданному типу расчетов необходимо вызвать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_TOTALS и передать тип расчета в параметре LIBFPTR_PARAM_RECEIPT_TYPE и тип счетчиков ФН в параметре LIBFPTR_PARAM_FN_COUNTERS_TYPE.

Выходные параметры:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int
LIBFPTR_PARAM_CORRECTIONS_COUNT Количество коррекций int
LIBFPTR_PARAM_RECEIPTS_SUM Итоговая сумма чеков (включая коррекции) double
LIBFPTR_PARAM_CORRECTIONS_SUM Сумма коррекций double
LIBFPTR_PARAM_PAYMENTS_SUM_CASH Сумма наличных оплат double
LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY Сумма безналичных оплат double
LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID Сумма оплат авансом double
LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT Сумма оплат кредитом double
LIBFPTR_PARAM_PAYMENTS_SUM_OTHER Сумма оплат встречным предоставлением double
LIBFPTR_PARAM_TAXES_SUM_VAT20 Сумма НДС 20% double
LIBFPTR_PARAM_TAXES_SUM_VAT10 Сумма НДС 10% double
LIBFPTR_PARAM_TAXES_SUM_VAT120 Сумма НДС 20/120 double
LIBFPTR_PARAM_TAXES_SUM_VAT110 Сумма НДС 10/110 double
LIBFPTR_PARAM_TAXES_SUM_VAT0 Сумма НДС 0% double
LIBFPTR_PARAM_TAXES_SUM_NO Сумма без НДС double

Чтение счетчиков итогов операций ФН

// Вспомогательная функция для чтения строковых параметров
std::wstring readStringAttribute(libfptr_handle fptr, int paramNumber) {
    std::vector<wchar_t> str(32);
    int size = libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    if (size > str.size()) {
        str.resize(size);
        libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    }
    return std::wstring(&str[0]);
}

// Вспомогательная функция чтения следующей записи
int readNextRecord(libfptr_handle fptr, const std::wstring &recordsID) {
    libfptr_set_param_str(fptr, LIBFPTR_PARAM_RECORDS_ID, recordsID.c_str());
    return libfptr_read_next_record(fptr);
}

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECORDS_TYPE, LIBFPTR_RT_FN_SUM_COUNTERS);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_COUNTERS_TYPE, LIBFPTR_FNCT_SHIFT);
libfptr_begin_read_records(handle);
std::wstring recordsID = readStringAttribute(fptr, LIBFPTR_PARAM_RECORDS_ID);
uint shiftNumber       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptsAll       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);
uint correctionsAll    = libfptr_get_param_int(fptr, LIBFPTR_PARAM_CORRECTIONS_COUNT);

while (readNextRecord(fptr, recordsID) == LIBFPTR_OK)
{    
    uint receiptType      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);

    uint receipts         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);
    uint corrections      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_CORRECTIONS_COUNT);

    double receiptsSum    = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPTS_SUM);
    double correctionsSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_CORRECTIONS_SUM);

    double cashSum        = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_CASH);
    double noncashSum     = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY);
    double prepaidSum     = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID);
    double creditSum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT);
    double barterSum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_PAYMENTS_SUM_OTHER);

    double vat20Sum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT20);
    double vat10Sum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT10);
    double vat120Sum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT120);
    double vat110Sum      = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT110);
    double vat0Sum        = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_VAT0);
    double vatNoSum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_TAXES_SUM_NO);
}

libfptr_set_param_str(fptr, LIBFPTR_PARAM_RECORDS_ID, recordsID.c_str());
libfptr_end_read_records(fptr);

// Вспомогательная функция чтения следующей записи
int readNextRecord(IFptr &fptr, const std::wstring &recordsID)
{
    fptr.setParam(LIBFPTR_PARAM_RECORDS_ID, recordsID);
    return fptr.readNextRecord();
}

fptr.setParam(LIBFPTR_PARAM_RECORDS_TYPE, LIBFPTR_RT_FN_SUM_COUNTERS);
fptr.setParam(LIBFPTR_PARAM_FN_COUNTERS_TYPE, LIBFPTR_FNCT_SHIFT);
fptr.beginReadRecords();
std::wstring recordsID = fptr.getParamString(LIBFPTR_PARAM_RECORDS_ID);
uint shiftNumber       = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptsAll       = fptr.getParamInt(LIBFPTR_PARAM_RECEIPTS_COUNT);
uint correctionsAll    = fptr.getParamInt(LIBFPTR_PARAM_CORRECTIONS_COUNT);

while (readNextRecord(fptr, recordsID) == LIBFPTR_OK)
{
    uint receiptType      = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_TYPE);

    uint receipts         = fptr.getParamInt(LIBFPTR_PARAM_RECEIPTS_COUNT);
    uint corrections      = fptr.getParamInt(LIBFPTR_PARAM_CORRECTIONS_COUNT);

    double receiptsSum    = fptr.getParamDouble(LIBFPTR_PARAM_RECEIPTS_SUM);
    double correctionsSum = fptr.getParamDouble(LIBFPTR_PARAM_CORRECTIONS_SUM);

    double cashSum        = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_CASH);
    double noncashSum     = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY);
    double prepaidSum     = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID);
    double creditSum      = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT);
    double barterSum      = fptr.getParamDouble(LIBFPTR_PARAM_PAYMENTS_SUM_OTHER);

    double vat20Sum       = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT20);
    double vat10Sum       = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT10);
    double vat120Sum      = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT120);
    double vat110Sum      = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT110);
    double vat0Sum        = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_VAT0);
    double vatNoSum       = fptr.getParamDouble(LIBFPTR_PARAM_TAXES_SUM_NO);
}

fptr.setParam(LIBFPTR_PARAM_RECORDS_ID, recordsID);
fptr.endReadRecords();

// Вспомогательная функция чтения следующей записи
int readNextRecord(IFptr fptr, String recordsID) {
    fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID);
    return fptr.readNextRecord();
}

fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_TYPE, IFptr.LIBFPTR_RT_FN_SUM_COUNTERS);
fptr.setParam(IFptr.LIBFPTR_PARAM_FN_COUNTERS_TYPE, IFptr.LIBFPTR_FNCT_SHIFT);
fptr.beginReadRecords();
String recordsID    = fptr.getParamString(IFptr.LIBFPTR_PARAM_RECORDS_ID);
long shiftNumber    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
long receiptsAll    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);
long correctionsAll = fptr.getParamInt(IFptr.LIBFPTR_PARAM_CORRECTIONS_COUNT);

while (readNextRecord(fptr, recordsID) == IFptr.LIBFPTR_OK) {
    long receiptType      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);

    long receipts         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);
    long corrections      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_CORRECTIONS_COUNT);

    double receiptsSum    = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPTS_SUM);
    double correctionsSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CORRECTIONS_SUM);

    double cashSum        = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_CASH);
    double noncashSum     = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY);
    double prepaidSum     = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID);
    double creditSum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT);
    double barterSum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_PAYMENTS_SUM_OTHER);

    double vat20Sum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT20);
    double vat10Sum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT10);
    double vat120Sum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT120);
    double vat110Sum      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT110);
    double vat0Sum        = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_VAT0);
    double vatNoSum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_TAXES_SUM_NO);
}

fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID);
fptr.endReadRecords();

Также можно запросить счетчики итогов сразу по всем типам расчетов. Для этого нужно вызвать метод beginReadRecords() с типом данных LIBFPTR_PARAM_RECORDS_TYPE равным LIBFPTR_RT_FN_SUM_COUNTERS. В параметре LIBFPTR_PARAM_FN_COUNTERS_TYPE нужно указать тип счетчиков.

Выходным параметрами будут следующие значения:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_NUMBER Номер смены int
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int
LIBFPTR_PARAM_CORRECTIONS_COUNT Количество коррекций int

Каждый успешный вызов метода readNextRecord() заполняет следующие параметры:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_TYPE Тип расчета int
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int
LIBFPTR_PARAM_CORRECTIONS_COUNT Количество коррекций int
LIBFPTR_PARAM_RECEIPTS_SUM Итоговая сумма чеков (включая коррекции) double
LIBFPTR_PARAM_CORRECTIONS_SUM Сумма коррекций double
LIBFPTR_PARAM_PAYMENTS_SUM_CASH Сумма наличных оплат double
LIBFPTR_PARAM_PAYMENTS_SUM_ELECTRONICALLY Сумма безналичных оплат double
LIBFPTR_PARAM_PAYMENTS_SUM_PREPAID Сумма оплат авансом double
LIBFPTR_PARAM_PAYMENTS_SUM_CREDIT Сумма оплат кредитом double
LIBFPTR_PARAM_PAYMENTS_SUM_OTHER Сумма оплат встречным предоставлением double
LIBFPTR_PARAM_TAXES_SUM_VAT20 Сумма НДС 20% double
LIBFPTR_PARAM_TAXES_SUM_VAT10 Сумма НДС 10% double
LIBFPTR_PARAM_TAXES_SUM_VAT120 Сумма НДС 20/120 double
LIBFPTR_PARAM_TAXES_SUM_VAT110 Сумма НДС 10/110 double
LIBFPTR_PARAM_TAXES_SUM_VAT0 Сумма НДС 0% double
LIBFPTR_PARAM_TAXES_SUM_NO Сумма без НДС double

Тип расчета (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Тип счетчиков ФН (LIBFPTR_PARAM_FN_COUNTERS_TYPE) может принимать следующие значения:

Счетчики количеств операций

Чтение счетчиков количеств операций ФН

// Вспомогательная функция для чтения строковых параметров
std::wstring readStringAttribute(libfptr_handle fptr, int paramNumber) {
    std::vector<wchar_t> str(32);
    int size = libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    if (size > str.size()) {
        str.resize(size);
        libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    }
    return std::wstring(&str[0]);
}

// Вспомогательная функция чтения следующей записи
int readNextRecord(libfptr_handle fptr, const std::wstring &recordsID) {
    libfptr_set_param_str(fptr, LIBFPTR_PARAM_RECORDS_ID, recordsID.c_str());
    return libfptr_read_next_record(fptr);
}

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECORDS_TYPE, LIBFPTR_RT_FN_QUANTITY_COUNTERS);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_COUNTERS_TYPE, LIBFPTR_FNCT_SHIFT);
libfptr_begin_read_records(handle);
std::wstring recordsID = readStringAttribute(fptr, LIBFPTR_PARAM_RECORDS_ID);
uint shiftNumber       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);
uint countAll          = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);

while (readNextRecord(fptr, recordsID) == LIBFPTR_OK)
{    
    uint receiptType = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);
    uint count       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);
    uint corrections = libfptr_get_param_int(fptr, LIBFPTR_PARAM_CORRECTIONS_COUNT);
}

libfptr_set_param_str(fptr, LIBFPTR_PARAM_RECORDS_ID, recordsID.c_str());
libfptr_end_read_records(fptr);

// Вспомогательная функция чтения следующей записи
int readNextRecord(IFptr &fptr, const std::wstring &recordsID)
{
    fptr.setParam(LIBFPTR_PARAM_RECORDS_ID, recordsID);
    return fptr.readNextRecord();
}

fptr.setParam(LIBFPTR_PARAM_RECORDS_TYPE, LIBFPTR_RT_FN_QUANTITY_COUNTERS);
fptr.setParam(LIBFPTR_PARAM_FN_COUNTERS_TYPE, LIBFPTR_FNCT_SHIFT);
fptr.beginReadRecords();
std::wstring recordsID = fptr.getParamString(LIBFPTR_PARAM_RECORDS_ID);
uint shiftNumber       = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER);
uint countAll          = fptr.getParamInt(LIBFPTR_PARAM_RECEIPTS_COUNT);

while (readNextRecord(fptr, recordsID) == LIBFPTR_OK)
{
    uint receiptType = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_TYPE);
    uint count       = fptr.getParamInt(LIBFPTR_PARAM_RECEIPTS_COUNT);
    uint corrections = fptr.getParamInt(LIBFPTR_PARAM_CORRECTIONS_COUNT);
}

fptr.setParam(LIBFPTR_PARAM_RECORDS_ID, recordsID);
fptr.endReadRecords();

// Вспомогательная функция чтения следующей записи
int readNextRecord(IFptr fptr, String recordsID) {
    fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID);
    return fptr.readNextRecord();
}

fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_TYPE, IFptr.LIBFPTR_RT_FN_QUANTITY_COUNTERS);
fptr.setParam(IFptr.LIBFPTR_PARAM_FN_COUNTERS_TYPE, IFptr.LIBFPTR_FNCT_SHIFT);
fptr.beginReadRecords();
String recordsID = fptr.getParamString(IFptr.LIBFPTR_PARAM_RECORDS_ID);
long shiftNumber = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
long countAll    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);

while (readNextRecord(fptr, recordsID) == IFptr.LIBFPTR_OK) {
    long receiptType = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
    long count       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);
    long corrections = fptr.getParamInt(IFptr.LIBFPTR_PARAM_CORRECTIONS_COUNT);
}

fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID);
fptr.endReadRecords();

Для чтения счетчиков количеств операций ФН необходимо вызвать метод beginReadRecords() с типом данных LIBFPTR_PARAM_RECORDS_TYPE равным LIBFPTR_RT_FN_QUANTITY_COUNTERS. В параметре LIBFPTR_PARAM_FN_COUNTERS_TYPE нужно указать тип счетчиков.

Выходным параметрами будут следующие значения:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_NUMBER Номер смены int
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int

Каждый успешный вызов метода readNextRecord() заполняет следующие параметры:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_TYPE Тип расчета int
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int
LIBFPTR_PARAM_CORRECTIONS_COUNT Количество коррекций int

Тип расчета (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Тип счетчиков ФН (LIBFPTR_PARAM_FN_COUNTERS_TYPE) может принимать следующие значения:

Счетчики итогов непереданных документов

Чтение счетчиков итогов непереданных документов ФН

// Вспомогательная функция для чтения строковых параметров
std::wstring readStringAttribute(libfptr_handle fptr, int paramNumber) {
    std::vector<wchar_t> str(32);
    int size = libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    if (size > str.size()) {
        str.resize(size);
        libfptr_get_param_str(fptr, paramNumber, &str[0], str.size());
    }
    return std::wstring(&str[0]);
}

// Вспомогательная функция чтения следующей записи
int readNextRecord(libfptr_handle fptr, const std::wstring &recordsID) {
    libfptr_set_param_str(fptr, LIBFPTR_PARAM_RECORDS_ID, recordsID.c_str());
    return libfptr_read_next_record(fptr);
}

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECORDS_TYPE, LIBFPTR_RT_FN_UNSENT_DOCS_COUNTERS);
libfptr_begin_read_records(handle);
std::wstring recordsID = readStringAttribute(fptr, LIBFPTR_PARAM_RECORDS_ID);
uint countAll = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);

while (readNextRecord(fptr, recordsID) == LIBFPTR_OK)
{    
    uint receiptType = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);
    uint count       = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPTS_COUNT);
    double sum       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPTS_SUM);
}

libfptr_set_param_str(fptr, LIBFPTR_PARAM_RECORDS_ID, recordsID.c_str());
libfptr_end_read_records(fptr);

// Вспомогательная функция чтения следующей записи
int readNextRecord(IFptr &fptr, const std::wstring &recordsID)
{
    fptr.setParam(LIBFPTR_PARAM_RECORDS_ID, recordsID);
    return fptr.readNextRecord();
}

fptr.setParam(LIBFPTR_PARAM_RECORDS_TYPE, LIBFPTR_RT_FN_UNSENT_DOCS_COUNTERS);
fptr.beginReadRecords();
std::wstring recordsID = fptr.getParamString(LIBFPTR_PARAM_RECORDS_ID);
uint countAll = fptr.getParamInt(LIBFPTR_PARAM_RECEIPTS_COUNT);

while (readNextRecord(fptr, recordsID) == LIBFPTR_OK)
{
    uint receiptType = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
    uint count       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);
    double sum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPTS_SUM);
}

fptr.setParam(LIBFPTR_PARAM_RECORDS_ID, recordsID);
fptr.endReadRecords();

// Вспомогательная функция чтения следующей записи
int readNextRecord(IFptr fptr, String recordsID) {
    fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID);
    return fptr.readNextRecord();
}

fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_TYPE, IFptr.LIBFPTR_RT_FN_UNSENT_DOCS_COUNTERS);
fptr.beginReadRecords();
String recordsID = fptr.getParamString(IFptr.LIBFPTR_PARAM_RECORDS_ID);
long countAll = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);

while (readNextRecord(fptr, recordsID) == IFptr.LIBFPTR_OK) {
    long receiptType = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
    long count       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPTS_COUNT);
    double sum       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPTS_SUM);
}

fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID);
fptr.endReadRecords();

Для чтения счетчиков количеств операций ФН необходимо вызвать метод beginReadRecords() с типом данных LIBFPTR_PARAM_RECORDS_TYPE равным LIBFPTR_RT_FN_UNSENT_DOCS_COUNTERS.

Выходным параметрами будут следующие значения:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int

Каждый успешный вызов метода readNextRecord() заполняет следующие параметры:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_TYPE Тип расчета int
LIBFPTR_PARAM_RECEIPTS_COUNT Общее количество чеков (включая коррекции) int
LIBFPTR_PARAM_RECEIPTS_SUM Итоговая сумма чеков (включая коррекции) double

Тип расчета (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Регистрация ККТ

Регистрация ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_OPERATION_TYPE, LIBFPTR_FNOP_REGISTRATION);

libfptr_set_param_str(fptr, 1060, L"www.nalog.ru");

libfptr_set_param_str(fptr, 1009, L"Улица свободы, 42");
libfptr_set_param_str(fptr, 1018, L"135792468001");
libfptr_set_param_str(fptr, 1048, L"Иванов Иван Иванович");
libfptr_set_param_int(fptr, 1062, LIBFPTR_TT_OSN | LIBFPTR_TT_PATENT);
libfptr_set_param_str(fptr, 1117, L"my-company@mail.ru");

libfptr_set_param_str(fptr, 1187, L"Улица свободы, 45");
libfptr_set_param_str(fptr, 1037, L"12345678900987654321");
libfptr_set_param_int(fptr, 1209, LIBFPTR_FFD_1_0_5);
libfptr_set_param_bool(fptr, 1001, false);
libfptr_set_param_str(fptr, 1036, L"513");
libfptr_set_param_bool(fptr, 1002, false);
libfptr_set_param_bool(fptr, 1056, false);
libfptr_set_param_bool(fptr, 1108, false);
libfptr_set_param_bool(fptr, 1109, false);
libfptr_set_param_bool(fptr, 1110, false);
libfptr_set_param_bool(fptr, 1126, false);
libfptr_set_param_bool(fptr, 1193, true);
libfptr_set_param_bool(fptr, 1207, false);
libfptr_set_param_bool(fptr, 1221, false);

libfptr_set_param_str(fptr, 1017, L"9715260691");
libfptr_set_param_str(fptr, 1046, L"ООО \"Эвотор ОФД\"");

libfptr_fn_operation(fptr);

fptr.setParam(LIBFPTR_PARAM_FN_OPERATION_TYPE, LIBFPTR_FNOP_REGISTRATION);

fptr.setParam(1060, L"www.nalog.ru");

fptr.setParam(1009, L"Улица свободы, 42");
fptr.setParam(1018, L"135792468001");
fptr.setParam(1048, L"Иванов Иван Иванович");
fptr.setParam(1062, LIBFPTR_TT_OSN | LIBFPTR_TT_PATENT);
fptr.setParam(1117, L"my-company@mail.ru");

fptr.setParam(1187, L"Улица свободы, 45");
fptr.setParam(1037, L"12345678900987654321");
fptr.setParam(1209, LIBFPTR_FFD_1_0_5);
fptr.setParam(1001, false);
fptr.setParam(1036, L"513");
fptr.setParam(1002, false);
fptr.setParam(1056, false);
fptr.setParam(1108, false);
fptr.setParam(1109, false);
fptr.setParam(1110, false);
fptr.setParam(1126, false);
fptr.setParam(1193, true);
fptr.setParam(1207, false);
fptr.setParam(1221, false);

fptr.setParam(1017, L"12345678910");
fptr.setParam(1046, L"ООО \"ОФД\"");

fptr.fnOperation();

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_OPERATION_TYPE, IFptr.LIBFPTR_FNOP_REGISTRATION);

fptr.setParam(1060, "www.nalog.gov.ru");

fptr.setParam(1009, "Улица свободы, 42");
fptr.setParam(1018, "135792468001");
fptr.setParam(1048, "Иванов Иван Иванович");
fptr.setParam(1062, IFptr.LIBFPTR_TT_OSN | IFptr.LIBFPTR_TT_PATENT);
fptr.setParam(1117, "my-company@mail.ru");

fptr.setParam(1187, "Улица свободы, 45");
fptr.setParam(1037, "12345678900987654321");
fptr.setParam(1209, IFptr.LIBFPTR_FFD_1_0_5);
fptr.setParam(1001, false);
fptr.setParam(1036, "513");
fptr.setParam(1002, false);
fptr.setParam(1056, false);
fptr.setParam(1108, false);
fptr.setParam(1109, false);
fptr.setParam(1110, false);
fptr.setParam(1126, false);
fptr.setParam(1193, true);
fptr.setParam(1207, false);
fptr.setParam(1221, false);

fptr.setParam(1017, "9715260691");
fptr.setParam(1046, "ООО \"Эвотор ОФД\"");

fptr.fnOperation()

Для регистрации ККТ необходимо вызвать метод fnOperation() с типом операции LIBFPTR_PARAM_FN_OPERATION_TYPE равным LIBFPTR_FNOP_REGISTRATION. Также необходимо указать параметры регистрации:

Параметр Описание Тип
1060 Адрес сайта ФНС string
1009 Адрес расчетов string
1018 ИНН организации string
1048 Название организации string
1062 Системы налогообложения int
1117 E-mail организации string
1187 Адрес места расчетов string
1037 Регистрационный номер устройства string
1209 Версия ФФД int
1001 Признак автоматического режима bool
1036 Номер автомата string
1002 Признак автономного режима bool
1056 Признак шифрования bool
1108 Признак ККТ для расчетов в сети Интернет bool
1109 Признак расчетов за услуги bool
1110 Признак АС БСО bool
1126 Признак проведения лотерей bool
1193 Признак проведения азартных игр bool
1207 Признак подакцизного товара bool
1221 Признак установки в автомате bool
LIBFPTR_PARAM_PAWN_SHOP_ACTIVITY Признак осуществления ломбардной деятельности bool
LIBFPTR_PARAM_INSURANCE_ACTIVITY Признак осуществления страховой деятельности bool
LIBFPTR_PARAM_TRADE_MARKED_PRODUCTS Признак торговли маркированными товарами bool
1017 ИНН ОФД string
1046 Название ОФД string

Значение реквизита 1062 (системы налогообложения) - битовое поле, значениями которого являются одно или несколько из следующих значений:

Реквизит 1209 (версия ФФД) может принимать следующие значения:

Перерегистрация ККТ

Для перерегистрации ККТ необходимо вызвать метод fnOperation() с типом операции LIBFPTR_PARAM_FN_OPERATION_TYPE равным LIBFPTR_FNOP_CHANGE_PARAMETERS. Список параметров перерегистрации приведен в разделе Регистрация ККТ.

Требуется указать причины перерегистрации в реквизите 1205 (битовое поле), который может принимать следующие значения:

На некоторых ККТ возможно отключить печать отчета о перерегистрации ККТ с помощью установки параметра LIBFPTR_PARAM_REPORT_ELECTRONICALLY в true. Если ККТ не поддерживает такой функционал, параметр будет проигнорирован и отчет будет напечатан.

Замена ФН

Для регистрации замены ФН необходимо вызвать метод fnOperation() с типом операции LIBFPTR_PARAM_FN_OPERATION_TYPE равным LIBFPTR_FNOP_CHANGE_FN. Список параметров перерегистрации приведен в разделе Регистрация ККТ.

В случае работы по ФФД ≥ 1.1 требуется указать причины перерегистрации в реквизите 1205 (битовое поле). Список возможных значений приведен в разделе Перерегистрация ККТ.

На некоторых ККТ возможно отключить печать отчета о регистрации замены ФН с помощью установки параметра LIBFPTR_PARAM_REPORT_ELECTRONICALLY в true. Если ККТ не поддерживает такой функционал, параметр будет проигнорирован и отчет будет напечатан.

Закрытие ФН

Закрытие ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_FN_OPERATION_TYPE, LIBFPTR_FNOP_CLOSE_ARCHIVE);
libfptr_fn_operation(fptr);

fptr.setParam(LIBFPTR_PARAM_FN_OPERATION_TYPE, LIBFPTR_FNOP_CLOSE_ARCHIVE);
fptr.fnOperation();

fptr.setParam(IFptr.LIBFPTR_PARAM_FN_OPERATION_TYPE, IFptr.LIBFPTR_FNOP_CLOSE_ARCHIVE);
fptr.fnOperation();

Для закрытия ФН необходимо вызвать метод fnOperation() с типом операции LIBFPTR_PARAM_FN_OPERATION_TYPE равным LIBFPTR_FNOP_CLOSE_ARCHIVE.

Нефискальная печать

Печать клише

Печать клише

libfptr_print_cliche(fptr);

fptr.printCliche();

fptr.printCliche();

Для печати запрограммированного в ККТ клише необходимо вызвать метод printCliche().

Клише автоматически печатается при закрытии всех документов (и фискальных, и нефискальных).

Печать текста

Печать строки

libfptr_set_param_str(fptr, LIBFPTR_PARAM_TEXT, L"Строка");
libfptr_print_text(fptr);

fptr.setParam(LIBFPTR_PARAM_TEXT, L"Строка");
fptr.printText();

fptr.setParam(IFptr.LIBFPTR_PARAM_TEXT, "Строка");
fptr.printText();

Печать строки с выравниванием по центру

libfptr_set_param_str(fptr, LIBFPTR_PARAM_TEXT, L"Строка");
libfptr_set_param_int(fptr, LIBFPTR_PARAM_ALIGNMENT, LIBFPTR_ALIGNMENT_CENTER);
libfptr_print_text(fptr);

fptr.setParam(LIBFPTR_PARAM_TEXT, L"Строка");
fptr.setParam(LIBFPTR_PARAM_ALIGNMENT, LIBFPTR_ALIGNMENT_CENTER);
fptr.printText();

fptr.setParam(IFptr.LIBFPTR_PARAM_TEXT, "Строка");
fptr.setParam(IFptr.LIBFPTR_PARAM_ALIGNMENT, IFptr.LIBFPTR_ALIGNMENT_CENTER);
fptr.printText();

Для печати строки необходимо вызвать метод printText() и задать следующие параметры:

Параметр Описание Тип Значение по умолчанию
LIBFPTR_PARAM_TEXT Строка для печати string Пустая строка
LIBFPTR_PARAM_ALIGNMENT Выравнивание int LIBFPTR_ALIGNMENT_LEFT
LIBFPTR_PARAM_FONT Номер шрифта int Стандартный для ККТ шрифт
LIBFPTR_PARAM_FONT_DOUBLE_WIDTH Двойная ширина bool false
LIBFPTR_PARAM_FONT_DOUBLE_HEIGHT Двойная высота bool false
LIBFPTR_PARAM_LINESPACING Межстрочный интервал int Стандартный для ККТ интервал

Выравнивание LIBFPTR_PARAM_ALIGNMENT может принимать следующие значения:

Печать штрихкода

Печать штрихкода

libfptr_set_param_str(fptr, LIBFPTR_PARAM_BARCODE, L"123456789012");
libfptr_set_param_int(fptr, LIBFPTR_PARAM_BARCODE_TYPE, LIBFPTR_BT_EAN_13);
libfptr_print_barcode(fptr);

fptr.setParam(LIBFPTR_PARAM_BARCODE, L"123456789012");
fptr.setParam(LIBFPTR_PARAM_BARCODE_TYPE, LIBFPTR_BT_EAN_13);
fptr.printBarcode();

fptr.setParam(IFptr.LIBFPTR_PARAM_BARCODE, "123456789012");
fptr.setParam(IFptr.LIBFPTR_PARAM_BARCODE_TYPE, IFptr.LIBFPTR_BT_EAN_13);
fptr.printBarcode();

Для печати штрихкода необходимо вызвать метод printBarcode() и задать следующие обязательные параметры:

Параметр Описание Тип
LIBFPTR_PARAM_BARCODE Данные штрихкода string
LIBFPTR_PARAM_BARCODE_TYPE Тип штрихкода int

Тип штрихкода LIBFPTR_PARAM_BARCODE_TYPE может принимать следующие значения:

Также можно изменить параметры печати штрихкода с помощью следующих параметров:

Параметр Описание Тип
LIBFPTR_PARAM_ALIGNMENT Выравнивание штрихкода int
LIBFPTR_PARAM_SCALE Коэффициент увеличения штрихкода int
LIBFPTR_PARAM_LEFT_MARGIN Дополнительный отступ слева int

Выравнивание LIBFPTR_PARAM_ALIGNMENT может принимать следующие значения:

Для одномерных штрихкодов дополнительно можно задать следующие параметры:

Параметр Описание Тип
LIBFPTR_PARAM_BARCODE_PRINT_TEXT Флаг печати данных ШК bool

Для QR-кода дополнительно можно задать следующие параметры:

Параметр Описание Тип
LIBFPTR_PARAM_BARCODE_CORRECTION Коррекция QR-кода int
LIBFPTR_PARAM_BARCODE_VERSION Версия QR-кода int

Коррекция штрихкода LIBFPTR_PARAM_BARCODE_CORRECTION может принимать следующие значения:

Печать картинки

Печать картинки

libfptr_set_param_str(fptr, LIBFPTR_PARAM_FILENAME, L"C:\\picture.png");
libfptr_print_picture(fptr);

fptr.setParam(LIBFPTR_PARAM_FILENAME