def storeData(self, accounts):
start_time = clock()
try:
now_d = datetime.now()
for acc in accounts:
# цикл по ЛС
for meter in accounts[acc]:
# цикл по счетчикам
data_s = "stored data: meter_id={}, count={}, updated={}".format(
meter["meter_id"], meter[DB_MTR_COUNT_NEW], now_d)
log.debug(data_s)
need_commit = True
if need_commit:
pass
except Exception as e:
self._db_error = True
log.exception("can't update data into database")
finally:
pass
log.debug("completed in {:g} sec.".format(clock() - start_time))
def _farewell(self, say_before = None):
self._set_state(State.READY_FOR_HANGOFF)
sp = []
if not say_before == None:
sp.append(say_before)
sp.append(self._farewell_message)
log.debug("begin speaking farewell message")
self._begin_speaking(sp)
def on_end_call(self):
if self._get_state() in (State.ANSWERED, State.ANSWER, State.RINGING):
log.debug("call is ended on the other side")
else:
log.error("unexpected event on state '{}'! Dropped to IDLE.".format(self._get_state()._name_))
self._set_def_state()
# нужно известить оператора о том что вызов завершен
if self._operator:
self._operator.onCallEnded()
def speak(self, sequence):
gain = 0
for word in sequence:
if word[:4] == 'std_':
gain += 1
log.debug("begin playing {}".format(sequence))
try:
self._play_obj = SA.PlayObj(gain)
except Exception as e:
raise Exception("can't play sound") from e
def _init_seq_begin(self):
self._set_state(State.INIT)
pn = "dev_init_sequence"
if not pn in self._config:
# последовательность инициализации не задана
self._set_def_state()
return
log.debug("begin init sequense...")
cmd_seq = self._config[pn].split(',')
self._protocol.execCmdSeq(cmd_seq)
def on_cmd_sequense_done(self, result):
st = self._get_state()
if st == State.INIT:
if result:
# успешно
log.debug("INIT sequense: OK")
self._set_def_state()
else:
# ошибка выполнения команды инициализации
log.error("INIT sequense: FAILED. Aborting")
# выход в майн луп по исключению
raise Exception("can't init device")
def on_caller_number_recieved(self, number):
log.debug("caller number recieved {}".format(number))
# тут уже отвечаем на вызов
if self._get_state() == State.RINGING:
self._caller_number = number
# создаем оператора
self._operator = aoperator.Operator(self._config, number)
# получем информацию о звонящем из бд
self._operator.prepareForAnswer()
# переходим на этам ответа на звонок
self._set_state(State.ANSWER)
self._protocol.cmdAnswerCall()
def storeData(self, accounts):
start_time = clock()
conn = self._db_connect()
need_commit = False
if not conn:
self._db_error = True
return
cursor = conn.cursor(dictionary=True)
# request_text = """UPDATE `meters`
# SET `updated` = %(date)s,
# `count` = %(count)s
# WHERE `meters`.`id` = %(meter_id)s"""
request_text = """INSERT INTO `meters_readings`
(`id`, `meter_id`, `count`, `updated`)
VALUES (NULL, '%(meter_id)s', '%(count)s', %(date)s)"""
try:
now_d = datetime.now()
for acc in accounts:
# цикл по ЛС
for meter in accounts[acc]:
# цикл по счетчикам
#if meter["__data_confirmed__"]:
cursor.execute(
request_text, {
'meter_id': meter["meter_id"],
'count': meter[DB_MTR_COUNT_NEW],
'date': now_d
})
log.debug("update row in 'meters' with id '{}'".format(
meter["meter_id"]))
need_commit = True
if need_commit:
conn.commit()
except SQLError as e:
self._db_error = True
log.exception("can't update data into database")
finally:
cursor.close()
conn.close()
log.debug("completed in {:g} sec.".format(clock() - start_time))
def fetchCallerInfo(self, caller_number):
start_time = clock()
accounts = {}
pers_gr = ""
try:
for item in self._data:
if not item["phone_number"] == caller_number:
continue
acc = item["account"]
if not acc in accounts:
accounts[acc] = []
mtr = item.copy()
# поле для новых показаний
mtr[DB_MTR_COUNT_NEW] = mtr[DB_MTR_COUNT]
accounts[acc].append(mtr)
pers_gr = mtr[DB_PERSONAL_GREATING]
except Exception as e:
self._db_error = True
log.exception("can't fetch data from database")
finally:
pass
# определение функции для извлечения ключа сортировки
def sf(item):
return item[DB_MTR_INDEX]
# сортировка по номеру в УС
for acc in accounts:
accounts[acc].sort(key=sf)
log.debug("completed in {:g} sec.".format(clock() - start_time))
log.debug("collected accounts : {}".format(list(accounts.keys())))
return (accounts, pers_gr)
def stop(self):
log.debug('waiting for playing is complete')
self._thread = None
def wait_done(self):
log.debug('waiting for playing is complete')
self._thread.join()
def run(self):
t = 3 * self.gain
log.debug("sleeping on {} sec...".format(t))
sleep(t)
log.debug("awaiked...".format(t))
def on_cmd_result(self, cmd, result, test_result):
log.debug("recieved result of {} with {}".format(cmd, result))
st = self._get_state()
# если состояние тестирования
if st == State.TEST:
if result:
# тест прошел успешно
log.debug("TEST: OK")
# запуск проверки регистрации в сети
self._cell()
else:
# ошибка проверки связи
# raise ATConnectionLostError("no connection")
log.error("TEST: command return not OK")
# возврат в состояние ожидания
self._set_def_state()
# состояние проверки связи
elif st == State.CELL:
if result:
# команда выполнена успешно
if test_result:
# зарегистрированы в сети
log.debug("CELL: registered")
else:
log.debug("CELL: not registered")
else:
log.error("CELL: command return not OK")
# возврат в состояние ожидания
self._set_def_state()
# если состояние ответа на входящий вызов
elif st == State.ANSWER:
if result:
# вызов успешно принят
self._set_state(State.ANSWERED)
# начало обработки звонка оператором
self._operator.beginCallProcessing()
# проверяем готовность в on_tick
else:
# ждем нового гудка для повтора ответа
self._operator = None
self._set_def_state()
# если состояние завершение вызова
elif st == State.ENDINGCALL:
if result:
# завершили вызов
self._set_def_state()
self._operator = None
else:
# ошибка команды завершения вызова - повтор команды
self._end_call()
elif st == State.CHECK:
if result:
# успешно
log.debug("CHECK: OK")
# следующая стадия инициализации
self._init_seq_begin()
#self._init_seq_next()
else:
# ошибка проверки связи
log.error("CHECK: FAILED. Device not responding")
# возврат в состояние ожидания протокола
self._set_state(State.WAIT_PROTOCOL)
elif st == State.INIT:
if result:
# успешно
log.debug("{}: OK".format(cmd))
else:
# ошибка выполнения команды инициализации
log.error("{}: FAILED")
def handle_line(self, line):
log.debug("handle line '{}'".format(line))
self._lines.put(line)
def on_cmd_sent(self, cmd):
log.debug("command {} sent".format(cmd))
import dbwrapperstub as db
else:
import mysqlwrapper as db
import loggingwrapper as log
# if __NO_SOUND__:
# from soundspeakerstub import SoundSpeaker
# log.debug("NO SOUND. used stub.")
# else:
# from soundspeaker import SoundSpeaker
try:
from soundspeaker import SoundSpeaker
except ModuleNotFoundError as e:
from soundspeakerstub import SoundSpeaker
log.debug("NO SOUND. used stub.")
SYM_CONFIRM = '*'
SYM_CANCEL = '#'
TICKS_INPUT_TIMEOUT = int(30 / __MAIN_LOOP_DELAY__) # 60 сек. выполняется тольк в состоянии IDLE
class State(Enum):
IDLE = 0
GREETING = 1
ACC_SELECTION = 2
METER_SELECTION = 4
NUMBER_INPUT = 10
ACC_CONFIRMATION = 11
DATA_CONFIRMED = 18
def on_DTMF_recieved(self, symbol):
log.debug("DTMF sybol recieved {}".format(symbol))
# получен символ - пересылаем текущему оператору
if self._operator:
self._operator.processSymbol(symbol)
def play_buffer(data, nc, bps, fr):
log.debug('begin playing sound...')
return PlayObj()
def connection_lost(self, exc):
log.debug("connection lost. code={}".format(exc))
def stop_all():
log.debug('stop playing all sound')
def on_incoming_call(self):
log.debug("incoming call")
if self._get_state() == State.IDLE:
self._set_state(State.RINGING)
def fetchCallerInfo(self, caller_number):
start_time = clock()
conn = self._db_connect()
accounts = {}
pers_gr = ""
if not conn:
self._db_error = True
return (accounts, pers_gr)
cursor = conn.cursor(dictionary=True)
request_text = """SELECT
`clients`.`id` AS `client_id`,
`clients`.`account`,
`clients`.`phone_number`,
`clients`.`registration_date`,
`meters`.`id` AS `meter_id`,
`meters`.`index_num`,
`meters`.`updated`,
`meters`.`count`,
`pers_set`.`greeting_f`
FROM `clients`
INNER JOIN `meters` ON `meters`.`owner_id` = `clients`.`id` AND `clients`.`phone_number`=%(phone)s
LEFT JOIN `pers_set` ON `pers_set`.`phone_number`=%(phone)s"""
try:
cursor.execute(request_text, {'phone': caller_number})
for item in cursor.fetchall():
acc = item["account"]
if not acc in accounts:
accounts[acc] = []
mtr = item.copy()
# поле для новых показаний
mtr[DB_MTR_COUNT_NEW] = mtr[DB_MTR_COUNT]
accounts[acc].append(mtr)
pers_gr = item[DB_PERSONAL_GREATING]
except SQLError as e:
self._db_error = True
log.exception("can't fetch data from database")
finally:
cursor.close()
conn.close()
# определение функции для извлечения ключа сортировки
def sf(item):
return item[DB_MTR_INDEX]
# сортировка по номеру в УС
for acc in accounts:
accounts[acc].sort(key=sf)
log.debug("completed in {:g} sec.".format(clock() - start_time))
log.debug("collected accounts : {}".format(list(accounts.keys())))
return (accounts, pers_gr)
def connection_made(self, transport):
log.debug("connection made")
transport.serial.rts = False
self._transport = transport
self._lines = FilteredQueue()
super(SerialLineReader, self).connection_made(transport)