sharix-open-webservice-running/handlers/handlers/open_access_request_pending.py

import hashlib
from datetime import datetime
import config
import logging
from EchoBot import JabberBot
from slixmpp.stanza import Message
import jsonAndRequest as jsreq
from time import sleep
from lib import filter_interval_tickets

botname = "open_access_request_pending"
operating_status = 320

JID = botname + "@" + config.JSERVER
PORT = config.PORT
PASSWORD = hashlib.md5((botname + config.PASSWORD).encode('utf-8')).hexdigest()

bot = JabberBot(JID, PASSWORD)

# таким образом хранится список jid, от которых можно получать сообщения этому боту
listen_to = [
    "test@ej.sharix-app.org",
    "open_template_bot@ej.sharix-app.org"
]

# тут хранится список jid, кому бот может отправлять сообщения в результате обработки заявки
proceed_to = [
    botname,
    "open_st_request_declined@ej.sharix-app.org",
    "open_service_request_forcemajeure@ej.sharix-app.org"
]

INTERVAL_COUNT = 3
# INTERVAL_TIME = 30 * 60  # 30 минут в секундах
INTERVAL_TIME = 30 # Для проверки

global ticket_list

def message_handler(msg: Message):
    """Обработчик входящих сообщений"""

    if msg['type'] in ('chat', 'normal'):
        text = msg['body']  # текст сообщения боту
        sender = msg['from']  # отправитель сообщения

        if (str(sender).split("/")[0]) in listen_to:
            if text is not None:
                logging.info(f"Сообщение получено")

def start_handler():
    """Событие запуска обработчика."""

    logging.info(">>>>>  %s  |---| %s  <<<<<", JID, PASSWORD)

    global tickets
    tickets = get_fake_data()

    while(True):
        if tickets == []:
            sleep(INTERVAL_TIME)
        else:
            for ticket in tickets:
                ticket['interval_count'] -= 1
                if ticket <= 0:
                    processing_interval_unlimited(ticket)
                else:
                    processing(ticket)
            tickets = filter_interval_tickets(tickets)
            sleep(INTERVAL_TIME)


# START CUSTOM FUNCTIONS

def processing_interval_unlimited(ticket):
    logging.debug(f"Лимит попыток обработки тикета {ticket.id} исчерпан")
    
    # db.changestatus
    # bot.send_message(JID, f"Сообщение отправлено {JID}: {datetime.now()}")
    # bot message:
    # {
    #   "action": "add_ticket"
    #   "ticket_id":      0
    #   "ticket_list_id": 0
    # }


def processing(ticket):
    logging.debug(f"Начало обработки тикета {ticket.id}")

    # Do something

    logging.debug(f"Конец обработки тикета {ticket.id}")


def get_fake_data():
    return [
        {
            "ticket_id": 0,
            "ticket_list_id": 0,
            "interval_count": INTERVAL_COUNT
        },
        {
            "ticket_id": 1,
            "ticket_list_id": 0,
            "interval_count": INTERVAL_COUNT
        },
        {
            "ticket_id": 2,
            "ticket_list_id": 0,
            "interval_count": INTERVAL_COUNT
        },
        {
            "ticket_id": 3,
            "ticket_list_id": 0,
            "interval_count": INTERVAL_COUNT
        },
        {
            "ticket_id": 4,
            "ticket_list_id": 0,
            "interval_count": INTERVAL_COUNT
        },
    ]

# def get_token():
#     return jsreq.requestGetToken(botname, PASSWORD, config.API_URL + "/auth/token/login/")

# def set_tasklist(token):
#     global tasklist

#     tasklist = []
#     tasklist = jsreq.requestGetList(token, config.API_URL + "/tickets/api/tickets/?list_id=10")


# END CUSTOM FUNCTIONS


#  ---------------------------------------
#  ---------------------------------------
#  ---------------------------------------
#  ---------------------------------------
#  ---------------------------------------


# # обработчик входящих сообщений
# def message_handler(conn, mess):
#     text = mess.getBody()  # текст сообщения боту
#     user = mess.getFrom()  # отправитель сообщения

#     print(str(user).split("/")[0])
#     if (str(user).split("/")[0]) in listen_to:
#         print(text)
#         print(mess)

#         if text is not None:
#             orderObj = jsreq.jsonToOrderTicket(text)
#             print(orderObj)
#             tasklist.append(orderObj)
#             bot.bot_log(str(datetime.now()) + " Поступивший заказ успешно добавлен в очередь обработки\n")


# def open_access_request_pending_wait(period, localtask):
#     bot.bot_log(botname + " " + str(datetime.now()) + " " + "Заказ ожидает\n")
#     time.sleep(period)

#     # ВАЖНО! Надо скорее всего через API редактировать заказ, иначе возможна потеря данных
#     localtask.title = localtask.title + "1"

#     # обязательно данный обработчик должен заканчиваться передачей заказа куда-то на обработку дальше - обратно или другому, иначе оно потеряется
#     bot.proceed_status(proceed_to[1], localtask)
#     bot.bot_log(botname + " " + str(datetime.now()) + " " + "Заказ перенаправлен\n")


# def open_access_request_pending_process(localtask):
#     bot.bot_log(botname + " " + str(datetime.now()) + " " + "Заказ в обработчике\n")

#     push_notifications(localtask)
#     open_access_request_pending_wait(100, localtask)


# # Пока не уверен
# def push_notifications(localtask):
#     # Отправка уведомлений
#     # ...
#     return True


# def open_access_request_pending():
#     while (len(tasklist)):
#         localtask = tasklist.pop(0)
#         bot.bot_log(botname + " " + datetime.now().strftime('%Y-%m-%d') + " " + "Заказ в очереди на обработке\n")
#         print("EACH TASKLIST", tasklist)

#         if (localtask.status != operating_status):
#             bot.proceed_status(proceed_to[-1], localtask)
#             bot.bot_log(botname + " " + str(datetime.now()) + " " + "Заказ не по адресу, перенаправляем на форсмажор\n")
#             continue

#         # if (localtask.title!="10"):
#         #     t1=threading.Thread(target=open_service_request_booked_wait, args=(5,localtask))
#         #     t1.start()

#         # if (localtask.title=="101"):
#         #     t1=threading.Thread(target=open_service_request_booked_process, args=(10,localtask))
#         #     t1.start()

#         t1 = threading.Thread(target=open_access_request_pending_process, args=(localtask))
#         t1.start()

#         # если никакие обработчики не подошли - отправляем обратно в очередь
#         bot.proceed_status(proceed_to[0], localtask)
#         print("Заказ возвращен в очередь\n")
#         print(tasklist)


# # пустой список заказов