Exemplo n.º 1
0
def text_parser(message):
    if message.chat.id in cfg.subscribed_chats:
        cid = message.chat.id
        uid = message.from_user.id
        # лол кек ахахаха детектор
        if utils.getSettings(cid, 'lol_kek') == 1:
            if tp.lol_kek_detector(message.text) is True:  # оптимизация
                if random.random() >= 0.8:
                    bot.send_sticker(cid, random.choice(cfg.sticker_var))
                    print('Sent!')

        # голосование за обед
        if utils.getSettings(cid, 'autodetect_vote') == 1:
            din_elec = tp.dinner_election(message.text, cid)
            # ТОЛЬКО ДЛЯ ТЕСТИРОВАНИЯ!!!
            # if din_elec is not False:

            if din_elec:
                # проверяем что пользователь может голосовать
                vote_today_err = utils.user_vote_check(cid, uid)
                if vote_today_err is None:
                    bot.send_chat_action(cid, 'typing')
                    utils.vote_func(din_elec, bot, message)
                else:
                    bot.reply_to(message, vote_today_err)
Exemplo n.º 2
0
def text_parser(message):
    week_day = datetime.datetime.today().weekday()
    # нужно брать дату из даты сообщения
    hour_msg = time.localtime(message.date).tm_hour
    # текущее время, может пригодиться
    # hour_now = time.localtime().tm_hour
    cid = message.chat.id
    # user_id = message.from_user.id

    if cid in cfg.subscribed_chats:
        # лол кек ахахаха детектор
        if utils.getSettings(
                cid,
                'lol_kek') == 1 and tp.lol_kek_detector(message.text) is True:
            if random.random() >= 0.8:
                bot.send_sticker(cid, random.choice(cfg.sticker_var))
                print('Sent!')

        # голосование за обед
        if utils.getSettings(cid, 'autodetect_vote') == 1:
            din_elec = tp.dinner_election(message.text, cid)
            # ТОЛЬКО ДЛЯ ТЕСТИРОВАНИЯ!!!
            # if din_elec is not False:

            # проверяем что сегодня не выходной и время меньше чем час обеда в этом чате
            if week_day not in (5, 6) and hour_msg < utils.getSettings(
                    cid, 'elec_end_hour') and din_elec:
                bot.send_chat_action(cid, 'typing')
                utils.vote_func(din_elec, bot, message)
Exemplo n.º 3
0
def settings_default_time(message):
    cid = message.chat.id
    try:
        msg = message.text.lower().strip().split()
        # отображаем текущее значение настройки
        if len(msg) == 1:
            bot.send_message(
                cid,
                cfg.curr_value_info + cfg.settings_tovar_dict[msg[0]] +
                ': <b>' +
                str(utils.getSettings(cid, 'default_dinner_time'))[:-3] +
                '</b>.',
                parse_mode='HTML')
        # проверяем корректность ввода
        elif len(msg) == 2 and tp.time_checker(msg[1]):
            chatSettings = utils.getSettings(cid)
            time = [int(m) for m in msg[1].split(':')]
            newTime = datetime.timedelta(hours=time[0], minutes=time[1])
            # проверяем, что время по умолчанию + время отклонения не превышает сутки
            if (newTime + chatSettings['max_deviation']).days > 0:
                bot.send_message(cid, cfg.err_time_limit, parse_mode='HTML')
            # проверяем, что время по умолчанию меньше, чем конец голосования
            elif chatSettings['elec_end_hour'] >= newTime.seconds // 3600:
                bot.send_message(cid, cfg.big_end_error, parse_mode='HTML')
            elif chatSettings['default_dinner_time'] == newTime:
                bot.send_message(cid,
                                 'Новое время совпадает с текущим.',
                                 parse_mode='HTML')
            else:
                # пересчитываем настройку в оперативке
                cfg.settings[cid]['default_dinner_time'] = newTime
                bot.send_message(
                    cid,
                    'Время обеда по умолчанию изменено, новое значение: <b>' +
                    msg[1] + '</b>.',
                    parse_mode='HTML')
                # обновление времени обеда в результате сдвига дефолтного времени
                utils.upd_din_time(cid)
                # уведомление пользователей если время обеда сдвинулось
                bot.send_message(
                    cid,
                    'С учётом сдвига времени обеда по умолчанию, сегодня обедаем в: <b>'
                    + cfg.show_din_time[cid] + '</b>.',
                    parse_mode='HTML')
                # записываем изменения в БД
                db.sql_exec(db.update_time_setting_text,
                            [time[0], time[1], cid])
        else:
            bot.send_message(cid,
                             cfg.err_wrong_cmd.format(msg[0] + ' HH:MM'),
                             parse_mode='HTML')
    except Exception as e:
        print('***ERROR: Проблема с командой settings_default_time***')
        print('Exception text: ' + str(e))
Exemplo n.º 4
0
def settings_max_deviation(message):
    cid = message.chat.id
    try:
        msg = message.text.lower().strip().split()
        # отображаем текущее значение настройки
        if len(msg) == 1:
            bot.send_message(
                cid,
                cfg.curr_value_info + cfg.settings_tovar_dict[msg[0]] +
                ': <b>' +
                str(utils.getSettings(cid, 'max_deviation').seconds // 60) +
                '</b> минут.',
                parse_mode='HTML')
        # проверяем корректность ввода
        elif len(msg) == 2 and tp.minute_checker(msg[1]):
            chatSettings = utils.getSettings(cid)
            deviation = datetime.timedelta(minutes=int(msg[1]))
            # проверяем, что время по умолчанию + время отклонения не превышает сутки
            if (deviation + chatSettings['default_dinner_time']).days > 0:
                bot.send_message(cid, cfg.err_time_limit, parse_mode='HTML')
            elif chatSettings['max_deviation'] == deviation:
                bot.send_message(
                    cid,
                    'Ошибка: новое отклонение совпадает с текущим.',
                    parse_mode='HTML')
            else:
                # обновляем настройку в оперативке
                cfg.settings[cid]['max_deviation'] = deviation
                bot.send_message(
                    cid,
                    'Максимальное время отклонения от обеда изменено, новое значение: <b>'
                    + msg[1] + '</b> минут.',
                    parse_mode='HTML')
                # обновляем настройку в БД
                db.sql_exec(db.update_deviation_setting_text,
                            [int(msg[1]), cid])
                # пересчёт votemax
                utils.vote_max_calc(cid)
        else:
            bot.send_message(cid,
                             cfg.err_wrong_cmd.format(msg[0] + ' MM'),
                             parse_mode='HTML')
    except Exception as e:
        print('***ERROR: Проблема с командой settings_max_deviation***')
        print('Exception text: ' + str(e))
Exemplo n.º 5
0
def settings_election_end_hour(message):
    cid = message.chat.id
    try:
        msg = message.text.lower().strip().split()
        # отображаем текущее значение настройки
        if len(msg) == 1:
            bot.send_message(cid,
                             cfg.curr_value_info +
                             cfg.settings_tovar_dict[msg[0]] + ': <b>' +
                             str(utils.getSettings(cid, 'elec_end_hour')) +
                             '</b>.',
                             parse_mode='HTML')
        # проверяем корректность ввода
        elif len(msg) == 2 and tp.hour_checker(msg[1]):
            chatSettings = utils.getSettings(cid)
            new_elec_end_hour = int(msg[1])
            # проверяем, что время по умолчанию меньше, чем конец голосования
            if new_elec_end_hour >= chatSettings[
                    'default_dinner_time'].seconds // 3600:
                bot.send_message(cid, cfg.big_end_error, parse_mode='HTML')
            elif chatSettings['elec_end_hour'] == new_elec_end_hour:
                bot.send_message(
                    cid,
                    'Ошибка: новое время окончания голосования совпадает с текущим.',
                    parse_mode='HTML')
            else:
                # обновляем настройку в оперативке
                cfg.settings[cid]['elec_end_hour'] = new_elec_end_hour
                bot.send_message(
                    cid,
                    'Время окончания голосования изменено, новое значение: <b>'
                    + msg[1] + '</b>.',
                    parse_mode='HTML')
                # обновляем настройку в БД
                db.sql_exec(db.update_elec_end_hour_setting_text,
                            [int(msg[1]), cid])
        else:
            bot.send_message(cid,
                             cfg.err_wrong_cmd.format(msg[0] + ' HH'),
                             parse_mode='HTML')
    except Exception as e:
        print('***ERROR: Проблема с командой settings_election_end_hour***')
        print('Exception text: ' + str(e))
Exemplo n.º 6
0
def settings_flg(message):
    cid = message.chat.id
    try:
        msg = message.text.lower().strip().split()
        # отображаем текущее значение настройки
        if len(msg) == 1:
            bot.send_message(cid,
                             cfg.curr_value_info +
                             cfg.settings_tovar_dict[msg[0]] + ': ' +
                             cfg.flg_check[utils.getSettings(
                                 cid, cfg.settings_tovar_dict[msg[0]])],
                             parse_mode='HTML')
        # проверяем корректность ввода
        elif len(msg) == 2 and msg[1] in cfg.flg_dict:
            if utils.getSettings(
                    cid,
                    cfg.settings_tovar_dict[msg[0]]) == cfg.flg_dict[msg[1]]:
                bot.send_message(cid,
                                 'Ошибка: новое значение совпадает с текущим.',
                                 parse_mode='HTML')
            else:
                # обновляем в оперативке
                cfg.settings[cid][cfg.settings_tovar_dict[
                    msg[0]]] = cfg.flg_dict[msg[1]]
                bot.send_message(cid,
                                 'Настройка ' + msg[0][10:] +
                                 cfg.flg_rus[msg[1]],
                                 parse_mode='HTML')
                # обновляем в БД
                db.sql_exec(
                    db.update_flg_setting_text.format(
                        cfg.settings_todb_dict[msg[0]], cfg.flg_dict[msg[1]],
                        cid), [])
        else:
            bot.send_message(cid,
                             cfg.err_wrong_cmd.format(msg[0] + ' on/off'),
                             parse_mode='HTML')
    except Exception as e:
        print('***ERROR: Проблема с командой settings_flg***')
        print('Exception text: ' + str(e))
Exemplo n.º 7
0
def getPage(entity, parent='', file_type='json', verbose=utils.verbose):

    if entity not in os.listdir(os.path.join(HOME_DIR, parent)):
        os.mkdir(os.path.join(
            HOME_DIR, parent,
            entity))  #Create and entity folder if one does not exists

    #Check for the expected file type
    if file_type == 'json':

        if 'json' not in os.listdir(os.path.join(HOME_DIR, parent, entity)):
            os.mkdir(
                os.path.join(HOME_DIR, parent, entity, 'json')
            )  #Make a json folder in the entity if one does not exists
        entity_settings = utils.getSettings(entity)
        query_info = entity_settings.get('query_info')

        #Check the query type
        if query_info.get('type') == 'range':
            start, stop, increment = query_info.get('range_info')
            conn = httplib.HTTPConnection(BASE_URL)

            #Query and Increment step
            for i in range(start, stop, increment):
                #try:
                args = {p: i for p in query_info.get('params')}
                time.sleep(utils.request_interval)
                url = '/%s%s?%s=%s' % (query_info.get('url_subpath'),
                                       query_info.get('extension'),
                                       query_info.get('params')[0], str(i))
                print url
                conn.request('GET', url)
                p = conn.getresponse().read()

                #Write the recieved json to a file
                with open(
                        os.path.join(HOME_DIR, parent, entity, 'json',
                                     '%s.json' % str(i)), 'w') as f:
                    f.write(p)
                    f.close()
                #except Exception, e:
                #	logging.warning(" There was an error: %s" % str(e))

        #Zip the files and remove the duplicates
        zipAndRemove(parent, entity)
Exemplo n.º 8
0
def vote_cmd(message):
    try:
        cid = message.chat.id
        msg = message.text.strip().split()
        # проверка корректности ввода
        if len(msg) == 2 and tp.dinner_election(msg[1], cid,
                                                manual=True) is not False:
            week_day = datetime.datetime.today().weekday()
            hour_msg = time.localtime(message.date).tm_hour
            din_elec = int(msg[1])
            # проверяем что сегодня не выходной и время меньше чем час обеда в этом чате
            if week_day not in (5, 6) and hour_msg < utils.getSettings(
                    cid, 'elec_end_hour'):
                bot.send_chat_action(cid, 'typing')
                utils.vote_func(din_elec, bot, message)
            else:
                bot.reply_to(message, cfg.too_late_err)
        else:
            bot.send_message(cid,
                             cfg.err_wrong_cmd.format('vote [+/-]NN'),
                             parse_mode='HTML')
    except Exception as e:
        print('***ERROR: Проблема с командой vote_cmd***')
        print('Exception text: ' + str(e))
Exemplo n.º 9
0
import os
import sqlite3
from pyproj import Proj, transform
import requests
import shapefile
from utils import download, extract, DatasetPath, getSettings

if __name__ == "__main__":
    conf = getSettings()
    openapiSettings = conf['nodelink']
    fileName = openapiSettings['filename']

    datasetPath = DatasetPath()
    downloadPath = os.path.join(datasetPath, f"{fileName}.zip")
    extractPath = os.path.join(datasetPath, f"{fileName}")
    resultPath = os.path.join(datasetPath, f"{fileName}.sqlite3")

    # Download Korea standard node link data
    nodeDataURL = openapiSettings['URL']
    download(nodeDataURL, downloadPath)
    extract(downloadPath, extractPath)

    # Read data
    shp_path_link = os.path.join(extractPath, "MOCT_LINK.shp")
    sf_link = shapefile.Reader(shp_path_link, encoding="cp949")

    ids = []
    names = []
    sources = []
    targets = []
Exemplo n.º 10
0
    from optparse import OptionParser
    parser = OptionParser(
        "Turn all the plain wiki files into corresponding LaTeX files")
    parser.add_option("-s",
                      "--settings",
                      dest="settingsfile",
                      help="the settings file")
    parser.add_option("-v",
                      "--verbose",
                      dest="verbose",
                      help="print lot's of debugging information",
                      action="store_true",
                      default=False)
    (options, args) = parser.parse_args()

    config = utils.getSettings(options.settingsfile)

    parser = wikiParser.wikiParserFactory(config)

    ##  do the normal wiki files:
    files = glob.glob(os.path.join(config.get("PathNames", "wikipath"), "*"))
    for f in files:
        if os.path.isdir(f):
            continue

        if config.get("Wiki", "projectName") in f:
            continue

        handleFile(f, config.get("PathNames", "genlatexpath"), parser, config,
                   options.verbose)
Exemplo n.º 11
0
                        if not os.path.lexists (targetfile):
                            #  create a symbolic link to of
                            ## print "Creating symlink from " + \
                            ##       os.path.abspath(targetfile) + " to " + \
                            ##       os.path.join(relpath, f)
                            os.symlink (os.path.join(relpath, f),
                                        os.path.abspath(targetfile))
                        else:
                            print "Warning: " + targetfile + " seems to be a broken symblink" 
                
                

if __name__ == '__main__':
    import sys

    from optparse import OptionParser
    parser = OptionParser("Check existence of all required symbolic links, create if necessary.")
    parser.add_option ("-s", "--settings", dest="settingsfile",
                       help="the settings file")
    parser.add_option ("-v", "--verbose", dest="verbose",
                       help="print lot's of debugging information",
                       action="store_true", default=False)
    (options, args) = parser.parse_args()

    config = utils.getSettings(options.settingsfile)

    # ensureWarningFile (config) 

    createLinks (config)
    
Exemplo n.º 12
0
def penalty(message):
    time_now = datetime.datetime.now()
    cid = message.chat.id
    bot.send_chat_action(cid, 'typing')
    pen = db.sql_exec(db.sel_all_penalty_time_text, [cid])
    # pen = db.sql_exec(db.sel_all_penalty_time_text, [-282255340])
    # print(pen)
    # print(db.sql_exec(db.sel_all_text, [-282255340]))
    cmd = message.text.split()
    flg = 0

    if (len(cmd) == 3) and (cmd[1].lower() == 'cancel') and (cmd[2].isdigit()):
        # отмена штрафа
        rk = int(cmd[2])
        meta = db.sql_exec(db.sel_meta_by_rk, [rk])

        if len(meta) == 0:
            bot.send_message(cid, 'Штрафа с таким номером не существует!')
        else:
            meta = meta[0]
            dttm = datetime.datetime.strptime(meta[5], '%Y-%m-%d %H:%M:%S')
            val = int(meta[4])
            sign = val / abs(val)

            # 1(active) = 1(positive penalty)
            if (dttm.date() == time_now.date()) and (meta[7] == sign):
                if meta[3] == message.from_user.id:
                    bot.send_message(cid, cfg.self_penalty.format('отменять'))
                else:
                    db.sql_exec(db.upd_operation_meta_text, [3, rk])
                    bot.send_message(cid, cfg.cancel_penalty.format(rk))
            else:
                bot.send_message(cid, 'Данный штраф уже невозможно отменить!')
    elif (len(cmd) == 3) and (not cmd[1].isdigit()) and (cmd[2].isdigit()):
        # постановка штрафа
        for user in pen:
            if user[0] == cmd[1][1:]:
                flg = 1

                if user[2] == message.from_user.id:
                    bot.send_message(cid, cfg.self_penalty.format('ставить'))
                    break

                penalty_time = abs(int(cmd[2]))
                if penalty_time != 0:
                    # if penalty_time > 25:
                    if penalty_time > utils.getSettings(
                            cid, 'max_deviation').seconds // 60:
                        bot.send_message(
                            cid,
                            'Я не ставлю штрафы больше чем на максимальное отклонение!'
                        )
                    else:
                        # добавляем строку штрафа в метаданные
                        delta = datetime.timedelta(hours=24)
                        # delta = datetime.timedelta(seconds=10)
                        expire_date = time_now + delta

                        db.sql_exec(db.ins_operation_meta_text, [
                            cfg.max_id_rk, 0, cid, user[2], penalty_time,
                            str(time_now)[:-7],
                            str(expire_date)[:-7], 1
                        ])
                        cfg.max_id_rk += 1

                        bot.send_message(
                            cid,
                            cfg.set_penalty.format(str(cmd[1]),
                                                   str(penalty_time),
                                                   cfg.max_id_rk - 1))
                        # evt.check_metadata(bot)
                        # evt.check_metadata(bot)

                        # print(db.sql_exec("""SELECT * FROM ELECTION""", []))
                else:
                    bot.send_message(cid, 'Я не ставлю штрафы 0 минут!')
                break

        if flg == 0:
            bot.send_message(cid, cfg.no_member.format(str(cmd[1])))
    else:
        # вывод списка штрафов
        pen_msg = 'Штрафы на сегодня:\n'
        pen_msg_flg = 0
        for user in pen:
            if int(user[1]) != 0:
                pen_msg += str(user[0]) + ' — <b>' + str(
                    user[1]) + '</b> мин\n'
                pen_msg_flg = 1

        if pen_msg_flg == 1:
            bot.send_message(cid, pen_msg, parse_mode='HTML')
        else:
            bot.send_message(cid, random.choice(cfg.penalty_empty_text))
Exemplo n.º 13
0
def check_metadata(bot):
    time_now = datetime.datetime.now()
    # выбираем все активные строки из метаданных
    meta = db.sql_exec(
        """SELECT * FROM METADATA
            WHERE operation in (0, 1) and is_success_flg = ?""", [1])

    # meta = db.sql_exec(db.sel_operation_meta_text, [0, 1])
    # meta.extend(db.sql_exec(db.sel_operation_meta_text, [1, 1]))
    # meta = db.sql_exec(db.sel_operation_meta_text, [(0, 1), 1])

    for m in meta:
        # print(m)

        # '%Y-%m-%d %H:%M:%S'
        dttm = datetime.datetime.strptime(m[6], '%Y-%m-%d %H:%M:%S')

        if (dttm.date()
                == time_now.date()) and (dttm.time() >= time_now.time()):
            # штрафы
            if m[1] == 0:
                print(m)
                user = db.sql_exec(db.sel_election_text, [m[2], m[3]])
                if len(user) == 0:
                    # обновляем строку в метаданных как ошибочную
                    db.sql_exec(db.upd_operation_meta_text, [2, m[0]])
                    print('!!! ОШИБКА, НЕТ ЮЗЕРА В БАЗЕ ДЛЯ ' + str(m[2]) +
                          ' ' + str(m[3]) + ' !!!')
                else:
                    if m[4] >= 0:
                        # вычисляем дату исполнения
                        hh = 48
                        if dttm.weekday() in (4, 5):
                            hh = 96
                        if dttm.weekday() == 6:
                            hh = 72

                        delta = datetime.timedelta(hours=hh, minutes=5)
                        # delta = datetime.timedelta(seconds=10)
                        expire_date = time_now + delta

                        db.sql_exec(db.ins_operation_meta_text, [
                            cfg.max_id_rk, 0, m[2], m[3], -int(m[4]),
                            str(time_now)[:-7],
                            str(expire_date)[:-7], 1
                        ])
                        cfg.max_id_rk += 1

                    penalty = int(user[0][3]) + int(m[4])

                    if penalty < 0:
                        penalty = 0
                    elif penalty > utils.getSettings(
                            m[2], 'max_deviation').seconds // 60:
                        penalty = utils.getSettings(
                            m[2], 'max_deviation').seconds // 60

                    # ставим/убираем штраф
                    db.sql_exec(db.upd_election_penalty_text,
                                [penalty, m[2], m[3]])
                    # обновляем строку в метаданных как успешно отработавшую
                    db.sql_exec(db.upd_operation_meta_text, [0, m[0]])

                print(db.sql_exec("""SELECT * FROM METADATA""", []))
                print(db.sql_exec("""SELECT * FROM ELECTION""", []))
            # воронков
            elif m[1] == 1 and utils.getSettings(m[2], 'voronkov') == 1:
                dttmt = dttm.time()
                expire_time = datetime.timedelta(hours=dttmt.hour,
                                                 minutes=dttmt.minute,
                                                 seconds=dttmt.second)
                dttmt_now = time_now.time()
                time_now_delta = datetime.timedelta(hours=dttmt_now.hour,
                                                    minutes=dttmt_now.minute,
                                                    seconds=dttmt_now.second)
                delta = expire_time - time_now_delta

                delta = int(delta.total_seconds()) + 1

                th.Timer(delta, voronkov_timer, args=(
                    bot,
                    m,
                )).start()
        elif dttm < time_now:
            # обновляем строку в метаданных как ошибочную (не выполнилась в нужную дату или время)
            db.sql_exec(db.upd_operation_meta_text, [2, m[0]])
            print('!!! ОШИБОЧНАЯ СТРОКА В ТАБЛИЦЕ МЕТАДАННЫХ !!!')
            print(m)

            # команду штрафа надо применить в любом случае
            if m[1] == 0:
                cfg.meta_error_flg = 1

                delta = datetime.timedelta(minutes=10)
                expire_date = time_now + delta

                db.sql_exec(db.ins_operation_meta_text, [
                    cfg.max_id_rk, 0, m[2], m[3], m[4],
                    str(time_now)[:-7],
                    str(expire_date)[:-7], 1
                ])
                cfg.max_id_rk += 1
Exemplo n.º 14
0
def one_hour_timer(bot):
    time_now = datetime.datetime.now()

    # флаг, который говорит, показывать ли сообщения (показывает, когда 1)
    to_show = 0

    # начальное время таймера (60 * 60)
    timer_time = 3600

    # начальная дельта (0)
    delta = datetime.timedelta(seconds=0)

    if str(time_now.time().minute) in ('0'):
        to_show = 1
        if str(time_now.time().second) <= '30':
            # нормальная работа
            timer = th.Timer(timer_time, one_hour_timer, args=(bot, ))
        else:
            # случай для возможного увеличения времени из-за расчётов программы
            timer_time -= 29
            timer = th.Timer(timer_time, one_hour_timer, args=(bot, ))
    else:
        # рандомное время, например, при запуске бота
        # высчитываем время до ближайшего часа **:00:01
        common_time = datetime.timedelta(minutes=60, seconds=0)
        cur_time = datetime.timedelta(minutes=time_now.time().minute,
                                      seconds=time_now.time().second)

        delta = common_time - cur_time

        timer_time = int(delta.total_seconds()) + 1

        timer = th.Timer(timer_time, one_hour_timer, args=(bot, ))

    print('Секунды до таймера =', timer_time)
    print('Время до таймера =', delta)

    timer.start()

    if to_show == 1:
        # будние + непраздничные дни
        if time_now.weekday() not in (5,
                                      6) and time_now not in cfg.ru_holidays:
            for chats in cfg.subscribed_chats:
                chatSettings = utils.getSettings(chats)
                # доброе утро + показать maxvote + вызвать pidora
                if str(time_now.time().hour) == '9':
                    send_msg(bot, rnd.choice(cfg.gm_text), chats)
                    send_msg(bot, utils.maxvote_cmd(chats), chats)
                    if chatSettings['pidor'] == 1:
                        send_msg(bot, '/pidor@SublimeBot', chats)

                # напоминание о голосовании за обед
                if time_now.time().hour == chatSettings['elec_end_hour'] - 1:
                    chatUsers = call_all(db.sel_nonvoted_users_text, chats)
                    for cid, msg in chatUsers.items():
                        send_msg(bot, msg + rnd.choice(cfg.vote_notif_text),
                                 cid)

                # обед
                if time_now.time().hour == chatSettings['elec_end_hour']:
                    chatUsers = call_all(chat_id=chats)
                    cur_time = datetime.timedelta(
                        hours=time_now.time().hour,
                        minutes=time_now.time().minute,
                        seconds=time_now.time().second)
                    for cid, msg in chatUsers.items():
                        send_msg(
                            bot,
                            '{}{}<b>{}</b>'.format(msg,
                                                   rnd.choice(cfg.dinner_text),
                                                   cfg.show_din_time[cid]),
                            cid)
                        # сохраняем историю голосования
                        db.sql_exec(db.colect_election_hist_text,
                                    [str(time_now.date())])
                        # обнуляем время голосования
                        db.sql_exec(db.reset_election_time_text, [0])

                        # ставим таймер за 10 минут до обеда, о напоминании об обеде
                        delta = utils.calc_show_din_time(
                            cid) - cur_time - datetime.timedelta(minutes=10,
                                                                 seconds=0)
                        th.Timer(int(delta.total_seconds()) + 1,
                                 dinner_timer,
                                 args=(
                                     bot,
                                     cid,
                                 )).start()

                # # намёк поесть
                # if str(time_now.time().hour) == '17':
                #     send_msg(bot, rnd.choice(cfg.eat_text))

                # пора уходить с работы
                if str(time_now.time().hour) == '19':
                    send_msg(bot, rnd.choice(cfg.bb_text), chats)

                # в определённое время намекать на попить
                if str(time_now.time().hour) in ('11', '15', '17', '18'):
                    send_msg(bot, rnd.choice(cfg.pitb_text), chats)
        # выходные
        elif time_now.weekday() == 6:
            # напоминать про дсс
            if str(time_now.time().hour) == '19':
                chatUsers = call_all()
                for cid, msg in chatUsers.items():
                    send_msg(bot, msg + rnd.choice(cfg.dss_text), cid)

            # поставить таймер на воронкова
            if str(time_now.time().hour) == '23':
                for cid in cfg.subscribed_chats:
                    # оставляем небольшой запас времени на вычисления
                    # 1 минута и 10 секунд
                    hh = rnd.randint(1, 119)
                    mm = rnd.randint(1, 58)
                    ss = rnd.randint(0, 50)

                    # вычисляем дату исполнения
                    delta = datetime.timedelta(hours=hh,
                                               minutes=mm,
                                               seconds=ss)
                    expire_date = time_now + delta

                    if utils.getSettings(cid, 'voronkov') == 1:
                        users = db.sql_exec(db.sel_all_text, [cid])
                        if users != []:
                            call_user = rnd.choice(users)[1]

                            # добавляем строку воронкова в метаданные для каждого чата
                            db.sql_exec(db.ins_operation_meta_text, [
                                cfg.max_id_rk, 1, cid, call_user, -1,
                                str(time_now)[:-7],
                                str(expire_date)[:-7], 1
                            ])
                            cfg.max_id_rk += 1
                        else:
                            print(
                                '! ОШИБКА, НЕТ ЮЗЕРОВ В БАЗЕ ДЛЯ CHAT_ID = ' +
                                str(cid) + ' !')

    # выводим дату для лога и выполняем системные сбросы и таймеры
    if str(time_now.time().hour) == '0':
        print('New day!', time_now)

        # проверяем метаданные и выставляем таймеры
        check_metadata(bot)

        # если произошла ошибка с выставлением штрафа,
        # нужно проверить метаданные ещё раз
        if cfg.meta_error_flg == 1:
            cfg.meta_error_flg = 0
            check_metadata(bot)

        # обнуляем время голосования в боте
        utils.upd_din_time()
        # пересчитываем ограничения на голосование
        utils.vote_params_reset()