Тариф, учитывающий время проезда по маршруту и километраж — различия между версиями

Версия 10:43, 4 мая 2022

В тарифе существуют параметры, которые позволяют учитывать не только километраж маршрута, но и предварительно рассчитанное время проезда по этому маршруту, которое может зависеть от загруженности дорог.
Текст тарифа (Развернуть/Свернуть) →

//<?xml version="1.0" encoding="UTF-8"?>
//<xml_consts>
//  <param>
//    <code>PRIOR_ORDER_COST</code>
//    <type>currency</type>
//    <name>Наценка за предварительный заказ</name>
//  </param>

//  <group>
//    <name>Ожидание</name>
//    <items>
//      <param>
//        <code>WAITING_INCLUDED</code>
//        <type>boolean</type>
//        <name>Ожидание включено в минимальную стоимость</name>
//      </param>
//      <param>
//        <code>WAIT_MINUTE_COST</code>
//        <type>currency</type>
//        <name>Цена минуты ожидания</name>
//      </param>
//      <param>
//        <code>FREE_WAITING_TIME</code>
//        <type>integer</type>
//        <name>Бесплатное время ожидания, мин</name>
//      </param>
//      <param>
//        <code>PRIOR_FREE_WAITING_TIME</code>
//        <type>integer</type>
//        <name>Бесплатное время ожидания для предварительного заказа, мин</name>
//      </param>
//      <param>
//        <code>CLIENT_ABSENT_VISIBLE</code>
//        <type>boolean</type>
//        <name>Отображать кнопку "Не выходят"</name>
//      </param>
//      <param>
//        <code>CLIENT_ABSENT_ENABLED_TIME</code>
//        <type>integer</type>
//        <name>За сколько минут до начала платного ожидания делать доступной кнопку "Не выходят"</name>
//        <visible>
//          <code>CLIENT_ABSENT_VISIBLE</code>
//          <condition>equal</condition>
//          <value>true</value>
//        </visible>
//      </param>
//    </items>
//  </group>

//  <group>
//    <name>Обычный заказ (не почасовой)</name>
//    <items>
//      <group>
//        <name>По городу</name>
//        <items>
//          <param>
//            <code>MIN_CITY</code>
//            <type>currency</type>
//            <name>Минимальная стоимость</name>
//          </param>
//          <param>
//            <code>BOARDING_CITY</code>
//            <type>currency</type>
//            <name>Посадка</name>
//          </param>
//          <param>
//            <code>CITY_KM_INCLUDED</code>
//            <type>float</type>
//            <name>Сколько км включено в посадку</name>
//          </param>
//          <param>
//            <code>CITY_KM_COST</code>
//            <type>currency</type>
//            <name>Цена км далее</name>
//          </param>
//          <param>
//            <type>integer</type>
//            <name>На сколько % увеличивать сумму по городу при обратном пути в карте заказа</name>
//            <code>CITY_BACK_WAY_PERCENT</code>
//          </param>
//          <param>
//            <code>CITY_MINUTES_INCLUDED</code>
//            <type>float</type>
//            <name>Сколько минут включено в посадку</name>
//          </param>
//          <param>
//            <code>CITY_MINUTE_COST</code>
//            <type>currency</type>
//            <name>Цена минуты далее</name>
//          </param>
//        </items>
//      </group>

//      <group>
//        <name>За городом</name>
//        <items>
//          <param>
//            <code>MIN_COUNTRY</code>
//            <type>currency</type>
//            <name>Минимальная стоимость</name>
//          </param>
//          <param>
//            <code>BOARDING_COUNTRY</code>
//            <type>currency</type>
//            <name>Посадка</name>
//          </param>
//          <param>
//            <code>COUNTRY_KM_INCLUDED</code>
//            <type>float</type>
//            <name>Сколько км включено в посадку</name>
//          </param>
//          <param>
//            <code>COUNTRY_KM_COST</code>
//            <type>currency</type>
//            <name>Цена км далее</name>
//          </param>
//          <param>
//            <code>SOURCE_COUNTRY_KM_COST</code>
//            <type>currency</type>
//            <name>Цена км до адреса подачи за город</name>
//          </param>
//          <param>
//            <code>COUNTRY_BACK_WAY_PERCENT</code>
//            <type>integer</type>
//            <name>На сколько % увеличивать сумму за городом при обратном пути в карте заказа</name>
//          </param>
//          <param>
//            <code>COUNTRY_MINUTES_INCLUDED</code>
//            <type>float</type>
//            <name>Сколько минут включено в посадку</name>
//          </param>
//          <param>
//            <code>COUNTRY_MINUTE_COST</code>
//            <type>currency</type>
//            <name>Цена минуты далее</name>
//          </param>
//        </items>
//      </group>

//      <group>
//        <name>Простой</name>
//        <items>
//          <param>
//            <code>IDLE_MINUTE_COST</code>
//            <type>currency</type>
//            <name>Цена минуты простоя</name>
//          </param>
//          <param>
//            <code>FREE_IDLE_TIME</code>
//            <type>integer</type>
//            <name>Период между потерей скорости и началом простоя, сек</name>
//          </param>
//          <param>
//            <code>SPEED_LIMIT</code>
//            <type>integer</type>
//            <name>Скорость, ниже которой считается простой, км/ч</name>
//          </param>
//        </items>
//      </group>

//      <group>
//        <name>Остановки</name>
//        <items>
//          <param>
//            <code>MIN_STOP_COST</code>
//            <type>currency</type>
//            <name>Минимальная стоимость остановки</name>
//          </param>
//          <param>
//            <code>STOP_MINUTES_INCLUDED</code>
//            <type>integer</type>
//            <name>Сколько минут включено в минимальную стоимость остановки</name>
//          </param>
//          <param>
//            <code>STOP_MINUTE_COST</code>
//            <type>currency</type>
//            <name>Цена минуты остановки далее</name>
//          </param>
//        </items>
//      </group>

//      <group>
//        <name>Расчет километража для таксометра через ТМ</name>
//        <items>
//          <param>
//            <code>USE_CALC_TM_ROUTE</code>
//            <type>boolean</type>
//            <name>Использовать расчет километража для таксометра через ТМ</name>
//          </param>
//          <param>
//            <code>CALC_TM_ROUTE_PERIOD</code>
//            <type>integer</type>
//            <name>Через сколько секунд делать пересчет километража для таксометра через ТМ</name>
//          </param>
//        </items>
//      </group>

//    </items>
//  </group>

//  <group>
//    <name>Почасовой заказ</name>
//    <items>
//      <param>
//        <code>MIN_HOURLY</code>
//        <type>currency</type>
//        <name>Минимальная стоимость</name>
//      </param>
//      <param>
//        <code>BOARDING_HOURLY</code>
//        <type>currency</type>
//        <name>Посадка</name>
//      </param>
//      <param>
//        <code>HOURLY_MINUTES_INCLUDED</code>
//        <type>integer</type>
//        <name>Сколько минут включено в посадку</name>
//      </param>
//      <param>
//        <code>HOURLY_MINUTE_COST</code>
//        <type>currency</type>
//        <name>Цена минуты далее</name>
//      </param>
//      <param>
//        <code>HOURLY_PERIOD</code>
//        <type>integer</type>
//        <name>За сколько минут разом увеличивать сумму</name>
//      </param>
//      <param>
//        <code>HOURLY_TRIP_KM_INCLUDED</code>
//        <type>float</type>
//        <name>Количество км, включенных в поездку</name>
//        <visible>
//          <code>HOURLY_HOUR_KM_INCLUDED</code>
//          <condition>equal</condition>
//          <value>0</value>
//        </visible>
//      </param>
//      <param>
//        <code>HOURLY_HOUR_KM_INCLUDED</code>
//        <type>float</type>
//        <name>Количество км, включенных в час</name>
//        <visible>
//          <code>HOURLY_TRIP_KM_INCLUDED</code>
//          <condition>equal</condition>
//          <value>0</value>
//        </visible>
//      </param>
//      <param>
//        <code>HOURLY_KM_COST</code>
//        <type>currency</type>
//        <name>Цена км</name>
//      </param>
//    </items>
//  </group>

//  <group>
//    <name>Районы</name>
//    <items>
//      <param>
//        <code>USE_ZONE_COST</code>
//        <type>boolean</type>
//        <name>Учитывать посадку/высадку в районах</name>
//      </param>
//      <param>
//        <code>USE_ZONE_PATH</code>
//        <type>boolean</type>
//        <name>Учитывать проезды между районами</name>
//      </param>
//      <param>
//        <code>ZONES_PATH_GROUP_ID</code>
//        <type>zones_path_group</type>
//        <name>Группа проездов между районами</name>
//        <visible>
//          <code>USE_ZONE_PATH</code>
//          <condition>equal</condition>
//          <value>true</value>
//        </visible>
//      </param>
//      <param>
//        <code>ZONES_BACK_WAY_PERCENT</code>
//        <type>integer</type>
//        <name>На сколько % увеличивать сумму за проезды между районами при обратном пути в карте заказа</name>
//        <visible>
//          <code>USE_ZONE_PATH</code>
//          <condition>equal</condition>
//          <value>true</value>
//        </visible>
//      </param>
//      <param>
//        <code>USE_REAL_ZONES_IN_TAXM</code>
//        <type>boolean</type>
//        <name>Определять районы в таксометре по фактическому маршруту</name>
//      </param>
//    </items>
//  </group>

//  <group>
//    <name>Дополнительные параметры минимальной стоимости</name>
//    <items>
//      <param>
//        <code>DISCOUNT_AFTER_MIN</code>
//        <type>boolean</type>
//        <name>Считать скидки после минимальной стоимости</name>
//      </param>
//      <param>
//        <code>SERVICES_AFTER_MIN</code>
//        <type>boolean</type>
//        <name>Считать услуги после минимальной стоимости</name>
//      </param>
//      <param>
//        <code>MIN_SUM_AFTER_CALC</code>
//        <type>boolean</type>
//        <name>Применять минимальную стоимость после завершения расчета в таксометре</name>
//      </param>
//    </items>
//  </group>

//  <group>
//    <name>Округление</name>
//    <items>
//      <param>
//        <code>ROUNDING</code>
//        <type>currency</type>
//        <name>Округление</name>
//        <min>0</min>
//      </param>
//      <param>
//        <code>ROUND_UP</code>
//        <type>boolean</type>
//        <name>Округлять в большую сторону</name>
//      </param>
//    </items>
//  </group>

//  <group>
//    <name>Таксофон</name>
//    <items>
//      <param>
//        <code>TAXOPHONE_FIRST_DISCOUNT_SUM</code>
//        <type>currency</type>
//        <name>Скидка за первый заказ из TaxoPhone, руб</name>
//      </param>
//      <param>
//        <code>TAXOPHONE_FIRST_DISCOUNT_PERCENT</code>
//        <type>integer</type>
//        <name>Скидка за первый заказ из TaxoPhone, %</name>
//      </param>
//      <param>
//        <code>TAXOPHONE_CONSTANT_DISCOUNT_SUM</code>
//        <type>currency</type>
//        <name>Постоянная скидка для заказов из TaxoPhone, руб</name>
//      </param>
//      <param>
//        <code>TAXOPHONE_CONSTANT_DISCOUNT_PERCENT</code>
//        <type>integer</type>
//        <name>Постоянная скидка для заказов из TaxoPhone, %</name>
//      </param>
//      <param>
//        <code>TAXOPHONE_REGULAR_DISCOUNT_COUNT</code>
//        <type>integer</type>
//        <name>Через сколько заказов должна срабатывать регулярная скидка для заказов из TaxoPhone</name>
//      </param>
//      <param>
//        <code>TAXOPHONE_REGULAR_DISCOUNT_SUM</code>
//        <type>currency</type>
//        <name>Регулярная скидка для заказов из TaxoPhone, руб</name>
//      </param>
//      <param>
//        <code>TAXOPHONE_REGULAR_DISCOUNT_PERCENT</code>
//        <type>integer</type>
//        <name>Регулярная скидка для заказов из TaxoPhone, %</name>
//      </param>
//    </items>
//  </group>

//  <group>
//    <name>Услуги, доступные водителю в таксометре</name>
//    <items>
//      <param>
//        <code>SERVICES_BUTTON_COUNT</code>
//        <type>integer</type>
//        <name>Количество услуг</name>
//        <min>0</min>
//        <max>10</max>
//      </param>
//      <param>
//        <code>SERVICE_1</code>
//        <type>order_param</type>
//        <name>Услуга 1</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>1</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_1</code>
//        <type>boolean</type>
//        <name>Услугу 1 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>1</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_2</code>
//        <type>order_param</type>
//        <name>Услуга 2</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>2</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_2</code>
//        <type>boolean</type>
//        <name>Услугу 2 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>2</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_3</code>
//        <type>order_param</type>
//        <name>Услуга 3</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>3</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_3</code>
//        <type>boolean</type>
//        <name>Услугу 3 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>3</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_4</code>
//        <type>order_param</type>
//        <name>Услуга 4</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>4</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_4</code>
//        <type>boolean</type>
//        <name>Услугу 4 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>4</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_5</code>
//        <type>order_param</type>
//        <name>Услуга 5</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>5</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_5</code>
//        <type>boolean</type>
//        <name>Услугу 5 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>5</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_6</code>
//        <type>order_param</type>
//        <name>Услуга 6</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>6</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_6</code>
//        <type>boolean</type>
//        <name>Услугу 6 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>6</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_7</code>
//        <type>order_param</type>
//        <name>Услуга 7</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>7</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_7</code>
//        <type>boolean</type>
//        <name>Услугу 7 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>7</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_8</code>
//        <type>order_param</type>
//        <name>Услуга 8</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>8</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_8</code>
//        <type>boolean</type>
//        <name>Услугу 8 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>8</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_9</code>
//        <type>order_param</type>
//        <name>Услуга 9</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>9</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_9</code>
//        <type>boolean</type>
//        <name>Услугу 9 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>9</value>
//        </visible>
//      </param>
//      <param>
//        <code>SERVICE_10</code>
//        <type>order_param</type>
//        <name>Услуга 10</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>greater_or_equal</condition>
//          <value>10</value>
//        </visible>
//      </param>
//      <param>
//        <code>CAN_REPEAT_SERVICE_10</code>
//        <type>boolean</type>
//        <name>Услугу 10 можно использовать повторно</name>
//        <visible>
//          <code>SERVICES_BUTTON_COUNT</code>
//          <condition>equal</condition>
//          <value>10</value>
//        </visible>
//      </param>
//    </items>
//  </group>

//  <param>
//    <code>CALC_SUM_BY_TAXIMETER</code>
//    <type>boolean</type>
//    <name>Считать сумму по таксометру</name>
//  </param>
//  <param>
//    <code>USE_STOPS_WAITING_IDLE</code>
//    <type>boolean</type>
//    <name>Считать простой, ожидание и остановки независимо от настройки "Считать сумму по таксометру"</name>
//    <visible>
//      <code>CALC_SUM_BY_TAXIMETER</code>
//      <condition>equal</condition>
//      <value>false</value>
//    </visible>
//  </param>
//  <param>
//    <code>USE_GPS_MISSED_DISTANCE_RECOVERY</code>
//    <type>boolean</type>
//    <name>Использовать восстановление километража по прямой при потере координат</name>
//    <visible>
//      <code>CALC_SUM_BY_TAXIMETER</code>
//      <condition>equal</condition>
//      <value>true</value>
//    </visible>
//  </param>
//  <param>
//    <code>VALUTA</code>
//    <type>string</type>
//    <name>Валюта</name>
//  </param>

//  <group>
//    <name>Параметры для печати чека</name>
//    <items>
//      <param>
//        <code>NEED_DETAILS_IN_CHECK</code>
//        <type>boolean</type>
//        <name>Печатать детализацию поездки</name>
//      </param>
//      <param>
//        <code>TAXI_NAME</code>
//        <type>string</type>
//        <name>Название такси</name>
//      </param>
//      <param>
//        <code>TAXI_PHONE</code>
//        <type>string</type>
//        <name>Телефон такси</name>
//      </param>
//      <param>
//        <code>TAXI_INN</code>
//        <type>string</type>
//        <name>ИНН</name>
//      </param>
//    </items>
//  </group>
//</xml_consts>

const
  MIN_CITY = 0;
  MIN_COUNTRY = 0;
  MIN_HOURLY = 0;
  BOARDING_CITY = 0;
  CITY_KM_INCLUDED = 0;
  CITY_KM_COST = 0;
  CITY_MINUTES_INCLUDED = 0;
  CITY_MINUTE_COST = 0;
  BOARDING_COUNTRY = 0;
  COUNTRY_KM_INCLUDED = 0;
  COUNTRY_KM_COST = 0;
  COUNTRY_MINUTES_INCLUDED = 0;
  COUNTRY_MINUTE_COST = 0;
  SOURCE_COUNTRY_KM_COST = 0;
  BOARDING_HOURLY = 0;
  HOURLY_MINUTES_INCLUDED = 0;
  HOURLY_MINUTE_COST = 0;
  HOURLY_PERIOD = 0;
  HOURLY_TRIP_KM_INCLUDED = 0;
  HOURLY_HOUR_KM_INCLUDED = 0;
  HOURLY_KM_COST = 0;
  WAITING_INCLUDED = True;
  WAIT_MINUTE_COST = 0;
  FREE_WAITING_TIME = 0;
  PRIOR_FREE_WAITING_TIME = 0;
  CLIENT_ABSENT_VISIBLE = True;
  CLIENT_ABSENT_ENABLED_TIME = 0;
  IDLE_MINUTE_COST = 0;
  FREE_IDLE_TIME = 0;
  SPEED_LIMIT = 5;
  USE_ZONE_PATH = False;
  USE_ZONE_COST = False;
  ZONES_PATH_GROUP_ID = 0;
  USE_REAL_ZONES_IN_TAXM = False;
  MIN_STOP_COST = 0;
  STOP_MINUTES_INCLUDED = 0;
  STOP_MINUTE_COST = 0;
  PRIOR_ORDER_COST = 0;
  CITY_BACK_WAY_PERCENT = 0;
  COUNTRY_BACK_WAY_PERCENT = 0;
  ZONES_BACK_WAY_PERCENT = 0;
  ROUNDING = 1;
  ROUND_UP = False;
  MIN_SUM_AFTER_CALC = False;
  DISCOUNT_AFTER_MIN = False;
  SERVICES_AFTER_MIN = False;
  TAXOPHONE_FIRST_DISCOUNT_SUM = 0;
  TAXOPHONE_FIRST_DISCOUNT_PERCENT = 0;
  TAXOPHONE_CONSTANT_DISCOUNT_SUM = 0;
  TAXOPHONE_CONSTANT_DISCOUNT_PERCENT = 0;
  TAXOPHONE_REGULAR_DISCOUNT_COUNT = 0;
  TAXOPHONE_REGULAR_DISCOUNT_SUM = 0;
  TAXOPHONE_REGULAR_DISCOUNT_PERCENT = 0;
  CALC_SUM_BY_TAXIMETER = True;
  USE_STOPS_WAITING_IDLE = False;
  USE_GPS_MISSED_DISTANCE_RECOVERY = False;
  USE_CALC_TM_ROUTE = False;
  CALC_TM_ROUTE_PERIOD = 0;
  CALC_TM_ROUTE_FINISH_TIMEOUT = 15;
  VALUTA = 'р';
  NEED_DETAILS_IN_CHECK = False;
  TAXI_NAME = 'ООО "Название Такси"';
  TAXI_PHONE = '(495) 123-45-67';
  TAXI_INN = '123456789012';

  SERVICES_BUTTON_COUNT = 0;
  SERVICE_1 = 0;
  CAN_REPEAT_SERVICE_1 = False;
  SERVICE_2 = 0;
  CAN_REPEAT_SERVICE_2 = False;
  SERVICE_3 = 0;
  CAN_REPEAT_SERVICE_3 = False;
  SERVICE_4 = 0;
  CAN_REPEAT_SERVICE_4 = False;
  SERVICE_5 = 0;
  CAN_REPEAT_SERVICE_5 = False;
  SERVICE_6 = 0;
  CAN_REPEAT_SERVICE_6 = False;
  SERVICE_7 = 0;
  CAN_REPEAT_SERVICE_7 = False;
  SERVICE_8 = 0;
  CAN_REPEAT_SERVICE_8 = False;
  SERVICE_9 = 0;
  CAN_REPEAT_SERVICE_9 = False;
  SERVICE_10 = 0;
  CAN_REPEAT_SERVICE_10 = False;

// Округлить сумму.
function RoundSum(Sum: Single): Single;
var
  F, R: Single;
begin
  if ROUNDING = 0 then
    Result := Sum
  else
  begin
    R := 1 / ROUNDING;
    if ROUND_UP then
      Result := Ceil(Sum * R) / R
    else
    begin
      F := Trunc(Sum * R) / R;
      if Sum - F >= ROUNDING / 2 then
        F := F + ROUNDING;
      Result := F;
    end;
  end;
end;


function FloatToStrFixed(Value: Single): String;
var
  R, SymbolCount: Integer;
begin
  R := Floor(ROUNDING * 100);
  if R mod 100 = 0 then
    SymbolCount := 0
  else
  if R mod 10 = 0 then
    SymbolCount := 1
  else
    SymbolCount := 2;
  Result := FloatToStr(Round(Value, SymbolCount));
end;


procedure TM_AddZonesSum(var TaxmZonesSum: Single; var ZonePathSum: Single;
  NeedPrintToBill: Boolean);
var
  F: Single;
  s: String;
  NeedZoneOutCost: Boolean;
  StopCount, i: Integer;
begin
  // == Районы.
  if USE_ZONE_COST then
  begin
    // Посадка.
    F := ReadFloat('ZoneInCost', -1);
    if F <> 0 then
    begin
      s := ReadStr('ZoneName', -1);
      TaxmZonesSum := TaxmZonesSum + F;
      if NeedPrintToBill then
      begin
        WriteStr('Bill', 'Text', 'Посадка в ''' + s + '''');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      end;
    end;
    // Высадка.
    if ReadStr('ZoneName', -1) <> ReadStr('ZoneName', -2) then
      NeedZoneOutCost := True
    else
      if ReadInt('StopCount') > 0 then
      begin
        NeedZoneOutCost := False;
        for i := 0 to ReadInt('StopCount') - 1 do
          if ReadStr('ZoneName', i) <> ReadStr('ZoneName', -1) then
            NeedZoneOutCost := True;
      end
      else
        NeedZoneOutCost := False;
    if NeedZoneOutCost then
    begin
      F := ReadFloat('ZoneOutCost', -2);
      if F <> 0 then
      begin
        s := ReadStr('ZoneName', -2);
        TaxmZonesSum := TaxmZonesSum + F;
        if NeedPrintToBill then
        begin
          WriteStr('Bill', 'Text', 'Высадка в ''' + s + '''');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        end;
      end;
    end;
    // Остановки.
    for i := 0 to ReadInt('StopCount') - 1 do
    begin
      F := ReadFloat('ZoneStopCost', i);
      if F <> 0 then
      begin
        s := ReadStr('ZoneName', i);
        TaxmZonesSum := TaxmZonesSum + F;
        if NeedPrintToBill then
        begin
          WriteStr('Bill', 'Text', 'Остановка в ''' + s + '''');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        end;
      end;
    end;
  end;

  // Проезды.
  if USE_ZONE_PATH then
  begin
    StopCount := ReadInt('StopCount');
    if StopCount > 0 then
    begin
      F := ReadFloat('ZonePathCost', -1, 0);
      if F <> 0 then
      begin
        ZonePathSum := F;
        if NeedPrintToBill then
        begin
          WriteStr('Bill', 'Text', 'Проезд ''' +
            ReadStr('ZoneName', -1) + ''' -> ''' +
            ReadStr('ZoneName', 0) + '''');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        end;
      end;
      for i := 0 to StopCount - 2 do
      begin
        F := ReadFloat('ZonePathCost', i, i + 1);
        if F <> 0 then
        begin
          ZonePathSum := ZonePathSum + F;
          if NeedPrintToBill then
          begin
            WriteStr('Bill', 'Text', 'Проезд ''' +
              ReadStr('ZoneName', i) + ''' -> ''' +
              ReadStr('ZoneName', i + 1) + '''');
            WriteStr('Bill', 'Sum', FloatToStr(F, 2));
          end;
        end;
      end;
      F := ReadFloat('ZonePathCost', StopCount - 1, -2);
      if F <> 0 then
      begin
        ZonePathSum := ZonePathSum + F;
        if NeedPrintToBill then
        begin
          WriteStr('Bill', 'Text', 'Проезд ''' +
            ReadStr('ZoneName', StopCount - 1) + ''' -> ''' +
            ReadStr('ZoneName', -2) + '''');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        end;
      end;
    end
    else
    begin
      F := ReadFloat('ZonePathCost', -1, -2);
      if F <> 0 then
      begin
        ZonePathSum := F;
        if NeedPrintToBill then
        begin
          WriteStr('Bill', 'Text', 'Проезд ''' +
            ReadStr('ZoneName', -1) + ''' -> ''' +
            ReadStr('ZoneName', -2) + '''');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        end;
      end;
    end;

    if ReadBool('BackFree') and (ZonePathSum <> 0) and
       (ZONES_BACK_WAY_PERCENT <> 0) then
    begin
      F := ZonePathSum * ZONES_BACK_WAY_PERCENT / 100;
      ZonePathSum := ZonePathSum + F;
      if NeedPrintToBill then
      begin
        WriteStr('Bill', 'Text', 'Обратный проезд между районами');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      end;
    end;
  end;
end;

// Заказ пришёл из TaxoPhone.
function TM_IsFromTaxophone: Boolean;
begin
  Result := (ReadInt('CreationWay') = 6) or
    (ReadInt('CreationWay') = 9) or
    (ReadInt('CreationWay') = 11);
end;


// Рассчитать стоимость за ожидание.
function TM_GetWaitingCost: Single;
var
  FreeWaitingTime: Integer;
begin
  if not ReadBool('IsPrior') then
    FreeWaitingTime := FREE_WAITING_TIME
  else
    FreeWaitingTime := PRIOR_FREE_WAITING_TIME;
  if ReadInt('WaitTime') div 60 > FreeWaitingTime then
    Result := WAIT_MINUTE_COST *
      (ReadInt('WaitTime') div 60 - FreeWaitingTime)
  else
    Result := 0;
end;


// Получить минималку.
function TM_GetMinSum: Single;
begin
  if ReadBool('IsHourly') then
    Result := MIN_HOURLY
  else
  if ReadBool('IsCountry') then
    Result := MIN_COUNTRY
  else
    Result := MIN_CITY;
end;


// Добавить услуги (атрибуты/параметры) к сумме.
procedure TM_AddServices(var Sum: Single; NeedPrintToBill: Boolean);
var
  F, ServicePercentSum, ServicesSum: Single;
  i: Integer;
begin
  // Услуги.
  ServicesSum := 0;
  for i := 0 to ReadInt('ServiceCount') - 1 do
  begin
    F := ReadFloat('ServiceSum', i);
    if F <> 0 then
    begin
      ServicesSum := ServicesSum + F;
      if NeedPrintToBill then
      begin
        WriteStr('Bill', 'Text',
          'Услуга ''' + ReadStr('ServiceName', i) + '''');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      end;
    end;
  end;

  ServicePercentSum := 0;
  for i := 0 to ReadInt('ServiceCount') - 1 do
  begin
    F := ReadFloat('ServicePercent', i);
    if F <> 0 then
    begin
      ServicePercentSum := ServicePercentSum + F;
      if NeedPrintToBill then
      begin
        WriteStr('Bill', 'Text',
          'Услуга ''' + ReadStr('ServiceName', i) + '''');
        WriteStr('Bill', 'Sum', FloatToStr(F, 0) + '%');
      end;
    end;
  end;

  Sum := Sum + Sum * ServicePercentSum / 100 + ServicesSum;
end;


// Рассчитать сумму со скидкой.
procedure TM_AddDiscounts(var Sum: Single;
  var TotalDiscSum: Single;
  var TotalDiscPercent: Single;
  NeedPrintToBill: Boolean);
var
  F: Single;
  i: Integer;
  S: String;
begin
  // == Скидки.

  TotalDiscSum := 0;
  TotalDiscPercent := 0;
  // Скидка/наценка.
  for i := 0 to ReadInt('DiscMarkupCount') - 1 do
  begin
    F := ReadFloat('DiscMarkupSum', i);
    if F <> 0 then
    begin
      if NeedPrintToBill then
      begin
        if F > 0 then
          S := 'Наценка'
        else
          S := 'Скидка';
        WriteStr('Bill', 'Text', S + ' ''' +
          ReadStr('DiscMarkupName', i) + '''');
        WriteStr('Bill', 'Sum', FloatToStr(Abs(F), 2));
      end;
      // + это наценка, - это скидка.
      TotalDiscSum := TotalDiscSum - F;
    end;
    F := ReadFloat('DiscMarkupPercent', i);
    if F <> 0 then
    begin
      if NeedPrintToBill then
      begin
        if F > 0 then
          S := 'Наценка'
        else
          S := 'Скидка';
        WriteStr('Bill', 'Text', S + ' ''' +
          ReadStr('DiscMarkupName', i) + '''');
        WriteStr('Bill', 'Sum', FloatToStr(Abs(F), 0) + '%');
      end;
      // + это наценка, - это скидка.
      TotalDiscPercent := TotalDiscPercent - F;
    end;
  end;

  if TM_IsFromTaxophone then
  begin
    // Постоянная скидка для заказов из TaxoPhone.
    TotalDiscSum := TotalDiscSum + TAXOPHONE_CONSTANT_DISCOUNT_SUM;
    TotalDiscPercent := TotalDiscPercent + TAXOPHONE_CONSTANT_DISCOUNT_PERCENT;
    if NeedPrintToBill then
    begin
      if TAXOPHONE_CONSTANT_DISCOUNT_SUM > 0 then
      begin
        WriteStr('Bill', 'Text', 'Постоянная скидка за заказ из TaxoPhone');
        WriteStr('Bill', 'Sum', FloatToStr(TAXOPHONE_CONSTANT_DISCOUNT_SUM, 2));
      end;
      if TAXOPHONE_CONSTANT_DISCOUNT_PERCENT > 0 then
      begin
        WriteStr('Bill', 'Text', 'Постоянная скидка за заказ из TaxoPhone');
        WriteStr('Bill', 'Sum', FloatToStr(TAXOPHONE_CONSTANT_DISCOUNT_PERCENT, 0) + '%');
      end;
    end;

    // Скидка за первый заказ из TaxoPhone.
    if ReadInt('ClientTaxoPhoneOrdersCount') = 0 then
    begin
      TotalDiscSum := TotalDiscSum + TAXOPHONE_FIRST_DISCOUNT_SUM;
      TotalDiscPercent := TotalDiscPercent + TAXOPHONE_FIRST_DISCOUNT_PERCENT;
      if NeedPrintToBill then
      begin
        if TAXOPHONE_FIRST_DISCOUNT_SUM > 0 then
        begin
          WriteStr('Bill', 'Text', 'Скидка за первый заказ из TaxoPhone');
          WriteStr('Bill', 'Sum', FloatToStr(TAXOPHONE_FIRST_DISCOUNT_SUM, 2));
        end;
        if TAXOPHONE_FIRST_DISCOUNT_PERCENT > 0 then
        begin
          WriteStr('Bill', 'Text', 'Скидка за первый заказ из TaxoPhone');
          WriteStr('Bill', 'Sum', FloatToStr(TAXOPHONE_FIRST_DISCOUNT_PERCENT, 0) + '%');
        end;
      end;
    end;

    // Регулярная скидка за заказ из TaxoPhone.
    if TAXOPHONE_REGULAR_DISCOUNT_COUNT > 0 then
      if (ReadInt('ClientTaxoPhoneOrdersCount') + 1) mod TAXOPHONE_REGULAR_DISCOUNT_COUNT = 0 then
      begin
        TotalDiscSum := TotalDiscSum + TAXOPHONE_REGULAR_DISCOUNT_SUM;
        TotalDiscPercent := TotalDiscPercent + TAXOPHONE_REGULAR_DISCOUNT_PERCENT;
        if NeedPrintToBill then
        begin
          if TAXOPHONE_REGULAR_DISCOUNT_SUM > 0 then
          begin
            WriteStr('Bill', 'Text', 'Регулярная скидка за каждый ' +
              IntToStr(TAXOPHONE_REGULAR_DISCOUNT_COUNT) + '-й заказ из TaxoPhone');
            WriteStr('Bill', 'Sum', FloatToStr(TAXOPHONE_REGULAR_DISCOUNT_SUM, 2));
          end;
          if TAXOPHONE_FIRST_DISCOUNT_PERCENT > 0 then
          begin
            WriteStr('Bill', 'Text', 'Регулярная скидка за каждый ' +
              IntToStr(TAXOPHONE_REGULAR_DISCOUNT_COUNT) + '-й заказ из TaxoPhone');
            WriteStr('Bill', 'Sum', FloatToStr(TAXOPHONE_REGULAR_DISCOUNT_PERCENT, 0) + '%');
          end;
        end;
      end;
  end;

  // Скидка.
  S := ReadStr('DiscountName');
  F := ReadFloat('DiscountSum');
  if F <> 0 then
  begin
    if NeedPrintToBill then
    begin
      WriteStr('Bill', 'Text', 'Скидка ''' + S + '''');
      WriteStr('Bill', 'Sum', FloatToStr(F, 2));
    end;
    TotalDiscSum := TotalDiscSum + F;
  end;
  F := ReadFloat('DiscountPercent');
  if F <> 0 then
  begin
    if NeedPrintToBill then
    begin
      WriteStr('Bill', 'Text', 'Скидка ''' + S + '''');
      WriteStr('Bill', 'Sum', FloatToStr(F, 0) + '%');
    end;
    TotalDiscPercent := TotalDiscPercent + F;
  end;
  // Скидка по диск. карте.
  S := ReadStr('DiscCardName');
  F := ReadFloat('DiscCardSum');
  if F <> 0 then
  begin
    if NeedPrintToBill then
    begin
      WriteStr('Bill', 'Text', 'Скидка по ДК ''' + S + '''');
      WriteStr('Bill', 'Sum', FloatToStr(F, 2));
    end;
    TotalDiscSum := TotalDiscSum + F;
  end;
  F := ReadFloat('DiscCardPercent');
  if F <> 0 then
  begin
    if NeedPrintToBill then
    begin
      WriteStr('Bill', 'Text', 'Скидка по ДК ''' + S + '''');
      WriteStr('Bill', 'Sum', FloatToStr(F, 0) + '%');
    end;
    TotalDiscPercent := TotalDiscPercent + F;
  end;

  Sum := Sum - Sum * TotalDiscPercent / 100 - TotalDiscSum;
  if NeedPrintToBill then
  begin
    WriteStr('Bill', 'Text', 'Сумма со скидкой');
    WriteStr('Bill', 'Sum', FloatToStr(Sum, 2));
  end;
end;


// *****************
// Вычисление суммы.
// *****************
procedure CalcSum;
var
  Sum, F, CityDist, CountryDist, TotalDist, HourlyPayDist,
  ZonePathSum, TaxmZonesSum: Single;
  CityCost, CountryCost: Single;
  i, StopCount, TripTime: Integer;
  NeedZoneOutCost: Boolean;
  CityTripTime, CountryTripTime: Integer;
begin
  Sum := 0;
  WriteInt('UseZonesPathGroupId', ZONES_PATH_GROUP_ID);

  if ReadBool('IsPrior') and (PRIOR_ORDER_COST <> 0) then
  begin
    Sum := Sum + PRIOR_ORDER_COST;
    WriteStr('Bill', 'Text', 'Предварительный заказ');
    WriteStr('Bill', 'Sum', FloatToStr(PRIOR_ORDER_COST, 2));
  end;

  F := TM_GetWaitingCost;
  if F <> 0 then
  begin
    Sum := Sum + F;
    WriteStr('Bill', 'Text',
      'Ожидание ' + FloatToStr(WAIT_MINUTE_COST, 2) + ' ' + VALUTA + '/мин');
    WriteStr('Bill', 'Value',
      IntToStr(ReadInt('WaitTime') div 60) + ' мин');
    WriteStr('Bill', 'Sum', FloatToStr(F, 2));
  end;

  F := SOURCE_COUNTRY_KM_COST * ReadFloat('SourceDistCountry');
  if F <> 0 then
  begin
    Sum := Sum + F;
    WriteStr('Bill', 'Text',
      'До подачи за город ' + FloatToStr(SOURCE_COUNTRY_KM_COST, 2) + ' ' + VALUTA + '/км');
    WriteStr('Bill', 'Value',
    FloatToStr(ReadFloat('SourceDistCountry'), 2) + ' км');
    WriteStr('Bill', 'Sum', FloatToStr(F, 2));
  end;

  CityDist := ReadFloat('Distance');
  if ReadBool('IsCountry') then
    CountryDist := ReadFloat('DistCountry')
  else
    CountryDist := 0;
  TotalDist := CityDist + CountryDist;
  TripTime := ReadInt('TripTime');

  // Почасовой заказ.
  if ReadBool('IsHourly') then
  begin
    F := BOARDING_HOURLY;
    if TripTime div 60 > HOURLY_MINUTES_INCLUDED then
      if HOURLY_PERIOD = 0 then
        F := F + (TripTime div 60 - HOURLY_MINUTES_INCLUDED) *
          HOURLY_MINUTE_COST
      else
        F := F + Ceil((TripTime div 60 - HOURLY_MINUTES_INCLUDED) /
          HOURLY_PERIOD) * HOURLY_PERIOD * HOURLY_MINUTE_COST;
    if F <> 0 then
    begin
      Sum := Sum + F;
      WriteStr('Bill', 'Text', 'Продолжительность');
      WriteStr('Bill', 'Value',
        IntToStr(TripTime div 60) + ' мин');
      WriteStr('Bill', 'Sum', FloatToStr(F, 2));
    end;

    if HOURLY_KM_COST > 0 then
    begin
      F := 0;
      HourlyPayDist := 0;
      if HOURLY_HOUR_KM_INCLUDED > 0 then
      begin
        HourlyPayDist := (TotalDist - HOURLY_HOUR_KM_INCLUDED *
          Ceil(TripTime / 60 / 60));
        F := HourlyPayDist * HOURLY_KM_COST;
      end
      else
      if HOURLY_TRIP_KM_INCLUDED > 0 then
      begin
        HourlyPayDist := TotalDist - HOURLY_TRIP_KM_INCLUDED;
        F := HourlyPayDist * HOURLY_KM_COST;
      end
      else
      begin
        HourlyPayDist := TotalDist;
        F := TotalDist * HOURLY_KM_COST;
      end;
      if F > 0 then
      begin
        Sum := Sum + F;
        WriteStr('Bill', 'Text', 'Платный километраж');
        WriteStr('Bill', 'Value',
          FloatToStr(HourlyPayDist, 2) + ' км');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      end;
    end;
  end
  else
  begin
    // Загородный заказ.
    if ReadBool('IsCountry') then
    begin
      F := BOARDING_COUNTRY;
      if TotalDist > COUNTRY_KM_INCLUDED then
        if CityDist <= COUNTRY_KM_INCLUDED then
          F := F + (TotalDist - COUNTRY_KM_INCLUDED) * COUNTRY_KM_COST
        else
          F := F + (CityDist - COUNTRY_KM_INCLUDED) * CITY_KM_COST +
            CountryDist * COUNTRY_KM_COST;

      CityCost := 0;
      if CityDist > COUNTRY_KM_INCLUDED then
        CityCost := BOARDING_COUNTRY + (CityDist - COUNTRY_KM_INCLUDED) * CITY_KM_COST
      else
        if (TotalDist > COUNTRY_KM_INCLUDED) and (COUNTRY_KM_INCLUDED > 0) then
          CityCost := BOARDING_COUNTRY * CityDist / COUNTRY_KM_INCLUDED
        else
          if TotalDist > 0 then
            CityCost := BOARDING_COUNTRY * CityDist / TotalDist;
      CountryCost := F - CityCost;

      if F <> 0 then
      begin
        Sum := Sum + F;
        WriteStr('Bill', 'Text', 'Путь');
        WriteStr('Bill', 'Value',
          FloatToStr(TotalDist, 2) + ' км');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        if ReadBool('BackFree') then
        begin
          if (CityCost <> 0) and (CITY_BACK_WAY_PERCENT <> 0) then
          begin
            F := CityCost * CITY_BACK_WAY_PERCENT / 100;
            Sum := Sum + F;
            WriteStr('Bill', 'Text', 'Обратно по городу');
            WriteStr('Bill', 'Sum', FloatToStr(F, 2));
          end;
          if (CountryCost <> 0) and (COUNTRY_BACK_WAY_PERCENT <> 0) then
          begin
            F := CountryCost * COUNTRY_BACK_WAY_PERCENT / 100;
            Sum := Sum + F;
            WriteStr('Bill', 'Text', 'Обратно за городом');
            WriteStr('Bill', 'Sum', FloatToStr(F, 2));
          end;
        end;
      end;

      if ((COUNTRY_MINUTE_COST > 0) or (CITY_MINUTE_COST > 0)) and 
         (TripTime > COUNTRY_MINUTES_INCLUDED * 60) and
         (TotalDist > 0) then
      begin
        CountryTripTime := Floor(TripTime * (CountryDist / TotalDist));
        CityTripTime := Floor(TripTime - CountryTripTime);

        if CityTripTime <= COUNTRY_MINUTES_INCLUDED * 60 then
        begin
          CityCost := 0;
          CountryCost := (TripTime / 60 - COUNTRY_MINUTES_INCLUDED) * COUNTRY_MINUTE_COST
        end
        else
        begin
          CityCost := (CityTripTime / 60 - COUNTRY_MINUTES_INCLUDED) * CITY_MINUTE_COST;
          CountryCost := CountryTripTime / 60 * COUNTRY_MINUTE_COST;
        end;

        F := CityCost + CountryCost;
        if F <> 0 then
        begin
          Sum := Sum + F;

          WriteStr('Bill', 'Text', 'Длительность по городу');
          WriteStr('Bill', 'Value', TimeLenToStr(CityTripTime));
          WriteStr('Bill', 'Sum', FloatToStr(CityCost, 2));

          WriteStr('Bill', 'Text', 'Длительность за городом');
          WriteStr('Bill', 'Value', TimeLenToStr(CountryTripTime));
          WriteStr('Bill', 'Sum', FloatToStr(CountryCost, 2));
        end;
      end;
    end
    else
    // Городской заказ.
    begin
      F := BOARDING_CITY;
      if TotalDist > CITY_KM_INCLUDED then
        F := F + (TotalDist - CITY_KM_INCLUDED) * CITY_KM_COST;

      if F <> 0 then
      begin
        Sum := Sum + F;
        WriteStr('Bill', 'Text', 'Путь');
        WriteStr('Bill', 'Value',
          FloatToStr(TotalDist, 2) + ' км');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        if ReadBool('BackFree') then
          if (CITY_BACK_WAY_PERCENT <> 0) then
          begin
            F := F * CITY_BACK_WAY_PERCENT / 100;
            Sum := Sum + F;
            WriteStr('Bill', 'Text', 'Обратно по городу');
            WriteStr('Bill', 'Sum', FloatToStr(F, 2));
          end;
      end;

      if (CITY_MINUTE_COST > 0) and 
         (TripTime > CITY_MINUTES_INCLUDED * 60) then
      begin
        F := (TripTime / 60 - CITY_MINUTES_INCLUDED) * CITY_MINUTE_COST;
        if F <> 0 then
        begin
          Sum := Sum + F;
          WriteStr('Bill', 'Text', 'Длительность по городу');
          WriteStr('Bill', 'Value', TimeLenToStr(TripTime));
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));
        end;
      end;
    end;
  end;

  // Остановки.
  if not ReadBool('IsHourly') then
  begin
    F := MIN_STOP_COST * ReadInt('StopCount');
    if F <> 0 then
    begin
      Sum := Sum + F;
      WriteStr('Bill', 'Text', 'Остановки');
      WriteStr('Bill', 'Value',
        IntToStr(ReadInt('StopCount')) + ' шт');
      WriteStr('Bill', 'Sum', FloatToStr(F, 2));
    end;
  end;

  TaxmZonesSum := 0;
  ZonePathSum := 0;
  TM_AddZonesSum(TaxmZonesSum, ZonePathSum, True);
  Sum := Sum + ZonePathSum + TaxmZonesSum;

  if not SERVICES_AFTER_MIN then
    TM_AddServices(Sum, True);

  WriteFloat('Sum', Sum);
end;


// ***********************************************
// Заполение полей райнов и скидок для таксометра.
// ***********************************************
procedure CalcTaxmSums;
var
  i, StopCount: Integer;
  TaxmZonesSum, TotalDiscPercent,
    TotalDiscSum, ZonePathSum, Sum: Single;
begin
  // == Районы.
  WriteInt('UseZonesPathGroupId', ZONES_PATH_GROUP_ID);
  TaxmZonesSum := 0;
  ZonePathSum := 0;
  TM_AddZonesSum(TaxmZonesSum, ZonePathSum, False);

  // Запись.
  WriteFloat('TaxmZonesSum', TaxmZonesSum + ZonePathSum);

  TotalDiscSum := 0;
  TotalDiscPercent := 0;
  TM_AddDiscounts(Sum, TotalDiscSum, TotalDiscPercent, False);

  // Запись.
  WriteFloat('TaxmTotalDiscSum', TotalDiscSum);
  WriteFloat('TaxmTotalDiscPercent', TotalDiscPercent);
end;


// ****************************
// Вычисление суммы со скидкой.
// ****************************
procedure CalcTotalSum;
var
  WaitingCost, F, MinSum, Sum: Single;
  i: Integer;
  TotalDiscSum, TotalDiscPercent: Single;
begin
  // Сумма без скидок.
  Sum := ReadFloat('Sum');

  TotalDiscSum := 0;
  TotalDiscPercent := 0;

  if not DISCOUNT_AFTER_MIN then
    TM_AddDiscounts(Sum, TotalDiscSum, TotalDiscPercent, True);

  MinSum := TM_GetMinSum;
  WriteStr('Bill', 'Text', 'Минимум');
  WriteStr('Bill', 'Sum', FloatToStr(MinSum, 2));

  WaitingCost := TM_GetWaitingCost;
  if WAITING_INCLUDED then
    Sum := Max(MinSum, Sum)
  else
    Sum := Max(MinSum + WaitingCost, Sum);

  if SERVICES_AFTER_MIN then
    TM_AddServices(Sum, True);

  if DISCOUNT_AFTER_MIN then
    TM_AddDiscounts(Sum, TotalDiscSum, TotalDiscPercent, True);

  Sum := RoundSum(Sum);

  WriteStr('Bill', 'Text', 'Итого');
  WriteStr('Bill', 'Sum', FloatToStr(Sum, 2) + ' ' + VALUTA);

  // Записать итоговую сумму.
  WriteFloat('TotalSum', Sum);
end;


// Использовать простой и остановки.
function TMD_UseCalcStopsIdle: Boolean;
begin
  Result := not ReadBool('IsHourly') and
    (CALC_SUM_BY_TAXIMETER or USE_STOPS_WAITING_IDLE)
end;


// **************
// Инициализация.
// **************
procedure ResetCalc;
begin
  if CLIENT_ABSENT_VISIBLE then
    WriteInt('ClientAbsentVisible', 1)
  else
    WriteInt('ClientAbsentVisible', 0);
end;


// *****************
// Ожидание клиента.
// *****************
procedure WaitCalc;
var
  Sum: Single;
  FreeWaitingTime, WaitTime: Integer;
begin
  if not ReadBool('IsPrior') then
    FreeWaitingTime := FREE_WAITING_TIME
  else
    FreeWaitingTime := PRIOR_FREE_WAITING_TIME;

  WaitTime := ReadInt('WaitTime');

  WriteInt('FreeWaitingTime', (FreeWaitingTime * 60 - WaitTime));

  if CALC_SUM_BY_TAXIMETER or USE_STOPS_WAITING_IDLE then
    if WaitTime > FreeWaitingTime * 60 then
    begin
      Sum := ReadFloat('Sum') + WAIT_MINUTE_COST / 60;
      WriteFloat('Temp', 'PayWaitTimeSum', Sum);
      WriteFloat('Sum', Sum);
      WriteStr('SumStr', FloatToStrFixed(RoundSum(Sum)));
      WriteFloat('CurrentSum', Sum);
    end;

  if CLIENT_ABSENT_VISIBLE and
     (WaitTime > (FreeWaitingTime - CLIENT_ABSENT_ENABLED_TIME) * 60) then
    WriteInt('ClientAbsentEnabled', 1)
  else
    WriteInt('ClientAbsentEnabled', 0);
end;


// Получить параметры услуги по ИД.
procedure TMD_GetServiceParams(ServiceId: Integer;
  var ServiceCost: Single;
  var ServicePercent: Integer;
  var ServiceName: String);
begin
  ServiceCost := ReadFloat('OrderParamSum', ServiceId);
  ServiceName := ReadStr('OrderParamName', ServiceId);
  ServicePercent := Trunc(ReadFloat('OrderParamPercent', ServiceId));
end;


// Получить параметры услуги по индексу.
procedure TMD_GetServiceParamsByIndex(Index: Integer;
  var ServiceCost: Single;
  var ServicePercent: Integer;
  var ServiceName: String;
  var ServiceId: Integer;
  var CanRepeatService: Boolean);
begin
  if Index = 1 then
  begin
    TMD_GetServiceParams(SERVICE_1, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_1;
    CanRepeatService := CAN_REPEAT_SERVICE_1;
  end
  else
  if Index = 2 then
  begin
    TMD_GetServiceParams(SERVICE_2, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_2;
    CanRepeatService := CAN_REPEAT_SERVICE_2;
  end
  else
  if Index = 3 then
  begin
    TMD_GetServiceParams(SERVICE_3, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_3;
    CanRepeatService := CAN_REPEAT_SERVICE_3;
  end
  else
  if Index = 4 then
  begin
    TMD_GetServiceParams(SERVICE_4, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_4;
    CanRepeatService := CAN_REPEAT_SERVICE_4;
  end
  else
  if Index = 5 then
  begin
    TMD_GetServiceParams(SERVICE_5, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_5;
    CanRepeatService := CAN_REPEAT_SERVICE_5;
  end
  else
  if Index = 6 then
  begin
    TMD_GetServiceParams(SERVICE_6, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_6;
    CanRepeatService := CAN_REPEAT_SERVICE_6;
  end
  else
  if Index = 7 then
  begin
    TMD_GetServiceParams(SERVICE_7, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_7;
    CanRepeatService := CAN_REPEAT_SERVICE_7;
  end
  else
  if Index = 8 then
  begin
    TMD_GetServiceParams(SERVICE_8, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_8;
    CanRepeatService := CAN_REPEAT_SERVICE_8;
  end
  else
  if Index = 9 then
  begin
    TMD_GetServiceParams(SERVICE_9, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_9;
    CanRepeatService := CAN_REPEAT_SERVICE_9;
  end
  else
  if Index = 10 then
  begin
    TMD_GetServiceParams(SERVICE_10, ServiceCost, ServicePercent, ServiceName);
    ServiceId := SERVICE_10;
    CanRepeatService := CAN_REPEAT_SERVICE_10;
  end;
end;


// Создать кнопку с услугой.
procedure TMD_CreateDriverServiceButton(Index: Integer; ButtonName: String);
var
  I, ServicePercent, ServiceId: Integer;
  ServiceCost: Single;
  ServiceName: String;
  CanRepeatService: Boolean;
begin
  TMD_GetServiceParamsByIndex(Index, ServiceCost, ServicePercent, ServiceName,
    ServiceId, CanRepeatService);
  if (ServiceId > 0) and
     ((ServiceCost <> 0) or (ServicePercent <> 0)) then
  begin
    WriteStr('Button', 'New', ButtonName);
    WriteStr('Button', 'Select', ButtonName);
    WriteInt('Button', 'Visible', 1);
    WriteInt('Button', 'Enabled', 1);
    WriteInt('Button', 'LongClick', 1);
    WriteStr('Button', 'Text', ServiceName);
  end;
end;


// Получить количество услуг, доступных водителю.
function TMD_GetDriverServicesCount: Integer;
begin
  if SERVICES_BUTTON_COUNT > 10 then
    Result := 10
  else
  if SERVICES_BUTTON_COUNT < 0 then
    Result := 0
  else
    Result := SERVICES_BUTTON_COUNT;
end;


// Инициализация доп. кнопок для водительских услуг.
procedure TMD_InitDriverServiceButtons;
var
  I: Integer;
  S: String;
begin
  for I := 1 to TMD_GetDriverServicesCount do
    TMD_CreateDriverServiceButton(I, 'DriverServiceButton' + IntToStr(I));
end;


// Перепроверить видимость услуг.
procedure TMD_RecheckDriverServiceButtons;
var
  I, J: Integer;
  ServicePercent, ServiceId: Integer;
  ServiceCost: Single;
  ServiceName: String;
  FoundService, CanRepeatService: Boolean;
  IsPressedUnrepeatableButton: Boolean;
begin
  for I := 1 to TMD_GetDriverServicesCount do
  begin
    TMD_GetServiceParamsByIndex(I, ServiceCost, ServicePercent, ServiceName,
      ServiceId, CanRepeatService);
    if ServiceId > 0 then
    begin
      WriteStr('Button', 'Select', 'DriverServiceButton' + IntToStr(I));
      // Кнопку нажали один раз, запрещено нажимать повторно.
      IsPressedUnrepeatableButton := not CanRepeatService and
        (ReadInt('Temp', 'DriverServiceButton' + IntToStr(I)) = 1);

      FoundService := False;
      for J := 0 to ReadInt('OrderParamsCount') - 1 do
        if ServiceId = ReadInt('OrderParamId', J) then
          FoundService := True;

      // В ТМ был добавлен атрибут с таким же ИД.
      // Нужно сделать соответствующую кнопку невидимой.
      if FoundService and
         ((ReadInt('Button', 'Visible') = 1) or IsPressedUnrepeatableButton) then
      begin
        WriteInt('Temp', 'DriverServiceButton' + IntToStr(I), 0);
        WriteInt('Button', 'Visible', 0);
      end
      else
      // В ТМ убрали атрибут.
      // Нужно вновь сделать кнопку видимой.
      if not FoundService and (ReadInt('Button', 'Visible') = 0) and
         not IsPressedUnrepeatableButton then
        WriteInt('Button', 'Visible', 1);
    end;
  end;
end;


// Взять сумму всех водительских услуг.
procedure TMD_GetDriverServicesSum(var DriverServicesSum: Single;
  var DriverServicesPercent: Integer);
var
  ServiceCost: Single;
  ServicePercent: Integer;
  ServiceName: String;
  ServiceId, I, ServicesCount: Integer;
  CanRepeatService: Boolean;
begin
  DriverServicesSum := 0;
  DriverServicesPercent := 0;
  for I := 1 to TMD_GetDriverServicesCount do
  begin
    ServicesCount := ReadInt('Temp', 'DriverServiceButton' + IntToStr(I));
    if ServicesCount > 0 then
    begin
      TMD_GetServiceParamsByIndex(I, ServiceCost, ServicePercent, ServiceName,
        ServiceId, CanRepeatService);
      DriverServicesSum := DriverServicesSum + ServicesCount * ServiceCost;
      DriverServicesPercent := DriverServicesPercent + ServicesCount * ServicePercent;
    end;
  end;
end;


// Добавить в чек стоимость за водительские услуги.
procedure TMD_AddDriverServices;
var
  ServiceName: String;
  ServiceCost: Single;
  I, ServicePercent, ServiceId, ServicesCount: Integer;
  CanRepeatService: Boolean;
begin
  for I := 1 to TMD_GetDriverServicesCount do
  begin
    ServicesCount := ReadInt('Temp', 'DriverServiceButton' + IntToStr(I));
    if ServicesCount > 0 then
    begin
      TMD_GetServiceParamsByIndex(I, ServiceCost, ServicePercent, ServiceName,
        ServiceId, CanRepeatService);

      if ServicePercent <> 0 then
      begin
        WriteStr('Bill', 'Code', 'DRIVER_SERVICE_PERCENT_' + IntToStr(I));
        WriteStr('Bill', 'Text', ServiceName);
        WriteStr('Bill', 'Value', IntToStr(ServicesCount));
        WriteStr('Bill', 'Sum', FloatToStr(ServicePercent * ServicesCount, 0) + '%');
      end;

      if ServiceCost <> 0 then
      begin
        WriteStr('Bill', 'Code', 'DRIVER_SERVICE_SUM_' + IntToStr(I));
        WriteStr('Bill', 'Text', ServiceName);
        WriteStr('Bill', 'Value', IntToStr(ServicesCount));
        WriteStr('Bill', 'Sum', FloatToStr(ServiceCost * ServicesCount, 2));
      end;
    end;
  end;
end;



// Добавить в чек стоимость за услуги (атрибуты/параметры).
procedure TMD_AddServices;
var
  F: Single;
begin
  F := ReadFloat('ServicesSum');
  if F <> 0 then
  begin
    WriteStr('Bill', 'Code', 'SERVICE_SUM');
    WriteStr('Bill', 'Text', 'Услуги');
    WriteStr('Bill', 'Value', ReadStr('ServicesName'));
    WriteStr('Bill', 'Sum', FloatToStr(F, 2));
  end;

  F := ReadFloat('ServicesPercent');
  if F <> 0 then
  begin
    WriteStr('Bill', 'Code', 'SERVICE_PERCENT');
    WriteStr('Bill', 'Text', 'Услуги');
    WriteStr('Bill', 'Value', ReadStr('ServicesName'));
    WriteStr('Bill', 'Sum', FloatToStr(F, 0) + '%');
  end;

  TMD_AddDriverServices;
end;


// Добавить в чек стоимость за скидки.
procedure TMD_AddDiscounts;
var
  Sum, DiscountSum, DiscountPercent: Single;
begin
  Sum := ReadFloat('Temp', 'SumBeforeDiscount');
  WriteStr('Bill', 'Code', 'BEFORE_DISC');
  WriteStr('Bill', 'Text', 'Сумма без скидки');
  WriteStr('Bill', 'Sum', FloatToStr(Sum, 2));

  DiscountSum := ReadFloat('TaxmTotalDiscSum');
  if DiscountSum <> 0 then
  begin
    WriteStr('Bill', 'Code', 'DISC_SUM');
    if DiscountSum < 0 then
      WriteStr('Bill', 'Text', 'Наценка')
    else
      WriteStr('Bill', 'Text', 'Скидка');
    WriteStr('Bill', 'Sum', FloatToStr(Abs(DiscountSum), 2));
  end;

  DiscountPercent := ReadFloat('TaxmTotalDiscPercent');
  if DiscountPercent <> 0 then
  begin
    WriteStr('Bill', 'Code', 'DISC_PERCENT');
    if DiscountPercent < 0 then
      WriteStr('Bill', 'Text', 'Наценка')
    else
      WriteStr('Bill', 'Text', 'Скидка');
    WriteStr('Bill', 'Sum', FloatToStr(Abs(DiscountPercent), 0) + '%');
  end;

  Sum := Sum - Sum * DiscountPercent / 100 - DiscountSum;

  WriteStr('Bill', 'Code', 'AFTER_DISC');
  WriteStr('Bill', 'Text', 'Сумма со скидкой');
  WriteStr('Bill', 'Sum', FloatToStr(Sum, 2));
end;


function TMD_UseCalcTMRoute: Boolean;
begin
  Result := USE_CALC_TM_ROUTE and (ReadInt('SupportedScriptVersion') >= 3);
end;


// Рассчитать стоимость за километраж с учётом маршрута из ТМ.
procedure TMD_RecalcDistSum;
var
  DistanceSum: Single;
begin
  if ReadInt('TMRouteReceiveTime') <> ReadInt('Temp', 'TMRouteReceiveTime') then
  begin
    WriteInt('Temp', 'TMRouteReceiveTime', ReadInt('TMRouteReceiveTime'));
    if (ReadInt('Now') - ReadInt('TMRouteSendTime') <= CALC_TM_ROUTE_FINISH_TIMEOUT) and
       (ReadFloat('TMRouteDistance') > 0) then
    begin
      if ReadFloat('TMRouteDistance') > ReadFloat('Temp', 'KmIncluded') then
      begin
        if ReadFloat('TMRouteCountryDistance') = 0 then
          DistanceSum := (ReadFloat('TMRouteDistance') - ReadFloat('Temp', 'KmIncluded')) * CITY_KM_COST
        else
        if ReadFloat('TMRouteCityDistance') > ReadFloat('Temp', 'KmIncluded') then
          DistanceSum := (ReadFloat('TMRouteCityDistance') - ReadFloat('Temp', 'KmIncluded')) * CITY_KM_COST +
            ReadFloat('TMRouteCountryDistance') * COUNTRY_KM_COST
        else
          DistanceSum := (ReadFloat('TMRouteDistance') - ReadFloat('Temp', 'KmIncluded')) * COUNTRY_KM_COST;
      end
      else
        DistanceSum := 0;

      // Перезаписать сумму и километраж.
      WriteFloat('Temp', 'DistanceSum', DistanceSum);
      WriteFloat('Temp', 'TotalDist', ReadFloat('TMRouteDistance'));
      WriteFloat('Temp', 'DistCity', ReadFloat('TMRouteCityDistance'));
      WriteFloat('Temp', 'DistCountry', ReadFloat('TMRouteCountryDistance'));
      WriteFloat('Temp', 'GPSLostDistSum', 0);
      WriteFloat('Temp', 'GpsLostDistCountry', 0);
      WriteFloat('Temp', 'GpsLostDistCity', 0);
      WriteFloat('Temp', 'GpsLostKmDist', 0);
    end;
  end;
end;


// Заполнить дополнительную информацию по тарифу в таксометре.
procedure TMD_FillMoreInfo;
var
  BoardingMoreInfo, CityMoreInfo, CountryMoreInfo: String;
  HasKmCost, HasMinutesCost: Boolean;
begin
  WriteStr('MoreInfo', 0, 'Тариф: ' + ReadStr('TariffName'));

  if CALC_SUM_BY_TAXIMETER then
  begin
    if not ReadBool('IsHourly') then
    begin
      // Если задан хоть один параметр города или загорода, нужно будет выводить оба, 
      // даже если цена будет 0.
      HasKmCost := (CITY_KM_COST <> 0) or (COUNTRY_KM_COST <> 0);
      HasMinutesCost := (CITY_MINUTE_COST <> 0) or (COUNTRY_MINUTE_COST <> 0);

      // Выводим подробный текст в поле посадки, если есть включенные км или минуты,
      // с учетом того, что есть соответствующие цены.
      if ((ReadFloat('Temp', 'KmIncluded') <> 0) and HasKmCost) or 
         ((ReadFloat('Temp', 'MinutesIncluded') <> 0) and HasMinutesCost) then
      begin
        BoardingMoreInfo := 'Первые';
        if HasKmCost then
          BoardingMoreInfo := BoardingMoreInfo + 
            ' ' + FloatToStr(ReadFloat('Temp', 'KmIncluded')) + ' км';
        if HasMinutesCost then
          BoardingMoreInfo := BoardingMoreInfo + 
            ' ' + FloatToStr(ReadFloat('Temp', 'MinutesIncluded')) + ' мин';

        CityMoreInfo := 'Далее город:';
        CountryMoreInfo := 'Далее загород:';
      end
      else
      // Иначе выводим обычный текст.
      begin
        BoardingMoreInfo := 'Посадка';
        CityMoreInfo := 'Город:';
        CountryMoreInfo := 'Загород:';
      end;

      // В конце строки посадки всегда пишем сумму посадки.
      BoardingMoreInfo := BoardingMoreInfo + 
        ': ' + FloatToStrFixed(ReadFloat('Temp', 'BoardingSum')) + ' ' + VALUTA;

      // Если есть цена за км, либо вообще нет ни одной цены, то выводим цену за км.
      if HasKmCost or not HasMinutesCost then
      begin
        CityMoreInfo := CityMoreInfo + 
          ' ' + FloatToStrFixed(CITY_KM_COST) + ' ' + VALUTA + '/км';
        CountryMoreInfo := CountryMoreInfo + 
          ' ' + FloatToStrFixed(COUNTRY_KM_COST) + ' ' + VALUTA + '/км';
      end;

      // Если есть цена за минуты, то выводим ее. 
      // Если при этом была цена за км, то цена за минуты выводится дополнительно.
      if HasMinutesCost then
      begin
        CityMoreInfo := CityMoreInfo + 
          ' ' + FloatToStrFixed(CITY_MINUTE_COST) + ' ' + VALUTA + '/мин';
        CountryMoreInfo := CountryMoreInfo + 
          ' ' + FloatToStrFixed(COUNTRY_MINUTE_COST) + ' ' + VALUTA + '/мин';
      end;

      if IDLE_MINUTE_COST <> 0 then
        WriteStr('MoreInfo', 1, 'Простой: ' +
          FloatToStrFixed(IDLE_MINUTE_COST) + ' ' + VALUTA + '/мин');
      if ReadFloat('Temp', 'MinSum') <> 0 then
        WriteStr('MoreInfo', 2, 'Минимум: ' +
          FloatToStrFixed(ReadFloat('Temp', 'MinSum')) + ' ' + VALUTA);
      WriteStr('MoreInfo', 3, BoardingMoreInfo);
      WriteStr('MoreInfo', 4, CityMoreInfo);
      WriteStr('MoreInfo', 5, CountryMoreInfo);
    end
    else
    begin
      if MIN_HOURLY <> 0 then
        WriteStr('MoreInfo', 1, 'Минимум: ' +
          FloatToStrFixed(MIN_HOURLY) + ' ' + VALUTA);
      if HOURLY_MINUTES_INCLUDED = 0 then
      begin
        WriteStr('MoreInfo', 3, 'Посадка: ' +
          FloatToStrFixed(BOARDING_HOURLY) + ' ' + VALUTA);
        if HOURLY_PERIOD > 0 then
          WriteStr('MoreInfo', 4, IntToStr(HOURLY_PERIOD) + ' мин: ' +
            FloatToStrFixed(HOURLY_MINUTE_COST * HOURLY_PERIOD) + ' ' + VALUTA)
        else
          WriteStr('MoreInfo', 4, '1 час: ' +
            FloatToStrFixed(HOURLY_MINUTE_COST * 60) + ' ' + VALUTA);
      end
      else
      begin
        WriteStr('MoreInfo', 3, 'Первые ' + IntToStr(HOURLY_MINUTES_INCLUDED) + ' мин: ' +
          FloatToStrFixed(BOARDING_HOURLY) + ' ' + VALUTA);
        if HOURLY_PERIOD > 0 then
          WriteStr('MoreInfo', 4, 'Далее ' + IntToStr(HOURLY_PERIOD) + ' мин: ' +
            FloatToStrFixed(HOURLY_MINUTE_COST * HOURLY_PERIOD) + ' ' + VALUTA)
        else
          WriteStr('MoreInfo', 4, 'Далее 1 час: ' +
            FloatToStrFixed(HOURLY_MINUTE_COST * 60) + ' ' + VALUTA);
      end;
    end;
  end;
end;


// Рассчитать полную стоимость поездки.
procedure TMD_CalcTaximeterSum;
var
  Sum, DriverServicesSum: Single;
  DriverServicesPercent: Integer;
  IsTripFinished: Boolean;
begin
  Sum := 0;
  TMD_RecheckDriverServiceButtons;
  // Стоимость всех водительских услуг.
  TMD_GetDriverServicesSum(DriverServicesSum, DriverServicesPercent);

  if CALC_SUM_BY_TAXIMETER then
  begin
    IsTripFinished := ReadInt('Temp', 'TripFinished') = 1;

    Sum := Sum + ReadFloat('Temp', 'PayWaitTimeSum') +
      ReadFloat('Temp', 'PriorOrderCost') +
      ReadFloat('Temp', 'SourceDistCountrySum') +
      ReadFloat('Temp', 'BoardingSum');

    if ReadBool('IsHourly') then
      Sum := Sum + ReadFloat('Temp', 'TripTimeSum') +
        ReadFloat('Temp', 'HourlyDistSum')
    else
    begin
      if not IsTripFinished and TMD_UseCalcTMRoute then
        TMD_RecalcDistSum;

      Sum := Sum + ReadFloat('Temp', 'DistanceSum') +
        ReadFloat('Temp', 'CityTripTimeSum') +
        ReadFloat('Temp', 'CountryTripTimeSum') +
        ReadFloat('Temp', 'GPSLostDistSum') +
        ReadFloat('Temp', 'IdleTimeSum') +
        ReadFloat('Temp', 'StopsSum') +
        ReadFloat('Temp', 'StopTimeSum');
    end;

    if not USE_REAL_ZONES_IN_TAXM then
      Sum := Sum + ReadFloat('TaxmZonesSum')
    else
      Sum := Sum + ReadFloat('Temp', 'ZoneStopSum') +
        ReadFloat('Temp', 'ZonePathSum') +
        ReadFloat('Temp', 'ZoneInCost') +
        ReadFloat('Temp', 'ZoneOutCost');

    if not SERVICES_AFTER_MIN then
    begin
      if IsTripFinished then
        TMD_AddServices;
      Sum := Sum + ReadFloat('ServicesSum') + DriverServicesSum +
        Sum * (DriverServicesPercent + ReadFloat('ServicesPercent')) / 100;
    end;

    // Сумма без скидки.
    // Работает только для Android.
    if ReadStr('Platform') = 'Android' then
      WriteFloat('Sum', RoundSum(Sum));

    if not DISCOUNT_AFTER_MIN then
    begin
      WriteFloat('Temp', 'SumBeforeDiscount', Sum);
      if IsTripFinished then
        TMD_AddDiscounts;
      Sum := Sum - Sum * ReadFloat('TaxmTotalDiscPercent') / 100 -
        ReadFloat('TaxmTotalDiscSum');
    end;

    if not ReadBool('IsHourly') and not ReadBool('IsCountry') then
      if (ReadInt('Temp', 'WasOutCity') = 0) and not ReadBool('InCity') then
      begin
        WriteInt('Temp', 'WasOutCity', 1);
        WriteFloat('Temp', 'MinSum', MIN_COUNTRY);
        WriteStr('MoreInfo', 2, 'Минимум: ' +
          FloatToStrFixed(MIN_COUNTRY) + ' ' + VALUTA);
      end;

    if IsTripFinished then
    begin
      WriteStr('Bill', 'Code', 'MINIMUM');
      WriteStr('Bill', 'Text', 'Минимум');
      WriteStr('Bill', 'Sum', FloatToStr(ReadFloat('Temp', 'MinSum'), 2));
    end;

    if (not MIN_SUM_AFTER_CALC) or (ReadInt('Temp', 'TripFinished') = 1) then
      if WAITING_INCLUDED then
        Sum := Max(ReadFloat('Temp', 'MinSum'), Sum)
      else
        Sum := Max(ReadFloat('Temp', 'MinSum') + ReadFloat('Temp', 'PayWaitTimeSum'), Sum);

    if SERVICES_AFTER_MIN then
    begin
      if IsTripFinished then
        TMD_AddServices;
      Sum := Sum + ReadFloat('ServicesSum') + DriverServicesSum +
        Sum * (DriverServicesPercent + ReadFloat('ServicesPercent')) / 100;
    end;

    if DISCOUNT_AFTER_MIN then
    begin
      WriteFloat('Temp', 'SumBeforeDiscount', Sum);
      if IsTripFinished then
        TMD_AddDiscounts;
      Sum := Sum - Sum * ReadFloat('TaxmTotalDiscPercent') / 100 -
        ReadFloat('TaxmTotalDiscSum');
    end;
  end
  else
  begin
    WriteStr('Caption', '');
    Sum := ReadFloat('OperSum');
    Sum := Sum + DriverServicesSum + Sum * DriverServicesPercent / 100;

    if USE_STOPS_WAITING_IDLE then
      Sum := Sum + ReadFloat('Temp', 'PayWaitTimeSum') +
        ReadFloat('Temp', 'IdleTimeSum') +
        ReadFloat('Temp', 'StopsSum') +
        ReadFloat('Temp', 'StopTimeSum');

    WriteFloat('Sum', RoundSum(Sum));
  end;

  Sum := RoundSum(Sum);

  // Итоговая сумма со скидкой.
  WriteFloat('TotalSum', Sum);

  // Для ios надо заполнить параметр Sum.
  if (ReadStr('Platform') <> 'Android') and CALC_SUM_BY_TAXIMETER then
    WriteFloat('Sum', Sum);

  WriteStr('SumStr', FloatToStrFixed(Sum));
  WriteFloat('CurrentSum', Sum);
end;


// ***************
// Начало расчета.
// ***************
procedure InitCalc;
var
  F, MinSum, Boarding, KmIncluded, MinutesIncluded: Single;
begin
  TMD_InitDriverServiceButtons;
  F := ReadFloat('Temp', 'PayWaitTimeSum');
  if F <> 0 then
  begin
    WriteStr('Bill', 'Code', 'WAITING_TIME');
    WriteStr('Bill', 'Text', 'Ожидание');
    WriteStr('Bill', 'Value',
      TimeLenToStr(ReadInt('WaitTime')));
    WriteStr('Bill', 'Sum', FloatToStr(F, 2));
  end;

  if CALC_SUM_BY_TAXIMETER then
  begin
    if ReadBool('IsPrior') and (PRIOR_ORDER_COST <> 0) then
    begin
      WriteStr('Bill', 'Code', 'PRIOR_ORDER');
      WriteStr('Bill', 'Text', 'Предварительный');
      WriteStr('Bill', 'Sum', FloatToStr(PRIOR_ORDER_COST, 2));
      WriteFloat('Temp', 'PriorOrderCost', PRIOR_ORDER_COST);
    end;

    F := ReadFloat('SourceDistCountry') * SOURCE_COUNTRY_KM_COST;
    if F <> 0 then
    begin
      WriteStr('Bill', 'Code', 'SOURCE_COUNTRY_DIST');
      WriteStr('Bill', 'Text', 'До подачи загород');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('SourceDistCountry'), 2) + ' км');
      WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      WriteFloat('Temp', 'SourceDistCountrySum', F);
    end;

    if not ReadBool('IsHourly') then
    begin
      if TMD_UseCalcTMRoute then
      begin
        WriteInt('UseCalcTMRoute', 1);
        WriteInt('CalcTMRoutePeriodSec', CALC_TM_ROUTE_PERIOD);
        ReadInt('Temp', 'TMRouteReceiveTime', 0);
      end;

      if ReadBool('IsCountry') or not ReadBool('InCity') then
      begin
        Boarding := BOARDING_COUNTRY;
        KmIncluded := COUNTRY_KM_INCLUDED;
        MinutesIncluded := COUNTRY_MINUTES_INCLUDED;
        MinSum := MIN_COUNTRY;
        WriteInt('Temp', 'WasOutCity', 1);
      end
      else
      begin
        Boarding := BOARDING_CITY;
        KmIncluded := CITY_KM_INCLUDED;
        MinutesIncluded := CITY_MINUTES_INCLUDED;
        MinSum := MIN_CITY;
        WriteInt('Temp', 'WasOutCity', 0);
      end;
      WriteFloat('Temp', 'KmIncluded', KmIncluded);
      WriteFloat('Temp', 'MinutesIncluded', MinutesIncluded);
    end
    else
    begin
      Boarding := BOARDING_HOURLY;
      MinSum := MIN_HOURLY;
    end;
    WriteFloat('Temp', 'BoardingSum', Boarding);
    WriteFloat('Temp', 'MinSum', MinSum);

    // Определяем район по фактическим координатам.
    if USE_REAL_ZONES_IN_TAXM then
    begin
      // Посадка в районе.
      if USE_ZONE_COST then
      begin
        F := ReadFloat('ZoneInCost', ReadInt('ZoneId'));
        if F <> 0 then
        begin
          WriteStr('Bill', 'Code', 'ZONE_IN');
          WriteStr('Bill', 'Text', 'Посадка ' +
            '"' + ReadStr('ZoneName') + '"');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));

          WriteFloat('Temp', 'ZoneInCost', F);
        end;
      end;

      // Сохраняем текущий район.
      WriteInt('Temp', 'LastZoneId', ReadInt('ZoneId'));
    end;
  end;

  TMD_CalcTaximeterSum;

  TMD_FillMoreInfo;

  WriteInt('Temp', 'AllStopTime', 0);
  WriteFloat('Temp', 'StopTimeSum', 0);
end;


// Использовать восстановление километража при потере GPS.
function TMD_UseGPSMissedDistanceRecovery: Boolean;
begin
  Result := USE_GPS_MISSED_DISTANCE_RECOVERY and
    (ReadInt('SupportedScriptVersion') > 0);
end;


// Пересчитать параметры, связанные с координатами.
procedure TMD_RecalcLostGPSParams;
var
  Lat, Lon, CurTotalDistance, KmCost, DistDelta: Single;
begin
  Lon := ReadFloat('Lon');
  Lat := ReadFloat('Lat');

  // Посчитать километраж по прямой, если появились координаты.
  if (ReadInt('Temp', 'IsLostGPS') = 1) and
     ((ReadFloat('Temp', 'OldLat') > 0) or
     (ReadFloat('Temp', 'OldLon') > 0)) and
     ((Lat > 0) or (Lon > 0)) then
  begin
    DistDelta := SegmentLength(ReadFloat('Temp', 'OldLon'),
      ReadFloat('Temp', 'OldLat'), Lon, Lat);

    WriteFloat('Temp', 'GpsLostKmDist',
      ReadFloat('Temp', 'GpsLostKmDist') + DistDelta);

    CurTotalDistance := ReadFloat('Temp', 'TotalDist') + DistDelta;

    // При восстанавлении координат не успевает правильно
    // определиться флаг ReadBool('InCity').
    if ReadInt('Temp', 'OldInCity') > 0 then
    begin
      WriteFloat('Temp', 'GpsLostDistCity',
        ReadFloat('Temp', 'GpsLostDistCity') + DistDelta);
      KmCost := CITY_KM_COST;
    end
    else
    begin
      WriteFloat('Temp', 'GpsLostDistCountry',
        ReadFloat('Temp', 'GpsLostDistCountry') + DistDelta);
      KmCost := COUNTRY_KM_COST;
    end;

    if CurTotalDistance > ReadFloat('Temp', 'KmIncluded') then
    begin
      // Если при восстановлении координат сразу закончился
      // включенный киломтраж.
      if ReadFloat('Temp', 'TotalDist') < ReadFloat('Temp', 'KmIncluded') then
        // Платный километраж.
        DistDelta := CurTotalDistance - ReadFloat('Temp', 'KmIncluded');

      WriteFloat('Temp', 'GPSLostDistSum',
        ReadFloat('Temp', 'GPSLostDistSum') + KmCost * DistDelta);
    end;
  end;

  // Пропал сигнал GPS.
  if (Lat = 0) and (Lon = 0) then
    WriteInt('Temp', 'IsLostGPS', 1)
  else
  // Есть сигнал GPS.
  begin
    WriteFloat('Temp', 'OldLat', Lat);
    WriteFloat('Temp', 'OldLon', Lon);
    if ReadBool('InCity') then
      WriteInt('Temp', 'OldInCity', 1)
    else
      WriteInt('Temp', 'OldInCity', 0);
    WriteInt('Temp', 'IsLostGPS', 0);
  end;
end;


// *******
// Расчёт.
// *******
procedure StepCalc;
var
  F, DistDelta, TripDistance: Single;
  City: String;
  Seconds: Integer;
begin
  if CALC_SUM_BY_TAXIMETER then
  begin
    if ReadBool('HasCities') then
    begin
      if ReadBool('InCity') then
        City := ' [' + ReadStr('CityName') + ']'
      else
        City := ' [загород]';
    end;

    DistDelta := ReadFloat('DistDelta');
    if ReadBool('IsHourly') then
    begin
      WriteStr('Caption', 'ЧАС' + City);

      if ReadInt('TripTime') > HOURLY_MINUTES_INCLUDED * 60 then
      begin
        if HOURLY_PERIOD = 0 then
          F := HOURLY_MINUTE_COST / 60
        else
          if Floor((ReadInt('TripTime') - HOURLY_MINUTES_INCLUDED * 60 - 1) /
             60 / HOURLY_PERIOD) * HOURLY_PERIOD * 60 =
             ReadInt('TripTime') - HOURLY_MINUTES_INCLUDED * 60 - 1 then
            F := HOURLY_PERIOD * HOURLY_MINUTE_COST
          else
            F := 0;
        if F <> 0 then
        begin
          WriteFloat('Temp', 'TripTimeSum',
            ReadFloat('Temp', 'TripTimeSum') + F);
        end;
      end;

      if HOURLY_KM_COST > 0 then
      begin
        F := 0;
        if HOURLY_HOUR_KM_INCLUDED > 0 then
        begin
          // Ещё один час закончился.
          if ReadInt('TripTime') mod (60 * 60) = 0 then
            WriteFloat('Temp', 'DistHour', 0);

          WriteFloat('Temp', 'DistHour',
            ReadFloat('Temp', 'DistHour') + DistDelta);

          if ReadFloat('Temp', 'DistHour') > HOURLY_HOUR_KM_INCLUDED then
            F := DistDelta * HOURLY_KM_COST;
        end
        else
        if HOURLY_TRIP_KM_INCLUDED > 0 then
        begin
          if ReadFloat('TripDistance') > HOURLY_TRIP_KM_INCLUDED then
            F := DistDelta * HOURLY_KM_COST;
        end
        else
          F := DistDelta * HOURLY_KM_COST;

        if F <> 0 then
        begin
          WriteFloat('Temp', 'HourlyDist',
            ReadFloat('Temp', 'HourlyDist') + DistDelta);
          WriteFloat('Temp', 'HourlyDistSum',
            ReadFloat('Temp', 'HourlyDistSum') + F);
        end;
      end;
    end
    else
    begin
      WriteFloat('Temp', 'TotalDist',
        ReadFloat('Temp', 'TotalDist') + DistDelta);
      // Если скорость достаточная, считать по километражу.
      if ReadFloat('Speed') > SPEED_LIMIT then
      begin
        WriteStr('Caption', 'КМ' + City);
        TripDistance := ReadFloat('Temp', 'TotalDist') + ReadFloat('Temp', 'GpsLostDistCountry') +
          ReadFloat('Temp', 'GpsLostDistCity');
        if not ReadBool('InCity') then
        begin
          WriteFloat('Temp', 'DistCountry',
            ReadFloat('Temp', 'DistCountry') + DistDelta);
          if TripDistance > ReadFloat('Temp', 'KmIncluded') then
          begin
            WriteFloat('Temp', 'DistanceSum',
              ReadFloat('Temp', 'DistanceSum') + COUNTRY_KM_COST * DistDelta);
          end;
        end
        else
        begin
          WriteFloat('Temp', 'DistCity',
            ReadFloat('Temp', 'DistCity') + DistDelta);
          if TripDistance > ReadFloat('Temp', 'KmIncluded') then
          begin
            WriteFloat('Temp', 'DistanceSum',
              ReadFloat('Temp', 'DistanceSum') + CITY_KM_COST * DistDelta);
          end;
        end;
      end;

      if (COUNTRY_MINUTE_COST <> 0) or (CITY_MINUTE_COST <> 0) then
        if not ReadBool('InCity') then
        begin
          WriteInt('Temp', 'CountryTripTime', 
            ReadInt('Temp', 'CountryTripTime') + 1);
          if ReadInt('TripTime') > ReadFloat('Temp', 'MinutesIncluded') * 60 then
            WriteFloat('Temp', 'CountryTripTimeSum', 
              ReadFloat('Temp', 'CountryTripTimeSum') + COUNTRY_MINUTE_COST / 60);
        end
        else
        begin
          WriteInt('Temp', 'CityTripTime', 
            ReadInt('Temp', 'CityTripTime') + 1);
          if ReadInt('TripTime') > ReadFloat('Temp', 'MinutesIncluded') * 60 then
            WriteFloat('Temp', 'CityTripTimeSum', 
              ReadFloat('Temp', 'CityTripTimeSum') + CITY_MINUTE_COST / 60);
        end;

      if TMD_UseGPSMissedDistanceRecovery then
        TMD_RecalcLostGPSParams;
    end;
  end;

  if TMD_UseCalcStopsIdle then
  begin
    if ReadFloat('Speed') > SPEED_LIMIT then
      WriteInt('Temp', 'LastKMTime', ReadInt('TripTime'))
    else
    if ReadInt('TripTime') - ReadInt('Temp', 'LastKMTime') > FREE_IDLE_TIME then
    begin
      WriteStr('Caption', 'Простой');
      WriteInt('Temp', 'IdleTime',
        ReadInt('Temp', 'IdleTime') + 1);
      WriteFloat('Temp', 'IdleTimeSum',
        ReadFloat('Temp', 'IdleTimeSum') + IDLE_MINUTE_COST / 60);
    end
    else
    begin
      Seconds := FREE_IDLE_TIME -
        (ReadInt('TripTime') - ReadInt('Temp', 'LastKMTime'));
      WriteStr('Caption', 'Ожидание (' + IntToStr(Seconds) + ')' + City);
    end;
  end;

  TMD_CalcTaximeterSum;
end;


// *****************
// Начало остановки.
// *****************
procedure StartStop;
var
  F: Single;
begin
  if CALC_SUM_BY_TAXIMETER then
  begin
    WriteStr('Caption', 'Остановка');
    WriteInt('UseZonesPathGroupId', ZONES_PATH_GROUP_ID);

    // Определяем район по фактическим координатам.
    if USE_REAL_ZONES_IN_TAXM then
    begin
      if ReadInt('ZoneId') <> ReadInt('Temp', 'LastZoneId') then
        // Сохраняем признак, что покидали район посадки.
        WriteInt('Temp', 'NeedZoneOutCost', 1);

      // Проезды между районами
      if (USE_ZONE_PATH) and (ReadInt('ZoneId') > 0) then
      begin
        F := ReadFloat('ZonePathCost',
          ReadInt('Temp', 'LastZoneId'), ReadInt('ZoneId'));
        if F <> 0 then
        begin
          WriteStr('Bill', 'Code', 'ZONES_PATH');
          WriteStr('Bill', 'Text', 'Проезд ' + '"' +
            ReadStr('ZoneName', ReadInt('Temp', 'LastZoneId')) +
            '"-"' + ReadStr('ZoneName') + '"');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));

          WriteFloat('Temp', 'ZonePathSum',
            ReadFloat('Temp', 'ZonePathSum') + F);
        end;
      end;

      // Сохраняем текущий район.
      WriteInt('Temp', 'LastZoneId', ReadInt('ZoneId'));

      // Остановка в районе.
      if USE_ZONE_COST then
      begin
        F := ReadFloat('ZoneStopCost', ReadInt('ZoneId'));
        if F <> 0 then
        begin
          WriteStr('Bill', 'Code', 'ZONES_STOP');
          WriteStr('Bill', 'Text', 'Остановка ' +
            '"' + ReadStr('ZoneName') + '"');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));

          WriteFloat('Temp', 'ZoneStopSum',
            ReadFloat('Temp', 'ZoneStopSum') + F);
        end;
      end;
    end;
  end;

  if TMD_UseCalcStopsIdle then
  begin
    WriteInt('Temp', 'StopTime', 0);
    WriteInt('Temp', 'StopsCount',
      ReadInt('Temp', 'StopsCount') + 1);
    WriteFloat('Temp', 'StopsSum',
      ReadFloat('Temp', 'StopsSum') + MIN_STOP_COST);
  end;

  TMD_CalcTaximeterSum;
end;


// **********
// Остановка.
// **********
procedure StepCalcStop;
var
  StopTime: Integer;
  Sum: Single;
begin
  if not TMD_UseCalcStopsIdle then
    StepCalc
  else
  begin
    WriteFloat('Temp', 'TotalDist',
      ReadFloat('Temp', 'TotalDist') + ReadFloat('DistDelta'));
    if TMD_UseGPSMissedDistanceRecovery then
      TMD_RecalcLostGPSParams;

    if STOP_MINUTE_COST <> 0 then
    begin
      StopTime := ReadInt('Temp', 'StopTime') + 1;

      if StopTime > (STOP_MINUTES_INCLUDED * 60) then
      begin
        WriteFloat('Temp', 'StopTimeSum',
          ReadFloat('Temp', 'StopTimeSum') + STOP_MINUTE_COST / 60);
        TMD_CalcTaximeterSum;
      end;

      WriteInt('Temp', 'StopTime', StopTime);
      WriteInt('Temp', 'AllStopTime',
        ReadInt('Temp', 'AllStopTime') + 1);
    end;
  end;
end;


// ****************
// Конец остановки.
// ****************
procedure EndStop;
begin
  WriteStr('Caption', '');
end;


// ****************
// Обработка дополнительных функциональных кнопок.
// ****************
procedure ButtonClick;
var
  ButtonName, ServiceName: String;
  Sum, ServiceSum, PercentSum: Single;
  I, ServicePercent, ServiceId: Integer;
  CanRepeatService: Boolean;
begin
  ButtonName := ReadStr('Button', 'Clicked');
  for I := 1 to TMD_GetDriverServicesCount do
    if ButtonName = 'DriverServiceButton' + IntToStr(I) then
    begin
      TMD_GetServiceParamsByIndex(I, ServiceSum, ServicePercent, ServiceName,
        ServiceId, CanRepeatService);
      if CanRepeatService then
        WriteInt('Temp', 'DriverServiceButton' + IntToStr(I),
          ReadInt('Temp', 'DriverServiceButton' + IntToStr(I)) + 1)
      else
      begin
        WriteInt('Temp', 'DriverServiceButton' + IntToStr(I), 1);
        WriteStr('Button', 'Select', ButtonName);
        WriteInt('Button', 'Visible', 0);
      end;
    end;

  TMD_CalcTaximeterSum;
end;


// Добавить в чек стоимость за восстановленный километраж.
procedure TMD_AddGPSParams;
begin
  if TMD_UseGPSMissedDistanceRecovery and
     (ReadFloat('Temp', 'GpsLostKmDist') > 0) then
  begin
    if ReadFloat('Temp', 'GPSLostDistCity') > 0 then
    begin
      WriteStr('Bill', 'Code', 'CITY_LOST_GPS_DIST');
      WriteStr('Bill', 'Text', 'По городу при отсутствии GPS');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('Temp', 'GPSLostDistCity'), 2) + ' км');
    end;

    if ReadFloat('Temp', 'GPSLostDistCountry') > 0 then
    begin
      WriteStr('Bill', 'Code', 'COUNTRY_LOST_GPS_DIST');
      WriteStr('Bill', 'Text', 'За городом при отсутствии GPS');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('Temp', 'GPSLostDistCountry'), 2) + ' км');
    end;
  end;
end;


// Добавить в чек стоимость за простой, ожидание, остановки.
procedure TMD_AddTimeParams;
begin
  WriteStr('Bill', 'Code', 'IDLE_TIME');
  WriteStr('Bill', 'Text', 'Простой');
  WriteStr('Bill', 'Value',
    TimeLenToStr(ReadInt('Temp', 'IdleTime')));
  WriteStr('Bill', 'Sum',
    FloatToStr(ReadFloat('Temp', 'IdleTimeSum'), 2));

  if ReadInt('Temp', 'StopsCount') > 0 then
  begin
    WriteStr('Bill', 'Code', 'STOPS');
    WriteStr('Bill', 'Text', 'Остановки');
    WriteStr('Bill', 'Value',
      IntToStr(ReadInt('Temp', 'StopsCount')) + ' шт');
    WriteStr('Bill', 'Sum',
      FloatToStr(ReadFloat('Temp', 'StopsSum'), 2));

    if (STOP_MINUTE_COST <> 0) and (ReadFloat('Temp', 'StopTimeSum') <> 0) then
    begin
      WriteStr('Bill', 'Code', 'STOPS_TIME');
      WriteStr('Bill', 'Text', 'Длит. остановок');
      WriteStr('Bill', 'Value',
        TimeLenToStr(ReadInt('Temp', 'AllStopTime')));
      WriteStr('Bill', 'Sum',
        FloatToStr(ReadFloat('Temp', 'StopTimeSum'), 2));
    end;
  end;
end;


// *******************
// Завершение расчета.
// *******************
procedure TermCalc;
var
  F: Single;
begin
  WriteInt('Temp', 'TripFinished', 1);
  if CALC_SUM_BY_TAXIMETER then
  begin
    WriteInt('UseZonesPathGroupId', ZONES_PATH_GROUP_ID);

    if not USE_REAL_ZONES_IN_TAXM then
    begin
      F := ReadFloat('TaxmZonesSum');
      if F <> 0 then
      begin
        WriteStr('Bill', 'Code', 'ZONES');
        WriteStr('Bill', 'Text', 'Районы');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      end;
    end
    else
    begin
      // Перед высадкой проверяем проезды между районами
      if (USE_ZONE_PATH) and (ReadInt('ZoneId') > 0) then
      begin
        F := ReadFloat('ZonePathCost',
          ReadInt('Temp', 'LastZoneId'), ReadInt('ZoneId'));
        if F <> 0 then
        begin
          WriteStr('Bill', 'Code', 'ZONES_PATH');
          WriteStr('Bill', 'Text', 'Проезд ' + '"' +
            ReadStr('ZoneName', ReadInt('Temp', 'LastZoneId')) +
            '"-"' + ReadStr('ZoneName') + '"');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));

          WriteFloat('Temp', 'ZonePathSum',
            ReadFloat('Temp', 'ZonePathSum') + F);
        end;
      end;

      // Высадка в районе.
      if USE_ZONE_COST and (ReadInt('ZoneId') > 0) and
         ((ReadInt('ZoneId') <> ReadInt('Temp', 'LastZoneId')) or
         (ReadInt('Temp', 'NeedZoneOutCost') = 1)) then
      begin
        F := ReadFloat('ZoneOutCost', ReadInt('ZoneId'));
        if F <> 0 then
        begin
          WriteStr('Bill', 'Code', 'ZONES_OUT');
          WriteStr('Bill', 'Text', 'Высадка ' +
            '"' + ReadStr('ZoneName') + '"');
          WriteStr('Bill', 'Sum', FloatToStr(F, 2));

          WriteFloat('Temp', 'ZoneOutCost', F);
        end;
      end;
    end;

    if ReadBool('IsHourly') then
    begin
      WriteStr('Bill', 'Code', 'TRIP_TIME');
      WriteStr('Bill', 'Text', 'Общее время');
      WriteStr('Bill', 'Value',
        TimeLenToStr(ReadInt('TripTime')));
      WriteStr('Bill', 'Sum',
        FloatToStr(ReadFloat('Temp', 'TripTimeSum') + ReadFloat('Temp', 'BoardingSum'), 2));

      WriteStr('Bill', 'Code', 'TRIP_DIST');
      WriteStr('Bill', 'Text', 'Общее расстояние');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('TripDistance'), 2) + ' км');

      F := ReadFloat('Temp', 'HourlyDistSum');
      if F > 0 then
      begin
        WriteStr('Bill', 'Code', 'HOURLY_PAY_DIST');
        WriteStr('Bill', 'Text', 'Платный километраж');
        WriteStr('Bill', 'Value',
          FloatToStr(ReadFloat('Temp', 'HourlyDist'), 2) + ' км');
        WriteStr('Bill', 'Sum', FloatToStr(F, 2));
      end;
    end
    else
    begin
      if TMD_UseCalcTMRoute then
        TMD_RecalcDistSum;

      WriteStr('Bill', 'Code', 'TRIP_TIME');
      WriteStr('Bill', 'Text', 'Общее время');
      WriteStr('Bill', 'Value',
        TimeLenToStr(ReadInt('TripTime')));

      if CITY_MINUTE_COST <> 0 then
      begin
        WriteStr('Bill', 'Code', 'CITY_TRIP_TIME');
        WriteStr('Bill', 'Text', 'Время по городу');
        WriteStr('Bill', 'Value',
          TimeLenToStr(ReadInt('Temp', 'CityTripTime')));
        WriteStr('Bill', 'Sum', 
          FloatToStr(ReadFloat('Temp', 'CityTripTimeSum'), 2));
      end;

      if COUNTRY_MINUTE_COST <> 0 then
      begin
        WriteStr('Bill', 'Code', 'COUNTRY_TRIP_TIME');
        WriteStr('Bill', 'Text', 'Время за городом');
        WriteStr('Bill', 'Value',
          TimeLenToStr(ReadInt('Temp', 'CountryTripTime')));
        WriteStr('Bill', 'Sum', 
          FloatToStr(ReadFloat('Temp', 'CountryTripTimeSum'), 2));  
      end;

      WriteStr('Bill', 'Code', 'TRIP_DIST');
      WriteStr('Bill', 'Text', 'Общее расстояние');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('Temp', 'TotalDist'), 2) + ' км');
      WriteStr('Bill', 'Sum',
        FloatToStr(ReadFloat('Temp', 'BoardingSum') + 
          ReadFloat('Temp', 'DistanceSum') + 
          ReadFloat('Temp', 'GPSLostDistSum'), 2));

      WriteStr('Bill', 'Code', 'CITY_DIST');
      WriteStr('Bill', 'Text', 'По городу');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('Temp', 'DistCity'), 2) + ' км');

      WriteStr('Bill', 'Code', 'COUNTRY_DIST');
      WriteStr('Bill', 'Text', 'За городом');
      WriteStr('Bill', 'Value',
        FloatToStr(ReadFloat('Temp', 'DistCountry'), 2) + ' км');

      TMD_AddGPSParams;

      TMD_AddTimeParams;
    end;

    TMD_CalcTaximeterSum;
  end
  else
  begin
    WriteStr('Bill', 'Code', 'TRIP_TIME');
    WriteStr('Bill', 'Text', 'Общее время');
    WriteStr('Bill', 'Value',
      TimeLenToStr(ReadInt('TripTime')));

    WriteStr('Bill', 'Code', 'TRIP_DIST');
    WriteStr('Bill', 'Text', 'Общее расстояние');
    WriteStr('Bill', 'Value',
      FloatToStr(ReadFloat('TripDistance'), 2) + ' км');

    WriteStr('Bill', 'Code', 'OPER_SUM');
    WriteStr('Bill', 'Text', 'Сумма оператора');
    WriteStr('Bill', 'Sum', FloatToStr(ReadFloat('OperSum'), 2));

    if USE_STOPS_WAITING_IDLE then
      TMD_AddTimeParams;

    TMD_AddDriverServices;

    TMD_CalcTaximeterSum;

    WriteStr('Bill', 'Code', 'AFTER_DISC');
    WriteStr('Bill', 'Text', 'Сумма');
    if ReadStr('Platform') = 'Android' then
       WriteStr('Bill', 'Sum', FloatToStr(ReadFloat('TotalSum'), 2))
    else
       WriteStr('Bill', 'Sum', FloatToStr(ReadFloat('Sum'), 2));
  end;
end;

// *****************************************************************
// Добавить строку в чек. В конец строки вставляется перенос строки.
// *****************************************************************
procedure AddLine(Line: String);
begin
  WriteStr('PrintCheck', 'Text', Line);
end;

// ******************************************
// Добавить в чек строку типа текст/значение.
// ******************************************
procedure AddLineTextValue(Line: String; Value: String);
begin
  WriteStr('PrintCheck', 'Text', Line);
  WriteStr('PrintCheck', 'Value', Value);
end;

// ******************************************
// Добавить в чек строку типа текст/значение для стоимости.
// ******************************************
procedure AddTextCostValue(Line: String; Value: Single);
begin
  WriteStr('PrintCheck', 'Text', Line);
  WriteStr('PrintCheck', 'Value', '=' + FloatToStr(Value, 2));
end;

// ******************************************
// Добавить в чек строку типа текст/значение с проверкой на 0.
// ******************************************
procedure AddTextNotNullValue(Line: String; Value: Single);
begin
  if Value <> 0 then
    AddTextCostValue(Line, Value);
end;

// ******************************
// Добавить перенос строки в чек.
// ******************************
procedure AddLineBreak;
begin
  WriteStr('PrintCheck', 'BreakLine');
end;

// ******************************
// Получить текущую дату и время в виде строки.
// ******************************
function GetDateTimeStr(DT: Integer): String;
var
  TmpStr: String;
  D, M, Y, DW, H, S, I: Integer;
begin
  TmpStr := '';
  ExtractDate(DT, D, M, Y, DW);
  if D < 10 then
    TmpStr := TmpStr + '0';
  TmpStr := TmpStr + IntToStr(D) + '.';
  if M < 10 then
    TmpStr := TmpStr + '0';
  TmpStr := TmpStr + IntToStr(M) + '.';
  Y := Y mod 100;
  if Y < 10 then
    TmpStr := TmpStr + '0';
  TmpStr := TmpStr + IntToStr(y) + ' ';
  ExtractTime(ReadInt('Now'), H, M, S);
  if H < 10 then
    TmpStr := TmpStr + '0';
  TmpStr := TmpStr + IntToStr(H) + ':';
  if M < 10 then
    TmpStr := TmpStr + '0';
  TmpStr := TmpStr + IntToStr(M);

  Result := TmpStr;
end;

// ******************************
// Сформировать QR-код.
// ******************************
function GetQrCode: String;
var
  D, M, Y, DW, H, MM, S, I: Integer;
  QR: String;
begin
  ExtractDate(ReadInt('FiscalInfo', 'CompleteTime'), D, M, Y, DW);
  ExtractTime(ReadInt('FiscalInfo', 'CompleteTime'), H, MM, S);
  QR := 't=' +IntToStr(Y) + IntToStr(M) + IntToStr(D) + 'T' + IntToStr(H) +
    IntToStr(MM);
  QR := QR + '&s=' + FloatToStr(ReadFloat('BankCardSum') + ReadFloat('CashSum'), 2);
  QR := QR + '&fn=' + ReadStr('FiscalInfo', 'FiscalNumber');
  QR := QR + '&i=' + IntToStr(ReadInt('FiscalInfo', 'FiscalDocumentNumber'));
  QR := QR + '&fp=' + ReadStr('FiscalInfo', 'FiscalDocumentSign');
  QR := QR + '&n=1';
  Result := QR;
end;

// ************
// Печать чека.
// ************
procedure PrintCheck;
var
  I: Integer;
  TmpStr, PrinterModel, Encoding: String;
  ServicePercent, SumServicePercent, NdsSum, FiscalSum, DiscountSum: Single;
begin
  WriteStr('PrintCheck', 'Align', '0');
  AddLine(TAXI_NAME);
  AddLine('т. ' + TAXI_PHONE);
  AddLineBreak;
  AddLine('БЛАГОДАРИМ ВАС');
  AddLine('ЗА ОБРАЩЕНИЕ В НАШУ КОМПАНИЮ!');
  AddLineBreak;

  // Детализация поездки
  if NEED_DETAILS_IN_CHECK then
  begin
    if not ReadBool('IsBorder') then
      AddLine('Заказ #' + IntToStr(ReadInt('OrderId')))
    else
      AddLine('Бордюрный заказ');

    AddLine('Тариф: ' + ReadStr('TariffName'));
    if not ReadBool('IsBorder') then
      AddLine('Адрес: ' + ReadStr('SourceAddress'));
    AddLine('Водитель: ' + ReadStr('DriverName'));
    AddLine('Машина: ' + ReadStr('CarColor') + ' ' +
      ReadStr('CarMark') + ' ' + ReadStr('CarModel') + ' ' + ReadStr('CarGosnumber'));
    AddLineBreak;
    AddLine('Километраж: ' + FloatToStr(ReadFloat('TripDistance'), 2) + ' км');
    AddLine('Длительность: ' + TimeLenToStr(ReadInt('TripTime')));
    AddLineBreak;

    if CALC_SUM_BY_TAXIMETER then
    begin
      AddLine('Услуга                     Сумма');
      AddLine('--------------------------------');

      AddTextNotNullValue('Доезд до адреса подачи',
        ReadFloat('Temp', 'SourceDistCountrySum'));
      AddTextNotNullValue('Ожидание', ReadFloat('Temp', 'PayWaitTimeSum'));
      AddTextNotNullValue('Посадка', ReadFloat('Temp', 'BoardingSum'));
      AddTextNotNullValue('Районы', ReadFloat('TaxmZonesSum'));

      if ReadBool('IsHourly') then
      begin
        AddTextNotNullValue('Поездка', ReadFloat('Temp', 'TripTimeSum'));
      end
      else
      begin
        AddTextNotNullValue('По городу', ReadFloat('Temp', 'DistanceSum'));
        AddTextNotNullValue('За городом', ReadFloat('Temp', 'DistCountrySum'));
        if ReadFloat('Temp', 'CityTripTimeSum') <> 0 then
          AddTextNotNullValue('Время по городу', ReadFloat('Temp', 'CityTripTimeSum'));
        if ReadFloat('Temp', 'CountryTripTimeSum') <> 0 then
          AddTextNotNullValue('Время за городом', ReadFloat('Temp', 'CountryTripTimeSum'));
        AddTextNotNullValue('Простой', ReadFloat('Temp', 'IdleTimeSum'));
        AddTextNotNullValue('Остановки', ReadFloat('Temp', 'StopsSum'));
      end;

      if ReadFloat('ServicesSum') <> 0 then
      begin
        for I := 0 to ReadInt('ServiceCount') - 1 do
          AddTextNotNullValue(ReadStr('ServiceName', ReadInt('OrderServiceId', I)),
            ReadFloat('ServiceSum', ReadInt('OrderServiceId', I)));
      end;

      if ReadFloat('ServicesPercent') <> 0 then
      begin
        for I := 0 to ReadInt('ServiceCount') - 1 do
          if ReadFloat('ServicePercent', ReadInt('OrderServiceId', I)) <> 0 then
          begin
            ServicePercent := ReadFloat('ServicePercent', ReadInt('OrderServiceId', I));
            SumServicePercent := ServicePercent * ReadFloat('Temp', 'Check_SumBeforeServices') / 100;
            AddTextNotNullValue(
              ReadStr('ServiceName', ReadInt('OrderServiceId', I)) + ' ' + FloatToStr(ServicePercent, 0) + '%',
              SumServicePercent);
          end;
      end;
    end;

    AddLineTextValue('',
      '==' + FloatToStr(ReadFloat('Temp', 'SumBeforeDiscount'), 2));

    if ReadFloat('Temp', 'Check_DiscountSum') <> 0 then
    begin
      AddLine('--------------------------------');
      if ReadFloat('Temp', 'Check_DiscountSum') > 0 then
        AddTextCostValue('Скидка', ReadFloat('Temp', 'Check_DiscountSum'))
      else
        AddTextCostValue('Наценка', -ReadFloat('Temp', 'Check_DiscountSum'));

      AddTextCostValue('', ReadFloat('Temp', 'Check_SumAfterDiscount'));
    end;
  end;

  AddLine( '================================');

  if CALC_SUM_BY_TAXIMETER and NEED_DETAILS_IN_CHECK then
    AddTextNotNullValue('Минимум', ReadFloat('Temp', 'MinSum'));

  if not NEED_DETAILS_IN_CHECK then
    AddLine('ПОЕЗДКА');
  AddLineTextValue('ИТОГО К ОПЛАТЕ',
    '==' + FloatToStr(ReadFloat('Temp', 'Check_TotalSum'), 2));
  AddLineTextValue('Наличными',
    '==' + FloatToStr(ReadFloat('CashSum'), 2));
  AddLineBreak;
  AddLine(GetDateTimeStr(ReadInt('Now')) + '  ИНН ' + TAXI_INN);
  AddLineBreak;
  AddLineBreak;

  // Чек с фискальными данными.
  if not ReadBool('PrintCheck', 'IsFiscal') and ReadBool('FiscalInfo', 'Success') then
  begin
    WriteStr('PrintCheck', 'Align', '0');
    AddLine('КАССОВЫЙ ЧЕК');

    WriteStr('PrintCheck', 'Align', '-1');
    AddLine('ПРИХОД');
    
    FiscalSum := ReadFloat('BankCardSum') + ReadFloat('CashSum');
    AddLineTextValue(ReadStr('FiscalInfo', 'CommodityName'),
      FloatToStr(FiscalSum, 2) + ' x 1 = ' + FloatToStr(FiscalSum, 2));
    AddTextNotNullValue('  ' + ReadStr('FiscalInfo', 'TaxRate'), ReadFloat('FiscalInfo', 'TaxSum'));
    
    DiscountSum := ReadFloat('TotalSum') - FiscalSum;
    if DiscountSum > 0 then
      AddTextCostValue('СКИДКА', DiscountSum);

    AddLine('УСЛУГА');
    if ReadStr('FiscalInfo', 'TaxRate') = 'без НДС' then
      NdsSum := FiscalSum
    else
      NdsSum := ReadFloat('FiscalInfo', 'TaxSum');
    WriteStr('PrintCheck', 'FontSize', '1');  
    AddTextCostValue('ИТОГ', FiscalSum);
    WriteStr('PrintCheck', 'FontSize', '0');
    
    AddTextNotNullValue('  Сумма ' + ReadStr('FiscalInfo', 'TaxRate'), NdsSum);
    AddTextNotNullValue('НАЛИЧНЫМИ', ReadFloat('CashSum'));
    AddTextNotNullValue('БАНК. КАРТОЙ', ReadFloat('BankCardSum'));

    AddTextCostValue('ПОЛУЧЕНО', FiscalSum);
    AddLineTextValue('СНО:', ReadStr('FiscalInfo', 'Taxation'));
    if ReadStr('FiscalInfo', 'ClientPhone') <> '' then
      AddLineTextValue('Тел.покупателя', ReadStr('FiscalInfo', 'ClientPhone'));
    if (ReadStr('FiscalInfo', 'ClientPhone') = '') and (ReadStr('FiscalInfo', 'ClientEmail') <> '') then
      AddLineTextValue('Эл.адр.покупателя', ReadStr('FiscalInfo', 'ClientEmail'));
    AddLineTextValue('Пользователь:', ReadStr('FiscalInfo', 'OrganizationName'));
    AddLineTextValue('Адрес:', ReadStr('FiscalInfo', 'OrganizationAddress'));
    AddLineTextValue('Место расчетов:', ReadStr('FiscalInfo', 'OrganizationAddress'));
    AddLineTextValue('Кассир:', ReadStr('FiscalInfo', 'OperatorName'));
    AddLineTextValue('Сайт ФНС:', ReadStr('FiscalInfo', 'FnsUrl'));
    AddLineTextValue('ЗН ККТ:', ReadStr('FiscalInfo', 'SerialNumber'));
    AddLineTextValue('Смена №', IntToStr(ReadInt('FiscalInfo', 'ShiftNumber')));
    AddLineTextValue('Чек №', IntToStr(ReadInt('FiscalInfo', 'CheckNumber')));
    AddLineTextValue('Дата Время', GetDateTimeStr(ReadInt('FiscalInfo', 'CompleteTime')));
    AddLineTextValue('ОФД:', ReadStr('FiscalInfo', 'OfdName'));
    AddLineTextValue('ИНН:', ReadStr('FiscalInfo', 'OfdVatin'));
    AddLineTextValue('РН ККТ:', ReadStr('FiscalInfo', 'RegistrationNumber'));
    AddLineTextValue('ФН №', ReadStr('FiscalInfo', 'FiscalNumber'));
    AddLineTextValue('ФД №', IntToStr(ReadInt('FiscalInfo', 'FiscalDocumentNumber')));
    AddLineTextValue('ФП:', ReadStr('FiscalInfo', 'FiscalDocumentSign'));

    WriteStr('PrintCheck','QR', GetQrCode);
    AddLineBreak;
    AddLineBreak;
  end;
end;
Параметры, которые позволяют учитывать время проезда по маршруту в тарифе (справочник "Тарифы"):
Обычный заказ - По городу - Стоимость минуты.
Обычный заказ - За городом - Стоимость минуты.
Расчет времени происходит через онлайн карты (в данном примере используется 2GIS).
Нужно выбрать карту как источник для расчета времени доезда экипажа («Файл - Настройки - Карта - Онлайн карты - Функционал - Расчет времени доезда экипажа до заказа в карточке заказа»).
Ветка Карта - онлайн карты - Функционал.png
Обратите внимание, для использования онлайн карт 2GIS, Яндекс и Google нужен API-ключ, который указывается в «Файл - Настройки - Карта - Онлайн карты - Настройки - API-ключ для использования онлайн карт».
Пример расчета стоимости поездки с учетом времени проезда по маршруту и километража в разное время.
Тариф, учитывающий время проезда по маршруту и километраж — различия между версиями

Версия 10:43, 4 мая 2022

Навигация

Просмотры

Персональные инструменты

Навигация

Поиск

Инструменты
